negate 0.1.1

Attribute macro that generates negated versions of functions that return booleans.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use syn::{AttributeArgs, Lit, LitStr, NestedMeta};

use crate::error::Error;

#[derive(Default)]
pub struct Args {
    // The name of the generated function
    pub name: Option<String>,
    // The doc-string of the generated function
    pub docs: Option<String>,
}

impl Args {
    pub fn set_name(&mut self, name: String) -> Result<(), Error> {
        if self.name.is_some() {
            Err(Error::ConflictingArgs)
        } else {
            self.name = Some(name);
            Ok(())
        }
    }

    pub fn set_docs(&mut self, docs: String) -> Result<(), Error> {
        if self.docs.is_some() {
            Err(Error::ConflictingArgs)
        } else {
            self.docs = Some(docs);
            Ok(())
        }
    }
}

enum ArgKind {
    Docs(LitStr),
    Name(LitStr),
}

fn literal_into_string_literal(literal: Lit) -> Result<LitStr, Error> {
    if let Lit::Str(lit_str) = literal {
        Ok(lit_str)
    } else {
        Err(Error::StringLiteralExpected)
    }
}

fn parse_meta_into_string_literal(nested_meta: NestedMeta) -> Result<ArgKind, Error> {
    let meta = match nested_meta {
        NestedMeta::Meta(meta) => meta,
        NestedMeta::Lit(_) => Err(Error::NestedMetaExpected)?,
    };

    let pair = match meta {
        syn::Meta::NameValue(pair) => pair,
        _ => Err(Error::NameValueExpected)?,
    };

    if pair.path.is_ident("docs") {
        Ok(ArgKind::Docs(literal_into_string_literal(pair.lit)?))
    } else if pair.path.is_ident("name") {
        Ok(ArgKind::Name(literal_into_string_literal(pair.lit)?))
    } else {
        Err(Error::UnexpectedName)
    }
}

pub fn parse_args(attrib_args: AttributeArgs) -> Result<Args, Error> {
    let mut args = Args::default();

    if attrib_args.is_empty() {
        return Ok(args);
    }

    let literals: Result<Vec<_>, _> = attrib_args
        .into_iter()
        .map(parse_meta_into_string_literal)
        .collect();

    let literals = literals?;

    if literals.len() > 2 {
        Err(Error::TooManyArgsSupplied)?;
    }

    for literal in literals {
        match literal {
            ArgKind::Docs(docs) => args.set_docs(docs.value())?,
            ArgKind::Name(name) => args.set_name(name.value())?,
        }
    }

    Ok(args)
}