compose-lens 0.1.1

Loss-aware parsing, processing, validation, and rendering of Compose projects
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

//! Tolerant Compose image references.

/// A parsed digest suffix that remains tolerant of implementation extensions.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ImageDigest {
    algorithm: Option<String>,
    value: String,
}

impl ImageDigest {
    /// Returns the digest algorithm when the suffix contains `algorithm:value`.
    #[must_use]
    pub fn algorithm(&self) -> Option<&str> {
        self.algorithm.as_deref()
    }

    /// Returns the digest payload without validating an OCI grammar.
    #[must_use]
    pub fn value(&self) -> &str {
        &self.value
    }
}

/// A loss-aware, tolerant image reference.
///
/// `ComposeLens` deliberately accepts combined tags and digests such as
/// `registry.example/app:1.2@sha256:...` and does not reject implementation-supported values
/// merely because a stricter external grammar would.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ImageReference {
    raw: String,
    name: String,
    tag: Option<String>,
    digest: Option<ImageDigest>,
}

impl ImageReference {
    pub(crate) fn parse(raw: String) -> Self {
        let (name_and_tag, digest) = raw.split_once('@').map_or((raw.as_str(), None), |(left, right)| {
            let (algorithm, value) = right
                .split_once(':')
                .map_or((None, right.to_owned()), |(algorithm, value)| {
                    (Some(algorithm.to_owned()), value.to_owned())
                });
            (left, Some(ImageDigest { algorithm, value }))
        });

        let last_slash = name_and_tag.rfind('/');
        let tag_separator = name_and_tag
            .rfind(':')
            .filter(|index| last_slash.is_none_or(|slash| *index > slash));
        let (name, tag) = tag_separator.map_or_else(
            || (name_and_tag.to_owned(), None),
            |index| {
                (
                    name_and_tag[..index].to_owned(),
                    Some(name_and_tag[index + 1..].to_owned()),
                )
            },
        );

        Self { raw, name, tag, digest }
    }

    /// Returns the complete unmodified semantic reference.
    #[must_use]
    pub fn raw(&self) -> &str {
        &self.raw
    }

    /// Returns the repository/name portion before a tag or digest.
    #[must_use]
    pub fn name(&self) -> &str {
        &self.name
    }

    /// Returns the tag without the leading colon.
    #[must_use]
    pub fn tag(&self) -> Option<&str> {
        self.tag.as_deref()
    }

    /// Returns the digest suffix without the leading at-sign.
    #[must_use]
    pub const fn digest(&self) -> Option<&ImageDigest> {
        self.digest.as_ref()
    }
}

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

    #[test]
    fn accepts_registry_ports_tags_and_digests_together() {
        let reference = ImageReference::parse("registry.example:5000/team/app:1.2@sha256:abcdef".to_owned());

        assert_eq!(reference.name(), "registry.example:5000/team/app");
        assert_eq!(reference.tag(), Some("1.2"));
        assert_eq!(
            reference.digest().and_then(super::ImageDigest::algorithm),
            Some("sha256")
        );
        assert_eq!(reference.digest().map(super::ImageDigest::value), Some("abcdef"));
    }
}