quickcfg 0.4.0

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
121
122
123
124

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

pub struct GitSystem {
    command: command::Command<'static>,
}

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> {
        match self.command.run(&["--version"]) {
            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> {
        use std::ffi::OsStr;

        let args = &[OsStr::new("clone"), OsStr::new(url), path.as_os_str()];
        self.command.run_checked(args)?;

        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<'static>,
}

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

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

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

    fn needs_update(&self) -> Result<bool, Error> {
        self.command
            .clone()
            .working_directory(self.path())
            .run_checked(&["fetch", "origin", "master"])?;

        let remote_head = self.rev_parse("FETCH_HEAD")?;
        let head = self.rev_parse("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 output = self
            .command
            .clone()
            .working_directory(self.path.as_path())
            .run(&["diff-index", "--quiet", "HEAD"])?;

        Ok(output.status.success())
    }

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

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