use-npm 0.0.1

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

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

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

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

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

        impl fmt::Display for $name {
            fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                formatter.write_str(self.as_str())
            }
        }
    };
}

/// Common npm command labels.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum NpmCommand {
    Install,
    Ci,
    Run,
    Test,
    Publish,
    Pack,
    Version,
    Audit,
}

impl NpmCommand {
    /// Returns the command label.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Install => "install",
            Self::Ci => "ci",
            Self::Run => "run",
            Self::Test => "test",
            Self::Publish => "publish",
            Self::Pack => "pack",
            Self::Version => "version",
            Self::Audit => "audit",
        }
    }
}

impl FromStr for NpmCommand {
    type Err = NpmCommandParseError;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        parse_command(input, |label| match label {
            "install" | "i" => Some(Self::Install),
            "ci" => Some(Self::Ci),
            "run" => Some(Self::Run),
            "test" | "t" => Some(Self::Test),
            "publish" => Some(Self::Publish),
            "pack" => Some(Self::Pack),
            "version" => Some(Self::Version),
            "audit" => Some(Self::Audit),
            _ => None,
        })
    }
}

/// Error returned while parsing npm commands.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum NpmCommandParseError {
    Empty,
    Unknown,
}

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

impl Error for NpmCommandParseError {}

string_newtype!(NpmScriptCommand);
string_newtype!(NpmPackageSpec);

/// npm registry URL metadata.
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NpmRegistryUrl(String);

impl NpmRegistryUrl {
    /// Creates registry URL metadata.
    ///
    /// # Errors
    ///
    /// Returns [`NpmTextError`] when `input` is empty, contains whitespace, or is not HTTP(S)-shaped.
    pub fn new(input: &str) -> Result<Self, NpmTextError> {
        let trimmed = input.trim();
        if trimmed.is_empty() {
            return Err(NpmTextError::Empty);
        }
        if trimmed.chars().any(char::is_whitespace) {
            return Err(NpmTextError::ContainsWhitespace);
        }
        if !(trimmed.starts_with("https://") || trimmed.starts_with("http://")) {
            return Err(NpmTextError::InvalidUrl);
        }
        Ok(Self(trimmed.to_string()))
    }

    /// Returns the registry URL label.
    #[must_use]
    pub fn as_str(&self) -> &str {
        &self.0
    }
}

/// Error returned when npm text metadata is invalid.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum NpmTextError {
    Empty,
    ContainsWhitespace,
    InvalidUrl,
}

impl fmt::Display for NpmTextError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Empty => formatter.write_str("npm metadata text cannot be empty"),
            Self::ContainsWhitespace => {
                formatter.write_str("npm metadata text cannot contain whitespace")
            }
            Self::InvalidUrl => {
                formatter.write_str("npm registry URL must start with http:// or https://")
            }
        }
    }
}

impl Error for NpmTextError {}

fn parse_command<F>(input: &str, parse: F) -> Result<NpmCommand, NpmCommandParseError>
where
    F: FnOnce(&str) -> Option<NpmCommand>,
{
    let trimmed = input.trim();
    if trimmed.is_empty() {
        return Err(NpmCommandParseError::Empty);
    }
    parse(trimmed.to_ascii_lowercase().as_str()).ok_or(NpmCommandParseError::Unknown)
}

#[cfg(test)]
mod tests {
    use super::{NpmCommand, NpmPackageSpec, NpmRegistryUrl, NpmTextError};

    #[test]
    fn models_npm_metadata() -> Result<(), Box<dyn std::error::Error>> {
        assert_eq!("ci".parse::<NpmCommand>()?, NpmCommand::Ci);
        assert_eq!(
            NpmRegistryUrl::new("https://registry.npmjs.org/")?.as_str(),
            "https://registry.npmjs.org/"
        );
        assert_eq!(
            NpmPackageSpec::new("react@latest")?.as_str(),
            "react@latest"
        );
        assert_eq!(
            NpmRegistryUrl::new("registry.npmjs.org"),
            Err(NpmTextError::InvalidUrl)
        );
        Ok(())
    }
}