protofetch 0.1.17

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

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

use crate::{
    cli::command_handlers::{do_clean, do_fetch, do_init, do_lock, do_migrate},
    fetch::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,
}

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
    pub fn lock(&self, lock_mode: LockMode) -> Result<(), Box<dyn Error>> {
        do_lock(
            lock_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(())
    }
}