herb 0.8.8-arm-linux-gnu → 0.8.10-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 888f3c26f99723abfd1d2ebdc4326a7a4df2081b0bff44726f921cffc6252d82
-  data.tar.gz: '087fea21f47e3ce9b75d7ef4bd9526e114ad08758c44bfcbac82b287b28f1aae'
+  metadata.gz: cce970c625f82f590b7b864222c558590b780b8beb41832ee1fcabbcc4921dc8
+  data.tar.gz: 87551da6a74a277c15dadf68d4b365a9f42461a05c1f9c6f22738da825e9b853
 SHA512:
-  metadata.gz: 3e14ed07d6c6d027eb4aad725bb1394fae4f1eeda95c9dcbdb615d567096669f1632d93a41bcdf44e59fd4a8d1262232820beecde7ad3276b4f2ed417b8a227e
-  data.tar.gz: 39fc879d1a0504869907fee059b17a79e3dbeb40cd336526cb3048ae25fb6350035bbd4ef5fbb756ea279a4c786544cde7224b5a937a6b519edc2f9aea037064
+  metadata.gz: c0d464f05bf5126d41ed6b0d82354733b09f67f5392c82aae800b90c61e8e30bc8aed4f213022b447548636e1707142e2e4c30c1c0d3fb7f6123d4a4029228b6
+  data.tar.gz: 2b11b9480eecddcede77573534358a3bb42b9539bc0a40f5ab3d3a0c06c51dc711a1d15e8205d77f61654d9013fa611c7fc76d91ee28ab704cdc9601bcca93f8

data/Makefile

@@ -67,15 +67,19 @@ ifeq ($(os),Linux)
 endif
 
 ifeq ($(os),Darwin)
-  brew_prefix := $(shell brew --prefix check)
-  test_cflags = $(test_flags) -I$(brew_prefix)/include
-  test_ldflags = -L$(brew_prefix)/lib -lcheck -lm $(prism_ldflags)
-  llvm_path = $(shell brew --prefix llvm@21)
-  cc = $(llvm_path)/bin/clang
-  clang_format = $(llvm_path)/bin/clang-format
-  clang_tidy = $(llvm_path)/bin/clang-tidy
+  llvm_version := 21
+  llvm_prefix ?= $(shell brew --prefix llvm@$(llvm_version))
+  check_prefix ?= $(shell brew --prefix check)
+
+  cc ?= $(llvm_prefix)/bin/clang
+  clang_format ?= $(llvm_prefix)/bin/clang-format
+  clang_tidy ?= $(llvm_prefix)/bin/clang-tidy
+
+  test_cflags = $(test_flags) -I$(check_prefix)/include
+  test_ldflags = -L$(check_prefix)/lib -lcheck -lm $(prism_ldflags)
 endif
 
+.PHONY: all
 all: templates prism $(exec) $(lib_name) $(static_lib_name) test wasm clangd_config
 
 $(exec): $(objects)
@@ -91,39 +95,49 @@ $(static_lib_name): $(objects)
 src/%.o: src/%.c templates
 	$(cc) -c $(flags) -fPIC $< -o $@
 
-test/%.o: test/%.c templates
+test/%.o: test/%.c templates prism
 	$(cc) -c $(test_cflags) $(test_flags) $(prism_flags) $< -o $@
 
+.PHONY: test
 test: $(test_objects) $(non_main_objects)
 	$(cc) $(test_objects) $(non_main_objects) $(test_cflags) $(test_ldflags) -o $(test_exec)
 
+.PHONY: clean
 clean:
 	rm -f $(exec) $(test_exec) $(lib_name) $(shared_lib_name) $(ruby_extension)
 	rm -rf $(objects) $(test_objects) $(extension_objects) lib/herb/*.bundle tmp
 	rm -rf $(prism_path)
 	rake prism:clean
 
+.PHONY: bundle_install
 bundle_install:
 	bundle install
 
+.PHONY: templates
 templates: bundle_install
 	bundle exec rake templates
 
+.PHONY: prism
 prism: bundle_install
 	cd $(prism_path) && ruby templates/template.rb && make static && cd -
 	rake prism:vendor
 
+.PHONY: format
 format:
 	$(clang_format) -i $(project_and_extension_files)
 
+.PHONY: lint
 lint:
 	$(clang_format) --dry-run --Werror $(project_and_extension_files)
 
+.PHONY: tidy
 tidy:
 	$(clang_tidy) $(project_files) -- $(flags)
 
+.PHONY: clangd_config
 clangd_config:
 	@echo "$(flags) $(test_cflags)" | tr ' ' '\n' | sort -u > compile_flags.txt
 
+.PHONY: wasm
 wasm:
 	cd wasm && make

data/config.yml

@@ -178,6 +178,13 @@ errors:
 
       fields: []
 
+    - name: ERBCaseWithConditionsError
+      message:
+        template: "A `case` statement with `when`/`in` in a single ERB tag cannot be formatted. Use separate tags for `case` and its conditions."
+        arguments: []
+
+      fields: []
+
 warnings:
   fields: []
   types: []

data/ext/herb/error_helpers.c

@@ -341,6 +341,30 @@ static VALUE rb_erb_multiple_blocks_in_tag_error_from_c_struct(ERB_MULTIPLE_BLOC
   return rb_class_new_instance(3, args, ERBMultipleBlocksInTagError);
 };
 
+static VALUE rb_erb_case_with_conditions_error_from_c_struct(ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error) {
+  if (erb_case_with_conditions_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &erb_case_with_conditions_error->base;
+
+  VALUE Herb = rb_define_module("Herb");
+  VALUE Errors = rb_define_module_under(Herb, "Errors");
+  VALUE Error = rb_define_class_under(Errors, "Error", rb_cObject);
+  VALUE ERBCaseWithConditionsError = rb_define_class_under(Errors, "ERBCaseWithConditionsError", Error);
+
+  VALUE type = rb_utf8_str_new_cstr(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_utf8_str_new_cstr(error->message);
+
+
+  VALUE args[3] = {
+    type,
+    location,
+    message
+  };
+
+  return rb_class_new_instance(3, args, ERBCaseWithConditionsError);
+};
+
 
 VALUE rb_error_from_c_struct(ERROR_T* error) {
   if (!error) { return Qnil; }
@@ -358,6 +382,7 @@ VALUE rb_error_from_c_struct(ERROR_T* error) {
     case ERB_CONTROL_FLOW_SCOPE_ERROR: return rb_erb_control_flow_scope_error_from_c_struct((ERB_CONTROL_FLOW_SCOPE_ERROR_T*) error); break;
     case MISSINGERB_END_TAG_ERROR: return rb_missingerb_end_tag_error_from_c_struct((MISSINGERB_END_TAG_ERROR_T*) error); break;
     case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return rb_erb_multiple_blocks_in_tag_error_from_c_struct((ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T*) error); break;
+    case ERB_CASE_WITH_CONDITIONS_ERROR: return rb_erb_case_with_conditions_error_from_c_struct((ERB_CASE_WITH_CONDITIONS_ERROR_T*) error); break;
   }
 
   return Qnil;

data/ext/herb/nodes.c

@@ -464,7 +464,7 @@ static VALUE rb_erb_content_node_from_c_struct(AST_ERB_CONTENT_NODE_T* erb_conte
   VALUE erb_content_node_tag_opening = rb_token_from_c_struct(erb_content_node->tag_opening);
   VALUE erb_content_node_content = rb_token_from_c_struct(erb_content_node->content);
   VALUE erb_content_node_tag_closing = rb_token_from_c_struct(erb_content_node->tag_closing);
-  /* #<Herb::Template::AnalyzedRubyField:0x00007fc7890faa98 @name="analyzed_ruby", @options={kind: nil}> */
+  /* #<Herb::Template::AnalyzedRubyField:0x00007fb54f94c300 @name="analyzed_ruby", @options={kind: nil}> */
   VALUE erb_content_node_analyzed_ruby = Qnil;
   VALUE erb_content_node_parsed = (erb_content_node->parsed) ? Qtrue : Qfalse;
   VALUE erb_content_node_valid = (erb_content_node->valid) ? Qtrue : Qfalse;

data/lib/herb/engine/compiler.rb

@@ -297,18 +297,20 @@ module Herb
       end
 
       def add_context_aware_expression(code, context)
+        closing = code.include?("#") ? "\n))" : "))"
+
         case context
         when :attribute_value
           @engine.send(:with_buffer) {
-            @engine.src << " << #{@attrfunc}((" << code << "))"
+            @engine.src << " << #{@attrfunc}((" << code << closing
           }
         when :script_content
           @engine.send(:with_buffer) {
-            @engine.src << " << #{@jsfunc}((" << code << "))"
+            @engine.src << " << #{@jsfunc}((" << code << closing
           }
         when :style_content
           @engine.send(:with_buffer) {
-            @engine.src << " << #{@cssfunc}((" << code << "))"
+            @engine.src << " << #{@cssfunc}((" << code << closing
           }
         else
           @engine.send(:add_expression_result_escaped, code)

data/lib/herb/engine/debug_visitor.rb

@@ -178,7 +178,7 @@ module Herb
 
         debug_attributes = [
           create_debug_attribute("data-herb-debug-outline-type", view_type),
-          create_debug_attribute("data-herb-debug-file-name", @filename&.basename&.to_s || "unknown"),
+          create_debug_attribute("data-herb-debug-file-name", component_display_name),
           create_debug_attribute("data-herb-debug-file-relative-path", @relative_file_path || "unknown"),
           create_debug_attribute("data-herb-debug-file-full-path", @filename&.to_s || "unknown")
         ]
@@ -231,7 +231,7 @@ module Herb
         debug_attributes = [
           create_debug_attribute("data-herb-debug-outline-type", outline_type),
           create_debug_attribute("data-herb-debug-erb", escaped_erb),
-          create_debug_attribute("data-herb-debug-file-name", @filename&.basename&.to_s || "unknown"),
+          create_debug_attribute("data-herb-debug-file-name", component_display_name),
           create_debug_attribute("data-herb-debug-file-relative-path", @relative_file_path || "unknown"),
           create_debug_attribute("data-herb-debug-file-full-path", @filename&.to_s || "unknown"),
           create_debug_attribute("data-herb-debug-inserted", "true")
@@ -288,8 +288,43 @@ module Herb
       def component?
         return false unless @filename
 
+        @filename.to_s.match?(%r{(^|/)app/components/})
+      end
+
+      def sidecar_component?
+        return false unless component?
+        return false unless @filename
+
+        @filename.basename.to_s.match?(/\Acomponent\.(html\.erb|html\.herb|erb|herb)\z/)
+      end
+
+      def component_display_name
+        return @filename&.basename&.to_s || "unknown" unless @filename
+
+        basename = @filename.basename.to_s
         path = @filename.to_s
-        path.include?("/components/")
+
+        if sidecar_component? && (match = path.match(%r{/components/(.+)/component\.[^/]+\z}))
+          return match[1].split("/").map { |s| classify(s) }.join("::")
+        end
+
+        if component?
+          path_without_ext = path.sub(/\.(?:html\.erb|html\.herb|erb|herb)\z/, "")
+
+          if (match = path_without_ext.match(%r{/components/(.+)\z}))
+            return match[1].split("/").map { |s| classify(s) }.join("::")
+          end
+        end
+
+        basename
+      end
+
+      def classify(name)
+        if name.respond_to?(:camelize)
+          name.camelize
+        else
+          name.split(/[_-]/).map(&:capitalize).join
+        end
       end
 
       def in_head_context?

data/lib/herb/engine.rb

@@ -212,11 +212,15 @@ module Herb
     end
 
     def add_expression_result(code)
-      with_buffer { @src << " << (" << code << ").to_s" }
+      with_buffer {
+        @src << " << (" << code << comment_aware_newline(code) << ").to_s"
+      }
     end
 
     def add_expression_result_escaped(code)
-      with_buffer { @src << " << " << @escapefunc << "((" << code << "))" }
+      with_buffer {
+        @src << " << " << @escapefunc << "((" << code << comment_aware_newline(code) << "))"
+      }
     end
 
     def add_expression_block(indicator, code)
@@ -228,11 +232,19 @@ module Herb
     end
 
     def add_expression_block_result(code)
-      with_buffer { @src << " << " << code }
+      with_buffer {
+        @src << " << " << code << comment_aware_newline(code)
+      }
     end
 
     def add_expression_block_result_escaped(code)
-      with_buffer { @src << " << " << @escapefunc << "(" << code << ")" }
+      with_buffer {
+        @src << " << " << @escapefunc << "(" << code << comment_aware_newline(code) << ")"
+      }
+    end
+
+    def comment_aware_newline(code)
+      code.include?("#") ? "\n" : ""
     end
 
     def add_postamble(postamble)

data/lib/herb/errors.rb

@@ -518,5 +518,25 @@ module Herb
       end
     end
 
+    class ERBCaseWithConditionsError < Error
+      include Colors
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location.tree_inspect})\n")}")
+        output += white("└── message: #{green(message.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
   end
 end

data/lib/herb/version.rb

@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.8.8"
+  VERSION = "0.8.10"
 end

data/sig/herb/engine/debug_visitor.rbs

@@ -57,6 +57,12 @@ module Herb
 
       def component?: () -> untyped
 
+      def sidecar_component?: () -> untyped
+
+      def component_display_name: () -> untyped
+
+      def classify: (untyped name) -> untyped
+
       def in_head_context?: () -> untyped
 
       def in_script_or_style_context?: () -> untyped

data/sig/herb/engine.rbs

@@ -51,6 +51,8 @@ module Herb
 
     def add_expression_block_result_escaped: (untyped code) -> untyped
 
+    def comment_aware_newline: (untyped code) -> untyped
+
     def add_postamble: (untyped postamble) -> untyped
 
     def with_buffer: () ?{ (?) -> untyped } -> untyped

data/sig/herb/errors.rbs

@@ -253,5 +253,15 @@ module Herb
       # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
       def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
     end
+
+    class ERBCaseWithConditionsError < Error
+      include Colors
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
   end
 end

data/sig/serialized_ast_errors.rbs

@@ -61,4 +61,7 @@ module Herb
   type serialized_erb_multiple_blocks_in_tag_error = serialized_error & {
   }
 
+  type serialized_erb_case_with_conditions_error = serialized_error & {
+  }
+
 end

data/src/analyze.c

@@ -14,6 +14,7 @@
 #include "include/util.h"
 #include "include/util/hb_array.h"
 #include "include/util/hb_string.h"
+#include "include/util/string.h"
 #include "include/visitor.h"
 
 #include <prism.h>
@@ -34,17 +35,20 @@ static analyzed_ruby_T* herb_analyze_ruby(hb_string_T source) {
   pm_visit_node(analyzed->root, search_until_nodes, analyzed);
   pm_visit_node(analyzed->root, search_begin_nodes, analyzed);
   pm_visit_node(analyzed->root, search_unless_nodes, analyzed);
+  pm_visit_node(analyzed->root, search_when_nodes, analyzed);
+  pm_visit_node(analyzed->root, search_in_nodes, analyzed);
 
-  search_elsif_nodes(analyzed);
-  search_else_nodes(analyzed);
-  search_end_nodes(analyzed);
-  search_when_nodes(analyzed);
-  search_in_nodes(analyzed);
-  search_rescue_nodes(analyzed);
-  search_ensure_nodes(analyzed);
+  search_unexpected_elsif_nodes(analyzed);
+  search_unexpected_else_nodes(analyzed);
+  search_unexpected_end_nodes(analyzed);
+  search_unexpected_when_nodes(analyzed);
+  search_unexpected_in_nodes(analyzed);
+
+  search_unexpected_rescue_nodes(analyzed);
+  search_unexpected_ensure_nodes(analyzed);
   search_yield_nodes(analyzed->root, analyzed);
   search_then_keywords(analyzed->root, analyzed);
-  search_block_closing_nodes(analyzed);
+  search_unexpected_block_closing_nodes(analyzed);
 
   if (!analyzed->valid) { pm_visit_node(analyzed->root, search_unclosed_control_flows, analyzed); }
 
@@ -57,8 +61,8 @@ 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
-        && strcmp(opening, "<%graphql") != 0) {
+    if (!string_equals(opening, "<%%") && !string_equals(opening, "<%%=") && !string_equals(opening, "<%#")
+        && !string_equals(opening, "<%graphql")) {
       analyzed_ruby_T* analyzed = herb_analyze_ruby(hb_string(erb_content_node->content->value));
 
       erb_content_node->parsed = true;
@@ -72,6 +76,16 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
           erb_content_node->base.errors
         );
       }
+
+      if (!analyzed->valid
+          && ((analyzed->case_node_count > 0 && analyzed->when_node_count > 0)
+              || (analyzed->case_match_node_count > 0 && analyzed->in_node_count > 0))) {
+        append_erb_case_with_conditions_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;
@@ -274,12 +288,14 @@ static control_type_t detect_control_type(AST_ERB_CONTENT_NODE_T* erb_node) {
   if (has_elsif_node(ruby)) { return CONTROL_TYPE_ELSIF; }
   if (has_else_node(ruby)) { return CONTROL_TYPE_ELSE; }
   if (has_end(ruby)) { return CONTROL_TYPE_END; }
-  if (has_when_node(ruby)) { return CONTROL_TYPE_WHEN; }
-  if (has_in_node(ruby)) { return CONTROL_TYPE_IN; }
+  if (has_when_node(ruby) && !has_case_node(ruby)) { return CONTROL_TYPE_WHEN; }
+  if (has_in_node(ruby) && !has_case_match_node(ruby)) { return CONTROL_TYPE_IN; }
   if (has_rescue_node(ruby)) { return CONTROL_TYPE_RESCUE; }
   if (has_ensure_node(ruby)) { return CONTROL_TYPE_ENSURE; }
   if (has_block_closing(ruby)) { return CONTROL_TYPE_BLOCK_CLOSE; }
 
+  if (ruby->unclosed_control_flow_count == 0 && !has_yield_node(ruby)) { return CONTROL_TYPE_UNKNOWN; }
+
   return find_earliest_control_keyword(root, ruby->parser.start);
 }
 

data/src/analyze_helpers.c

@@ -3,6 +3,7 @@
 #include <string.h>
 
 #include "include/analyzed_ruby.h"
+#include "include/util/string.h"
 
 bool has_if_node(analyzed_ruby_T* analyzed) {
   return analyzed->if_node_count > 0;
@@ -83,7 +84,7 @@ bool has_then_keyword(analyzed_ruby_T* analyzed) {
 bool has_error_message(analyzed_ruby_T* anlayzed, const char* message) {
   for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) anlayzed->parser.error_list.head; error != NULL;
        error = (const pm_diagnostic_t*) error->node.next) {
-    if (strcmp(error->message, message) == 0) { return true; }
+    if (string_equals(error->message, message)) { return true; }
   }
 
   return false;
@@ -242,7 +243,28 @@ bool search_unless_nodes(const pm_node_t* node, void* data) {
   return false;
 }
 
-bool search_elsif_nodes(analyzed_ruby_T* analyzed) {
+bool search_when_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_WHEN_NODE) { analyzed->when_node_count++; }
+
+  pm_visit_child_nodes(node, search_when_nodes, analyzed);
+
+  return false;
+}
+
+bool search_in_nodes(const pm_node_t* node, void* data) {
+  analyzed_ruby_T* analyzed = (analyzed_ruby_T*) data;
+
+  if (node->type == PM_IN_NODE) { analyzed->in_node_count++; }
+  if (node->type == PM_MATCH_PREDICATE_NODE) { analyzed->in_node_count++; }
+
+  pm_visit_child_nodes(node, search_in_nodes, analyzed);
+
+  return false;
+}
+
+bool search_unexpected_elsif_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'elsif', ignoring it")) {
     analyzed->elsif_node_count++;
     return true;
@@ -251,7 +273,7 @@ bool search_elsif_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_else_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_else_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'else', ignoring it")) {
     analyzed->else_node_count++;
     return true;
@@ -260,7 +282,7 @@ bool search_else_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_end_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_end_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'end', ignoring it")) {
     if (has_error_message(analyzed, "unexpected '=', ignoring it")) {
       // `=end`
@@ -274,7 +296,7 @@ bool search_end_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_block_closing_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_block_closing_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected '}', ignoring it")) {
     analyzed->block_closing_count++;
     return true;
@@ -283,7 +305,7 @@ bool search_block_closing_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_when_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_when_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'when', ignoring it")) {
     analyzed->when_node_count++;
     return true;
@@ -292,7 +314,7 @@ bool search_when_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_in_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_in_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'in', ignoring it")) {
     analyzed->in_node_count++;
     return true;
@@ -301,7 +323,7 @@ bool search_in_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_rescue_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_rescue_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'rescue', ignoring it")) {
     analyzed->rescue_node_count++;
     return true;
@@ -310,7 +332,7 @@ bool search_rescue_nodes(analyzed_ruby_T* analyzed) {
   return false;
 }
 
-bool search_ensure_nodes(analyzed_ruby_T* analyzed) {
+bool search_unexpected_ensure_nodes(analyzed_ruby_T* analyzed) {
   if (has_error_message(analyzed, "unexpected 'ensure', ignoring it")) {
     analyzed->ensure_node_count++;
     return true;
@@ -468,6 +490,7 @@ bool search_unclosed_control_flows(const pm_node_t* node, void* data) {
       if (has_opening && !has_valid_block_closing(block_node->opening_loc, block_node->closing_loc)) {
         analyzed->unclosed_control_flow_count++;
       }
+
       break;
     }
 

data/src/errors.c

@@ -511,6 +511,20 @@ void append_erb_multiple_blocks_in_tag_error(position_T start, position_T end, h
   hb_array_append(errors, erb_multiple_blocks_in_tag_error_init(start, end));
 }
 
+ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error_init(position_T start, position_T end) {
+  ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error = malloc(sizeof(ERB_CASE_WITH_CONDITIONS_ERROR_T));
+
+  error_init(&erb_case_with_conditions_error->base, ERB_CASE_WITH_CONDITIONS_ERROR, start, end);
+
+  erb_case_with_conditions_error->base.message = herb_strdup("A `case` statement with `when`/`in` in a single ERB tag cannot be formatted. Use separate tags for `case` and its conditions.");
+
+  return erb_case_with_conditions_error;
+}
+
+void append_erb_case_with_conditions_error(position_T start, position_T end, hb_array_T* errors) {
+  hb_array_append(errors, erb_case_with_conditions_error_init(start, end));
+}
+
 const char* error_type_to_string(ERROR_T* error) {
   switch (error->type) {
     case UNEXPECTED_ERROR: return "UNEXPECTED_ERROR";
@@ -525,6 +539,7 @@ const char* error_type_to_string(ERROR_T* 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";
+    case ERB_CASE_WITH_CONDITIONS_ERROR: return "ERB_CASE_WITH_CONDITIONS_ERROR";
   }
 
   return "Unknown error_type_T";
@@ -544,6 +559,7 @@ const char* error_human_type(ERROR_T* error) {
     case ERB_CONTROL_FLOW_SCOPE_ERROR: return "ERBControlFlowScopeError";
     case MISSINGERB_END_TAG_ERROR: return "MissingERBEndTagError";
     case ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR: return "ERBMultipleBlocksInTagError";
+    case ERB_CASE_WITH_CONDITIONS_ERROR: return "ERBCaseWithConditionsError";
   }
 
   return "Unknown error_type_T";
@@ -638,6 +654,12 @@ static void error_free_erb_multiple_blocks_in_tag_error(ERB_MULTIPLE_BLOCKS_IN_T
   error_free_base_error(&erb_multiple_blocks_in_tag_error->base);
 }
 
+static void error_free_erb_case_with_conditions_error(ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error) {
+  /* no ERB_CASE_WITH_CONDITIONS_ERROR_T specific fields to free up */
+
+  error_free_base_error(&erb_case_with_conditions_error->base);
+}
+
 void error_free(ERROR_T* error) {
   if (!error) { return; }
 
@@ -654,6 +676,7 @@ void error_free(ERROR_T* error) {
     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;
+    case ERB_CASE_WITH_CONDITIONS_ERROR: error_free_erb_case_with_conditions_error((ERB_CASE_WITH_CONDITIONS_ERROR_T*) error); break;
   }
 }
 
@@ -877,6 +900,19 @@ static void error_pretty_print_erb_multiple_blocks_in_tag_error(ERB_MULTIPLE_BLO
   pretty_print_quoted_property(hb_string("message"), hb_string(error->base.message), indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_erb_case_with_conditions_error(ERB_CASE_WITH_CONDITIONS_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; }
 
@@ -893,5 +929,6 @@ void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relati
     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;
+    case ERB_CASE_WITH_CONDITIONS_ERROR: error_pretty_print_erb_case_with_conditions_error((ERB_CASE_WITH_CONDITIONS_ERROR_T*) error, indent, relative_indent, buffer); break;
   }
 }