@herb-tools/node 0.8.4 → 0.8.5

package/dist/herb-node.esm.js

@@ -6,7 +6,7 @@ import { createRequire } from 'module';
 import { fileURLToPath } from 'url';
 
 var name = "@herb-tools/node";
-var version = "0.8.4";
+var version = "0.8.5";
 var packageJSON = {
 	name: name,
 	version: version};

package/extension/error_helpers.cpp

@@ -1,5 +1,5 @@
 // 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.4/templates/javascript/packages/node/extension/error_helpers.cpp.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/javascript/packages/node/extension/error_helpers.cpp.erb
 
 #include <node_api.h>
 #include "error_helpers.h"
@@ -331,6 +331,29 @@ napi_value MissingERBEndTagErrorFromCStruct(napi_env env, MISSINGERB_END_TAG_ERR
   return result;
 }
 
+napi_value ERBMultipleBlocksInTagErrorFromCStruct(napi_env env, ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error) {
+  if (!erb_multiple_blocks_in_tag_error) {
+    napi_value null_value;
+    napi_get_null(env, &null_value);
+    return null_value;
+  }
+
+  napi_value result;
+  napi_create_object(env, &result);
+
+  napi_value type = CreateString(env, error_type_to_string(&erb_multiple_blocks_in_tag_error->base));
+  napi_set_named_property(env, result, "type", type);
+
+  napi_value message = CreateString(env, erb_multiple_blocks_in_tag_error->base.message);
+  napi_set_named_property(env, result, "message", message);
+
+  napi_value location = CreateLocation(env, erb_multiple_blocks_in_tag_error->base.location);
+  napi_set_named_property(env, result, "location", location);
+
+
+  return result;
+}
+
 
 napi_value ErrorsArrayFromCArray(napi_env env, hb_array_T* array) {
   napi_value result;
@@ -390,6 +413,9 @@ napi_value ErrorFromCStruct(napi_env env, ERROR_T* error) {
     case MISSINGERB_END_TAG_ERROR:
       return MissingERBEndTagErrorFromCStruct(env, (MISSINGERB_END_TAG_ERROR_T*) error);
       break;
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR:
+      return ERBMultipleBlocksInTagErrorFromCStruct(env, (ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error);
+      break;
     default:
       napi_value null_value;
       napi_get_null(env, &null_value);

package/extension/error_helpers.h

@@ -1,5 +1,5 @@
 // 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.4/templates/javascript/packages/node/extension/error_helpers.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/javascript/packages/node/extension/error_helpers.h.erb
 
 #ifndef HERB_EXTENSION_ERRORS_H
 #define HERB_EXTENSION_ERRORS_H
@@ -24,5 +24,6 @@ napi_value UnclosedElementErrorFromCStruct(napi_env env, UNCLOSED_ELEMENT_ERROR_
 napi_value RubyParseErrorFromCStruct(napi_env env, RUBY_PARSE_ERROR_T* ruby_parse_error);
 napi_value ERBControlFlowScopeErrorFromCStruct(napi_env env, ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error);
 napi_value MissingERBEndTagErrorFromCStruct(napi_env env, MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error);
+napi_value ERBMultipleBlocksInTagErrorFromCStruct(napi_env env, ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error);
 
 #endif

package/extension/libherb/analyze.c

@@ -45,6 +45,8 @@ static analyzed_ruby_T* herb_analyze_ruby(hb_string_T source) {
   search_yield_nodes(analyzed->root, analyzed);
   search_block_closing_nodes(analyzed);
 
+  if (!analyzed->valid) { pm_visit_node(analyzed->root, search_unclosed_control_flows, analyzed); }
+
   return analyzed;
 }
 
@@ -54,12 +56,21 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
 
     const char* opening = erb_content_node->tag_opening->value;
 
-    if (strcmp(opening, "<%%") != 0 && strcmp(opening, "<%%=") != 0 && strcmp(opening, "<%#") != 0) {
+    if (strcmp(opening, "<%%") != 0 && strcmp(opening, "<%%=") != 0 && strcmp(opening, "<%#") != 0
+        && strcmp(opening, "<%graphql") != 0) {
       analyzed_ruby_T* analyzed = herb_analyze_ruby(hb_string(erb_content_node->content->value));
 
       erb_content_node->parsed = true;
       erb_content_node->valid = analyzed->valid;
       erb_content_node->analyzed_ruby = analyzed;
+
+      if (!analyzed->valid && analyzed->unclosed_control_flow_count >= 2) {
+        append_erb_multiple_blocks_in_tag_error(
+          erb_content_node->base.location.start,
+          erb_content_node->base.location.end,
+          erb_content_node->base.errors
+        );
+      }
     } else {
       erb_content_node->parsed = false;
       erb_content_node->valid = true;

package/extension/libherb/analyze_helpers.c

@@ -5,75 +5,75 @@
 #include "include/analyzed_ruby.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_if_node;
+  return analyzed->if_node_count > 0;
 }
 
 bool has_elsif_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_elsif_node;
+  return analyzed->elsif_node_count > 0;
 }
 
 bool has_else_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_else_node;
+  return analyzed->else_node_count > 0;
 }
 
 bool has_end(analyzed_ruby_T* analyzed) {
-  return analyzed->has_end;
+  return analyzed->end_count > 0;
 }
 
 bool has_block_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_block_node;
+  return analyzed->block_node_count > 0;
 }
 
 bool has_block_closing(analyzed_ruby_T* analyzed) {
-  return analyzed->has_block_closing;
+  return analyzed->block_closing_count > 0;
 }
 
 bool has_case_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_case_node;
+  return analyzed->case_node_count > 0;
 }
 
 bool has_case_match_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_case_match_node;
+  return analyzed->case_match_node_count > 0;
 }
 
 bool has_when_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_when_node;
+  return analyzed->when_node_count > 0;
 }
 
 bool has_in_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_in_node;
+  return analyzed->in_node_count > 0;
 }
 
 bool has_for_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_for_node;
+  return analyzed->for_node_count > 0;
 }
 
 bool has_while_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_while_node;
+  return analyzed->while_node_count > 0;
 }
 
 bool has_until_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_until_node;
+  return analyzed->until_node_count > 0;
 }
 
 bool has_begin_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_begin_node;
+  return analyzed->begin_node_count > 0;
 }
 
 bool has_rescue_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_rescue_node;
+  return analyzed->rescue_node_count > 0;
 }
 
 bool has_ensure_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_ensure_node;
+  return analyzed->ensure_node_count > 0;
 }
 
 bool has_unless_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_unless_node;
+  return analyzed->unless_node_count > 0;
 }
 
 bool has_yield_node(analyzed_ruby_T* analyzed) {
-  return analyzed->has_yield_node;
+  return analyzed->yield_node_count > 0;
 }
 
 bool has_error_message(analyzed_ruby_T* anlayzed, const char* message) {
@@ -94,11 +94,7 @@ bool search_if_nodes(const pm_node_t* node, void* data) {
     bool has_if_keyword = if_node->if_keyword_loc.start != NULL && if_node->if_keyword_loc.end != NULL;
     bool has_end_keyword = if_node->end_keyword_loc.start != NULL && if_node->end_keyword_loc.end != NULL;
 
-    if (has_if_keyword && has_end_keyword) {
-      analyzed->has_if_node = true;
-
-      return true;
-    }
+    if (has_if_keyword && has_end_keyword) { analyzed->if_node_count++; }
   }
 
   pm_visit_child_nodes(node, search_if_nodes, analyzed);
@@ -106,20 +102,32 @@ bool search_if_nodes(const pm_node_t* node, void* data) {
   return false;
 }
 
+static bool is_do_block(pm_location_t opening_location) {
+  size_t length = opening_location.end - opening_location.start;
+
+  return length == 2 && opening_location.start[0] == 'd' && opening_location.start[1] == 'o';
+}
+
+static bool is_brace_block(pm_location_t opening_location) {
+  size_t length = opening_location.end - opening_location.start;
+
+  return length == 1 && opening_location.start[0] == '{';
+}
+
+static bool has_location(pm_location_t location) {
+  return location.start != NULL && location.end != NULL && (location.end - location.start) > 0;
+}
+
 bool search_block_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
   if (node->type == PM_BLOCK_NODE) {
     pm_block_node_t* block_node = (pm_block_node_t*) node;
 
-    size_t opening_length = block_node->opening_loc.end - block_node->opening_loc.start;
+    bool has_opening = is_do_block(block_node->opening_loc) || is_brace_block(block_node->opening_loc);
+    bool is_unclosed = !has_location(block_node->closing_loc);
 
-    if ((opening_length == 2 && block_node->opening_loc.start[0] == 'd' && block_node->opening_loc.start[1] == 'o')
-        || (opening_length == 1 && block_node->opening_loc.start[0] == '{')) {
-      analyzed->has_block_node = true;
-
-      return true;
-    }
+    if (has_opening && is_unclosed) { analyzed->block_node_count++; }
   }
 
   pm_visit_child_nodes(node, search_block_nodes, analyzed);
@@ -130,12 +138,9 @@ bool search_block_nodes(const pm_node_t* node, void* data) {
 bool search_case_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
-  if (node->type == PM_CASE_NODE) {
-    analyzed->has_case_node = true;
-    return true;
-  } else {
-    pm_visit_child_nodes(node, search_case_nodes, analyzed);
-  }
+  if (node->type == PM_CASE_NODE) { analyzed->case_node_count++; }
+
+  pm_visit_child_nodes(node, search_case_nodes, analyzed);
 
   return false;
 }
@@ -143,12 +148,9 @@ bool search_case_nodes(const pm_node_t* node, void* data) {
 bool search_case_match_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
-  if (node->type == PM_CASE_MATCH_NODE) {
-    analyzed->has_case_match_node = true;
-    return true;
-  } else {
-    pm_visit_child_nodes(node, search_case_match_nodes, analyzed);
-  }
+  if (node->type == PM_CASE_MATCH_NODE) { analyzed->case_match_node_count++; }
+
+  pm_visit_child_nodes(node, search_case_match_nodes, analyzed);
 
   return false;
 }
@@ -156,12 +158,9 @@ bool search_case_match_nodes(const pm_node_t* node, void* data) {
 bool search_while_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
-  if (node->type == PM_WHILE_NODE) {
-    analyzed->has_while_node = true;
-    return true;
-  } else {
-    pm_visit_child_nodes(node, search_while_nodes, analyzed);
-  }
+  if (node->type == PM_WHILE_NODE) { analyzed->while_node_count++; }
+
+  pm_visit_child_nodes(node, search_while_nodes, analyzed);
 
   return false;
 }
@@ -169,12 +168,9 @@ bool search_while_nodes(const pm_node_t* node, void* data) {
 bool search_for_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
-  if (node->type == PM_FOR_NODE) {
-    analyzed->has_for_node = true;
-    return true;
-  } else {
-    pm_visit_child_nodes(node, search_for_nodes, analyzed);
-  }
+  if (node->type == PM_FOR_NODE) { analyzed->for_node_count++; }
+
+  pm_visit_child_nodes(node, search_for_nodes, analyzed);
 
   return false;
 }
@@ -182,12 +178,9 @@ bool search_for_nodes(const pm_node_t* node, void* data) {
 bool search_until_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
-  if (node->type == PM_UNTIL_NODE) {
-    analyzed->has_until_node = true;
-    return true;
-  } else {
-    pm_visit_child_nodes(node, search_until_nodes, analyzed);
-  }
+  if (node->type == PM_UNTIL_NODE) { analyzed->until_node_count++; }
+
+  pm_visit_child_nodes(node, search_until_nodes, analyzed);
 
   return false;
 }
@@ -195,12 +188,9 @@ bool search_until_nodes(const pm_node_t* node, void* data) {
 bool search_begin_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
-  if (node->type == PM_BEGIN_NODE) {
-    analyzed->has_begin_node = true;
-    return true;
-  } else {
-    pm_visit_child_nodes(node, search_begin_nodes, analyzed);
-  }
+  if (node->type == PM_BEGIN_NODE) { analyzed->begin_node_count++; }
+
+  pm_visit_child_nodes(node, search_begin_nodes, analyzed);
 
   return false;
 }
@@ -214,11 +204,7 @@ bool search_unless_nodes(const pm_node_t* node, void* data) {
     bool has_if_keyword = unless_node->keyword_loc.start != NULL && unless_node->keyword_loc.end != NULL;
     bool has_end_keyword = unless_node->end_keyword_loc.start != NULL && unless_node->end_keyword_loc.end != NULL;
 
-    if (has_if_keyword && has_end_keyword) {
-      analyzed->has_unless_node = true;
-
-      return true;
-    }
+    if (has_if_keyword && has_end_keyword) { analyzed->unless_node_count++; }
   }
 
   pm_visit_child_nodes(node, search_unless_nodes, analyzed);
@@ -228,7 +214,7 @@ bool search_unless_nodes(const pm_node_t* node, void* data) {
 
 bool search_elsif_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'elsif', ignoring it")) {
-    analyzed->has_elsif_node = true;
+    analyzed->elsif_node_count++;
     return true;
   }
 
@@ -237,7 +223,7 @@ bool search_elsif_nodes(analyzed_ruby_T* analyzed) {
 
 bool search_else_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'else', ignoring it")) {
-    analyzed->has_else_node = true;
+    analyzed->else_node_count++;
     return true;
   }
 
@@ -251,7 +237,7 @@ bool search_end_nodes(analyzed_ruby_T* analyzed) {
       return false;
     }
 
-    analyzed->has_end = true;
+    analyzed->end_count++;
     return true;
   }
 
@@ -260,7 +246,7 @@ bool search_end_nodes(analyzed_ruby_T* analyzed) {
 
 bool search_block_closing_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected '}', ignoring it")) {
-    analyzed->has_block_closing = true;
+    analyzed->block_closing_count++;
     return true;
   }
 
@@ -269,7 +255,7 @@ bool search_block_closing_nodes(analyzed_ruby_T* analyzed) {
 
 bool search_when_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'when', ignoring it")) {
-    analyzed->has_when_node = true;
+    analyzed->when_node_count++;
     return true;
   }
 
@@ -278,7 +264,7 @@ bool search_when_nodes(analyzed_ruby_T* analyzed) {
 
 bool search_in_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'in', ignoring it")) {
-    analyzed->has_in_node = true;
+    analyzed->in_node_count++;
     return true;
   }
 
@@ -287,7 +273,7 @@ bool search_in_nodes(analyzed_ruby_T* analyzed) {
 
 bool search_rescue_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'rescue', ignoring it")) {
-    analyzed->has_rescue_node = true;
+    analyzed->rescue_node_count++;
     return true;
   }
 
@@ -296,7 +282,7 @@ bool search_rescue_nodes(analyzed_ruby_T* analyzed) {
 
 bool search_ensure_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'ensure', ignoring it")) {
-    analyzed->has_ensure_node = true;
+    analyzed->ensure_node_count++;
     return true;
   }
 
@@ -306,12 +292,121 @@ bool search_ensure_nodes(analyzed_ruby_T* analyzed) {
 bool search_yield_nodes(const pm_node_t* node, void* data) {
   analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
 
-  if (node->type == PM_YIELD_NODE) {
-    analyzed->has_yield_node = true;
-    return true;
-  } else {
-    pm_visit_child_nodes(node, search_yield_nodes, analyzed);
+  if (node->type == PM_YIELD_NODE) { analyzed->yield_node_count++; }
+
+  pm_visit_child_nodes(node, search_yield_nodes, analyzed);
+
+  return false;
+}
+
+static bool is_postfix_conditional(const pm_statements_node_t* statements, pm_location_t keyword_location) {
+  if (statements == NULL) { return false; }
+
+  return statements->base.location.start < keyword_location.start;
+}
+
+bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (analyzed->unclosed_control_flow_count >= 2) { return false; }
+
+  switch (node->type) {
+    case PM_IF_NODE: {
+      const pm_if_node_t* if_node = (const pm_if_node_t*) node;
+
+      if (has_location(if_node->if_keyword_loc) && !has_location(if_node->end_keyword_loc)) {
+        if (!is_postfix_conditional(if_node->statements, if_node->if_keyword_loc)) {
+          analyzed->unclosed_control_flow_count++;
+        }
+      }
+
+      break;
+    }
+
+    case PM_UNLESS_NODE: {
+      const pm_unless_node_t* unless_node = (const pm_unless_node_t*) node;
+
+      if (has_location(unless_node->keyword_loc) && !has_location(unless_node->end_keyword_loc)) {
+        if (!is_postfix_conditional(unless_node->statements, unless_node->keyword_loc)) {
+          analyzed->unclosed_control_flow_count++;
+        }
+      }
+
+      break;
+    }
+
+    case PM_CASE_NODE: {
+      const pm_case_node_t* case_node = (const pm_case_node_t*) node;
+
+      if (has_location(case_node->case_keyword_loc) && !has_location(case_node->end_keyword_loc)) {
+        analyzed->unclosed_control_flow_count++;
+      }
+
+      break;
+    }
+
+    case PM_CASE_MATCH_NODE: {
+      const pm_case_match_node_t* case_match_node = (const pm_case_match_node_t*) node;
+
+      if (has_location(case_match_node->case_keyword_loc) && !has_location(case_match_node->end_keyword_loc)) {
+        analyzed->unclosed_control_flow_count++;
+      }
+
+      break;
+    }
+
+    case PM_WHILE_NODE: {
+      const pm_while_node_t* while_node = (const pm_while_node_t*) node;
+
+      if (has_location(while_node->keyword_loc) && !has_location(while_node->closing_loc)) {
+        analyzed->unclosed_control_flow_count++;
+      }
+
+      break;
+    }
+
+    case PM_UNTIL_NODE: {
+      const pm_until_node_t* until_node = (const pm_until_node_t*) node;
+
+      if (has_location(until_node->keyword_loc) && !has_location(until_node->closing_loc)) {
+        analyzed->unclosed_control_flow_count++;
+      }
+
+      break;
+    }
+
+    case PM_FOR_NODE: {
+      const pm_for_node_t* for_node = (const pm_for_node_t*) node;
+
+      if (has_location(for_node->for_keyword_loc) && !has_location(for_node->end_keyword_loc)) {
+        analyzed->unclosed_control_flow_count++;
+      }
+
+      break;
+    }
+
+    case PM_BEGIN_NODE: {
+      const pm_begin_node_t* begin_node = (const pm_begin_node_t*) node;
+
+      if (has_location(begin_node->begin_keyword_loc) && !has_location(begin_node->end_keyword_loc)) {
+        analyzed->unclosed_control_flow_count++;
+      }
+
+      break;
+    }
+
+    case PM_BLOCK_NODE: {
+      const pm_block_node_t* block_node = (const pm_block_node_t*) node;
+      bool has_opening = is_do_block(block_node->opening_loc) || is_brace_block(block_node->opening_loc);
+
+      if (has_opening && !has_location(block_node->closing_loc)) { analyzed->unclosed_control_flow_count++; }
+      break;
+    }
+
+    default: break;
   }
 
+  pm_visit_child_nodes(node, search_unclosed_control_flows, analyzed);
+
   return false;
 }

package/extension/libherb/analyze_helpers.h

@@ -46,6 +46,7 @@ bool search_in_nodes(analyzed_ruby_T* analyzed);
 bool search_rescue_nodes(analyzed_ruby_T* analyzed);
 bool search_ensure_nodes(analyzed_ruby_T* analyzed);
 bool search_yield_nodes(const pm_node_t* node, void* data);
+bool search_unclosed_control_flows(const pm_node_t* node, void* data);
 
 void check_erb_node_for_missing_end(const AST_NODE_T* node);
 

package/extension/libherb/analyze_missing_end.c

@@ -1,5 +1,5 @@
 // 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.4/templates/src/analyze_missing_end.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/analyze_missing_end.c.erb
 
 #include "include/analyze_helpers.h"
 #include "include/errors.h"

package/extension/libherb/analyze_transform.c

@@ -1,5 +1,5 @@
 // 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.4/templates/src/analyze_transform.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/analyze_transform.c.erb
 
 #include "include/analyze.h"
 #include "include/visitor.h"

package/extension/libherb/analyzed_ruby.c

@@ -12,24 +12,25 @@ analyzed_ruby_T* init_analyzed_ruby(hb_string_T source) {
   analyzed->root = pm_parse(&analyzed->parser);
   analyzed->valid = (analyzed->parser.error_list.size == 0);
   analyzed->parsed = true;
-  analyzed->has_if_node = false;
-  analyzed->has_elsif_node = false;
-  analyzed->has_else_node = false;
-  analyzed->has_end = false;
-  analyzed->has_block_node = false;
-  analyzed->has_block_closing = false;
-  analyzed->has_case_node = false;
-  analyzed->has_case_match_node = false;
-  analyzed->has_when_node = false;
-  analyzed->has_in_node = false;
-  analyzed->has_for_node = false;
-  analyzed->has_while_node = false;
-  analyzed->has_until_node = false;
-  analyzed->has_begin_node = false;
-  analyzed->has_rescue_node = false;
-  analyzed->has_ensure_node = false;
-  analyzed->has_unless_node = false;
-  analyzed->has_yield_node = false;
+  analyzed->if_node_count = 0;
+  analyzed->elsif_node_count = 0;
+  analyzed->else_node_count = 0;
+  analyzed->end_count = 0;
+  analyzed->block_node_count = 0;
+  analyzed->block_closing_count = 0;
+  analyzed->case_node_count = 0;
+  analyzed->case_match_node_count = 0;
+  analyzed->when_node_count = 0;
+  analyzed->in_node_count = 0;
+  analyzed->for_node_count = 0;
+  analyzed->while_node_count = 0;
+  analyzed->until_node_count = 0;
+  analyzed->begin_node_count = 0;
+  analyzed->rescue_node_count = 0;
+  analyzed->ensure_node_count = 0;
+  analyzed->unless_node_count = 0;
+  analyzed->yield_node_count = 0;
+  analyzed->unclosed_control_flow_count = 0;
 
   return analyzed;
 }
@@ -45,19 +46,19 @@ void free_analyzed_ruby(analyzed_ruby_T* analyzed) {
 }
 
 const char* erb_keyword_from_analyzed_ruby(const analyzed_ruby_T* analyzed) {
-  if (analyzed->has_end) {
+  if (analyzed->end_count > 0) {
     return "`<% end %>`";
-  } else if (analyzed->has_else_node) {
+  } else if (analyzed->else_node_count > 0) {
     return "`<% else %>`";
-  } else if (analyzed->has_elsif_node) {
+  } else if (analyzed->elsif_node_count > 0) {
     return "`<% elsif %>`";
-  } else if (analyzed->has_when_node) {
+  } else if (analyzed->when_node_count > 0) {
     return "`<% when %>`";
-  } else if (analyzed->has_in_node) {
+  } else if (analyzed->in_node_count > 0) {
     return "`<% in %>`";
-  } else if (analyzed->has_rescue_node) {
+  } else if (analyzed->rescue_node_count > 0) {
     return "`<% rescue %>`";
-  } else if (analyzed->has_ensure_node) {
+  } else if (analyzed->ensure_node_count > 0) {
     return "`<% ensure %>`";
   }
 

package/extension/libherb/analyzed_ruby.h

@@ -11,24 +11,25 @@ typedef struct ANALYZED_RUBY_STRUCT {
   pm_node_t* root;
   bool valid;
   bool parsed;
-  bool has_if_node;
-  bool has_elsif_node;
-  bool has_else_node;
-  bool has_end;
-  bool has_block_closing;
-  bool has_block_node;
-  bool has_case_node;
-  bool has_case_match_node;
-  bool has_when_node;
-  bool has_in_node;
-  bool has_for_node;
-  bool has_while_node;
-  bool has_until_node;
-  bool has_begin_node;
-  bool has_rescue_node;
-  bool has_ensure_node;
-  bool has_unless_node;
-  bool has_yield_node;
+  int if_node_count;
+  int elsif_node_count;
+  int else_node_count;
+  int end_count;
+  int block_closing_count;
+  int block_node_count;
+  int case_node_count;
+  int case_match_node_count;
+  int when_node_count;
+  int in_node_count;
+  int for_node_count;
+  int while_node_count;
+  int until_node_count;
+  int begin_node_count;
+  int rescue_node_count;
+  int ensure_node_count;
+  int unless_node_count;
+  int yield_node_count;
+  int unclosed_control_flow_count;
 } analyzed_ruby_T;
 
 analyzed_ruby_T* init_analyzed_ruby(hb_string_T source);

package/extension/libherb/ast_nodes.c

@@ -1,5 +1,5 @@
 // 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.4/templates/src/ast_nodes.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/ast_nodes.c.erb
 
 #include <stdio.h>
 #include <stdbool.h>

package/extension/libherb/ast_nodes.h

@@ -1,5 +1,5 @@
 // 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.4/templates/src/include/ast_nodes.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/include/ast_nodes.h.erb
 
 #ifndef HERB_AST_NODES_H
 #define HERB_AST_NODES_H

package/extension/libherb/ast_pretty_print.c

@@ -1,6 +1,7 @@
 // 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.4/templates/src/ast_pretty_print.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/ast_pretty_print.c.erb
 
+#include "include/analyze_helpers.h"
 #include "include/ast_node.h"
 #include "include/ast_nodes.h"
 #include "include/errors.h"
@@ -214,21 +215,21 @@ void ast_pretty_print_node(AST_NODE_T* node, const size_t indent, const size_t r
       pretty_print_token_property(erb_content_node->content, hb_string("content"), indent, relative_indent, false, buffer);
       pretty_print_token_property(erb_content_node->tag_closing, hb_string("tag_closing"), indent, relative_indent, false, buffer);
       if (erb_content_node->analyzed_ruby) {
-        pretty_print_boolean_property(hb_string("if_node"), erb_content_node->analyzed_ruby->has_if_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("elsif_node"), erb_content_node->analyzed_ruby->has_elsif_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("else_node"), erb_content_node->analyzed_ruby->has_else_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("end"), erb_content_node->analyzed_ruby->has_end, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("block_node"), erb_content_node->analyzed_ruby->has_block_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("block_closing"), erb_content_node->analyzed_ruby->has_block_closing, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("case_node"), erb_content_node->analyzed_ruby->has_case_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("when_node"), erb_content_node->analyzed_ruby->has_when_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("for_node"), erb_content_node->analyzed_ruby->has_for_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("while_node"), erb_content_node->analyzed_ruby->has_while_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("until_node"), erb_content_node->analyzed_ruby->has_until_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("begin_node"), erb_content_node->analyzed_ruby->has_begin_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("rescue_node"), erb_content_node->analyzed_ruby->has_rescue_node, indent, relative_indent, false, buffer);
-        pretty_print_boolean_property(hb_string("ensure_node"), erb_content_node->analyzed_ruby->has_ensure_node, indent, relative_indent,  false, buffer);
-        pretty_print_boolean_property(hb_string("unless_node"), erb_content_node->analyzed_ruby->has_unless_node, indent, relative_indent,  false, buffer);
+        pretty_print_boolean_property(hb_string("if_node"), has_if_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("elsif_node"), has_elsif_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("else_node"), has_else_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("end"), has_end(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_node"), has_block_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("block_closing"), has_block_closing(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("case_node"), has_case_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("when_node"), has_when_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("for_node"), has_for_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("while_node"), has_while_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("until_node"), has_until_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("begin_node"), has_begin_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("rescue_node"), has_rescue_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("ensure_node"), has_ensure_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
+        pretty_print_boolean_property(hb_string("unless_node"), has_unless_node(erb_content_node->analyzed_ruby), indent, relative_indent, false, buffer);
       } else {
       pretty_print_label(hb_string("analyzed_ruby"), indent, relative_indent, false, buffer);
         hb_buffer_append(buffer, " ∅\n");

package/extension/libherb/ast_pretty_print.h

@@ -1,5 +1,5 @@
 // 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.4/templates/src/include/ast_pretty_print.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/include/ast_pretty_print.h.erb
 
 #ifndef HERB_AST_PRETTY_PRINT_H
 #define HERB_AST_PRETTY_PRINT_H

package/extension/libherb/errors.c

@@ -1,5 +1,5 @@
 // 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.4/templates/src/errors.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/errors.c.erb
 
 #include "include/errors.h"
 #include "include/location.h"
@@ -497,6 +497,20 @@ void append_missingerb_end_tag_error(const char* keyword, position_T start, posi
   hb_array_append(errors, missingerb_end_tag_error_init(keyword, start, end));
 }
 
+ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(position_T start, position_T end) {
+  ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error = malloc(sizeof(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T));
+
+  error_init(&erb_multiple_blocks_in_tag_error->base, ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR, start, end);
+
+  erb_multiple_blocks_in_tag_error->base.message = herb_strdup("Multiple unclosed control flow blocks in a single ERB tag. Split each block into its own ERB tag, or close all blocks within the same tag.");
+
+  return erb_multiple_blocks_in_tag_error;
+}
+
+void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, erb_multiple_blocks_in_tag_error_init(start, end));
+}
+
 const char* error_type_to_string(ERROR_T* error) {
   switch (error->type) {
     case UNEXPECTED_ERROR: return "UNEXPECTED_ERROR";
@@ -510,6 +524,7 @@ const char* error_type_to_string(ERROR_T* error) {
     case RUBY_PARSE_ERROR: return "RUBY_PARSE_ERROR";
     case ERB_CONTROL_FLOW_SCOPE_ERROR: return "ERB_CONTROL_FLOW_SCOPE_ERROR";
     case MISSINGERB_END_TAG_ERROR: return "MISSINGERB_END_TAG_ERROR";
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return "ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR";
   }
 
   return "Unknown error_type_T";
@@ -528,6 +543,7 @@ const char* error_human_type(ERROR_T* error) {
     case RUBY_PARSE_ERROR: return "RubyParseError";
     case ERB_CONTROL_FLOW_SCOPE_ERROR: return "ERBControlFlowScopeError";
     case MISSINGERB_END_TAG_ERROR: return "MissingERBEndTagError";
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return "ERBMultipleBlocksInTagError";
   }
 
   return "Unknown error_type_T";
@@ -616,6 +632,12 @@ static void error_free_missingerb_end_tag_error(MISSINGERB_END_TAG_ERROR_T* miss
   error_free_base_error(&missingerb_end_tag_error->base);
 }
 
+static void error_free_erb_multiple_blocks_in_tag_error(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error) {
+  /* no ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T specific fields to free up */
+
+  error_free_base_error(&erb_multiple_blocks_in_tag_error->base);
+}
+
 void error_free(ERROR_T* error) {
   if (!error) { return; }
 
@@ -631,6 +653,7 @@ void error_free(ERROR_T* error) {
     case RUBY_PARSE_ERROR: error_free_ruby_parse_error((RUBY_PARSE_ERROR_T*) error); break;
     case ERB_CONTROL_FLOW_SCOPE_ERROR: error_free_erb_control_flow_scope_error((ERB_CONTROL_FLOW_SCOPE_ERROR_T*) error); break;
     case MISSINGERB_END_TAG_ERROR: error_free_missingerb_end_tag_error((MISSINGERB_END_TAG_ERROR_T*) error); break;
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: error_free_erb_multiple_blocks_in_tag_error((ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error); break;
   }
 }
 
@@ -841,6 +864,19 @@ static void error_pretty_print_missingerb_end_tag_error(MISSINGERB_END_TAG_ERROR
   pretty_print_quoted_property(hb_string("keyword"), hb_string(error->keyword), indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_erb_multiple_blocks_in_tag_error(ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
+  if (!error) { return; }
+
+  hb_buffer_append(buffer, "@ ");
+  hb_buffer_append(buffer, error_human_type((ERROR_T*) error));
+  hb_buffer_append(buffer, " ");
+
+  pretty_print_location(error->base.location, buffer);
+  hb_buffer_append(buffer, "\n");
+
+  pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, true, buffer);
+}
+
 void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relative_indent, hb_buffer_T* buffer) {
   if (!error) { return; }
 
@@ -856,5 +892,6 @@ void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relati
     case RUBY_PARSE_ERROR: error_pretty_print_ruby_parse_error((RUBY_PARSE_ERROR_T*) error, indent, relative_indent, buffer); break;
     case ERB_CONTROL_FLOW_SCOPE_ERROR: error_pretty_print_erb_control_flow_scope_error((ERB_CONTROL_FLOW_SCOPE_ERROR_T*) error, indent, relative_indent, buffer); break;
     case MISSINGERB_END_TAG_ERROR: error_pretty_print_missingerb_end_tag_error((MISSINGERB_END_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: error_pretty_print_erb_multiple_blocks_in_tag_error((ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error, indent, relative_indent, buffer); break;
   }
 }

package/extension/libherb/errors.h

@@ -1,5 +1,5 @@
 // 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.4/templates/src/include/errors.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/include/errors.h.erb
 
 #ifndef HERB_ERRORS_H
 #define HERB_ERRORS_H
@@ -23,6 +23,7 @@ typedef enum {
   RUBY_PARSE_ERROR,
   ERB_CONTROL_FLOW_SCOPE_ERROR,
   MISSINGERB_END_TAG_ERROR,
+  ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR,
 } error_type_T;
 
 typedef struct ERROR_STRUCT {
@@ -96,6 +97,11 @@ typedef struct {
   const char* keyword;
 } MISSINGERB_END_TAG_ERROR_T;
 
+typedef struct {
+  ERROR_T base;
+  /* no additional fields */
+} ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T;
+
 UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* expected, const char* found, position_T start, position_T end);
 void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors);
 UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end);
@@ -118,6 +124,8 @@ ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(const char* ke
 void append_erb_control_flow_scope_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
 MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error_init(const char* keyword, position_T start, position_T end);
 void append_missingerb_end_tag_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
+ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(position_T start, position_T end);
+void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_array_T* errors);
 
 void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 

package/extension/libherb/extract.c

@@ -25,7 +25,8 @@ void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output) {
         if (strcmp(token->value, "<%#") == 0) {
           skip_erb_content = true;
           is_comment_tag = true;
-        } else if (strcmp(token->value, "<%%") == 0 || strcmp(token->value, "<%%=") == 0) {
+        } else if (strcmp(token->value, "<%%") == 0 || strcmp(token->value, "<%%=") == 0
+                   || strcmp(token->value, "<%graphql") == 0) {
           skip_erb_content = true;
           is_comment_tag = false;
         } else {

package/extension/libherb/include/analyze_helpers.h

@@ -46,6 +46,7 @@ bool search_in_nodes(analyzed_ruby_T* analyzed);
 bool search_rescue_nodes(analyzed_ruby_T* analyzed);
 bool search_ensure_nodes(analyzed_ruby_T* analyzed);
 bool search_yield_nodes(const pm_node_t* node, void* data);
+bool search_unclosed_control_flows(const pm_node_t* node, void* data);
 
 void check_erb_node_for_missing_end(const AST_NODE_T* node);
 

package/extension/libherb/include/analyzed_ruby.h

@@ -11,24 +11,25 @@ typedef struct ANALYZED_RUBY_STRUCT {
   pm_node_t* root;
   bool valid;
   bool parsed;
-  bool has_if_node;
-  bool has_elsif_node;
-  bool has_else_node;
-  bool has_end;
-  bool has_block_closing;
-  bool has_block_node;
-  bool has_case_node;
-  bool has_case_match_node;
-  bool has_when_node;
-  bool has_in_node;
-  bool has_for_node;
-  bool has_while_node;
-  bool has_until_node;
-  bool has_begin_node;
-  bool has_rescue_node;
-  bool has_ensure_node;
-  bool has_unless_node;
-  bool has_yield_node;
+  int if_node_count;
+  int elsif_node_count;
+  int else_node_count;
+  int end_count;
+  int block_closing_count;
+  int block_node_count;
+  int case_node_count;
+  int case_match_node_count;
+  int when_node_count;
+  int in_node_count;
+  int for_node_count;
+  int while_node_count;
+  int until_node_count;
+  int begin_node_count;
+  int rescue_node_count;
+  int ensure_node_count;
+  int unless_node_count;
+  int yield_node_count;
+  int unclosed_control_flow_count;
 } analyzed_ruby_T;
 
 analyzed_ruby_T* init_analyzed_ruby(hb_string_T source);

package/extension/libherb/include/ast_nodes.h

@@ -1,5 +1,5 @@
 // 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.4/templates/src/include/ast_nodes.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/include/ast_nodes.h.erb
 
 #ifndef HERB_AST_NODES_H
 #define HERB_AST_NODES_H

package/extension/libherb/include/ast_pretty_print.h

@@ -1,5 +1,5 @@
 // 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.4/templates/src/include/ast_pretty_print.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/include/ast_pretty_print.h.erb
 
 #ifndef HERB_AST_PRETTY_PRINT_H
 #define HERB_AST_PRETTY_PRINT_H

package/extension/libherb/include/errors.h

@@ -1,5 +1,5 @@
 // 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.4/templates/src/include/errors.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/include/errors.h.erb
 
 #ifndef HERB_ERRORS_H
 #define HERB_ERRORS_H
@@ -23,6 +23,7 @@ typedef enum {
   RUBY_PARSE_ERROR,
   ERB_CONTROL_FLOW_SCOPE_ERROR,
   MISSINGERB_END_TAG_ERROR,
+  ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR,
 } error_type_T;
 
 typedef struct ERROR_STRUCT {
@@ -96,6 +97,11 @@ typedef struct {
   const char* keyword;
 } MISSINGERB_END_TAG_ERROR_T;
 
+typedef struct {
+  ERROR_T base;
+  /* no additional fields */
+} ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T;
+
 UNEXPECTED_ERROR_T* unexpected_error_init(const char* description, const char* expected, const char* found, position_T start, position_T end);
 void append_unexpected_error(const char* description, const char* expected, const char* found, position_T start, position_T end, hb_array_T* errors);
 UNEXPECTED_TOKEN_ERROR_T* unexpected_token_error_init(token_type_T expected_type, token_T* found, position_T start, position_T end);
@@ -118,6 +124,8 @@ ERB_CONTROL_FLOW_SCOPE_ERROR_T* erb_control_flow_scope_error_init(const char* ke
 void append_erb_control_flow_scope_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
 MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error_init(const char* keyword, position_T start, position_T end);
 void append_missingerb_end_tag_error(const char* keyword, position_T start, position_T end, hb_array_T* errors);
+ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T* erb_multiple_blocks_in_tag_error_init(position_T start, position_T end);
+void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, hb_array_T* errors);
 
 void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 

package/extension/libherb/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.4"
+#define HERB_VERSION "0.8.5"
 
 #endif

package/extension/libherb/lexer.c

@@ -185,8 +185,8 @@ static token_T* lexer_parse_identifier(lexer_T* lexer) {
 // ===== ERB Parsing
 
 static token_T* lexer_parse_erb_open(lexer_T* lexer) {
-  hb_string_T erb_patterns[] = { hb_string("<%=="), hb_string("<%%="), hb_string("<%="), hb_string("<%#"),
-                                 hb_string("<%-"),  hb_string("<%%"),  hb_string("<%") };
+  hb_string_T erb_patterns[] = { hb_string("<%=="), hb_string("<%%="), hb_string("<%="),       hb_string("<%#"),
+                                 hb_string("<%-"),  hb_string("<%%"),  hb_string("<%graphql"), hb_string("<%") };
 
   lexer->state = STATE_ERB_CONTENT;
 
@@ -278,7 +278,7 @@ token_T* lexer_next_token(lexer_T* lexer) {
         return lexer_advance_with_next(lexer, strlen("<![CDATA["), TOKEN_CDATA_START);
       }
 
-      if (isalnum(lexer_peek(lexer, 1))) { return lexer_advance_current(lexer, TOKEN_HTML_TAG_START); }
+      if (isalpha(lexer_peek(lexer, 1))) { return lexer_advance_current(lexer, TOKEN_HTML_TAG_START); }
 
       if (lexer_peek_for_html_comment_start(lexer, 0)) {
         return lexer_advance_with(lexer, hb_string("<!--"), TOKEN_HTML_COMMENT_START);

package/extension/libherb/parser.c

@@ -1115,7 +1115,9 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
           TOKEN_DASH,
           TOKEN_EQUALS,
           TOKEN_EXCLAMATION,
+          TOKEN_HTML_TAG_END,
           TOKEN_IDENTIFIER,
+          TOKEN_LT,
           TOKEN_NBSP,
           TOKEN_NEWLINE,
           TOKEN_PERCENT,
@@ -1149,11 +1151,11 @@ static size_t find_matching_close_tag(hb_array_T* nodes, size_t start_idx, hb_st
     if (node->type == AST_HTML_OPEN_TAG_NODE) {
       AST_HTML_OPEN_TAG_NODE_T* open = (AST_HTML_OPEN_TAG_NODE_T*) node;
 
-      if (hb_string_equals(hb_string(open->tag_name->value), tag_name)) { depth++; }
+      if (hb_string_equals_case_insensitive(hb_string(open->tag_name->value), tag_name)) { depth++; }
     } else if (node->type == AST_HTML_CLOSE_TAG_NODE) {
       AST_HTML_CLOSE_TAG_NODE_T* close = (AST_HTML_CLOSE_TAG_NODE_T*) node;
 
-      if (hb_string_equals(hb_string(close->tag_name->value), tag_name)) {
+      if (hb_string_equals_case_insensitive(hb_string(close->tag_name->value), tag_name)) {
         if (depth == 0) { return i; }
         depth--;
       }

package/extension/libherb/parser_helpers.c

@@ -24,7 +24,7 @@ bool parser_check_matching_tag(const parser_T* parser, hb_string_T tag_name) {
   token_T* top_token = hb_array_last(parser->open_tags_stack);
   if (top_token == NULL || top_token->value == NULL) { return false; };
 
-  return hb_string_equals(hb_string(top_token->value), tag_name);
+  return hb_string_equals_case_insensitive(hb_string(top_token->value), tag_name);
 }
 
 token_T* parser_pop_open_tag(const parser_T* parser) {
@@ -49,7 +49,7 @@ bool parser_in_svg_context(const parser_T* parser) {
 
     if (tag && tag->value) {
       hb_string_T tag_value_string = hb_string(tag->value);
-      if (hb_string_equals(tag_value_string, hb_string("svg"))) { return true; }
+      if (hb_string_equals_case_insensitive(tag_value_string, hb_string("svg"))) { return true; }
     }
   }
 
@@ -61,8 +61,8 @@ bool parser_in_svg_context(const parser_T* parser) {
 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 (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; }
+  if (hb_string_equals_case_insensitive(tag_name, hb_string("script"))) { return FOREIGN_CONTENT_SCRIPT; }
+  if (hb_string_equals_case_insensitive(tag_name, hb_string("style"))) { return FOREIGN_CONTENT_STYLE; }
 
   return FOREIGN_CONTENT_UNKNOWN;
 }
@@ -217,5 +217,5 @@ bool parser_is_expected_closing_tag_name(hb_string_T tag_name, foreign_content_t
 
   if (hb_string_is_empty(tag_name) || hb_string_is_empty(expected_tag_name)) { return false; }
 
-  return hb_string_equals(expected_tag_name, tag_name);
+  return hb_string_equals_case_insensitive(expected_tag_name, tag_name);
 }

package/extension/libherb/parser_match_tags.c

@@ -1,5 +1,5 @@
 // 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.4/templates/src/parser_match_tags.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/parser_match_tags.c.erb
 
 #include "include/parser.h"
 #include "include/ast_nodes.h"

package/extension/libherb/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.4"
+#define HERB_VERSION "0.8.5"
 
 #endif

package/extension/libherb/visitor.c

@@ -1,5 +1,5 @@
 // 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.4/templates/src/visitor.c.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/src/visitor.c.erb
 
 #include <stdio.h>
 

package/extension/nodes.cpp

@@ -1,5 +1,5 @@
 // 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.4/templates/javascript/packages/node/extension/nodes.cpp.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/javascript/packages/node/extension/nodes.cpp.erb
 
 #include <node_api.h>
 #include "error_helpers.h"

package/extension/nodes.h

@@ -1,5 +1,5 @@
 // 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.4/templates/javascript/packages/node/extension/nodes.h.erb
+// be modified manually. See /Users/marcoroth/Development/herb-release-0.8.5/templates/javascript/packages/node/extension/nodes.h.erb
 
 #ifndef HERB_EXTENSION_NODES_H
 #define HERB_EXTENSION_NODES_H

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herb-tools/node",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "Native Node.js addon for HTML-aware ERB parsing using Herb.",
   "type": "module",
   "license": "MIT",
@@ -48,7 +48,7 @@
     "host": "https://github.com/marcoroth/herb/releases/download/"
   },
   "dependencies": {
-    "@herb-tools/core": "0.8.4",
+    "@herb-tools/core": "0.8.5",
     "@mapbox/node-pre-gyp": "^2.0.0",
     "node-addon-api": "^8.5.0",
     "node-pre-gyp-github": "^2.0.0"

package/CHANGELOG.md

@@ -1,19 +0,0 @@
-## 0.3.1 (2025-06-23)
-
-This was a version bump only for @herb-tools/node to align it with other projects, there were no code changes.
-
-## 0.3.0 (2025-06-21)
-
-This was a version bump only for @herb-tools/node to align it with other projects, there were no code changes.
-
-## 0.2.0 (2025-06-11)
-
-This was a version bump only for @herb-tools/node to align it with other projects, there were no code changes.
-
-## 0.1.1 (2025-04-20)
-
-This was a version bump only for @herb-tools/node to align it with other projects, there were no code changes.
-
-## 0.1.0 (2025-04-15)
-
-This was a version bump only for @herb-tools/node to align it with other projects, there were no code changes.