herb 0.8.4 → 0.8.5

data/src/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;
 }

data/src/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 %>`";
   }
 

data/src/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 /home/runner/work/herb/herb/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");

data/src/errors.c

@@ -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;
   }
 }

data/src/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 {

data/src/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);