lux-lib 0.70.0

Library for the lux package manager for Lua
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

use std::fmt::Display;

use crate::package_db::PackageDB;
use miette::Diagnostic;
use thiserror::Error;

use super::{version::Version, Name, Req, Spec, VersionReq};

#[derive(Error, Debug, Diagnostic)]
#[error("rock {0} not found")]
pub struct RockNotFound(Name);

#[derive(Error, Debug, Diagnostic)]
#[error("rock {} has no version that satisfies constraint {}", .name, .constraint.to_string())]
pub struct RockConstraintUnsatisfied {
    name: Name,
    constraint: VersionReq,
}

impl Spec {
    /// Tries to find a newer version of a given rock.
    /// Returns the latest version if found.
    pub async fn has_update(
        &self,
        package_db: &PackageDB,
    ) -> Result<Option<Version>, RockNotFound> {
        let latest_version = package_db
            .latest_version(self.name())
            .await
            .ok_or_else(|| RockNotFound(self.name().clone()))?;

        if self.version() < &latest_version {
            Ok(Some(latest_version))
        } else {
            Ok(None)
        }
    }

    /// Tries to find a newer version of a rock given a constraint.
    /// Returns the latest version if found.
    pub async fn has_update_with(
        &self,
        constraint: &Req,
        package_db: &PackageDB,
    ) -> Result<Option<Version>, RockConstraintUnsatisfied> {
        let latest_version = package_db
            .latest_match(constraint, None)
            .await
            .ok_or_else(|| RockConstraintUnsatisfied {
                name: self.name().clone(),
                constraint: constraint.version_req.clone(),
            })?;

        if self.version() < latest_version.version() {
            Ok(Some(latest_version.version().clone()))
        } else {
            Ok(None)
        }
    }
}

impl Display for Spec {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(format!("{} {}", self.name(), self.version()).as_str())
    }
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    use url::Url;

    use crate::{
        config::ConfigBuilder,
        manifest::{Manifest, ManifestMetadata},
        package::Spec,
        package_db::PackageDB,
    };

    #[tokio::test]
    async fn rock_has_update() {
        let test_manifest_path =
            PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("resources/test/manifest-5.1");
        let content = String::from_utf8(std::fs::read(&test_manifest_path).unwrap()).unwrap();
        let metadata = ManifestMetadata::new(&content).unwrap();
        let config = ConfigBuilder::new().unwrap().build().unwrap();
        let package_db = PackageDB::from_manifest(
            Manifest::new(
                Url::parse("https://example.com").unwrap(),
                metadata,
                Default::default(),
            ),
            &config,
        );

        let test_package = Spec::parse("lua-cjson".to_string(), "2.0.0".to_string()).unwrap();

        assert_eq!(
            test_package.has_update(&package_db).await.unwrap(),
            Some("2.1.0.10-1".parse().unwrap())
        );
    }
}