@herb-tools/node 0.7.5 → 0.8.1

package/extension/libherb/parser.h

@@ -1,9 +1,9 @@
 #ifndef HERB_PARSER_H
 #define HERB_PARSER_H
 
-#include "array.h"
 #include "ast_node.h"
 #include "lexer.h"
+#include "util/hb_array.h"
 
 typedef enum {
   FOREIGN_CONTENT_UNKNOWN = 0,
@@ -19,21 +19,27 @@ typedef struct PARSER_OPTIONS_STRUCT {
   bool track_whitespace;
 } parser_options_T;
 
+extern const parser_options_T HERB_DEFAULT_PARSER_OPTIONS;
+
 typedef struct PARSER_STRUCT {
   lexer_T* lexer;
   token_T* current_token;
-  array_T* open_tags_stack;
+  hb_array_T* open_tags_stack;
   parser_state_T state;
   foreign_content_type_T foreign_content_type;
-  parser_options_T* options;
+  parser_options_T options;
 } parser_T;
 
-parser_T* herb_parser_init(lexer_T* lexer, parser_options_T* options);
+size_t parser_sizeof(void);
+
+void herb_parser_init(parser_T* parser, lexer_T* lexer, parser_options_T options);
 
 AST_DOCUMENT_NODE_T* herb_parser_parse(parser_T* parser);
 
-size_t parser_sizeof(void);
+void herb_parser_match_html_tags_post_analyze(AST_DOCUMENT_NODE_T* document);
+void herb_parser_deinit(parser_T* parser);
 
-void parser_free(parser_T* parser);
+void match_tags_in_node_array(hb_array_T* nodes, hb_array_T* errors);
+bool match_tags_visitor(const AST_NODE_T* node, void* data);
 
 #endif

package/extension/libherb/parser_helpers.c

@@ -1,36 +1,36 @@
 #include "include/parser_helpers.h"
-#include "include/array.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
-#include "include/buffer.h"
 #include "include/errors.h"
 #include "include/html_util.h"
 #include "include/lexer.h"
 #include "include/parser.h"
 #include "include/token.h"
 #include "include/token_matchers.h"
+#include "include/util/hb_array.h"
+#include "include/util/hb_buffer.h"
+#include "include/util/hb_string.h"
 
 #include <stdio.h>
-#include <strings.h>
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name) {
   token_T* copy = token_copy(tag_name);
-  array_push(parser->open_tags_stack, copy);
+  hb_array_push(parser->open_tags_stack, copy);
 }
 
-bool parser_check_matching_tag(const parser_T* parser, const char* tag_name) {
-  if (array_size(parser->open_tags_stack) == 0) { return false; }
+bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
+  if (hb_array_size(parser->open_tags_stack) == 0) { return false; }
 
-  token_T* top_token = array_last(parser->open_tags_stack);
+  token_T* top_token = hb_array_last(parser->open_tags_stack);
   if (top_token == NULL || top_token->value == NULL) { return false; };
 
-  return (strcasecmp(top_token->value, tag_name) == 0);
+  return hb_string_equals(hb_string(top_token->value), tag_name);
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
-  if (array_size(parser->open_tags_stack) == 0) { return NULL; }
+  if (hb_array_size(parser->open_tags_stack) == 0) { return NULL; }
 
-  return array_pop(parser->open_tags_stack);
+  return hb_array_pop(parser->open_tags_stack);
 }
 
 /**
@@ -42,13 +42,14 @@ token_T* parser_pop_open_tag(const parser_T* parser) {
 bool parser_in_svg_context(const parser_T* parser) {
   if (!parser || !parser->open_tags_stack) { return false; }
 
-  size_t stack_size = array_size(parser->open_tags_stack);
+  size_t stack_size = hb_array_size(parser->open_tags_stack);
 
   for (size_t i = 0; i < stack_size; i++) {
-    token_T* tag = (token_T*) array_get(parser->open_tags_stack, i);
+    token_T* tag = (token_T*) hb_array_get(parser->open_tags_stack, i);
 
     if (tag && tag->value) {
-      if (strcasecmp(tag->value, "svg") == 0) { return true; }
+      hb_string_T tag_value_string = hb_string(tag->value);
+      if (hb_string_equals(tag_value_string, hb_string("svg"))) { return true; }
     }
   }
 
@@ -57,24 +58,24 @@ bool parser_in_svg_context(const parser_T* parser) {
 
 // ===== Foreign Content Handling =====
 
-foreign_content_type_T parser_get_foreign_content_type(const char* tag_name) {
-  if (tag_name == NULL) { return FOREIGN_CONTENT_UNKNOWN; }
+foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name) {
+  if (hb_string_is_empty(tag_name)) { return FOREIGN_CONTENT_UNKNOWN; }
 
-  if (strcasecmp(tag_name, "script") == 0) { return FOREIGN_CONTENT_SCRIPT; }
-  if (strcasecmp(tag_name, "style") == 0) { return FOREIGN_CONTENT_STYLE; }
+  if (hb_string_equals(tag_name, hb_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
+  if (hb_string_equals(tag_name, hb_string("style"))) { return FOREIGN_CONTENT_STYLE; }
 
   return FOREIGN_CONTENT_UNKNOWN;
 }
 
-bool parser_is_foreign_content_tag(const char* tag_name) {
+bool parser_is_foreign_content_tag(hb_string_T tag_name) {
   return parser_get_foreign_content_type(tag_name) != FOREIGN_CONTENT_UNKNOWN;
 }
 
-const char* parser_get_foreign_content_closing_tag(foreign_content_type_T type) {
+hb_string_T parser_get_foreign_content_closing_tag(foreign_content_type_T type) {
   switch (type) {
-    case FOREIGN_CONTENT_SCRIPT: return "script";
-    case FOREIGN_CONTENT_STYLE: return "style";
-    default: return NULL;
+    case FOREIGN_CONTENT_SCRIPT: return hb_string("script");
+    case FOREIGN_CONTENT_STYLE: return hb_string("style");
+    default: return hb_string("");
   }
 }
 
@@ -92,7 +93,12 @@ void parser_exit_foreign_content(parser_T* parser) {
   parser->foreign_content_type = FOREIGN_CONTENT_UNKNOWN;
 }
 
-void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors) {
+void parser_append_unexpected_error(
+  parser_T* parser,
+  const char* description,
+  const char* expected,
+  hb_array_T* errors
+) {
   token_T* token = parser_advance(parser);
 
   append_unexpected_error(
@@ -107,7 +113,7 @@ void parser_append_unexpected_error(parser_T* parser, const char* description, c
   token_free(token);
 }
 
-void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors) {
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors) {
   append_unexpected_token_error(
     expected_type,
     parser->current_token,
@@ -119,17 +125,17 @@ void parser_append_unexpected_token_error(parser_T* parser, token_type_T expecte
 
 void parser_append_literal_node_from_buffer(
   const parser_T* parser,
-  buffer_T* buffer,
-  array_T* children,
+  hb_buffer_T* buffer,
+  hb_array_T* children,
   position_T start
 ) {
-  if (buffer_length(buffer) == 0) { return; }
+  if (hb_buffer_length(buffer) == 0) { return; }
 
   AST_LITERAL_NODE_T* literal =
-    ast_literal_node_init(buffer_value(buffer), start, parser->current_token->location.start, NULL);
+    ast_literal_node_init(hb_buffer_value(buffer), start, parser->current_token->location.start, NULL);
 
-  if (children != NULL) { array_append(children, literal); }
-  buffer_clear(buffer);
+  if (children != NULL) { hb_array_append(children, literal); }
+  hb_buffer_clear(buffer);
 }
 
 token_T* parser_advance(parser_T* parser) {
@@ -143,7 +149,7 @@ token_T* parser_consume_if_present(parser_T* parser, const token_type_T type) {
   return parser_advance(parser);
 }
 
-token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_type, array_T* array) {
+token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_type, hb_array_T* array) {
   token_T* token = parser_consume_if_present(parser, expected_type);
 
   if (token == NULL) {
@@ -157,8 +163,8 @@ token_T* parser_consume_expected(parser_T* parser, const token_type_T expected_t
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
-  array_T* body,
-  array_T* errors
+  hb_array_T* body,
+  hb_array_T* errors
 ) {
   append_missing_closing_tag_error(
     open_tag->tag_name,
@@ -183,10 +189,10 @@ AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
 void parser_handle_mismatched_tags(
   const parser_T* parser,
   const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
-  array_T* errors
+  hb_array_T* errors
 ) {
-  if (array_size(parser->open_tags_stack) > 0) {
-    token_T* expected_tag = array_last(parser->open_tags_stack);
+  if (hb_array_size(parser->open_tags_stack) > 0) {
+    token_T* expected_tag = hb_array_last(parser->open_tags_stack);
     token_T* actual_tag = close_tag->tag_name;
 
     append_tag_names_mismatch_error(
@@ -206,10 +212,10 @@ void parser_handle_mismatched_tags(
   }
 }
 
-bool parser_is_expected_closing_tag_name(const char* tag_name, foreign_content_type_T expected_type) {
-  const char* expected_tag_name = parser_get_foreign_content_closing_tag(expected_type);
+bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_type_T expected_type) {
+  hb_string_T expected_tag_name = parser_get_foreign_content_closing_tag(expected_type);
 
-  if (expected_tag_name == NULL || tag_name == NULL) { return false; }
+  if (hb_string_is_empty(tag_name) || hb_string_is_empty(expected_tag_name)) { return false; }
 
-  return strcmp(tag_name, expected_tag_name) == 0;
+  return hb_string_equals(expected_tag_name, tag_name);
 }

package/extension/libherb/parser_helpers.h

@@ -1,47 +1,57 @@
 #ifndef HERB_PARSER_HELPERS_H
 #define HERB_PARSER_HELPERS_H
 
-#include "array.h"
 #include "ast_nodes.h"
-#include "buffer.h"
 #include "errors.h"
 #include "parser.h"
 #include "token.h"
+#include "util/hb_array.h"
+#include "util/hb_buffer.h"
+#include "util/hb_string.h"
 
 void parser_push_open_tag(const parser_T* parser, token_T* tag_name);
-bool parser_check_matching_tag(const parser_T* parser, const char* tag_name);
+bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name);
 token_T* parser_pop_open_tag(const parser_T* parser);
 
-void parser_append_unexpected_error(parser_T* parser, const char* description, const char* expected, array_T* errors);
-void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, array_T* errors);
+void parser_append_unexpected_error(
+  parser_T* parser,
+  const char* description,
+  const char* expected,
+  hb_array_T* errors
+);
+void parser_append_unexpected_token_error(parser_T* parser, token_type_T expected_type, hb_array_T* errors);
 
 void parser_append_literal_node_from_buffer(
   const parser_T* parser,
-  buffer_T* buffer,
-  array_T* children,
+  hb_buffer_T* buffer,
+  hb_array_T* children,
   position_T start
 );
 
 bool parser_in_svg_context(const parser_T* parser);
 
-foreign_content_type_T parser_get_foreign_content_type(const char* tag_name);
-bool parser_is_foreign_content_tag(const char* tag_name);
-const char* parser_get_foreign_content_closing_tag(foreign_content_type_T type);
+foreign_content_type_T parser_get_foreign_content_type(hb_string_T tag_name);
+bool parser_is_foreign_content_tag(hb_string_T tag_name);
+hb_string_T parser_get_foreign_content_closing_tag(foreign_content_type_T type);
 
 void parser_enter_foreign_content(parser_T* parser, foreign_content_type_T type);
 void parser_exit_foreign_content(parser_T* parser);
 
-bool parser_is_expected_closing_tag_name(const char* tag_name, foreign_content_type_T expected_type);
+bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_type_T expected_type);
 
 token_T* parser_advance(parser_T* parser);
 token_T* parser_consume_if_present(parser_T* parser, token_type_T type);
-token_T* parser_consume_expected(parser_T* parser, token_type_T type, array_T* array);
+token_T* parser_consume_expected(parser_T* parser, token_type_T type, hb_array_T* array);
 
 AST_HTML_ELEMENT_NODE_T* parser_handle_missing_close_tag(
   AST_HTML_OPEN_TAG_NODE_T* open_tag,
-  array_T* body,
-  array_T* errors
+  hb_array_T* body,
+  hb_array_T* errors
+);
+void parser_handle_mismatched_tags(
+  const parser_T* parser,
+  const AST_HTML_CLOSE_TAG_NODE_T* close_tag,
+  hb_array_T* errors
 );
-void parser_handle_mismatched_tags(const parser_T* parser, const AST_HTML_CLOSE_TAG_NODE_T* close_tag, array_T* errors);
 
 #endif

package/extension/libherb/parser_match_tags.c

@@ -0,0 +1,316 @@
+// NOTE: This file is generated by the templates/template.rb script and should not
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.1/templates/src/parser_match_tags.c.erb
+
+#include "include/parser.h"
+#include "include/ast_nodes.h"
+#include "include/util/hb_array.h"
+#include "include/visitor.h"
+
+bool match_tags_visitor(const AST_NODE_T* node, void* data) {
+  hb_array_T* errors = (hb_array_T*) data;
+
+  if (node == NULL) { return false; }
+
+  switch (node->type) {
+
+    case AST_DOCUMENT_NODE: {
+      const AST_DOCUMENT_NODE_T* document_node = (const AST_DOCUMENT_NODE_T*) node;
+
+      if (document_node->children != NULL) {
+        match_tags_in_node_array(document_node->children, errors);
+      }
+    } break;
+
+
+
+    case AST_HTML_OPEN_TAG_NODE: {
+      const AST_HTML_OPEN_TAG_NODE_T* html_open_tag_node = (const AST_HTML_OPEN_TAG_NODE_T*) node;
+
+      if (html_open_tag_node->children != NULL) {
+        match_tags_in_node_array(html_open_tag_node->children, errors);
+      }
+    } break;
+
+
+    case AST_HTML_CLOSE_TAG_NODE: {
+      const AST_HTML_CLOSE_TAG_NODE_T* html_close_tag_node = (const AST_HTML_CLOSE_TAG_NODE_T*) node;
+
+      if (html_close_tag_node->children != NULL) {
+        match_tags_in_node_array(html_close_tag_node->children, errors);
+      }
+    } break;
+
+
+    case AST_HTML_ELEMENT_NODE: {
+      const AST_HTML_ELEMENT_NODE_T* html_element_node = (const AST_HTML_ELEMENT_NODE_T*) node;
+
+      if (html_element_node->body != NULL) {
+        match_tags_in_node_array(html_element_node->body, errors);
+      }
+      if (html_element_node->open_tag != NULL) {
+        herb_visit_node((AST_NODE_T*) html_element_node->open_tag, match_tags_visitor, errors);
+      }
+      if (html_element_node->close_tag != NULL) {
+        herb_visit_node((AST_NODE_T*) html_element_node->close_tag, match_tags_visitor, errors);
+      }
+    } break;
+
+
+    case AST_HTML_ATTRIBUTE_VALUE_NODE: {
+      const AST_HTML_ATTRIBUTE_VALUE_NODE_T* html_attribute_value_node = (const AST_HTML_ATTRIBUTE_VALUE_NODE_T*) node;
+
+      if (html_attribute_value_node->children != NULL) {
+        match_tags_in_node_array(html_attribute_value_node->children, errors);
+      }
+    } break;
+
+
+    case AST_HTML_ATTRIBUTE_NAME_NODE: {
+      const AST_HTML_ATTRIBUTE_NAME_NODE_T* html_attribute_name_node = (const AST_HTML_ATTRIBUTE_NAME_NODE_T*) node;
+
+      if (html_attribute_name_node->children != NULL) {
+        match_tags_in_node_array(html_attribute_name_node->children, errors);
+      }
+    } break;
+
+
+    case AST_HTML_ATTRIBUTE_NODE: {
+      const AST_HTML_ATTRIBUTE_NODE_T* html_attribute_node = (const AST_HTML_ATTRIBUTE_NODE_T*) node;
+
+      if (html_attribute_node->name != NULL) {
+        herb_visit_node((AST_NODE_T*) html_attribute_node->name, match_tags_visitor, errors);
+      }
+      if (html_attribute_node->value != NULL) {
+        herb_visit_node((AST_NODE_T*) html_attribute_node->value, match_tags_visitor, errors);
+      }
+    } break;
+
+
+
+    case AST_HTML_COMMENT_NODE: {
+      const AST_HTML_COMMENT_NODE_T* html_comment_node = (const AST_HTML_COMMENT_NODE_T*) node;
+
+      if (html_comment_node->children != NULL) {
+        match_tags_in_node_array(html_comment_node->children, errors);
+      }
+    } break;
+
+
+    case AST_HTML_DOCTYPE_NODE: {
+      const AST_HTML_DOCTYPE_NODE_T* html_doctype_node = (const AST_HTML_DOCTYPE_NODE_T*) node;
+
+      if (html_doctype_node->children != NULL) {
+        match_tags_in_node_array(html_doctype_node->children, errors);
+      }
+    } break;
+
+
+    case AST_XML_DECLARATION_NODE: {
+      const AST_XML_DECLARATION_NODE_T* xml_declaration_node = (const AST_XML_DECLARATION_NODE_T*) node;
+
+      if (xml_declaration_node->children != NULL) {
+        match_tags_in_node_array(xml_declaration_node->children, errors);
+      }
+    } break;
+
+
+    case AST_CDATA_NODE: {
+      const AST_CDATA_NODE_T* cdata_node = (const AST_CDATA_NODE_T*) node;
+
+      if (cdata_node->children != NULL) {
+        match_tags_in_node_array(cdata_node->children, errors);
+      }
+    } break;
+
+
+
+
+
+    case AST_ERB_ELSE_NODE: {
+      const AST_ERB_ELSE_NODE_T* erb_else_node = (const AST_ERB_ELSE_NODE_T*) node;
+
+      if (erb_else_node->statements != NULL) {
+        match_tags_in_node_array(erb_else_node->statements, errors);
+      }
+    } break;
+
+
+    case AST_ERB_IF_NODE: {
+      const AST_ERB_IF_NODE_T* erb_if_node = (const AST_ERB_IF_NODE_T*) node;
+
+      if (erb_if_node->statements != NULL) {
+        match_tags_in_node_array(erb_if_node->statements, errors);
+      }
+      if (erb_if_node->subsequent != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_if_node->subsequent, match_tags_visitor, errors);
+      }
+      if (erb_if_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_if_node->end_node, match_tags_visitor, errors);
+      }
+    } break;
+
+
+    case AST_ERB_BLOCK_NODE: {
+      const AST_ERB_BLOCK_NODE_T* erb_block_node = (const AST_ERB_BLOCK_NODE_T*) node;
+
+      if (erb_block_node->body != NULL) {
+        match_tags_in_node_array(erb_block_node->body, errors);
+      }
+      if (erb_block_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_block_node->end_node, match_tags_visitor, errors);
+      }
+    } break;
+
+
+    case AST_ERB_WHEN_NODE: {
+      const AST_ERB_WHEN_NODE_T* erb_when_node = (const AST_ERB_WHEN_NODE_T*) node;
+
+      if (erb_when_node->statements != NULL) {
+        match_tags_in_node_array(erb_when_node->statements, errors);
+      }
+    } break;
+
+
+    case AST_ERB_CASE_NODE: {
+      const AST_ERB_CASE_NODE_T* erb_case_node = (const AST_ERB_CASE_NODE_T*) node;
+
+      if (erb_case_node->children != NULL) {
+        match_tags_in_node_array(erb_case_node->children, errors);
+      }
+      if (erb_case_node->conditions != NULL) {
+        match_tags_in_node_array(erb_case_node->conditions, errors);
+      }
+      if (erb_case_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_case_node->else_clause, match_tags_visitor, errors);
+      }
+      if (erb_case_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_case_node->end_node, match_tags_visitor, errors);
+      }
+    } break;
+
+
+    case AST_ERB_CASE_MATCH_NODE: {
+      const AST_ERB_CASE_MATCH_NODE_T* erb_case_match_node = (const AST_ERB_CASE_MATCH_NODE_T*) node;
+
+      if (erb_case_match_node->children != NULL) {
+        match_tags_in_node_array(erb_case_match_node->children, errors);
+      }
+      if (erb_case_match_node->conditions != NULL) {
+        match_tags_in_node_array(erb_case_match_node->conditions, errors);
+      }
+      if (erb_case_match_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_case_match_node->else_clause, match_tags_visitor, errors);
+      }
+      if (erb_case_match_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_case_match_node->end_node, match_tags_visitor, errors);
+      }
+    } break;
+
+
+    case AST_ERB_WHILE_NODE: {
+      const AST_ERB_WHILE_NODE_T* erb_while_node = (const AST_ERB_WHILE_NODE_T*) node;
+
+      if (erb_while_node->statements != NULL) {
+        match_tags_in_node_array(erb_while_node->statements, errors);
+      }
+      if (erb_while_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_while_node->end_node, match_tags_visitor, errors);
+      }
+    } break;
+
+
+    case AST_ERB_UNTIL_NODE: {
+      const AST_ERB_UNTIL_NODE_T* erb_until_node = (const AST_ERB_UNTIL_NODE_T*) node;
+
+      if (erb_until_node->statements != NULL) {
+        match_tags_in_node_array(erb_until_node->statements, errors);
+      }
+      if (erb_until_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_until_node->end_node, match_tags_visitor, errors);
+      }
+    } break;
+
+
+    case AST_ERB_FOR_NODE: {
+      const AST_ERB_FOR_NODE_T* erb_for_node = (const AST_ERB_FOR_NODE_T*) node;
+
+      if (erb_for_node->statements != NULL) {
+        match_tags_in_node_array(erb_for_node->statements, errors);
+      }
+      if (erb_for_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_for_node->end_node, match_tags_visitor, errors);
+      }
+    } break;
+
+
+    case AST_ERB_RESCUE_NODE: {
+      const AST_ERB_RESCUE_NODE_T* erb_rescue_node = (const AST_ERB_RESCUE_NODE_T*) node;
+
+      if (erb_rescue_node->statements != NULL) {
+        match_tags_in_node_array(erb_rescue_node->statements, errors);
+      }
+      if (erb_rescue_node->subsequent != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_rescue_node->subsequent, match_tags_visitor, errors);
+      }
+    } break;
+
+
+    case AST_ERB_ENSURE_NODE: {
+      const AST_ERB_ENSURE_NODE_T* erb_ensure_node = (const AST_ERB_ENSURE_NODE_T*) node;
+
+      if (erb_ensure_node->statements != NULL) {
+        match_tags_in_node_array(erb_ensure_node->statements, errors);
+      }
+    } break;
+
+
+    case AST_ERB_BEGIN_NODE: {
+      const AST_ERB_BEGIN_NODE_T* erb_begin_node = (const AST_ERB_BEGIN_NODE_T*) node;
+
+      if (erb_begin_node->statements != NULL) {
+        match_tags_in_node_array(erb_begin_node->statements, errors);
+      }
+      if (erb_begin_node->rescue_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_begin_node->rescue_clause, match_tags_visitor, errors);
+      }
+      if (erb_begin_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_begin_node->else_clause, match_tags_visitor, errors);
+      }
+      if (erb_begin_node->ensure_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_begin_node->ensure_clause, match_tags_visitor, errors);
+      }
+      if (erb_begin_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_begin_node->end_node, match_tags_visitor, errors);
+      }
+    } break;
+
+
+    case AST_ERB_UNLESS_NODE: {
+      const AST_ERB_UNLESS_NODE_T* erb_unless_node = (const AST_ERB_UNLESS_NODE_T*) node;
+
+      if (erb_unless_node->statements != NULL) {
+        match_tags_in_node_array(erb_unless_node->statements, errors);
+      }
+      if (erb_unless_node->else_clause != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_unless_node->else_clause, match_tags_visitor, errors);
+      }
+      if (erb_unless_node->end_node != NULL) {
+        herb_visit_node((AST_NODE_T*) erb_unless_node->end_node, match_tags_visitor, errors);
+      }
+    } break;
+
+
+
+    case AST_ERB_IN_NODE: {
+      const AST_ERB_IN_NODE_T* erb_in_node = (const AST_ERB_IN_NODE_T*) node;
+
+      if (erb_in_node->statements != NULL) {
+        match_tags_in_node_array(erb_in_node->statements, errors);
+      }
+    } break;
+
+    default: break;
+  }
+
+  return false;
+}