phalus 0.7.0

Private Headless Automated License Uncoupling System — AI-powered clean room software reimplementation
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

use super::ManifestError;
use crate::{Ecosystem, PackageRef, ParsedManifest};
use std::path::Path;

pub struct CargoParser;

impl CargoParser {
    pub fn detect(path: &Path) -> bool {
        path.file_name()
            .and_then(|n| n.to_str())
            .map(|n| n == "Cargo.toml")
            .unwrap_or(false)
    }

    pub fn parse(content: &str) -> Result<ParsedManifest, ManifestError> {
        let value: toml::Value = content
            .parse()
            .map_err(|e: toml::de::Error| ManifestError::Parse(e.to_string()))?;

        let mut packages = Vec::new();

        if let Some(deps) = value.get("dependencies").and_then(|d| d.as_table()) {
            for (name, spec) in deps {
                let version_constraint = match spec {
                    // Simple string form: serde = "1.0"
                    toml::Value::String(v) => v.clone(),
                    // Inline table form: tokio = { version = "1", ... }
                    toml::Value::Table(t) => t
                        .get("version")
                        .and_then(|v| v.as_str())
                        .unwrap_or("*")
                        .to_string(),
                    _ => "*".to_string(),
                };

                packages.push(PackageRef {
                    name: name.clone(),
                    version_constraint,
                    ecosystem: Ecosystem::Crates,
                });
            }
        }

        Ok(ParsedManifest {
            manifest_type: "Cargo.toml".to_string(),
            packages,
        })
    }
}

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

    #[test]
    fn test_parse_cargo_toml() {
        let input = r#"
[package]
name = "my-app"
version = "0.1.0"

[dependencies]
serde = "1.0"
tokio = { version = "1", features = ["full"] }
"#;
        let manifest = CargoParser::parse(input).unwrap();
        assert_eq!(manifest.packages.len(), 2);
        assert_eq!(manifest.packages[0].ecosystem, Ecosystem::Crates);
    }

    #[test]
    fn test_detect() {
        assert!(CargoParser::detect(Path::new("Cargo.toml")));
    }

    #[test]
    fn test_no_dependencies() {
        let input = r#"
[package]
name = "empty"
version = "0.1.0"
"#;
        let manifest = CargoParser::parse(input).unwrap();
        assert_eq!(manifest.packages.len(), 0);
    }
}