repoke 0.7.0

Finds the package managers on your system and keeps them up to date, interactively or unattended
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

use std::path::Path;

use serde::Deserialize;

use super::table;

use crate::manager::{Installed, Manager, Package, Step, capture};

pub struct Scoop;

impl Manager for Scoop {
    fn id(&self) -> &'static str {
        "scoop"
    }

    fn name(&self) -> &'static str {
        "Scoop"
    }

    fn binary(&self) -> &'static str {
        "scoop"
    }

    fn supported(&self) -> bool {
        cfg!(windows)
    }

    fn outdated(&self, bin: &Path) -> Result<Vec<Package>, String> {
        Ok(parse_status(&capture(bin, ["status"])?.expect(&[0])?))
    }

    /// Without app names, `scoop update` updates scoop itself and its buckets.
    fn has_refresh(&self) -> bool {
        true
    }

    fn refresh(&self, bin: &Path) -> Result<(), String> {
        capture(bin, ["update"])?.expect(&[0]).map(drop)
    }

    fn upgrade_steps(&self, _bin: &Path, packages: &[Package]) -> Vec<Step> {
        let names = packages.iter().map(|p| p.name.clone());
        vec![Step::new(
            ["update".to_string()].into_iter().chain(names),
            packages,
        )]
    }

    /// Buckets first (as `bucket:<name>`), then apps with their bucket as `kind`.
    fn installed(&self, bin: &Path) -> Result<Vec<Installed>, String> {
        parse_export(&capture(bin, ["export"])?.expect(&[0])?)
    }

    fn install_steps(&self, _bin: &Path, packages: &[Installed]) -> Vec<Step> {
        packages
            .iter()
            .map(|p| match p.kind.as_deref() {
                Some("bucket") => {
                    Step::install(["bucket", "add", &p.name], std::slice::from_ref(p))
                }
                Some(bucket) => Step::install(
                    ["install", &format!("{bucket}/{}", p.name)],
                    std::slice::from_ref(p),
                ),
                None => Step::install(["install", &p.name], std::slice::from_ref(p)),
            })
            .collect()
    }
}

/// Columns: Name, Installed Version, Latest Version, Missing Dependencies, Info.
fn parse_status(text: &str) -> Vec<Package> {
    table::parse(text)
        .into_iter()
        .filter_map(|row| {
            let latest = row.get(2).filter(|v| !v.is_empty())?;
            Some(Package {
                name: row.first()?.clone(),
                current: row.get(1).cloned().unwrap_or_default(),
                latest: latest.clone(),
            })
        })
        .collect()
}

#[derive(Deserialize)]
struct Export {
    #[serde(default)]
    buckets: Vec<Bucket>,
    #[serde(default)]
    apps: Vec<App>,
}

#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
struct Bucket {
    name: String,
}

#[derive(Deserialize)]
#[serde(rename_all = "PascalCase")]
struct App {
    name: String,
    #[serde(default)]
    version: String,
    #[serde(default)]
    source: String,
}

/// `main` is scoop's own bucket and needs no `bucket add`.
fn parse_export(json: &str) -> Result<Vec<Installed>, String> {
    let export: Export =
        serde_json::from_str(json).map_err(|e| format!("unexpected scoop export: {e}"))?;
    let buckets = export
        .buckets
        .into_iter()
        .filter(|b| b.name != "main")
        .map(|b| Installed::new(b.name).kind("bucket"));
    let apps = export.apps.into_iter().map(|a| {
        let app = Installed::new(a.name).version(a.version);
        if a.source.is_empty() || a.source == "main" {
            app
        } else {
            app.kind(a.source)
        }
    });
    Ok(buckets.chain(apps).collect())
}

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

    #[test]
    fn parses_status_table() {
        let text = "Scoop is up to date.\n\nName    Installed Version Latest Version Missing Dependencies Info\n----    ----------------- -------------- -------------------- ----\ngit     2.46.0            2.47.0\n7zip    24.07                                                 Held package\n";
        let packages = parse_status(text);
        assert_eq!(packages.len(), 1);
        assert_eq!(packages[0].name, "git");
        assert_eq!(packages[0].latest, "2.47.0");
    }
}