gpt_commit 0.1.2

A tool to make ChatGPT create a commit message based on a `git diff`.
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

use crate::errors::{ArgsError, ArgumentError, CommandError, OptionError};
use std::fmt;
use std::str::FromStr;

#[derive(PartialEq, Debug)]
pub enum Command {
    Run,
    Config,
}

#[derive(PartialEq, Debug)]
pub enum Option {
    NoCache,
    Not,
    ApiKey,
    Language,
    URL,
    Model,
}

impl FromStr for Command {
    type Err = CommandError;
    fn from_str(s: &str) -> Result<Self, CommandError> {
        match s {
            "run" => Ok(Command::Run),
            "config" => Ok(Command::Config),
            _ => Err(CommandError::InvalidCommand),
        }
    }
}

pub fn parse_command(s: &str) -> Result<Command, CommandError> {
    s.parse()
}

impl FromStr for Option {
    type Err = OptionError;
    fn from_str(s: &str) -> Result<Self, OptionError> {
        match s {
            "-n" | "--no-cache" | "--no-cached" => Ok(Option::NoCache),
            "not" => Ok(Option::Not),
            "-k" | "--api-key" => Ok(Option::ApiKey),
            "-l" | "--language" => Ok(Option::Language),
            "-m" | "--model" => Ok(Option::Model),
            "-u" | "--url" => Ok(Option::URL),
            _ => Err(OptionError::InvalidOption),
        }
    }
}

impl fmt::Display for Option {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Option::ApiKey => write!(f, "API Key"),
            Option::Language => write!(f, "Language"),
            Option::URL => write!(f, "OpenAI URL"),
            Option::Model => write!(f, "OpenAI Model"),
            _ => Ok(()),
        }
    }
}
pub fn parse_option(s: &str) -> Result<Option, OptionError> {
    s.parse()
}

fn argument_confirmation(cmd: &Command, op: &Option) -> bool {
    match cmd {
        Command::Run => matches!(op, Option::NoCache | Option::Not),
        Command::Config => matches!(
            op,
            Option::Not | Option::Language | Option::ApiKey | Option::Model | Option::URL
        ),
    }
}
fn get_args(cmd: &str, op: &str, val: &str) -> Result<Args, ArgumentError> {
    let _command: Command = parse_command(cmd)
        .map_err(|_| ArgumentError::CommandError(CommandError::InvalidCommand))?;

    let _option: Option =
        parse_option(op).map_err(|_| ArgumentError::OptionError(OptionError::InvalidOption))?;

    if !argument_confirmation(&_command, &_option) {
        return Err(ArgumentError::ArgsError(ArgsError::InvalidArgs));
    }

    if !val.is_empty() && !needs_value(&_command, &_option) {
        return Err(ArgumentError::ArgsError(ArgsError::InvalidArgs));
    }

    Ok(Args {
        command: _command,
        option: _option,
        value: val.to_string(),
    })
}

fn needs_value(cmd: &Command, op: &Option) -> bool {
    cmd == &Command::Config && !matches!(op, Option::NoCache | Option::Not)
}

pub struct Args {
    command: Command,
    option: Option,
    value: String,
}

impl Args {
    pub fn new(args: &Vec<String>) -> Result<Args, ArgumentError> {
        if args.len() < 2 {
            return Err(ArgumentError::ArgsError(ArgsError::MissingArgs));
        }
        match args.len() {
            2 => get_args(&args[1], "not", ""),
            3 => get_args(&args[1], &args[2], ""),
            4 => get_args(&args[1], &args[2], &args[3]),
            _ => Err(ArgumentError::ArgsError(ArgsError::InvalidArgs)),
        }
    }
    pub fn command(&self) -> &Command {
        &self.command
    }

    pub fn option(&self) -> &Option {
        &self.option
    }
    pub fn option_is_not(&self) -> bool {
        self.option == Option::Not
    }

    pub fn value(&self) -> String {
        self.value.clone()
    }
}