rustine 0.1.1

High-performance Gel syntax parser transforming to JSON/XML (Rust + PyO3)
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

//! JSON output generator - converts AST to JSON

use crate::parser::ast::{Expression, FunctionCall, GelDocument, Grammar, Statement};
use serde_json::{json, Map, Value};

/// JSON generator for Gel documents
#[derive(Debug, Default)]
pub struct JsonGenerator;

impl JsonGenerator {
    pub fn new() -> Self {
        Self
    }

    /// Main entry: generate JSON from GelDocument
    pub fn generate_from_ast(document: &GelDocument) -> String {
        let generator = Self::new();

        // For now build a simple representation of the AST structure
        let mut result = Map::new();

        // Render defines
        if !document.defines.is_empty() {
            let defines: Map<String, Value> = document
                .defines
                .iter()
                .map(|(name, expr)| (name.clone(), generator.expression_to_json(expr)))
                .collect();
            result.insert("defines".to_string(), json!(defines));
        }

        // Render grammars
        if !document.grammars.is_empty() {
            let grammars: Map<String, Value> = document
                .grammars
                .iter()
                .map(|(name, grammar)| (name.clone(), generator.grammar_to_json(grammar)))
                .collect();
            result.insert("grammars".to_string(), json!(grammars));
        }

        serde_json::to_string_pretty(&Value::Object(result)).unwrap_or_else(|_| "{}".to_string())
    }

    /// Convert a grammar node into JSON
    fn grammar_to_json(&self, grammar: &Grammar) -> Value {
        let mut result = Map::new();

        if let Some(ref inherit) = grammar.inherit {
            result.insert("inherit".to_string(), json!(inherit));
        }

        if !grammar.statements.is_empty() {
            let statements: Vec<Value> = grammar
                .statements
                .iter()
                .map(|stmt| self.statement_to_json(stmt))
                .collect();
            result.insert("statements".to_string(), json!(statements));
        }

        Value::Object(result)
    }

    /// Convert a statement into JSON
    fn statement_to_json(&self, statement: &Statement) -> Value {
        match statement {
            Statement::Match(match_stmt) => {
                json!({
                    "type": "match",
                    "case_insensitive": match_stmt.case_insensitive,
                    "patterns": self.match_list_to_json(&match_stmt.match_list),
                    "actions": match_stmt.actions.iter().map(|a| self.action_to_json(a)).collect::<Vec<_>>()
                })
            }
            Statement::When(when_stmt) => {
                json!({
                    "type": "when",
                    "patterns": self.match_list_to_json(&when_stmt.match_list),
                    "actions": when_stmt.actions.iter().map(|a| self.action_to_json(a)).collect::<Vec<_>>()
                })
            }
            Statement::Skip(skip_stmt) => {
                json!({
                    "type": "skip",
                    "pattern": self.expression_to_json(&skip_stmt.pattern)
                })
            }
            Statement::Action(func_call) => {
                json!({
                    "type": "action",
                    "name": &*func_call.name,
                    "args": func_call.args.iter().map(|e| self.expression_to_json(e)).collect::<Vec<_>>()
                })
            }
        }
    }

    /// Convert a MatchList to JSON
    fn match_list_to_json(&self, match_list: &crate::parser::ast::MatchList) -> Value {
        let alternatives: Vec<Value> = match_list
            .alternatives
            .iter()
            .map(|field_list| {
                json!({
                    "expressions": field_list.expressions.iter()
                        .map(|e| self.expression_to_json(e))
                        .collect::<Vec<_>>(),
                    "flags": field_list.flags
                })
            })
            .collect();
        json!(alternatives)
    }

    /// Convert an Expression to JSON
    fn expression_to_json(&self, expression: &Expression) -> Value {
        match expression {
            Expression::String(s) => json!({"type": "string", "value": s}),
            Expression::Regex(r) => json!({"type": "regex", "value": r}),
            Expression::Variable(v) => json!({"type": "variable", "value": v}),
            Expression::Number(n) => json!({"type": "number", "value": n}),
            Expression::Capture(i) => json!({"type": "capture", "index": i}),
            Expression::CaptureName(name) => json!({"type": "capture_name", "name": name}),
        }
    }

    fn action_to_json(&self, call: &FunctionCall) -> Value {
        json!({
            "type": "call",
            "name": &*call.name,
            "args": call.args.iter().map(|e| self.expression_to_json(e)).collect::<Vec<_>>()
        })
    }
}