quickcfg 0.6.3

Do basic configuration of a system, declaratively and quickly.
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

use crate::{command, os};
use anyhow::Error;
use std::io;
use std::path::{Path, PathBuf};

pub struct GitSystem {
    command: command::Command,
}

impl GitSystem {
    pub fn new() -> Self {
        Self {
            command: command::Command::new(os::command("git")),
        }
    }
}

impl super::GitSystem for GitSystem {
    fn test(&self) -> Result<bool, Error> {
        let mut command = self.command.clone();
        command.arg("--version");

        match command.run() {
            Ok(output) => Ok(output.status.success()),
            Err(e) => match e.kind() {
                io::ErrorKind::NotFound => Ok(false),
                _ => Err(e.into()),
            },
        }
    }

    fn clone(&self, url: &str, path: &Path) -> Result<Box<dyn super::Git>, Error> {
        let mut command = self.command.clone();
        command.arg("clone");
        command.arg(url);
        command.arg(path);
        command.run_checked()?;

        Ok(Box::new(External {
            path: path.to_owned(),
            command: self.command.clone(),
        }))
    }

    fn open(&self, path: &Path) -> Result<Box<dyn super::Git>, Error> {
        Ok(Box::new(External {
            path: path.to_owned(),
            command: self.command.clone(),
        }))
    }
}

/// Helper to interact with a git repository through an external command.
#[derive(Debug)]
struct External {
    pub path: PathBuf,
    command: command::Command,
}

impl External {
    fn rev_parse(&self, git_ref: &str) -> Result<String, Error> {
        let mut command = self.command.clone();
        command.working_directory(&self.path);
        command.args(&["rev-parse", git_ref]);
        Ok(command.run_stdout()?.trim().to_string())
    }

    /// Find the merge base between two commits.
    fn merge_base(&self, a: &str, b: &str) -> Result<String, Error> {
        let mut command = self.command.clone();
        command.working_directory(&self.path);
        command.args(&["merge-base", a, b]);
        Ok(command.run_stdout()?.trim().to_string())
    }
}

impl super::Git for External {
    fn path(&self) -> &Path {
        &self.path
    }

    fn needs_update(&self) -> Result<bool, Error> {
        let head = self.rev_parse("HEAD")?;

        let mut command = self.command.clone();
        command.working_directory(self.path());
        command.args(&["fetch", "origin", head.as_str()]);
        command.run_checked()?;

        let remote_head = self.rev_parse("FETCH_HEAD")?;

        if remote_head != head {
            // check if remote is a base
            return Ok(self.merge_base(&remote_head, &head)? != remote_head);
        }

        Ok(false)
    }

    fn is_fresh(&self) -> Result<bool, Error> {
        let mut command = self.command.clone();
        command.working_directory(&self.path);
        command.args(&["diff-index", "--quiet", "HEAD"]);
        Ok(command.status()?.success())
    }

    fn force_update(&self) -> Result<(), Error> {
        let mut command = self.command.clone();
        command.working_directory(&self.path);
        command.args(&["reset", "--hard", "FETCH_HEAD"]);
        command.run_checked()
    }

    fn update(&self) -> Result<(), Error> {
        let mut command = self.command.clone();
        command.working_directory(&self.path);
        command.args(&["merge", "--ff-only", "FETCH_HEAD"]);
        command.run_checked()
    }
}