herb 0.8.9 → 0.8.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9b42d0123634348d9e777dbd6889093262e59df2ee067fbd5a9b9c3a73e701e
-  data.tar.gz: 2f68d9250ae09827e1946c4b2ed83af9588af36e25522fe76b21eb191a8af2f0
+  metadata.gz: 99c86daa1824a8c955a69c6015f8930c49b43b3e4333cb4c16b30d62b0e9ba58
+  data.tar.gz: 8e71055933851fa346707121e806e85b59a62d4ef00a9e6c4e7014c26859cca1
 SHA512:
-  metadata.gz: 66d65923cffe6d108b4cf48be595d270c56b180596d457a41dba859e81642f894ad5af027a7c8e809cda2ac3c012e73bcfb46c634a9c07f6ac0fbe0a0ddca54f
-  data.tar.gz: d2b924c70779af2e4a2f4d9a34a5c97a9700df4b0c4c929397afdf57a226c108f0e5233854d9748abf4892e377703a0c05a51d6df374174168dff5d49e67e1a5
+  metadata.gz: 50134d7481f2d8bb436d9115d95e58af534a7be1ee4c24e5e193b738d32f605b4e767a49bec3b87b10956faaf1f7128c666e5db81dd4221ef163aa2e0857b505
+  data.tar.gz: 551022b3dd92e528d541696b829690bad55e749d2cff7993912cba3539b495266a8ee284cc2845c6d2c435eb029668bef9c8f699730270df0373ea5e0f8136b4

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:0x00007ffb7f81b0a0 @name="analyzed_ruby", @options={kind: nil}> */
+  /* #<Herb::Template::AnalyzedRubyField:0x00007f8f1d2522c8 @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.9"
+  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,8 +288,8 @@ 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; }

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

data/src/extract.c

@@ -3,7 +3,9 @@
 #include "include/lexer.h"
 #include "include/util/hb_array.h"
 #include "include/util/hb_buffer.h"
+#include "include/util/string.h"
 
+#include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -22,11 +24,11 @@ void herb_extract_ruby_to_buffer(const char* source, hb_buffer_T* output) {
       }
 
       case TOKEN_ERB_START: {
-        if (strcmp(token->value, "<%#") == 0) {
+        if (string_equals(token->value, "<%#")) {
           skip_erb_content = true;
           is_comment_tag = true;
-        } else if (strcmp(token->value, "<%%") == 0 || strcmp(token->value, "<%%=") == 0
-                   || strcmp(token->value, "<%graphql") == 0) {
+        } else if (string_equals(token->value, "<%%") || string_equals(token->value, "<%%=")
+                   || string_equals(token->value, "<%graphql")) {
           skip_erb_content = true;
           is_comment_tag = false;
         } else {
@@ -129,6 +131,7 @@ char* herb_extract(const char* source, const herb_extract_language_T language) {
   switch (language) {
     case HERB_EXTRACT_LANGUAGE_RUBY: herb_extract_ruby_to_buffer(source, &output); break;
     case HERB_EXTRACT_LANGUAGE_HTML: herb_extract_html_to_buffer(source, &output); break;
+    default: assert(0 && "invalid extract language");
   }
 
   return output.value;

data/src/include/analyze_helpers.h

@@ -34,26 +34,29 @@ bool is_brace_block(pm_location_t opening_location);
 bool is_closing_brace(pm_location_t location);
 bool has_valid_block_closing(pm_location_t opening_loc, pm_location_t closing_loc);
 
-bool search_if_nodes(const pm_node_t* node, void* data);
+bool search_begin_nodes(const pm_node_t* node, void* data);
 bool search_block_nodes(const pm_node_t* node, void* data);
-bool search_case_nodes(const pm_node_t* node, void* data);
 bool search_case_match_nodes(const pm_node_t* node, void* data);
-bool search_while_nodes(const pm_node_t* node, void* data);
+bool search_case_nodes(const pm_node_t* node, void* data);
 bool search_for_nodes(const pm_node_t* node, void* data);
-bool search_until_nodes(const pm_node_t* node, void* data);
-bool search_begin_nodes(const pm_node_t* node, void* data);
-bool search_unless_nodes(const pm_node_t* node, void* data);
-bool search_elsif_nodes(analyzed_ruby_T* analyzed);
-bool search_else_nodes(analyzed_ruby_T* analyzed);
-bool search_end_nodes(analyzed_ruby_T* analyzed);
-bool search_block_closing_nodes(analyzed_ruby_T* analyzed);
-bool search_when_nodes(analyzed_ruby_T* analyzed);
-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_if_nodes(const pm_node_t* node, void* data);
+bool search_in_nodes(const pm_node_t* node, void* data);
 bool search_then_keywords(const pm_node_t* node, void* data);
 bool search_unclosed_control_flows(const pm_node_t* node, void* data);
+bool search_unless_nodes(const pm_node_t* node, void* data);
+bool search_until_nodes(const pm_node_t* node, void* data);
+bool search_when_nodes(const pm_node_t* node, void* data);
+bool search_while_nodes(const pm_node_t* node, void* data);
+bool search_yield_nodes(const pm_node_t* node, void* data);
+
+bool search_unexpected_block_closing_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_else_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_elsif_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_end_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_ensure_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_in_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_rescue_nodes(analyzed_ruby_T* analyzed);
+bool search_unexpected_when_nodes(analyzed_ruby_T* analyzed);
 
 void check_erb_node_for_missing_end(const AST_NODE_T* node);
 

data/src/include/errors.h

@@ -24,6 +24,7 @@ typedef enum {
   ERB_CONTROL_FLOW_SCOPE_ERROR,
   MISSINGERB_END_TAG_ERROR,
   ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR,
+  ERB_CASE_WITH_CONDITIONS_ERROR,
 } error_type_T;
 
 typedef struct ERROR_STRUCT {
@@ -102,6 +103,11 @@ typedef struct {
   /* no additional fields */
 } ERB_MULTIPLE_BLOCKS_IN_TAG_ERROR_T;
 
+typedef struct {
+  ERROR_T base;
+  /* no additional fields */
+} ERB_CASE_WITH_CONDITIONS_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);
@@ -126,6 +132,8 @@ MISSINGERB_END_TAG_ERROR_T* missingerb_end_tag_error_init(const char* keyword, p
 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);
+ERB_CASE_WITH_CONDITIONS_ERROR_T* erb_case_with_conditions_error_init(position_T start, position_T end);
+void append_erb_case_with_conditions_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);
 

data/src/include/util/string.h

@@ -0,0 +1,11 @@
+#ifndef HERB_UTILS_STRING_H
+#define HERB_UTILS_STRING_H
+
+#include <stdbool.h>
+#include <string.h>
+
+static inline bool string_equals(const char* a, const char* b) {
+  return strcmp(a, b) == 0;
+}
+
+#endif

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.8.9"
+#define HERB_VERSION "0.8.10"
 
 #endif

data/src/main.c

@@ -9,8 +9,10 @@
 #include "include/io.h"
 #include "include/ruby_parser.h"
 #include "include/util/hb_buffer.h"
+#include "include/util/string.h"
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
@@ -34,22 +36,22 @@ void print_time_diff(const struct timespec start, const struct timespec end, con
 
 int main(const int argc, char* argv[]) {
   if (argc < 2) {
-    printf("./herb [command] [options]\n\n");
+    puts("./herb [command] [options]\n");
 
-    printf("Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.\n\n");
+    puts("Herb 🌿 Powerful and seamless HTML-aware ERB parsing and tooling.\n");
 
-    printf("./herb lex [file]      -  Lex a file\n");
-    printf("./herb parse [file]    -  Parse a file\n");
-    printf("./herb ruby [file]     -  Extract Ruby from a file\n");
-    printf("./herb html [file]     -  Extract HTML from a file\n");
-    printf("./herb prism [file]    -  Extract Ruby from a file and parse the Ruby source with Prism\n");
+    puts("./herb lex [file]      -  Lex a file");
+    puts("./herb parse [file]    -  Parse a file");
+    puts("./herb ruby [file]     -  Extract Ruby from a file");
+    puts("./herb html [file]     -  Extract HTML from a file");
+    puts("./herb prism [file]    -  Extract Ruby from a file and parse the Ruby source with Prism");
 
-    return 1;
+    return EXIT_FAILURE;
   }
 
   if (argc < 3) {
-    printf("Please specify input file.\n");
-    return 1;
+    puts("Please specify input file.");
+    return EXIT_FAILURE;
   }
 
   hb_buffer_T output;
@@ -61,38 +63,20 @@ int main(const int argc, char* argv[]) {
   struct timespec start, end;
   clock_gettime(CLOCK_MONOTONIC, &start);
 
-  if (strcmp(argv[1], "visit") == 0) {
-    AST_DOCUMENT_NODE_T* root = herb_parse(source, NULL);
-    clock_gettime(CLOCK_MONOTONIC, &end);
-
-    herb_analyze_parse_tree(root, source);
-
-    ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
-    printf("%s\n", output.value);
-
-    print_time_diff(start, end, "visiting");
-
-    ast_node_free((AST_NODE_T*) root);
-    free(output.value);
-    free(source);
-
-    return 0;
-  }
-
-  if (strcmp(argv[1], "lex") == 0) {
+  if (string_equals(argv[1], "lex")) {
     herb_lex_to_buffer(source, &output);
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    printf("%s\n", output.value);
+    puts(output.value);
     print_time_diff(start, end, "lexing");
 
     free(output.value);
     free(source);
 
-    return 0;
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "parse") == 0) {
+  if (string_equals(argv[1], "parse")) {
     AST_DOCUMENT_NODE_T* root = herb_parse(source, NULL);
 
     herb_analyze_parse_tree(root, source);
@@ -100,11 +84,11 @@ int main(const int argc, char* argv[]) {
     clock_gettime(CLOCK_MONOTONIC, &end);
 
     int silent = 0;
-    if (argc > 3 && strcmp(argv[3], "--silent") == 0) { silent = 1; }
+    if (argc > 3 && string_equals(argv[3], "--silent")) { silent = 1; }
 
     if (!silent) {
       ast_pretty_print_node((AST_NODE_T*) root, 0, 0, &output);
-      printf("%s\n", output.value);
+      puts(output.value);
 
       print_time_diff(start, end, "parsing");
     }
@@ -113,36 +97,36 @@ int main(const int argc, char* argv[]) {
     free(output.value);
     free(source);
 
-    return 0;
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "ruby") == 0) {
+  if (string_equals(argv[1], "ruby")) {
     herb_extract_ruby_to_buffer(source, &output);
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    printf("%s\n", output.value);
+    puts(output.value);
     print_time_diff(start, end, "extracting Ruby");
 
     free(output.value);
     free(source);
 
-    return 0;
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "html") == 0) {
+  if (string_equals(argv[1], "html")) {
     herb_extract_html_to_buffer(source, &output);
     clock_gettime(CLOCK_MONOTONIC, &end);
 
-    printf("%s\n", output.value);
+    puts(output.value);
     print_time_diff(start, end, "extracting HTML");
 
     free(output.value);
     free(source);
 
-    return 0;
+    return EXIT_SUCCESS;
   }
 
-  if (strcmp(argv[1], "prism") == 0) {
+  if (string_equals(argv[1], "prism")) {
     printf("HTML+ERB File: \n%s\n", source);
 
     char* ruby_source = herb_extract(source, HERB_EXTRACT_LANGUAGE_RUBY);
@@ -150,9 +134,13 @@ int main(const int argc, char* argv[]) {
 
     herb_parse_ruby_to_stdout(ruby_source);
 
-    return 0;
+    free(ruby_source);
+    free(output.value);
+    free(source);
+
+    return EXIT_SUCCESS;
   }
 
   printf("Unknown Command: %s\n", argv[1]);
-  return 1;
+  return EXIT_FAILURE;
 }

data/src/parser.c

@@ -12,6 +12,7 @@
 #include "include/util/hb_array.h"
 #include "include/util/hb_buffer.h"
 #include "include/util/hb_string.h"
+#include "include/util/string.h"
 #include "include/visitor.h"
 
 #include <stdio.h>
@@ -346,7 +347,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
   while (!token_is(parser, TOKEN_EOF)
          && !(
            token_is(parser, TOKEN_QUOTE) && opening_quote != NULL
-           && strcmp(parser->current_token->value, opening_quote->value) == 0
+           && string_equals(parser->current_token->value, opening_quote->value)
          )) {
     if (token_is(parser, TOKEN_ERB_START)) {
       parser_append_literal_node_from_buffer(parser, &buffer, children, start);
@@ -364,7 +365,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
       token_T* next_token = lexer_next_token(parser->lexer);
 
       if (next_token && next_token->type == TOKEN_QUOTE && opening_quote != NULL
-          && strcmp(next_token->value, opening_quote->value) == 0) {
+          && string_equals(next_token->value, opening_quote->value)) {
         hb_buffer_append(&buffer, parser->current_token->value);
         hb_buffer_append(&buffer, next_token->value);
 
@@ -387,7 +388,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
   }
 
   if (token_is(parser, TOKEN_QUOTE) && opening_quote != NULL
-      && strcmp(parser->current_token->value, opening_quote->value) == 0) {
+      && string_equals(parser->current_token->value, opening_quote->value)) {
     lexer_state_snapshot_T saved_state = lexer_save_state(parser->lexer);
 
     token_T* potential_closing = parser->current_token;
@@ -415,7 +416,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
       while (!token_is(parser, TOKEN_EOF)
              && !(
                token_is(parser, TOKEN_QUOTE) && opening_quote != NULL
-               && strcmp(parser->current_token->value, opening_quote->value) == 0
+               && string_equals(parser->current_token->value, opening_quote->value)
              )) {
         if (token_is(parser, TOKEN_ERB_START)) {
           parser_append_literal_node_from_buffer(parser, &buffer, children, start);
@@ -445,7 +446,7 @@ static AST_HTML_ATTRIBUTE_VALUE_NODE_T* parser_parse_quoted_html_attribute_value
 
   token_T* closing_quote = parser_consume_expected(parser, TOKEN_QUOTE, errors);
 
-  if (opening_quote != NULL && closing_quote != NULL && strcmp(opening_quote->value, closing_quote->value) != 0) {
+  if (opening_quote != NULL && closing_quote != NULL && !string_equals(opening_quote->value, closing_quote->value)) {
     append_quotes_mismatch_error(
       opening_quote,
       closing_quote,

data/vendor/prism/config.yml

@@ -1269,17 +1269,17 @@ nodes:
       - name: opening_loc
         type: location
         comment: |
-          Represents the location of the opening `|`.
+          Represents the location of the opening `{` or `do`.
 
               [1, 2, 3].each { |i| puts x }
-                               ^
+                             ^
       - name: closing_loc
         type: location
         comment: |
-          Represents the location of the closing `|`.
+          Represents the location of the closing `}` or `end`.
 
               [1, 2, 3].each { |i| puts x }
-                                 ^
+                                          ^
     comment: |
       Represents a block of ruby code.
 

data/vendor/prism/include/prism/ast.h

@@ -1826,20 +1826,20 @@ typedef struct pm_block_node {
     /**
      * BlockNode#opening_loc
      *
-     * Represents the location of the opening `|`.
+     * Represents the location of the opening `{` or `do`.
      *
      *     [1, 2, 3].each { |i| puts x }
-     *                      ^
+     *                    ^
      */
     pm_location_t opening_loc;
 
     /**
      * BlockNode#closing_loc
      *
-     * Represents the location of the closing `|`.
+     * Represents the location of the closing `}` or `end`.
      *
      *     [1, 2, 3].each { |i| puts x }
-     *                        ^
+     *                                 ^
      */
     pm_location_t closing_loc;
 } pm_block_node_t;

data/vendor/prism/include/prism/version.h

@@ -14,7 +14,7 @@
 /**
  * The minor version of the Prism library as an int.
  */
-#define PRISM_VERSION_MINOR 8
+#define PRISM_VERSION_MINOR 9
 
 /**
  * The patch version of the Prism library as an int.
@@ -24,6 +24,6 @@
 /**
  * The version of the Prism library as a constant string.
  */
-#define PRISM_VERSION "1.8.0"
+#define PRISM_VERSION "1.9.0"
 
 #endif

data/vendor/prism/src/prism.c

@@ -12438,7 +12438,7 @@ expect1_opening(pm_parser_t *parser, pm_token_type_t type, pm_diagnostic_id_t di
 
     pm_parser_err(parser, opening->start, opening->end, diag_id);
 
-    parser->previous.start = opening->end;
+    parser->previous.start = parser->previous.end;
     parser->previous.type = PM_TOKEN_MISSING;
 }
 

data/vendor/prism/templates/java/org/prism/Loader.java.erb

@@ -101,7 +101,7 @@ public class Loader {
         expect((byte) 'M', "incorrect prism header");
 
         expect((byte) 1, "prism major version does not match");
-        expect((byte) 8, "prism minor version does not match");
+        expect((byte) 9, "prism minor version does not match");
         expect((byte) 0, "prism patch version does not match");
 
         expect((byte) 1, "Loader.java requires no location fields in the serialized output");

data/vendor/prism/templates/javascript/src/deserialize.js.erb

@@ -1,7 +1,7 @@
 import * as nodes from "./nodes.js";
 
 const MAJOR_VERSION = 1;
-const MINOR_VERSION = 8;
+const MINOR_VERSION = 9;
 const PATCH_VERSION = 0;
 
 // The DataView getFloat64 function takes an optional second argument that

data/vendor/prism/templates/lib/prism/node.rb.erb

@@ -183,25 +183,13 @@ module Prism
     def tunnel(line, column)
       queue = [self] #: Array[Prism::node]
       result = [] #: Array[Prism::node]
+      offset = source.byte_offset(line, column)
 
       while (node = queue.shift)
         result << node
 
         node.each_child_node do |child_node|
-          child_location = child_node.location
-
-          start_line = child_location.start_line
-          end_line = child_location.end_line
-
-          if start_line == end_line
-            if line == start_line && column >= child_location.start_column && column < child_location.end_column
-              queue << child_node
-              break
-            end
-          elsif (line == start_line && column >= child_location.start_column) || (line == end_line && column < child_location.end_column)
-            queue << child_node
-            break
-          elsif line > start_line && line < end_line
+          if child_node.start_offset <= offset && offset < child_node.end_offset
             queue << child_node
             break
           end
@@ -212,7 +200,7 @@ module Prism
     end
 
     # Returns the first node that matches the given block when visited in a
-    # depth-first search. This is useful for finding a node that matches a
+    # breadth-first search. This is useful for finding a node that matches a
     # particular condition.
     #
     #     node.breadth_first_search { |node| node.node_id == node_id }
@@ -227,6 +215,26 @@ module Prism
 
       nil
     end
+    alias find breadth_first_search
+
+    # Returns all of the nodes that match the given block when visited in a
+    # breadth-first search. This is useful for finding all nodes that match a
+    # particular condition.
+    #
+    #     node.breadth_first_search_all { |node| node.is_a?(Prism::CallNode) }
+    #
+    def breadth_first_search_all(&block)
+      queue = [self] #: Array[Prism::node]
+      results = [] #: Array[Prism::node]
+
+      while (node = queue.shift)
+        results << node if yield node
+        queue.concat(node.compact_child_nodes)
+      end
+
+      results
+    end
+    alias find_all breadth_first_search_all
 
     # Returns a list of the fields that exist for this node class. Fields
     # describe the structure of the node. This kind of reflection is useful for

data/vendor/prism/templates/lib/prism/serialize.rb.erb

@@ -10,7 +10,7 @@ module Prism
 
     # The minor version of prism that we are expecting to find in the serialized
     # strings.
-    MINOR_VERSION = 8
+    MINOR_VERSION = 9
 
     # The patch version of prism that we are expecting to find in the serialized
     # strings.

data/vendor/prism/templates/rbi/prism/node.rbi.erb

@@ -49,6 +49,9 @@ class Prism::Node
   sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T.nilable(Prism::Node)) }
   def breadth_first_search(&block); end
 
+  sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T::Array[Prism::Node]) }
+  def breadth_first_search_all(&block); end
+
   sig { abstract.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
 

data/vendor/prism/templates/sig/prism/node.rbs.erb

@@ -25,6 +25,9 @@ module Prism
     def to_dot: () -> String
     def tunnel: (Integer line, Integer column) -> Array[Prism::node]
     def breadth_first_search: () { (Prism::node) -> bool } -> Prism::node?
+    alias find breadth_first_search
+    def breadth_first_search_all: () { (Prism::node) -> bool } -> Array[Prism::node]
+    alias find_all breadth_first_search_all
     def newline!: (Array[untyped]) -> void
 
     def save: (_Repository repository) -> void

data/vendor/prism/templates/sig/prism.rbs.erb

@@ -23,15 +23,16 @@ module Prism
 
   def self.<%= method %>: (
     String source,
+    ?command_line: String,
     ?encoding: Encoding | false,
     ?filepath: String,
     ?freeze: bool,
     ?frozen_string_literal: bool,
     ?line: Integer,
     ?main_script: bool,
-    ?offset: Integer,
+    ?partial_script: bool,
     ?scopes: Array[Array[Symbol]],
-    ?verbose: bool
+    ?version: String
   ) -> <%= return_type %>
   <%- end -%>
 
@@ -41,10 +42,6 @@ module Prism
     ?bool freeze
   ) -> ParseResult
 
-  def self.lex_ripper: (
-    String source
-  ) -> Array[[[Integer, Integer], Symbol, String, untyped]]
-
   # Methods taking a path to a Ruby file:
   <%-
     {
@@ -61,14 +58,15 @@ module Prism
 
   def self.<%= method %>: (
     String filepath,
+    ?command_line: String,
     ?encoding: Encoding | false,
     ?freeze: bool,
     ?frozen_string_literal: bool,
     ?line: Integer,
     ?main_script: bool,
-    ?offset: Integer,
+    ?partial_script: bool,
     ?scopes: Array[Array[Symbol]],
-    ?verbose: bool
+    ?version: String
   ) -> <%= return_type %>
   <%- end -%>
 
@@ -78,15 +76,16 @@ module Prism
 
   def self.parse_stream: (
     _Stream stream,
+    ?command_line: String,
     ?encoding: Encoding | false,
     ?filepath: String,
     ?freeze: bool,
     ?frozen_string_literal: bool,
     ?line: Integer,
     ?main_script: bool,
-    ?offset: Integer,
+    ?partial_script: bool,
     ?scopes: Array[Array[Symbol]],
-    ?verbose: bool
+    ?version: String
   ) -> ParseResult
 
   def self.scope: (?locals: Array[Symbol], ?forwarding: Array[Symbol]) -> Scope

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.8.9
+  version: 0.8.10
 platform: ruby
 authors:
 - Marco Roth
@@ -148,6 +148,7 @@ files:
 - src/include/util/hb_narray.h
 - src/include/util/hb_string.h
 - src/include/util/hb_system.h
+- src/include/util/string.h
 - src/include/version.h
 - src/include/visitor.h
 - src/io.c