scalp 0.4.3

A declarative parsing library for pretty and highly customizable command-line interfaces.
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

use crate::meta::Meta;
use core::ops::{Deref, DerefMut};

pub trait Scope: Into<Meta> + Extend<Meta> + DerefMut<Target = Vec<Meta>> {
    fn push(&mut self, meta: Meta) {
        self.extend([meta]);
    }
}

pub trait Version: Scope {}
pub trait Node: Scope {}

macro_rules! scope {
    ($name: ident, $meta: ident) => {
        #[derive(Default)]
        pub struct $name(Vec<Meta>);

        impl $name {
            pub const fn new() -> Self {
                Self(Vec::new())
            }
        }

        impl Scope for $name {}

        impl From<$name> for Meta {
            fn from(scope: $name) -> Self {
                Meta::$meta(scope.0)
            }
        }

        impl Extend<Meta> for $name {
            fn extend<T: IntoIterator<Item = Meta>>(&mut self, iter: T) {
                self.0.extend(iter);
            }
        }

        impl Deref for $name {
            type Target = Vec<Meta>;
            fn deref(&self) -> &Self::Target {
                &self.0
            }
        }

        impl DerefMut for $name {
            fn deref_mut(&mut self) -> &mut Self::Target {
                &mut self.0
            }
        }
    };
}

scope!(Root, Group);
scope!(Option, Option);
scope!(Group, Group);
scope!(Verb, Verb);

impl Version for Root {}
impl Version for Verb {}
impl Node for Root {}
impl Node for Group {}
impl Node for Verb {}