Struct Attrs

pub struct Attrs<'a> { /* private fields */ }

Ergonomic Parser for #[attributes].

See crate documentation for more.

let mut untagged = false;
let mut krate = None::<syn::Path>;

let parseme: syn::Attribute = syn::parse_quote! {
    #[serde(untagged, crate = "path::to::serde")]
};

parseme.parse_args_with(
    Attrs::new()
        .once("untagged", set::flag(&mut untagged))
        .once("crate", with::eq(set::parse_str(&mut krate)))
)?;

assert!(krate.is_some() && untagged);

Implementations

impl<'a> Attrs<'a>

pub fn new() -> Self

Create a new empty parser.

pub fn contains<Q>(&self, key: &Q) -> bool

where Q: ?Sized, Ident: PartialEq<Q>,

Whether key already exists in this parser.

pub fn once<K, F>(&mut self, key: K, f: F) -> &mut Self

where K: UnwrapIdent, F: 'a + FnOnce(ParseStream<'_>) -> Result<()>,

Parse tokens following key using f, at most once.

See crate documentation for more.

Panics

• If key has already been registered.
• If key is an invalid ident.

pub fn many<K, F>(&mut self, key: K, f: F) -> &mut Self

where K: UnwrapIdent, F: 'a + FnMut(ParseStream<'_>) -> Result<()>,

Parse tokens following key using f, potentially many times.

See crate documentation for more.

Panics

• If key has already been registered.
• If key is an invalid ident.

pub fn fallback<F>(&mut self, f: F) -> &mut Self

where F: 'a + FnMut(&Ident, ParseStream<'_>) -> Result<()>,

Parse unrecognised keys using f.

let mut krate = None::<syn::Path>;

let parseme: syn::Attribute = syn::parse_quote! {
    #[serde(crate = "path::to::serde")]
};

parseme.parse_args_with(Attrs::new().fallback(|key, input| {
    assert_eq!(key, "crate");
    input.parse::<syn::Token![=]>()?;
    krate = Some(input.parse::<syn::LitStr>()?.parse()?);
    Ok(())
}))?;

assert!(krate.is_some());

pub fn alias<A, K>(&mut self, alias: A, key: K) -> &mut Self

where A: UnwrapIdent, K: UnwrapIdent,

If the key alias is encountered, call the parser for key.

See module documentation for more.

Panics

• If alias has already been registered.
• If alias is an invalid ident.
• If key has not been registered.

pub fn parse_attrs<Q>(&mut self, path: &Q, attrs: &[Attribute]) -> Result<()>

where Q: ?Sized, Ident: PartialEq<Q>,

Parse all the Attributes where their path is the given path.

let mut rename_all = None::<String>;
let mut untagged = false;
let mut deny_unknown_fields = false;
let attrs: Vec<Attribute> = parse_quote! {
    #[serde(rename_all = "kebab-case", untagged)]
    #[default] // SKIPPED
    #[serde(deny_unknown_fields)]
};

Attrs::new()
    .once("rename_all", with::eq(set::from_str(&mut rename_all)))
    .once("untagged", set::flag(&mut untagged))
    .once("deny_unknown_fields", set::flag(&mut deny_unknown_fields))
    .parse_attrs("serde", &attrs)?;

assert!(rename_all.is_some() && untagged && deny_unknown_fields);

pub fn extract_from<Q>( &mut self, path: &Q, attrs: &mut Vec<Attribute>, ) -> Result<()>

where Q: ?Sized, Ident: PartialEq<Q>,

Parse and remove all the Attributes where their path is the given path.

let mut rename_all = None::<String>;
let mut untagged = false;
let mut deny_unknown_fields = false;
let mut attrs: Vec<Attribute> = parse_quote! {
    #[serde(rename_all = "kebab-case", untagged)]
    #[default] // SKIPPED
    #[serde(deny_unknown_fields)]
};

Attrs::new()
    .once("rename_all", with::eq(set::from_str(&mut rename_all)))
    .once("untagged", set::flag(&mut untagged))
    .once("deny_unknown_fields", set::flag(&mut deny_unknown_fields))
    .extract_from("serde", &mut attrs)?;

assert!(rename_all.is_some() && untagged && deny_unknown_fields);
assert_eq!(attrs.len(), 1); // `#[default]` is still there

Trait Implementations

impl Debug for Attrs<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Default for Attrs<'a>

fn default() -> Attrs<'a>

Returns the “default value” for a type.

impl Parser for &mut Attrs<'_>

Borrow from this object as a Parser.

use syn::parse::Parser as _;

let mut untagged = false;
let mut krate = None::<Path>;

Attrs::new()
    .once("untagged", set::flag(&mut untagged))
    .once("crate", with::eq(set::parse_str(&mut krate)))
    .parse_str(r#"untagged, crate = "path::to::serde""#)?;

assert!(krate.is_some() && untagged);

type Output = ()

fn parse2(self, tokens: TokenStream) -> Result<Self::Output>

Parse a proc-macro2 token stream into the chosen syntax tree node.

fn parse_str(self, s: &str) -> Result<Self::Output, Error>

Parse a string of Rust code into the chosen syntax tree node.

impl Parser for Attrs<'_>

Move this object into a Parser.

use syn::parse::Parser as _;

let mut untagged = false;
let mut krate = None::<Path>;

let mut attrs = Attrs::new();
attrs
    .once("untagged", set::flag(&mut untagged))
    .once("crate", with::eq(set::parse_str(&mut krate)));
attrs.parse_str(r#"untagged, crate = "path::to::serde""#)?;

assert!(krate.is_some() && untagged);

type Output = ()

fn parse2(self, tokens: TokenStream) -> Result<Self::Output>

Parse a proc-macro2 token stream into the chosen syntax tree node.

fn parse_str(self, s: &str) -> Result<Self::Output, Error>

Parse a string of Rust code into the chosen syntax tree node.