normalize-manifest 0.3.1

Manifest file parsing for programming language ecosystems
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

//! Parser for `fpm.toml` files (Fortran Package Manager).

use crate::{DeclaredDep, DepKind, ManifestError, ManifestParser, ParsedManifest};
use toml::Value;

/// Parser for `fpm.toml` files.
///
/// `[dependencies]` → `Normal`, `[dev-dependencies]` → `Dev`.
/// Dependencies are tables with optional `tag`, `git`, or `path` keys.
/// Version is taken from `tag` if present, otherwise `None`.
pub struct FortranFpmParser;

impl ManifestParser for FortranFpmParser {
    fn filename(&self) -> &'static str {
        "fpm.toml"
    }

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

        let name = toml
            .get("name")
            .and_then(|v| v.as_str())
            .map(|s| s.to_string());
        let version = toml
            .get("version")
            .and_then(|v| v.as_str())
            .map(|s| s.to_string());

        let mut deps = Vec::new();
        extract_fpm_deps(&toml, "dependencies", DepKind::Normal, &mut deps);
        extract_fpm_deps(&toml, "dev-dependencies", DepKind::Dev, &mut deps);

        Ok(ParsedManifest {
            ecosystem: "fpm",
            name,
            version,
            dependencies: deps,
        })
    }
}

fn extract_fpm_deps(toml: &Value, section: &str, kind: DepKind, out: &mut Vec<DeclaredDep>) {
    let Some(table) = toml.get(section).and_then(|v| v.as_table()) else {
        return;
    };
    for (name, val) in table {
        let version_req = val
            .as_table()
            .and_then(|t| t.get("tag"))
            .and_then(|v| v.as_str())
            .map(|s| s.to_string());
        out.push(DeclaredDep {
            name: name.clone(),
            version_req,
            kind,
        });
    }
}

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

    #[test]
    fn test_fpm_toml() {
        let content = r#"
name = "my_lib"
version = "0.1.0"

[dependencies]
fortran-stdlib = { git = "https://github.com/fortran-lang/stdlib" }
M_math = { git = "https://github.com/urbanjost/M_math.git", tag = "v0.0.1" }
toml-f = { path = "../toml-f" }

[dev-dependencies]
test-drive = { git = "https://github.com/fortran-lang/test-drive.git" }
"#;
        let m = FortranFpmParser.parse(content).unwrap();
        assert_eq!(m.ecosystem, "fpm");
        assert_eq!(m.name.as_deref(), Some("my_lib"));
        assert_eq!(m.version.as_deref(), Some("0.1.0"));
        assert_eq!(m.dependencies.len(), 4);

        let stdlib = m
            .dependencies
            .iter()
            .find(|d| d.name == "fortran-stdlib")
            .unwrap();
        assert_eq!(stdlib.kind, DepKind::Normal);
        assert!(stdlib.version_req.is_none());

        let mmath = m.dependencies.iter().find(|d| d.name == "M_math").unwrap();
        assert_eq!(mmath.kind, DepKind::Normal);
        assert_eq!(mmath.version_req.as_deref(), Some("v0.0.1"));

        let tomlf = m.dependencies.iter().find(|d| d.name == "toml-f").unwrap();
        assert_eq!(tomlf.kind, DepKind::Normal);
        assert!(tomlf.version_req.is_none());

        let test_drive = m
            .dependencies
            .iter()
            .find(|d| d.name == "test-drive")
            .unwrap();
        assert_eq!(test_drive.kind, DepKind::Dev);
        assert!(test_drive.version_req.is_none());
    }

    #[test]
    fn test_fpm_no_dev_deps() {
        let content = r#"
name = "minimal"
version = "0.0.1"

[dependencies]
stdlib = { git = "https://github.com/fortran-lang/stdlib", tag = "v0.4.0" }
"#;
        let m = FortranFpmParser.parse(content).unwrap();
        assert_eq!(m.dependencies.len(), 1);
        assert_eq!(m.dependencies[0].version_req.as_deref(), Some("v0.4.0"));
    }
}