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
        }
    }

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