rgch 0.1.33

Rust version of gch
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
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

extern crate rgch;

use rgch::{
    arg::{save, set_default, set_git_dir},
    git::{
        add::{add, silence_add},
        branch::set_branch,
        clone::clone,
        commit::{amend, check_raw_commit},
        diff::diff,
        erase_all,
        init::init,
        log::log,
        ls_files::ls,
        merge::merge,
        pull::pull,
        push::push,
        remote::set_remote,
        reset::reset,
        status::{check_status, is_status_clean, short_status},
    },
    help::help,
    misc::show,
    version::{short_version, version},
};
#[allow(unused_imports)]
use std::process::exit;

fn main() {
    short_version();

    let args = set_default();

    if args["show-args"].flag {
        show(&args);
    }

    // can be operated without .git folder
    match (
        args["version"].flag,
        args["help"].flag,
        args["clone"].flag,
        args["init"].flag,
    ) {
        (true, _, _, _) => version(),
        (_, true, _, _) => help(),
        (_, _, true, _) => clone(
            &args["clone"].value,
            &args["branch"].value,
            args["branch"].flag,
        ),
        (_, _, _, true) => init(&args["gitdir"].value),
        (_, _, _, _) => (),
    }

    set_git_dir(&args["gitdir"].value);

    match (args["log"].flag, args["ls"].flag, args["erase-all"].flag) {
        (true, _, _) => log(),
        (_, true, _) => ls(),
        (_, _, true) => erase_all(&args["erase-all"].value),
        (_, _, _) => (),
    }

    if args["save"].flag {
        save(&args);
    }

    if args["amd"].flag {
        amend();
    } else {
        let remote = if args["push"].flag {
            set_remote(&args["remote"].value, &args["gitdir"].value)
        } else {
            "origin".to_string()
        };

        if args["pull"].flag {
            pull(&remote, &args["branch"].value, true);
        }

        if !is_status_clean() {
            diff(args["verbose"].flag);
        }

        if args["add"].flag {
            add(&args["add"].value, args["force"].flag);
        } else {
            silence_add(&args["add"].value, args["force"].flag);
        }

        if !args["merge"].flag {
            set_branch(&args["branch"].value, &args["gitdir"].value);
        }

        let branch = if args["merge"].flag {
            if args["merge"].value != args["branch"].value
                && !is_status_clean()
                && args["merge"].value == "master"
            {
                check_raw_commit(&args);
            }
            merge(&args);
            args["merge"].value.clone()
        } else {
            if args["commit"].flag {
                check_raw_commit(&args);
            } else {
                if check_status() {
                    short_status();
                }
                reset();
            }
            args["branch"].value.clone()
        };

        if args["push"].flag {
            push(&remote, &branch);
        }
    }

    println!();
}