hj-cli 0.1.2

CLI for handoff state, reconciliation, and handup surveys
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

mod alias;
mod cli;
mod handoff;
mod handup;
mod install;

use std::process;

use anyhow::Result;
use clap::Parser;
use cli::{Cli, Commands};
use hj_core::ReconcileMode;

pub fn main_entry() {
    if let Err(error) = run() {
        eprintln!("error: {error:#}");
        process::exit(1);
    }
}

pub fn run() -> Result<()> {
    let cli = Cli::parse_from(alias::rewrite_args_for_alias(std::env::args_os()));
    match cli.command {
        Commands::Detect(args) => handoff::detect(args),
        Commands::Handoff(args) => handoff::close(args),
        Commands::Handon(args) => handoff::handon(args),
        Commands::Handover(args) => handoff::handover(args),
        Commands::HandoffDb(args) => handoff::handoff_db(args),
        Commands::Handup(args) => handup::handup(args),
        Commands::Install(args) => install::install(args),
        Commands::Update(args) | Commands::UpdateAll(args) => install::update(args),
        Commands::Refresh(args) => handoff::refresh(args),
        Commands::Reconcile(args) => handoff::reconcile(args, ReconcileMode::Sync),
        Commands::Audit(args) => handoff::reconcile(args, ReconcileMode::Audit),
        Commands::Close(args) => handoff::close(args),
    }
}

#[cfg(test)]
mod tests {
    use std::ffi::{OsStr, OsString};

    use clap::Parser;

    use crate::{
        alias::rewrite_args_for_alias,
        cli::{Cli, Commands, InstallArgs, TargetArgs, UpdateArgs},
    };

    #[test]
    fn handoff_detect_alias_rewrites_to_subcommand() {
        let rewritten = rewrite_args_for_alias([
            OsString::from("handoff-detect"),
            OsString::from("--project"),
        ]);
        assert_eq!(
            rewritten,
            vec![
                OsString::from("hj"),
                OsString::from("detect"),
                OsString::from("--project")
            ]
        );
    }

    #[test]
    fn handoff_alias_rewrites_to_subcommand() {
        let rewritten = rewrite_args_for_alias([OsString::from("handoff")]);
        assert_eq!(
            rewritten,
            vec![OsString::from("hj"), OsString::from("handoff")]
        );
    }

    #[test]
    fn handon_alias_rewrites_to_subcommand() {
        let rewritten = rewrite_args_for_alias([OsString::from("handon")]);
        assert_eq!(
            rewritten,
            vec![OsString::from("hj"), OsString::from("handon")]
        );
    }

    #[test]
    fn handover_alias_rewrites_to_subcommand() {
        let rewritten = rewrite_args_for_alias([OsString::from("handover")]);
        assert_eq!(
            rewritten,
            vec![OsString::from("hj"), OsString::from("handover")]
        );
    }

    #[test]
    fn install_command_uses_default_root() {
        let cli = Cli::parse_from([OsStr::new("hj"), OsStr::new("install")]);
        match cli.command {
            Commands::Install(InstallArgs { root }) => assert_eq!(root, "~/.local"),
            other => panic!("expected install command, got {other:?}"),
        }
    }

    #[test]
    fn update_command_uses_default_root() {
        let cli = Cli::parse_from([OsStr::new("hj"), OsStr::new("update")]);
        match cli.command {
            Commands::Update(UpdateArgs { root }) => assert_eq!(root, "~/.local"),
            other => panic!("expected update command, got {other:?}"),
        }
    }

    #[test]
    fn update_all_command_parses_separately() {
        let cli = Cli::parse_from([OsStr::new("hj"), OsStr::new("update-all")]);
        match cli.command {
            Commands::UpdateAll(UpdateArgs { root }) => assert_eq!(root, "~/.local"),
            other => panic!("expected update-all command, got {other:?}"),
        }
    }

    #[test]
    fn handon_command_parses_target_args() {
        let cli = Cli::parse_from([
            OsStr::new("hj"),
            OsStr::new("handon"),
            OsStr::new("--project"),
            OsStr::new("hj"),
        ]);
        match cli.command {
            Commands::Handon(TargetArgs { project, .. }) => {
                assert_eq!(project.as_deref(), Some("hj"))
            }
            other => panic!("expected handon command, got {other:?}"),
        }
    }
}