Auto generate argument enums

The argparse module we use for parsing events expects an enum in order
to convey what subcommand has been supplied as an argument. Such an enum
also needs to implement str::FromStr and, preferably, fmt::Display.
Manually writing down those definitions is error-prone, tedious, and
adds no value -- only lines of code.
As it turns out the proper definitions can be generated with relative
easy with a declarative macro, making the code much more concise. Hence,
with this change we use a newly introduced macro for generating those
enums.

1 files changed, 71 insertions, 356 deletions

diff --git a/nitrocli/src/args.rs b/nitrocli/src/args.rs
index 76b9766..8ce06e2 100644
--- a/nitrocli/src/args.rs
+++ b/nitrocli/src/args.rs
@@ -17,7 +17,6 @@
 // * along with this program.  If not, see <http://www.gnu.org/licenses/>. *
 // *************************************************************************
 
-use std::fmt;
 use std::io;
 use std::result;
 use std::str;
@@ -29,38 +28,6 @@ use crate::RunCtx;
 
 type Result<T> = result::Result<T, Error>;
 
-/// The available Nitrokey models.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum DeviceModel {
-  Pro,
-  Storage,
-}
-
-impl fmt::Display for DeviceModel {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(
-      f,
-      "{}",
-      match *self {
-        DeviceModel::Pro => "pro",
-        DeviceModel::Storage => "storage",
-      }
-    )
-  }
-}
-
-impl str::FromStr for DeviceModel {
-  type Err = ();
-
-  fn from_str(s: &str) -> result::Result<Self, Self::Err> {
-    match s {
-      "pro" => Ok(DeviceModel::Pro),
-      "storage" => Ok(DeviceModel::Storage),
-      _ => Err(()),
-    }
-  }
-}
-
 trait Stdio {
   fn stdio(&mut self) -> (&mut dyn io::Write, &mut dyn io::Write);
 }
@@ -86,22 +53,27 @@ impl<'io> Stdio for ExecCtx<'io> {
   }
 }
 
+/// The available Nitrokey models.
+Enum! {DeviceModel, [
+  Pro => "pro",
+  Storage => "storage"
+]}
+
 /// A top-level command for nitrocli.
-#[derive(Debug)]
-pub enum Command {
-  Config,
-  Lock,
-  Otp,
-  Pin,
-  Pws,
-  Status,
-  Storage,
-}
+Enum! {Command, [
+  Config => "config",
+  Lock => "lock",
+  Otp => "otp",
+  Pin => "pin",
+  Pws => "pws",
+  Status => "status",
+  Storage => "storage"
+]}
 
 impl Command {
   /// Execute this command with the given arguments.
-  pub fn execute(&self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
-    match *self {
+  pub fn execute(self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
+    match self {
       Command::Config => config(ctx, args),
       Command::Lock => lock(ctx, args),
       Command::Otp => otp(ctx, args),
@@ -113,81 +85,20 @@ impl Command {
   }
 }
 
-impl fmt::Display for Command {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(
-      f,
-      "{}",
-      match *self {
-        Command::Config => "config",
-        Command::Lock => "lock",
-        Command::Otp => "otp",
-        Command::Pin => "pin",
-        Command::Pws => "pws",
-        Command::Status => "status",
-        Command::Storage => "storage",
-      }
-    )
-  }
-}
-
-impl str::FromStr for Command {
-  type Err = ();
-
-  fn from_str(s: &str) -> result::Result<Self, Self::Err> {
-    match s {
-      "config" => Ok(Command::Config),
-      "lock" => Ok(Command::Lock),
-      "otp" => Ok(Command::Otp),
-      "pin" => Ok(Command::Pin),
-      "pws" => Ok(Command::Pws),
-      "status" => Ok(Command::Status),
-      "storage" => Ok(Command::Storage),
-      _ => Err(()),
-    }
-  }
-}
-
-#[derive(Debug)]
-enum ConfigCommand {
-  Get,
-  Set,
-}
+Enum! {ConfigCommand, [
+  Get => "get",
+  Set => "set"
+]}
 
 impl ConfigCommand {
-  fn execute(&self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
-    match *self {
+  fn execute(self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
+    match self {
       ConfigCommand::Get => config_get(ctx, args),
       ConfigCommand::Set => config_set(ctx, args),
     }
   }
 }
 
-impl fmt::Display for ConfigCommand {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(
-      f,
-      "{}",
-      match *self {
-        ConfigCommand::Get => "get",
-        ConfigCommand::Set => "set",
-      }
-    )
-  }
-}
-
-impl str::FromStr for ConfigCommand {
-  type Err = ();
-
-  fn from_str(s: &str) -> result::Result<Self, Self::Err> {
-    match s {
-      "get" => Ok(ConfigCommand::Get),
-      "set" => Ok(ConfigCommand::Set),
-      _ => Err(()),
-    }
-  }
-}
-
 #[derive(Clone, Copy, Debug)]
 pub enum ConfigOption<T> {
   Enable(T),
@@ -223,17 +134,16 @@ impl<T> ConfigOption<T> {
   }
 }
 
-#[derive(Debug)]
-enum OtpCommand {
-  Clear,
-  Get,
-  Set,
-  Status,
-}
+Enum! {OtpCommand, [
+  Clear => "clear",
+  Get => "get",
+  Set => "set",
+  Status => "status"
+]}
 
 impl OtpCommand {
-  fn execute(&self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
-    match *self {
+  fn execute(self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
+    match self {
       OtpCommand::Clear => otp_clear(ctx, args),
       OtpCommand::Get => otp_get(ctx, args),
       OtpCommand::Set => otp_set(ctx, args),
@@ -242,96 +152,15 @@ impl OtpCommand {
   }
 }
 
-impl fmt::Display for OtpCommand {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(
-      f,
-      "{}",
-      match *self {
-        OtpCommand::Clear => "clear",
-        OtpCommand::Get => "get",
-        OtpCommand::Set => "set",
-        OtpCommand::Status => "status",
-      }
-    )
-  }
-}
-
-impl str::FromStr for OtpCommand {
-  type Err = ();
-
-  fn from_str(s: &str) -> result::Result<Self, Self::Err> {
-    match s {
-      "clear" => Ok(OtpCommand::Clear),
-      "get" => Ok(OtpCommand::Get),
-      "set" => Ok(OtpCommand::Set),
-      "status" => Ok(OtpCommand::Status),
-      _ => Err(()),
-    }
-  }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum OtpAlgorithm {
-  Hotp,
-  Totp,
-}
-
-impl fmt::Display for OtpAlgorithm {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(
-      f,
-      "{}",
-      match *self {
-        OtpAlgorithm::Hotp => "hotp",
-        OtpAlgorithm::Totp => "totp",
-      }
-    )
-  }
-}
-
-impl str::FromStr for OtpAlgorithm {
-  type Err = ();
-
-  fn from_str(s: &str) -> result::Result<Self, Self::Err> {
-    match s {
-      "hotp" => Ok(OtpAlgorithm::Hotp),
-      "totp" => Ok(OtpAlgorithm::Totp),
-      _ => Err(()),
-    }
-  }
-}
-
-#[derive(Clone, Copy, Debug)]
-enum OtpMode {
-  SixDigits,
-  EightDigits,
-}
-
-impl fmt::Display for OtpMode {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(
-      f,
-      "{}",
-      match *self {
-        OtpMode::SixDigits => "6",
-        OtpMode::EightDigits => "8",
-      }
-    )
-  }
-}
-
-impl str::FromStr for OtpMode {
-  type Err = ();
+Enum! {OtpAlgorithm, [
+  Hotp => "hotp",
+  Totp => "totp"
+]}
 
-  fn from_str(s: &str) -> result::Result<Self, Self::Err> {
-    match s {
-      "6" => Ok(OtpMode::SixDigits),
-      "8" => Ok(OtpMode::EightDigits),
-      _ => Err(()),
-    }
-  }
-}
+Enum! {OtpMode, [
+  SixDigits => "6",
+  EightDigits => "8"
+]}
 
 impl From<OtpMode> for nitrokey::OtpMode {
   fn from(mode: OtpMode) -> Self {
@@ -342,50 +171,21 @@ impl From<OtpMode> for nitrokey::OtpMode {
   }
 }
 
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum OtpSecretFormat {
-  Ascii,
-  Base32,
-  Hex,
-}
-
-impl fmt::Display for OtpSecretFormat {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(
-      f,
-      "{}",
-      match *self {
-        OtpSecretFormat::Ascii => "ascii",
-        OtpSecretFormat::Base32 => "base32",
-        OtpSecretFormat::Hex => "hex",
-      }
-    )
-  }
-}
-
-impl str::FromStr for OtpSecretFormat {
-  type Err = ();
-
-  fn from_str(s: &str) -> result::Result<Self, Self::Err> {
-    match s {
-      "ascii" => Ok(OtpSecretFormat::Ascii),
-      "base32" => Ok(OtpSecretFormat::Base32),
-      "hex" => Ok(OtpSecretFormat::Hex),
-      _ => Err(()),
-    }
-  }
-}
+Enum! {OtpSecretFormat, [
+  Ascii => "ascii",
+  Base32 => "base32",
+  Hex => "hex"
+]}
 
-#[derive(Debug)]
-enum PinCommand {
-  Clear,
-  Set,
-  Unblock,
-}
+Enum! {PinCommand, [
+  Clear => "clear",
+  Set => "set",
+  Unblock => "unblock"
+]}
 
 impl PinCommand {
-  fn execute(&self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
-    match *self {
+  fn execute(self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
+    match self {
       PinCommand::Clear => pin_clear(ctx, args),
       PinCommand::Set => pin_set(ctx, args),
       PinCommand::Unblock => pin_unblock(ctx, args),
@@ -393,44 +193,16 @@ impl PinCommand {
   }
 }
 
-impl fmt::Display for PinCommand {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(
-      f,
-      "{}",
-      match *self {
-        PinCommand::Clear => "clear",
-        PinCommand::Set => "set",
-        PinCommand::Unblock => "unblock",
-      }
-    )
-  }
-}
-
-impl str::FromStr for PinCommand {
-  type Err = ();
-
-  fn from_str(s: &str) -> result::Result<Self, Self::Err> {
-    match s {
-      "clear" => Ok(PinCommand::Clear),
-      "set" => Ok(PinCommand::Set),
-      "unblock" => Ok(PinCommand::Unblock),
-      _ => Err(()),
-    }
-  }
-}
-
-#[derive(Debug)]
-enum PwsCommand {
-  Clear,
-  Get,
-  Set,
-  Status,
-}
+Enum! {PwsCommand, [
+  Clear => "clear",
+  Get => "get",
+  Set => "set",
+  Status => "status"
+]}
 
 impl PwsCommand {
-  fn execute(&self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
-    match *self {
+  fn execute(self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
+    match self {
       PwsCommand::Clear => pws_clear(ctx, args),
       PwsCommand::Get => pws_get(ctx, args),
       PwsCommand::Set => pws_set(ctx, args),
@@ -439,35 +211,6 @@ impl PwsCommand {
   }
 }
 
-impl fmt::Display for PwsCommand {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(
-      f,
-      "{}",
-      match *self {
-        PwsCommand::Clear => "clear",
-        PwsCommand::Get => "get",
-        PwsCommand::Set => "set",
-        PwsCommand::Status => "status",
-      }
-    )
-  }
-}
-
-impl str::FromStr for PwsCommand {
-  type Err = ();
-
-  fn from_str(s: &str) -> result::Result<Self, Self::Err> {
-    match s {
-      "clear" => Ok(PwsCommand::Clear),
-      "get" => Ok(PwsCommand::Get),
-      "set" => Ok(PwsCommand::Set),
-      "status" => Ok(PwsCommand::Status),
-      _ => Err(()),
-    }
-  }
-}
-
 fn parse(
   ctx: &mut impl Stdio,
   parser: &argparse::ArgumentParser<'_>,
@@ -490,16 +233,15 @@ fn status(ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
   commands::status(ctx)
 }
 
-#[derive(Debug)]
-enum StorageCommand {
-  Close,
-  Open,
-  Status,
-}
+Enum! {StorageCommand, [
+  Close => "close",
+  Open => "open",
+  Status => "status"
+]}
 
 impl StorageCommand {
-  fn execute(&self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
-    match *self {
+  fn execute(self, ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
+    match self {
       StorageCommand::Close => storage_close(ctx, args),
       StorageCommand::Open => storage_open(ctx, args),
       StorageCommand::Status => storage_status(ctx, args),
@@ -507,33 +249,6 @@ impl StorageCommand {
   }
 }
 
-impl fmt::Display for StorageCommand {
-  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    write!(
-      f,
-      "{}",
-      match *self {
-        StorageCommand::Close => "close",
-        StorageCommand::Open => "open",
-        StorageCommand::Status => "status",
-      }
-    )
-  }
-}
-
-impl str::FromStr for StorageCommand {
-  type Err = ();
-
-  fn from_str(s: &str) -> result::Result<Self, Self::Err> {
-    match s {
-      "close" => Ok(StorageCommand::Close),
-      "open" => Ok(StorageCommand::Open),
-      "status" => Ok(StorageCommand::Status),
-      _ => Err(()),
-    }
-  }
-}
-
 /// Execute a storage subcommand.
 fn storage(ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
   let mut subcommand = StorageCommand::Open;
@@ -554,7 +269,7 @@ fn storage(ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
   parse(ctx, &parser, args)?;
   drop(parser);
 
-  subargs.insert(0, format!("nitrocli storage {}", subcommand));
+  subargs.insert(0, format!("nitrocli {} {}", Command::Storage, subcommand));
   subcommand.execute(ctx, subargs)
 }
 
@@ -605,7 +320,7 @@ fn config(ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
   parse(ctx, &parser, args)?;
   drop(parser);
 
-  subargs.insert(0, format!("nitrocli config {}", subcommand));
+  subargs.insert(0, format!("nitrocli {} {}", Command::Config, subcommand));
   subcommand.execute(ctx, subargs)
 }
 
@@ -715,7 +430,7 @@ fn otp(ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
   parse(ctx, &parser, args)?;
   drop(parser);
 
-  subargs.insert(0, format!("nitrocli otp {}", subcommand));
+  subargs.insert(0, format!("nitrocli {} {}", Command::Otp, subcommand));
   subcommand.execute(ctx, subargs)
 }
 
@@ -892,7 +607,7 @@ fn pin(ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
   parse(ctx, &parser, args)?;
   drop(parser);
 
-  subargs.insert(0, format!("nitrocli pin {}", subcommand));
+  subargs.insert(0, format!("nitrocli {} {}", Command::Pin, subcommand));
   subcommand.execute(ctx, subargs)
 }
 
@@ -950,7 +665,7 @@ fn pws(ctx: &mut ExecCtx<'_>, args: Vec<String>) -> Result<()> {
   parse(ctx, &parser, args)?;
   drop(parser);
 
-  subargs.insert(0, format!("nitrocli pws {}", subcommand));
+  subargs.insert(0, format!("nitrocli {} {}", Command::Pws, subcommand));
   subcommand.execute(ctx, subargs)
 }