herb 0.10.1-x86-linux-musl → 0.10.2-x86-linux-musl

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd9ab6fe09717a673a5aa7f3ce0cb4d2264461839be66b4066d4f738e50d220b
-  data.tar.gz: 1b23695b1a69420fd113fc4f2ec3738f569cb5aa14c41bd8eabf4356adebbfde
+  metadata.gz: d8580eb8bced26efa1b7d2e9d706be035b0c19d3f47cb2c8a97faede0c6fbbed
+  data.tar.gz: 2cbf6c0923d2a3a0ef088b8fc978e6f2895718571afd045a18b7eb10dd4ab397
 SHA512:
-  metadata.gz: ba61010831b454c3e85df2146c5220387f3ce73c0354b0e250a836a25e73000dc0208eb30df6a03790e0e01428117e4a937d982a7409e1c309505b8c932c91c4
-  data.tar.gz: 3889f34d9762abab0796c98df40c2234dd4a251e75732f676c5bfa75fe2a73b8100606cbb8e5727b422b1e9677a851dba878f301121d5f791aefae1b3fb9c649
+  metadata.gz: d3208283da316cc34d9e1c93ebbf685cea626b0e7b63138dd808b6fefc50495d8e50c0f256ce2fffdf6daf1d26ecdb937d1e48ffbac4d59acdb2451c6afb5d45
+  data.tar.gz: 59158a54fa34f44ee7599381b05d00ea3a38af915a7e53d82e60b67fe7572a9d8641e2bdba18a2e68295eb99507a380b26e871b925b635ced059c2202a9b7bc6

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/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/version.rb

@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.10.1"
+  VERSION = "0.10.2"
 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/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/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/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.2"
 
 #endif

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.2
 platform: x86-linux-musl
 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