otter-pm 0.1.0

NPM-compatible package manager for Otter
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Lockfile format (otter.lock)

use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::path::Path;

/// Lockfile structure (otter.lock)
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct Lockfile {
    /// Lockfile format version
    pub version: u32,

    /// Locked packages
    pub packages: HashMap<String, LockfileEntry>,
}

impl Lockfile {
    pub fn new() -> Self {
        Self {
            version: 1,
            packages: HashMap::new(),
        }
    }

    /// Load lockfile from path
    pub fn load(path: &Path) -> Result<Self, LockfileError> {
        let content = fs::read_to_string(path).map_err(|e| LockfileError::Io(e.to_string()))?;

        serde_json::from_str(&content).map_err(|e| LockfileError::Parse(e.to_string()))
    }

    /// Save lockfile to path
    pub fn save(&self, path: &Path) -> Result<(), LockfileError> {
        let content =
            serde_json::to_string_pretty(self).map_err(|e| LockfileError::Parse(e.to_string()))?;

        fs::write(path, content).map_err(|e| LockfileError::Io(e.to_string()))
    }

    /// Check if a package is locked at a specific version
    pub fn is_locked(&self, name: &str, version: &str) -> bool {
        self.packages
            .get(name)
            .is_some_and(|entry| entry.version == version)
    }

    /// Get locked version for a package
    pub fn get_version(&self, name: &str) -> Option<&str> {
        self.packages.get(name).map(|e| e.version.as_str())
    }
}

/// Single package entry in lockfile
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LockfileEntry {
    /// Exact version installed
    pub version: String,

    /// Resolved tarball URL
    pub resolved: String,

    /// Integrity hash (SHA-512)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub integrity: Option<String>,

    /// Dependencies with version requirements
    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
    pub dependencies: HashMap<String, String>,
}

#[derive(Debug, thiserror::Error)]
pub enum LockfileError {
    #[error("IO error: {0}")]
    Io(String),

    #[error("Parse error: {0}")]
    Parse(String),
}

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

    #[test]
    fn test_lockfile_new() {
        let lockfile = Lockfile::new();
        assert_eq!(lockfile.version, 1);
        assert!(lockfile.packages.is_empty());
    }

    #[test]
    fn test_lockfile_serialize() {
        let mut lockfile = Lockfile::new();
        lockfile.packages.insert(
            "lodash".to_string(),
            LockfileEntry {
                version: "4.17.21".to_string(),
                resolved: "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz".to_string(),
                integrity: Some("sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==".to_string()),
                dependencies: HashMap::new(),
            },
        );

        let json = serde_json::to_string_pretty(&lockfile).unwrap();
        assert!(json.contains("lodash"));
        assert!(json.contains("4.17.21"));
    }

    #[test]
    fn test_lockfile_deserialize() {
        let json = r#"{
            "version": 1,
            "packages": {
                "lodash": {
                    "version": "4.17.21",
                    "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz"
                }
            }
        }"#;

        let lockfile: Lockfile = serde_json::from_str(json).unwrap();
        assert_eq!(lockfile.version, 1);
        assert!(lockfile.packages.contains_key("lodash"));
        assert_eq!(lockfile.packages["lodash"].version, "4.17.21");
    }

    #[test]
    fn test_is_locked() {
        let mut lockfile = Lockfile::new();
        lockfile.packages.insert(
            "lodash".to_string(),
            LockfileEntry {
                version: "4.17.21".to_string(),
                resolved: "https://example.com".to_string(),
                integrity: None,
                dependencies: HashMap::new(),
            },
        );

        assert!(lockfile.is_locked("lodash", "4.17.21"));
        assert!(!lockfile.is_locked("lodash", "4.17.20"));
        assert!(!lockfile.is_locked("underscore", "1.0.0"));
    }
}