protofetch 0.1.20

A source dependency management tool for Protobuf.
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

pub mod error;
pub mod types;

#[cfg(feature = "git-backend-libgit2")]
pub mod libgit2;

#[cfg(feature = "git-backend-cli")]
pub mod cli;

use std::{
    panic::{RefUnwindSafe, UnwindSafe},
    path::{Path, PathBuf},
    str::FromStr,
};

use anyhow::bail;
use log::info;
use serde::Deserialize;

use error::GitBackendError;
use types::GitOid;

/// Per-repository operations. Obtained from a [`GitBackend`].
/// The implementing type stores the repository path internally.
pub trait GitRepository {
    fn remote_add(&self, name: &str, url: &str) -> Result<(), GitBackendError>;
    fn remote_get_url(&self, name: &str) -> Result<Option<String>, GitBackendError>;
    fn remote_set_url(&self, name: &str, url: &str) -> Result<(), GitBackendError>;
    fn fetch(&self, remote_name: &str, refspecs: &[String]) -> Result<(), GitBackendError>;
    fn commit_exists(&self, oid: &str) -> Result<bool, GitBackendError>;
    fn revparse_commit(&self, spec: &str) -> Result<GitOid, GitBackendError>;
    fn read_blob(&self, commit: &str, blob_path: &str) -> Result<Option<Vec<u8>>, GitBackendError>;
    /// Check if `ancestor` is an ancestor of `descendant`.
    fn is_ancestor(&self, ancestor: &GitOid, descendant: &GitOid) -> Result<bool, GitBackendError>;
    fn create_worktree(
        &self,
        name: &str,
        worktree_path: &Path,
        commit: &str,
    ) -> Result<WorktreeResult, GitBackendError>;
    /// Hard-reset the repository to a specific commit.
    fn reset(&self, commit: &str) -> Result<(), GitBackendError>;
}

/// Factory for opening or creating git repositories.
pub trait GitBackend: Send + Sync + UnwindSafe + RefUnwindSafe {
    /// Initialize a new bare repository at the given path and return a handle to it.
    fn init_bare(&self, path: &Path) -> Result<Box<dyn GitRepository>, GitBackendError>;

    /// Open an existing repository at the given path and return a handle to it.
    /// Returns an error if no repository exists there.
    fn open(&self, path: &Path) -> Result<Box<dyn GitRepository>, GitBackendError>;
}

/// Result of a worktree creation attempt.
pub enum WorktreeResult {
    /// A new worktree was created. The inner value is a repository handle for the worktree.
    Created(Box<dyn GitRepository>),
    /// An existing worktree was found at the given canonical path.
    Existing(PathBuf, Box<dyn GitRepository>),
}

impl std::fmt::Debug for WorktreeResult {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            WorktreeResult::Created(_) => write!(f, "Created(..)"),
            WorktreeResult::Existing(p, _) => write!(f, "Existing({:?}, ..)", p),
        }
    }
}

/// The type of git backend to use.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
pub enum GitBackendType {
    #[cfg(feature = "git-backend-libgit2")]
    #[serde(rename = "libgit2")]
    Libgit2,
    #[cfg(feature = "git-backend-cli")]
    #[serde(rename = "cli")]
    Cli,
}

impl GitBackendType {
    #[allow(unreachable_code)]
    pub fn try_default() -> anyhow::Result<Self> {
        #[cfg(feature = "git-backend-libgit2")]
        return Ok(GitBackendType::Libgit2);

        #[cfg(feature = "git-backend-cli")]
        return Ok(GitBackendType::Cli);

        bail!("No git backend is enabled. Please enable at least one of `git-backend-libgit2` or `git-backend-cli` features.");
    }
}

impl FromStr for GitBackendType {
    type Err = anyhow::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            #[cfg(feature = "git-backend-libgit2")]
            "libgit2" => Ok(GitBackendType::Libgit2),
            #[cfg(feature = "git-backend-cli")]
            "cli" => Ok(GitBackendType::Cli),
            _ => bail!("invalid git backend type: {s}"),
        }
    }
}

/// Create a git backend of the specified type.
pub fn create_backend(
    backend_type: GitBackendType,
    git_executable: Option<String>,
) -> Box<dyn GitBackend> {
    match backend_type {
        #[cfg(feature = "git-backend-libgit2")]
        GitBackendType::Libgit2 => {
            info!("Using libgit2 git backend");
            Box::new(libgit2::Libgit2Backend::new())
        }
        #[cfg(feature = "git-backend-cli")]
        GitBackendType::Cli => {
            info!("Using git CLI backend");
            Box::new(cli::CliBackend::new(
                git_executable.unwrap_or_else(|| "git".to_string()),
            ))
        }
    }
}