Merge branch 'update-clap'

1 files changed, 33 insertions, 51 deletions

diff --git a/mullvad-cli/src/cmds/beta_program.rs b/mullvad-cli/src/cmds/beta_program.rs
index 77aa73ace3..ba9c72616e 100644
--- a/mullvad-cli/src/cmds/beta_program.rs
+++ b/mullvad-cli/src/cmds/beta_program.rs
@@ -1,61 +1,43 @@
-use crate::{new_rpc_client, Command, Error, Result};
+use anyhow::{anyhow, Result};
+use clap::Subcommand;
+use mullvad_management_interface::MullvadProxyClient;
 
-pub struct BetaProgram;
+use super::BooleanOption;
 
-#[mullvad_management_interface::async_trait]
-impl Command for BetaProgram {
-    fn name(&self) -> &'static str {
-        "beta-program"
-    }
+#[derive(Subcommand, Debug)]
+pub enum BetaProgram {
+    /// Get beta notifications setting
+    Get,
+    /// Change beta notifications setting
+    Set { policy: BooleanOption },
+}
 
-    fn clap_subcommand(&self) -> clap::App<'static> {
-        clap::App::new(self.name())
-            .about("Receive notifications about beta updates")
-            .setting(clap::AppSettings::SubcommandRequiredElseHelp)
-            .subcommand(
-                clap::App::new("set")
-                    .about("Change beta notifications setting")
-                    .arg(
-                        clap::Arg::new("policy")
-                            .required(true)
-                            .possible_values(["on", "off"]),
-                    ),
-            )
-            .subcommand(clap::App::new("get").about("Get beta notifications setting"))
+impl BetaProgram {
+    pub async fn handle(self) -> Result<()> {
+        match self {
+            BetaProgram::Get => Self::get().await,
+            BetaProgram::Set { policy } => Self::set(policy).await,
+        }
     }
 
-    async fn run(&self, matches: &clap::ArgMatches) -> Result<()> {
-        match matches.subcommand() {
-            Some(("get", _)) => {
-                let mut rpc = new_rpc_client().await?;
-                let settings = rpc.get_settings(()).await?.into_inner();
-                let enabled_str = if settings.show_beta_releases {
-                    "on"
-                } else {
-                    "off"
-                };
-                println!("Beta program: {enabled_str}");
-                Ok(())
-            }
-            Some(("set", matches)) => {
-                let enable_str = matches.value_of("policy").expect("missing policy");
-                let enable = enable_str == "on";
+    async fn set(state: BooleanOption) -> Result<()> {
+        if !*state && mullvad_version::VERSION.contains("beta") {
+            return Err(anyhow!(
+                "The beta program must be enabled while running a beta version",
+            ));
+        }
 
-                if !enable && mullvad_version::VERSION.contains("beta") {
-                    return Err(Error::InvalidCommand(
-                        "The beta program must be enabled while running a beta version",
-                    ));
-                }
+        let mut rpc = MullvadProxyClient::new().await?;
+        rpc.set_show_beta_releases(*state).await?;
 
-                let mut rpc = new_rpc_client().await?;
-                rpc.set_show_beta_releases(enable).await?;
+        println!("Beta program: {state}");
+        Ok(())
+    }
 
-                println!("Beta program: {enable_str}");
-                Ok(())
-            }
-            _ => {
-                unreachable!("unhandled command");
-            }
-        }
+    async fn get() -> Result<()> {
+        let mut rpc = MullvadProxyClient::new().await?;
+        let opt = BooleanOption::from(rpc.get_settings().await?.show_beta_releases);
+        println!("Beta program: {opt}");
+        Ok(())
     }
 }