herb 0.10.4-aarch64-linux-gnu → 0.11.0-aarch64-linux-gnu

data/src/diff/herb_diff_nodes.c

@@ -1,8 +1,9 @@
 // NOTE: This file is generated by the templates/template.rb script and should not
-// be modified manually. See /home/runner/work/herb/herb/templates/src/diff/herb_diff_nodes.c.erb
+// be modified manually. See templates/src/diff/herb_diff_nodes.c.erb
 
 #include "../include/diff/herb_diff.h"
 #include "../include/lib/hb_string.h"
+#include "../include/util/html_util.h"
 
 static bool tokens_equal(const token_T* old_token, const token_T* new_token) {
   if (old_token == NULL && new_token == NULL) { return true; }
@@ -11,14 +12,26 @@ static bool tokens_equal(const token_T* old_token, const token_T* new_token) {
   return hb_string_equals(old_token->value, new_token->value);
 }
 
+static bool body_preserves_whitespace(const token_T* old_tag_name, const token_T* new_tag_name, const bool inherited) {
+  if (inherited) { return true; }
+  if (old_tag_name != NULL && is_whitespace_preserving_element(old_tag_name->value)) { return true; }
+  if (new_tag_name != NULL && is_whitespace_preserving_element(new_tag_name->value)) { return true; }
+
+  return false;
+}
+
 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,
+  const bool preserve_whitespace,
   herb_diff_result_T* result
 ) {
+  const bool preserve_body_whitespace =
+    body_preserves_whitespace(old_element->tag_name, new_element->tag_name, preserve_whitespace);
+
   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);
   }
@@ -36,7 +49,7 @@ static void diff_element_node(
   }
 
   if (old_element->body != NULL && new_element->body != NULL) {
-    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, result);
+    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, preserve_body_whitespace, 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);
@@ -56,8 +69,12 @@ static void diff_conditional_element_node(
   const herb_diff_path_T path,
   const herb_hash_map_T* old_hashes,
   const herb_hash_map_T* new_hashes,
+  const bool preserve_whitespace,
   herb_diff_result_T* result
 ) {
+  const bool preserve_body_whitespace =
+    body_preserves_whitespace(old_element->tag_name, new_element->tag_name, preserve_whitespace);
+
   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);
   }
@@ -72,7 +89,7 @@ static void diff_conditional_element_node(
   }
 
   if (old_element->body != NULL && new_element->body != NULL) {
-    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, result);
+    herb_diff_children(old_element->body, new_element->body, path, old_hashes, new_hashes, preserve_body_whitespace, result);
   }
 }
 
@@ -82,10 +99,11 @@ static void diff_children_nullable(
   const herb_diff_path_T path,
   const herb_hash_map_T* old_hashes,
   const herb_hash_map_T* new_hashes,
+  const bool preserve_whitespace,
   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);
+    herb_diff_children(old_children, new_children, path, old_hashes, new_hashes, preserve_whitespace, 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);
@@ -105,6 +123,7 @@ void herb_diff_node(
   const herb_diff_path_T path,
   const herb_hash_map_T* old_hashes,
   const herb_hash_map_T* new_hashes,
+  const bool preserve_whitespace,
   herb_diff_result_T* result
 ) {
   if (old_node == NULL && new_node == NULL) { return; }
@@ -136,7 +155,7 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_document_node->children, new_document_node->children, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_document_node->children, new_document_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -167,7 +186,7 @@ void herb_diff_node(
 
 
 
-      herb_diff_node((const AST_NODE_T*) old_html_conditional_open_tag_node->conditional, (const AST_NODE_T*) new_html_conditional_open_tag_node->conditional, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_html_conditional_open_tag_node->conditional, (const AST_NODE_T*) new_html_conditional_open_tag_node->conditional, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_HTML_CLOSE_TAG_NODE: {
@@ -180,7 +199,7 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_html_close_tag_node->children, new_html_close_tag_node->children, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_html_close_tag_node->children, new_html_close_tag_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -196,7 +215,7 @@ void herb_diff_node(
       diff_element_node(
         (const AST_HTML_ELEMENT_NODE_T*) old_node,
         (const AST_HTML_ELEMENT_NODE_T*) new_node,
-        path, old_hashes, new_hashes, result
+        path, old_hashes, new_hashes, preserve_whitespace, result
       );
     } break;
 
@@ -204,7 +223,7 @@ void herb_diff_node(
       diff_conditional_element_node(
         (const AST_HTML_CONDITIONAL_ELEMENT_NODE_T*) old_node,
         (const AST_HTML_CONDITIONAL_ELEMENT_NODE_T*) new_node,
-        path, old_hashes, new_hashes, result
+        path, old_hashes, new_hashes, preserve_whitespace, result
       );
     } break;
 
@@ -214,7 +233,7 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_html_attribute_value_node->children, new_html_attribute_value_node->children, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_html_attribute_value_node->children, new_html_attribute_value_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -224,7 +243,7 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_html_attribute_name_node->children, new_html_attribute_name_node->children, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_html_attribute_name_node->children, new_html_attribute_name_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -285,21 +304,24 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_open_tag_node->children, new_erb_open_tag_node->children, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_open_tag_node->children, new_erb_open_tag_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
     case AST_HTML_TEXT_NODE: {
-      const AST_HTML_TEXT_NODE_T* old_html_text_node = (const AST_HTML_TEXT_NODE_T*) old_node;
-      const AST_HTML_TEXT_NODE_T* new_html_text_node = (const AST_HTML_TEXT_NODE_T*) new_node;
-
+      const AST_HTML_TEXT_NODE_T* old_text_node = (const AST_HTML_TEXT_NODE_T*) old_node;
+      const AST_HTML_TEXT_NODE_T* new_text_node = (const AST_HTML_TEXT_NODE_T*) new_node;
 
-      if (!hb_string_equals(old_html_text_node->content, new_html_text_node->content)) {
+      if (preserve_whitespace) {
+        if (!hb_string_equals(old_text_node->content, new_text_node->content)) {
+          herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+        }
+      } else if (!hb_string_equals_collapsing_whitespace(old_text_node->content, new_text_node->content)) {
         herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      } else if (result->options.track_whitespace_changes
+                 && !hb_string_equals(old_text_node->content, new_text_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_WHITESPACE_CHANGED, path, old_node, new_node, 0, 0);
       }
-
-
-
     } break;
 
     case AST_HTML_COMMENT_NODE: {
@@ -308,7 +330,7 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_html_comment_node->children, new_html_comment_node->children, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_html_comment_node->children, new_html_comment_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -322,7 +344,7 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_html_doctype_node->children, new_html_doctype_node->children, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_html_doctype_node->children, new_html_doctype_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -336,7 +358,21 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_xml_declaration_node->children, new_xml_declaration_node->children, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_xml_declaration_node->children, new_xml_declaration_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
+
+    } break;
+
+    case AST_XML_PROCESSING_INSTRUCTION_NODE: {
+      const AST_XML_PROCESSING_INSTRUCTION_NODE_T* old_xml_processing_instruction_node = (const AST_XML_PROCESSING_INSTRUCTION_NODE_T*) old_node;
+      const AST_XML_PROCESSING_INSTRUCTION_NODE_T* new_xml_processing_instruction_node = (const AST_XML_PROCESSING_INSTRUCTION_NODE_T*) new_node;
+
+      if (!tokens_equal(old_xml_processing_instruction_node->tag_opening, new_xml_processing_instruction_node->tag_opening)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_xml_processing_instruction_node->children, new_xml_processing_instruction_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -350,7 +386,7 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_cdata_node->children, new_cdata_node->children, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_cdata_node->children, new_cdata_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -397,7 +433,7 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_else_node->statements, new_erb_else_node->statements, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_else_node->statements, new_erb_else_node->statements, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -412,10 +448,10 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_if_node->statements, new_erb_if_node->statements, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_if_node->statements, new_erb_if_node->statements, path, old_hashes, new_hashes, preserve_whitespace, result);
 
-      herb_diff_node((const AST_NODE_T*) old_erb_if_node->subsequent, (const AST_NODE_T*) new_erb_if_node->subsequent, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_if_node->end_node, (const AST_NODE_T*) new_erb_if_node->end_node, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_if_node->subsequent, (const AST_NODE_T*) new_erb_if_node->subsequent, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_if_node->end_node, (const AST_NODE_T*) new_erb_if_node->end_node, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_ERB_BLOCK_NODE: {
@@ -429,13 +465,34 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_block_node->body, new_erb_block_node->body, path, old_hashes, new_hashes, result);
-      diff_children_nullable(old_erb_block_node->block_arguments, new_erb_block_node->block_arguments, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_block_node->body, new_erb_block_node->body, path, old_hashes, new_hashes, preserve_whitespace, result);
+      diff_children_nullable(old_erb_block_node->block_arguments, new_erb_block_node->block_arguments, path, old_hashes, new_hashes, preserve_whitespace, result);
+
+      herb_diff_node((const AST_NODE_T*) old_erb_block_node->rescue_clause, (const AST_NODE_T*) new_erb_block_node->rescue_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_block_node->else_clause, (const AST_NODE_T*) new_erb_block_node->else_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_block_node->ensure_clause, (const AST_NODE_T*) new_erb_block_node->ensure_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_block_node->end_node, (const AST_NODE_T*) new_erb_block_node->end_node, path, old_hashes, new_hashes, preserve_whitespace, result);
+    } break;
+
+    case AST_ERB_ITERATION_BLOCK_NODE: {
+      const AST_ERB_ITERATION_BLOCK_NODE_T* old_erb_iteration_block_node = (const AST_ERB_ITERATION_BLOCK_NODE_T*) old_node;
+      const AST_ERB_ITERATION_BLOCK_NODE_T* new_erb_iteration_block_node = (const AST_ERB_ITERATION_BLOCK_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_iteration_block_node->tag_opening, new_erb_iteration_block_node->tag_opening)
+          || !tokens_equal(old_erb_iteration_block_node->content, new_erb_iteration_block_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_erb_iteration_block_node->arguments, new_erb_iteration_block_node->arguments, path, old_hashes, new_hashes, preserve_whitespace, result);
+      diff_children_nullable(old_erb_iteration_block_node->body, new_erb_iteration_block_node->body, path, old_hashes, new_hashes, preserve_whitespace, result);
+      diff_children_nullable(old_erb_iteration_block_node->block_arguments, new_erb_iteration_block_node->block_arguments, path, old_hashes, new_hashes, preserve_whitespace, result);
 
-      herb_diff_node((const AST_NODE_T*) old_erb_block_node->rescue_clause, (const AST_NODE_T*) new_erb_block_node->rescue_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_block_node->else_clause, (const AST_NODE_T*) new_erb_block_node->else_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_block_node->ensure_clause, (const AST_NODE_T*) new_erb_block_node->ensure_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_block_node->end_node, (const AST_NODE_T*) new_erb_block_node->end_node, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_iteration_block_node->rescue_clause, (const AST_NODE_T*) new_erb_iteration_block_node->rescue_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_iteration_block_node->else_clause, (const AST_NODE_T*) new_erb_iteration_block_node->else_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_iteration_block_node->ensure_clause, (const AST_NODE_T*) new_erb_iteration_block_node->ensure_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_iteration_block_node->end_node, (const AST_NODE_T*) new_erb_iteration_block_node->end_node, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_ERB_WHEN_NODE: {
@@ -449,7 +506,7 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_when_node->statements, new_erb_when_node->statements, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_when_node->statements, new_erb_when_node->statements, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -464,11 +521,11 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_case_node->children, new_erb_case_node->children, path, old_hashes, new_hashes, result);
-      diff_children_nullable(old_erb_case_node->conditions, new_erb_case_node->conditions, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_case_node->children, new_erb_case_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
+      diff_children_nullable(old_erb_case_node->conditions, new_erb_case_node->conditions, path, old_hashes, new_hashes, preserve_whitespace, result);
 
-      herb_diff_node((const AST_NODE_T*) old_erb_case_node->else_clause, (const AST_NODE_T*) new_erb_case_node->else_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_case_node->end_node, (const AST_NODE_T*) new_erb_case_node->end_node, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_case_node->else_clause, (const AST_NODE_T*) new_erb_case_node->else_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_case_node->end_node, (const AST_NODE_T*) new_erb_case_node->end_node, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_ERB_CASE_MATCH_NODE: {
@@ -482,11 +539,11 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_case_match_node->children, new_erb_case_match_node->children, path, old_hashes, new_hashes, result);
-      diff_children_nullable(old_erb_case_match_node->conditions, new_erb_case_match_node->conditions, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_case_match_node->children, new_erb_case_match_node->children, path, old_hashes, new_hashes, preserve_whitespace, result);
+      diff_children_nullable(old_erb_case_match_node->conditions, new_erb_case_match_node->conditions, path, old_hashes, new_hashes, preserve_whitespace, result);
 
-      herb_diff_node((const AST_NODE_T*) old_erb_case_match_node->else_clause, (const AST_NODE_T*) new_erb_case_match_node->else_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_case_match_node->end_node, (const AST_NODE_T*) new_erb_case_match_node->end_node, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_case_match_node->else_clause, (const AST_NODE_T*) new_erb_case_match_node->else_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_case_match_node->end_node, (const AST_NODE_T*) new_erb_case_match_node->end_node, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_ERB_WHILE_NODE: {
@@ -500,9 +557,9 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_while_node->statements, new_erb_while_node->statements, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_while_node->statements, new_erb_while_node->statements, path, old_hashes, new_hashes, preserve_whitespace, result);
 
-      herb_diff_node((const AST_NODE_T*) old_erb_while_node->end_node, (const AST_NODE_T*) new_erb_while_node->end_node, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_while_node->end_node, (const AST_NODE_T*) new_erb_while_node->end_node, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_ERB_UNTIL_NODE: {
@@ -516,9 +573,9 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_until_node->statements, new_erb_until_node->statements, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_until_node->statements, new_erb_until_node->statements, path, old_hashes, new_hashes, preserve_whitespace, result);
 
-      herb_diff_node((const AST_NODE_T*) old_erb_until_node->end_node, (const AST_NODE_T*) new_erb_until_node->end_node, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_until_node->end_node, (const AST_NODE_T*) new_erb_until_node->end_node, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_ERB_FOR_NODE: {
@@ -532,9 +589,9 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_for_node->statements, new_erb_for_node->statements, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_for_node->statements, new_erb_for_node->statements, path, old_hashes, new_hashes, preserve_whitespace, result);
 
-      herb_diff_node((const AST_NODE_T*) old_erb_for_node->end_node, (const AST_NODE_T*) new_erb_for_node->end_node, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_for_node->end_node, (const AST_NODE_T*) new_erb_for_node->end_node, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_ERB_RESCUE_NODE: {
@@ -548,9 +605,9 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_rescue_node->statements, new_erb_rescue_node->statements, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_rescue_node->statements, new_erb_rescue_node->statements, path, old_hashes, new_hashes, preserve_whitespace, result);
 
-      herb_diff_node((const AST_NODE_T*) old_erb_rescue_node->subsequent, (const AST_NODE_T*) new_erb_rescue_node->subsequent, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_rescue_node->subsequent, (const AST_NODE_T*) new_erb_rescue_node->subsequent, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_ERB_ENSURE_NODE: {
@@ -564,7 +621,7 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_ensure_node->statements, new_erb_ensure_node->statements, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_ensure_node->statements, new_erb_ensure_node->statements, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -579,12 +636,12 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_begin_node->statements, new_erb_begin_node->statements, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_begin_node->statements, new_erb_begin_node->statements, path, old_hashes, new_hashes, preserve_whitespace, result);
 
-      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->rescue_clause, (const AST_NODE_T*) new_erb_begin_node->rescue_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->else_clause, (const AST_NODE_T*) new_erb_begin_node->else_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->ensure_clause, (const AST_NODE_T*) new_erb_begin_node->ensure_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->end_node, (const AST_NODE_T*) new_erb_begin_node->end_node, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->rescue_clause, (const AST_NODE_T*) new_erb_begin_node->rescue_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->else_clause, (const AST_NODE_T*) new_erb_begin_node->else_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->ensure_clause, (const AST_NODE_T*) new_erb_begin_node->ensure_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_begin_node->end_node, (const AST_NODE_T*) new_erb_begin_node->end_node, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_ERB_UNLESS_NODE: {
@@ -598,10 +655,10 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_unless_node->statements, new_erb_unless_node->statements, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_unless_node->statements, new_erb_unless_node->statements, path, old_hashes, new_hashes, preserve_whitespace, result);
 
-      herb_diff_node((const AST_NODE_T*) old_erb_unless_node->else_clause, (const AST_NODE_T*) new_erb_unless_node->else_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_unless_node->end_node, (const AST_NODE_T*) new_erb_unless_node->end_node, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_unless_node->else_clause, (const AST_NODE_T*) new_erb_unless_node->else_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_unless_node->end_node, (const AST_NODE_T*) new_erb_unless_node->end_node, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_RUBY_RENDER_LOCAL_NODE: {
@@ -611,7 +668,7 @@ void herb_diff_node(
 
 
 
-      herb_diff_node((const AST_NODE_T*) old_ruby_render_local_node->value, (const AST_NODE_T*) new_ruby_render_local_node->value, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_ruby_render_local_node->value, (const AST_NODE_T*) new_ruby_render_local_node->value, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_RUBY_RENDER_KEYWORDS_NODE: {
@@ -620,7 +677,8 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_ruby_render_keywords_node->locals, new_ruby_render_keywords_node->locals, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_ruby_render_keywords_node->locals, new_ruby_render_keywords_node->locals, path, old_hashes, new_hashes, preserve_whitespace, result);
+      diff_children_nullable(old_ruby_render_keywords_node->state, new_ruby_render_keywords_node->state, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -635,14 +693,14 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_render_node->body, new_erb_render_node->body, path, old_hashes, new_hashes, result);
-      diff_children_nullable(old_erb_render_node->block_arguments, new_erb_render_node->block_arguments, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_render_node->body, new_erb_render_node->body, path, old_hashes, new_hashes, preserve_whitespace, result);
+      diff_children_nullable(old_erb_render_node->block_arguments, new_erb_render_node->block_arguments, path, old_hashes, new_hashes, preserve_whitespace, result);
 
-      herb_diff_node((const AST_NODE_T*) old_erb_render_node->keywords, (const AST_NODE_T*) new_erb_render_node->keywords, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_render_node->rescue_clause, (const AST_NODE_T*) new_erb_render_node->rescue_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_render_node->else_clause, (const AST_NODE_T*) new_erb_render_node->else_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_render_node->ensure_clause, (const AST_NODE_T*) new_erb_render_node->ensure_clause, path, old_hashes, new_hashes, result);
-      herb_diff_node((const AST_NODE_T*) old_erb_render_node->end_node, (const AST_NODE_T*) new_erb_render_node->end_node, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_render_node->keywords, (const AST_NODE_T*) new_erb_render_node->keywords, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_render_node->rescue_clause, (const AST_NODE_T*) new_erb_render_node->rescue_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_render_node->else_clause, (const AST_NODE_T*) new_erb_render_node->else_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_render_node->ensure_clause, (const AST_NODE_T*) new_erb_render_node->ensure_clause, path, old_hashes, new_hashes, preserve_whitespace, result);
+      herb_diff_node((const AST_NODE_T*) old_erb_render_node->end_node, (const AST_NODE_T*) new_erb_render_node->end_node, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_RUBY_PARAMETER_NODE: {
@@ -656,7 +714,7 @@ void herb_diff_node(
 
 
 
-      herb_diff_node((const AST_NODE_T*) old_ruby_parameter_node->default_value, (const AST_NODE_T*) new_ruby_parameter_node->default_value, path, old_hashes, new_hashes, result);
+      herb_diff_node((const AST_NODE_T*) old_ruby_parameter_node->default_value, (const AST_NODE_T*) new_ruby_parameter_node->default_value, path, old_hashes, new_hashes, preserve_whitespace, result);
     } break;
 
     case AST_ERB_STRICT_LOCALS_NODE: {
@@ -670,7 +728,7 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_strict_locals_node->locals, new_erb_strict_locals_node->locals, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_strict_locals_node->locals, new_erb_strict_locals_node->locals, path, old_hashes, new_hashes, preserve_whitespace, result);
 
     } break;
 
@@ -699,7 +757,64 @@ void herb_diff_node(
 
 
 
-      diff_children_nullable(old_erb_in_node->statements, new_erb_in_node->statements, path, old_hashes, new_hashes, result);
+      diff_children_nullable(old_erb_in_node->statements, new_erb_in_node->statements, path, old_hashes, new_hashes, preserve_whitespace, result);
+
+    } break;
+
+    case AST_HERB_DIRECTIVE_NODE: {
+      const AST_HERB_DIRECTIVE_NODE_T* old_herb_directive_node = (const AST_HERB_DIRECTIVE_NODE_T*) old_node;
+      const AST_HERB_DIRECTIVE_NODE_T* new_herb_directive_node = (const AST_HERB_DIRECTIVE_NODE_T*) new_node;
+
+      if (!tokens_equal(old_herb_directive_node->tag_opening, new_herb_directive_node->tag_opening)
+          || !tokens_equal(old_herb_directive_node->content, new_herb_directive_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+
+    } break;
+
+    case AST_HERB_STATE_DECLARATION_NODE: {
+      const AST_HERB_STATE_DECLARATION_NODE_T* old_herb_state_declaration_node = (const AST_HERB_STATE_DECLARATION_NODE_T*) old_node;
+      const AST_HERB_STATE_DECLARATION_NODE_T* new_herb_state_declaration_node = (const AST_HERB_STATE_DECLARATION_NODE_T*) new_node;
+
+
+      if (!hb_string_equals(old_herb_state_declaration_node->kind, new_herb_state_declaration_node->kind)) {
+        herb_diff_emit_operation(result, HERB_DIFF_TEXT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      herb_diff_node((const AST_NODE_T*) old_herb_state_declaration_node->default_value, (const AST_NODE_T*) new_herb_state_declaration_node->default_value, path, old_hashes, new_hashes, preserve_whitespace, result);
+    } break;
+
+    case AST_HERB_STATE_DIRECTIVE_NODE: {
+      const AST_HERB_STATE_DIRECTIVE_NODE_T* old_herb_state_directive_node = (const AST_HERB_STATE_DIRECTIVE_NODE_T*) old_node;
+      const AST_HERB_STATE_DIRECTIVE_NODE_T* new_herb_state_directive_node = (const AST_HERB_STATE_DIRECTIVE_NODE_T*) new_node;
+
+      if (!tokens_equal(old_herb_state_directive_node->tag_opening, new_herb_state_directive_node->tag_opening)
+          || !tokens_equal(old_herb_state_directive_node->content, new_herb_state_directive_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
+      diff_children_nullable(old_herb_state_directive_node->states, new_herb_state_directive_node->states, path, old_hashes, new_hashes, preserve_whitespace, result);
+
+    } break;
+
+    case AST_ERB_COMMENT_NODE: {
+      const AST_ERB_COMMENT_NODE_T* old_erb_comment_node = (const AST_ERB_COMMENT_NODE_T*) old_node;
+      const AST_ERB_COMMENT_NODE_T* new_erb_comment_node = (const AST_ERB_COMMENT_NODE_T*) new_node;
+
+      if (!tokens_equal(old_erb_comment_node->tag_opening, new_erb_comment_node->tag_opening)
+          || !tokens_equal(old_erb_comment_node->content, new_erb_comment_node->content)) {
+        herb_diff_emit_operation(result, HERB_DIFF_ERB_CONTENT_CHANGED, path, old_node, new_node, 0, 0);
+      }
+
+
+
 
     } break;