Skip to main content

git_nav/
cli.rs

1//! Manual arg parsing — kept dependency-free so compile times stay small
2//! and the binary size doesn't balloon from clap.
3
4use std::path::PathBuf;
5
6use crate::config::expand_tilde;
7
8#[derive(Debug, Default)]
9pub struct ParsedArgs {
10    pub command: Command,
11    pub root_override: Option<PathBuf>,
12    pub depth_override: Option<u32>,
13}
14
15#[derive(Debug, Default, PartialEq, Eq)]
16pub enum Command {
17    #[default]
18    Run,
19    Help,
20    Version,
21    Init {
22        shell: String,
23    },
24    InstallShell,
25    ConfigPath,
26    Reset,
27}
28
29pub fn parse(args: &[String]) -> Result<ParsedArgs, String> {
30    let mut out = ParsedArgs::default();
31    let mut i = 1;
32    while i < args.len() {
33        let a = args[i].as_str();
34        match a {
35            "-h" | "--help" => {
36                out.command = Command::Help;
37                return Ok(out);
38            }
39            "-V" | "--version" => {
40                out.command = Command::Version;
41                return Ok(out);
42            }
43            "--init" => {
44                let shell = args
45                    .get(i + 1)
46                    .ok_or_else(|| "--init needs a shell (bash|zsh|fish)".to_string())?
47                    .clone();
48                out.command = Command::Init { shell };
49                return Ok(out);
50            }
51            "--install-shell" => {
52                out.command = Command::InstallShell;
53                return Ok(out);
54            }
55            "--config-path" => {
56                out.command = Command::ConfigPath;
57                return Ok(out);
58            }
59            "--reset" => {
60                out.command = Command::Reset;
61                return Ok(out);
62            }
63            "-r" | "--root" => {
64                let v = args
65                    .get(i + 1)
66                    .ok_or_else(|| "--root needs a value".to_string())?
67                    .clone();
68                out.root_override = Some(expand_tilde(&v));
69                i += 1;
70            }
71            "-d" | "--depth" => {
72                let v = args
73                    .get(i + 1)
74                    .ok_or_else(|| "--depth needs a value".to_string())?
75                    .clone();
76                let n: u32 = v
77                    .parse()
78                    .map_err(|_| format!("--depth expects a number, got {v}"))?;
79                out.depth_override = Some(n);
80                i += 1;
81            }
82            other => return Err(format!("unknown argument: {other}")),
83        }
84        i += 1;
85    }
86    Ok(out)
87}
88
89#[cfg(test)]
90mod tests {
91    use super::*;
92
93    fn args(v: &[&str]) -> Vec<String> {
94        std::iter::once("git-nav")
95            .chain(v.iter().copied())
96            .map(String::from)
97            .collect()
98    }
99
100    #[test]
101    fn defaults_to_run() {
102        let p = parse(&args(&[])).unwrap();
103        assert_eq!(p.command, Command::Run);
104        assert!(p.root_override.is_none());
105        assert!(p.depth_override.is_none());
106    }
107
108    #[test]
109    fn help_short_and_long() {
110        assert_eq!(parse(&args(&["-h"])).unwrap().command, Command::Help);
111        assert_eq!(parse(&args(&["--help"])).unwrap().command, Command::Help);
112    }
113
114    #[test]
115    fn init_captures_shell() {
116        let p = parse(&args(&["--init", "zsh"])).unwrap();
117        assert_eq!(
118            p.command,
119            Command::Init {
120                shell: "zsh".into()
121            }
122        );
123    }
124
125    #[test]
126    fn root_and_depth_override() {
127        let p = parse(&args(&["--root", "/tmp", "--depth", "2"])).unwrap();
128        assert_eq!(p.depth_override, Some(2));
129        assert_eq!(
130            p.root_override.as_deref(),
131            Some(std::path::Path::new("/tmp"))
132        );
133    }
134
135    #[test]
136    fn unknown_arg_errors() {
137        assert!(parse(&args(&["--bogus"])).is_err());
138    }
139
140    #[test]
141    fn depth_needs_number() {
142        assert!(parse(&args(&["--depth", "abc"])).is_err());
143    }
144}