git-shadow 0.0.3

Standalone shadow copies of git repos (or parts of them) in a working directory.
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
136
137
138
139
140
141
142
143

use clap::{Parser, Subcommand};

#[derive(Debug, Parser)]
#[command(
    name = "git-shadow",
    bin_name = "git shadow",
    version,
    about = "Run git commands against shadow repositories that live inside your working directory"
)]
pub struct Cli {
    #[command(subcommand)]
    pub command: Command,
}

#[derive(Debug, Subcommand)]
pub enum Command {
    /// List the shadows configured for this repo
    List {
        /// List every configured shadow across all repos
        #[arg(long)]
        global: bool,
    },
    /// Clone any configured shadows that are not present
    Sync {
        /// Sync only this shadow
        name: Option<String>,
    },
    /// Clone a repo and register it as a shadow of this repo
    Clone {
        /// Remote URL of the repository to clone
        repo: String,
        /// Directory to clone into, relative to the current directory
        /// (defaults to the repository name)
        directory: Option<String>,
        /// Nickname for the shadow (defaults to the repository name)
        #[arg(long)]
        name: Option<String>,
    },
    /// Remove a shadow from the config and exclude file
    #[command(alias = "rm")]
    Remove {
        /// Nickname of the shadow to remove
        name: String,
        /// Also delete the shadow's directory
        #[arg(long)]
        delete: bool,
    },
    /// Any other first argument is a shadow nickname: the remaining
    /// arguments are run as a git command inside that shadow's directory
    #[command(external_subcommand)]
    Passthrough(Vec<String>),
}

#[cfg(test)]
mod tests {
    use super::*;

    fn parse(args: &[&str]) -> Result<Command, clap::Error> {
        Cli::try_parse_from(std::iter::once("git-shadow").chain(args.iter().copied()))
            .map(|cli| cli.command)
    }

    #[test]
    fn list_parses_with_and_without_global() {
        assert!(matches!(
            parse(&["list"]),
            Ok(Command::List { global: false })
        ));
        assert!(matches!(
            parse(&["list", "--global"]),
            Ok(Command::List { global: true })
        ));
    }

    #[test]
    fn list_rejects_unknown_flags() {
        assert!(parse(&["list", "--bogus"]).is_err());
    }

    #[test]
    fn sync_takes_an_optional_name() {
        assert!(matches!(parse(&["sync"]), Ok(Command::Sync { name: None })));
        assert!(
            matches!(parse(&["sync", "cardlet"]), Ok(Command::Sync { name: Some(n) }) if n == "cardlet")
        );
        assert!(parse(&["sync", "a", "b"]).is_err());
    }

    #[test]
    fn clone_parses_url_directory_and_name() {
        let Ok(Command::Clone {
            repo,
            directory,
            name,
        }) = parse(&["clone", "url", ".vendor/fb", "--name", "fb"])
        else {
            panic!("expected clone command");
        };

        assert_eq!(repo, "url");
        assert_eq!(directory.as_deref(), Some(".vendor/fb"));
        assert_eq!(name.as_deref(), Some("fb"));

        assert!(matches!(
            parse(&["clone", "url", "--name=fb"]),
            Ok(Command::Clone {
                directory: None,
                ..
            })
        ));
        assert!(parse(&["clone"]).is_err());
        assert!(parse(&["clone", "url", "dir", "extra"]).is_err());
        assert!(parse(&["clone", "url", "--name"]).is_err());
    }

    #[test]
    fn remove_parses_name_delete_flag_and_rm_alias() {
        assert!(matches!(
            parse(&["remove", "cardlet"]),
            Ok(Command::Remove { delete: false, .. })
        ));
        assert!(matches!(
            parse(&["rm", "cardlet", "--delete"]),
            Ok(Command::Remove { delete: true, .. })
        ));
        assert!(parse(&["remove"]).is_err());
        assert!(parse(&["remove", "a", "b"]).is_err());
    }

    #[test]
    fn unknown_subcommand_falls_through_to_passthrough() {
        let Ok(Command::Passthrough(args)) = parse(&["cardlet", "status", "-sb"]) else {
            panic!("expected passthrough");
        };

        assert_eq!(args, vec!["cardlet", "status", "-sb"]);
    }

    #[test]
    fn no_arguments_is_an_error() {
        assert!(parse(&[]).is_err());
    }
}