` at (1:1) doesn't have a matching closing tag"));
+}
+
+#[test]
+fn test_tag_names_mismatch_error() {
+ let source = "
";
+ let result = parse(source).unwrap();
+
+ let tree_inspect = result.tree_inspect();
+ assert!(tree_inspect.contains("TAG_NAMES_MISMATCH_ERROR"));
+ assert!(tree_inspect.contains("Opening tag `
` at (1:1) closed with ``"));
+}
+
+#[test]
+fn test_no_errors_with_valid_html() {
+ let source = "
Hello
";
+ let result = parse(source).unwrap();
+
+ let tree_inspect = result.tree_inspect();
+ assert!(!tree_inspect.contains("error"));
+ assert!(!tree_inspect.contains("ERROR"));
+}
diff --git a/rust/tests/fixtures/test.html.erb b/rust/tests/fixtures/test.html.erb
new file mode 100644
index 000000000..49cc40405
--- /dev/null
+++ b/rust/tests/fixtures/test.html.erb
@@ -0,0 +1,11 @@
+
+
+<% if valid? %>
+
+ <%= "Valid" %>
+
+<% else %>
+
+ Invalid
+
+<% end %>
diff --git a/rust/tests/node_field_test.rs b/rust/tests/node_field_test.rs
new file mode 100644
index 000000000..77b4b2d0c
--- /dev/null
+++ b/rust/tests/node_field_test.rs
@@ -0,0 +1,30 @@
+use herb::parse;
+
+#[test]
+fn test_open_tag_field_is_displayed() {
+ let source = "
Hello
";
+ let result = parse(source).unwrap();
+
+ let tree_inspect = result.tree_inspect();
+ assert!(tree_inspect.contains("open_tag:"));
+ assert!(tree_inspect.contains("@ HTMLOpenTagNode"));
+ assert!(tree_inspect.contains("tag_opening: \"<\""));
+ assert!(tree_inspect.contains("tag_name: \"div\""));
+
+ assert!(tree_inspect.contains("close_tag:"));
+ assert!(tree_inspect.contains("@ HTMLCloseTagNode"));
+ assert!(tree_inspect.contains("tag_opening: \"Hello
";
+ let result = parse(source).unwrap();
+
+ let tree_inspect = result.tree_inspect();
+ assert!(tree_inspect.contains("@ HTMLAttributeNode"));
+ assert!(tree_inspect.contains("name:"));
+ assert!(tree_inspect.contains("@ HTMLAttributeNameNode"));
+ assert!(tree_inspect.contains("value:"));
+ assert!(tree_inspect.contains("@ HTMLAttributeValueNode"));
+}
diff --git a/rust/tests/parse_result_test.rs b/rust/tests/parse_result_test.rs
new file mode 100644
index 000000000..930536774
--- /dev/null
+++ b/rust/tests/parse_result_test.rs
@@ -0,0 +1,94 @@
+use herb::parse;
+
+#[test]
+fn test_parse_result_success_with_valid_html() {
+ let source = "
Hello
";
+ let result = parse(source).unwrap();
+
+ assert!(
+ result.success(),
+ "Expected success() to be true for valid HTML"
+ );
+
+ assert!(
+ !result.failed(),
+ "Expected failed() to be false for valid HTML"
+ );
+
+ assert!(
+ result.errors().is_empty(),
+ "Expected no errors for valid HTML"
+ );
+}
+
+#[test]
+fn test_parse_result_failed_with_unclosed_element() {
+ let source = "
";
+ let result = parse(source).unwrap();
+
+ assert!(
+ !result.success(),
+ "Expected success() to be false for invalid HTML"
+ );
+
+ assert!(
+ result.failed(),
+ "Expected failed() to be true for invalid HTML"
+ );
+
+ assert!(
+ !result.recursive_errors().is_empty(),
+ "Expected errors for invalid HTML"
+ );
+
+ let errors = result.recursive_errors();
+
+ assert!(errors
+ .iter()
+ .any(|e| e.error_type() == "UNCLOSED_ELEMENT_ERROR"));
+
+ assert!(errors
+ .iter()
+ .any(|e| e.error_type() == "MISSING_CLOSING_TAG_ERROR"));
+}
+
+#[test]
+fn test_parse_result_failed_with_tag_mismatch() {
+ let source = "
";
+ let result = parse(source).unwrap();
+
+ assert!(
+ !result.success(),
+ "Expected success() to be false for mismatched tags"
+ );
+
+ assert!(
+ result.failed(),
+ "Expected failed() to be true for mismatched tags"
+ );
+
+ let errors = result.recursive_errors();
+
+ assert!(!errors.is_empty(), "Expected errors for mismatched tags");
+
+ assert!(errors
+ .iter()
+ .any(|e| e.error_type() == "TAG_NAMES_MISMATCH_ERROR"));
+}
+
+#[test]
+fn test_parse_result_errors_are_recursive() {
+ let source = "
";
+ let result = parse(source).unwrap();
+
+ let errors = result.recursive_errors();
+ assert!(
+ !errors.is_empty(),
+ "Expected recursive errors to be collected"
+ );
+
+ assert!(
+ result.failed(),
+ "Expected failed() to be true when there are recursive errors"
+ );
+}
diff --git a/rust/tests/snapshot_test.rs b/rust/tests/snapshot_test.rs
new file mode 100644
index 000000000..07f389fd2
--- /dev/null
+++ b/rust/tests/snapshot_test.rs
@@ -0,0 +1,59 @@
+use herb::{extract_html, extract_ruby, herb_version, lex, parse, prism_version, version};
+
+const TEST_INPUT: &str = include_str!("./fixtures/test.html.erb");
+
+#[test]
+fn test_version_output() {
+ let output = version();
+
+ insta::assert_snapshot!(output);
+}
+
+#[test]
+fn test_herb_version_output() {
+ let output = herb_version();
+
+ insta::assert_snapshot!(output);
+}
+
+#[test]
+fn test_prism_version_output() {
+ let output = prism_version();
+
+ insta::assert_snapshot!(output);
+}
+
+#[test]
+fn test_lex_output() {
+ let result = lex(TEST_INPUT);
+ let output = result
+ .tokens()
+ .iter()
+ .map(|token| token.inspect())
+ .collect::
>()
+ .join("\n");
+
+ insta::assert_snapshot!(output);
+}
+
+#[test]
+fn test_parse_output() {
+ let result = parse(TEST_INPUT).expect("Failed to parse");
+ let output = result.tree_inspect();
+
+ insta::assert_snapshot!(output);
+}
+
+#[test]
+fn test_extract_ruby_output() {
+ let result = extract_ruby(TEST_INPUT).expect("Failed to extract Ruby");
+
+ insta::assert_snapshot!(result);
+}
+
+#[test]
+fn test_extract_html_output() {
+ let result = extract_html(TEST_INPUT).expect("Failed to extract HTML");
+
+ insta::assert_snapshot!(result);
+}
diff --git a/rust/tests/snapshots/snapshot_test__extract_html_output.snap b/rust/tests/snapshots/snapshot_test__extract_html_output.snap
new file mode 100644
index 000000000..af9b7ec93
--- /dev/null
+++ b/rust/tests/snapshots/snapshot_test__extract_html_output.snap
@@ -0,0 +1,14 @@
+---
+source: tests/snapshot_test.rs
+expression: result
+---
+
+
+
+
+
+ Invalid
+
diff --git a/rust/tests/snapshots/snapshot_test__extract_ruby_output.snap b/rust/tests/snapshots/snapshot_test__extract_ruby_output.snap
new file mode 100644
index 000000000..d8e79d9ff
--- /dev/null
+++ b/rust/tests/snapshots/snapshot_test__extract_ruby_output.snap
@@ -0,0 +1,15 @@
+---
+source: tests/snapshot_test.rs
+expression: result
+---
+
+
+ if valid?
+
+ "Valid"
+
+ else
+
+
+
+ end
diff --git a/rust/tests/snapshots/snapshot_test__herb_version_output.snap b/rust/tests/snapshots/snapshot_test__herb_version_output.snap
new file mode 100644
index 000000000..192993920
--- /dev/null
+++ b/rust/tests/snapshots/snapshot_test__herb_version_output.snap
@@ -0,0 +1,5 @@
+---
+source: tests/snapshot_test.rs
+expression: output
+---
+0.7.5
diff --git a/rust/tests/snapshots/snapshot_test__lex_output.snap b/rust/tests/snapshots/snapshot_test__lex_output.snap
new file mode 100644
index 000000000..781b7c888
--- /dev/null
+++ b/rust/tests/snapshots/snapshot_test__lex_output.snap
@@ -0,0 +1,69 @@
+---
+source: tests/snapshot_test.rs
+expression: output
+---
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
+#
diff --git a/rust/tests/snapshots/snapshot_test__parse_output.snap b/rust/tests/snapshots/snapshot_test__parse_output.snap
new file mode 100644
index 000000000..02d76cc48
--- /dev/null
+++ b/rust/tests/snapshots/snapshot_test__parse_output.snap
@@ -0,0 +1,156 @@
+---
+source: tests/snapshot_test.rs
+expression: output
+---
+@ DocumentNode (location: (1:0)-(12:0))
+└── children: (12 items)
+ ├── @ HTMLElementNode (location: (1:0)-(1:18))
+ │ ├── open_tag:
+ │ │ └── @ HTMLOpenTagNode (location: (1:0)-(1:18))
+ │ │ ├── tag_opening: "<" (location: (1:0)-(1:1))
+ │ │ ├── tag_name: "input" (location: (1:1)-(1:6))
+ │ │ ├── tag_closing: "/>" (location: (1:16)-(1:18))
+ │ │ ├── children: (1 item)
+ │ │ │ └── @ HTMLAttributeNode (location: (1:7)-(1:15))
+ │ │ │ ├── name:
+ │ │ │ │ └── @ HTMLAttributeNameNode (location: (1:7)-(1:15))
+ │ │ │ │ └── children: (1 item)
+ │ │ │ │ └── @ LiteralNode (location: (1:7)-(1:15))
+ │ │ │ │ └── content: "required"
+ │ │ │ │
+ │ │ │ ├── equals: ∅
+ │ │ │ └── value: ∅
+ │ │ └── is_void: true
+ │ │
+ │ ├── tag_name: "input" (location: (1:1)-(1:6))
+ │ ├── body: []
+ │ ├── close_tag: ∅
+ │ ├── is_void: true
+ │ └── source: "HTML"
+ │
+ ├── @ HTMLTextNode (location: (1:18)-(3:0))
+ │ └── content: "\n\n"
+ │
+ ├── @ ERBContentNode (location: (3:0)-(3:15))
+ │ ├── tag_opening: "<%" (location: (3:0)-(3:2))
+ │ ├── content: " if valid? " (location: (3:2)-(3:13))
+ │ ├── tag_closing: "%>" (location: (3:13)-(3:15))
+ │ ├── parsed: false
+ │ └── valid: false
+ │
+ ├── @ HTMLTextNode (location: (3:15)-(4:2))
+ │ └── content: "\n "
+ │
+ ├── @ HTMLElementNode (location: (4:2)-(6:7))
+ │ ├── open_tag:
+ │ │ └── @ HTMLOpenTagNode (location: (4:2)-(4:37))
+ │ │ ├── tag_opening: "<" (location: (4:2)-(4:3))
+ │ │ ├── tag_name: "h1" (location: (4:3)-(4:5))
+ │ │ ├── tag_closing: ">" (location: (4:36)-(4:37))
+ │ │ ├── children: (1 item)
+ │ │ │ └── @ HTMLAttributeNode (location: (4:6)-(4:36))
+ │ │ │ ├── name:
+ │ │ │ │ └── @ HTMLAttributeNameNode (location: (4:6)-(4:11))
+ │ │ │ │ └── children: (1 item)
+ │ │ │ │ └── @ LiteralNode (location: (4:6)-(4:11))
+ │ │ │ │ └── content: "class"
+ │ │ │ │
+ │ │ │ ├── equals: "=" (location: (4:11)-(4:12))
+ │ │ │ └── value:
+ │ │ │ └── @ HTMLAttributeValueNode (location: (4:12)-(4:36))
+ │ │ │ ├── open_quote: "\"" (location: (4:12)-(4:13))
+ │ │ │ ├── children: (1 item)
+ │ │ │ │ └── @ LiteralNode (location: (4:13)-(4:35))
+ │ │ │ │ └── content: "bg-green-500 text-gray"
+ │ │ │ ├── close_quote: "\"" (location: (4:35)-(4:36))
+ │ │ │ └── quoted: true
+ │ │ └── is_void: false
+ │ │
+ │ ├── tag_name: "h1" (location: (4:3)-(4:5))
+ │ ├── body: (3 items)
+ │ │ ├── @ HTMLTextNode (location: (4:37)-(5:4))
+ │ │ │ └── content: "\n "
+ │ │ │
+ │ │ ├── @ ERBContentNode (location: (5:4)-(5:18))
+ │ │ │ ├── tag_opening: "<%=" (location: (5:4)-(5:7))
+ │ │ │ ├── content: " \"Valid\" " (location: (5:7)-(5:16))
+ │ │ │ ├── tag_closing: "%>" (location: (5:16)-(5:18))
+ │ │ │ ├── parsed: false
+ │ │ │ └── valid: false
+ │ │ │
+ │ │ └── @ HTMLTextNode (location: (5:18)-(6:2))
+ │ │ └── content: "\n "
+ │ ├── close_tag:
+ │ │ └── @ HTMLCloseTagNode (location: (6:2)-(6:7))
+ │ │ ├── tag_opening: "" (location: (6:6)-(6:7))
+ │ │
+ │ ├── is_void: false
+ │ └── source: "HTML"
+ │
+ ├── @ HTMLTextNode (location: (6:7)-(7:0))
+ │ └── content: "\n"
+ │
+ ├── @ ERBContentNode (location: (7:0)-(7:10))
+ │ ├── tag_opening: "<%" (location: (7:0)-(7:2))
+ │ ├── content: " else " (location: (7:2)-(7:8))
+ │ ├── tag_closing: "%>" (location: (7:8)-(7:10))
+ │ ├── parsed: false
+ │ └── valid: false
+ │
+ ├── @ HTMLTextNode (location: (7:10)-(8:2))
+ │ └── content: "\n "
+ │
+ ├── @ HTMLElementNode (location: (8:2)-(10:7))
+ │ ├── open_tag:
+ │ │ └── @ HTMLOpenTagNode (location: (8:2)-(8:36))
+ │ │ ├── tag_opening: "<" (location: (8:2)-(8:3))
+ │ │ ├── tag_name: "h1" (location: (8:3)-(8:5))
+ │ │ ├── tag_closing: ">" (location: (8:35)-(8:36))
+ │ │ ├── children: (1 item)
+ │ │ │ └── @ HTMLAttributeNode (location: (8:6)-(8:35))
+ │ │ │ ├── name:
+ │ │ │ │ └── @ HTMLAttributeNameNode (location: (8:6)-(8:11))
+ │ │ │ │ └── children: (1 item)
+ │ │ │ │ └── @ LiteralNode (location: (8:6)-(8:11))
+ │ │ │ │ └── content: "class"
+ │ │ │ │
+ │ │ │ ├── equals: "=" (location: (8:11)-(8:12))
+ │ │ │ └── value:
+ │ │ │ └── @ HTMLAttributeValueNode (location: (8:12)-(8:35))
+ │ │ │ ├── open_quote: "\"" (location: (8:12)-(8:13))
+ │ │ │ ├── children: (1 item)
+ │ │ │ │ └── @ LiteralNode (location: (8:13)-(8:34))
+ │ │ │ │ └── content: "bg-red-500 text-black"
+ │ │ │ ├── close_quote: "\"" (location: (8:34)-(8:35))
+ │ │ │ └── quoted: true
+ │ │ └── is_void: false
+ │ │
+ │ ├── tag_name: "h1" (location: (8:3)-(8:5))
+ │ ├── body: (1 item)
+ │ │ └── @ HTMLTextNode (location: (8:36)-(10:2))
+ │ │ └── content: "\n Invalid\n "
+ │ ├── close_tag:
+ │ │ └── @ HTMLCloseTagNode (location: (10:2)-(10:7))
+ │ │ ├── tag_opening: "" (location: (10:6)-(10:7))
+ │ │
+ │ ├── is_void: false
+ │ └── source: "HTML"
+ │
+ ├── @ HTMLTextNode (location: (10:7)-(11:0))
+ │ └── content: "\n"
+ │
+ ├── @ ERBContentNode (location: (11:0)-(11:9))
+ │ ├── tag_opening: "<%" (location: (11:0)-(11:2))
+ │ ├── content: " end " (location: (11:2)-(11:7))
+ │ ├── tag_closing: "%>" (location: (11:7)-(11:9))
+ │ ├── parsed: false
+ │ └── valid: false
+ │
+ └── @ HTMLTextNode (location: (11:9)-(12:0))
+ └── content: "\n"
diff --git a/rust/tests/snapshots/snapshot_test__prism_version_output.snap b/rust/tests/snapshots/snapshot_test__prism_version_output.snap
new file mode 100644
index 000000000..f5516a1a8
--- /dev/null
+++ b/rust/tests/snapshots/snapshot_test__prism_version_output.snap
@@ -0,0 +1,5 @@
+---
+source: tests/snapshot_test.rs
+expression: output
+---
+1.6.0
diff --git a/rust/tests/snapshots/snapshot_test__version_output.snap b/rust/tests/snapshots/snapshot_test__version_output.snap
new file mode 100644
index 000000000..b46419a0c
--- /dev/null
+++ b/rust/tests/snapshots/snapshot_test__version_output.snap
@@ -0,0 +1,5 @@
+---
+source: tests/snapshot_test.rs
+expression: output
+---
+herb rust v0.7.5, libprism v1.6.0, libherb v0.7.5 (Rust FFI)
diff --git a/rust/tests/tree_inspect_test.rs b/rust/tests/tree_inspect_test.rs
new file mode 100644
index 000000000..42826b6bd
--- /dev/null
+++ b/rust/tests/tree_inspect_test.rs
@@ -0,0 +1,30 @@
+use herb::nodes::{AnyNode, DocumentNode, HTMLTextNode, Node};
+use herb::{Location, Position};
+
+#[test]
+fn test_document_with_text_node() {
+ let loc = Location::new(Position::new(1, 0), Position::new(1, 5));
+
+ let text_node = HTMLTextNode {
+ node_type: "HTMLTextNode".to_string(),
+ location: loc,
+ errors: vec![],
+ content: "Hello".to_string(),
+ };
+
+ let doc_node = DocumentNode {
+ node_type: "DocumentNode".to_string(),
+ location: Location::new(Position::new(1, 0), Position::new(2, 0)),
+ errors: vec![],
+ children: vec![AnyNode::HTMLTextNode(text_node)],
+ };
+
+ let output = doc_node.tree_inspect();
+
+ println!("Tree inspect output:\n{}", output);
+
+ assert!(output.contains("@ DocumentNode"));
+ assert!(output.contains("children: (1 item)"));
+ assert!(output.contains("@ HTMLTextNode"));
+ assert!(output.contains("content: \"Hello\""));
+}
diff --git a/templates/rust/src/ast/nodes.rs.erb b/templates/rust/src/ast/nodes.rs.erb
new file mode 100644
index 000000000..1cd175e4a
--- /dev/null
+++ b/templates/rust/src/ast/nodes.rs.erb
@@ -0,0 +1,220 @@
+use crate::bindings::*;
+use crate::convert::token_from_c;
+use crate::errors::*;
+use crate::nodes::*;
+use crate::{Location, Position};
+use std::ffi::CStr;
+use std::os::raw::{c_char, c_void};
+
+unsafe fn convert_location(c_location: location_T) -> Location {
+ Location::new(
+ Position::new(c_location.start.line, c_location.start.column),
+ Position::new(c_location.end.line, c_location.end.column),
+ )
+}
+
+<%- errors.each do |error| -%>
+<%- snake_name = error.name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase -%>
+unsafe fn convert_<%= snake_name %>(error_ptr: *const <%= error.c_type %>) -> <%= error.name %> {
+ let error_ref = &*error_ptr;
+ let message = if error_ref.base.message.is_null() {
+ String::new()
+ } else {
+ CStr::from_ptr(error_ref.base.message).to_string_lossy().into_owned()
+ };
+ let location = convert_location(error_ref.base.location);
+
+ <%= error.name %>::new(
+ message,
+ location,
+ <%- error.fields.each do |field| -%>
+ <%- case field -%>
+ <%- when Herb::Template::StringField -%>
+ get_string_field(error_ref.<%= field.name %>),
+ <%- when Herb::Template::TokenField -%>
+ convert_token_field(error_ref.<%= field.name %>),
+ <%- when Herb::Template::TokenTypeField -%>
+ if error_ref.<%= field.name %> == u32::MAX {
+ None
+ } else {
+ Some(CStr::from_ptr(crate::ffi::token_type_to_string(error_ref.<%= field.name %>)).to_string_lossy().into_owned())
+ },
+ <%- end -%>
+ <%- end -%>
+ )
+}
+
+<%- end -%>
+
+unsafe fn convert_errors(errors_array: *mut hb_array_T) -> Vec {
+ if errors_array.is_null() {
+ return Vec::new();
+ }
+
+ let count = hb_array_size(errors_array);
+ let mut errors = Vec::with_capacity(count);
+
+ for index in 0..count {
+ let error_base_ptr = hb_array_get(errors_array, index) as *const ERROR_T;
+ if error_base_ptr.is_null() {
+ continue;
+ }
+
+ let error_base = &*error_base_ptr;
+
+ let error = match error_base.type_ {
+ <%- errors.each do |error| -%>
+ <%- snake_name = error.name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase -%>
+ <%= error.type %> => {
+ let error_ptr = error_base_ptr as *const <%= error.c_type %>;
+ AnyError::<%= error.name %>(convert_<%= snake_name %>(error_ptr))
+ }
+ <%- end -%>
+ _ => continue,
+ };
+
+ errors.push(error);
+ }
+
+ errors
+}
+
+unsafe fn get_string_field(string_ptr: *const c_char) -> String {
+ if string_ptr.is_null() {
+ String::new()
+ } else {
+ CStr::from_ptr(string_ptr).to_string_lossy().into_owned()
+ }
+}
+
+unsafe fn convert_element_source(source: u32) -> String {
+ let hb_string = crate::ffi::element_source_to_string(source);
+ if hb_string.data.is_null() {
+ String::new()
+ } else {
+ let slice = std::slice::from_raw_parts(hb_string.data as *const u8, hb_string.length as usize);
+ String::from_utf8_lossy(slice).into_owned()
+ }
+}
+
+unsafe fn convert_token_field(token_ptr: *mut token_T) -> Option {
+ if token_ptr.is_null() {
+ None
+ } else {
+ Some(token_from_c(token_ptr))
+ }
+}
+
+unsafe fn convert_children(children_array: *mut hb_array_T) -> Vec {
+ if children_array.is_null() {
+ return Vec::new();
+ }
+
+ let count = hb_array_size(children_array);
+ let mut children = Vec::with_capacity(count);
+
+ for index in 0..count {
+ let child_ptr = hb_array_get(children_array, index);
+ if !child_ptr.is_null() {
+ if let Some(node) = convert_node(child_ptr as *const c_void) {
+ children.push(node);
+ }
+ }
+ }
+
+ children
+}
+
+unsafe fn convert_node_field(node_ptr: *mut c_void) -> Option> {
+ if node_ptr.is_null() {
+ None
+ } else {
+ convert_node(node_ptr).map(Box::new)
+ }
+}
+
+macro_rules! convert_specific_node_field {
+ ($node_ptr:expr, $expected_type:expr, $convert_fn:ident, $node_type:ty) => {
+ if $node_ptr.is_null() {
+ None
+ } else {
+ let ast_base_ptr = $node_ptr as *const AST_NODE_T;
+ let ast_base_ref = &*ast_base_ptr;
+ let node_type = ast_base_ref.type_;
+
+ if node_type != $expected_type {
+ eprintln!("Warning: Expected node type {} but got {}", $expected_type, node_type);
+ None
+ } else {
+ $convert_fn($node_ptr as *const c_void).map(Box::new)
+ }
+ }
+ };
+}
+
+unsafe fn convert_node(node_ptr: *const c_void) -> Option {
+ if node_ptr.is_null() {
+ return None;
+ }
+
+ let ast_base_ptr = node_ptr as *const AST_NODE_T;
+ let ast_base_ref = &*ast_base_ptr;
+ let node_type = ast_base_ref.type_;
+
+ match node_type {
+ <%- nodes.each do |node| -%>
+ <%= node.type %> => convert_<%= node.human %>(node_ptr).map(AnyNode::<%= node.name %>),
+ <%- end -%>
+ _ => {
+ eprintln!("Warning: Unknown node type {}", node_type);
+ None
+ }
+ }
+}
+
+ <%- nodes.each do |node| -%>
+ <%- if node.name == "DocumentNode" -%>
+ /// Converts a C document node pointer to a Rust DocumentNode.
+ ///
+ /// # Safety
+ ///
+ /// The caller must ensure that `node_ptr` is a valid pointer to a C document node
+ /// structure with properly initialized fields.
+ <%- end -%>
+ <%= node.name == "DocumentNode" ? "pub " : "" %>unsafe fn convert_<%= node.human %>(node_ptr: *const c_void) -> Option<<%= node.name %>> {
+ if node_ptr.is_null() {
+ return None;
+ }
+
+ let c_node_ptr = node_ptr as *const <%= node.c_type %>;
+ let node_base_ref = &(*c_node_ptr).base;
+
+ Some(<%= node.name %> {
+ node_type: "<%= node.name %>".to_string(),
+ location: convert_location(node_base_ref.location),
+ errors: convert_errors(node_base_ref.errors),
+ <%- node.fields.each do |field| -%>
+ <%- case field -%>
+ <%- when Herb::Template::StringField -%>
+ <%= field.name %>: get_string_field((*c_node_ptr).<%= field.name %>),
+ <%- when Herb::Template::ElementSourceField -%>
+ <%= field.name %>: convert_element_source((*c_node_ptr).<%= field.name %>),
+ <%- when Herb::Template::TokenField -%>
+ <%= field.name %>: convert_token_field((*c_node_ptr).<%= field.name %>),
+ <%- when Herb::Template::BooleanField -%>
+ <%= field.name %>: (*c_node_ptr).<%= field.name %>,
+ <%- when Herb::Template::ArrayField -%>
+ <%= field.name %>: convert_children((*c_node_ptr).<%= field.name %>),
+ <%- when Herb::Template::NodeField -%>
+ <%- if field.specific_kind && field.specific_kind != "Node" -%>
+ <%- specific_node = nodes.find { |n| n.name == field.specific_kind } -%>
+ <%= field.name %>: convert_specific_node_field!((*c_node_ptr).<%= field.name %>, <%= specific_node.type %>, convert_<%= specific_node.human %>, <%= field.specific_kind %>),
+ <%- else -%>
+ <%= field.name %>: convert_node_field((*c_node_ptr).<%= field.name %> as *mut c_void),
+ <%- end -%>
+ <%- end -%>
+ <%- end -%>
+ })
+ }
+
+<%- end -%>
diff --git a/templates/rust/src/errors.rs.erb b/templates/rust/src/errors.rs.erb
new file mode 100644
index 000000000..dbd859601
--- /dev/null
+++ b/templates/rust/src/errors.rs.erb
@@ -0,0 +1,211 @@
+use crate::{Location, Token};
+
+fn escape_string(s: &str) -> String {
+ s.replace('\\', "\\\\")
+ .replace('\n', "\\n")
+ .replace('\r', "\\r")
+ .replace('\t', "\\t")
+ .replace('"', "\\\"")
+}
+
+fn format_string_value(value: &str) -> String {
+ format!("\"{}\"", escape_string(value))
+}
+
+fn format_token_value(token: &Option) -> String {
+ token.as_ref().map(|t| t.tree_inspect()).unwrap_or_else(|| "∅".to_string())
+}
+
+fn format_token_type_value(token_type: &Option) -> String {
+ token_type.as_ref().map(|t| format!("\"{}\"", t)).unwrap_or_else(|| "∅".to_string())
+}
+
+#[allow(dead_code)]
+fn format_position_value(position: &Option) -> String {
+ position.as_ref().map(|p| p.to_string()).unwrap_or_else(|| "∅".to_string())
+}
+
+#[allow(dead_code)]
+fn format_size_value(value: usize) -> String {
+ value.to_string()
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ErrorType {
+ <%- errors.each do |error| -%>
+ <%= error.name %>,
+ <%- end -%>
+}
+
+impl ErrorType {
+ pub fn as_str(&self) -> &str {
+ match self {
+ <%- errors.each do |error| -%>
+ ErrorType::<%= error.name %> => "<%= error.type %>",
+ <%- end -%>
+ }
+ }
+}
+
+pub trait ErrorNode {
+ fn error_type(&self) -> &str;
+ fn message(&self) -> &str;
+ fn location(&self) -> &Location;
+ fn tree_inspect(&self) -> String;
+}
+
+#[derive(Debug, Clone)]
+pub enum AnyError {
+ <%- errors.each do |error| -%>
+ <%= error.name %>(<%= error.name %>),
+ <%- end -%>
+}
+
+impl AnyError {
+ pub fn error_type(&self) -> &str {
+ match self {
+ <%- errors.each do |error| -%>
+ AnyError::<%= error.name %>(e) => &e.error_type,
+ <%- end -%>
+ }
+ }
+
+ pub fn message(&self) -> &str {
+ match self {
+ <%- errors.each do |error| -%>
+ AnyError::<%= error.name %>(e) => &e.message,
+ <%- end -%>
+ }
+ }
+
+ pub fn location(&self) -> &Location {
+ match self {
+ <%- errors.each do |error| -%>
+ AnyError::<%= error.name %>(e) => &e.location,
+ <%- end -%>
+ }
+ }
+
+ pub fn tree_inspect(&self) -> String {
+ match self {
+ <%- errors.each do |error| -%>
+ AnyError::<%= error.name %>(e) => e.tree_inspect(),
+ <%- end -%>
+ }
+ }
+}
+
+impl ErrorNode for AnyError {
+ fn error_type(&self) -> &str {
+ self.error_type()
+ }
+
+ fn message(&self) -> &str {
+ self.message()
+ }
+
+ fn location(&self) -> &Location {
+ self.location()
+ }
+
+ fn tree_inspect(&self) -> String {
+ self.tree_inspect()
+ }
+}
+
+<%- errors.each do |error| -%>
+#[derive(Debug, Clone)]
+pub struct <%= error.name %> {
+ pub error_type: String,
+ pub message: String,
+ pub location: Location,
+ <%- error.fields.each do |field| -%>
+ <%- case field -%>
+ <%- when Herb::Template::StringField -%>
+ pub <%= field.name %>: String,
+ <%- when Herb::Template::TokenField -%>
+ pub <%= field.name %>: Option,
+ <%- when Herb::Template::TokenTypeField -%>
+ pub <%= field.name %>: Option,
+ <%- when Herb::Template::PositionField -%>
+ pub <%= field.name %>: Option,
+ <%- when Herb::Template::SizeTField -%>
+ pub <%= field.name %>: usize,
+ <%- end -%>
+ <%- end -%>
+}
+
+impl <%= error.name %> {
+ pub fn new(
+ message: String,
+ location: Location,
+ <%- error.fields.each do |field| -%>
+ <%- case field -%>
+ <%- when Herb::Template::StringField -%>
+ <%= field.name %>: String,
+ <%- when Herb::Template::TokenField -%>
+ <%= field.name %>: Option,
+ <%- when Herb::Template::TokenTypeField -%>
+ <%= field.name %>: Option,
+ <%- when Herb::Template::PositionField -%>
+ <%= field.name %>: Option,
+ <%- when Herb::Template::SizeTField -%>
+ <%= field.name %>: usize,
+ <%- end -%>
+ <%- end -%>
+ ) -> Self {
+ Self {
+ error_type: "<%= error.type %>".to_string(),
+ message,
+ location,
+ <%- error.fields.each do |field| -%>
+ <%= field.name %>,
+ <%- end -%>
+ }
+ }
+
+ pub fn tree_inspect(&self) -> String {
+ let mut output = String::new();
+
+ output.push_str(&format!("@ <%= error.type %> {}\n", self.location));
+ <%- symbol = error.fields.any? ? "├──" : "└──" -%>
+ output.push_str(&format!("<%= symbol %> message: {}\n", format_string_value(&self.message)));
+ <%- error.fields.each do |field| -%>
+ <%- symbol = error.fields.last == field ? "└──" : "├──" -%>
+ <%- case field -%>
+ <%- when Herb::Template::StringField -%>
+ output.push_str(&format!("<%= symbol %> <%= field.name %>: {}\n", format_string_value(&self.<%= field.name %>)));
+ <%- when Herb::Template::TokenField -%>
+ output.push_str(&format!("<%= symbol %> <%= field.name %>: {}\n", format_token_value(&self.<%= field.name %>)));
+ <%- when Herb::Template::TokenTypeField -%>
+ output.push_str(&format!("<%= symbol %> <%= field.name %>: {}\n", format_token_type_value(&self.<%= field.name %>)));
+ <%- when Herb::Template::PositionField -%>
+ output.push_str(&format!("<%= symbol %> <%= field.name %>: {}\n", format_position_value(&self.<%= field.name %>)));
+ <%- when Herb::Template::SizeTField -%>
+ output.push_str(&format!("<%= symbol %> <%= field.name %>: {}\n", format_size_value(self.<%= field.name %>)));
+ <%- end -%>
+ <%- end -%>
+
+ output
+ }
+}
+
+impl ErrorNode for <%= error.name %> {
+ fn error_type(&self) -> &str {
+ &self.error_type
+ }
+
+ fn message(&self) -> &str {
+ &self.message
+ }
+
+ fn location(&self) -> &Location {
+ &self.location
+ }
+
+ fn tree_inspect(&self) -> String {
+ <%= error.name %>::tree_inspect(self)
+ }
+}
+
+<%- end -%>
diff --git a/templates/rust/src/nodes.rs.erb b/templates/rust/src/nodes.rs.erb
new file mode 100644
index 000000000..c68784233
--- /dev/null
+++ b/templates/rust/src/nodes.rs.erb
@@ -0,0 +1,366 @@
+use crate::errors::{AnyError, ErrorNode};
+use crate::{Location, Token};
+
+fn escape_string(s: &str) -> String {
+ s.replace('\\', "\\\\")
+ .replace('\n', "\\n")
+ .replace('\r', "\\r")
+ .replace('\t', "\\t")
+ .replace('"', "\\\"")
+}
+
+fn format_string_value(value: &str) -> String {
+ format!("\"{}\"", escape_string(value))
+}
+
+fn format_token_value(token: &Option) -> String {
+ token.as_ref().map(|t| t.tree_inspect()).unwrap_or_else(|| "∅".to_string())
+}
+
+fn format_bool_value(value: bool) -> String {
+ value.to_string()
+}
+
+fn format_node_value(node: &Option>, prefix: &str, add_spacing: bool) -> String {
+ if let Some(ref n) = node {
+ let mut output = String::new();
+ output.push('\n');
+ output.push_str(&inspect_node_field(n.as_ref(), prefix));
+ if add_spacing {
+ output.push_str(&format!("{}\n", prefix));
+ }
+ output
+ } else {
+ "∅\n".to_string()
+ }
+}
+
+fn format_array_value(array: &[AnyNode], prefix: &str) -> String {
+ inspect_array(array, prefix)
+}
+
+fn format_errors_field(errors: &[AnyError], prefix: &str) -> String {
+ inspect_errors(errors, prefix)
+}
+
+fn inspect_errors(errors: &[AnyError], prefix: &str) -> String {
+ if errors.is_empty() {
+ return String::new();
+ }
+
+ let mut output = String::new();
+ output.push_str(&format!("├── errors: ({} error{})\n",
+ errors.len(),
+ if errors.len() == 1 { "" } else { "s" }
+ ));
+
+ for (i, error) in errors.iter().enumerate() {
+ let is_last = i == errors.len() - 1;
+ let symbol = if is_last { "└── " } else { "├── " };
+ let next_prefix = if is_last { " " } else { "│ " };
+
+ let tree = error.tree_inspect();
+ let tree = tree.trim_end_matches('\n');
+ output.push_str(&format!("{}{}{}\n", prefix, symbol, tree.replace('\n', &format!("\n{}{}", prefix, next_prefix))));
+
+ if !is_last {
+ output.push_str(&format!("{}│ \n", prefix));
+ }
+ }
+
+ output.push_str(&format!("{}\n", prefix));
+ output
+}
+
+fn inspect_array(array: &[AnyNode], prefix: &str) -> String {
+ if array.is_empty() {
+ return "[]\n".to_string();
+ }
+
+ let mut output = String::new();
+ output.push_str(&format!("({} item{})\n", array.len(), if array.len() == 1 { "" } else { "s" }));
+
+ for (i, item) in array.iter().enumerate() {
+ let is_last = i == array.len() - 1;
+ let symbol = if is_last { "└── " } else { "├── " };
+ let next_prefix = if is_last { " " } else { "│ " };
+
+ let tree = item.tree_inspect();
+ let tree = tree.trim_end_matches('\n');
+
+ output.push_str(prefix);
+ output.push_str(symbol);
+ output.push_str(&tree.replace('\n', &format!("\n{}{}", prefix, next_prefix)));
+ output.push('\n');
+
+ if !is_last {
+ output.push_str(prefix);
+ output.push_str(next_prefix);
+ output.push('\n');
+ }
+ }
+
+ output
+}
+
+fn inspect_node_field(node: &T, prefix: &str) -> String {
+ let tree = node.tree_inspect();
+ let tree = tree.trim_end_matches('\n');
+
+ let lines: Vec<&str> = tree.split('\n').collect();
+ if lines.is_empty() {
+ return "∅\n".to_string();
+ }
+
+ let mut result = String::new();
+ result.push_str(prefix);
+ result.push_str("└── ");
+ result.push_str(lines[0]);
+ result.push('\n');
+
+ for line in lines.iter().skip(1) {
+ if line.is_empty() {
+ result.push_str(prefix);
+ result.push('\n');
+ } else {
+ result.push_str(prefix);
+ result.push_str(" ");
+ result.push_str(line);
+ result.push('\n');
+ }
+ }
+
+ result
+}
+
+pub trait Node {
+ fn node_type(&self) -> &str;
+ fn location(&self) -> &Location;
+ fn errors(&self) -> &[AnyError];
+ fn child_nodes(&self) -> Vec<&dyn Node>;
+ fn recursive_errors(&self) -> Vec<&dyn ErrorNode>;
+ fn tree_inspect(&self) -> String;
+}
+
+#[derive(Debug, Clone)]
+pub enum AnyNode {
+ <%- nodes.each do |node| -%>
+ <%= node.name %>(<%= node.name %>),
+ <%- end -%>
+}
+
+impl AnyNode {
+ pub fn node_type(&self) -> &str {
+ match self {
+ <%- nodes.each do |node| -%>
+ AnyNode::<%= node.name %>(n) => &n.node_type,
+ <%- end -%>
+ }
+ }
+
+ pub fn location(&self) -> &Location {
+ match self {
+ <%- nodes.each do |node| -%>
+ AnyNode::<%= node.name %>(n) => &n.location,
+ <%- end -%>
+ }
+ }
+
+ pub fn errors(&self) -> &[AnyError] {
+ match self {
+ <%- nodes.each do |node| -%>
+ AnyNode::<%= node.name %>(n) => &n.errors,
+ <%- end -%>
+ }
+ }
+
+ pub fn tree_inspect(&self) -> String {
+ match self {
+ <%- nodes.each do |node| -%>
+ AnyNode::<%= node.name %>(n) => n.tree_inspect(),
+ <%- end -%>
+ }
+ }
+
+ pub fn child_nodes(&self) -> Vec<&dyn Node> {
+ match self {
+ <%- nodes.each do |node| -%>
+ AnyNode::<%= node.name %>(n) => n.child_nodes(),
+ <%- end -%>
+ }
+ }
+
+ pub fn recursive_errors(&self) -> Vec<&dyn ErrorNode> {
+ match self {
+ <%- nodes.each do |node| -%>
+ AnyNode::<%= node.name %>(n) => n.recursive_errors(),
+ <%- end -%>
+ }
+ }
+}
+
+impl Node for AnyNode {
+ fn node_type(&self) -> &str {
+ self.node_type()
+ }
+
+ fn location(&self) -> &Location {
+ self.location()
+ }
+
+ fn errors(&self) -> &[AnyError] {
+ self.errors()
+ }
+
+ fn child_nodes(&self) -> Vec<&dyn Node> {
+ self.child_nodes()
+ }
+
+ fn recursive_errors(&self) -> Vec<&dyn ErrorNode> {
+ self.recursive_errors()
+ }
+
+ fn tree_inspect(&self) -> String {
+ self.tree_inspect()
+ }
+}
+
+<%- nodes.each do |node| -%>
+#[derive(Debug, Clone)]
+pub struct <%= node.name %> {
+ pub node_type: String,
+ pub location: Location,
+ pub errors: Vec,
+ <%- node.fields.each do |field| -%>
+ <%- case field -%>
+ <%- when Herb::Template::StringField -%>
+ pub <%= field.name %>: String,
+ <%- when Herb::Template::TokenField -%>
+ pub <%= field.name %>: Option,
+ <%- when Herb::Template::BooleanField -%>
+ pub <%= field.name %>: bool,
+ <%- when Herb::Template::ArrayField -%>
+ pub <%= field.name %>: Vec,
+ <%- when Herb::Template::NodeField -%>
+ <%- if field.specific_kind && field.specific_kind != "Node" -%>
+ pub <%= field.name %>: Option>>,
+ <%- else -%>
+ pub <%= field.name %>: Option>,
+ <%- end -%>
+ <%- when Herb::Template::ElementSourceField -%>
+ pub <%= field.name %>: String,
+ <%- end -%>
+ <%- end -%>
+}
+
+impl Node for <%= node.name %> {
+ fn node_type(&self) -> &str {
+ &self.node_type
+ }
+
+ fn location(&self) -> &Location {
+ &self.location
+ }
+
+ fn errors(&self) -> &[AnyError] {
+ &self.errors
+ }
+
+ fn child_nodes(&self) -> Vec<&dyn Node> {
+ <%- has_children = node.fields.any? { |field|
+ case field
+ when Herb::Template::ArrayField
+ true
+ when Herb::Template::NodeField
+ true
+ else
+ false
+ end
+ } -%>
+ <%- if has_children -%>
+ let mut children: Vec<&dyn Node> = Vec::new();
+ <%- node.fields.each do |field| -%>
+ <%- case field -%>
+ <%- when Herb::Template::ArrayField -%>
+ children.extend(self.<%= field.name %>.iter().map(|n| n as &dyn Node));
+ <%- when Herb::Template::NodeField -%>
+ if let Some(ref node) = self.<%= field.name %> {
+ <%- if field.specific_kind && field.specific_kind != "Node" -%>
+ children.push(node.as_ref() as &dyn Node);
+ <%- else -%>
+ children.push(node.as_ref() as &dyn Node);
+ <%- end -%>
+ }
+ <%- end -%>
+ <%- end -%>
+ children
+ <%- else -%>
+ Vec::new()
+ <%- end -%>
+ }
+
+ fn recursive_errors(&self) -> Vec<&dyn ErrorNode> {
+ <%- has_children = node.fields.any? { |field|
+ case field
+ when Herb::Template::ArrayField
+ true
+ when Herb::Template::NodeField
+ true
+ else
+ false
+ end
+ } -%>
+ <%- if has_children -%>
+ let mut all_errors: Vec<&dyn ErrorNode> = Vec::new();
+ all_errors.extend(self.errors.iter().map(|e| e as &dyn ErrorNode));
+
+ <%- node.fields.each do |field| -%>
+ <%- case field -%>
+ <%- when Herb::Template::ArrayField -%>
+ for child in &self.<%= field.name %> {
+ all_errors.extend(child.recursive_errors());
+ }
+ <%- when Herb::Template::NodeField -%>
+ if let Some(ref node) = self.<%= field.name %> {
+ all_errors.extend(node.recursive_errors());
+ }
+ <%- end -%>
+ <%- end -%>
+
+ all_errors
+ <%- else -%>
+ self.errors.iter().map(|e| e as &dyn ErrorNode).collect()
+ <%- end -%>
+ }
+
+ fn tree_inspect(&self) -> String {
+ let mut output = String::new();
+
+ output.push_str(&format!("@ <%= node.name %> (location: {})\n", self.location));
+ output.push_str(&format_errors_field(&self.errors, <%- if node.fields.any? -%>"│ "<%- else -%>" "<%- end -%>));
+ <%- if node.fields.any? -%>
+ <%- node.fields.each_with_index do |field, index| -%>
+ <%- is_last = index == node.fields.length - 1 -%>
+ <%- symbol = is_last ? "└── " : "├── " -%>
+ <%- case field -%>
+ <%- when Herb::Template::StringField, Herb::Template::ElementSourceField -%>
+ output.push_str(&format!("<%= symbol %><%= field.name %>: {}\n", format_string_value(&self.<%= field.name %>)));
+ <%- when Herb::Template::TokenField -%>
+ output.push_str(&format!("<%= symbol %><%= field.name %>: {}\n", format_token_value(&self.<%= field.name %>)));
+ <%- when Herb::Template::BooleanField -%>
+ output.push_str(&format!("<%= symbol %><%= field.name %>: {}\n", format_bool_value(self.<%= field.name %>)));
+ <%- when Herb::Template::ArrayField -%>
+ output.push_str(&format!("<%= symbol %><%= field.name %>: {}", format_array_value(&self.<%= field.name %>, "<%= is_last ? " " : "│ " %>")));
+ <%- when Herb::Template::NodeField -%>
+ output.push_str(&format!("<%= symbol %><%= field.name %>: {}", format_node_value(&self.<%= field.name %>, "<%= is_last ? " " : "│ " %>", <%= !is_last %>)));
+ <%- end -%>
+ <%- end -%>
+ <%- else -%>
+ output.push_str("└── (no fields)\n");
+ <%- end -%>
+
+ output
+ }
+}
+
+<%- end -%>
diff --git a/templates/template.rb b/templates/template.rb
index 64097371f..749c970db 100755
--- a/templates/template.rb
+++ b/templates/template.rb
@@ -245,6 +245,10 @@ def initialize(config)
type.new(name: field_name, kind: kind)
end
end
+
+ def c_type
+ @struct_type
+ end
end
class NodeType
@@ -268,6 +272,10 @@ def initialize(config)
type.new(name: field_name, kind: kind)
end
end
+
+ def c_type
+ @struct_type
+ end
end
class PrintfMessageTemplate
@@ -331,6 +339,8 @@ def self.check_gitignore(name)
end
def self.render(template_file)
+ template_file_display = template_file.delete_prefix("#{File.expand_path("../", __dir__)}/")
+
name = Pathname.new(template_file)
name = if name.absolute?
template_file.gsub(
@@ -351,8 +361,6 @@ def self.render(template_file)
)
end
- puts "Rendering #{template_file.delete_prefix("#{File.expand_path("../", __dir__)}/")} → #{destination}"
-
template_file = Pathname.new(template_file)
template_path = if template_file.absolute?
template_file
@@ -367,6 +375,17 @@ def self.render(template_file)
check_gitignore(name)
+ if File.exist?(destination)
+ existing_content = File.read(destination, encoding: Encoding::UTF_8)
+
+ if existing_content == content
+ puts "[unchanged] #{destination}"
+ return
+ end
+ end
+
+ puts "Rendering #{template_file_display} → #{destination}"
+
FileUtils.mkdir_p(File.dirname(destination))
File.write(destination, content)
rescue SyntaxError => e