index : smol-guess.git

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
        }

        /// Loads a set of built-in language definitions into the collection.
        ///
        /// The `load_builtins` function is used to add predefined language definitions to the
        /// `LanguageDefinitions` collection. This can be convenient for initializing the collection
        /// with common languages and extensions.
        ///
        /// # Parameters
        ///
        /// - `self`: The current `LanguageDefinitions` instance.
        ///
        /// # Returns
        ///
        /// A new `LanguageDefinitions` instance with the built-in language definitions added.
        ///
        /// # Examples
        ///
        /// ```
        /// use smolguess::core::{LanguageDefinition, LanguageDefinitions};
        ///
        /// // Load built-in language definitions
        /// let languages = LanguageDefinitions::default().load_builtins();
        ///
        /// assert_eq!(languages.items.iter().any(|lang| lang.name.eq("Rust")), true);
        /// ```
        pub fn load_builtins(self) -> Self {
            self.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"))
        }
    }

    /// 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())
        }
    }
}