gitquick 0.2.0

Command line tool that simplifies common git workflows.
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
141

use std::{
    fs,
    io::{self, Write},
    path::PathBuf,
};

use directories::ProjectDirs;
use serde::{Deserialize, Serialize};

use crate::ConfigArgs;

#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(default)]
pub struct Config {
    pub commit: Commit,
    pub branch: Branch,
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(default)]
pub struct Commit {
    pub conventional: bool,
    pub ticket: bool,
    pub types: Vec<String>,
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(default)]
pub struct Branch {
    pub conventional: bool,
    pub types: Vec<String>,
}

impl Default for Commit {
    fn default() -> Self {
        Self {
            conventional: false,
            ticket: false,
            types: vec![
                "build".into(),
                "ci".into(),
                "docs".into(),
                "feat".into(),
                "fix".into(),
                "perf".into(),
                "refactor".into(),
                "style".into(),
                "test".into(),
                "revert".into(),
            ],
        }
    }
}

impl Default for Branch {
    fn default() -> Self {
        Self {
            conventional: false,
            types: vec![
                "feature".into(),
                "bugfix".into(),
                "hotfix".into(),
                "release".into(),
                "chore".into(),
            ],
        }
    }
}

pub fn load_config() -> Config {
    let config_path = get_config_path();

    if let Ok(config_content) = fs::read_to_string(&config_path) {
        toml::from_str(&config_content).expect("Failed to parse config")
    } else {
        let config = Config::default();
        let _ = save_config(&config, &config_path);
        config
    }
}

pub fn run_config(args: &ConfigArgs) -> Result<(), String> {
    let mut config = load_config();
    let config_path = get_config_path();
    let setting: Vec<&str> = args.key.split('.').collect();
    if setting.len() != 2 {
        return Err("Key format must be <section>.<field>".into());
    }
    let (section, field) = (setting[0], setting[1]);

    match section {
        "commit" => match field {
            "conventional" => set_bool(&mut config.commit.conventional, &args.value)?,
            "ticket" => set_bool(&mut config.commit.ticket, &args.value)?,
            "types" => set_vec(&mut config.commit.types, &args.value)?,
            _ => return Err(format!("Unknown commit setting '{}'", field)),
        },

        "branch" => match field {
            "conventional" => set_bool(&mut config.branch.conventional, &args.value)?,
            "types" => set_vec(&mut config.branch.types, &args.value)?,
            _ => return Err(format!("Unknown branch setting '{}'", field)),
        },

        _ => return Err(format!("Unknown section '{}'", section)),
    }
    save_config(&config, &config_path).map_err(|e| format!("Failed to save config: {}", e))?;
    println!("✅ Config created successfuly!");
    Ok(())
}

fn set_bool(target: &mut bool, value: &str) -> Result<(), String> {
    match value.to_lowercase().as_str() {
        "1" | "true" => *target = true,
        "0" | "false" => *target = false,
        _ => return Err("Value must be boolean".into()),
    }
    Ok(())
}

fn set_vec(target: &mut Vec<String>, value: &str) -> Result<(), String> {
    *target = value.split(',').map(|s| s.trim().to_string()).collect();
    Ok(())
}

fn get_config_path() -> PathBuf {
    let proj_dirs = ProjectDirs::from("", "", "gitquick").expect("Failed to get project directory");

    let directory = proj_dirs.config_dir();
    directory.join("config.toml")
}

fn save_config(config: &Config, config_path: &PathBuf) -> io::Result<()> {
    if let Some(directory) = config_path.parent() {
        fs::create_dir_all(directory)?
    };
    let content = toml::to_string(config).unwrap();
    let mut file = fs::File::create(config_path)?;
    file.write_all(content.as_bytes())?;
    Ok(())
}