lib-ruby-parser 3.0.11

Ruby parser
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

use lib_ruby_parser_nodes::{template::TemplateFns, template::F, MessageField, NodeField};

pub(crate) mod node_fields {
    use super::*;

    pub(crate) fn cpp_pack_fn_name(node_field: &NodeField) -> String {
        use lib_ruby_parser_nodes::NodeFieldType::*;
        match node_field.field_type {
            Node => "PACK_Ptr",
            Nodes => "PACK_NodeList",
            MaybeNode { .. } => "PACK_MaybePtr",
            Loc => "PACK_Loc",
            MaybeLoc => "PACK_MaybeLoc",
            Str { .. } => "PACK_StringPtr",
            MaybeStr { .. } => "PACK_MaybeStringPtr",
            StringValue => "PACK_Bytes",
            U8 => "PACK_Byte",
        }
        .to_string()
    }
    pub(crate) fn cpp_unpack_fn_name(node_field: &NodeField) -> String {
        use lib_ruby_parser_nodes::NodeFieldType::*;
        match node_field.field_type {
            Node => "UNPACK_Ptr",
            Nodes => "UNPACK_NodeList",
            MaybeNode { .. } => "UNPACK_MaybePtr",
            Loc => "UNPACK_Loc",
            MaybeLoc => "UNPACK_MaybeLoc",
            Str { .. } => "UNPACK_StringPtr",
            MaybeStr { .. } => "UNPACK_MaybeStringPtr",
            StringValue => "UNPACK_Bytes",
            U8 => "UNPACK_Byte",
        }
        .to_string()
    }

    pub(crate) fn cpp_field_type(node_field: &NodeField) -> String {
        use lib_ruby_parser_nodes::NodeFieldType::*;
        match node_field.field_type {
            Node => "NodePtr",
            Nodes => "NodeList",
            MaybeNode { .. } => "MaybeNodePtr",
            Loc => "Loc",
            MaybeLoc => "MaybeLoc",
            Str { .. } => "StringPtr",
            MaybeStr { .. } => "MaybeStringPtr",
            StringValue => "Bytes",
            U8 => "Byte",
        }
        .to_string()
    }

    pub(crate) fn cpp_blob_type(node_field: &NodeField) -> String {
        use lib_ruby_parser_nodes::NodeFieldType::*;
        match node_field.field_type {
            Node => "Ptr_BLOB",
            Nodes => "NodeList_BLOB",
            MaybeNode { .. } => "MaybePtr_BLOB",
            Loc => "Loc_BLOB",
            MaybeLoc => "MaybeLoc_BLOB",
            Str { .. } => "StringPtr_BLOB",
            MaybeStr { .. } => "MaybeStringPtr_BLOB",
            StringValue => "Bytes_BLOB",
            U8 => "Byte_BLOB",
        }
        .to_string()
    }
}

pub(crate) mod message_fields {
    use super::*;

    pub(crate) fn cpp_field_type(message_field: &MessageField) -> String {
        use lib_ruby_parser_nodes::MessageFieldType::*;
        match message_field.field_type {
            Str => "StringPtr",
            Byte => "Byte",
        }
        .to_string()
    }

    pub(crate) fn cpp_blob_type(message_field: &MessageField) -> String {
        format!("{}_BLOB", cpp_field_type(message_field))
    }
}

pub(crate) fn build() -> TemplateFns {
    let mut fns = TemplateFns::new();

    fns.register::<NodeField, F::Helper>("node-field-cpp-field-type", node_fields::cpp_field_type);
    fns.register::<NodeField, F::Helper>("node-field-cpp-blob-type", node_fields::cpp_blob_type);
    fns.register::<NodeField, F::Helper>(
        "node-field-cpp-pack-fn-name",
        node_fields::cpp_pack_fn_name,
    );
    fns.register::<NodeField, F::Helper>(
        "node-field-cpp-unpack-fn-name",
        node_fields::cpp_unpack_fn_name,
    );

    fns.register::<MessageField, F::Helper>(
        "message-field-cpp-field-type",
        message_fields::cpp_field_type,
    );
    fns.register::<MessageField, F::Helper>(
        "message-field-cpp-blob-type",
        message_fields::cpp_blob_type,
    );

    fns
}