use darling::{Error, FromMeta};
use syn::parse_quote;
#[derive(Debug, FromMeta)]
#[darling(derive_syn_parse)]
struct Meta {
#[darling(default)]
meta1: Option<String>,
#[darling(default)]
meta2: bool,
}
#[test]
fn nested_meta_meta_value() {
let meta = Meta::from_list(&[parse_quote! {
meta1 = "thefeature"
}])
.unwrap();
assert_eq!(meta.meta1, Some("thefeature".to_string()));
assert!(!meta.meta2);
}
#[test]
fn nested_meta_meta_bool() {
let meta = Meta::from_list(&[parse_quote! {
meta2
}])
.unwrap();
assert_eq!(meta.meta1, None);
assert!(meta.meta2);
}
#[test]
fn nested_meta_lit_string_errors() {
let err = Meta::from_list(&[parse_quote! {
"meta2"
}])
.unwrap_err();
assert_eq!(
err.to_string(),
Error::unsupported_format("literal").to_string()
);
}
#[test]
fn nested_meta_lit_integer_errors() {
let err = Meta::from_list(&[parse_quote! {
2
}])
.unwrap_err();
assert_eq!(
err.to_string(),
Error::unsupported_format("literal").to_string()
);
}
#[test]
fn nested_meta_lit_bool_errors() {
let err = Meta::from_list(&[parse_quote! {
true
}])
.unwrap_err();
assert_eq!(
err.to_string(),
Error::unsupported_format("literal").to_string()
);
}
#[test]
fn parse_impl() {
let meta = parse_quote! {
meta1 = "thefeature",
meta2
};
let parsed_meta: Meta = syn::parse2(meta).unwrap();
assert_eq!(parsed_meta.meta1, Some("thefeature".to_string()));
assert!(parsed_meta.meta2);
}
mod enum_impl {
use darling::{Error, FromMeta};
use syn::parse_quote;
#[derive(Debug, Clone, Copy, PartialEq, Eq, FromMeta)]
enum Volume {
Normal,
Low,
High,
#[darling(rename = "dB")]
Decibels(u8),
}
#[test]
fn string_for_unit_variant() {
let volume = Volume::from_string("low").unwrap();
assert_eq!(volume, Volume::Low);
}
#[test]
fn single_value_list() {
let unit_variant = Volume::from_list(&[parse_quote!(high)]).unwrap();
assert_eq!(unit_variant, Volume::High);
let newtype_variant = Volume::from_list(&[parse_quote!(dB = 100)]).unwrap();
assert_eq!(newtype_variant, Volume::Decibels(100));
}
#[test]
fn empty_list_errors() {
let err = Volume::from_list(&[]).unwrap_err();
assert_eq!(err.to_string(), Error::too_few_items(1).to_string());
}
#[test]
fn multiple_values_list_errors() {
let err = Volume::from_list(&[parse_quote!(low), parse_quote!(dB = 20)]).unwrap_err();
assert_eq!(err.to_string(), Error::too_many_items(1).to_string());
}
}
mod keyword {
use darling::FromMeta;
use quote::quote;
use syn::{parse2, parse_quote, Path, Type};
#[derive(Debug, FromMeta)]
struct Keyword {
#[darling(rename = "type")]
ty: Type,
#[darling(rename = "fn")]
func: Path,
}
#[derive(Debug, FromMeta)]
struct FlattenKeyword {
#[darling(rename = "ref")]
reference: Type,
#[darling(flatten)]
keyword: Keyword,
}
#[derive(Debug, PartialEq, Eq, FromMeta)]
enum UnitEnumKeyword {
#[darling(rename = "enum")]
Enum,
#[darling(rename = "struct")]
Struct,
#[darling(rename = "trait")]
Trait,
}
#[derive(Debug, FromMeta)]
struct FlattenEnumKeyword {
#[darling(rename = "ref")]
reference: Type,
#[darling(flatten)]
keyword: UnitEnumKeyword,
}
#[test]
fn keywords() {
let meta = quote! {
outer(type = "u32", fn = foo)
};
let keyword = Keyword::from_meta(&parse2(meta).unwrap()).unwrap();
assert_eq!(keyword.ty, parse_quote!(u32));
assert_eq!(keyword.func, parse_quote!(foo));
}
#[test]
fn flatten_keywords() {
let meta = quote! {
outer(ref = "u32", type = "i32", fn = bar)
};
let keyword = FlattenKeyword::from_meta(&parse2(meta).unwrap()).unwrap();
assert_eq!(keyword.reference, parse_quote!(u32));
assert_eq!(keyword.keyword.ty, parse_quote!(i32));
assert_eq!(keyword.keyword.func, parse_quote!(bar));
}
#[test]
fn enum_keywords() {
let enum_ = quote! {
outer(enum)
};
let unit_enum = UnitEnumKeyword::from_meta(&parse2(enum_).unwrap()).unwrap();
assert_eq!(unit_enum, UnitEnumKeyword::Enum);
let struct_ = quote! {
outer(struct)
};
let unit_enum = UnitEnumKeyword::from_meta(&parse2(struct_).unwrap()).unwrap();
assert_eq!(unit_enum, UnitEnumKeyword::Struct);
}
#[test]
fn flatten_enum_keywords() {
let meta = quote! {
outer(ref = "u32", enum)
};
let keyword = FlattenEnumKeyword::from_meta(&parse2(meta).unwrap()).unwrap();
assert_eq!(keyword.reference, parse_quote!(u32));
assert_eq!(keyword.keyword, UnitEnumKeyword::Enum);
let meta = quote! {
outer(ref = "u32", struct)
};
let keyword = FlattenEnumKeyword::from_meta(&parse2(meta).unwrap()).unwrap();
assert_eq!(keyword.reference, parse_quote!(u32));
assert_eq!(keyword.keyword, UnitEnumKeyword::Struct);
}
}
mod from_none_struct_closure {
use darling::FromMeta;
use syn::parse_quote;
#[derive(Debug, FromMeta)]
struct Outer {
speech: Example,
}
#[derive(Debug, FromMeta)]
#[darling(from_none = || Some(Default::default()))]
struct Example {
max_volume: u32,
}
impl Default for Example {
fn default() -> Self {
Example { max_volume: 3 }
}
}
#[test]
fn absent_gets_from_none() {
let thing = Outer::from_list(&[]).unwrap();
assert_eq!(thing.speech.max_volume, 3);
}
#[test]
fn word_errors() {
let error = Outer::from_list(&[parse_quote!(speech)])
.expect_err("speech should require its fields if declared");
assert_eq!(error.len(), 1);
}
#[test]
fn list_sets_field() {
let thing = Outer::from_list(&[parse_quote!(speech(max_volume = 5))]).unwrap();
assert_eq!(thing.speech.max_volume, 5);
}
}
mod from_none_struct_path {
use darling::FromMeta;
use syn::parse_quote;
#[derive(Debug, FromMeta)]
struct Outer {
speech: Example,
}
fn from_none_fallback() -> Option<Example> {
Some(Example { max_volume: 3 })
}
#[derive(Debug, FromMeta)]
#[darling(from_none = from_none_fallback)]
struct Example {
max_volume: u32,
}
#[test]
fn absent_gets_from_none() {
let thing = Outer::from_list(&[]).unwrap();
assert_eq!(thing.speech.max_volume, 3);
}
#[test]
fn word_errors() {
let error = Outer::from_list(&[parse_quote!(speech)])
.expect_err("speech should require its fields if declared");
assert_eq!(error.len(), 1);
}
#[test]
fn list_sets_field() {
let thing = Outer::from_list(&[parse_quote!(speech(max_volume = 5))]).unwrap();
assert_eq!(thing.speech.max_volume, 5);
}
}
mod from_word_struct_closure {
use darling::FromMeta;
use syn::parse_quote;
#[derive(FromMeta)]
struct Outer {
#[darling(default)]
speech: Example,
}
#[derive(FromMeta, Default)]
#[darling(from_word = || Ok(Example { max_volume: 10 }))]
struct Example {
max_volume: u32,
}
#[test]
fn absent_gets_default() {
let thing = Outer::from_list(&[]).unwrap();
assert_eq!(thing.speech.max_volume, 0);
}
#[test]
fn word_gets_value() {
let thing = Outer::from_list(&[parse_quote!(speech)]).unwrap();
assert_eq!(thing.speech.max_volume, 10);
}
#[test]
fn list_sets_field() {
let thing = Outer::from_list(&[parse_quote!(speech(max_volume = 5))]).unwrap();
assert_eq!(thing.speech.max_volume, 5);
}
}
mod from_word_struct_path {
use darling::FromMeta;
use syn::parse_quote;
#[derive(FromMeta)]
struct Outer {
#[darling(default)]
speech: Example,
}
fn max_volume_10() -> darling::Result<Example> {
Ok(Example { max_volume: 10 })
}
#[derive(FromMeta, Default)]
#[darling(from_word = max_volume_10)]
struct Example {
max_volume: u32,
}
#[test]
fn absent_gets_default() {
let thing = Outer::from_list(&[]).unwrap();
assert_eq!(thing.speech.max_volume, 0);
}
#[test]
fn word_gets_value() {
let thing = Outer::from_list(&[parse_quote!(speech)]).unwrap();
assert_eq!(thing.speech.max_volume, 10);
}
#[test]
fn list_sets_field() {
let thing = Outer::from_list(&[parse_quote!(speech(max_volume = 5))]).unwrap();
assert_eq!(thing.speech.max_volume, 5);
}
}
mod from_word_enum_closure {
use darling::FromMeta;
use syn::parse_quote;
#[derive(Debug, FromMeta)]
struct Outer {
speech: Example,
}
#[derive(Debug, FromMeta, PartialEq, Eq)]
#[darling(from_word = || Ok(Example::Left { max_volume: 10 }))]
enum Example {
Left { max_volume: u32 },
Right { speed: u32 },
}
#[test]
fn word_gets_value() {
let thing = Outer::from_list(&[parse_quote!(speech)]).unwrap();
assert_eq!(thing.speech, Example::Left { max_volume: 10 });
}
#[test]
fn list_sets_field() {
let thing = Outer::from_list(&[parse_quote!(speech(left(max_volume = 5)))]).unwrap();
assert_eq!(thing.speech, Example::Left { max_volume: 5 });
}
#[test]
fn variant_word_fails() {
let thing = Outer::from_list(&[parse_quote!(speech(left))]).expect_err(
"A variant word is an error because from_word applies at the all-up enum level",
);
assert_eq!(thing.len(), 1);
}
}