use-package-json 0.0.1

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

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

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

        impl $name {
            /// Creates non-empty package metadata text.
            ///
            /// # Errors
            ///
            /// Returns [`PackageJsonTextError::Empty`] when `input` is empty after trimming.
            pub fn new(input: &str) -> Result<Self, PackageJsonTextError> {
                let trimmed = input.trim();
                if trimmed.is_empty() {
                    Err(PackageJsonTextError::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())
            }
        }

        impl FromStr for $name {
            type Err = PackageJsonTextError;

            fn from_str(input: &str) -> Result<Self, Self::Err> {
                Self::new(input)
            }
        }
    };
}

/// Validated package name metadata.
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PackageName(String);

impl PackageName {
    /// Creates lightly validated package name metadata.
    ///
    /// # Errors
    ///
    /// Returns [`PackageJsonTextError`] when `input` is empty, contains whitespace, or has an invalid scoped shape.
    pub fn new(input: &str) -> Result<Self, PackageJsonTextError> {
        let trimmed = input.trim();
        if trimmed.is_empty() {
            return Err(PackageJsonTextError::Empty);
        }
        if trimmed.chars().any(char::is_whitespace) {
            return Err(PackageJsonTextError::ContainsWhitespace);
        }
        if let Some(rest) = trimmed.strip_prefix('@') {
            let Some((scope, name)) = rest.split_once('/') else {
                return Err(PackageJsonTextError::InvalidScopedName);
            };
            if scope.is_empty() || name.is_empty() || name.contains('/') {
                return Err(PackageJsonTextError::InvalidScopedName);
            }
        } else if trimmed.contains('/') {
            return Err(PackageJsonTextError::InvalidName);
        }
        Ok(Self(trimmed.to_string()))
    }

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

    /// Returns whether this package name is scoped.
    #[must_use]
    pub fn is_scoped(&self) -> bool {
        self.0.starts_with('@')
    }
}

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

impl FromStr for PackageName {
    type Err = PackageJsonTextError;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        Self::new(input)
    }
}

impl TryFrom<&str> for PackageName {
    type Error = PackageJsonTextError;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        Self::new(value)
    }
}

text_newtype!(PackageVersion);
text_newtype!(PackageScriptName);
text_newtype!(PackageScript);

/// Dependency map keyed by package name.
pub type DependencyMap = BTreeMap<PackageName, PackageVersion>;

/// `package.json` dependency section kind.
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum DependencyKind {
    Dependencies,
    DevDependencies,
    PeerDependencies,
    OptionalDependencies,
    BundleDependencies,
}

impl DependencyKind {
    /// Returns the `package.json` field name.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Dependencies => "dependencies",
            Self::DevDependencies => "devDependencies",
            Self::PeerDependencies => "peerDependencies",
            Self::OptionalDependencies => "optionalDependencies",
            Self::BundleDependencies => "bundleDependencies",
        }
    }
}

/// `package.json` package type metadata.
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum PackageType {
    Module,
    CommonJs,
}

impl PackageType {
    /// Returns the package type label.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Module => "module",
            Self::CommonJs => "commonjs",
        }
    }
}

/// Partial practical `package.json` metadata.
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct PackageJson {
    name: Option<PackageName>,
    version: Option<PackageVersion>,
    package_type: Option<PackageType>,
    scripts: BTreeMap<PackageScriptName, PackageScript>,
    dependencies: BTreeMap<DependencyKind, DependencyMap>,
}

impl PackageJson {
    /// Creates empty package metadata.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the package name.
    #[must_use]
    pub fn with_name(mut self, name: PackageName) -> Self {
        self.name = Some(name);
        self
    }

    /// Sets the package version.
    #[must_use]
    pub fn with_version(mut self, version: PackageVersion) -> Self {
        self.version = Some(version);
        self
    }

    /// Sets the package type.
    #[must_use]
    pub const fn with_package_type(mut self, package_type: PackageType) -> Self {
        self.package_type = Some(package_type);
        self
    }

    /// Adds a script entry.
    #[must_use]
    pub fn with_script(mut self, name: PackageScriptName, script: PackageScript) -> Self {
        self.scripts.insert(name, script);
        self
    }

    /// Adds a dependency entry under a dependency kind.
    #[must_use]
    pub fn with_dependency(
        mut self,
        kind: DependencyKind,
        name: PackageName,
        version: PackageVersion,
    ) -> Self {
        self.dependencies
            .entry(kind)
            .or_default()
            .insert(name, version);
        self
    }

    /// Returns the optional package name.
    #[must_use]
    pub const fn name(&self) -> Option<&PackageName> {
        self.name.as_ref()
    }

    /// Returns the optional package version.
    #[must_use]
    pub const fn version(&self) -> Option<&PackageVersion> {
        self.version.as_ref()
    }

    /// Returns the optional package type.
    #[must_use]
    pub const fn package_type(&self) -> Option<PackageType> {
        self.package_type
    }

    /// Returns script entries.
    #[must_use]
    pub const fn scripts(&self) -> &BTreeMap<PackageScriptName, PackageScript> {
        &self.scripts
    }

    /// Returns dependency entries grouped by dependency kind.
    #[must_use]
    pub const fn dependencies(&self) -> &BTreeMap<DependencyKind, DependencyMap> {
        &self.dependencies
    }
}

/// Error returned when package metadata text is invalid.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum PackageJsonTextError {
    Empty,
    ContainsWhitespace,
    InvalidScopedName,
    InvalidName,
}

impl fmt::Display for PackageJsonTextError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Empty => formatter.write_str("package metadata text cannot be empty"),
            Self::ContainsWhitespace => {
                formatter.write_str("package metadata text cannot contain whitespace")
            }
            Self::InvalidScopedName => {
                formatter.write_str("scoped package names must look like @scope/name")
            }
            Self::InvalidName => formatter.write_str("package name has an invalid shape"),
        }
    }
}

impl Error for PackageJsonTextError {}

#[cfg(test)]
mod tests {
    use super::{
        DependencyKind, PackageJson, PackageJsonTextError, PackageName, PackageScript,
        PackageScriptName, PackageType, PackageVersion,
    };

    #[test]
    fn validates_package_names() -> Result<(), PackageJsonTextError> {
        let scoped = PackageName::new("@rustuse/example")?;
        assert!(scoped.is_scoped());
        assert_eq!(
            PackageName::new("bad name"),
            Err(PackageJsonTextError::ContainsWhitespace)
        );
        assert_eq!(
            PackageName::new("@scope"),
            Err(PackageJsonTextError::InvalidScopedName)
        );
        Ok(())
    }

    #[test]
    fn stores_package_metadata() -> Result<(), PackageJsonTextError> {
        let manifest = PackageJson::new()
            .with_name(PackageName::new("demo")?)
            .with_version(PackageVersion::new("0.1.0")?)
            .with_package_type(PackageType::Module)
            .with_script(
                PackageScriptName::new("test")?,
                PackageScript::new("vitest")?,
            )
            .with_dependency(
                DependencyKind::Dependencies,
                PackageName::new("react")?,
                PackageVersion::new("^18")?,
            );

        assert_eq!(manifest.name().map(PackageName::as_str), Some("demo"));
        assert_eq!(manifest.scripts().len(), 1);
        assert_eq!(manifest.dependencies().len(), 1);
        Ok(())
    }
}