From 81ce85ffddfe9c82f328d95a09f37f43c625495f Mon Sep 17 00:00:00 2001 From: holly sparkles Date: Sun, 7 Jan 2024 15:55:22 +0100 Subject: [PATCH] feat(lang): add language definitions from guesslang --- src/lib.rs | 159 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/main.rs | 64 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 222 insertions(+), 1 deletion(-) create mode 100644 src/lib.rs 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, + } + + 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 + } + } + + /// 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/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)) } -- libgit2 1.7.2