herb 0.9.7-arm-linux-gnu → 0.10.1-arm-linux-gnu

data/src/include/diff/herb_diff.h

@@ -0,0 +1,118 @@
+#ifndef HERB_DIFF_H
+#define HERB_DIFF_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "../ast/ast_nodes.h"
+#include "../lib/hb_allocator.h"
+#include "../lib/hb_array.h"
+#include "herb_hash.h"
+#include "herb_hash_map.h"
+
+#define HERB_DIFF_PATH_MAX_DEPTH 64
+
+typedef enum {
+  HERB_DIFF_NODE_INSERTED,
+  HERB_DIFF_NODE_REMOVED,
+  HERB_DIFF_NODE_REPLACED,
+  HERB_DIFF_NODE_MOVED,
+
+  HERB_DIFF_TEXT_CHANGED,
+  HERB_DIFF_ERB_CONTENT_CHANGED,
+
+  HERB_DIFF_ATTRIBUTE_ADDED,
+  HERB_DIFF_ATTRIBUTE_REMOVED,
+  HERB_DIFF_ATTRIBUTE_VALUE_CHANGED,
+
+  HERB_DIFF_TAG_NAME_CHANGED,
+
+  HERB_DIFF_NODE_WRAPPED,
+  HERB_DIFF_NODE_UNWRAPPED,
+} herb_diff_operation_type_T;
+
+typedef struct {
+  uint32_t indices[HERB_DIFF_PATH_MAX_DEPTH];
+  uint16_t depth;
+} herb_diff_path_T;
+
+typedef struct {
+  herb_diff_operation_type_T type;
+  herb_diff_path_T path;
+  const AST_NODE_T* old_node;
+  const AST_NODE_T* new_node;
+  uint32_t old_index;
+  uint32_t new_index;
+} herb_diff_operation_T;
+
+typedef struct {
+  hb_array_T* operations;
+  hb_allocator_T* allocator;
+  bool trees_identical;
+} herb_diff_result_T;
+
+herb_diff_path_T herb_diff_path_empty(void);
+herb_diff_path_T herb_diff_path_append(herb_diff_path_T path, uint32_t index);
+
+herb_diff_result_T* herb_diff(
+  const AST_DOCUMENT_NODE_T* old_document,
+  const AST_DOCUMENT_NODE_T* new_document,
+  hb_allocator_T* allocator
+);
+
+size_t herb_diff_operation_count(const herb_diff_result_T* result);
+const herb_diff_operation_T* herb_diff_operation_at(const herb_diff_result_T* result, size_t index);
+bool herb_diff_trees_identical(const herb_diff_result_T* result);
+const char* herb_diff_operation_type_to_string(herb_diff_operation_type_T type);
+
+void herb_diff_node(
+  const AST_NODE_T* old_node,
+  const AST_NODE_T* new_node,
+  herb_diff_path_T path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+);
+
+void herb_diff_children(
+  const hb_array_T* old_children,
+  const hb_array_T* new_children,
+  herb_diff_path_T parent_path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+);
+
+void herb_diff_attributes(
+  const hb_array_T* old_attributes,
+  const hb_array_T* new_attributes,
+  herb_diff_path_T parent_path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+);
+
+void herb_diff_emit_operation(
+  herb_diff_result_T* result,
+  herb_diff_operation_type_T type,
+  herb_diff_path_T path,
+  const AST_NODE_T* old_node,
+  const AST_NODE_T* new_node,
+  uint32_t old_index,
+  uint32_t new_index
+);
+
+const hb_array_T* herb_diff_get_node_children(const AST_NODE_T* node);
+
+const AST_NODE_T* herb_diff_find_child_by_hash(
+  const AST_NODE_T* parent,
+  herb_hash_T target_hash,
+  const herb_hash_map_T* hash_map
+);
+
+herb_hash_T herb_hash_tree(const AST_NODE_T* node, herb_hash_map_T* hash_map);
+herb_hash_T herb_hash_node_identity(const AST_NODE_T* node, const herb_hash_map_T* hash_map);
+herb_hash_T herb_hash_node_move_identity(const AST_NODE_T* node, const herb_hash_map_T* hash_map);
+
+#endif

data/src/include/diff/herb_hash.h

@@ -0,0 +1,25 @@
+#ifndef HERB_HASH_H
+#define HERB_HASH_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "../lib/hb_string.h"
+
+typedef uint64_t herb_hash_T;
+
+// FNV-1a 64-bit hash constants
+// Fowler-Noll-Vo hash function: http://www.isthe.com/chongo/tech/comp/fnv/
+// Created by Glenn Fowler, Landon Curt Noll, and Kiem-Phong Vo
+#define HERB_HASH_INIT ((herb_hash_T) 0xcbf29ce484222325ULL)
+#define HERB_HASH_FNV_PRIME ((herb_hash_T) 0x100000001b3ULL)
+
+herb_hash_T herb_hash_byte(herb_hash_T hash, uint8_t byte);
+herb_hash_T herb_hash_bytes(herb_hash_T hash, const void* data, size_t length);
+herb_hash_T herb_hash_uint32(herb_hash_T hash, uint32_t value);
+herb_hash_T herb_hash_uint64(herb_hash_T hash, uint64_t value);
+herb_hash_T herb_hash_bool(herb_hash_T hash, bool value);
+herb_hash_T herb_hash_string(herb_hash_T hash, hb_string_T string);
+herb_hash_T herb_hash_combine(herb_hash_T hash, herb_hash_T other);
+
+#endif

data/src/include/diff/herb_hash_index_map.h

@@ -0,0 +1,32 @@
+#ifndef HERB_HASH_INDEX_MAP_H
+#define HERB_HASH_INDEX_MAP_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#include "../lib/hb_allocator.h"
+#include "herb_hash.h"
+
+typedef struct {
+  herb_hash_T key;
+  size_t value;
+  bool occupied;
+} herb_hash_index_entry_T;
+
+typedef struct {
+  herb_hash_index_entry_T* entries;
+  size_t capacity;
+} herb_hash_index_map_T;
+
+bool herb_hash_index_map_init(herb_hash_index_map_T* map, size_t count, hb_allocator_T* allocator);
+
+void herb_hash_index_map_insert(herb_hash_index_map_T* map, herb_hash_T key, size_t value);
+
+bool herb_hash_index_map_find_unmatched(
+  const herb_hash_index_map_T* map,
+  herb_hash_T key,
+  const bool* matched,
+  size_t* out_value
+);
+
+#endif

data/src/include/diff/herb_hash_map.h

@@ -0,0 +1,30 @@
+#ifndef HERB_HASH_MAP_H
+#define HERB_HASH_MAP_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include "../ast/ast_nodes.h"
+#include "../lib/hb_allocator.h"
+#include "herb_hash.h"
+
+typedef struct {
+  const AST_NODE_T* node;
+  herb_hash_T hash;
+  bool occupied;
+} herb_hash_map_entry_T;
+
+typedef struct {
+  herb_hash_map_entry_T* entries;
+  size_t capacity;
+  size_t size;
+  hb_allocator_T* allocator;
+} herb_hash_map_T;
+
+bool herb_hash_map_init(herb_hash_map_T* map, size_t initial_capacity, hb_allocator_T* allocator);
+void herb_hash_map_set(herb_hash_map_T* map, const AST_NODE_T* node, herb_hash_T hash);
+herb_hash_T herb_hash_map_get(const herb_hash_map_T* map, const AST_NODE_T* node);
+bool herb_hash_map_has(const herb_hash_map_T* map, const AST_NODE_T* node);
+
+#endif

data/src/include/herb.h

@@ -2,6 +2,7 @@
 #define HERB_H
 
 #include "ast/ast_node.h"
+#include "diff/herb_diff.h"
 #include "extract.h"
 #include "lib/hb_allocator.h"
 #include "lib/hb_array.h"

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.9.7"
+#define HERB_VERSION "0.10.1"
 
 #endif

data/templates/javascript/packages/core/src/config.ts.erb

@@ -0,0 +1,43 @@
+<%
+  options = YAML.safe_load_file("config/options.yml")
+
+  def camel_case(string)
+    parts = string.split("_")
+    parts[0] + parts[1..].map(&:capitalize).join
+  end
+
+  def pascal_case(string)
+    string.split("_").map(&:capitalize).join
+  end
+-%>
+
+<% options.each do |key, config| -%>
+export type <%= pascal_case(key) %> = <%= config["values"].map { |v| "\"#{v}\"" }.join(" | ") %>
+<% end -%>
+
+<% options.each do |key, config| -%>
+export const VALID_<%= key.upcase %>S: readonly <%= pascal_case(key) %>[] = [<%= config["values"].map { |v| "\"#{v}\"" }.join(", ") %>] as const
+<% end -%>
+
+<% options.each do |key, config| -%>
+export const DEFAULT_<%= key.upcase %>: <%= pascal_case(key) %> = "<%= config["default"] %>"
+<% end -%>
+
+export interface HerbConfig {
+<% options.each do |key, _config| -%>
+  <%= camel_case(key) %>: <%= pascal_case(key) %>
+<% end -%>
+}
+
+export const DEFAULT_CONFIG: HerbConfig = {
+<% options.each do |key, _config| -%>
+  <%= camel_case(key) %>: DEFAULT_<%= key.upcase %>,
+<% end -%>
+}
+
+<% options.each do |key, _config| -%>
+export function isValid<%= pascal_case(key) %>(value: string): value is <%= pascal_case(key) %> {
+  return (VALID_<%= key.upcase %>S as readonly string[]).includes(value)
+}
+
+<% end -%>

data/templates/rust/src/ast/nodes.rs.erb

@@ -160,7 +160,7 @@ macro_rules! convert_specific_node_field {
   };
 }
 
-unsafe fn convert_node(node_pointer: *const c_void) -> Option<AnyNode> {
+pub(crate) unsafe fn convert_node(node_pointer: *const c_void) -> Option<AnyNode> {
   if node_pointer.is_null() {
     return None;
   }

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

@@ -0,0 +1,50 @@
+<%
+  options = YAML.safe_load_file("config/options.yml")
+
+  def pascal_case(string)
+    string.split("_").map(&:capitalize).join
+  end
+
+  def title_case(string)
+    string.split("_").map(&:capitalize).join("")
+  end
+-%>
+
+use std::fmt;
+
+<% options.each do |key, config| -%>
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum <%= pascal_case(key) %> {
+<% config["values"].each do |value| -%>
+  <%= title_case(value) %>,
+<% end -%>
+}
+
+impl Default for <%= pascal_case(key) %> {
+  fn default() -> Self {
+    <%= pascal_case(key) %>::<%= title_case(config["default"]) %>
+  }
+}
+
+impl fmt::Display for <%= pascal_case(key) %> {
+  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    match self {
+    <% config["values"].each do |value| -%>
+      <%= pascal_case(key) %>::<%= title_case(value) %> => write!(f, "<%= value %>"),
+    <% end -%>
+    }
+  }
+}
+
+impl <%= pascal_case(key) %> {
+  pub fn from_str(string: &str) -> Option<Self> {
+    match string {
+    <% config["values"].each do |value| -%>
+      "<%= value %>" => Some(<%= pascal_case(key) %>::<%= title_case(value) %>),
+    <% end -%>
+      _ => None,
+    }
+  }
+}
+
+<% end -%>

data/templates/src/diff/herb_diff_helpers.c.erb

@@ -0,0 +1,38 @@
+#include "../include/diff/herb_diff.h"
+
+const hb_array_T* herb_diff_get_node_children(const AST_NODE_T* node) {
+  if (node == NULL) { return NULL; }
+
+  switch (node->type) {
+  <%- nodes.each do |node| -%>
+    <%- primary_array = node.fields.find { |field| field.is_a?(Herb::Template::ArrayField) && (field.name == "children" || field.name == "body" || field.name == "statements" || field.name == "conditions") } -%>
+    <%- if primary_array -%>
+    case <%= node.type %>:
+      return ((const <%= node.struct_type %>*) node)-><%= primary_array.name %>;
+
+    <%- end -%>
+  <%- end -%>
+    default:
+      return NULL;
+  }
+}
+
+const AST_NODE_T* herb_diff_find_child_by_hash(
+  const AST_NODE_T* parent,
+  const herb_hash_T target_hash,
+  const herb_hash_map_T* hash_map
+) {
+  const hb_array_T* children = herb_diff_get_node_children(parent);
+  if (children == NULL) { return NULL; }
+
+  const size_t count = hb_array_size(children);
+
+  for (size_t index = 0; index < count; index++) {
+    const AST_NODE_T* child = (const AST_NODE_T*) hb_array_get(children, index);
+    herb_hash_T child_hash = herb_hash_map_get(hash_map, child);
+
+    if (child_hash == target_hash) { return child; }
+  }
+
+  return NULL;
+}

data/templates/src/diff/herb_diff_nodes.c.erb

@@ -0,0 +1,224 @@
+#include "../include/diff/herb_diff.h"
+#include "../include/lib/hb_string.h"
+
+static bool tokens_equal(const token_T* old_token, const token_T* new_token) {
+  if (old_token == NULL && new_token == NULL) { return true; }
+  if (old_token == NULL || new_token == NULL) { return false; }
+
+  return hb_string_equals(old_token->value, new_token->value);
+}
+
+static void diff_element_node(
+  const AST_HTML_ELEMENT_NODE_T* old_element,
+  const AST_HTML_ELEMENT_NODE_T* new_element,
+  const herb_diff_path_T path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+) {
+  if (!tokens_equal(old_element->tag_name, new_element->tag_name)) {
+    herb_diff_emit_operation(result, HERB_DIFF_TAG_NAME_CHANGED, path, (const AST_NODE_T*) old_element, (const AST_NODE_T*) new_element, 0, 0);
+  }
+
+  if (old_element->open_tag != NULL && new_element->open_tag != NULL) {
+    herb_hash_T old_open_hash = herb_hash_map_get(old_hashes, old_element->open_tag);
+    herb_hash_T new_open_hash = herb_hash_map_get(new_hashes, new_element->open_tag);
+
+    if (old_open_hash != new_open_hash) {
+      const AST_HTML_OPEN_TAG_NODE_T* old_open_tag = (const AST_HTML_OPEN_TAG_NODE_T*) old_element->open_tag;
+      const AST_HTML_OPEN_TAG_NODE_T* new_open_tag = (const AST_HTML_OPEN_TAG_NODE_T*) new_element->open_tag;
+
+      herb_diff_attributes(old_open_tag->children, new_open_tag->children, path, old_hashes, new_hashes, result);
+    }
+  }
+
+  if (old_element->body != NULL && new_element->body != NULL) {
+    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, result);
+  } else if (old_element->body == NULL && new_element->body != NULL) {
+    for (size_t index = 0; index < hb_array_size(new_element->body); index++) {
+      const AST_NODE_T* new_child = (const AST_NODE_T*) hb_array_get(new_element->body, index);
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_INSERTED, herb_diff_path_append(path, (uint32_t) index), NULL, new_child, 0, (uint32_t) index);
+    }
+  } else if (old_element->body != NULL && new_element->body == NULL) {
+    for (size_t index = 0; index < hb_array_size(old_element->body); index++) {
+      const AST_NODE_T* old_child = (const AST_NODE_T*) hb_array_get(old_element->body, index);
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_REMOVED, herb_diff_path_append(path, (uint32_t) index), old_child, NULL, (uint32_t) index, 0);
+    }
+  }
+}
+
+static void diff_conditional_element_node(
+  const AST_HTML_CONDITIONAL_ELEMENT_NODE_T* old_element,
+  const AST_HTML_CONDITIONAL_ELEMENT_NODE_T* new_element,
+  const herb_diff_path_T path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+) {
+  if (!tokens_equal(old_element->tag_name, new_element->tag_name)) {
+    herb_diff_emit_operation(result, HERB_DIFF_TAG_NAME_CHANGED, path, (const AST_NODE_T*) old_element, (const AST_NODE_T*) new_element, 0, 0);
+  }
+
+  if (old_element->open_tag != NULL && new_element->open_tag != NULL) {
+    herb_hash_T old_open_hash = herb_hash_map_get(old_hashes, (const AST_NODE_T*) old_element->open_tag);
+    herb_hash_T new_open_hash = herb_hash_map_get(new_hashes, (const AST_NODE_T*) new_element->open_tag);
+
+    if (old_open_hash != new_open_hash) {
+      herb_diff_attributes(old_element->open_tag->children, new_element->open_tag->children, path, old_hashes, new_hashes, result);
+    }
+  }
+
+  if (old_element->body != NULL && new_element->body != NULL) {
+    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, result);
+  }
+}
+
+static void diff_children_nullable(
+  const hb_array_T* old_children,
+  const hb_array_T* new_children,
+  const herb_diff_path_T path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+) {
+  if (old_children != NULL && new_children != NULL) {
+    herb_diff_children(old_children, new_children, path, old_hashes, new_hashes, result);
+  } else if (old_children == NULL && new_children != NULL) {
+    for (size_t index = 0; index < hb_array_size(new_children); index++) {
+      const AST_NODE_T* new_child = (const AST_NODE_T*) hb_array_get(new_children, index);
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_INSERTED, herb_diff_path_append(path, (uint32_t) index), NULL, new_child, 0, (uint32_t) index);
+    }
+  } else if (old_children != NULL && new_children == NULL) {
+    for (size_t index = 0; index < hb_array_size(old_children); index++) {
+      const AST_NODE_T* old_child = (const AST_NODE_T*) hb_array_get(old_children, index);
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_REMOVED, herb_diff_path_append(path, (uint32_t) index), old_child, NULL, (uint32_t) index, 0);
+    }
+  }
+}
+
+void herb_diff_node(
+  const AST_NODE_T* old_node,
+  const AST_NODE_T* new_node,
+  const herb_diff_path_T path,
+  const herb_hash_map_T* old_hashes,
+  const herb_hash_map_T* new_hashes,
+  herb_diff_result_T* result
+) {
+  if (old_node == NULL && new_node == NULL) { return; }
+
+  if (old_node == NULL) {
+    herb_diff_emit_operation(result, HERB_DIFF_NODE_INSERTED, path, NULL, new_node, 0, 0);
+    return;
+  }
+
+  if (new_node == NULL) {
+    herb_diff_emit_operation(result, HERB_DIFF_NODE_REMOVED, path, old_node, NULL, 0, 0);
+    return;
+  }
+
+  herb_hash_T old_hash = herb_hash_map_get(old_hashes, old_node);
+  herb_hash_T new_hash = herb_hash_map_get(new_hashes, new_node);
+
+  if (old_hash == new_hash) { return; }
+
+  if (old_node->type != new_node->type) {
+    herb_diff_emit_operation(result, HERB_DIFF_NODE_REPLACED, path, old_node, new_node, 0, 0);
+    return;
+  }
+
+  switch (old_node->type) {
+  <%- nodes.each do |node| -%>
+  <%- # Skip nodes with custom handlers -%>
+  <%- if node.name == "HTMLElementNode" -%>
+    case <%= node.type %>: {
+      diff_element_node(
+        (const <%= node.struct_type %>*) old_node,
+        (const <%= node.struct_type %>*) new_node,
+        path, old_hashes, new_hashes, result
+      );
+    } break;
+
+  <%- elsif node.name == "HTMLConditionalElementNode" -%>
+    case <%= node.type %>: {
+      diff_conditional_element_node(
+        (const <%= node.struct_type %>*) old_node,
+        (const <%= node.struct_type %>*) new_node,
+        path, old_hashes, new_hashes, result
+      );
+    } break;
+
+  <%- elsif node.name == "HTMLAttributeNode" -%>
+    case <%= node.type %>: {
+      const <%= node.struct_type %>* old_attribute = (const <%= node.struct_type %>*) old_node;
+      const <%= node.struct_type %>* new_attribute = (const <%= node.struct_type %>*) new_node;
+
+      herb_hash_T old_name_hash = herb_hash_map_get(old_hashes, (const AST_NODE_T*) old_attribute->name);
+      herb_hash_T new_name_hash = herb_hash_map_get(new_hashes, (const AST_NODE_T*) new_attribute->name);
+
+      if (old_name_hash != new_name_hash) {
+        herb_diff_emit_operation(result, HERB_DIFF_NODE_REPLACED, path, old_node, new_node, 0, 0);
+      } else {
+        herb_hash_T old_value_hash = herb_hash_map_get(old_hashes, (const AST_NODE_T*) old_attribute->value);
+        herb_hash_T new_value_hash = herb_hash_map_get(new_hashes, (const AST_NODE_T*) new_attribute->value);
+
+        if (old_value_hash != new_value_hash) {
+          herb_diff_emit_operation(result, HERB_DIFF_ATTRIBUTE_VALUE_CHANGED, path, old_node, new_node, 0, 0);
+        }
+      }
+    } break;
+
+  <%- elsif node.name == "HTMLOpenTagNode" -%>
+    case <%= node.type %>: {
+      const <%= node.struct_type %>* old_open_tag = (const <%= node.struct_type %>*) old_node;
+      const <%= node.struct_type %>* new_open_tag = (const <%= node.struct_type %>*) new_node;
+
+      herb_diff_attributes(old_open_tag->children, new_open_tag->children, path, old_hashes, new_hashes, result);
+    } break;
+
+  <%- else -%>
+    <%- all_fields = node.fields.reject(&:always_invisible?).reject { |field| field.is_a?(Herb::Template::PrismNodeField) || field.is_a?(Herb::Template::LocationField) || field.is_a?(Herb::Template::BooleanField) || field.is_a?(Herb::Template::ElementSourceField) } -%>
+    <%- token_fields = all_fields.select { |field| field.is_a?(Herb::Template::TokenField) } -%>
+    <%- string_fields = all_fields.select { |field| field.is_a?(Herb::Template::StringField) } -%>
+    <%- array_fields = all_fields.select { |field| field.is_a?(Herb::Template::ArrayField) } -%>
+    <%- node_fields = all_fields.select { |field| field.is_a?(Herb::Template::NodeField) || field.is_a?(Herb::Template::BorrowedNodeField) } -%>
+    <%- content_tokens = token_fields.select { |field| %w[content tag_opening].include?(field.name) } -%>
+    <%- has_comparisons = content_tokens.any? || string_fields.any? || array_fields.any? || node_fields.any? -%>
+    <%- is_erb_node = node.name.start_with?("ERB") || node.name.start_with?("Ruby") -%>
+    <%- if !has_comparisons -%>
+    case <%= node.type %>: {
+      herb_diff_emit_operation(result, HERB_DIFF_NODE_REPLACED, path, old_node, new_node, 0, 0);
+    } break;
+
+  <%- else -%>
+    case <%= node.type %>: {
+      const <%= node.struct_type %>* old_<%= node.human %> = (const <%= node.struct_type %>*) old_node;
+      const <%= node.struct_type %>* new_<%= node.human %> = (const <%= node.struct_type %>*) new_node;
+
+    <%- if content_tokens.any? -%>
+      if (<%= content_tokens.map { |field| "!tokens_equal(old_#{node.human}->#{field.name}, new_#{node.human}->#{field.name})" }.join("\n          || ") %>) {
+        herb_diff_emit_operation(result, <%= is_erb_node ? "HERB_DIFF_ERB_CONTENT_CHANGED" : "HERB_DIFF_TEXT_CHANGED" %>, path, old_node, new_node, 0, 0);
+      }
+
+    <%- end -%>
+
+    <%- if string_fields.any? -%>
+      if (<%= string_fields.map { |field| "!hb_string_equals(old_#{node.human}->#{field.name}, new_#{node.human}->#{field.name})" }.join("\n          || ") %>) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+    <%- end -%>
+
+    <%- array_fields.each do |field| -%>
+      diff_children_nullable(old_<%= node.human %>-><%= field.name %>, new_<%= node.human %>-><%= field.name %>, path, old_hashes, new_hashes, result);
+    <%- end -%>
+
+    <%- node_fields.each do |field| -%>
+      herb_diff_node((const AST_NODE_T*) old_<%= node.human %>-><%= field.name %>, (const AST_NODE_T*) new_<%= node.human %>-><%= field.name %>, path, old_hashes, new_hashes, result);
+    <%- end -%>
+    } break;
+
+  <%- end -%>
+<%- end -%>
+<%- end -%>
+  }
+}