gipm 0.1.0

Gipm is a git package manager
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
144
145
146
147
148
149
150
151
152
153
154
155
156

use crate::git::GitPackage;
use crate::third_party::semver_pubgrub::SemverPubgrub;
use anyhow::{Context, Result};
use pubgrub::Ranges;
use semver::Version;
use std::fmt::{Display, Formatter};
use std::fs::File;
use std::hash::Hash;
use std::io::Read;

#[derive(Clone, Debug, Eq, PartialEq, Hash, serde::Deserialize)]
pub struct DependencySpecification {
    // The version of the dependency
    // Expressed as a String version range
    pub version: String,

    // The remote URL of the dependency
    pub url: String,

    #[serde(default)]
    // The prefix for the version
    pub prefix: Option<String>,

    #[serde(default)]
    // The replacement for the version
    pub replacement: Option<Vec<[String; 2]>>,
}

#[derive(serde::Deserialize)]
struct DependenciesFile {
    dependencies: Vec<DependencySpecification>,
}

impl Display for DependencySpecification {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}@{}", self.url, self.version)
    }
}

impl DependencySpecification {
    pub fn new(
        version_string: String,
        url: String,
        prefix: Option<String>,
        replacement: Option<Vec<[String; 2]>>,
    ) -> Self {
        Self {
            version: version_string,
            url,
            prefix,
            replacement,
        }
    }

    pub fn to_package_and_version_range(&self) -> Result<(GitPackage, SemverPubgrub<Version>)> {
        let package = GitPackage::new(
            self.url.clone(),
            self.prefix.clone(),
            self.replacement.clone(),
        );

        let version_req = package
            .parse_version_requirement(&self.version, &self.prefix, &self.replacement)
            .context(format!(
                "Failed to parse version requirement for dependency specification {}, version {}",
                self.url, self.version
            ))?;

        let version_range: SemverPubgrub<Version> = (&version_req).into();

        Ok((package, version_range))
    }
}

/// Parse dependencies.yaml content from a string
pub fn parse_dependencies_yaml_content(content: &str) -> Result<Vec<DependencySpecification>> {
    let deps_file: DependenciesFile =
        serde_yaml::from_str(content).context("Failed to parse dependencies.yaml content")?;

    // Convert to Dependency structs
    let dependencies = deps_file.dependencies;
    Ok(dependencies)
}

pub fn parse_dependencies_yaml_file(path: &str) -> Result<Vec<DependencySpecification>> {
    // Read the file contents
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;

    parse_dependencies_yaml_content(&contents)
}

pub fn dependency_spec_to_package_and_version_range(
    dependencies: Vec<DependencySpecification>,
) -> Result<Vec<(GitPackage, Ranges<Version>)>> {
    dependencies
        .into_iter()
        .map(|d| {
            let (package, version_range) = d.to_package_and_version_range()?;
            let (start, end) = version_range
                .bounding_range()
                .ok_or_else(|| anyhow::anyhow!("No bounding range for version requirement"))?;
            Ok((
                package,
                Ranges::from_iter(vec![(start.cloned(), end.cloned())]),
            ))
        })
        .collect()
}

#[cfg(test)]
#[test]
fn test_dependency_specification() -> anyhow::Result<()> {
    let dep_spec = DependencySpecification::new(
        "1.0.0".to_string(),
        "github.com/user/repo.git".to_string(),
        Some("v".to_string()),
        Some(vec![["_".to_string(), "-".to_string()]]),
    );

    anyhow::ensure!(
        dep_spec.version == "1.0.0"
            && dep_spec.url == "github.com/user/repo.git"
            && dep_spec.prefix == Some("v".to_string())
            && dep_spec.replacement == Some(vec![["_".to_string(), "-".to_string()]]),
        "DependencySpecification did not initialize correctly"
    );

    // Coverage for Display formatter
    println!("{dep_spec}");

    Ok(())
}

#[cfg(test)]
#[test]
fn test_bad_version() -> anyhow::Result<()> {
    let dep_spec = DependencySpecification::new(
        "not_a_version".to_string(),
        "github.com/user/repo.git".to_string(),
        Some("v".to_string()),
        Some(vec![["_".to_string(), "-".to_string()]]),
    );

    let result = dep_spec.to_package_and_version_range();

    println!("Testing: {dep_spec}");

    anyhow::ensure!(
        result.is_err(),
        "Expect that version string did not parse correctly"
    );

    Ok(())
}