gitbox 2.1.3

Git toolbox to simplify adoption of conventional commits and semantic version, among other things.
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

use clap::{builder::NonEmptyStringValueParser, Args};

use crate::{
    application::{
        controller::{commit::CommitController, exit_code::ControllerExitCode},
        manager::{
            gitinfo_ingress_manager::GitInfoIngressManager,
            message_egress_manager::MessageEgressManager,
        },
        options::commit::CommitOptions,
    },
    infrastructure::{
        helper::commit_prompt_helper::CommitPromptHelper,
        interface::{
            git_cli::GitCli, gitextra_manager_impl::GitExtraManagerImpl,
            message_egress_manager_impl::MessageEgressManagerImpl,
        },
        subcommand::Subcommand,
    },
    usecase::type_aliases::AnyError,
};

#[derive(Args, Debug)]
#[command(about = "Create a commit with a conventional message")]
pub struct CommitSubCommand {
    #[arg(short = 't', long = "type", help = "Set the type of the commit", value_parser = NonEmptyStringValueParser::new())]
    commit_type: Option<String>,

    #[arg(short = 'S', long, help = "Set the scope of the commit")]
    scope: Option<String>,

    #[arg(
        long = "breaking",
        help = "Flag the commit as a breaking change",
        overrides_with = "is_not_breaking"
    )]
    is_breaking: bool,
    #[arg(
        long = "no-breaking",
        help = "Flag the commit as not a breaking change",
        overrides_with = "is_breaking"
    )]
    is_not_breaking: bool,

    #[arg(short = 's', long, help = "Set the summary of the commit", value_parser = NonEmptyStringValueParser::new())]
    summary: Option<String>,

    #[arg(short = 'm', long, help = "Set the body of the commit")]
    message: Option<String>,

    #[arg(short, long, help = "Suppress the print of the complete message")]
    quiet: bool,
}

impl Subcommand for CommitSubCommand {
    fn execute(&self) -> i32 {
        let git_cli = GitCli::new();
        let output_manager = MessageEgressManagerImpl::new();
        if let Err(e) = git_cli.git_dir() {
            output_manager.error(&format!("Failed to retrieve git directory: {}", e));
            output_manager.error("commit subcommand can only be run inside a git project.");
            return 1;
        }
        let gitextra_manager = GitExtraManagerImpl::new(&git_cli);
        let prompt_manager = CommitPromptHelper::new(&gitextra_manager, &gitextra_manager);
        let options = match self.ask_missing_fields(prompt_manager) {
            Ok(o) => o,
            Err(e) => {
                output_manager.error(&e.to_string());
                return 1;
            }
        };
        let controller = CommitController::new(options, &git_cli, &output_manager);
        match controller.commit() {
            ControllerExitCode::Ok => 0,
            ControllerExitCode::Error(i) => i,
        }
    }
}

impl CommitSubCommand {
    fn breaking_option(&self) -> Option<bool> {
        match (self.is_breaking, self.is_not_breaking) {
            (false, false) => None,
            (false, true) => Some(false),
            (true, false) => Some(true),
            (true, true) => unreachable!(),
        }
    }

    fn ask_missing_fields(
        &self,
        prompt_manager: CommitPromptHelper,
    ) -> Result<CommitOptions, AnyError> {
        let temp_type = match self.commit_type.clone() {
            Some(t) => t,
            None => prompt_manager.ask_type()?,
        };
        let temp_scope = match self.scope.clone() {
            Some(s) if !s.is_empty() => Some(s),
            Some(_) => None,
            None => prompt_manager.ask_scope()?,
        };
        let temp_breaking = match self.breaking_option() {
            Some(b) => b,
            None => prompt_manager.ask_breaking()?,
        };
        let temp_summary = match self.summary.clone() {
            Some(s) => s,
            None => prompt_manager.ask_summary()?,
        };
        let temp_message = match self.message.clone() {
            Some(s) if !s.is_empty() => Some(s),
            Some(_) => None,
            None => prompt_manager.ask_body()?,
        };
        CommitOptions::new(
            temp_type,
            temp_scope,
            temp_breaking,
            temp_summary,
            temp_message,
            self.quiet,
        )
    }
}