rtx-cli 1.3.0

Polyglot runtime manager (asdf rust clone)
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

use std::fs::create_dir_all;
use std::path::PathBuf;

use color_eyre::eyre::Result;

use crate::cmd;
use crate::file::touch_dir;

pub struct Git {
    pub dir: PathBuf,
}

impl Git {
    pub fn new(dir: PathBuf) -> Self {
        Self { dir }
    }

    pub fn is_repo(&self) -> bool {
        self.dir.join(".git").is_dir()
    }

    pub fn remote_default_branch(&self) -> Result<String> {
        let branch = cmd!(
            "git",
            "-C",
            &self.dir,
            "symbolic-ref",
            "refs/remotes/origin/HEAD"
        )
        .read()?;

        let branch = branch.rsplit_once('/').unwrap().1;
        Ok(branch.to_string())
    }

    pub fn update(&self, gitref: Option<String>) -> Result<(String, String)> {
        let gitref = gitref.map_or_else(|| self.remote_default_branch(), Ok)?;
        debug!("updating {} to {}", self.dir.display(), gitref);
        cmd!(
            "git",
            "-C",
            &self.dir,
            "fetch",
            "--prune",
            "--update-head-ok",
            "origin",
            [gitref.as_str(), gitref.as_str()].join(":"),
        )
        .run()?;
        let prev_rev = self.current_sha()?;
        cmd!(
            "git",
            "-C",
            &self.dir,
            "-c",
            "advice.detachedHead=false",
            "-c",
            "advice.objectNameWarning=false",
            "checkout",
            "--force",
            gitref
        )
        .run()?;
        let post_rev = self.current_sha()?;
        touch_dir(&self.dir)?;

        Ok((prev_rev, post_rev))
    }

    pub fn clone(&self, url: &str) -> Result<()> {
        debug!("cloning {} to {}", url, self.dir.display());
        if let Some(parent) = self.dir.parent() {
            create_dir_all(parent)?;
        }
        match get_git_version() {
            Ok(version) => trace!("git version: {}", version),
            Err(err) => warn!(
                "failed to get git version: {}\n Git is required to use rtx.",
                err
            ),
        }
        cmd!("git", "clone", "-q", "--depth", "1", url, &self.dir).run()?;
        Ok(())
    }

    pub fn current_sha(&self) -> Result<String> {
        let sha = cmd!("git", "-C", &self.dir, "rev-parse", "HEAD").read()?;
        debug!("current sha for {}: {}", self.dir.display(), &sha);
        Ok(sha)
    }

    pub fn get_remote_url(&self) -> Option<String> {
        let res = cmd!(
            "git",
            "-C",
            &self.dir,
            "config",
            "--get",
            "remote.origin.url"
        )
        .read();
        match res {
            Ok(url) => {
                debug!("remote url for {}: {}", self.dir.display(), &url);
                Some(url)
            }
            Err(err) => {
                warn!(
                    "failed to get remote url for {}: {}",
                    self.dir.display(),
                    err
                );
                None
            }
        }
    }
}

fn get_git_version() -> Result<String> {
    let version = cmd!("git", "--version").read()?;
    Ok(version.trim().into())
}

#[cfg(test)]
mod tests {
    use tempfile::tempdir;

    use super::*;

    #[test]
    fn test_clone_and_update() {
        let dir = tempdir().unwrap().into_path();
        let git = Git::new(dir);
        git.clone("https://github.com/asdf-vm/asdf-plugins")
            .unwrap();
        let prev_rev = "f4b510d1d0c01ab2da95b80a1c1521f651cdd708".to_string();
        let latest = git.current_sha().unwrap();
        let update_result = git.update(Some(prev_rev.clone())).unwrap();
        assert_eq!(update_result, (latest.to_string(), prev_rev.to_string()));
        let update_result = git.update(None).unwrap();
        assert_eq!(update_result, (prev_rev, latest));
    }
}