axe-cli 0.3.0

axe - Argument execute is xargs alternative that focus on arguments processing and ordering.
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

use logos::Logos;

use super::tokens::{ArgPlaceholderToken, ArgPlaceholderToken::*, ArgTemplateToken, LexingError};
use super::ArgTemplatePart;
use super::ResolvedArgument;

pub fn resolve_template_args(
    arg_templates: &[String],
) -> Result<Vec<ResolvedArgument>, LexingError> {
    arg_templates
        .iter()
        .map(|a| resolve_arg_template(a.as_str()))
        .collect()
}

fn resolve_arg_template(arg_template: &str) -> Result<ResolvedArgument, LexingError> {
    let mut lex = ArgTemplateToken::lexer(arg_template);
    let mut resolved = Vec::new();
    while let Some(token) = lex.next() {
        match token? {
            ArgTemplateToken::ArgPlaceholder => {
                let ra = resolve_arg_placeholder(lex.slice())?;
                resolved.push(ra);
            }
            ArgTemplateToken::FreeText => {
                let ra = ArgTemplatePart::FreeText(lex.slice());
                resolved.push(ra)
            }
            ArgTemplateToken::EscapedText => {
                let ra = ArgTemplatePart::FreeText(&lex.slice()[1..]);
                resolved.push(ra)
            }
        }
    }
    Ok(resolved)
}

fn resolve_arg_placeholder(placeholder: &str) -> Result<ArgTemplatePart, LexingError> {
    let lex = ArgPlaceholderToken::lexer(placeholder);
    let tokens = lex.collect::<Result<Vec<ArgPlaceholderToken>, LexingError>>()?;
    match tokens.as_slice() {
        [BraceOpen, Index(index), BraceClose] => Ok(ArgTemplatePart::Index(*index)),
        [BraceOpen, Index(index), Separator(sep), BraceClose] => {
            Ok(ArgTemplatePart::IndexSplit(*index, sep))
        }
        [BraceOpen, Index(index), Separator(sep), Index(index2), BraceClose] => {
            Ok(ArgTemplatePart::IndexSplitIndex(*index, sep, *index2))
        }
        [BraceOpen, Separator(sep), Index(index), BraceClose] => {
            Ok(ArgTemplatePart::SplitIndex(sep, *index))
        }
        [BraceOpen, Separator(sep), BraceClose] => Ok(ArgTemplatePart::Split(sep)),
        [BraceOpen, BraceClose] => Ok(ArgTemplatePart::Empty),
        _ => Err(LexingError::InvalidDefinition),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn should_parse_arg_template() {
        assert_eq!(
            vec![
                ArgTemplatePart::FreeText("freeText"),
                ArgTemplatePart::IndexSplitIndex(0, ".", 0),
                ArgTemplatePart::FreeText("-"),
                ArgTemplatePart::Split("."),
                ArgTemplatePart::Empty,
                ArgTemplatePart::FreeText("text"),
                ArgTemplatePart::FreeText("{EscapedText}"),
                ArgTemplatePart::FreeText("{{}}"),
            ],
            resolve_arg_template(r"freeText{0.0}-{.}{}text\{EscapedText}\{{}}").unwrap()
        );
    }

    #[test]
    fn should_fail_to_parse_arg_template() {
        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_template("{{0}}").unwrap_err()
        );

        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_template(r"\{\{0}}").unwrap_err()
        );
    }

    #[test]
    fn should_parse_arg_placeholders() {
        assert_eq!(
            ArgTemplatePart::Index(0),
            resolve_arg_placeholder("{0}").unwrap()
        );
        assert_eq!(
            ArgTemplatePart::IndexSplit(0, "."),
            resolve_arg_placeholder("{0.}").unwrap()
        );
        assert_eq!(
            ArgTemplatePart::IndexSplitIndex(0, ".", 1),
            resolve_arg_placeholder("{0.1}").unwrap()
        );
        assert_eq!(
            ArgTemplatePart::SplitIndex(".", 0),
            resolve_arg_placeholder("{.0}").unwrap()
        );
        assert_eq!(
            ArgTemplatePart::Split("."),
            resolve_arg_placeholder("{.}").unwrap()
        );
        assert_eq!(
            ArgTemplatePart::Empty,
            resolve_arg_placeholder("{}").unwrap()
        );
    }

    #[test]
    fn should_fail_to_parse_arg_placeholders() {
        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_placeholder("{").unwrap_err()
        );
        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_placeholder("}").unwrap_err()
        );
        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_placeholder("{0").unwrap_err()
        );
        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_placeholder("{0.").unwrap_err()
        );
        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_placeholder("{0.1").unwrap_err()
        );
        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_placeholder("xxx").unwrap_err()
        );
        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_placeholder("0.0").unwrap_err()
        );
        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_placeholder("{0}x").unwrap_err()
        );
        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_placeholder("0{0}").unwrap_err()
        );
        assert_eq!(
            LexingError::InvalidDefinition,
            resolve_arg_placeholder("{{0}}").unwrap_err()
        );
    }
}