fluidattacks-blends-domain 0.32.0

Blends functional core: pure AST graph to syntax graph (no_std)
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

use crate::syntax::readers::ruby;
use crate::syntax::SyntaxReader;

#[must_use]
pub fn dispatcher(node_type: &str) -> Option<SyntaxReader> {
    match node_type {
        "program" => Some(ruby::program::reader),
        "integer" => Some(ruby::integer::reader),
        "interpolation" => Some(ruby::interpolation::reader),
        "false" | "true" => Some(ruby::boolean_literal::reader),
        "nil" => Some(ruby::nil::reader),
        "comment" => Some(ruby::comment::reader),
        "regex" | "string" => Some(ruby::string_literal::reader),
        "string_content" => Some(ruby::string_content::reader),
        "constant" | "hash_key_symbol" | "identifier" | "instance_variable" | "simple_symbol" => {
            Some(ruby::identifier::reader)
        }
        "subshell" => Some(ruby::subshell::reader),
        "binary" => Some(ruby::binary_expression::reader),
        "scope_resolution" => Some(ruby::scope_resolution::reader),
        "element_reference" => Some(ruby::element_reference::reader),
        "array" => Some(ruby::array_node::reader),
        "call" => Some(ruby::call::reader),
        "argument_list" => Some(ruby::argument_list::reader),
        "body_statement" | "do" | "do_block" | "else" | "then" | "block" | "block_body" => {
            Some(ruby::execution_block::reader)
        }
        "return" => Some(ruby::return_statement::reader),
        "hash" => Some(ruby::hash::reader),
        "assignment" => Some(ruby::assignment::reader),
        "pair" => Some(ruby::pair::reader),
        "module" => Some(ruby::module_definition::reader),
        "method_parameters" => Some(ruby::method_parameters::reader),
        "block_parameters" => Some(ruby::parameters::reader),
        "block_parameter" | "hash_splat_parameter" | "optional_parameter" | "splat_parameter" => {
            Some(ruby::parameter::reader)
        }
        "class" | "singleton_class" => Some(ruby::class_definition::reader),
        "method" | "singleton_method" => Some(ruby::method_declaration::reader),
        "elsif" | "if" => Some(ruby::if_conditional::reader),
        "if_modifier" => Some(ruby::if_modifier::reader),
        "unless_modifier" | "unless" => Some(ruby::unless::reader),
        "while" | "while_modifier" => Some(ruby::while_statement::reader),
        "for" => Some(ruby::for_statement::reader),
        "begin" => Some(ruby::begin::reader),
        "rescue_modifier" => Some(ruby::try_statement::reader),
        "rescue" => Some(ruby::catch_declaration::reader),
        "exception_variable" => Some(ruby::exception_variable::reader),
        _ => None,
    }
}

#[cfg(test)]
mod tests {
    use super::dispatcher;
    #[test]
    #[allow(
        clippy::too_many_lines,
        reason = "one match arm per migrated c# node type; grows with the migration"
    )]
    fn maps_the_implemented_ruby_node_types() {
        assert!(dispatcher("program").is_some());
        assert!(dispatcher("integer").is_some());
        assert!(dispatcher("interpolation").is_some());
        assert!(dispatcher("false").is_some());
        assert!(dispatcher("true").is_some());
        assert!(dispatcher("nil").is_some());
        assert!(dispatcher("comment").is_some());
        assert!(dispatcher("regex").is_some());
        assert!(dispatcher("string_content").is_some());
        assert!(dispatcher("constant").is_some());
        assert!(dispatcher("hash_key_symbol").is_some());
        assert!(dispatcher("identifier").is_some());
        assert!(dispatcher("instance_variable").is_some());
        assert!(dispatcher("simple_symbol").is_some());
        assert!(dispatcher("subshell").is_some());
        assert!(dispatcher("binary").is_some());
        assert!(dispatcher("scope_resolution").is_some());
        assert!(dispatcher("element_reference").is_some());
        assert!(dispatcher("array").is_some());
        assert!(dispatcher("call").is_some());
        assert!(dispatcher("argument_list").is_some());
        assert!(dispatcher("body_statement").is_some());
        assert!(dispatcher("do").is_some());
        assert!(dispatcher("do_block").is_some());
        assert!(dispatcher("else").is_some());
        assert!(dispatcher("then").is_some());
        assert!(dispatcher("block").is_some());
        assert!(dispatcher("block_body").is_some());
        assert!(dispatcher("return").is_some());
        assert!(dispatcher("assignment").is_some());
        assert!(dispatcher("pair").is_some());
        assert!(dispatcher("module").is_some());
        assert!(dispatcher("method_parameters").is_some());
        assert!(dispatcher("block_parameters").is_some());
        assert!(dispatcher("block_parameter").is_some());
        assert!(dispatcher("hash_splat_parameter").is_some());
        assert!(dispatcher("optional_parameter").is_some());
        assert!(dispatcher("splat_parameter").is_some());
        assert!(dispatcher("class").is_some());
        assert!(dispatcher("singleton_class").is_some());
        assert!(dispatcher("method").is_some());
        assert!(dispatcher("singleton_method").is_some());
        assert!(dispatcher("elsif").is_some());
        assert!(dispatcher("if").is_some());
        assert!(dispatcher("if_modifier").is_some());
        assert!(dispatcher("unless_modifier").is_some());
        assert!(dispatcher("unless").is_some());
        assert!(dispatcher("while").is_some());
        assert!(dispatcher("while_modifier").is_some());
        assert!(dispatcher("for").is_some());
        assert!(dispatcher("begin").is_some());
        assert!(dispatcher("rescue_modifier").is_some());
        assert!(dispatcher("rescue").is_some());
        assert!(dispatcher("exception_variable").is_some());
    }
}