repoke 0.2.1

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

use std::path::Path;

use super::node_versions::{self, Version};
use crate::manager::{Installed, Manager, Package, Step, capture};

pub struct Fnm;

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

    fn name(&self) -> &'static str {
        "fnm (Node.js)"
    }

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

    fn outdated(&self, bin: &Path) -> Result<Vec<Package>, String> {
        let (installed, _) = parse_list(&capture(bin, ["list"])?.expect(&[0])?);
        let remote: Vec<Version> = capture(bin, ["ls-remote"])?
            .expect(&[0])?
            .lines()
            .filter_map(|l| l.split_whitespace().next().and_then(node_versions::parse))
            .collect();
        Ok(node_versions::outdated(&installed, &remote))
    }

    /// fnm keeps globals per Node version, so they are reinstalled on the new one.
    fn upgrade_steps(&self, bin: &Path, packages: &[Package]) -> Vec<Step> {
        let default = capture(bin, ["list"])
            .and_then(|o| o.expect(&[0]))
            .ok()
            .and_then(|list| parse_list(&list).1);
        packages
            .iter()
            .map(|p| {
                let latest = p.latest.clone();
                let mut commands = vec![vec!["install".to_string(), latest.clone()]];
                if default.is_some_and(|d| Some(d[0]) == node_versions::major(p)) {
                    commands.push(vec!["default".to_string(), latest.clone()]);
                }
                // Globals live in the version in use, which is the default when it is on this line.
                let source = default
                    .filter(|d| Some(d[0]) == node_versions::major(p))
                    .map_or(p.current.clone(), node_versions::show);
                let globals = globals(bin, &source);
                if !globals.is_empty() {
                    let mut install = vec![
                        "exec".to_string(),
                        format!("--using={latest}"),
                        "npm".to_string(),
                        "install".to_string(),
                        "--global".to_string(),
                    ];
                    install.extend(globals);
                    commands.push(install);
                }
                Step {
                    commands,
                    packages: vec![p.clone()],
                }
            })
            .collect()
    }

    /// The newest installed version of each major line; the default line is marked.
    fn installed(&self, bin: &Path) -> Result<Vec<Installed>, String> {
        let (installed, default) = parse_list(&capture(bin, ["list"])?.expect(&[0])?);
        Ok(node_versions::lines(&installed, default))
    }

    fn install_steps(&self, _bin: &Path, packages: &[Installed]) -> Vec<Step> {
        packages
            .iter()
            .filter_map(|p| {
                let major = p.name.strip_prefix("node@")?.to_string();
                let mut commands = vec![vec!["install".to_string(), major.clone()]];
                if p.is("default") {
                    commands.push(vec!["default".to_string(), major]);
                }
                Some(Step {
                    commands,
                    packages: vec![Package::from(p)],
                })
            })
            .collect()
    }
}

/// Lines look like `* v22.13.1 default, lts-latest`.
fn parse_list(text: &str) -> (Vec<Version>, Option<Version>) {
    let mut installed = Vec::new();
    let mut default = None;
    for line in text.lines() {
        if let Some(version) = line.split_whitespace().find_map(node_versions::parse) {
            installed.push(version);
            if line.contains("default") {
                default = Some(version);
            }
        }
    }
    (installed, default)
}

fn globals(bin: &Path, version: &str) -> Vec<String> {
    let using = format!("--using={version}");
    let args = [&using, "npm", "ls", "--global", "--depth=0", "--json"];
    capture(bin, ["exec"].into_iter().chain(args))
        .and_then(|o| o.expect(&[0]))
        .and_then(|json| super::npm::parse_globals(&json))
        .map(|globals| globals.into_iter().map(|g| g.name).collect())
        .unwrap_or_default()
}

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

    #[test]
    fn parses_installed_versions_and_default() {
        let list = "* v18.18.0\n* v22.13.1 default, lts-latest\n* v24.15.0\n* system\n";
        let (installed, default) = parse_list(list);
        assert_eq!(installed, [[18, 18, 0], [22, 13, 1], [24, 15, 0]]);
        assert_eq!(default, Some([22, 13, 1]));
    }
}