git-alias 1.0.0

A fast git alias tool with dual-style command support
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::collections::HashMap;
use std::fs;
use std::path::PathBuf;

#[derive(Debug, Clone)]
pub struct Config {
    pub aliases: HashMap<String, Vec<String>>,
    pub main_branch: String,
    pub verbose: bool,
}

impl Default for Config {
    fn default() -> Self {
        Self {
            aliases: HashMap::new(),
            main_branch: "main".to_string(),
            verbose: false,
        }
    }
}

pub fn load_config() -> Config {
    let config_path = get_config_path();
    
    if !config_path.exists() {
        return Config::default();
    }

    let content = match fs::read_to_string(&config_path) {
        Ok(c) => c,
        Err(_) => return Config::default(),
    };

    let config: toml::Value = match content.parse() {
        Ok(c) => c,
        Err(_) => return Config::default(),
    };

    let mut result = Config::default();

    if let Some(aliases) = config.get("aliases") {
        if let Some(table) = aliases.as_table() {
            for (key, value) in table {
                if let Some(arr) = value.as_array() {
                    let cmd: Vec<String> = arr.iter()
                        .filter_map(|v| v.as_str().map(|s| s.to_string()))
                        .collect();
                    if !cmd.is_empty() {
                        result.aliases.insert(key.clone(), cmd);
                    }
                }
            }
        }
    }

    if let Some(settings) = config.get("settings") {
        if let Some(branch) = settings.get("main_branch") {
            if let Some(s) = branch.as_str() {
                result.main_branch = s.to_string();
            }
        }
        if let Some(verbose) = settings.get("verbose") {
            if let Some(v) = verbose.as_bool() {
                result.verbose = v;
            }
        }
    }

    result
}

fn get_config_path() -> PathBuf {
    let mut path = dirs::home_dir().unwrap_or_else(|| PathBuf::from("."));
    path.push(".git-alias.toml");
    path
}

pub fn create_default_config() -> Result<(), String> {
    let config_path = get_config_path();
    
    if config_path.exists() {
        return Err("Config file already exists".to_string());
    }

    let default_config = r#"# Git-Short Configuration File

[aliases]
# Add your custom aliases here
# Example:
# my = ["status", "-s", "-b"]
# pushf = ["push", "--force-with-lease"]

[settings]
# Default branch name
main_branch = "main"

# Verbose mode (show executed command)
verbose = false
"#;

    fs::write(&config_path, default_config)
        .map_err(|e| format!("Failed to create config file: {}", e))?;

    println!("Created config file at: {}", config_path.display());
    Ok(())
}