Add #[bool] attribute to #[config_type]

This allows declaring a boolean value as aliasing an enum variant, for
upgrading fields that were previously boolean valued into an enum.

Author: Nemo157

Diff for: config_proc_macro/src/attrs.rs

@@ -50,6 +50,30 @@ pub fn is_unstable_variant(attr: &syn::Attribute) -> bool {
     is_attr_path(attr, "unstable_variant")
 }
 
+/// Returns the value of the first `bool` attribute in the given slice or
+/// `None` if `bool` attribute is not available.
+pub fn find_config_bool(attrs: &[syn::Attribute]) -> Option<bool> {
+    attrs.iter().filter_map(config_bool).next()
+}
+
+/// Returns a bool literal value if the given attribute is `bool`
+/// attribute or `None` otherwise.
+pub fn config_bool(attr: &syn::Attribute) -> Option<bool> {
+    match &attr.meta {
+        syn::Meta::NameValue(syn::MetaNameValue {
+            path,
+            value: syn::Expr::Lit(syn::ExprLit { lit: syn::Lit::Bool(lit_bool), .. }),
+            ..
+        }) if path.is_ident("bool") => Some(lit_bool.value()),
+        _ => None,
+    }
+}
+
+/// Returns `true` if the given attribute is a `bool` attribute.
+pub fn is_config_bool(attr: &syn::Attribute) -> bool {
+    is_attr_name_value(attr, "bool")
+}
+
 fn is_attr_name_value(attr: &syn::Attribute, name: &str) -> bool {
     match &attr.meta {
         syn::Meta::NameValue(syn::MetaNameValue { path, .. }) if path.is_ident(name) => true,

Diff for: config_proc_macro/src/item_enum.rs

@@ -48,7 +48,7 @@ fn process_variant(variant: &syn::Variant) -> TokenStream {
     let metas = variant
         .attrs
         .iter()
-        .filter(|attr| !is_doc_hint(attr) && !is_config_value(attr) && !is_unstable_variant(attr));
+        .filter(|attr| !is_doc_hint(attr) && !is_config_value(attr) && !is_unstable_variant(attr) && !is_config_bool(attr));
     let attrs = fold_quote(metas, |meta| quote!(#meta));
     let syn::Variant { ident, fields, .. } = variant;
     quote!(#attrs #ident #fields)
@@ -123,12 +123,22 @@ fn impl_from_str(ident: &syn::Ident, variants: &Variants) -> TokenStream {
     let vs = variants
         .iter()
         .filter(|v| is_unit(v))
-        .map(|v| (config_value_of_variant(v), &v.ident));
-    let if_patterns = fold_quote(vs, |(s, v)| {
+        .map(|v| (config_value_of_variant(v), &v.ident, find_config_bool(&v.attrs)));
+    let if_patterns = fold_quote(vs, |(s, v, b)| {
+        let parse_bool = b.map(|b| {
+            let b = if b { "true" } else { "false" };
+            quote! {
+                if #b == s {
+                    return Ok(#ident::#v);
+                }
+            }
+        }).unwrap_or_default();
+
         quote! {
             if #s.eq_ignore_ascii_case(s) {
                 return Ok(#ident::#v);
             }
+            #parse_bool
         }
     });
     let mut err_msg = String::from("Bad variant, expected one of:");
@@ -210,6 +220,27 @@ fn impl_deserialize(ident: &syn::Ident, variants: &Variants) -> TokenStream {
     let supported_vs = variants.iter().filter(|v| is_unit(v));
     let allowed = fold_quote(supported_vs.map(config_value_of_variant), |s| quote!(#s,));
 
+    let mut bools =
+        variants.iter()
+        .filter(|v| is_unit(v))
+        .filter_map(|v| Some({
+            let bool = find_config_bool(&v.attrs)?;
+            let value = config_value_of_variant(v);
+            quote! {
+                #bool => return Ok(String::from(#value)),
+            }
+        })).peekable();
+
+    let visit_bool = bools.peek().is_some().then(|| {
+        quote! {
+            fn visit_bool<E>(self, value: bool) -> Result<String, E> {
+                match value {
+                    #(#bools)*
+                }
+            }
+        }
+    }).unwrap_or_default();
+
     quote! {
         impl<'de> serde::de::Deserialize<'de> for #ident {
             fn deserialize<D>(d: D) -> Result<Self, D::Error>
@@ -229,7 +260,9 @@ fn impl_deserialize(ident: &syn::Ident, variants: &Variants) -> TokenStream {
                     fn visit_str<E>(self, value: &str) -> Result<String, E> {
                         Ok(String::from(value))
                     }
+                    #visit_bool
                 }
+
                 let s = &d.deserialize_string(StringOnly::<D>(PhantomData))?;
 
                 #if_patterns

Diff for: src/config/options.rs

@@ -217,11 +217,14 @@ pub enum Verbosity {
 }
 
 /// Which comments to wrap
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
+#[config_type]
+#[derive(Copy)]
 pub enum WrapComments {
     /// Don't wrap comments
+    #[bool = false]
     Off,
     /// Wrap all kinds of comments
+    #[bool = true]
     All,
     /// Only wrap doc comments
     Doc,
@@ -239,74 +242,6 @@ impl WrapComments {
     }
 }
 
-impl fmt::Display for WrapComments {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            WrapComments::Off => f.write_str("Off"),
-            WrapComments::All => f.write_str("All"),
-            WrapComments::Doc => f.write_str("Doc"),
-            WrapComments::Normal => f.write_str("Normal"),
-        }
-    }
-}
-
-impl super::ConfigType for WrapComments {
-    fn doc_hint() -> String {
-        "[Off|All|Doc|Normal]".to_owned()
-    }
-
-    fn stable_variant(&self) -> bool {
-        true
-    }
-}
-
-impl std::str::FromStr for WrapComments {
-    type Err = &'static str;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "off" | "false" => Ok(WrapComments::Off),
-            "all" | "true" => Ok(WrapComments::All),
-            "doc" => Ok(WrapComments::Doc),
-            "normal" => Ok(WrapComments::Normal),
-            _ => Err("Bad variant, expected one of: `Off` `All` `Doc` `Normal`"),
-        }
-    }
-}
-
-impl<'de> serde::de::Deserialize<'de> for WrapComments {
-    fn deserialize<D>(d: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        use serde::de::Error;
-
-        struct StringOrBoolVisitor;
-
-        impl<'de> Visitor<'de> for StringOrBoolVisitor {
-            type Value = String;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("string")
-            }
-
-            fn visit_str<E>(self, value: &str) -> Result<String, E> {
-                Ok(String::from(value))
-            }
-
-            fn visit_bool<E>(self, value: bool) -> Result<String, E> {
-                Ok(value.to_string())
-            }
-        }
-
-        let s = d.deserialize_string(StringOrBoolVisitor)?;
-        s.parse().map_err(|_| {
-            static ALLOWED: &'static [&str] = &["Off", "All", "Doc", "Normal"];
-            D::Error::unknown_variant(&s, ALLOWED)
-        })
-    }
-}
-
 #[derive(Deserialize, Serialize, Clone, Debug, PartialEq)]
 pub struct WidthHeuristics {
     // Maximum width of the args of a function call before falling back