gen-types 0.1.4

gen — typed IR for the universal package-manager → build-system engine. One typed Manifest / Package / Dependency / Feature / Constraint / Lockfile / Workspace / BuildStep / Derivation shape that every ecosystem reduces to. Foundation crate; the only thing every adapter + renderer + cache backend depends on. See theory/GEN.md for the full design.
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

//! Typed [`Package`] — one node in the dependency graph.

use crate::{BuildStep, Dependency, Feature, PackageSource, Registry, Version};
use serde::{Deserialize, Serialize};

/// Canonical identifier: `(name, version, registry)`. Different
/// registries can host packages with the same name+version, so the
/// registry is part of identity.
#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct PackageId {
    pub name: String,
    pub version: Version,
    pub registry: Registry,
}

impl PackageId {
    /// Stable string form for diagnostics + filesystem-safe cache
    /// keys: `<registry>/<name>/<version>`.
    #[must_use]
    pub fn dotted(&self) -> String {
        format!("{}/{}/{}", self.registry.as_str(), self.name, self.version)
    }
}

/// One package in the parsed manifest. Adapter-agnostic shape;
/// every language reduces to this.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Package {
    pub name: String,
    pub version: Version,
    pub source: PackageSource,
    pub registry: Registry,
    #[serde(default)]
    pub dependencies: Vec<Dependency>,
    #[serde(default)]
    pub features: Vec<Feature>,
    #[serde(default)]
    pub build_steps: Vec<BuildStep>,
    /// SPDX license string when available.
    #[serde(default)]
    pub license: Option<String>,
    /// Free-text description from the manifest.
    #[serde(default)]
    pub description: Option<String>,
    /// Authors / publisher line.
    #[serde(default)]
    pub authors: Vec<String>,
    /// Homepage URL.
    #[serde(default)]
    pub homepage: Option<String>,
    /// Source repository URL.
    #[serde(default)]
    pub repository: Option<String>,
}

impl Package {
    /// Convenience: canonical identity of this package.
    #[must_use]
    pub fn id(&self) -> PackageId {
        PackageId {
            name: self.name.clone(),
            version: self.version.clone(),
            registry: self.registry.clone(),
        }
    }
}

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

    #[test]
    fn id_dotted_form_is_stable() {
        let p = Package {
            name: "serde".into(),
            version: Version::new(1, 0, 228),
            source: PackageSource::Registry {
                registry: Registry::CratesIo,
                registry_name: "serde".into(),
                integrity_hash: None,
            },
            registry: Registry::CratesIo,
            dependencies: vec![],
            features: vec![],
            build_steps: vec![],
            license: Some("MIT OR Apache-2.0".into()),
            description: None,
            authors: vec![],
            homepage: None,
            repository: None,
        };
        assert_eq!(p.id().dotted(), "crates-io/serde/1.0.228");
    }

    #[test]
    fn package_id_used_as_hash_key() {
        let id_a = PackageId {
            name: "serde".into(),
            version: Version::new(1, 0, 0),
            registry: Registry::CratesIo,
        };
        let id_b = id_a.clone();
        let mut m = std::collections::HashMap::new();
        m.insert(id_a, "x");
        assert_eq!(m.get(&id_b), Some(&"x"));
    }

    #[test]
    fn round_trip_through_serde() {
        let p = Package {
            name: "serde".into(),
            version: Version::new(1, 0, 228),
            source: PackageSource::Registry {
                registry: Registry::CratesIo,
                registry_name: "serde".into(),
                integrity_hash: Some("sha256:abc".into()),
            },
            registry: Registry::CratesIo,
            dependencies: vec![Dependency {
                name: "serde_derive".into(),
                constraint: crate::VersionConstraint::from_spec(ConstraintSpec::Caret(
                    Version::new(1, 0, 228),
                )),
                kind: crate::DependencyKind::Direct,
                features_enabled: vec![],
                default_features: true,
                target_predicate: None,
                source_override: None,
            }],
            features: vec![],
            build_steps: vec![],
            license: Some("MIT".into()),
            description: Some("Serialization framework".into()),
            authors: vec![],
            homepage: None,
            repository: Some("https://github.com/serde-rs/serde".into()),
        };
        let j = serde_json::to_string(&p).unwrap();
        let parsed: Package = serde_json::from_str(&j).unwrap();
        assert_eq!(p, parsed);
    }
}