hit 0.2.0

Utilities for working with git.
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::Git;
use std::path::{Path, PathBuf};
use thiserror::Error;

#[derive(Debug, Error)]
pub enum Error {
    #[error("Failed to fetch repo: {0}")]
    FetchFailed(#[source] bossy::Error),
    #[error("Failed to get checkout revision: {0}")]
    RevParseLocalFailed(#[source] bossy::Error),
    #[error("Failed to get upstream revision: {0}")]
    RevParseRemoteFailed(#[source] bossy::Error),
    #[error("Failed to get commit log: {0}")]
    LogFailed(#[source] bossy::Error),
    #[error("Failed to create parent directory {path:?}: {source}")]
    ParentDirCreationFailed {
        path: PathBuf,
        source: std::io::Error,
    },
    #[error("Failed to clone repo: {0}")]
    CloneFailed(#[source] bossy::Error),
    #[error("Failed to reset repo: {0}")]
    ResetFailed(#[source] bossy::Error),
    #[error("Failed to clean repo: {0}")]
    CleanFailed(#[source] bossy::Error),
}

#[derive(Clone, Copy, Debug)]
pub enum Status {
    Stale,
    Fresh,
}

impl Status {
    pub fn stale(self) -> bool {
        matches!(self, Self::Stale)
    }
}

#[derive(Clone, Debug)]
pub struct Repo {
    path: PathBuf,
}

impl Repo {
    pub fn from_path(path: impl Into<PathBuf>) -> Self {
        Self { path: path.into() }
    }

    pub fn path(&self) -> &Path {
        &self.path
    }

    pub fn git(&self) -> Git<'_> {
        Git::new(self.path())
    }

    pub fn status(&self) -> Result<Status, Error> {
        let status = if !self.path().is_dir() {
            Status::Stale
        } else {
            let git = self.git();
            git.command_parse("fetch origin")
                .run_and_wait()
                .map_err(Error::FetchFailed)?;
            let local = git
                .command_parse("rev-parse HEAD")
                .run_and_wait_for_output()
                .map_err(Error::RevParseLocalFailed)?;
            let remote = git
                .command_parse("rev-parse @{u}")
                .run_and_wait_for_output()
                .map_err(Error::RevParseRemoteFailed)?;
            if local.stdout() != remote.stdout() {
                Status::Stale
            } else {
                Status::Fresh
            }
        };
        Ok(status)
    }

    pub fn latest_commit(&self, format: impl AsRef<str>) -> Result<String, Error> {
        self.git()
            .command_parse(format!("log -1 --pretty={}", format.as_ref()))
            .run_and_wait_for_str(|s| s.trim().to_owned())
            .map_err(Error::LogFailed)
    }

    pub fn latest_subject(&self) -> Result<String, Error> {
        self.latest_commit("%s")
    }

    pub fn latest_body(&self) -> Result<String, Error> {
        self.latest_commit("%b")
    }

    pub fn update(&self, url: impl AsRef<std::ffi::OsStr>) -> Result<(), Error> {
        let path = self.path();
        if !path.is_dir() {
            let parent = self
                .path()
                .parent()
                .expect("developer error: `Repo` path was at root");
            if !parent.is_dir() {
                std::fs::create_dir_all(parent).map_err(|source| {
                    Error::ParentDirCreationFailed {
                        path: parent.to_owned(),
                        source,
                    }
                })?;
            }
            Git::new(parent)
                .command_parse("clone --depth 1 --single-branch")
                .with_arg(url)
                .with_arg(path)
                .run_and_wait()
                .map_err(Error::CloneFailed)?;
        } else {
            println!(
                "Updating `{}` repo...",
                Path::new(
                    self.path()
                        .file_name()
                        .expect("developer error: `Repo` path had no file name")
                )
                .display()
            );
            self.git()
                .command_parse("fetch --depth 1")
                .run_and_wait()
                .map_err(Error::FetchFailed)?;
            self.git()
                .command_parse("reset --hard origin/master")
                .run_and_wait()
                .map_err(Error::ResetFailed)?;
            self.git()
                .command_parse("clean -dfx --exclude /target")
                .run_and_wait()
                .map_err(Error::CleanFailed)?;
        }
        Ok(())
    }
}