ruby-parser 0.0.0-dev1

A parser for the Ruby language
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

use crate::lexers::token::literal::string::double::double_quoted_string;
use crate::lexers::token::literal::string::quoted::non_expanded_delimited_string;
use crate::lexers::token::literal::string::single::single_quoted_string;
use crate::lexers::token::*;
use nom::branch::alt;
use nom::bytes::complete::tag;
use nom::character::complete::char;
use nom::combinator::{map, recognize};
use nom::sequence::tuple;

/// *symbol_literal* | *dynamic_symbol*
pub(crate) fn symbol(i: Input) -> TokenResult {
    alt((symbol_literal, dynamic_symbol))(i)
}

/// `:` *symbol_name*
pub(crate) fn symbol_literal(i: Input) -> TokenResult {
    map(recognize(tuple((char(':'), symbol_name))), |s| {
        Token::Symbol((*s).to_owned())
    })(i)
}

/// `:` *single_quoted_string*  | `:` *double_quoted_string* | `%s` *literal_beginning_delimiter* *non_expanded_literal_string** *literal_ending_delimiter*
pub(crate) fn dynamic_symbol(i: Input) -> TokenResult {
    alt((
        map(tuple((char(':'), single_quoted_string)), |mut t| {
            t.1.insert(0, ':');
            Token::Symbol(t.1)
        }),
        map(tuple((char(':'), double_quoted_string)), |t| match t.1 {
            Interpolatable::String(mut s) => {
                s.insert(0, ':');
                Token::Symbol(s)
            }
            Interpolatable::Interpolated(mut vec) => {
                vec.insert(0, Token::Segment(":".to_owned()));
                Token::InterpolatedSymbol(vec)
            }
        }),
        map(
            tuple((tag("%s"), non_expanded_delimited_string)),
            |mut t| {
                t.1.insert(0, ':');
                Token::Symbol(t.1)
            },
        ),
    ))(i)
}

/// *identifier* | *operator* | *keyword*
pub(crate) fn symbol_name(i: Input) -> ParseResult {
    alt((recognize(identifier), recognize(operator), keyword))(i)
}

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

    macro_rules! assert_symbol {
        ($a:expr, $b:expr) => {
            assert_ok!($a, Token::Symbol($b.to_owned()))
        };
    }
    macro_rules! assert_interpolated {
        ($a:expr, $b:expr) => {
            assert_ok!($a, Token::InterpolatedSymbol($b))
        };
    }

    #[test]
    fn test_symbol_literal() {
        use_parser!(symbol_literal);
        // Parse errors
        assert_err!(":");
        assert_err!("foo");
        assert_err!("::");
        assert_err!(":foo bar");
        assert_err!(":@");
        assert_err!(":@@");
        assert_err!(":$");
        assert_err!(":[");
        assert_err!(":====");
        assert_err!(":foo==");
        // Success cases
        assert_symbol!(":foo", ":foo");
        assert_symbol!(":_", ":_");
        assert_symbol!(":===", ":===");
        assert_symbol!(":!", ":!");
        assert_symbol!(":[]", ":[]");
        assert_symbol!(":foo=", ":foo=");
        assert_symbol!(":>=", ":>=");
        assert_symbol!(":if", ":if");
        assert_symbol!(":$glob", ":$glob");
        assert_symbol!(":@@v", ":@@v");
        assert_symbol!(":CONST", ":CONST");
        assert_symbol!(":😉😎", ":😉😎");
    }

    #[test]
    fn test_dynamic_symbol() {
        use_parser!(dynamic_symbol);
        // Parse errors
        assert_err!("''");
        assert_err!(":'");
        assert_err!(":'\"");
        assert_err!(":'foo bar''");
        // Success cases
        assert_symbol!(":''", ":");
        assert_symbol!(":\"\"", ":");
        assert_symbol!(":'foo #$bar'", ":foo #$bar");
        assert_symbol!(":'$123'", ":$123");
        assert_symbol!(":\"\\x00\"", ":\0");
        assert_symbol!(":\"foo\\nbar\"", ":foo\nbar");
        assert_symbol!("%s(foo #{2 + 4} bar)", ":foo #{2 + 4} bar");
        assert_interpolated!(
            ":\"foo#$bar\"",
            vec![
                Token::Segment(":".to_owned()),
                Token::Segment("foo".to_owned()),
                Token::GlobalVariableIdentifier("$bar".to_owned())
            ]
        );
    }
}