parkour 0.1.0

A fast, extensible command-line arguments parser
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
112
113
114
115
116
117
118
119
120
121
122

use crate::util::{ArgCtx, Flag, PosCtx};
use crate::{Error, ErrorInner, FromInput, FromInputValue, Parse};

use super::{
    Action, ApplyResult, Reset, Set, SetOnce, SetPositional, SetSubcommand, Unset,
};

impl<V: FromInputValue> Action<ArgCtx<'static, V::Context>> for Set<'_, Option<V>> {
    fn apply<P: Parse>(
        self,
        input: &mut P,
        context: &ArgCtx<'static, V::Context>,
    ) -> ApplyResult {
        match input
            .try_parse(context)
            .map_err(|e| e.with_source(Error::in_argument(&context.flag)))?
        {
            Some(s) => {
                *self.0 = Some(s);
                Ok(true)
            }
            None => Ok(false),
        }
    }
}

impl<V: FromInputValue> Action<ArgCtx<'static, V::Context>> for SetOnce<'_, Option<V>> {
    fn apply<P: Parse>(
        self,
        input: &mut P,
        context: &ArgCtx<'static, V::Context>,
    ) -> ApplyResult {
        match input
            .try_parse(context)
            .map_err(|e| e.with_source(Error::in_argument(&context.flag)))?
        {
            Some(s) => {
                if self.0.is_some() {
                    return Err(ErrorInner::TooManyArgOccurrences {
                        arg: context.flag.first_to_string(),
                        max: Some(1),
                    }
                    .into());
                }
                *self.0 = Some(s);
                Ok(true)
            }
            None => Ok(false),
        }
    }
}

impl<'a, V: FromInputValue> Action<Flag<'a>> for Reset<'_, Option<V>> {
    fn apply<P: Parse>(self, input: &mut P, context: &Flag<'a>) -> ApplyResult {
        if Flag::from_input(input, context)? {
            *self.0 = None;
            Ok(true)
        } else {
            Ok(false)
        }
    }
}

impl<'a, V: FromInputValue> Action<Flag<'a>> for Unset<'_, Option<V>> {
    fn apply<P: Parse>(self, input: &mut P, context: &Flag<'a>) -> ApplyResult {
        if Flag::from_input(input, context)? {
            if self.0.is_none() {
                return Err(ErrorInner::TooManyArgOccurrences {
                    arg: context.first_to_string(),
                    max: None,
                }
                .into());
            }
            *self.0 = None;
            Ok(true)
        } else {
            Ok(false)
        }
    }
}

impl<'a, T: FromInputValue> Action<PosCtx<'a, T::Context>>
    for SetPositional<'_, Option<T>>
{
    fn apply<P: Parse>(
        self,
        input: &mut P,
        context: &PosCtx<'a, T::Context>,
    ) -> ApplyResult {
        if let Some(s) = input.try_parse_value(&context.inner)? {
            if self.0.is_some() {
                return Err(ErrorInner::TooManyArgOccurrences {
                    arg: context.name.to_string(),
                    max: None,
                }
                .into());
            }
            *self.0 = Some(s);
            Ok(true)
        } else {
            Ok(false)
        }
    }
}

impl<T: FromInput> Action<T::Context> for SetSubcommand<'_, Option<T>> {
    fn apply<P: Parse>(self, input: &mut P, context: &T::Context) -> ApplyResult {
        if let Some(s) = input.try_parse(context)? {
            if self.0.is_some() {
                return Err(ErrorInner::TooManyArgOccurrences {
                    arg: "subcommand".to_string(),
                    max: None,
                }
                .into());
            }
            *self.0 = Some(s);
            Ok(true)
        } else {
            Ok(false)
        }
    }
}