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

use super::sizes;

fn contents() -> String {
    format!(
        "// This file is autogenerated by {generator}

use crate::containers::size;

{blobs}
",
        generator = file!(),
        blobs = blobs()
    )
}

pub(crate) fn codegen() {
    std::fs::write("src/blobs/gen.rs", contents()).unwrap();
}

fn blobs() -> String {
    let mut messages = vec![];
    let mut nodes = vec![];

    for size in sizes() {
        let size_name = size.name.clone();

        let struct_name = camelcase(size_name.strip_suffix("_SIZE").unwrap());

        if struct_name.starts_with("Node") && struct_name != "Node" {
            let struct_name = struct_name.strip_prefix("Node").unwrap().to_owned();
            nodes.push((struct_name, size_name));
        } else if struct_name.starts_with("Message") {
            let struct_name = struct_name.strip_prefix("Message").unwrap().to_owned();
            messages.push((struct_name, size_name));
        } else {
            // ignore
        }
    }

    format!(
        "/// Mod with node blobs
pub mod nodes {{
    use super::size;
    use crate::nodes::*;

    {node_blobs}
}}

/// Mod with message blobs
pub mod messages {{
    use super::size;
    use crate::error::message::variants::*;

    {message_blobs}
}}
",
        node_blobs = map_blobs(nodes, &blob_code).join("\n    "),
        message_blobs = map_blobs(messages, &blob_code).join("\n    "),
    )
}

fn camelcase(capitalized_name: &str) -> String {
    capitalized_name
        .split('_')
        .map(|word| {
            if word.is_empty() {
                format!("_")
            } else {
                format!("{}{}", word[..1].to_uppercase(), word[1..].to_lowercase())
            }
        })
        .collect::<Vec<_>>()
        .join("")
}

fn map_blobs(blobs: Vec<(String, String)>, f: &dyn Fn(&str, &str) -> String) -> Vec<String> {
    blobs
        .into_iter()
        .map(|(struct_name, size_name)| f(&struct_name, &size_name))
        .collect()
}

fn blob_code(struct_name: &str, size_name: &str) -> String {
    let blob_name = format!("{}Blob", struct_name);

    format!(
        "declare_blob!(
        size = size::{size_name},
        value = {struct_name},
        blob = {blob_name},
        doc = \"Blob of the `{struct_name}`\"
    );",
        size_name = size_name,
        struct_name = struct_name,
        blob_name = blob_name
    )
}