herb 0.7.4-aarch64-linux-gnu → 0.8.0-aarch64-linux-gnu

data/templates/lib/herb/errors.rb.erb

@@ -37,14 +37,16 @@ module Herb
         to_hash.to_json(state)
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(_indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         raise NotImplementedError
       end
     end
 
     <%- errors.each do |error| -%>
     class <%= error.name -%> < Error
+      include Colors
+
       <%- error.fields.each do |field| -%>
       attr_reader :<%= field.name %> #: <%= field.ruby_type %>
       <%- end -%>
@@ -72,27 +74,30 @@ module Herb
         }) #: Herb::serialized_<%= error.human %>
       end
 
-      #: (?Integer) -> String
-      def tree_inspect(indent = 0)
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
         output = +""
 
-        output += %(@ #{error_name} #{location.tree_inspect}\n)
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
         <%- symbol = error.fields.none? ? "└──" : "├──" -%>
-        output += %(<%= symbol %> message: #{message.inspect}\n)
+        output += white("<%= symbol %> message: #{green(message.inspect)}\n")
         <%- error.fields.each do |field| -%>
         <%- symbol = error.fields.last == field ? "└──" : "├──" -%>
-        <%- name = "#{symbol} #{field.name}: " -%>
         <%- case field -%>
         <%- when Herb::Template::PositionField -%>
-        output += %(<%= name %>#{<%= field.name %> ? <%= field.name %>.tree_inspect : "∅"}\n)
+        output += white("<%= symbol %> <%= field.name %>: ")
+        output += <%= field.name %> ? <%= field.name %>.tree_inspect : magenta("∅")
+        output += "\n"
         <%- when Herb::Template::TokenField -%>
-        output += %(<%= name %>#{<%= field.name %> ? <%= field.name %>.tree_inspect : "∅"}\n)
+        output += white("<%= symbol %> <%= field.name %>: ")
+        output += <%= field.name %> ? <%= field.name %>.tree_inspect : magenta("∅")
+        output += "\n"
         <%- when Herb::Template::TokenTypeField -%>
-        output += %(<%= name %>#{<%= field.name %>.inspect}\n)
+        output += white("<%= symbol %> <%= field.name %>: #{green(<%= field.name %>.inspect)}\n")
         <%- when Herb::Template::StringField -%>
-        output += %(<%= name %>#{<%= field.name %>.inspect}\n)
+        output += white("<%= symbol %> <%= field.name %>: #{green(<%= field.name %>.inspect)}\n")
         <%- else -%>
-        output += "<%= name %>'#{<%= field.name %>.class}'\n"
+        output += white("<%= symbol %> <%= field.name %>: ") + '#{<%= field.name %>.class}'\n"
         <%- end -%>
         <%- end -%>
         output += %(\n)

data/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<AnyError> {
+  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<crate::Token> {
+  if token_ptr.is_null() {
+    None
+  } else {
+    Some(token_from_c(token_ptr))
+  }
+}
+
+unsafe fn convert_children(children_array: *mut hb_array_T) -> Vec<AnyNode> {
+  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<Box<AnyNode>> {
+  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<AnyNode> {
+  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 -%>

data/templates/rust/src/errors.rs.erb

@@ -0,0 +1,216 @@
+use crate::{Location, Token};
+use colored::*;
+
+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)).green().to_string()
+}
+
+fn format_token_value(token: &Option<Token>) -> String {
+  token.as_ref().map(|t| t.tree_inspect()).unwrap_or_else(|| "∅".magenta().to_string())
+}
+
+fn format_token_type_value(token_type: &Option<String>) -> String {
+  token_type.as_ref().map(|t| format!("\"{}\"", t).green().to_string()).unwrap_or_else(|| "∅".magenta().to_string())
+}
+
+#[allow(dead_code)]
+fn format_position_value(position: &Option<crate::Position>) -> String {
+  position.as_ref().map(|p| p.to_string()).unwrap_or_else(|| "∅".magenta().to_string())
+}
+
+#[allow(dead_code)]
+fn format_size_value(value: usize) -> String {
+  value.to_string().magenta().bold().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<Token>,
+  <%- when Herb::Template::TokenTypeField -%>
+  pub <%= field.name %>: Option<String>,
+  <%- when Herb::Template::PositionField -%>
+  pub <%= field.name %>: Option<Position>,
+  <%- 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<Token>,
+    <%- when Herb::Template::TokenTypeField -%>
+    <%= field.name %>: Option<String>,
+    <%- when Herb::Template::PositionField -%>
+    <%= field.name %>: Option<Position>,
+    <%- 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!("{} {} {}\n",
+      "@".white(),
+      "<%= error.name %>".red().bold(),
+      format!("(location: {})", self.location).dimmed()
+    ));
+    <%- symbol = error.fields.any? ? "├──" : "└──" -%>
+    output.push_str(&format!("{} {}: {}\n", "<%= symbol %>".white(), "message".white(), 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!("{} {}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), format_string_value(&self.<%= field.name %>)));
+    <%- when Herb::Template::TokenField -%>
+    output.push_str(&format!("{} {}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), format_token_value(&self.<%= field.name %>)));
+    <%- when Herb::Template::TokenTypeField -%>
+    output.push_str(&format!("{} {}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), format_token_type_value(&self.<%= field.name %>)));
+    <%- when Herb::Template::PositionField -%>
+    output.push_str(&format!("{} {}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), format_position_value(&self.<%= field.name %>)));
+    <%- when Herb::Template::SizeTField -%>
+    output.push_str(&format!("{} {}: {}\n", "<%= symbol %>".white(), "<%= field.name %>".white(), 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 -%>