Update clap dependency

Author: qzed

Cargo.lock

@@ -13,7 +13,7 @@ build = "build.rs"
 
 [dependencies]
 anyhow = "1.0.57"
-clap = "2.33.3"
+clap = { version = "3.1.12", features = ['cargo'] }
 indoc = "1.0.4"
 nix = "0.24.1"
 sdtx = { git = "https://github.com/linux-surface/libsurfacedtx", tag = "v0.1.3" }
@@ -24,7 +24,8 @@ udev = "0.6.3"
 
 [build-dependencies]
 anyhow = "1.0.57"
-clap = "2.33.3"
+clap = { version = "3.1.12", features = ['cargo'] }
+clap_complete = "3.1.2"
 indoc = "1.0.4"
 nix = "0.24.1"
 sdtx = { git = "https://github.com/linux-surface/libsurfacedtx", tag = "v0.1.3" }

Cargo.toml

@@ -1,5 +1,5 @@
 use std::env;
-use clap::Shell;
+use clap_complete::shells;
 
 #[allow(dead_code)]
 #[path = "src/cli/mod.rs"]
@@ -15,8 +15,10 @@ fn main() {
         .or_else(|| env::var_os("OUT_DIR"))
         .unwrap();
 
-    let mut app = cli::build().cli();
-    app.gen_completions("surface", Shell::Bash, &outdir);
-    app.gen_completions("surface", Shell::Zsh,  &outdir);
-    app.gen_completions("surface", Shell::Fish, &outdir);
+    let reg = cli::build();
+    let mut app = reg.cli();
+
+    clap_complete::generate_to(shells::Bash, &mut app, "surface", &outdir).unwrap();
+    clap_complete::generate_to(shells::Zsh, &mut app, "surface", &outdir).unwrap();
+    clap_complete::generate_to(shells::Fish, &mut app, "surface", &outdir).unwrap();
 }

build.rs

@@ -14,29 +14,30 @@ impl DynCommand for Command {
         "dgpu"
     }
 
-    fn build(&self) -> clap::App<'static, 'static> {
-        use clap::{AppSettings, Arg, SubCommand};
+    fn build(&self) -> clap::Command {
+        use clap::Arg;
 
-        clap::SubCommand::with_name(self.name())
+        clap::Command::new(self.name())
             .about("Control the discrete GPU")
-            .setting(AppSettings::SubcommandRequiredElseHelp)
-            .setting(AppSettings::InferSubcommands)
-            .subcommand(SubCommand::with_name("id")
+            .subcommand_required(true)
+            .arg_required_else_help(true)
+            .infer_subcommands(true)
+            .subcommand(clap::Command::new("id")
                 .alias("get-id")
                 .about("Get the dGPU PCI device ID")
                 .display_order(1))
-            .subcommand(SubCommand::with_name("get-power-state")
+            .subcommand(clap::Command::new("get-power-state")
                 .aliases(&["ps", "get-ps", "power-state"])
                 .about("Get the dGPU PCI power state")
                 .display_order(2))
-            .subcommand(SubCommand::with_name("get-runtime-pm")
+            .subcommand(clap::Command::new("get-runtime-pm")
                 .aliases(&["rpm", "get-rpm"])
                 .about("Get the dGPU runtime PM control")
                 .display_order(3))
-            .subcommand(SubCommand::with_name("set-runtime-pm")
+            .subcommand(clap::Command::new("set-runtime-pm")
                 .alias("set-rpm")
                 .about("Set the dGPU runtime PM control")
-                .arg(Arg::with_name("mode")
+                .arg(Arg::new("mode")
                     .possible_values(&["on", "off"])
                     .required(true)
                     .index(1))
@@ -45,10 +46,10 @@ impl DynCommand for Command {
 
     fn execute(&self, m: &clap::ArgMatches) -> Result<()> {
         match m.subcommand() {
-            ("id",              Some(m)) => self.get_id(m),
-            ("get-power-state", Some(m)) => self.get_power_state(m),
-            ("get-runtime-pm",  Some(m)) => self.get_runtime_pm(m),
-            ("set-runtime-pm",  Some(m)) => self.set_runtime_pm(m),
+            Some(("id",              m)) => self.get_id(m),
+            Some(("get-power-state", m)) => self.get_power_state(m),
+            Some(("get-runtime-pm",  m)) => self.get_runtime_pm(m),
+            Some(("set-runtime-pm",  m)) => self.set_runtime_pm(m),
             _                            => unreachable!(),
         }
     }
@@ -103,8 +104,7 @@ impl Command {
     }
 
     fn set_runtime_pm(&self, m: &clap::ArgMatches) -> Result<()> {
-        use clap::value_t_or_exit;
-        let mode = value_t_or_exit!(m, "mode", sys::pci::RuntimePowerManagement);
+        let mode: sys::pci::RuntimePowerManagement = m.value_of_t_or_exit("mode");
 
         let mut dgpu = find_dgpu_device()
             .context("Failed to look up discrete GPU device")?

src/cli/dgpu.rs

@@ -11,56 +11,56 @@ impl DynCommand for Command {
         "dtx"
     }
 
-    fn build(&self) -> clap::App<'static, 'static> {
-        use clap::{AppSettings, SubCommand};
-
-        SubCommand::with_name(self.name())
+    fn build(&self) -> clap::Command {
+        clap::Command::new(self.name())
             .about("Control the latch/dtx-system on the Surface Book 2")
-            .setting(AppSettings::SubcommandRequiredElseHelp)
-            .subcommand(SubCommand::with_name("lock")
+            .subcommand_required(true)
+            .arg_required_else_help(true)
+            .infer_subcommands(true)
+            .subcommand(clap::Command::new("lock")
                 .about("Lock the latch")
                 .display_order(1))
-            .subcommand(SubCommand::with_name("unlock")
+            .subcommand(clap::Command::new("unlock")
                 .about("Unlock the latch")
                 .display_order(2))
-            .subcommand(SubCommand::with_name("request")
+            .subcommand(clap::Command::new("request")
                 .about("Request latch-open or abort if already in progress")
                 .display_order(3))
-            .subcommand(SubCommand::with_name("confirm")
+            .subcommand(clap::Command::new("confirm")
                 .about("Confirm latch-open if detachment in progress")
                 .display_order(4))
-            .subcommand(SubCommand::with_name("heartbeat")
+            .subcommand(clap::Command::new("heartbeat")
                 .about("Send heartbeat if detachment in progress")
                 .display_order(5))
-            .subcommand(SubCommand::with_name("cancel")
+            .subcommand(clap::Command::new("cancel")
                 .about("Cancel any detachment in progress")
                 .display_order(6))
-            .subcommand(SubCommand::with_name("get-base")
+            .subcommand(clap::Command::new("get-base")
                 .about("Get information about the currently attached base")
                 .display_order(7))
-            .subcommand(SubCommand::with_name("get-devicemode")
+            .subcommand(clap::Command::new("get-devicemode")
                 .about("Query the current device operation mode")
                 .display_order(8))
-            .subcommand(SubCommand::with_name("get-latchstatus")
+            .subcommand(clap::Command::new("get-latchstatus")
                 .about("Query the current latch status")
                 .display_order(9))
-            .subcommand(SubCommand::with_name("monitor")
+            .subcommand(clap::Command::new("monitor")
                 .about("Monitor DTX events")
                 .display_order(10))
     }
 
     fn execute(&self, m: &clap::ArgMatches) -> Result<()> {
         match m.subcommand() {
-            ("lock",            Some(m)) => self.lock(m),
-            ("unlock",          Some(m)) => self.unlock(m),
-            ("request",         Some(m)) => self.request(m),
-            ("confirm",         Some(m)) => self.confirm(m),
-            ("heartbeat",       Some(m)) => self.heartbeat(m),
-            ("cancel",          Some(m)) => self.cancel(m),
-            ("get-base",        Some(m)) => self.get_base_info(m),
-            ("get-devicemode",  Some(m)) => self.get_device_mode(m),
-            ("get-latchstatus", Some(m)) => self.get_latch_status(m),
-            ("monitor",         Some(m)) => self.monitor(m),
+            Some(("lock",            m)) => self.lock(m),
+            Some(("unlock",          m)) => self.unlock(m),
+            Some(("request",         m)) => self.request(m),
+            Some(("confirm",         m)) => self.confirm(m),
+            Some(("heartbeat",       m)) => self.heartbeat(m),
+            Some(("cancel",          m)) => self.cancel(m),
+            Some(("get-base",        m)) => self.get_base_info(m),
+            Some(("get-devicemode",  m)) => self.get_device_mode(m),
+            Some(("get-latchstatus", m)) => self.get_latch_status(m),
+            Some(("monitor",         m)) => self.monitor(m),
             _                            => unreachable!(),
         }
     }