Merge branch 'ISSUE-245' of https://github.com/ericmcbride/strum into…

… ericmcbride-ISSUE-245

strum_macros/src/helpers/inner_variant_props.rs

@@ -0,0 +1,33 @@
+use super::metadata::{InnerVariantExt, InnerVariantMeta};
+use super::occurrence_error;
+use syn::{Field, LitStr};
+
+pub trait HasInnerVariantProperties {
+ fn get_variant_inner_properties(&self) -> syn::Result<StrumInnerVariantProperties>;
+}
+
+#[derive(Clone, Eq, PartialEq, Debug, Default)]
+pub struct StrumInnerVariantProperties {
+ pub default_with: Option<LitStr>,
+}
+
+impl HasInnerVariantProperties for Field {
+ fn get_variant_inner_properties(&self) -> syn::Result<StrumInnerVariantProperties> {
+ let mut output = StrumInnerVariantProperties { default_with: None };
+
+ let mut default_with_kw = None;
+ for meta in self.get_named_metadata()? {
+ match meta {
+ InnerVariantMeta::DefaultWith { kw, value } => {
+ if let Some(fst_kw) = default_with_kw {
+ return Err(occurrence_error(fst_kw, kw, "default_with"));
+ }
+ default_with_kw = Some(kw);
+ output.default_with = Some(value);
+ }
+ }
+ }
+
+ Ok(output)
+ }
+}

strum_macros/src/helpers/metadata.rs

@@ -4,8 +4,8 @@ use syn::{
  parse::{Parse, ParseStream},
  parse2, parse_str,
  punctuated::Punctuated,
- Attribute, DeriveInput, Expr, ExprLit, Ident, Lit, LitBool, LitStr, Meta, MetaNameValue, Path,
- Token, Variant, Visibility,
+ Attribute, DeriveInput, Expr, ExprLit, Field, Ident, Lit, LitBool, LitStr, Meta, MetaNameValue,
+ Path, Token, Variant, Visibility,
 };
 
 use super::case_style::CaseStyle;
@@ -31,6 +31,7 @@ pub mod kw {
  custom_keyword!(to_string);
  custom_keyword!(disabled);
  custom_keyword!(default);
+ custom_keyword!(default_with);
  custom_keyword!(props);
  custom_keyword!(ascii_case_insensitive);
 }
@@ -165,6 +166,10 @@ pub enum VariantMeta {
  },
  Disabled(kw::disabled),
  Default(kw::default),
+ DefaultWith {
+ kw: kw::default_with,
+ value: LitStr,
+ },
  AsciiCaseInsensitive {
  kw: kw::ascii_case_insensitive,
  value: bool,
@@ -202,6 +207,11 @@ impl Parse for VariantMeta {
  Ok(VariantMeta::Disabled(input.parse()?))
  } else if lookahead.peek(kw::default) {
  Ok(VariantMeta::Default(input.parse()?))
+ } else if lookahead.peek(kw::default_with) {
+ let kw = input.parse()?;
+ let _: Token![=] = input.parse()?;
+ let value = input.parse()?;
+ Ok(VariantMeta::DefaultWith { kw, value })
  } else if lookahead.peek(kw::ascii_case_insensitive) {
  let kw = input.parse()?;
  let value = if input.peek(Token![=]) {
@@ -253,7 +263,7 @@ impl VariantExt for Variant {
  let result = get_metadata_inner("strum", &self.attrs)?;
  self.attrs
  .iter()
- .filter(|attr| attr.path().is_ident("doc"))
+ .filter(|attr| attr.meta.path().is_ident("doc"))
  .try_fold(result, |mut vec, attr| {
  if let Meta::NameValue(MetaNameValue {
  value:
@@ -284,3 +294,37 @@ fn get_metadata_inner<'a, T: Parse>(
  Ok(vec)
  })
 }
+
+#[derive(Debug)]
+pub enum InnerVariantMeta {
+ DefaultWith { kw: kw::default_with, value: LitStr },
+}
+
+impl Parse for InnerVariantMeta {
+ fn parse(input: ParseStream) -> syn::Result<Self> {
+ let lookahead = input.lookahead1();
+ if lookahead.peek(kw::default_with) {
+ let kw = input.parse()?;
+ let _: Token![=] = input.parse()?;
+ let value = input.parse()?;
+ Ok(InnerVariantMeta::DefaultWith { kw, value })
+ } else {
+ Err(lookahead.error())
+ }
+ }
+}
+
+pub trait InnerVariantExt {
+ /// Get all the metadata associated with an enum variant inner.
+ fn get_named_metadata(&self) -> syn::Result<Vec<InnerVariantMeta>>;
+}
+
+impl InnerVariantExt for Field {
+ fn get_named_metadata(&self) -> syn::Result<Vec<InnerVariantMeta>> {
+ let result = get_metadata_inner("strum", &self.attrs)?;
+ self.attrs
+ .iter()
+ .filter(|attr| attr.meta.path().is_ident("default_with"))
+ .try_fold(result, |vec, _attr| Ok(vec))
+ }
+}

strum_macros/src/helpers/mod.rs

@@ -1,8 +1,9 @@
-pub use self::case_style::{snakify, CaseStyleHelpers};
+pub use self::inner_variant_props::HasInnerVariantProperties;
 pub use self::type_props::HasTypeProperties;
 pub use self::variant_props::HasStrumVariantProperties;
 
 pub mod case_style;
+pub mod inner_variant_props;
 mod metadata;
 pub mod type_props;
 pub mod variant_props;

strum_macros/src/helpers/variant_props.rs

@@ -13,6 +13,7 @@ pub trait HasStrumVariantProperties {
 pub struct StrumVariantProperties {
  pub disabled: Option<kw::disabled>,
  pub default: Option<kw::default>,
+ pub default_with: Option<LitStr>,
  pub ascii_case_insensitive: Option<bool>,
  pub message: Option<LitStr>,
  pub detailed_message: Option<LitStr>,
@@ -62,9 +63,10 @@ impl HasStrumVariantProperties for Variant {
 
  let mut message_kw = None;
  let mut detailed_message_kw = None;
- let mut to_string_kw = None;
  let mut disabled_kw = None;
  let mut default_kw = None;
+ let mut default_with_kw = None;
+ let mut to_string_kw = None;
  let mut ascii_case_insensitive_kw = None;
  for meta in self.get_metadata()? {
  match meta {
@@ -114,6 +116,14 @@ impl HasStrumVariantProperties for Variant {
  default_kw = Some(kw);
  output.default = Some(kw);
  }
+ VariantMeta::DefaultWith { kw, value } => {
+ if let Some(fst_kw) = default_with_kw {
+ return Err(occurrence_error(fst_kw, kw, "default_with"));
+ }
+
+ default_with_kw = Some(kw);
+ output.default_with = Some(value);
+ }
  VariantMeta::AsciiCaseInsensitive { kw, value } => {
  if let Some(fst_kw) = ascii_case_insensitive_kw {
  return Err(occurrence_error(fst_kw, kw, "ascii_case_insensitive"));

strum_macros/src/macros/enum_is.rs

@@ -1,4 +1,4 @@
-use crate::helpers::{non_enum_error, snakify, HasStrumVariantProperties};
+use crate::helpers::{case_style::snakify, non_enum_error, HasStrumVariantProperties};
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 use syn::{Data, DeriveInput};
@@ -20,7 +20,10 @@ pub fn enum_is_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
 
  let variant_name = &variant.ident;
  let fn_name = format_ident!("is_{}", snakify(&variant_name.to_string()));
- let doc_comment = format!("Returns [true] if the enum is [{}::{}] otherwise [false]", enum_name, variant_name);
+ let doc_comment = format!(
+ "Returns [true] if the enum is [{}::{}] otherwise [false]",
+ enum_name, variant_name
+ );
  Some(quote! {
  #[must_use]
  #[inline]

strum_macros/src/macros/enum_try_as.rs

@@ -1,4 +1,4 @@
-use crate::helpers::{non_enum_error, snakify, HasStrumVariantProperties};
+use crate::helpers::{case_style::snakify, non_enum_error, HasStrumVariantProperties};
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote, ToTokens};
 use syn::{Data, DeriveInput};

strum_macros/src/macros/strings/from_string.rs

@@ -3,7 +3,8 @@ use quote::quote;
 use syn::{Data, DeriveInput, Fields};
 
 use crate::helpers::{
- non_enum_error, occurrence_error, HasStrumVariantProperties, HasTypeProperties,
+ non_enum_error, occurrence_error, HasInnerVariantProperties, HasStrumVariantProperties,
+ HasTypeProperties,
 };
 
 pub fn from_string_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
@@ -45,7 +46,6 @@ pub fn from_string_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
  ))
  }
  }
-
  default_kw = Some(kw);
  default = quote! {
  ::core::result::Result::Ok(#name::#ident(s.into()))
@@ -56,16 +56,34 @@ pub fn from_string_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
  let params = match &variant.fields {
  Fields::Unit => quote! {},
  Fields::Unnamed(fields) => {
- let defaults =
- ::core::iter::repeat(quote!(Default::default())).take(fields.unnamed.len());
- quote! { (#(#defaults),*) }
+ if let Some(ref value) = variant_properties.default_with {
+ let func = proc_macro2::Ident::new(&value.value(), value.span());
+ let defaults = vec![quote! { #func() }];
+ quote! { (#(#defaults),*) }
+ } else {
+ let defaults =
+ ::core::iter::repeat(quote!(Default::default())).take(fields.unnamed.len());
+ quote! { (#(#defaults),*) }
+ }
  }
  Fields::Named(fields) => {
- let fields = fields
- .named
- .iter()
- .map(|field| field.ident.as_ref().unwrap());
- quote! { {#(#fields: Default::default()),*} }
+ let mut defaults = vec![];
+ for field in &fields.named {
+ let meta = field.get_variant_inner_properties()?;
+ let field = field.ident.as_ref().unwrap();
+
+ if let Some(default_with) = meta.default_with {
+ let func =
+ proc_macro2::Ident::new(&default_with.value(), default_with.span());
+ defaults.push(quote! {
+ #field: #func()
+ });
+ } else {
+ defaults.push(quote! { #field: Default::default() });
+ }
+ }
+
+ quote! { {#(#defaults),*} }
  }
  };
 
@@ -113,6 +131,7 @@ pub fn from_string_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
  }
  }
  };
+
  let standard_match_body = if standard_match_arms.is_empty() {
  default
  } else {
@@ -134,7 +153,6 @@ pub fn from_string_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
  }
  }
  };
-
  let try_from_str = try_from_str(
  name,
  &impl_generics,

strum_tests/tests/from_str.rs

@@ -17,6 +17,15 @@ enum Color {
  Purple,
  #[strum(serialize = "blk", serialize = "Black", ascii_case_insensitive)]
  Black,
+ Pink {
+ #[strum(default_with = "test_default")]
+ test_no_default: NoDefault,
+
+ #[strum(default_with = "string_test")]
+ string_test: String,
+ },
+ #[strum(default_with = "to_white")]
+ White(String),
 }
 
 #[rustversion::since(1.34)]
@@ -177,3 +186,46 @@ fn case_insensitive_enum_case_insensitive() {
  assert_from_str(CaseInsensitiveEnum::CaseInsensitive, "CaseInsensitive");
  assert_from_str(CaseInsensitiveEnum::CaseInsensitive, "caseinsensitive");
 }
+
+#[derive(Eq, PartialEq, Debug)]
+struct NoDefault(String);
+
+fn test_default() -> NoDefault {
+ NoDefault(String::from("test"))
+}
+
+fn to_white() -> String {
+ String::from("white-test")
+}
+
+fn string_test() -> String {
+ String::from("This is a string test")
+}
+
+#[test]
+fn color_default_with() {
+ match Color::from_str("Pink").unwrap() {
+ Color::Pink {
+ test_no_default,
+ string_test,
+ } => {
+ assert_eq!(test_no_default, test_default());
+ assert_eq!(string_test, String::from("This is a string test"));
+ }
+ other => {
+ panic!("Failed to get correct enum value {:?}", other);
+ }
+ }
+}
+
+#[test]
+fn color_default_with_white() {
+ match Color::from_str("White").unwrap() {
+ Color::White(inner) => {
+ assert_eq!(inner, String::from("white-test"));
+ }
+ other => {
+ panic!("Failed t o get correct enum value {:?}", other);
+ }
+ }
+}