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
130
131
132
133
134
135
136
137
138
139
140

use std::{
    error::Error,
    path::{Path, PathBuf},
    sync::Arc,
};

use crate::{
    cli::command_handlers::{do_clean, do_fetch, do_init, do_lock, do_migrate},
    engine::ParallelConfig,
    git::cache::ProtofetchGitCache,
};

mod builder;

pub use builder::ProtofetchBuilder;

pub struct Protofetch {
    cache: Arc<ProtofetchGitCache>,
    root: PathBuf,
    module_file_name: PathBuf,
    lock_file_name: PathBuf,
    output_directory_name: Option<PathBuf>,
    parallel: ParallelConfig,
}

#[allow(dead_code)]
fn _assert_protofetch_auto_traits() {
    fn assert<T: Send + Sync + std::panic::UnwindSafe + std::panic::RefUnwindSafe>() {}
    assert::<Protofetch>();
}

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
pub enum LockMode {
    /// Verify that the lock file is up to date. This mode should be normally used on CI.
    Locked,
    /// Update the lock file if necessary.
    Update,
    /// Recreate the lock file from scratch.
    Recreate,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub enum LockUpdateMode {
    /// Verify that the lock file is up to date.
    Verify,
    /// Reconcile the lock file with the current module descriptor, updating it if necessary.
    Reconcile,
    /// Reconcile the lock file and update the selected dependencies, keeping other locked entries pinned.
    ReconcileAndUpdate(Vec<DependencyUpdate>),
    /// Recreate the lock file from scratch, updating all dependencies.
    Full,
}

#[derive(Debug, PartialEq, Eq, Clone)]
pub enum DependencyUpdate {
    Latest { name: String },
    Precise { name: String, commit_hash: String },
}

impl From<LockMode> for LockUpdateMode {
    fn from(lock_mode: LockMode) -> Self {
        match lock_mode {
            LockMode::Locked => LockUpdateMode::Verify,
            LockMode::Update => LockUpdateMode::Reconcile,
            LockMode::Recreate => LockUpdateMode::Full,
        }
    }
}

impl Protofetch {
    pub fn builder() -> ProtofetchBuilder {
        ProtofetchBuilder::default()
    }

    /// Creates an initial protofetch setup
    pub fn init(&self, name: Option<String>) -> Result<(), Box<dyn Error>> {
        do_init(&self.root, name, &self.module_file_name)
    }

    /// Fetches dependencies defined in the toml configuration file
    pub fn fetch(&self, lock_mode: LockMode) -> Result<(), Box<dyn Error>> {
        do_fetch(
            lock_mode,
            self.cache.clone(),
            &self.root,
            &self.module_file_name,
            &self.lock_file_name,
            self.output_directory_name.as_deref(),
            self.parallel,
        )
    }

    /// Creates, updates or verifies a lock file based on the toml configuration file.
    #[deprecated(note = "use Protofetch::update instead")]
    pub fn lock(&self, lock_mode: LockMode) -> Result<(), Box<dyn Error>> {
        self.update(lock_mode.into())
    }

    /// Creates, updates or verifies a lock file based on the toml configuration file.
    pub fn update(&self, lock_update_mode: LockUpdateMode) -> Result<(), Box<dyn Error>> {
        do_lock(
            lock_update_mode,
            self.cache.clone(),
            &self.root,
            &self.module_file_name,
            &self.lock_file_name,
            self.parallel,
        )?;
        Ok(())
    }

    /// Migrates a protodep.toml file to the protofetch format
    pub fn migrate(
        &self,
        name: Option<String>,
        source_directory_path: impl AsRef<Path>,
    ) -> Result<(), Box<dyn Error>> {
        do_migrate(
            &self.root,
            name,
            &self.module_file_name,
            source_directory_path.as_ref(),
        )
    }

    /// Delete generated proto sources and the lock file
    pub fn clean(&self) -> Result<(), Box<dyn Error>> {
        do_clean(
            &self.root,
            &self.module_file_name,
            &self.lock_file_name,
            self.output_directory_name.as_deref(),
        )
    }

    pub fn clear_cache(&self) -> Result<(), Box<dyn Error>> {
        self.cache.clear()?;
        Ok(())
    }
}