shadowplay 0.16.3

Utility for checking puppet syntax, a puppet manifest linter, a pretty printer, and a utility for exploring the Hiera.
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

use nom::{
    branch::alt,
    bytes::complete::tag,
    combinator::{map, opt},
    sequence::{pair, tuple},
};

use crate::puppet_parser::{
    common::{capture_comment, fold_many0_with_const_init, space0_delimimited},
    {range::Range, IResult, ParseError, Span},
};

pub fn parse_search_condition(
    input: Span,
) -> IResult<crate::puppet_lang::resource_collection::SearchExpression<Range>> {
    let parser = tuple((
        space0_delimimited(crate::puppet_parser::identifier::lowercase_identifier),
        alt((tag("=="), tag("!="))),
        space0_delimimited(crate::puppet_parser::term::parse_term),
    ));

    map(parser, |(name, op, expr)| match *op {
        "==" => crate::puppet_lang::resource_collection::SearchExpression {
            extra: Range::from((name, &expr.extra)),
            value: crate::puppet_lang::resource_collection::ExpressionVariant::Equal((
                crate::puppet_lang::resource_collection::Attribute {
                    extra: Range::from((name, name)),
                    name: name.to_string(),
                },
                expr,
            )),
        },
        "!=" => crate::puppet_lang::resource_collection::SearchExpression {
            extra: Range::from((name, &expr.extra)),
            value: crate::puppet_lang::resource_collection::ExpressionVariant::NotEqual((
                crate::puppet_lang::resource_collection::Attribute {
                    extra: Range::from((name, name)),
                    name: name.to_string(),
                },
                expr,
            )),
        },
        _ => unreachable!(),
    })(input)
}

fn parse_parens(input: Span) -> IResult<crate::puppet_lang::resource_collection::SearchExpression<Range>> {
    let parser = map(
        tuple((
            space0_delimimited(tag("(")),
            parse_search_expression,
            space0_delimimited(tag(")")),
        )),
        |(left_paren, expr, right_paren)| crate::puppet_lang::resource_collection::SearchExpression {
            extra: Range::from((left_paren, right_paren)),
            value: crate::puppet_lang::resource_collection::ExpressionVariant::Parens(Box::new(expr)),
        },
    );

    alt((parser, parse_search_condition))(input)
}

fn parse_search_expression(
    input: Span,
) -> IResult<crate::puppet_lang::resource_collection::SearchExpression<Range>> {
    let (input, left_expr) = space0_delimimited(parse_parens)(input)?;
    let mut parser = fold_many0_with_const_init(
        pair(
            alt((tag("and"), tag("or"))),
            space0_delimimited(ParseError::protect(
                |_| "Second argument of operator is expected".to_string(),
                parse_parens,
            )),
        ),
        left_expr,
        |prev, (op, cur)| match *op {
            "and" => crate::puppet_lang::resource_collection::SearchExpression {
                extra: Range::from((&prev.extra, &cur.extra)),
                value: crate::puppet_lang::resource_collection::ExpressionVariant::And((
                    Box::new(prev),
                    Box::new(cur),
                )),
            },
            "or" => crate::puppet_lang::resource_collection::SearchExpression {
                extra: Range::from((&prev.extra, &cur.extra)),
                value: crate::puppet_lang::resource_collection::ExpressionVariant::Or((
                    Box::new(prev),
                    Box::new(cur),
                )),
            },
            _ => unreachable!(),
        },
    );
    parser(input)
}

pub fn parse_resource_collection(
    input: Span,
) -> IResult<crate::puppet_lang::resource_collection::ResourceCollection<Range>> {
    let parser = tuple((
        capture_comment,
        crate::puppet_parser::typing::parse_type_specification,
        opt(tuple((
            space0_delimimited(tag("<|")),
            opt(parse_search_expression),
            space0_delimimited(tag("|>")),
        ))),
    ));

    map(
        parser,
        |(comment, type_specification, search_expression)| {
            let (search_expression, end_range) = match search_expression {
                Some((_left_tag, search_expression, right_tag)) => {
                    (Some(search_expression), Range::from((right_tag, right_tag)))
                }
                None => (None, type_specification.extra.clone()),
            };

            crate::puppet_lang::resource_collection::ResourceCollection {
                extra: Range::from((&type_specification.extra, &end_range)),
                type_specification,
                search_expression: search_expression.flatten(),
                comment,
            }
        },
    )(input)
}