index : smol-guess.git

81ce85ffddfe9c82f328d95a09f37f43c625495f [patch]

f562783509b76c31fddddb8a95c17d55fa3fb90d

7ba0825bd5822b120ea572d0ce03c2b9ef17f0bf

81ce85ffddfe9c82f328d95a09f37f43c625495f.tar.gz

feat(lang): add language definitions from guesslang

Diff

 src/lib.rs  | 159 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 src/main.rs |  64 ++++++++++++++++++++++++-
 2 files changed, 222 insertions(+), 1 deletion(-)

diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..f436c88
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,159 @@
pub mod core {
    /// A collection of programming language definitions.
    ///
    /// `LanguageDefinitions` is used to manage a list of programming language definitions, which consist
    /// of pairs of a language name and its corresponding file extension.
    ///
    /// # Examples
    ///
    /// ```
    /// use smolguess::core::{LanguageDefinition, LanguageDefinitions};
    ///
    /// let languages = LanguageDefinitions {
    ///     items: vec![
    ///         LanguageDefinition { name: "Rust".to_string(), extension: "rs".to_string() },
    ///         LanguageDefinition::new("Markdown", "md"),
    ///     ],
    /// };
    ///
    /// assert_eq!(languages.items.len(), 2);
    /// assert_eq!((languages.items[0].name.as_str(), languages.items[0].extension.as_str()), ("Rust", "rs"));
    /// assert_eq!((languages.items[1].name.as_str(), languages.items[1].extension.as_str()), ("Markdown", "md"));
    /// ```
    #[derive(Debug, Default)]
    pub struct LanguageDefinitions {
        pub items: Vec<LanguageDefinition>,
    }

    impl LanguageDefinitions {
        /// Insert a language definition into the collection.
        ///
        /// This method takes a generic parameter `T` that can be converted into a `LanguageDefinition`.
        /// The language definition is then added to the collection, and the modified collection is
        /// returned.
        ///
        /// # Parameters
        ///
        /// - `self`: The current `LanguageDefinitions` instance.
        /// - `definition`: The language definition to insert into the collection.
        ///
        /// # Returns
        ///
        /// A new `LanguageDefinitions` instance with the added language definition.
        ///
        /// # Examples
        ///
        /// ```
        /// use smolguess::core::{LanguageDefinition, LanguageDefinitions};
        ///
        /// let languages = LanguageDefinitions::default()
        ///     .insert(("Rust", "rs"))
        ///     .insert(LanguageDefinition::new("Markdown", "md"));
        ///
        /// assert_eq!(languages.items.len(), 2);
        /// assert_eq!((languages.items[0].name.as_str(), languages.items[0].extension.as_str()), ("Rust", "rs"));
        /// assert_eq!((languages.items[1].name.as_str(), languages.items[1].extension.as_str()), ("Markdown", "md"));
        /// ```
        pub fn insert<T>(mut self, definition: T) -> Self
        where
            T: Into<LanguageDefinition>,
        {
            self.items.push(definition.into());

            self
        }
    }

    /// Represents a language definition, consisting of a name and its corresponding file extension.
    ///
    /// # Fields
    ///
    /// - `name`: The name of the programming language.
    /// - `extension`: The file extension associated with the programming language.
    ///
    /// # Examples
    ///
    /// Creating a new `LanguageDefinition` instance using the `new` method:
    ///
    /// ```
    /// use smolguess::core::LanguageDefinition;
    ///
    /// let definition = LanguageDefinition::new("Rust", "rs");
    ///
    /// assert_eq!((definition.name.as_str(), definition.extension.as_str()), ("Rust", "rs"));
    /// ```
    ///
    /// Creating a new `LanguageDefinition` instance using struct initialization:
    ///
    /// ```
    /// use smolguess::core::LanguageDefinition;
    ///
    /// let definition = LanguageDefinition { name: "Rust".to_string(), extension: "rs".to_string() };
    ///
    /// assert_eq!((definition.name.as_str(), definition.extension.as_str()), ("Rust", "rs"));
    /// ```
    #[derive(Debug)]
    pub struct LanguageDefinition {
        pub name: String,
        pub extension: String,
    }

    impl LanguageDefinition {
        /// Creates a new `LanguageDefinition` instance with the specified name and file extension.
        ///
        /// # Parameters
        ///
        /// - `name`: The name of the programming language.
        /// - `extension`: The file extension associated with the programming language.
        ///
        /// # Returns
        ///
        /// A new `LanguageDefinition` instance.
        ///
        /// # Examples
        ///
        /// ```
        /// use smolguess::core::LanguageDefinition;
        ///
        /// let definition = LanguageDefinition::new("Rust", "rs");
        ///
        /// assert_eq!((definition.name.as_str(), definition.extension.as_str()), ("Rust", "rs"));
        /// ```
        pub fn new(name: &str, extension: &str) -> Self {
            LanguageDefinition {
                name: name.to_string(),
                extension: extension.to_string(),
            }
        }
    }

    impl<T> From<(T, T)> for LanguageDefinition
    where
        T: AsRef<str>,
    {
        /// Converts a tuple of two values into a `LanguageDefinition` instance.
        ///
        /// The first value in the tuple is used as the name, and the second value is used as the extension.
        ///
        /// # Parameters
        ///
        /// - `value`: A tuple containing the name and extension values.
        ///
        /// # Returns
        ///
        /// A new `LanguageDefinition` instance.
        ///
        /// # Examples
        ///
        /// ```
        /// use smolguess::core::LanguageDefinition;
        ///
        /// let definition = LanguageDefinition::from(("Rust", "rs"));
        ///
        /// assert_eq!((definition.name.as_str(), definition.extension.as_str()), ("Rust", "rs"));
        /// ```
        fn from(value: (T, T)) -> Self {
            LanguageDefinition::new(value.0.as_ref(), value.1.as_ref())
        }
    }
}
diff --git a/src/main.rs b/src/main.rs
index e7a11a9..569a7a0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,3 +1,65 @@
use smolguess::core::LanguageDefinitions;

fn main() {
    println!("Hello, world!");
    // TODO: move to a library
    let languages = LanguageDefinitions::default()
        .insert(("Assembly", "asm"))
        .insert(("Batchfile", "bat"))
        .insert(("C", "c"))
        .insert(("C#", "cs"))
        .insert(("C++", "cpp"))
        .insert(("Clojure", "clj"))
        .insert(("CMake", "cmake"))
        .insert(("COBOL", "cbl"))
        .insert(("CoffeeScript", "coffee"))
        .insert(("CSS", "css"))
        .insert(("CSV", "csv"))
        .insert(("Dart", "dart"))
        .insert(("DM", "dm"))
        .insert(("Dockerfile", "dockerfile"))
        .insert(("Elixir", "ex"))
        .insert(("Erlang", "erl"))
        .insert(("Fortran", "f90"))
        .insert(("Go", "go"))
        .insert(("Groovy", "groovy"))
        .insert(("Haskell", "hs"))
        .insert(("HTML", "html"))
        .insert(("INI", "ini"))
        .insert(("Java", "java"))
        .insert(("JavaScript", "js"))
        .insert(("JSON", "json"))
        .insert(("Julia", "jl"))
        .insert(("Kotlin", "kt"))
        .insert(("Lisp", "lisp"))
        .insert(("Lua", "lua"))
        .insert(("Makefile", "makefile"))
        .insert(("Markdown", "md"))
        .insert(("Matlab", "matlab"))
        .insert(("Objective-C", "mm"))
        .insert(("OCaml", "ml"))
        .insert(("Pascal", "pas"))
        .insert(("Perl", "pm"))
        .insert(("PHP", "php"))
        .insert(("PowerShell", "ps1"))
        .insert(("Prolog", "prolog"))
        .insert(("Python", "py"))
        .insert(("R", "r"))
        .insert(("Ruby", "rb"))
        .insert(("Rust", "rs"))
        .insert(("Scala", "scala"))
        .insert(("Shell", "sh"))
        .insert(("SQL", "sql"))
        .insert(("Swift", "swift"))
        .insert(("TeX", "tex"))
        .insert(("TOML", "toml"))
        .insert(("TypeScrpit", "ts"))
        .insert(("Verilog", "v"))
        .insert(("Visual Basic", "vba"))
        .insert(("XML", "xml"))
        .insert(("YAML", "yaml"));

    languages
        .items
        .iter()
        .for_each(|def| println!("{} has the extension {}", def.name, def.extension))
}