os-xtask-utils 0.0.0

Program executation for xtask in os or bootloader project
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

use crate::{ext, CommandExt};
use std::{ffi::OsStr, path::PathBuf, process::Command};

ext!(def; Git);

impl Git {
    fn new(sub: impl AsRef<OsStr>) -> Self {
        let mut git = Self(Command::new("git"));
        git.arg(sub);
        git
    }

    pub fn lfs() -> Self {
        Self::new("lfs")
    }

    pub fn config(global: bool) -> Self {
        let mut git = Self::new("config");
        git.option(global.then_some("--global"));
        git
    }

    pub fn clone(repo: impl AsRef<str>) -> GitCloneContext {
        GitCloneContext {
            repo: repo.as_ref().into(),
            dir: None,
            branch: None,
            single_branch: false,
            depth: usize::MAX,
        }
    }

    pub fn pull() -> Self {
        Self::new("pull")
    }

    pub fn submodule_update(init: bool) -> Self {
        let mut git = Self::new("submodule");
        git.arg("update").option(init.then_some("--init"));
        git
    }
}

pub struct GitCloneContext {
    repo: String,
    dir: Option<PathBuf>,
    branch: Option<String>,
    single_branch: bool,
    depth: usize,
}

impl GitCloneContext {
    #[inline]
    pub fn dir(mut self, path: PathBuf) -> Self {
        self.dir = Some(path);
        self
    }

    #[inline]
    pub fn branch(mut self, branch: impl AsRef<str>) -> Self {
        self.branch = Some(branch.as_ref().into());
        self
    }

    #[inline]
    pub fn single_branch(mut self) -> Self {
        self.single_branch = true;
        self
    }

    #[inline]
    pub fn depth(mut self, depth: usize) -> Self {
        self.depth = depth;
        self
    }

    pub fn done(self) -> Git {
        let mut git = Git::new("clone");
        git.arg(self.repo);
        if let Some(dir) = self.dir {
            git.arg(dir);
        }
        if let Some(branch) = self.branch {
            git.args(["--branch", &branch]);
        }
        if self.single_branch {
            git.arg("--single-branch");
        }
        if self.depth != usize::MAX {
            git.arg(format!("--depth={}", self.depth));
        }
        git
    }
}