clippier 0.3.0

MoosicBox clippier package
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Node.js workspace support for npm, pnpm, and bun monorepos.
//!
//! This module provides workspace detection and package analysis for Node.js projects
//! using various package managers:
//!
//! - **npm**: Uses `package.json` `workspaces` field with `package-lock.json`
//! - **pnpm**: Uses `pnpm-workspace.yaml` with `pnpm-lock.yaml`
//! - **bun**: Uses `package.json` `workspaces` field with `bun.lock`
//!
//! # Example
//!
//! ```rust,ignore
//! use clippier::workspace::node::{NodeWorkspace, NodePackageManager};
//! use clippier::workspace::Workspace;
//!
//! async fn analyze() {
//!     // Auto-detect package manager
//!     let ws = NodeWorkspace::detect(Path::new(".")).await.unwrap().unwrap();
//!     println!("Using {:?}", ws.package_manager());
//!     
//!     // List all packages
//!     for pkg in ws.packages().await.unwrap() {
//!         println!("  - {}", pkg.name());
//!     }
//! }
//! ```

mod context;
pub mod lockfile;
mod package;

pub use context::NodeWorkspace;
pub use lockfile::{NodeLockDiffParser, NodeLockEntry, NodeLockfile};
pub use package::{NodePackage, parse_dependencies, read_package_name, read_package_version};

/// Supported Node.js package managers.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum NodePackageManager {
    /// npm - Node Package Manager
    ///
    /// Uses `package-lock.json` for lockfile and `package.json` `workspaces` field.
    Npm,

    /// pnpm - Performant npm
    ///
    /// Uses `pnpm-lock.yaml` for lockfile and `pnpm-workspace.yaml` for workspace config.
    Pnpm,

    /// bun - Fast all-in-one JavaScript runtime
    ///
    /// Uses `bun.lock` for lockfile and `package.json` `workspaces` field.
    Bun,
}

impl NodePackageManager {
    /// Returns the lockfile name for this package manager.
    #[must_use]
    pub const fn lockfile_name(self) -> &'static str {
        match self {
            Self::Npm => "package-lock.json",
            Self::Pnpm => "pnpm-lock.yaml",
            Self::Bun => "bun.lock",
        }
    }

    /// Returns the workspace config file name for this package manager.
    ///
    /// Note: npm and bun use `package.json`, while pnpm uses `pnpm-workspace.yaml`.
    #[must_use]
    pub const fn workspace_config_name(self) -> &'static str {
        match self {
            Self::Npm | Self::Bun => "package.json",
            Self::Pnpm => "pnpm-workspace.yaml",
        }
    }

    /// Returns the display name for this package manager.
    #[must_use]
    pub const fn display_name(self) -> &'static str {
        match self {
            Self::Npm => "npm",
            Self::Pnpm => "pnpm",
            Self::Bun => "bun",
        }
    }
}

impl std::fmt::Display for NodePackageManager {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.display_name())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_package_manager_lockfile_names() {
        assert_eq!(NodePackageManager::Npm.lockfile_name(), "package-lock.json");
        assert_eq!(NodePackageManager::Pnpm.lockfile_name(), "pnpm-lock.yaml");
        assert_eq!(NodePackageManager::Bun.lockfile_name(), "bun.lock");
    }

    #[test]
    fn test_package_manager_workspace_config() {
        assert_eq!(
            NodePackageManager::Npm.workspace_config_name(),
            "package.json"
        );
        assert_eq!(
            NodePackageManager::Pnpm.workspace_config_name(),
            "pnpm-workspace.yaml"
        );
        assert_eq!(
            NodePackageManager::Bun.workspace_config_name(),
            "package.json"
        );
    }

    #[test]
    fn test_package_manager_display() {
        assert_eq!(NodePackageManager::Npm.to_string(), "npm");
        assert_eq!(NodePackageManager::Pnpm.to_string(), "pnpm");
        assert_eq!(NodePackageManager::Bun.to_string(), "bun");
    }
}