From 73fe7d9c76741bdaa627045f6e02e785066ef384 Mon Sep 17 00:00:00 2001 From: holly sparkles Date: Sun, 7 Jan 2024 18:59:00 +0100 Subject: [PATCH] refactor(lang): restructure core library files --- src/core/mod.rs | 240 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/lib.rs | 243 +-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2 files changed, 241 insertions(+), 242 deletions(-) create mode 100644 src/core/mod.rs 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, +} + +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(mut self, definition: T) -> Self + where + T: Into, + { + 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 From<(T, T)> for LanguageDefinition +where + T: AsRef, +{ + /// 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, - } - - 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(mut self, definition: T) -> Self - where - T: Into, - { - 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 From<(T, T)> for LanguageDefinition - where - T: AsRef, - { - /// 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; -- libgit2 1.7.2