nym 0.1.0

Manipulate files en masse using patterns.
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

use itertools::Itertools as _;
use thiserror::Error;

use crate::glob::token::{self, Component, Token};
use crate::glob::{IteratorExt as _, SliceExt as _, Terminals};

#[derive(Debug, Error)]
#[non_exhaustive]
pub enum RuleError {
    #[error("invalid tree wildcard `**` in alternative")]
    AlternativeTree,
    #[error("invalid zero-or-more wildcard `*` or `$` in alternative")]
    AlternativeZeroOrMore,
    #[error("invalid separator `/`")]
    SeparatorAdjacent,
}

pub fn check<'t, I>(tokens: I) -> Result<(), RuleError>
where
    I: IntoIterator<Item = &'t Token<'t>>,
    I::IntoIter: Clone,
{
    let tokens = tokens.into_iter();
    alternative(tokens.clone())?;
    separator(tokens)?;
    Ok(())
}

fn alternative<'t, I>(tokens: I) -> Result<(), RuleError>
where
    I: IntoIterator<Item = &'t Token<'t>>,
    I::IntoIter: Clone,
{
    use crate::glob::token::Token::{Alternative, Wildcard};
    use crate::glob::token::Wildcard::{Tree, ZeroOrMore};
    use crate::glob::Terminals::{Only, StartEnd};

    fn recurse<'t>(
        components: impl Iterator<Item = Component<'t>>,
        parent: (Option<&Token<'t>>, Option<&Token<'t>>),
    ) -> Result<(), RuleError> {
        for component in components {
            for (left, alternative, right) in
                component
                    .tokens()
                    .iter()
                    .adjacent()
                    .filter_map(|adjacency| match adjacency.into_tuple() {
                        (left, Alternative(alternative), right) => Some((left, alternative, right)),
                        _ => None,
                    })
            {
                let left = left.cloned().or(parent.0);
                let right = right.cloned().or(parent.1);
                for tokens in alternative.branches() {
                    if let Some(terminals) = tokens.terminals() {
                        // Check branch terminals against the tokens adjacent to
                        // their corresponding alternative token.
                        check(terminals, left, right)?;
                    }
                    recurse(token::components(tokens), (left, right))?;
                }
            }
        }
        Ok(())
    }

    fn check<'t>(
        terminals: Terminals<&Token<'t>>,
        left: Option<&Token<'t>>,
        right: Option<&Token<'t>>,
    ) -> Result<(), RuleError> {
        match terminals {
            // TODO: Do not consider this an error and instead detect this in
            //       `token::optimize` and replace `{...,**,...}` with `**`.
            Only(Wildcard(Tree)) => {
                // Disallow singular tree tokens.
                //
                // For example, `{foo,**}`.
                Err(RuleError::AlternativeTree)
            }
            StartEnd(Wildcard(Tree), _) if left.is_some() => {
                // The alternative is prefixed; disallow leading tree tokens.
                //
                // For example, `foo{bar,**/baz}`.
                Err(RuleError::AlternativeTree)
            }
            StartEnd(_, Wildcard(Tree)) if right.is_some() => {
                // The alternative is postfixed; disallow trailing tree tokens.
                //
                // For example, `{foo,bar/**}baz`.
                Err(RuleError::AlternativeTree)
            }
            Only(Wildcard(ZeroOrMore(_)))
                if matches!(
                    (left, right),
                    (Some(Wildcard(ZeroOrMore(_))), _) | (_, Some(Wildcard(ZeroOrMore(_))))
                ) =>
            {
                // The alternative is adjacent to a zero-or-more token; disallow
                // singular zero-or-more tokens.
                //
                // For example, `foo*{bar,*,baz}`.
                Err(RuleError::AlternativeZeroOrMore)
            }
            StartEnd(Wildcard(ZeroOrMore(_)), _)
                if matches!(left, Some(Wildcard(ZeroOrMore(_)))) =>
            {
                // The alternative is prefixed by a zero-or-more token; disallow
                // leading zero-or-more tokens.
                //
                // For example, `foo*{bar,*baz}`.
                Err(RuleError::AlternativeZeroOrMore)
            }
            StartEnd(_, Wildcard(ZeroOrMore(_)))
                if matches!(right, Some(Wildcard(ZeroOrMore(_)))) =>
            {
                // The alternative is postfixed by a zero-or-more token;
                // disallow trailing zero-or-more tokens.
                //
                // For example, `{foo,bar*}*baz`.
                Err(RuleError::AlternativeZeroOrMore)
            }
            _ => Ok(()),
        }
    }

    recurse(token::components(tokens), (None, None))
}

fn separator<'t, I>(tokens: I) -> Result<(), RuleError>
where
    I: IntoIterator<Item = &'t Token<'t>>,
    I::IntoIter: Clone,
{
    if tokens
        .into_iter()
        .tuple_windows::<(_, _)>()
        .any(|adjacent| matches!(adjacent, (Token::Separator, Token::Separator)))
    {
        Err(RuleError::SeparatorAdjacent)
    }
    else {
        Ok(())
    }
}