use-yarn 0.0.1

#![forbid(unsafe_code)]
#![doc = include_str!("../README.md")]

use core::{fmt, str::FromStr};
use std::error::Error;

macro_rules! text_newtype {
    ($name:ident) => {
        #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
        pub struct $name(String);

        impl $name {
            /// Creates non-empty Yarn text metadata.
            ///
            /// # Errors
            ///
            /// Returns [`YarnTextError::Empty`] when `input` is empty after trimming.
            pub fn new(input: &str) -> Result<Self, YarnTextError> {
                let trimmed = input.trim();
                if trimmed.is_empty() {
                    Err(YarnTextError::Empty)
                } else {
                    Ok(Self(trimmed.to_string()))
                }
            }

            /// Returns the stored text.
            #[must_use]
            pub fn as_str(&self) -> &str {
                &self.0
            }
        }
    };
}

/// Common Yarn command labels.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum YarnCommand {
    Install,
    Add,
    Run,
    Test,
    Workspaces,
    Publish,
}

impl FromStr for YarnCommand {
    type Err = YarnTextError;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        match normalized(input)?.as_str() {
            "install" => Ok(Self::Install),
            "add" => Ok(Self::Add),
            "run" => Ok(Self::Run),
            "test" => Ok(Self::Test),
            "workspaces" | "workspace" => Ok(Self::Workspaces),
            "publish" => Ok(Self::Publish),
            _ => Err(YarnTextError::Unknown),
        }
    }
}

/// Yarn release-line family.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum YarnVersionFamily {
    Classic,
    Berry,
}

impl YarnVersionFamily {
    /// Returns the family label.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Classic => "classic",
            Self::Berry => "berry",
        }
    }
}

text_newtype!(YarnWorkspace);

/// Common Yarn lockfile label.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum YarnLockfile {
    YarnLock,
}

impl YarnLockfile {
    /// Returns the lockfile label.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        "yarn.lock"
    }
}

/// Error returned when Yarn text metadata is invalid.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum YarnTextError {
    Empty,
    Unknown,
}

impl fmt::Display for YarnTextError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Empty => formatter.write_str("Yarn metadata text cannot be empty"),
            Self::Unknown => formatter.write_str("unknown Yarn command"),
        }
    }
}

impl Error for YarnTextError {}

fn normalized(input: &str) -> Result<String, YarnTextError> {
    let trimmed = input.trim();
    if trimmed.is_empty() {
        Err(YarnTextError::Empty)
    } else {
        Ok(trimmed.to_ascii_lowercase())
    }
}

#[cfg(test)]
mod tests {
    use super::{YarnCommand, YarnLockfile, YarnVersionFamily, YarnWorkspace};

    #[test]
    fn models_yarn_metadata() -> Result<(), Box<dyn std::error::Error>> {
        assert_eq!("install".parse::<YarnCommand>()?, YarnCommand::Install);
        assert_eq!(YarnVersionFamily::Classic.as_str(), "classic");
        assert_eq!(YarnWorkspace::new("packages/*")?.as_str(), "packages/*");
        assert_eq!(YarnLockfile::YarnLock.as_str(), "yarn.lock");
        Ok(())
    }
}