git-skel 0.1.1

a git subcommand to apply skeleton repository continuously
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

use crate::error::ErrorKind;
use failure::{bail, Error, ResultExt};
use git2::{Commit, Repository};
use serde_derive::{Deserialize, Serialize};
use std::fs;
use std::io::Read;
use std::path::{Path, PathBuf};

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Config {
    pub url: String,
    pub branch: Option<String>,
    pub tag: Option<String>,
    pub revision: String,
}

impl Config {
    pub fn new<T: AsRef<str>>(url: T, branch: Option<T>, tag: Option<T>, commit: &Commit) -> Self {
        Config {
            url: String::from(url.as_ref()),
            branch: branch.map(|x| String::from(x.as_ref())),
            tag: tag.map(|x| String::from(x.as_ref())),
            revision: format!("{}", commit.id()),
        }
    }

    pub fn set_branch(&mut self, branch: &str) {
        self.branch = Some(String::from(branch));
        self.tag = None;
    }

    pub fn set_tag(&mut self, tag: &str) {
        self.branch = None;
        self.tag = Some(String::from(tag));
    }

    pub fn set_commit(&mut self, commit: &Commit) {
        self.revision = format!("{}", commit.id());
    }

    pub fn load(tgt: &Repository) -> Result<Config, Error> {
        let tgt_root = PathBuf::from(tgt.workdir().unwrap());
        let config_path = tgt_root.join(".gitskel.toml");

        fn load_file(path: &Path) -> Result<Config, Error> {
            let mut f = fs::File::open(path)?;
            let mut s = String::new();
            let _ = f.read_to_string(&mut s);
            let config = toml::from_str(&s)?;
            Ok(config)
        }

        let config = load_file(&config_path).context(ErrorKind::ConfigLoad(
            config_path.to_string_lossy().to_string(),
        ))?;
        Ok(config)
    }

    pub fn save(&self, tgt: &Repository) -> Result<(), Error> {
        let tgt_root = PathBuf::from(tgt.workdir().unwrap());
        let config_path = tgt_root.join(".gitskel.toml");

        fs::write(&config_path, toml::to_string(self)?).context(ErrorKind::ConfigSave(
            config_path.to_string_lossy().to_string(),
        ))?;

        Ok(())
    }

    pub fn delete(tgt: &Repository) -> Result<(), Error> {
        let tgt_root = PathBuf::from(tgt.workdir().unwrap());
        let config_path = tgt_root.join(".gitskel.toml");

        fs::remove_file(config_path)?;

        Ok(())
    }

    pub fn check(tgt: &Repository) -> Result<(), Error> {
        let tgt_root = PathBuf::from(tgt.workdir().unwrap());
        let config_path = tgt_root.join(".gitskel.toml");

        if config_path.exists() {
            bail!(ErrorKind::AbortByConfigExist(
                config_path.to_string_lossy().to_string()
            ));
        } else {
            Ok(())
        }
    }
}