Implemented ability to serialize_all using cases from heck.

Issue Peternator7#21

strum_macros/Cargo.toml

@@ -17,6 +17,7 @@ proc-macro = true
 name = "strum_macros"
 
 [dependencies]
+heck = "0.3"
 proc-macro2 = "0.4"
 quote = "0.6"
 syn = { version = "0.15", features = ["parsing"] }

strum_macros/src/case_style.rs

@@ -0,0 +1,34 @@
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum CaseStyle {
+    CamelCase,
+    KebabCase,
+    MixedCase,
+    ShoutySnakeCase,
+    SnakeCase,
+    TitleCase,
+}
+
+impl<'s> From<&'s str> for CaseStyle {
+    fn from(text: &'s str) -> CaseStyle {
+        match text {
+            "camel_case" => CaseStyle::CamelCase,
+            "kebab_case" => CaseStyle::KebabCase,
+            "mixed_case" => CaseStyle::MixedCase,
+            "shouty_snake_case" | "shouty_snek_case" => CaseStyle::ShoutySnakeCase,
+            "snake_case" | "snek_case" => CaseStyle::SnakeCase,
+            "title_case" => CaseStyle::TitleCase,
+            _ => panic!(
+                "Unexpected case style for serialize_all: `{}`. Valid values are: `{:?}`",
+                text,
+                [
+                    "camel_case",
+                    "kebab_case",
+                    "mixed_case",
+                    "shouty_snake_case",
+                    "snake_case",
+                    "title_case"
+                ]
+            ),
+        }
+    }
+}

strum_macros/src/from_string.rs

@@ -1,7 +1,8 @@
 use proc_macro2::TokenStream;
 use syn;
 
-use helpers::{extract_attrs, extract_meta, is_disabled, unique_attr};
+use case_style::CaseStyle;
+use helpers::{convert_case, extract_attrs, extract_meta, is_disabled, unique_attr};
 
 pub fn from_string_inner(ast: &syn::DeriveInput) -> TokenStream {
     let name = &ast.ident;
@@ -11,6 +12,10 @@ pub fn from_string_inner(ast: &syn::DeriveInput) -> TokenStream {
         _ => panic!("FromString only works on Enums"),
     };
 
+    let type_meta = extract_meta(&ast.attrs);
+    let case_style = unique_attr(&type_meta, "strum", "serialize_all")
+        .map(|style| CaseStyle::from(style.as_ref()));
+
     let mut has_default = false;
     let mut default =
         quote! { _ => ::std::result::Result::Err(::strum::ParseError::VariantNotFound) };
@@ -48,9 +53,9 @@ pub fn from_string_inner(ast: &syn::DeriveInput) -> TokenStream {
             continue;
         }
 
-        // If we don't have any custom variants, add the default name.
+        // If we don't have any custom variants, add the default serialized name.
         if attrs.len() == 0 {
-            attrs.push(ident.to_string());
+            attrs.push(convert_case(ident, case_style));
         }
 
         let params = match variant.fields {

strum_macros/src/helpers.rs

@@ -1,4 +1,7 @@
-use syn::{Attribute, Meta};
+use heck::{CamelCase, KebabCase, MixedCase, ShoutySnakeCase, SnakeCase, TitleCase};
+use syn::{Attribute, Ident, Meta};
+
+use case_style::CaseStyle;
 
 pub fn extract_meta(attrs: &[Attribute]) -> Vec<Meta> {
     attrs
@@ -55,3 +58,19 @@ pub fn is_disabled(attrs: &[Meta]) -> bool {
         _ => panic!("Can't have multiple values for 'disabled'"),
     }
 }
+
+pub fn convert_case(ident: &Ident, case_style: Option<CaseStyle>) -> String {
+    let ident_string = ident.to_string();
+    if let Some(case_style) = case_style {
+        match case_style {
+            CaseStyle::CamelCase => ident_string.to_camel_case(),
+            CaseStyle::KebabCase => ident_string.to_kebab_case(),
+            CaseStyle::MixedCase => ident_string.to_mixed_case(),
+            CaseStyle::ShoutySnakeCase => ident_string.to_shouty_snake_case(),
+            CaseStyle::SnakeCase => ident_string.to_snake_case(),
+            CaseStyle::TitleCase => ident_string.to_title_case(),
+        }
+    } else {
+        ident_string
+    }
+}

strum_macros/src/lib.rs

@@ -9,13 +9,15 @@
 
 #![recursion_limit = "128"]
 
+extern crate heck;
 extern crate syn;
 #[macro_use]
 extern crate quote;
 extern crate proc_macro;
 extern crate proc_macro2;
 
 mod as_ref_str;
+mod case_style;
 mod display;
 mod enum_iter;
 mod enum_messages;

strum_macros/src/to_string.rs

@@ -1,7 +1,8 @@
 use proc_macro2::TokenStream;
 use syn;
 
-use helpers::{extract_attrs, extract_meta, is_disabled, unique_attr};
+use case_style::CaseStyle;
+use helpers::{convert_case, extract_attrs, extract_meta, is_disabled, unique_attr};
 
 pub fn to_string_inner(ast: &syn::DeriveInput) -> TokenStream {
     let name = &ast.ident;
@@ -11,6 +12,10 @@ pub fn to_string_inner(ast: &syn::DeriveInput) -> TokenStream {
         _ => panic!("ToString only works on Enums"),
     };
 
+    let type_meta = extract_meta(&ast.attrs);
+    let case_style = unique_attr(&type_meta, "strum", "serialize_all")
+        .map(|style| CaseStyle::from(style.as_ref()));
+
     let mut arms = Vec::new();
     for variant in variants {
         use syn::Fields::*;
@@ -31,7 +36,7 @@ pub fn to_string_inner(ast: &syn::DeriveInput) -> TokenStream {
             if let Some(n) = attrs.pop() {
                 n
             } else {
-                ident.to_string()
+                convert_case(ident, case_style)
             }
         };
 

strum_tests/tests/from_str.rs

@@ -47,6 +47,33 @@ fn color_default() {
     );
 }
 
+#[derive(Debug, Eq, PartialEq, EnumString)]
+#[strum(serialize_all = "snake_case")]
+enum Brightness {
+    DarkBlack,
+    Dim {
+        glow: usize,
+    },
+    #[strum(serialize = "Bright")]
+    BrightWhite,
+}
+
+#[test]
+fn brightness_serialize_all() {
+    assert_eq!(
+        Brightness::DarkBlack,
+        Brightness::from_str("dark_black").unwrap()
+    );
+    assert_eq!(
+        Brightness::Dim { glow: 0 },
+        Brightness::from_str("dim").unwrap()
+    );
+    assert_eq!(
+        Brightness::BrightWhite,
+        Brightness::from_str("Bright").unwrap()
+    );
+}
+
 #[derive(Debug, Eq, PartialEq, EnumString)]
 enum Week {
     Sunday,

strum_tests/tests/to_string.rs

@@ -38,3 +38,30 @@ fn to_red_string() {
         Color::from_str((Color::Red).to_string().as_ref()).unwrap()
     );
 }
+
+#[derive(Debug, Eq, PartialEq, ToString)]
+#[strum(serialize_all = "snake_case")]
+enum Brightness {
+    DarkBlack,
+    Dim {
+        glow: usize,
+    },
+    #[strum(serialize = "bright")]
+    BrightWhite,
+}
+
+#[test]
+fn brightness_to_string() {
+    assert_eq!(
+        String::from("dark_black"),
+        Brightness::DarkBlack.to_string().as_ref()
+    );
+    assert_eq!(
+        String::from("dim"),
+        Brightness::Dim { glow: 0 }.to_string().as_ref()
+    );
+    assert_eq!(
+        String::from("bright"),
+        Brightness::BrightWhite.to_string().as_ref()
+    );
+}