pax-lang 0.38.3

Pax language 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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use std::fs;
use std::path::Path;
use syn::spanned::Spanned;
use syn::visit::Visit;
use syn::{parse_file, ItemStruct};

#[derive(Debug)]
pub struct InlinedTemplate {
    pub struct_name: String,
    pub start: (usize, usize),
    pub end: (usize, usize),
    pub template: String,
}

#[derive(Debug)]
pub struct InlinedTemplateFinder {
    pub file_contents: String,
    pub templates: Vec<InlinedTemplate>,
}

impl InlinedTemplateFinder {
    pub fn new(file_contents: String) -> Self {
        InlinedTemplateFinder {
            file_contents,
            templates: Vec::new(),
        }
    }
}

impl<'ast> Visit<'ast> for InlinedTemplateFinder {
    fn visit_item_struct(&mut self, i: &'ast ItemStruct) {
        let mut has_pax = false;
        let struct_name = i.ident.to_string();
        for attr in &i.attrs {
            // Check for #[pax]
            if attr.path.is_ident("pax") {
                has_pax = true;
            }

            if attr.path.is_ident("inlined") {
                let start = attr.tokens.span().start();
                let start_tuple = (start.line, start.column + 1);
                let end = attr.tokens.span().end();
                let end_tuple = (end.line, end.column + 1);
                let content =
                    get_substring_by_line_column(&self.file_contents, start_tuple, end_tuple)
                        .unwrap()
                        .trim_start_matches("(")
                        .trim_end_matches(")")
                        .to_string();
                if has_pax {
                    let found_template = InlinedTemplate {
                        struct_name: struct_name.clone(),
                        start: start_tuple,
                        end: end_tuple,
                        template: content,
                    };
                    self.templates.insert(0, found_template);
                }
            }
        }
    }
}

fn find_start_end_bytes(
    input: &str,
    start: (usize, usize),
    end: (usize, usize),
) -> (Option<usize>, Option<usize>) {
    let mut current_line = 1;
    let mut current_column = 1;
    let mut start_byte = None;
    let mut end_byte = None;

    for (i, c) in input.char_indices() {
        if current_line == start.0 && current_column == start.1 {
            start_byte = Some(i);
        }
        if current_line == end.0 && current_column == end.1 {
            end_byte = Some(i);
            break;
        }

        if c == '\n' {
            current_line += 1;
            current_column = 1;
        } else {
            current_column += 1;
        }
    }

    (start_byte, end_byte)
}

pub fn replace_by_line_column(
    input: &str,
    start: (usize, usize),
    end: (usize, usize),
    replacement: String,
) -> Option<String> {
    let (start_byte, end_byte) = find_start_end_bytes(input, start, end);

    match (start_byte, end_byte) {
        (Some(start_byte), Some(end_byte)) => {
            let mut result = String::new();
            result.push_str(&input[..start_byte]);
            result.push_str(&replacement);
            result.push_str(&input[end_byte..]);
            Some(result)
        }
        _ => None,
    }
}

pub fn get_substring_by_line_column(
    input: &str,
    start: (usize, usize),
    end: (usize, usize),
) -> Option<String> {
    let (start_byte, end_byte) = find_start_end_bytes(input, start, end);

    match (start_byte, end_byte) {
        (Some(start_byte), Some(end_byte)) => Some(input[start_byte..end_byte].to_string()),
        _ => None,
    }
}

pub fn clear_inlined_template(file_path: &str, pascal_identifier: &str) {
    let path = Path::new(file_path);
    let content = fs::read_to_string(path).expect("Failed to read file");
    let ast = parse_file(&content).expect("Failed to parse file");

    let mut finder = InlinedTemplateFinder::new(content.clone());
    finder.visit_file(&ast);

    let mut modified_content = content;
    for template in finder.templates {
        if template.struct_name == pascal_identifier {
            let blank_template = format!("()");
            modified_content = replace_by_line_column(
                &modified_content,
                template.start,
                template.end,
                blank_template,
            )
            .unwrap();
        }
    }
    fs::write(path, modified_content).expect("Failed to write to file");
}