simple-commit 1.0.2

A little CLI written in rust to improve your dirty commits into conventional ones. 
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

use clap::Parser;
use directories::BaseDirs;
use merge2::Merge;
use serde::{Deserialize, Serialize};
use std::env::current_dir;
use std::fs;
use std::path::PathBuf;

use crate::tui::structs::Scope;

mod handle_config;

#[inline]
pub fn swap_option<T>(left: &mut Option<T>, right: &mut Option<T>) {
    if left.is_none() || right.is_some() {
        core::mem::swap(left, right);
    }
}

#[derive(Parser)]
/// Cli config settings.
pub struct CliConfig {
    #[clap(long, help = "set custom path to load config.")]
    config: Option<PathBuf>,

    #[clap(flatten)]
    sc_config: SimpleCommitsConfig,
}

/// File settings for customizing the bin.
#[derive(Default, Serialize, Deserialize, Parser, Merge)]
pub struct SimpleCommitsConfig {
    #[merge(skip)]
    #[serde(skip)]
    #[clap(skip)]
    config: PathBuf,

    #[clap(skip)]
    #[serde(flatten)]
    #[merge(strategy = swap_option)]
    pub scopes: Option<Scope>,

    #[clap(flatten)]
    #[merge(strategy = swap_option)]
    pub git: Option<GitConfig>,
}

/// Configs to run git commands
#[derive(Clone, Default, Serialize, Deserialize, Parser, Merge)]
pub struct GitConfig {
    /// Confirm before to run git commit
    #[arg(short = 'p', long = "skip-preview")]
    pub skip_preview: bool,

    /// Confirm before to run git commit
    #[arg(short = 'e', long = "skip-emojis")]
    pub skip_emojis: bool,

    /// Command to run after generate commit message
    #[clap(long, short)]
    #[merge(strategy = swap_option)]
    pub commit_template: Option<Vec<String>>,
}

impl SimpleCommitsConfig {
    pub fn update(&self) -> std::io::Result<()> {
        let updated = toml::to_string_pretty(&self).unwrap();
        fs::write(&self.config, updated)?;
        Ok(())
    }
}

pub fn get_config() -> SimpleCommitsConfig {
    let mut args = CliConfig::parse();
    let mut config = SimpleCommitsConfig::default();

    // load custom path if exists or load global config
    // check if the config path was provided.

    let config_path = args.config.unwrap_or_else(|| {
        let path = BaseDirs::new().unwrap().config_dir().join("sc");
        // create directory if not exists
        std::fs::create_dir_all(path.clone()).unwrap();
        path.join("config.toml")
    });

    // Load Global
    if let Ok(cfg_content) = std::fs::read_to_string(&config_path) {
        let mut g_config: SimpleCommitsConfig = toml::from_str(&cfg_content).unwrap();
        config.merge(&mut g_config);
        config.config = config_path;
    }

    let config_path = current_dir()
        .expect("Cannot get current directory")
        .join("sc.toml");

    // Load Local
    // TODO: make recursive search root path
    // The idea is find `.git` folder and use that as root path
    if let Ok(cfg_content) = std::fs::read_to_string(&config_path) {
        let mut l_config: SimpleCommitsConfig = toml::from_str(&cfg_content).unwrap();
        config.merge(&mut l_config);
        config.config = config_path;
    }

    // Merge arguments to loaded config
    config.merge(&mut args.sc_config);
    config
}

pub fn start_logging() {
    env_logger::builder()
        // .filter_level(log::LevelFilter::Trace)
        .init();
}