gflags-impl 0.3.12

Macros for gflags crate
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use proc_macro2::TokenStream;
use quote::{quote, ToTokens};
use std::fmt::{self, Display};
use syn::ext::IdentExt;
use syn::parse::{Error, Parse, ParseStream, Result};
use syn::punctuated::{Pair, Punctuated};
use syn::{Ident, Token};

pub enum Name {
    Short(Short),
    Long(Long),
}

pub struct Short {
    pub hyphen: Token![-],
    pub ch: Ident,
}

pub struct Long {
    pub hyphen1: Token![-],
    pub hyphen2: Token![-],
    pub segments: Punctuated<Ident, Token![-]>,
}

impl Short {
    pub fn ch(&self) -> char {
        self.ch.to_string().chars().next().unwrap()
    }
}

impl Long {
    pub fn to_ident(&self) -> Ident {
        let span = self.segments[0].span();
        let symbol = self.to_string().replace('-', "_").to_uppercase();
        Ident::new(&symbol, span)
    }
}

impl Parse for Name {
    fn parse(input: ParseStream) -> Result<Self> {
        let hyphen1: Token![-] = input.parse()?;

        if input.fork().call(Ident::parse_any).is_ok() {
            let short = input.call(Ident::parse_any)?;
            if short.to_string().chars().count() > 1 {
                let spanned = quote!(#hyphen1 #short);
                let msg = "short flag must be a single character";
                return Err(Error::new_spanned(spanned, msg));
            }
            Ok(Name::Short(Short {
                hyphen: hyphen1,
                ch: short,
            }))
        } else if let Some(hyphen2) = input.parse()? {
            let segments = input.call(parse_long_segments)?;
            Ok(Name::Long(Long {
                hyphen1,
                hyphen2,
                segments,
            }))
        } else {
            Err(input.error("expected short (-v) or long (--verbose) flag"))
        }
    }
}

fn parse_long_segments(input: ParseStream) -> Result<Punctuated<Ident, Token![-]>> {
    let mut segments = Punctuated::new();
    let first = input.call(Ident::parse_any)?;
    segments.push_value(first);

    while input.peek(Token![-]) {
        let hyphen: Token![-] = input.parse()?;
        segments.push_punct(hyphen);
        let segment = input.call(Ident::parse_any)?;
        segments.push_value(segment);
    }

    Ok(segments)
}

impl ToTokens for Short {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        self.hyphen.to_tokens(tokens);
        self.ch.to_tokens(tokens);
    }
}

impl ToTokens for Long {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        self.hyphen1.to_tokens(tokens);
        self.hyphen2.to_tokens(tokens);
        self.segments.to_tokens(tokens);
    }
}

impl Display for Long {
    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        for pair in self.segments.pairs() {
            match pair {
                Pair::Punctuated(ident, _hyphen) => write!(formatter, "{}-", ident)?,
                Pair::End(ident) => write!(formatter, "{}", ident)?,
            }
        }
        Ok(())
    }
}