clap-config-fallback-derive 0.1.13

Macro implementation of #[derive(ConfigParser)]
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
108
109
110
111

use proc_macro2::TokenStream;
use quote::{ToTokens, quote};
use syn::{Expr, GenericArgument, Ident, PathArguments, Type, parse_quote};

pub trait IntoTokenStream {
    fn into_token_stream(self) -> TokenStream;
}

impl<T, U> IntoTokenStream for T
where
    T: Iterator<Item = U>,
    U: ToTokens,
{
    fn into_token_stream(self) -> TokenStream {
        let tokens = self.map(|item| item.to_token_stream());

        quote! { #(#tokens)* }
    }
}

/// Extension trait for `syn::Type`.
pub trait TypeExt {
    /// Checks if the type is an `Option` of a specific identifier.
    /// Checks if the type is a specific identifier.
    fn is(&self, ident: &str) -> bool;

    /// Converts the type to an `Option` type if it is not already an `Option`.
    fn to_option(&self) -> Type;

    /// Unwraps an `Option` type to get the inner type, or returns the type itself if it is not an `Option`.
    fn unwrap_option(&self) -> Type;

    /// Get the innermost type
    fn unwrap_all(&self) -> Type;

    /// Checks if the type is the unit type `()`.
    fn is_unit(&self) -> bool;
}

impl TypeExt for Type {
    fn is_unit(&self) -> bool {
        matches!(self, Type::Tuple(tuple) if tuple.elems.is_empty())
    }

    fn is(&self, ident: &str) -> bool {
        if let Type::Path(type_path) = self
            && let Some(segment) = type_path.path.segments.last()
            && segment.ident == ident
        {
            true
        } else {
            false
        }
    }

    fn to_option(&self) -> Type {
        if self.is("Option") {
            self.clone()
        } else {
            parse_quote! { Option<#self> }
        }
    }

    fn unwrap_option(&self) -> Type {
        if let Type::Path(type_path) = self
            && let Some(segment) = type_path.path.segments.last()
            && segment.ident == "Option"
            && let PathArguments::AngleBracketed(args) = &segment.arguments
            && let Some(GenericArgument::Type(ty)) = args.args.first()
        {
            ty.clone()
        } else {
            self.clone()
        }
    }

    fn unwrap_all(&self) -> Type {
        if let Type::Path(type_path) = self
            && let Some(segment) = type_path.path.segments.last()
            && let PathArguments::AngleBracketed(args) = &segment.arguments
            && let Some(GenericArgument::Type(ty)) = args.args.first()
        {
            ty.unwrap_all()
        } else {
            self.clone()
        }
    }
}

/// Extension trait for `syn::Expr`.
pub trait ExprExt {
    /// Attempts to extract an identifier from the expression.
    fn ident(&self) -> Option<&Ident>;
}

impl ExprExt for Expr {
    fn ident(&self) -> Option<&Ident> {
        match self {
            Expr::Path(p) => p.path.get_ident(),
            Expr::Assign(a) => match &*a.left {
                Expr::Path(p) => p.path.get_ident(),
                _ => None,
            },
            Expr::Call(c) => match &*c.func {
                Expr::Path(p) => p.path.get_ident(),
                _ => None,
            },
            _ => None,
        }
    }
}