murmur-artifact 0.11.0

The shared artifact model for Murmur capsules: manifest schema, .mur.zip packing and unpacking, the registry trait, refs, lockfile, and inference config.
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

use thiserror::Error;

use crate::artifact_name::{ArtifactName, ArtifactNameError};

/// What `mur install <ref>` names, short of a path to a `.mur.zip` file.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ArtifactRef {
    /// `<scope>/<name>`, with no version: whatever the sources serve for it.
    Name(ArtifactName),
    /// `github:<owner>/<repo>@<tag>`: every asset of one release.
    GitHub {
        owner: String,
        repo: String,
        tag: String,
    },
}

impl ArtifactRef {
    pub fn parse(input: &str) -> Result<Self, ArtifactRefError> {
        let value = input.trim();
        if value.is_empty() {
            return Err(ArtifactRefError::Empty);
        }

        if let Some(rest) = value.strip_prefix("github:") {
            return parse_github(rest);
        }

        if value.contains(':') {
            let prefix = value.split(':').next().unwrap_or_default();
            return Err(ArtifactRefError::UnknownSourcePrefix(prefix.to_string()));
        }

        ArtifactName::parse(value)
            .map(Self::Name)
            .map_err(ArtifactRefError::Name)
    }
}

#[derive(Debug, Error, Clone, PartialEq, Eq)]
pub enum ArtifactRefError {
    #[error("artifact reference cannot be empty")]
    Empty,
    #[error("invalid github artifact reference '{0}' (expected github:<owner>/<repo>@<tag>)")]
    InvalidGitHub(String),
    #[error("unsupported artifact source prefix '{0}'")]
    UnknownSourcePrefix(String),
    #[error(transparent)]
    Name(ArtifactNameError),
}

fn parse_github(rest: &str) -> Result<ArtifactRef, ArtifactRefError> {
    let Some((repo_ref, tag)) = rest.split_once('@') else {
        return Err(ArtifactRefError::InvalidGitHub(format!("github:{rest}")));
    };

    let Some((owner, repo)) = repo_ref.split_once('/') else {
        return Err(ArtifactRefError::InvalidGitHub(format!("github:{rest}")));
    };

    if owner.trim().is_empty() || repo.trim().is_empty() || tag.trim().is_empty() {
        return Err(ArtifactRefError::InvalidGitHub(format!("github:{rest}")));
    }

    Ok(ArtifactRef::GitHub {
        owner: owner.to_string(),
        repo: repo.to_string(),
        tag: tag.to_string(),
    })
}

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

    #[test]
    fn artifact_ref_parses_a_full_name() {
        assert_eq!(
            ArtifactRef::parse("murmur/driver-anthropic").unwrap(),
            ArtifactRef::Name(ArtifactName::parse("murmur/driver-anthropic").unwrap())
        );
    }

    #[test]
    fn artifact_ref_refuses_a_bare_name_with_the_scoped_hint() {
        let error = ArtifactRef::parse("murmur-driver-anthropic").unwrap_err();
        let ArtifactRefError::Name(name_error) = error else {
            panic!("expected a name error, got {error:?}");
        };
        assert!(name_error
            .hint()
            .unwrap()
            .contains("murmur/driver-anthropic"));
    }

    #[test]
    fn artifact_ref_parses_github_uri() {
        assert_eq!(
            ArtifactRef::parse("github:murmur-nexus/default-artifacts@v0.1.1").unwrap(),
            ArtifactRef::GitHub {
                owner: "murmur-nexus".to_string(),
                repo: "default-artifacts".to_string(),
                tag: "v0.1.1".to_string(),
            }
        );
    }

    #[test]
    fn artifact_ref_rejects_malformed_github_uri() {
        let error = ArtifactRef::parse("github:murmur-nexus/default-artifacts").unwrap_err();
        assert!(matches!(error, ArtifactRefError::InvalidGitHub(_)));
    }
}