golem-rib 1.3.1

Parser for Golem's Rib language
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

// Copyright 2024-2025 Golem Cloud
//
// Licensed under the Golem Source License v1.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://license.golem.cloud/LICENSE
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use combine::parser::char::digit;
use combine::{attempt, sep_by};
use combine::{
    many1,
    parser::char::{char as char_, letter, spaces},
    ParseError, Parser,
};

use crate::expr::Expr;
use crate::parser::errors::RibParseError;
use crate::rib_source_span::GetSourcePosition;

pub fn flag<Input>() -> impl Parser<Input, Output = Expr>
where
    Input: combine::Stream<Token = char>,
    RibParseError: Into<
        <Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError,
    >,
    Input::Position: GetSourcePosition,
{
    let flag_name = many1(letter().or(char_('_')).or(digit()).or(char_('-')))
        .map(|s: Vec<char>| s.into_iter().collect());

    (
        char_('{').skip(spaces().silent()),
        sep_by(
            attempt(flag_name.skip(spaces().silent())),
            char_(',').skip(spaces().silent()),
        ),
        char_('}').skip(spaces().silent()),
    )
        .map(|(_, flags, _): (_, Vec<String>, _)| Expr::flags(flags))
}

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

    use super::*;

    #[test]
    fn test_empty_flag() {
        let input = "{}";
        let result = Expr::from_text(input);
        assert_eq!(result, Ok(Expr::flags(vec![])));
    }

    #[test]
    fn test_flag_singleton() {
        let input = "{foo}";
        let result = Expr::from_text(input);
        assert_eq!(result, Ok(Expr::flags(vec!["foo".to_string()])));
    }

    #[test]
    fn test_flag() {
        let input = "{ foo, bar}";
        let result = Expr::from_text(input);
        assert_eq!(
            result,
            Ok(Expr::flags(vec!["foo".to_string(), "bar".to_string()]))
        );
    }

    #[test]
    fn test_bool_str_flags() {
        let input = "{true, false}";
        let result = Expr::from_text(input);
        assert_eq!(
            result,
            Ok(Expr::flags(vec!["true".to_string(), "false".to_string()]))
        );
    }
}