herb 0.10.1-arm-linux-gnu → 0.10.3-arm-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c50af1ad11b3ef398a89914a8750846b1ca78043493cf043e74d9103a538d36d
-  data.tar.gz: 0f990d09eafb6f3b2b33146b6c70c371a430bfbd195d5503773cb23c11500c52
+  metadata.gz: 0216afda4c85b7e2509251face5bc516c057ba8bc9282666bec6aa8eddecd4fd
+  data.tar.gz: 0fd52650bda4254b48c5e8e50c3e4033448520eb05f4c8a1f7b96ccde3638342
 SHA512:
-  metadata.gz: d376f262651fdd09f9979d8a449f85f019fb2a48d7631fe197952439a5662db8dd8030bfdeb9049e73acd7de9e5acd534c74d29c0e4b1ad4e5d551c5ef96321e
-  data.tar.gz: c3aca47f9b6575930a31888de3166b79fc7d97335b8e801fba94d4855665ac59bae392e5866e7efe65a601a427c6bec348f25f72ea1a6b8d5ba1dde8dac7c840
+  metadata.gz: 88e3352adad7331dea737ed9cff30b439d7a4fd4245d2437ba652d7b85328d5fa7ef2381609b70f685c72684c2f98129ee776ac42dd190c4e5839394dd7d9210
+  data.tar.gz: 97ba9f70499b6ae5d6f5b0b59a1f085240a75a6d83709b19ec008ef79de8759105f20bd15af6c4a8be3a392ce5889d86ca18eddebc82f3a9b5a65a1e8da133a6

data/Makefile

@@ -53,7 +53,7 @@ production_flags = $(warning_flags) -O3 -march=native -flto
 shared_library_flags = -fPIC
 
 # Default build mode (change this as needed)
-flags = $(warning_flags) $(debug_flags) $(prism_flags) -std=c99
+flags = $(warning_flags) $(debug_flags) $(prism_flags) -std=gnu99
 
 # Separate test compilation flags
 test_flags = $(debug_flags) $(prism_flags) -std=gnu99

data/config.yml

@@ -486,6 +486,16 @@ errors:
         - name: segment
           type: token
 
+    - name: TimeoutError
+      message:
+        template: "Parsing timed out after %zu ms."
+        arguments:
+          - timeout_ms
+
+      fields:
+        - name: timeout_ms
+          type: size_t
+
 warnings:
   fields: []
   types: []

data/ext/herb/error_helpers.c

@@ -53,6 +53,7 @@ static VALUE cStrictLocalsMissingParenthesisError;
 static VALUE cStrictLocalsDuplicateDeclarationError;
 static VALUE cVoidElementContentError;
 static VALUE cDotNotationCasingError;
+static VALUE cTimeoutError;
 
 void rb_init_error_classes(void) {
   mErrors = rb_define_module_under(mHerb, "Errors");
@@ -94,6 +95,7 @@ void rb_init_error_classes(void) {
   cStrictLocalsDuplicateDeclarationError = rb_define_class_under(mErrors, "StrictLocalsDuplicateDeclarationError", cError);
   cVoidElementContentError = rb_define_class_under(mErrors, "VoidElementContentError", cError);
   cDotNotationCasingError = rb_define_class_under(mErrors, "DotNotationCasingError", cError);
+  cTimeoutError = rb_define_class_under(mErrors, "TimeoutError", cError);
 }
 
 static VALUE rb_unexpected_error_from_c_struct(UNEXPECTED_ERROR_T* unexpected_error) {
@@ -906,6 +908,27 @@ static VALUE rb_dot_notation_casing_error_from_c_struct(DOT_NOTATION_CASING_ERRO
   return rb_class_new_instance(4, args, cDotNotationCasingError);
 };
 
+static VALUE rb_timeout_error_from_c_struct(TIMEOUT_ERROR_T* timeout_error) {
+  if (timeout_error == NULL) { return Qnil; }
+
+  ERROR_T* error = &timeout_error->base;
+
+  VALUE type = rb_string_from_hb_string(error_type_to_string(error));
+  VALUE location = rb_location_from_c_struct(error->location);
+  VALUE message = rb_string_from_hb_string(error->message);
+
+  VALUE timeout_error_timeout_ms = ULONG2NUM(timeout_error->timeout_ms);
+
+  VALUE args[4] = {
+    type,
+    location,
+    message,
+    timeout_error_timeout_ms
+  };
+
+  return rb_class_new_instance(4, args, cTimeoutError);
+};
+
 
 VALUE rb_error_from_c_struct(ERROR_T* error) {
   if (!error) { return Qnil; }
@@ -948,6 +971,7 @@ VALUE rb_error_from_c_struct(ERROR_T* error) {
     case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: return rb_strict_locals_duplicate_declaration_error_from_c_struct((STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T*) error); break;
     case VOID_ELEMENT_CONTENT_ERROR: return rb_void_element_content_error_from_c_struct((VOID_ELEMENT_CONTENT_ERROR_T*) error); break;
     case DOT_NOTATION_CASING_ERROR: return rb_dot_notation_casing_error_from_c_struct((DOT_NOTATION_CASING_ERROR_T*) error); break;
+    case TIMEOUT_ERROR: return rb_timeout_error_from_c_struct((TIMEOUT_ERROR_T*) error); break;
   }
 
   return Qnil;

data/ext/herb/extension.c

@@ -174,6 +174,21 @@ static VALUE Herb_parse(int argc, VALUE* argv, VALUE self) {
     if (NIL_P(html)) { html = rb_hash_lookup(options, ID2SYM(rb_intern("html"))); }
     if (!NIL_P(html) && !RTEST(html)) { parser_options.html = false; }
 
+    VALUE timeout = rb_hash_lookup(options, rb_utf8_str_new_cstr("timeout"));
+    if (NIL_P(timeout)) { timeout = rb_hash_lookup(options, ID2SYM(rb_intern("timeout"))); }
+    if (!NIL_P(timeout)) { parser_options.timeout_ms = (uint32_t) (NUM2DBL(timeout) * 1000); }
+
+    VALUE max_errors_sentinel = ID2SYM(rb_intern("__not_set__"));
+    VALUE max_errors = rb_hash_lookup2(options, rb_utf8_str_new_cstr("max_errors"), max_errors_sentinel);
+
+    if (max_errors == max_errors_sentinel) {
+      max_errors = rb_hash_lookup2(options, ID2SYM(rb_intern("max_errors")), max_errors_sentinel);
+    }
+
+    if (max_errors != max_errors_sentinel) {
+      parser_options.max_errors = NIL_P(max_errors) ? 0 : (uint32_t) NUM2UINT(max_errors);
+    }
+
     VALUE arena_stats = rb_hash_lookup(options, rb_utf8_str_new_cstr("arena_stats"));
     if (NIL_P(arena_stats)) { arena_stats = rb_hash_lookup(options, ID2SYM(rb_intern("arena_stats"))); }
     if (!NIL_P(arena_stats) && RTEST(arena_stats)) { print_arena_stats = true; }

data/ext/herb/extension_helpers.c

@@ -95,6 +95,13 @@ VALUE create_parse_result(AST_DOCUMENT_NODE_T* root, VALUE source, const parser_
   rb_hash_aset(kwargs, ID2SYM(rb_intern("prism_nodes")), options->prism_nodes ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("prism_nodes_deep")), options->prism_nodes_deep ? Qtrue : Qfalse);
   rb_hash_aset(kwargs, ID2SYM(rb_intern("prism_program")), options->prism_program ? Qtrue : Qfalse);
+  rb_hash_aset(kwargs, ID2SYM(rb_intern("timeout")), DBL2NUM((double) options->timeout_ms / 1000.0));
+
+  rb_hash_aset(
+    kwargs,
+    ID2SYM(rb_intern("max_errors")),
+    options->max_errors == 0 ? Qnil : UINT2NUM(options->max_errors)
+  );
 
   VALUE parser_options_args[1] = { kwargs };
   VALUE parser_options = rb_class_new_instance_kw(1, parser_options_args, cParserOptions, RB_PASS_KEYWORDS);

data/herb.gemspec

@@ -31,6 +31,7 @@ Gem::Specification.new do |spec|
     "lib/**/*.rb",
     "lib/**/*.yml",
     "sig/**/*.rbs",
+    "sig/manifest.yaml",
     "src/**/*.{c,h}",
     "ext/**/*.{c,h}",
     "templates/**/*.{rb,erb}",

data/lib/herb/action_view/render_analyzer.rb

@@ -784,7 +784,7 @@ module Herb
       def ensure_parallel!
         return if defined?(Parallel)
 
-        Herb.ensure_installed { gem "parallel" } # steep:ignore
+        Herb.ensure_installed { gem "parallel" }
       end
 
       def collect_ruby_render_references

data/lib/herb/cli.rb

@@ -8,7 +8,7 @@ require "optparse"
 class Herb::CLI
   include Herb::Colors
 
-  attr_accessor :json, :silent, :log_file, :no_timing, :local, :escape, :no_escape, :freeze, :debug, :tool, :strict, :analyze, :track_whitespace, :verbose, :isolate, :arena_stats, :leak_check, :action_view_helpers, :trim, :optimize
+  attr_accessor :json, :silent, :log_file, :no_timing, :local, :escape, :no_escape, :freeze, :debug, :tool, :strict, :analyze, :track_whitespace, :verbose, :isolate, :arena_stats, :leak_check, :action_view_helpers, :trim, :optimize, :file_timeout
 
   def initialize(args)
     @args = args
@@ -154,6 +154,7 @@ class Herb::CLI
                   project.silent = silent
                   project.verbose = verbose || ci?
                   project.isolate = isolate
+                  project.file_timeout = file_timeout if file_timeout
                   project.validate_ruby = true
                   project.arena_stats = arena_stats
                   project.leak_check = leak_check
@@ -269,6 +270,10 @@ class Herb::CLI
         self.isolate = true
       end
 
+      parser.on("--timeout SECONDS", Float, "Per-file timeout for parse + compile (for analyze command) (default: #{Herb::Project::DEFAULT_FILE_TIMEOUT})") do |seconds|
+        self.file_timeout = seconds
+      end
+
       parser.on("--log-file", "Enable log file generation") do
         self.log_file = true
       end

data/lib/herb/engine/debug_visitor.rb

@@ -336,7 +336,7 @@ module Herb
       end
 
       def in_excluded_context?
-        excluded_tags = ["script", "style", "head", "textarea", "pre", "svg", "math"]
+        excluded_tags = ["script", "style", "head", "title", "textarea", "pre", "svg", "math"]
         return true if excluded_tags.any? { |tag| @element_stack.include?(tag) }
 
         if @erb_block_stack.any? { |node| javascript_tag?(node.content.value.strip) || include_debug_disable_comment?(node.content.value.strip) }

data/lib/herb/engine/parser_error_overlay.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "digest"
+
 module Herb
   class Engine
     class ParserErrorOverlay

data/lib/herb/errors.rb

@@ -1526,5 +1526,44 @@ module Herb
       end
     end
 
+    class TimeoutError < Error
+      include Colors
+
+      #|  timeout_ms: Integer?,
+      #| }
+
+      attr_reader :timeout_ms #: Integer?
+
+      #: (String, Location?, String, Integer) -> void
+      def initialize(type, location, message, timeout_ms)
+        super(type, location, message)
+        @timeout_ms = timeout_ms
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_timeout_error
+      def to_hash
+        super.merge(
+          timeout_ms: timeout_ms
+        ) #: Herb::serialized_timeout_error
+      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 += white("└── timeout_ms: #{green(timeout_ms.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
   end
 end

data/lib/herb/parser_options.rb

@@ -12,6 +12,8 @@ module Herb
     attr_reader :prism_program #: bool
     attr_reader :prism_nodes #: bool
     attr_reader :prism_nodes_deep #: bool
+    attr_reader :timeout #: Numeric
+    attr_reader :max_errors #: Integer?
 
     DEFAULT_STRICT = true #: bool
     DEFAULT_TRACK_WHITESPACE = false #: bool
@@ -23,9 +25,11 @@ module Herb
     DEFAULT_PRISM_PROGRAM = false #: bool
     DEFAULT_PRISM_NODES = false #: bool
     DEFAULT_PRISM_NODES_DEEP = false #: bool
+    DEFAULT_TIMEOUT = 1 #: Numeric
+    DEFAULT_MAX_ERRORS = 25 #: Integer
 
-    #: (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?render_nodes: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool) -> void
-    def initialize(strict: DEFAULT_STRICT, track_whitespace: DEFAULT_TRACK_WHITESPACE, analyze: DEFAULT_ANALYZE, action_view_helpers: DEFAULT_ACTION_VIEW_HELPERS, transform_conditionals: DEFAULT_TRANSFORM_CONDITIONALS, render_nodes: DEFAULT_RENDER_NODES, strict_locals: DEFAULT_STRICT_LOCALS, prism_nodes: DEFAULT_PRISM_NODES, prism_nodes_deep: DEFAULT_PRISM_NODES_DEEP, prism_program: DEFAULT_PRISM_PROGRAM)
+    #: (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?render_nodes: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?timeout: Numeric) -> void
+    def initialize(strict: DEFAULT_STRICT, track_whitespace: DEFAULT_TRACK_WHITESPACE, analyze: DEFAULT_ANALYZE, action_view_helpers: DEFAULT_ACTION_VIEW_HELPERS, transform_conditionals: DEFAULT_TRANSFORM_CONDITIONALS, render_nodes: DEFAULT_RENDER_NODES, strict_locals: DEFAULT_STRICT_LOCALS, prism_nodes: DEFAULT_PRISM_NODES, prism_nodes_deep: DEFAULT_PRISM_NODES_DEEP, prism_program: DEFAULT_PRISM_PROGRAM, timeout: DEFAULT_TIMEOUT, max_errors: DEFAULT_MAX_ERRORS)
       @strict = strict
       @track_whitespace = track_whitespace
       @analyze = analyze
@@ -36,9 +40,11 @@ module Herb
       @prism_nodes = prism_nodes
       @prism_nodes_deep = prism_nodes_deep
       @prism_program = prism_program
+      @timeout = timeout
+      @max_errors = max_errors
     end
 
-    #: () -> Hash[Symbol, bool]
+    #: () -> Hash[Symbol, (bool | Numeric | nil)]
     def to_h
       {
         strict: @strict,
@@ -51,6 +57,8 @@ module Herb
         prism_nodes: @prism_nodes,
         prism_nodes_deep: @prism_nodes_deep,
         prism_program: @prism_program,
+        timeout: @timeout,
+        max_errors: @max_errors,
       }
     end
 
@@ -66,7 +74,9 @@ module Herb
         "strict_locals=#{@strict_locals}\n  " \
         "prism_nodes=#{@prism_nodes}\n  " \
         "prism_nodes_deep=#{@prism_nodes_deep}\n  " \
-        "prism_program=#{@prism_program}>"
+        "prism_program=#{@prism_program}\n  " \
+        "timeout=#{@timeout}\n  " \
+        "max_errors=#{@max_errors}>"
     end
   end
 end

data/lib/herb/project.rb

@@ -12,7 +12,9 @@ module Herb
   class Project
     include Colors
 
-    attr_accessor :project_path, :output_file, :no_log_file, :no_timing, :silent, :verbose, :isolate, :validate_ruby, :file_paths, :arena_stats, :leak_check
+    attr_accessor :project_path, :output_file, :no_log_file, :no_timing, :silent, :verbose, :isolate, :validate_ruby, :file_paths, :arena_stats, :leak_check, :file_timeout
+
+    DEFAULT_FILE_TIMEOUT = 1 # seconds per file for parse + compile
 
     # Known error types that indicate issues in the user's template, not bugs in the parser.
     TEMPLATE_ERRORS = [
@@ -126,6 +128,7 @@ module Herb
 
       date = Time.now.strftime("%Y-%m-%d_%H-%M-%S")
       @output_file = output_file || "#{date}_erb_parsing_result_#{@project_path.basename}.log"
+      @file_timeout = DEFAULT_FILE_TIMEOUT
     end
 
     def configuration
@@ -354,7 +357,7 @@ module Herb
         result[:leak_check] = capture_leak_check(file_content)
       end
 
-      Timeout.timeout(1) do
+      Timeout.timeout(file_timeout) do
         parse_result = Herb.parse(file_content)
 
         if parse_result.failed?
@@ -369,7 +372,7 @@ module Herb
       result
     rescue Timeout::Error
       result.merge(status: :timeout, file_content: file_content,
-                   log: "⏱️ Parsing #{file_path} timed out after 1 second")
+                   log: "⏱️ Parsing #{file_path} timed out after #{file_timeout} #{pluralize(file_timeout, "second")}")
     rescue StandardError => e
       file_content ||= begin
         File.read(file_path)
@@ -388,7 +391,7 @@ module Herb
       stdout_file = Tempfile.new("stdout")
       stderr_file = Tempfile.new("stderr")
 
-      Timeout.timeout(1) do
+      Timeout.timeout(file_timeout) do
         pid = Process.fork do
           $stdout.reopen(stdout_file.path, "w")
           $stderr.reopen(stderr_file.path, "w")
@@ -431,7 +434,7 @@ module Herb
         nil
       end
 
-      { file_path: file_path, status: :timeout, file_content: file_content, log: "⏱️ Parsing #{file_path} timed out after 1 second" }
+      { file_path: file_path, status: :timeout, file_content: file_content, log: "⏱️ Parsing #{file_path} timed out after #{file_timeout} #{pluralize(file_timeout, "second")}" }
     rescue StandardError => e
       file_content ||= begin
         File.read(file_path)

data/lib/herb/version.rb

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

data/sig/herb/errors.rbs

@@ -694,5 +694,23 @@ module Herb
       # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
       def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
     end
+
+    class TimeoutError < Error
+      include Colors
+
+      attr_reader timeout_ms: Integer?
+
+      # : (String, Location?, String, Integer) -> void
+      def initialize: (String, Location?, String, Integer) -> void
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : () -> serialized_timeout_error
+      def to_hash: () -> serialized_timeout_error
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
   end
 end

data/sig/herb/parser_options.rbs

@@ -22,6 +22,10 @@ module Herb
 
     attr_reader prism_nodes_deep: bool
 
+    attr_reader timeout: Numeric
+
+    attr_reader max_errors: Integer?
+
     DEFAULT_STRICT: bool
 
     DEFAULT_TRACK_WHITESPACE: bool
@@ -42,11 +46,15 @@ module Herb
 
     DEFAULT_PRISM_NODES_DEEP: bool
 
-    # : (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?render_nodes: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool) -> void
-    def initialize: (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?render_nodes: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool) -> void
+    DEFAULT_TIMEOUT: Numeric
+
+    DEFAULT_MAX_ERRORS: Integer
+
+    # : (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?render_nodes: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?timeout: Numeric) -> void
+    def initialize: (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?transform_conditionals: bool, ?render_nodes: bool, ?strict_locals: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool, ?timeout: Numeric) -> void
 
-    # : () -> Hash[Symbol, bool]
-    def to_h: () -> Hash[Symbol, bool]
+    # : () -> Hash[Symbol, (bool | Numeric | nil)]
+    def to_h: () -> Hash[Symbol, bool | Numeric | nil]
 
     # : () -> String
     def inspect: () -> String

data/sig/manifest.yaml

@@ -0,0 +1,13 @@
+dependencies:
+  - name: delegate
+  - name: did_you_mean
+  - name: fileutils
+  - name: json
+  - name: optparse
+  - name: pathname
+  - name: socket
+  - name: stringio
+  - name: tempfile
+  - name: time
+  - name: timeout
+  - name: yaml

data/sig/serialized_ast_errors.rbs

@@ -169,4 +169,8 @@ module Herb
     segment: Herb::Token,
   }
 
+  type serialized_timeout_error = serialized_error & {
+    timeout_ms: Integer,
+  }
+
 end

data/src/analyze/action_view/tag_helpers.c

@@ -5,6 +5,7 @@
 #include "../../include/analyze/analyze.h"
 #include "../../include/ast/ast_nodes.h"
 #include "../../include/herb.h"
+#include "../../include/lexer/token.h"
 #include "../../include/lib/hb_allocator.h"
 #include "../../include/lib/hb_array.h"
 #include "../../include/lib/hb_buffer.h"
@@ -1426,6 +1427,8 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
     if (child->type == AST_ERB_BLOCK_NODE) {
       AST_ERB_BLOCK_NODE_T* block_node = (AST_ERB_BLOCK_NODE_T*) child;
 
+      if (token_is_escaped_erb_tag_opening(block_node->tag_opening)) { continue; }
+
       if (block_node->tag_opening && !hb_string_is_empty(block_node->tag_opening->value)) {
         const char* opening_string = block_node->tag_opening->value.data;
         if (opening_string && strstr(opening_string, "=") == NULL) { continue; }
@@ -1455,6 +1458,8 @@ void transform_tag_helper_array(hb_array_T* array, analyze_ruby_context_T* conte
       AST_ERB_CONTENT_NODE_T* erb_node = (AST_ERB_CONTENT_NODE_T*) child;
       token_T* tag_opening = erb_node->tag_opening;
 
+      if (token_is_escaped_erb_tag_opening(tag_opening)) { continue; }
+
       if (tag_opening && !hb_string_is_empty(tag_opening->value)) {
         const char* opening_string = tag_opening->value.data;
 

data/src/analyze/analyze_helpers.c

@@ -277,7 +277,13 @@ 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++; }
+  if (node->type == PM_CASE_MATCH_NODE) {
+    const pm_case_match_node_t* case_match_node = (const pm_case_match_node_t*) node;
+
+    if (case_match_node->predicate != NULL && case_match_node->predicate->type == PM_MATCH_PREDICATE_NODE) {
+      analyzed->in_node_count++;
+    }
+  }
 
   pm_visit_child_nodes(node, search_in_nodes, analyzed);
 

data/src/analyze/control_type.c

@@ -110,11 +110,10 @@ static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* da
       if (call->block != NULL && call->block->type == PM_BLOCK_NODE) {
         pm_block_node_t* block_node = (pm_block_node_t*) call->block;
 
-        bool has_do_opening = is_do_block(block_node->opening_loc);
-        bool has_brace_opening = is_brace_block(block_node->opening_loc);
-        bool has_valid_brace_closing = is_closing_brace(block_node->closing_loc);
+        bool has_opening = is_do_block(block_node->opening_loc) || is_brace_block(block_node->opening_loc);
+        bool is_unclosed = !has_valid_block_closing(block_node->opening_loc, block_node->closing_loc);
 
-        if (has_do_opening || (has_brace_opening && !has_valid_brace_closing)) {
+        if (has_opening && is_unclosed) {
           current_type = CONTROL_TYPE_BLOCK;
           keyword_offset = (uint32_t) (node->location.start - context->source_start);
         }
@@ -125,11 +124,10 @@ static bool find_earliest_control_keyword_walker(const pm_node_t* node, void* da
     case PM_LAMBDA_NODE: {
       pm_lambda_node_t* lambda = (pm_lambda_node_t*) node;
 
-      bool has_do_opening = is_do_block(lambda->opening_loc);
-      bool has_brace_opening = is_brace_block(lambda->opening_loc);
-      bool has_valid_brace_closing = is_closing_brace(lambda->closing_loc);
+      bool has_opening = is_do_block(lambda->opening_loc) || is_brace_block(lambda->opening_loc);
+      bool is_unclosed = !has_valid_block_closing(lambda->opening_loc, lambda->closing_loc);
 
-      if (has_do_opening || (has_brace_opening && !has_valid_brace_closing)) {
+      if (has_opening && is_unclosed) {
         current_type = CONTROL_TYPE_BLOCK;
         keyword_offset = (uint32_t) (node->location.start - context->source_start);
       }

data/src/analyze/render_nodes.c

@@ -5,6 +5,7 @@
 #include "../include/analyze/helpers.h"
 #include "../include/ast/ast_nodes.h"
 #include "../include/errors.h"
+#include "../include/lexer/token.h"
 #include "../include/lib/hb_allocator.h"
 #include "../include/lib/hb_array.h"
 #include "../include/lib/hb_string.h"
@@ -811,6 +812,7 @@ static AST_ERB_RENDER_NODE_T* try_transform_content_node(
 ) {
   if (!erb_node->analyzed_ruby || !erb_node->analyzed_ruby->valid || !erb_node->analyzed_ruby->parsed) { return NULL; }
   if (is_erb_comment_tag(erb_node->tag_opening)) { return NULL; }
+  if (token_is_escaped_erb_tag_opening(erb_node->tag_opening)) { return NULL; }
 
   pm_call_node_t* render_call = find_render_call(erb_node->analyzed_ruby->root, &erb_node->analyzed_ruby->parser);
   if (!render_call) { return NULL; }
@@ -840,6 +842,7 @@ static AST_ERB_RENDER_NODE_T* try_transform_block_node(
   analyze_ruby_context_T* context
 ) {
   if (!block_node->content || hb_string_is_empty(block_node->content->value)) { return NULL; }
+  if (token_is_escaped_erb_tag_opening(block_node->tag_opening)) { return NULL; }
 
   const char* ruby_source = block_node->content->value.data;
   size_t ruby_length = block_node->content->value.length;

data/src/errors.c

@@ -1248,6 +1248,33 @@ void append_dot_notation_casing_error(token_T* segment, position_T start, positi
   hb_array_append(errors, dot_notation_casing_error_init(segment, start, end, allocator));
 }
 
+TIMEOUT_ERROR_T* timeout_error_init(size_t timeout_ms, position_T start, position_T end, hb_allocator_T* allocator) {
+  TIMEOUT_ERROR_T* timeout_error = hb_allocator_alloc(allocator, sizeof(TIMEOUT_ERROR_T));
+
+  if (!timeout_error) { return NULL; }
+
+  error_init(&timeout_error->base, TIMEOUT_ERROR, start, end);
+
+  const char* message_template = "Parsing timed out after %zu ms.";
+
+  char message[52];
+  snprintf(
+    message,
+    sizeof(message),
+    message_template,
+    timeout_ms
+  );
+
+  timeout_error->base.message = hb_string_copy(hb_string(message), allocator);
+
+  timeout_error->timeout_ms = timeout_ms;
+  return timeout_error;
+}
+
+void append_timeout_error(size_t timeout_ms, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors) {
+  hb_array_append(errors, timeout_error_init(timeout_ms, start, end, allocator));
+}
+
 hb_string_T error_type_to_string(ERROR_T* error) {
   switch (error->type) {
     case UNEXPECTED_ERROR: return hb_string("UNEXPECTED_ERROR");
@@ -1287,6 +1314,7 @@ hb_string_T error_type_to_string(ERROR_T* error) {
     case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: return hb_string("STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR");
     case VOID_ELEMENT_CONTENT_ERROR: return hb_string("VOID_ELEMENT_CONTENT_ERROR");
     case DOT_NOTATION_CASING_ERROR: return hb_string("DOT_NOTATION_CASING_ERROR");
+    case TIMEOUT_ERROR: return hb_string("TIMEOUT_ERROR");
   }
 
   return hb_string("Unknown error_type_T");
@@ -1331,6 +1359,7 @@ hb_string_T error_human_type(ERROR_T* error) {
     case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: return hb_string("StrictLocalsDuplicateDeclarationError");
     case VOID_ELEMENT_CONTENT_ERROR: return hb_string("VoidElementContentError");
     case DOT_NOTATION_CASING_ERROR: return hb_string("DotNotationCasingError");
+    case TIMEOUT_ERROR: return hb_string("TimeoutError");
   }
 
   return hb_string("Unknown error_type_T");
@@ -1588,6 +1617,12 @@ static void error_free_dot_notation_casing_error(DOT_NOTATION_CASING_ERROR_T* do
   error_free_base_error(&dot_notation_casing_error->base, allocator);
 }
 
+static void error_free_timeout_error(TIMEOUT_ERROR_T* timeout_error, hb_allocator_T* allocator) {
+  // size_t is part of struct
+
+  error_free_base_error(&timeout_error->base, allocator);
+}
+
 void error_free(ERROR_T* error, hb_allocator_T* allocator) {
   if (!error) { return; }
 
@@ -1629,6 +1664,7 @@ void error_free(ERROR_T* error, hb_allocator_T* allocator) {
     case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: error_free_strict_locals_duplicate_declaration_error((STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T*) error, allocator); break;
     case VOID_ELEMENT_CONTENT_ERROR: error_free_void_element_content_error((VOID_ELEMENT_CONTENT_ERROR_T*) error, allocator); break;
     case DOT_NOTATION_CASING_ERROR: error_free_dot_notation_casing_error((DOT_NOTATION_CASING_ERROR_T*) error, allocator); break;
+    case TIMEOUT_ERROR: error_free_timeout_error((TIMEOUT_ERROR_T*) error, allocator); break;
   }
 }
 
@@ -2212,6 +2248,20 @@ static void error_pretty_print_dot_notation_casing_error(DOT_NOTATION_CASING_ERR
   pretty_print_token_property(error->segment, hb_string("segment"), indent, relative_indent, true, buffer);
 }
 
+static void error_pretty_print_timeout_error(TIMEOUT_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_string(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"), error->base.message, indent, relative_indent, false, buffer);
+  pretty_print_size_t_property(error->timeout_ms, hb_string("timeout_ms"), 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; }
 
@@ -2253,6 +2303,7 @@ void error_pretty_print(ERROR_T* error, const size_t indent, const size_t relati
     case STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR: error_pretty_print_strict_locals_duplicate_declaration_error((STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR_T*) error, indent, relative_indent, buffer); break;
     case VOID_ELEMENT_CONTENT_ERROR: error_pretty_print_void_element_content_error((VOID_ELEMENT_CONTENT_ERROR_T*) error, indent, relative_indent, buffer); break;
     case DOT_NOTATION_CASING_ERROR: error_pretty_print_dot_notation_casing_error((DOT_NOTATION_CASING_ERROR_T*) error, indent, relative_indent, buffer); break;
+    case TIMEOUT_ERROR: error_pretty_print_timeout_error((TIMEOUT_ERROR_T*) error, indent, relative_indent, buffer); break;
   }
 }
 

data/src/herb.c

@@ -1,6 +1,7 @@
 #include "include/herb.h"
 #include "include/analyze/analyze.h"
 #include "include/analyze/prism_annotate.h"
+#include "include/errors.h"
 #include "include/lexer/lexer.h"
 #include "include/lexer/token.h"
 #include "include/lib/hb_allocator.h"
@@ -44,6 +45,11 @@ HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(
   parser_options_T parser_options = HERB_DEFAULT_PARSER_OPTIONS;
   if (options != NULL) { parser_options = *options; }
 
+  uint32_t error_count = 0;
+  parser_options.error_count = &error_count;
+
+  parser_options_set_deadline(&parser_options);
+
   if (parser_options.start_line > 0) {
     lexer.current_line = parser_options.start_line;
     lexer.previous_line = parser_options.start_line;
@@ -73,6 +79,16 @@ HERB_EXPORTED_FUNCTION AST_DOCUMENT_NODE_T* herb_parse(
     );
   }
 
+  if (parser_options_past_deadline(&parser_options)) {
+    append_timeout_error(
+      parser_options.timeout_ms,
+      document->base.location.start,
+      document->base.location.end,
+      allocator,
+      document->base.errors
+    );
+  }
+
   return document;
 }
 

data/src/include/errors.h

@@ -51,6 +51,7 @@ typedef enum {
   STRICT_LOCALS_DUPLICATE_DECLARATION_ERROR,
   VOID_ELEMENT_CONTENT_ERROR,
   DOT_NOTATION_CASING_ERROR,
+  TIMEOUT_ERROR,
 } error_type_T;
 
 typedef struct ERROR_STRUCT {
@@ -267,6 +268,11 @@ typedef struct {
   token_T* segment;
 } DOT_NOTATION_CASING_ERROR_T;
 
+typedef struct {
+  ERROR_T base;
+  size_t timeout_ms;
+} TIMEOUT_ERROR_T;
+
 UNEXPECTED_ERROR_T* unexpected_error_init(hb_string_T description, hb_string_T expected, hb_string_T found, position_T start, position_T end, hb_allocator_T* allocator);
 void append_unexpected_error(hb_string_T description, hb_string_T expected, hb_string_T found, position_T start, position_T end, hb_allocator_T* allocator, 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, hb_allocator_T* allocator);
@@ -341,6 +347,8 @@ VOID_ELEMENT_CONTENT_ERROR_T* void_element_content_error_init(token_T* tag_name,
 void append_void_element_content_error(token_T* tag_name, hb_string_T helper_name, hb_string_T content_type, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors);
 DOT_NOTATION_CASING_ERROR_T* dot_notation_casing_error_init(token_T* segment, position_T start, position_T end, hb_allocator_T* allocator);
 void append_dot_notation_casing_error(token_T* segment, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors);
+TIMEOUT_ERROR_T* timeout_error_init(size_t timeout_ms, position_T start, position_T end, hb_allocator_T* allocator);
+void append_timeout_error(size_t timeout_ms, position_T start, position_T end, hb_allocator_T* allocator, hb_array_T* errors);
 
 void error_init(ERROR_T* error, error_type_T type, position_T start, position_T end);
 

data/src/include/lexer/token.h

@@ -28,4 +28,6 @@ void token_free(token_T* token, hb_allocator_T* allocator);
 
 bool token_value_empty(const token_T* token);
 
+bool token_is_escaped_erb_tag_opening(const token_T* token);
+
 #endif

data/src/include/lib/hb_clock.h

@@ -0,0 +1,15 @@
+#ifndef HERB_CLOCK_H
+#define HERB_CLOCK_H
+
+#include <stdint.h>
+#include <time.h>
+
+static inline uint64_t hb_monotonic_ms(void) {
+  struct timespec now;
+
+  clock_gettime(CLOCK_MONOTONIC, &now);
+
+  return (uint64_t) now.tv_sec * 1000 + (uint64_t) now.tv_nsec / 1000000;
+}
+
+#endif

data/src/include/parser/parser.h

@@ -5,6 +5,7 @@
 #include "../lexer/lexer.h"
 #include "../lib/hb_allocator.h"
 #include "../lib/hb_array.h"
+#include "../lib/hb_clock.h"
 
 #include <stdint.h>
 
@@ -33,6 +34,10 @@ typedef struct PARSER_OPTIONS_STRUCT {
   bool html;
   uint32_t start_line;
   uint32_t start_column;
+  uint32_t timeout_ms;
+  uint32_t max_errors;
+  uint32_t* error_count;
+  uint64_t deadline_ms;
 } parser_options_T;
 
 typedef struct MATCH_TAGS_CONTEXT_STRUCT {
@@ -43,6 +48,29 @@ typedef struct MATCH_TAGS_CONTEXT_STRUCT {
 
 extern const parser_options_T HERB_DEFAULT_PARSER_OPTIONS;
 
+static inline bool parser_options_past_deadline(const parser_options_T* options) {
+  if (options == NULL || options->timeout_ms == 0) { return false; }
+
+  return hb_monotonic_ms() >= options->deadline_ms;
+}
+
+static inline bool parser_options_errors_exceeded(const parser_options_T* options) {
+  if (options == NULL || options->error_count == NULL) { return false; }
+  if (options->max_errors == 0) { return false; }
+
+  return *options->error_count >= options->max_errors;
+}
+
+static inline void parser_options_increment_error_count(const parser_options_T* options) {
+  if (options != NULL && options->error_count != NULL) { (*options->error_count)++; }
+}
+
+static inline void parser_options_set_deadline(parser_options_T* options) {
+  if (options->timeout_ms == 0) { return; }
+
+  options->deadline_ms = hb_monotonic_ms() + options->timeout_ms;
+}
+
 typedef struct PARSER_STRUCT {
   hb_allocator_T* allocator;
   lexer_T* lexer;

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.10.1"
+#define HERB_VERSION "0.10.3"
 
 #endif

data/src/lexer/token.c

@@ -228,6 +228,12 @@ bool token_value_empty(const token_T* token) {
   return token == NULL || hb_string_is_empty(token->value);
 }
 
+bool token_is_escaped_erb_tag_opening(const token_T* token) {
+  if (token_value_empty(token)) { return false; }
+
+  return hb_string_starts_with(token->value, hb_string("<%%"));
+}
+
 void token_free(token_T* token, hb_allocator_T* allocator) {
   if (!token) { return; }
 

data/src/parser.c

@@ -23,7 +23,6 @@
 #include <strings.h>
 
 #define MAX_CONSECUTIVE_ERRORS 10
-
 static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, hb_array_T* errors);
 static void parser_parse_foreign_content(parser_T* parser, hb_array_T* children, hb_array_T* errors);
 static AST_ERB_CONTENT_NODE_T* parser_parse_erb_tag(parser_T* parser);
@@ -48,7 +47,10 @@ const parser_options_T HERB_DEFAULT_PARSER_OPTIONS = { .track_whitespace = false
                                                        .dot_notation_tags = false,
                                                        .html = true,
                                                        .start_line = 0,
-                                                       .start_column = 0 };
+                                                       .start_column = 0,
+                                                       .timeout_ms = 1000,
+                                                       .max_errors = 25,
+                                                       .deadline_ms = 0 };
 
 size_t parser_sizeof(void) {
   return sizeof(struct PARSER_STRUCT);
@@ -1498,6 +1500,7 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
   }
 
   while (token_is_not(parser, TOKEN_EOF)) {
+    if (parser_options_past_deadline(&parser->options)) { break; }
 
     if (token_is(parser, TOKEN_ERB_START)) {
       hb_array_append(children, parser_parse_erb_tag(parser));
@@ -1601,11 +1604,18 @@ static void parser_parse_in_data_state(parser_T* parser, hb_array_T* children, h
   }
 }
 
-static size_t find_matching_close_tag(hb_array_T* nodes, size_t start_idx, hb_string_T tag_name) {
+static size_t find_matching_close_tag(
+  hb_array_T* nodes,
+  size_t start_index,
+  hb_string_T tag_name,
+  const parser_options_T* options
+) {
   int depth = 0;
 
-  for (size_t i = start_idx + 1; i < hb_array_size(nodes); i++) {
-    AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, i);
+  for (size_t index = start_index + 1; index < hb_array_size(nodes); index++) {
+    if (parser_options_past_deadline(options)) { return (size_t) -1; }
+
+    AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, index);
     if (node == NULL) { continue; }
 
     if (node->type == AST_HTML_OPEN_TAG_NODE) {
@@ -1616,7 +1626,7 @@ static size_t find_matching_close_tag(hb_array_T* nodes, size_t start_idx, hb_st
       AST_HTML_CLOSE_TAG_NODE_T* close = (AST_HTML_CLOSE_TAG_NODE_T*) node;
 
       if (hb_string_equals_case_insensitive(close->tag_name->value, tag_name)) {
-        if (depth == 0) { return i; }
+        if (depth == 0) { return index; }
         depth--;
       }
     }
@@ -1625,23 +1635,23 @@ static size_t find_matching_close_tag(hb_array_T* nodes, size_t start_idx, hb_st
   return (size_t) -1;
 }
 
-static size_t find_implicit_close_index(hb_array_T* nodes, size_t start_idx, hb_string_T tag_name) {
+static size_t find_implicit_close_index(hb_array_T* nodes, size_t start_index, hb_string_T tag_name) {
   if (!has_optional_end_tag(tag_name)) { return (size_t) -1; }
 
-  for (size_t i = start_idx + 1; i < hb_array_size(nodes); i++) {
-    AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, i);
+  for (size_t index = start_index + 1; index < hb_array_size(nodes); index++) {
+    AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, index);
     if (node == NULL) { continue; }
 
     if (node->type == AST_HTML_OPEN_TAG_NODE) {
       AST_HTML_OPEN_TAG_NODE_T* open = (AST_HTML_OPEN_TAG_NODE_T*) node;
       hb_string_T next_tag_name = open->tag_name->value;
 
-      if (should_implicitly_close(tag_name, next_tag_name)) { return i; }
+      if (should_implicitly_close(tag_name, next_tag_name)) { return index; }
     } else if (node->type == AST_HTML_CLOSE_TAG_NODE) {
       AST_HTML_CLOSE_TAG_NODE_T* close = (AST_HTML_CLOSE_TAG_NODE_T*) node;
       hb_string_T close_tag_name = close->tag_name->value;
 
-      if (parent_closes_element(tag_name, close_tag_name)) { return i; }
+      if (parent_closes_element(tag_name, close_tag_name)) { return index; }
     }
   }
 
@@ -1655,6 +1665,35 @@ static hb_array_T* parser_build_elements_from_tags(
   hb_allocator_T* allocator
 );
 
+static bool has_close_tag_for_name(hb_array_T* close_tag_names, hb_string_T tag_name) {
+  for (size_t i = 0; i < hb_array_size(close_tag_names); i++) {
+    hb_string_T* name = (hb_string_T*) hb_array_get(close_tag_names, i);
+    if (name != NULL && hb_string_equals_case_insensitive(*name, tag_name)) { return true; }
+  }
+
+  return false;
+}
+
+static hb_array_T* collect_close_tag_names(hb_array_T* nodes, hb_allocator_T* allocator) {
+  hb_array_T* close_tag_names = hb_array_init(16, allocator);
+
+  for (size_t i = 0; i < hb_array_size(nodes); i++) {
+    AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, i);
+    if (node == NULL || node->type != AST_HTML_CLOSE_TAG_NODE) { continue; }
+
+    AST_HTML_CLOSE_TAG_NODE_T* close_tag = (AST_HTML_CLOSE_TAG_NODE_T*) node;
+    hb_string_T name = close_tag->tag_name->value;
+
+    if (!has_close_tag_for_name(close_tag_names, name)) {
+      hb_string_T* stored = hb_allocator_alloc(allocator, sizeof(hb_string_T));
+      *stored = name;
+      hb_array_append(close_tag_names, stored);
+    }
+  }
+
+  return close_tag_names;
+}
+
 static hb_array_T* parser_build_elements_from_tags(
   hb_array_T* nodes,
   hb_array_T* errors,
@@ -1663,8 +1702,11 @@ static hb_array_T* parser_build_elements_from_tags(
 ) {
   bool strict = options ? options->strict : false;
   hb_array_T* result = hb_array_init(hb_array_size(nodes), allocator);
+  hb_array_T* close_tag_names = collect_close_tag_names(nodes, allocator);
 
   for (size_t index = 0; index < hb_array_size(nodes); index++) {
+    if (parser_options_past_deadline(options)) { break; }
+
     AST_NODE_T* node = (AST_NODE_T*) hb_array_get(nodes, index);
     if (node == NULL) { continue; }
 
@@ -1672,7 +1714,11 @@ static hb_array_T* parser_build_elements_from_tags(
       AST_HTML_OPEN_TAG_NODE_T* open_tag = (AST_HTML_OPEN_TAG_NODE_T*) node;
       hb_string_T tag_name = open_tag->tag_name->value;
 
-      size_t close_index = find_matching_close_tag(nodes, index, tag_name);
+      size_t close_index = (size_t) -1;
+
+      if (has_close_tag_for_name(close_tag_names, tag_name)) {
+        close_index = find_matching_close_tag(nodes, index, tag_name, options);
+      }
 
       if (close_index == (size_t) -1) {
         size_t implicit_close_index = find_implicit_close_index(nodes, index, tag_name);
@@ -1732,7 +1778,7 @@ static hb_array_T* parser_build_elements_from_tags(
 
           index = implicit_close_index - 1;
         } else {
-          if (hb_array_size(open_tag->base.errors) == 0) {
+          if (hb_array_size(open_tag->base.errors) == 0 && !parser_options_errors_exceeded(options)) {
             append_missing_closing_tag_error(
               open_tag->tag_name,
               open_tag->base.location.start,
@@ -1740,6 +1786,8 @@ static hb_array_T* parser_build_elements_from_tags(
               allocator,
               open_tag->base.errors
             );
+
+            parser_options_increment_error_count(options);
           }
 
           hb_array_append(result, node);
@@ -1779,7 +1827,7 @@ static hb_array_T* parser_build_elements_from_tags(
       AST_HTML_CLOSE_TAG_NODE_T* close_tag = (AST_HTML_CLOSE_TAG_NODE_T*) node;
 
       if (!is_void_element(close_tag->tag_name->value)) {
-        if (hb_array_size(close_tag->base.errors) == 0) {
+        if (hb_array_size(close_tag->base.errors) == 0 && !parser_options_errors_exceeded(options)) {
           append_missing_opening_tag_error(
             close_tag->tag_name,
             close_tag->base.location.start,
@@ -1787,6 +1835,8 @@ static hb_array_T* parser_build_elements_from_tags(
             allocator,
             close_tag->base.errors
           );
+
+          parser_options_increment_error_count(options);
         }
       }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.10.3
 platform: arm-linux-gnu
 authors:
 - Marco Roth
@@ -397,12 +397,11 @@ files:
 - sig/herb/visitor.rbs
 - sig/herb/warnings.rbs
 - sig/herb_c_extension.rbs
+- sig/manifest.yaml
 - sig/rubyvm.rbs
 - sig/serialized.rbs
 - sig/serialized_ast_errors.rbs
 - sig/serialized_ast_nodes.rbs
-- sig/vendor/did_you_mean.rbs
-- sig/vendor/parallel.rbs
 - src/analyze/action_view/attribute_extraction_helpers.c
 - src/analyze/action_view/generated_handlers.c
 - src/analyze/action_view/generated_handlers.h
@@ -488,6 +487,7 @@ files:
 - src/include/lib/hb_arena_debug.h
 - src/include/lib/hb_array.h
 - src/include/lib/hb_buffer.h
+- src/include/lib/hb_clock.h
 - src/include/lib/hb_foreach.h
 - src/include/lib/hb_narray.h
 - src/include/lib/hb_string.h
@@ -705,7 +705,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.22
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: The modern HTML+ERB Toolchain
 test_files: []

data/sig/vendor/did_you_mean.rbs

@@ -1,6 +0,0 @@
-module DidYouMean
-  class SpellChecker
-    def initialize: (dictionary: Array[String]) -> void
-    def correct: (String input) -> Array[String]
-  end
-end

data/sig/vendor/parallel.rbs

@@ -1,4 +0,0 @@
-module Parallel
-  def self.map: [T, U] (Array[T], ?in_processes: Integer) { (T) -> U } -> Array[U]
-  def self.processor_count: () -> Integer
-end