clap_interactive/
lib.rs

1pub mod error;
2
3use clap::{Arg, Command, Parser};
4#[cfg(test)]
5use error::ClapIntError;
6use error::ClapIntResult;
7use inquire::{Confirm, Select, Text};
8
9pub trait InteractiveParse
10where
11    Self: Sized,
12{
13    fn interactive_parse() -> ClapIntResult<Self>;
14}
15
16impl<T> InteractiveParse for T
17where
18    T: Parser,
19{
20    fn interactive_parse() -> ClapIntResult<Self> {
21        let base_command = T::command();
22        let mut args = vec![base_command.get_name().to_string()];
23        let mut command = &base_command;
24        loop {
25            args.extend(get_args(command.get_arguments())?);
26            let subcommands: Vec<&Command> = command.get_subcommands().collect();
27            if subcommands.is_empty() {
28                break;
29            }
30            if !command.is_subcommand_required_set() && !add_optional_command(command)? {
31                break;
32            }
33            command = Select::new(command.get_name(), subcommands).prompt()?;
34            args.push(command.get_name().to_string());
35        }
36        Ok(
37            #[cfg(test)]
38            T::try_parse_from(args.clone()).map_err(|e| ClapIntError::WrapClap {
39                args: args,
40                clap_error: e,
41            })?,
42            #[cfg(not(test))]
43            T::parse_from(args),
44        )
45    }
46}
47
48pub trait IterInteractiveParse
49where
50    Self: Sized,
51{
52    fn interactive_parse() -> ClapIntResult<Self>;
53}
54
55impl<T> IterInteractiveParse for Vec<T>
56where
57    T: InteractiveParse,
58{
59    fn interactive_parse() -> ClapIntResult<Self> {
60        let mut vec = vec![];
61        loop {
62            let long_type_name = std::any::type_name::<T>();
63            let short_type_name = match long_type_name.rsplit_once(':') {
64                Some((_, right)) => right,
65                None => long_type_name,
66            };
67            if Confirm::new("Add optional entry?")
68                .with_help_message(short_type_name)
69                .prompt()?
70            {
71                vec.push(T::interactive_parse()?)
72            } else {
73                break;
74            }
75        }
76        Ok(vec)
77    }
78}
79
80fn parse_required_arg(arg: &Arg) -> ClapIntResult<Vec<String>> {
81    let mut output_args = vec![];
82    let id = arg.get_id();
83    let prefix = match arg.is_positional() {
84        // Arg is positional
85        true => String::new(),
86        // Arg uses flag
87        false => {
88            // output_args.push(format!("--{}", id));
89            format!("--{}=", id)
90        }
91    };
92    let mut text = Text::new(arg.get_id().as_str());
93
94    // Add a help string
95    #[cfg(debug_assertions)]
96    let mut help_string = get_type_string(arg);
97
98    #[cfg(not(debug_assertions))]
99    let mut help_string = String::default();
100
101    #[cfg(debug_assertions)]
102    if let Some(help) = arg.get_help() {
103        help_string = format!("{}: {}", help_string, help);
104    }
105
106    #[cfg(not(debug_assertions))]
107    if let Some(help) = arg.get_help() {
108        help_string = format!("{}", help);
109    }
110
111    text = text.with_help_message(help_string.as_str());
112
113    output_args.push(format!("{}{}", prefix, text.prompt()?));
114    Ok(output_args)
115}
116
117fn add_optional_command(command: &Command) -> ClapIntResult<bool> {
118    let mut confirm = Confirm::new("Add optional command?");
119    if let Some(help) = command.get_subcommand_value_name() {
120        confirm = confirm.with_help_message(help);
121    }
122    Ok(confirm.prompt()?)
123}
124
125fn parse_optional_arg(arg: &Arg) -> ClapIntResult<Vec<String>> {
126    match Confirm::new("Add optional value?")
127        .with_help_message(arg.get_id().as_str())
128        .prompt()?
129    {
130        true => parse_required_arg(arg),
131        false => Ok(vec![]),
132    }
133}
134
135fn parse_vec_arg(arg: &Arg) -> ClapIntResult<Vec<String>> {
136    let mut new_args = parse_optional_arg(arg)?;
137    let mut total_args = vec![];
138    while !new_args.is_empty() {
139        total_args.extend(new_args);
140        new_args = parse_optional_arg(arg)?;
141    }
142    if let Some(value_delimiter) = arg.get_value_delimiter() {
143        total_args.join(value_delimiter.to_string().as_str());
144    }
145    Ok(total_args)
146}
147
148fn parse_arg(arg: &Arg) -> ClapIntResult<Vec<String>> {
149    match arg.get_num_args() {
150        // arg is a vec
151        Some(_) => parse_vec_arg(arg),
152        None => match arg.is_required_set() {
153            true => parse_required_arg(arg),
154            false => parse_optional_arg(arg),
155        },
156    }
157}
158
159fn get_args<'a>(command: impl Iterator<Item = &'a Arg>) -> ClapIntResult<Vec<String>> {
160    let mut arg_list = vec![];
161    for arg in command {
162        arg_list.extend(parse_arg(arg)?);
163    }
164    Ok(arg_list)
165}
166
167#[cfg(debug_assertions)]
168fn get_type_string(arg: &Arg) -> String {
169    let value_parser = arg.get_value_parser();
170    let type_id = value_parser.type_id();
171    let mut long_type_name = format!("{:?}", type_id);
172    long_type_name = long_type_name.replace('(', "");
173    long_type_name = long_type_name.replace(')', "");
174    let mut type_list: Vec<&str> = long_type_name.split(", ").collect();
175    for type_str in &mut type_list {
176        if let Some(split) = type_str.rsplit_once(':') {
177            *type_str = split.1
178        }
179    }
180    let combine = type_list.join(",");
181    let output = format!("<{}>", combine);
182    output
183}
184
185#[cfg(test)]
186mod test {
187    use std::{fmt::Debug, str::FromStr};
188
189    #[cfg(debug_assertions)]
190    use clap::CommandFactory;
191
192    use super::*;
193
194    #[derive(Parser, Debug)]
195    #[command(author, version, about, long_about = None, subcommand_value_name="my_subcommand")]
196    struct Git {
197        /// my_subcommand doc
198        #[command(subcommand)]
199        my_subcommand: Option<SubCommand>,
200
201        /// MyArg help string
202        #[arg(long, required=false, value_parser=tuple_parser::<String, String>)]
203        my_arg: Option<Vec<(String, String)>>,
204    }
205
206    /// Other heading
207    #[derive(Parser, Debug)]
208    #[clap(rename_all = "snake_case", infer_subcommands = true)]
209    enum SubCommand {
210        Commit {
211            #[arg(required = false)]
212            message: Option<String>,
213        },
214        Clone {
215            #[arg(value_parser=tuple_parser::<String, String>)]
216            address: Vec<(String, String)>,
217        },
218        Merge {
219            #[arg(value_delimiter = ',')]
220            address: Vec<String>,
221            #[arg(long)]
222            bool: bool,
223        },
224    }
225
226    pub fn tuple_parser<T, U>(s: &str) -> ClapIntResult<(T, U)>
227    where
228        T: FromStr,
229        U: FromStr,
230        <T as FromStr>::Err: Debug,
231        <U as FromStr>::Err: Debug,
232    {
233        let vec: Vec<&str> = s.split(',').collect();
234        Ok((T::from_str(vec[0]).unwrap(), U::from_str(vec[1]).unwrap()))
235    }
236
237    #[ignore]
238    #[test]
239    fn test_interactive() {
240        let git = Git::interactive_parse();
241        match git {
242            Ok(git) => {
243                println!("{:?}", git);
244            }
245            Err(err) => {
246                println!("{}", err);
247            }
248        }
249    }
250
251    #[ignore]
252    #[test]
253    fn test_iter_interactive() {
254        let git = Vec::<Git>::interactive_parse().unwrap();
255        println!("{:?}", git);
256    }
257
258    #[ignore]
259    #[test]
260    fn test_static() {
261        let args = ["git", "-h"];
262        let git = Git::parse_from(args);
263        println!("{:?}", git);
264    }
265
266    #[cfg(debug_assertions)]
267    #[test]
268    fn test_get_type_string() {
269        let arg = Git::command()
270            .get_arguments()
271            .find(|x| x.get_id() == "my_arg")
272            .unwrap()
273            .clone();
274        let type_string = get_type_string(&arg);
275        assert_eq!(type_string.as_str(), "<String,String>")
276    }
277}
clap_interactive/lib.rs

clap_interactive/
lib.rs
