gitsync 0.2.1

Library that facilitates monitoring Git repositories for changes. Could enable GitOps
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

use std::{error::Error, fmt, path::PathBuf};

#[derive(Debug)]
pub enum GitSyncError {
    IncorrectGitRemotes {
        dir: PathBuf,
        expected: String,
        actual: String,
    },
    CurrentBranchUnknown {
        dir: PathBuf,
    },
    WorkTreeNotClean,
    FastForwardMergeNotPossible,
    GixError {
        error: Box<dyn Error + Send + Sync>,
    },
    GitCommandError {
        command: String,
        stderr: String,
    },
    GenericError {
        error: std::io::Error,
    },
}

impl fmt::Display for GitSyncError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            GitSyncError::IncorrectGitRemotes {
                dir,
                expected,
                actual,
            } => {
                write!(
                    f,
                    "A directory already exists at {} and is a Git repository, but we expected the remote to be {} and got {}.",
                    dir.display(),
                    expected,
                    actual
                )
            }

            GitSyncError::CurrentBranchUnknown { dir } => {
                write!(
                    f,
                    "The repository at {} is not on a named branch. Set GitSync::branch before syncing.",
                    dir.display()
                )
            }

            GitSyncError::FastForwardMergeNotPossible => {
                write!(f, "Can't fast-forward merge")
            }

            GitSyncError::WorkTreeNotClean => {
                write!(f, "The worktree isn't clean. Refusing to sync")
            }

            GitSyncError::GixError { error } => {
                write!(f, "There was an error reported by gix: {error}")
            }

            GitSyncError::GitCommandError { command, stderr } => {
                write!(f, "Git command `{command}` failed: {stderr}")
            }

            GitSyncError::GenericError { error } => {
                write!(f, "There was an IO error: {error}")
            }
        }
    }
}

impl Error for GitSyncError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            GitSyncError::GixError { error } => Some(error.as_ref()),
            GitSyncError::GenericError { error } => Some(error),
            GitSyncError::GitCommandError { .. } => None,
            _ => None,
        }
    }
}

impl GitSyncError {
    pub fn from_gix(error: impl Error + Send + Sync + 'static) -> Self {
        GitSyncError::GixError {
            error: Box::new(error),
        }
    }
}