feat(derive): Make it possible to use ArgEnum with default_value

clap_derive/src/derives/arg_enum.rs

@@ -49,6 +49,7 @@ pub fn gen_for_enum(name: &Ident, attrs: &[Attribute], e: &DataEnum) -> TokenStr
     let lits = lits(&e.variants, &attrs);
     let variants = gen_variants(&lits);
     let from_str = gen_from_str(&lits);
+    let as_arg = gen_as_arg(&lits);
 
     quote! {
         #[allow(dead_code, unreachable_code, unused_variables)]
@@ -66,6 +67,7 @@ pub fn gen_for_enum(name: &Ident, attrs: &[Attribute], e: &DataEnum) -> TokenStr
         impl clap::ArgEnum for #name {
             #variants
             #from_str
+            #as_arg
         }
     }
 }
@@ -127,3 +129,16 @@ fn gen_from_str(lits: &[(TokenStream, Ident)]) -> TokenStream {
         }
     }
 }
+
+fn gen_as_arg(lits: &[(TokenStream, Ident)]) -> TokenStream {
+    let (lit, variant): (Vec<TokenStream>, Vec<Ident>) = lits.iter().cloned().unzip();
+
+    quote! {
+        fn as_arg(&self) -> Option<&'static str> {
+            match self {
+                #(Self::#variant => Some(#lit),)*
+                _ => None
+            }
+        }
+    }
+}

clap_derive/tests/arg_enum.rs

@@ -38,6 +38,52 @@ fn basic() {
     assert!(Opt::try_parse_from(&["", "fOo"]).is_err());
 }
 
+#[test]
+fn default_value() {
+    #[derive(ArgEnum, PartialEq, Debug)]
+    enum ArgChoice {
+        Foo,
+        Bar,
+    }
+
+    impl Default for ArgChoice {
+        fn default() -> Self {
+            Self::Bar
+        }
+    }
+
+    impl std::fmt::Display for ArgChoice {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+            std::fmt::Display::fmt(self.as_arg().unwrap(), f)
+        }
+    }
+
+    #[derive(Clap, PartialEq, Debug)]
+    struct Opt {
+        #[clap(arg_enum, default_value)]
+        arg: ArgChoice,
+    }
+
+    assert_eq!(
+        Opt {
+            arg: ArgChoice::Foo
+        },
+        Opt::parse_from(&["", "foo"])
+    );
+    assert_eq!(
+        Opt {
+            arg: ArgChoice::Bar
+        },
+        Opt::parse_from(&["", "bar"])
+    );
+    assert_eq!(
+        Opt {
+            arg: ArgChoice::Bar
+        },
+        Opt::parse_from(&[""])
+    );
+}
+
 #[test]
 fn multi_word_is_renamed_kebab() {
     #[derive(ArgEnum, PartialEq, Debug)]

src/derive.rs

@@ -285,6 +285,11 @@ pub trait ArgEnum: Sized {
 
     /// Parse an argument into `Self`.
     fn from_str(input: &str, case_insensitive: bool) -> Result<Self, String>;
+
+    /// The canonical argument value.
+    ///
+    /// The value is `None` for skipped variants.
+    fn as_arg(&self) -> Option<&'static str>;
 }
 
 impl<T: Clap> Clap for Box<T> {