index : smol-guess.git

73fe7d9c76741bdaa627045f6e02e785066ef384 [patch]

17b9b9fdf303d5d6b1db18b8e5f3d6b427074f2f

bc3265c2477a4f29906f15befb9d5a1cb5313a20

73fe7d9c76741bdaa627045f6e02e785066ef384.tar.gz

refactor(lang): restructure core library files

Diff

 src/core/mod.rs | 240 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 src/lib.rs      | 243 +---------------------------------------------------------
 2 files changed, 241 insertions(+), 242 deletions(-)

diff --git a/src/core/mod.rs b/src/core/mod.rs
new file mode 100644
index 0000000..c233f47
--- /dev/null
+++ b/src/core/mod.rs
@@ -0,0 +1,240 @@
/// 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(("GDScript", "gd"))
            .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(("SCSS", "scss"))
            .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())
    }
}
diff --git a/src/lib.rs b/src/lib.rs
index 3eb9781..5a7ca06 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,242 +1 @@
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(("GDScript", "gd"))
                .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(("SCSS", "scss"))
                .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())
        }
    }
}
pub mod core;