use std::ffi::OsStr;
use std::ffi::OsString;
use std::path::PathBuf;
use clap::{Args, Parser, Subcommand};
#[derive(Debug, Parser)] #[command(name = "git")]
#[command(about = "A fictional versioning CLI", long_about = None)]
struct Cli {
#[command(subcommand)]
command: Commands,
}
#[derive(Debug, Subcommand)]
enum Commands {
#[command(arg_required_else_help = true)]
Clone {
remote: String,
},
Diff {
#[arg(value_name = "COMMIT")]
base: Option<OsString>,
#[arg(value_name = "COMMIT")]
head: Option<OsString>,
#[arg(last = true)]
path: Option<OsString>,
},
#[command(arg_required_else_help = true)]
Push {
remote: String,
},
#[command(arg_required_else_help = true)]
Add {
#[arg(required = true)]
path: Vec<PathBuf>,
},
Stash(Stash),
#[command(external_subcommand)]
External(Vec<OsString>),
}
#[derive(Debug, Args)]
#[command(args_conflicts_with_subcommands = true)]
struct Stash {
#[command(subcommand)]
command: Option<StashCommands>,
#[command(flatten)]
push: StashPush,
}
#[derive(Debug, Subcommand)]
enum StashCommands {
Push(StashPush),
Pop { stash: Option<String> },
Apply { stash: Option<String> },
}
#[derive(Debug, Args)]
struct StashPush {
#[arg(short, long)]
message: Option<String>,
}
fn main() {
let args = Cli::parse();
match args.command {
Commands::Clone { remote } => {
println!("Cloning {}", remote);
}
Commands::Diff {
mut base,
mut head,
mut path,
} => {
if path.is_none() {
path = head;
head = None;
if path.is_none() {
path = base;
base = None;
}
}
let base = base
.as_deref()
.map(|s| s.to_str().unwrap())
.unwrap_or("stage");
let head = head
.as_deref()
.map(|s| s.to_str().unwrap())
.unwrap_or("worktree");
let path = path.as_deref().unwrap_or_else(|| OsStr::new(""));
println!("Diffing {}..{} {}", base, head, path.to_string_lossy());
}
Commands::Push { remote } => {
println!("Pushing to {}", remote);
}
Commands::Add { path } => {
println!("Adding {:?}", path);
}
Commands::Stash(stash) => {
let stash_cmd = stash.command.unwrap_or(StashCommands::Push(stash.push));
match stash_cmd {
StashCommands::Push(push) => {
println!("Pushing {:?}", push);
}
StashCommands::Pop { stash } => {
println!("Popping {:?}", stash);
}
StashCommands::Apply { stash } => {
println!("Applying {:?}", stash);
}
}
}
Commands::External(args) => {
println!("Calling out to {:?} with {:?}", &args[0], &args[1..]);
}
}
}