gitwrap 0.11.0

GitWrap is a simple wrapper around `git` command
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
124
125
126
127
128
129
130
131
132
133
134
135

use upon::Engine;


pub const TEMPLATE_MOD_RS: &str = "mod_rs";
pub const TEMPLATE_OPTION_SIMPLE: &str = "simple";
pub const TEMPLATE_OPTION_DOC_COMMENTS: &str = "doc_comments";
pub const TEMPLATE_OPTION_EQUAL_NO_OPTIONAL: &str = "equal_no_optional";
pub const TEMPLATE_OPTION_EQUAL_OPTIONAL: &str = "equal_optional";
pub const TEMPLATE_OPTION_WITH_PARAMETER: &str = "with_parameter";
pub const TEMPLATE_OPTION_WITH_OPTIONAL_PARAMETER: &str = "with_optional_parameter";
pub const TEMPLATE_OPTION_VALUE_PARAMETER: &str = "value_parameter";
pub const TEMPLATE_GIT_COMMAND_FILE: &str = "git_command_file";
pub const TEMPLATE_GIT_COMMAND_MACRO: &str = "git_command_macro";
pub const TEMPLATE_OPTION_NAME_CONSTANT: &str = "option_name_constant";



static GIT_TEMPLATES_COMMON: &[(&str, &str)] = &[
    (
        TEMPLATE_MOD_RS,
        r#"mod options;
pub use options::*;

{% if is_command %}use crate::wrap_command::WrapCommand;
use crate::git;

pub const GIT_COMMAND: &str = "{{ git_command }}";

{% for doc in descriptions %}/// {{ doc }}
{% endfor %}/// [Git doc]({{ doc_url }})
pub fn {{ command_name }}() -> WrapCommand {
    git(GIT_COMMAND)
}{% endif %}
"#
    ),
    (
        TEMPLATE_OPTION_NAME_CONSTANT,
        r#"pub const {{ constant_name }}: &str = "{{ git_option }}";"#
    ),
    (
        TEMPLATE_OPTION_DOC_COMMENTS,
        r#"{% for doc in descriptions %}/// {{ doc }}
{% endfor %}/// {{ arguments }}"#
    ),
    (
        TEMPLATE_OPTION_SIMPLE,
        r#"pub fn {{ method_name }}() -> FnOptionArg {
    option_arg::simple({{ constant_name }})
}"#
    ),
    (
        TEMPLATE_OPTION_EQUAL_NO_OPTIONAL,
        r#"pub fn {{ method_name }}({{ option_argument }}: &str) -> FnOptionArg {
    option_arg::equal_no_optional({{ constant_name }}, {{ option_argument }})
}"#
    ),
    (
        TEMPLATE_OPTION_EQUAL_OPTIONAL,
        r#"pub fn {{ method_name }}({{ option_argument }}: &str) -> FnOptionArg {
    option_arg::equal_optional({{ constant_name }}, {{ option_argument }})
}"#
    ),
    (
        TEMPLATE_OPTION_WITH_PARAMETER,
        r#"pub fn {{ method_name }}({{ option_argument }}: &str) -> FnOptionArg {
    option_arg::with_parameter({{ constant_name }}, {{ option_argument }})
}"#
    ),
    (
        TEMPLATE_OPTION_WITH_OPTIONAL_PARAMETER,
        r#"pub fn {{ method_name }}({{ option_argument }}: &str) -> FnOptionArg {
    option_arg::with_optional_parameter({{ constant_name }}, {{ option_argument }})
}"#
    ),
    (
        TEMPLATE_OPTION_VALUE_PARAMETER,
        r#"pub fn {{ method_name }}({{ value_parameter }}: &str) -> FnOptionArg {
    option_arg::value_parameter({{ value_parameter }})
}"#
    ),
    (
        TEMPLATE_GIT_COMMAND_FILE,
        r#"use std::sync::Arc;
use crate::wrap_command::{FnOptionArg, WrapCommand};

pub fn git(cmd: &str) -> WrapCommand {
    let l_cmd = String::from(cmd);
    WrapCommand::new("git")
        .add_option(FnOptionArg(Arc::new(move || vec![String::from(l_cmd.as_str())])))
}
"#
    ),
    (
        TEMPLATE_GIT_COMMAND_MACRO,
        r#"#[macro_export]
macro_rules! {{ command_name }} {
    () => (
        {
            $crate::git({{ command_name }}::GIT_COMMAND).run()
        }
    );
    (path: $path:expr) => (
        {
            $crate::git({{ command_name }}::GIT_COMMAND).current_dir($path).run()
        }
    );
    (path: $path:expr, options: $($option:expr), *) => (
        {
            let command = $crate::git({{ command_name }}::GIT_COMMAND)
            $(.add_option($option))*;
            command.current_dir($path).run()
        }
     );
    (options: $($option:expr), *) => (
        {
            let command = $crate::git({{ command_name }}::GIT_COMMAND)
            $(.add_option($option))*;
            command.run()
        }
     );
}"#
    )
];

pub fn command_templates() -> Engine<'static> {
    let mut engine = Engine::new();
    
    for (name, source) in GIT_TEMPLATES_COMMON {
        let _ = engine.add_template(*name, *source);
    }
    
    engine
}