feat(cmd): use clap derive for commands

Author: clearloop

Cargo.lock

@@ -18,7 +18,7 @@ readme = './README.md'
 [dependencies]
 async-trait = "0.1.89"
 tokio = { version = "1.48.0", features = ["full"] }
-clap = { version = "4.5.51", features = ["cargo"] }
+clap = { version = "4.5.51", features = ["cargo", "derive"] }
 colored = "3.0.0"
 dirs = "6.0.0"
 env_logger = "0.11.6"

Cargo.toml

@@ -1,13 +1,12 @@
 //! Clap Commanders
 use crate::{
     cmd::{
-        completion_handler, Command, CompletionCommand, DataCommand, EditCommand, ExecCommand,
-        ListCommand, PickCommand, StatCommand, TestCommand,
+        CompletionsArgs, DataArgs, EditArgs, ExecArgs, ListArgs, PickArgs, StatArgs, TestArgs,
     },
     err::Error,
-    flag::{Debug, Flag},
 };
-use clap::crate_version;
+use clap::{CommandFactory, Parser, Subcommand};
+use env_logger::Env;
 use log::LevelFilter;
 
 /// This should be called before calling any cli method or printing any output.
@@ -23,46 +22,81 @@ pub fn reset_signal_pipe_handler() {
     }
 }
 
+/// May the Code be with You
+#[derive(Parser)]
+#[command(name = "leetcode", version, about = "May the Code be with You 👻")]
+#[command(arg_required_else_help = true)]
+pub struct Cli {
+    /// Debug mode
+    #[arg(short, long)]
+    pub debug: bool,
+
+    #[command(subcommand)]
+    pub command: Option<Commands>,
+}
+
+#[derive(Subcommand)]
+pub enum Commands {
+    /// Manage Cache
+    #[command(visible_alias = "d", display_order = 1)]
+    Data(DataArgs),
+
+    /// Edit question
+    #[command(visible_alias = "e", display_order = 2)]
+    Edit(EditArgs),
+
+    /// Submit solution
+    #[command(visible_alias = "x", display_order = 3)]
+    Exec(ExecArgs),
+
+    /// List problems
+    #[command(visible_alias = "l", display_order = 4)]
+    List(ListArgs),
+
+    /// Pick a problem
+    #[command(visible_alias = "p", display_order = 5)]
+    Pick(PickArgs),
+
+    /// Show simple chart about submissions
+    #[command(visible_alias = "s", display_order = 6)]
+    Stat(StatArgs),
+
+    /// Test a question
+    #[command(visible_alias = "t", display_order = 7)]
+    Test(TestArgs),
+
+    /// Generate shell Completions
+    #[command(visible_alias = "c", display_order = 8)]
+    Completions(CompletionsArgs),
+}
+
 /// Get matches
 pub async fn main() -> Result<(), Error> {
     reset_signal_pipe_handler();
 
-    let mut cmd = clap::Command::new("leetcode")
-        .version(crate_version!())
-        .about("May the Code be with You 👻")
-        .subcommands(vec![
-            DataCommand::usage().display_order(1),
-            EditCommand::usage().display_order(2),
-            ExecCommand::usage().display_order(3),
-            ListCommand::usage().display_order(4),
-            PickCommand::usage().display_order(5),
-            StatCommand::usage().display_order(6),
-            TestCommand::usage().display_order(7),
-            CompletionCommand::usage().display_order(8),
-        ])
-        .arg(Debug::usage())
-        .arg_required_else_help(true);
-
-    let m = cmd.clone().get_matches();
-
-    if m.get_flag("debug") {
-        Debug::handler()?;
+    let cli = Cli::parse();
+
+    if cli.debug {
+        env_logger::Builder::from_env(Env::default().default_filter_or("debug")).init();
     } else {
         env_logger::Builder::new()
             .filter_level(LevelFilter::Info)
             .format_timestamp(None)
             .init();
     }
 
-    match m.subcommand() {
-        Some(("data", sub_m)) => Ok(DataCommand::handler(sub_m).await?),
-        Some(("edit", sub_m)) => Ok(EditCommand::handler(sub_m).await?),
-        Some(("exec", sub_m)) => Ok(ExecCommand::handler(sub_m).await?),
-        Some(("list", sub_m)) => Ok(ListCommand::handler(sub_m).await?),
-        Some(("pick", sub_m)) => Ok(PickCommand::handler(sub_m).await?),
-        Some(("stat", sub_m)) => Ok(StatCommand::handler(sub_m).await?),
-        Some(("test", sub_m)) => Ok(TestCommand::handler(sub_m).await?),
-        Some(("completions", sub_m)) => Ok(completion_handler(sub_m, &mut cmd)?),
-        _ => Err(Error::MatchError),
+    match cli.command {
+        Some(Commands::Data(args)) => args.run().await,
+        Some(Commands::Edit(args)) => args.run().await,
+        Some(Commands::Exec(args)) => args.run().await,
+        Some(Commands::List(args)) => args.run().await,
+        Some(Commands::Pick(args)) => args.run().await,
+        Some(Commands::Stat(args)) => args.run().await,
+        Some(Commands::Test(args)) => args.run().await,
+        Some(Commands::Completions(args)) => {
+            let mut cmd = Cli::command();
+            args.run(&mut cmd)
+        }
+        None => Err(Error::MatchError),
     }
 }

src/cli.rs

@@ -1,46 +1,14 @@
 //! Completions command
-
-use super::Command;
 use crate::err::Error;
-use async_trait::async_trait;
-use clap::{Arg, ArgAction, ArgMatches, Command as ClapCommand};
+use clap::{Args, Command as ClapCommand};
 use clap_complete::{Generator, Shell, generate};
 
-/// Abstract shell completions command
-///
-/// ```sh
-/// Generate shell Completions
-///
-/// USAGE:
-///     leetcode completions <shell>
-///
-/// ARGUMENTS:
-///     <shell>  [possible values: bash, elvish, fish, powershell, zsh]
-/// ```
-pub struct CompletionCommand;
-
-#[async_trait]
-impl Command for CompletionCommand {
-    /// `pick` usage
-    fn usage() -> ClapCommand {
-        ClapCommand::new("completions")
-            .about("Generate shell Completions")
-            .visible_alias("c")
-            .arg(
-                Arg::new("shell")
-                    .action(ArgAction::Set)
-                    .value_parser(clap::value_parser!(Shell)),
-            )
-    }
-
-    async fn handler(_m: &ArgMatches) -> Result<(), Error> {
-        // defining custom handler to print the completions. Handler method signature limits taking
-        // other params. We need &ArgMatches and &mut ClapCommand to generate completions.
-        println!(
-            "Don't use this handler. Does not implement the functionality to print completions. Use completions_handler() below."
-        );
-        Ok(())
-    }
+/// Completions command arguments
+#[derive(Args)]
+pub struct CompletionsArgs {
+    /// Shell type [possible values: bash, elvish, fish, powershell, zsh]
+    #[arg(value_parser = clap::value_parser!(Shell))]
+    pub shell: Option<Shell>,
 }
 
 fn get_completions_string<G: Generator>(
@@ -53,12 +21,15 @@ fn get_completions_string<G: Generator>(
     Ok(String::from_utf8(v)?)
 }
 
-pub fn completion_handler(m: &ArgMatches, cmd: &mut ClapCommand) -> Result<(), Error> {
-    let shell = *m.get_one::<Shell>("shell").unwrap_or(
-        // if shell value is not provided try to get from the environment
-        &Shell::from_env().ok_or(Error::MatchError)?,
-    );
-    let completions = get_completions_string(shell, cmd)?;
-    println!("{}", completions);
-    Ok(())
+impl CompletionsArgs {
+    /// Generate and print shell completions
+    pub fn run(&self, cmd: &mut ClapCommand) -> Result<(), Error> {
+        let shell = self
+            .shell
+            .or_else(Shell::from_env)
+            .ok_or(Error::MatchError)?;
+        let completions = get_completions_string(shell, cmd)?;
+        println!("{}", completions);
+        Ok(())
+    }
 }

src/cmd/completions.rs

@@ -1,54 +1,23 @@
-//! Cache managger
-use super::Command;
+//! Cache manager
 use crate::{cache::Cache, helper::Digit, Error};
-use async_trait::async_trait;
-use clap::{Arg, ArgAction, ArgMatches, Command as ClapCommand};
+use clap::Args;
 use colored::Colorize;
 
-/// Abstract `data` command
-///
-/// ```sh
-/// leetcode-data
-/// Manage Cache
-///
-/// USAGE:
-///     leetcode data [FLAGS]
-///
-/// FLAGS:
-///     -d, --delete     Delete cache
-///     -u, --update     Update cache
-///     -h, --help       Prints help information
-///     -V, --version    Prints version information
-/// ```
-pub struct DataCommand;
+/// Data command arguments
+#[derive(Args)]
+pub struct DataArgs {
+    /// Delete cache
+    #[arg(short, long)]
+    pub delete: bool,
 
-#[async_trait]
-impl Command for DataCommand {
-    /// `data` command usage
-    fn usage() -> ClapCommand {
-        ClapCommand::new("data")
-            .about("Manage Cache")
-            .visible_alias("d")
-            .arg(
-                Arg::new("delete")
-                    .display_order(1)
-                    .short('d')
-                    .long("delete")
-                    .help("Delete cache")
-                    .action(ArgAction::SetTrue),
-            )
-            .arg(
-                Arg::new("update")
-                    .display_order(2)
-                    .short('u')
-                    .long("update")
-                    .help("Update cache")
-                    .action(ArgAction::SetTrue),
-            )
-    }
+    /// Update cache
+    #[arg(short, long)]
+    pub update: bool,
+}
 
+impl DataArgs {
     /// `data` handler
-    async fn handler(m: &ArgMatches) -> Result<(), Error> {
+    pub async fn run(&self) -> Result<(), Error> {
         use std::fs::File;
         use std::path::Path;
 
@@ -75,13 +44,13 @@ impl Command for DataCommand {
         title.push_str(&"-".repeat(65));
 
         let mut flags = 0;
-        if m.get_flag("delete") {
+        if self.delete {
             flags += 1;
             cache.clean()?;
             println!("{}", "ok!".bright_green());
         }
 
-        if m.get_flag("update") {
+        if self.update {
             flags += 1;
             cache.update().await?;
             println!("{}", "ok!".bright_green());