herb 0.9.3 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a490ad868e9fa08be317c7343a0553a8bf07234decbb95046d235d64256ed743
-  data.tar.gz: 2f1312897b63fe33263bf35f023b6d2377bfb9e806d5f640837d9de57b2878bb
+  metadata.gz: dad9b36758689e8b12d360b0ab22322e820762b4b065556d90a5d1d2cdd319b0
+  data.tar.gz: d298f4e91debfefac4725f7647f671d4eeb571a0d6e52d19b2452eeaf5c4b497
 SHA512:
-  metadata.gz: f820a5463221a38d26c92a3a388f137bb2295125641dd7de7102290c85036adfa5c0bdafd3331e049fff6fc218a8c53b094fd5037277276c67121a64e99b7535
-  data.tar.gz: 6bee2c356c1e18c5670ce9ffcd8193100f0be4dc8d2aba74faaadc6409fe0d534390c34796dcd5aa8c1bfa4c55209cf07b856898a6a66cf654e871d14a869003
+  metadata.gz: a935b405301ba5ffc3531ae41157321278d4f6f56a56a15d7e287605493eaf2d4fe9a4a43e753001ea094d462d7972c50691c569ea01c7e2470e8f41cc8d4623
+  data.tar.gz: 1157b317060949235da509fb8f7b33f424ade19a1288b3319140c233e6df53afc560042ca4713ee71abfdb00975b673844d0bd16d01259ea2b0fbe91cce43ae8

data/lib/herb/engine/compiler.rb

@@ -5,6 +5,12 @@ module Herb
     class Compiler < ::Herb::Visitor
       EXPRESSION_TOKEN_TYPES = [:expr, :expr_escaped, :expr_block, :expr_block_escaped].freeze
 
+      TRAILING_WHITESPACE = /[ \t]+\z/
+      TRAILING_INDENTATION = /\n[ \t]+\z/
+      TRAILING_INDENTATION_CAPTURE = /\n([ \t]+)\z/
+      WHITESPACE_ONLY = /\A[ \t]+\z/
+      WHITESPACE_ONLY_CAPTURE = /\A([ \t]+)\z/
+
       attr_reader :tokens
 
       def initialize(engine, options = {})
@@ -242,6 +248,8 @@ module Herb
       def visit_erb_block_node(node)
         opening = node.tag_opening.value
 
+        check_for_escaped_erb_tag!(opening)
+
         if opening.include?("=")
           should_escape = should_escape_output?(opening)
           code = node.content.value.strip
@@ -251,7 +259,9 @@ module Herb
                      else
                        [:expr_block, code, current_context]
                      end
+
           @last_trim_consumed_newline = false
+          @trim_next_whitespace = true if right_trim?(node)
 
           visit_all(node.body)
           visit_erb_block_end_node(node.end_node, escaped: should_escape)
@@ -267,9 +277,7 @@ module Herb
       end
 
       def visit_erb_block_end_node(node, escaped: false)
-        has_left_trim = node.tag_opening.value.start_with?("<%-")
-
-        remove_trailing_whitespace_from_last_token! if has_left_trim
+        remove_trailing_whitespace_from_last_token! if left_trim?(node)
 
         code = node.content.value.strip
 
@@ -302,6 +310,15 @@ module Herb
 
       private
 
+      def check_for_escaped_erb_tag!(opening)
+        return unless opening.start_with?("<%%")
+
+        raise Herb::Engine::GeneratorTemplateError,
+              "This file appears to be a generator template (a template used to generate ERB files) " \
+              "rather than a standard ERB template. It contains escaped ERB tags like <%%= %> which " \
+              "produce literal ERB output in the generated file."
+      end
+
       def current_context
         @context_stack.last
       end
@@ -336,10 +353,11 @@ module Herb
       def process_erb_tag(node, skip_comment_check: false)
         opening = node.tag_opening.value
 
+        check_for_escaped_erb_tag!(opening)
+
         if !skip_comment_check && erb_comment?(opening)
-          has_left_trim = opening.start_with?("<%-")
           follows_newline = leading_space_follows_newline?
-          remove_trailing_whitespace_from_last_token! if has_left_trim
+          remove_trailing_whitespace_from_last_token! if left_trim?(node)
 
           if at_line_start?
             leading_space = extract_and_remove_leading_space!
@@ -485,10 +503,9 @@ module Herb
           @last_trim_consumed_newline = false
         end
 
-        has_right_trim = node.tag_closing&.value == "-%>"
         should_escape = should_escape_output?(opening)
         add_expression_with_escaping(code, should_escape)
-        @trim_next_whitespace = true if has_right_trim
+        @trim_next_whitespace = true if right_trim?(node)
       end
 
       def indicator_for(type)
@@ -521,7 +538,7 @@ module Herb
         last_value = @tokens.last[1]
 
         if last_type == :text
-          last_value.empty? || last_value.end_with?("\n") || (last_value =~ /\A[ \t]+\z/ && preceding_token_ends_with_newline?) || last_value =~ /\n[ \t]+\z/
+          last_value.empty? || last_value.end_with?("\n") || (last_value =~ WHITESPACE_ONLY && preceding_token_ends_with_newline?) || last_value =~ TRAILING_INDENTATION
         elsif EXPRESSION_TOKEN_TYPES.include?(last_type)
           @last_trim_consumed_newline
         else
@@ -540,6 +557,14 @@ module Herb
         preceding[1].end_with?("\n")
       end
 
+      def left_trim?(node)
+        node.tag_opening.value == "<%-"
+      end
+
+      def right_trim?(node)
+        node.tag_closing&.value == "-%>"
+      end
+
       def last_text_token
         return unless @tokens.last && @tokens.last[0] == :text
 
@@ -552,7 +577,7 @@ module Herb
 
         text = token[1]
 
-        return Regexp.last_match(1) if text =~ /\n([ \t]+)\z/ || text =~ /\A([ \t]+)\z/
+        return Regexp.last_match(1) if text =~ TRAILING_INDENTATION_CAPTURE || text =~ WHITESPACE_ONLY_CAPTURE
 
         ""
       end
@@ -561,7 +586,12 @@ module Herb
         token = last_text_token
         return false unless token
 
-        token[1].match?(/\n[ \t]+\z/)
+        text = token[1]
+
+        return true if text.match?(TRAILING_INDENTATION)
+        return true if @last_trim_consumed_newline && text.match?(WHITESPACE_ONLY)
+
+        false
       end
 
       def extract_and_remove_leading_space!
@@ -570,9 +600,9 @@ module Herb
 
         text = @tokens.last[1]
 
-        if text =~ /\n[ \t]+\z/
-          text.sub!(/[ \t]+\z/, "")
-        elsif text =~ /\A[ \t]+\z/
+        if text =~ TRAILING_INDENTATION
+          text.sub!(TRAILING_WHITESPACE, "")
+        elsif text =~ WHITESPACE_ONLY
           text.replace("")
         end
 
@@ -582,10 +612,8 @@ module Herb
       end
 
       def apply_trim(node, code)
-        has_left_trim = node.tag_opening.value.start_with?("<%-")
-
         follows_newline = leading_space_follows_newline?
-        removed_whitespace = has_left_trim ? remove_trailing_whitespace_from_last_token! : ""
+        removed_whitespace = left_trim?(node) ? remove_trailing_whitespace_from_last_token! : ""
 
         if at_line_start?
           leading_space = extract_and_remove_leading_space!
@@ -617,12 +645,12 @@ module Herb
         return "" unless token
 
         text = token[1]
-        removed = text[/[ \t]+\z/] || ""
+        removed = text[TRAILING_WHITESPACE] || ""
 
-        if text =~ /\n[ \t]+\z/
-          text.sub!(/[ \t]+\z/, "")
+        if text =~ TRAILING_INDENTATION
+          text.sub!(TRAILING_WHITESPACE, "")
           token[1] = text
-        elsif text =~ /\A[ \t]+\z/
+        elsif text =~ WHITESPACE_ONLY
           text.replace("")
           token[1] = text
         end

data/lib/herb/engine.rb

@@ -31,6 +31,9 @@ module Herb
     class CompilationError < StandardError
     end
 
+    class GeneratorTemplateError < CompilationError
+    end
+
     class InvalidRubyError < CompilationError
       attr_reader :compiled_source
 

data/lib/herb/project.rb

@@ -71,9 +71,9 @@ module Herb
       attr_reader :successful, :failed, :timeout, :template_error, :unexpected_error,
                   :strict_parse_error, :analyze_parse_error,
                   :validation_error, :compilation_failed, :strict_compilation_failed,
-                  :invalid_ruby,
+                  :invalid_ruby, :skipped,
                   :error_outputs, :file_contents, :parse_errors, :compilation_errors,
-                  :file_diagnostics
+                  :file_diagnostics, :skip_reasons
 
       def initialize
         @successful = []
@@ -87,11 +87,13 @@ module Herb
         @compilation_failed = []
         @strict_compilation_failed = []
         @invalid_ruby = []
+        @skipped = []
         @error_outputs = {}
         @file_contents = {}
         @parse_errors = {}
         @compilation_errors = {}
         @file_diagnostics = {}
+        @skip_reasons = {}
       end
 
       def problem_files
@@ -432,8 +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 1 second" }
     rescue StandardError => e
       file_content ||= begin
         File.read(file_path)
@@ -441,8 +442,7 @@ module Herb
         nil
       end
 
-      { file_path: file_path, status: :failed, file_content: file_content,
-        log: "⚠️ Error processing #{file_path}: #{e.message}" }
+      { file_path: file_path, status: :failed, file_content: file_content, log: "⚠️ Error processing #{file_path}: #{e.message}" }
     ensure
       [stdout_file, stderr_file].each do |tempfile|
         next unless tempfile
@@ -488,6 +488,9 @@ module Herb
       Herb::Engine.new(file_content, filename: file_path, escape: true, validate_ruby: validate_ruby)
 
       { status: :successful, log: "✅ Compiled #{file_path} successfully" }
+    rescue Herb::Engine::GeneratorTemplateError => e
+      { status: :skipped, skip_reason: e.message,
+        log: "⊘ Skipping #{file_path}: #{e.message}" }
     rescue Herb::Engine::InvalidRubyError => e
       { status: :invalid_ruby, file_content: file_content,
         compilation_error: { error: e.message, backtrace: e.backtrace&.first(10) || [] },
@@ -545,6 +548,7 @@ module Herb
       tracker.parse_errors[file_path] = result[:parse_error] if result[:parse_error]
       tracker.compilation_errors[file_path] = result[:compilation_error] if result[:compilation_error]
       tracker.file_diagnostics[file_path] = result[:diagnostics] if result[:diagnostics]&.any?
+      tracker.skip_reasons[file_path] = result[:skip_reason] if result[:skip_reason]
     end
 
     def print_summary(results, log, duration)
@@ -563,13 +567,18 @@ module Herb
       puts "  #{label("Checked")} #{cyan("#{total} #{pluralize(total, "file")}")}"
 
       if total > 1
-        files_line = if issues.positive?
-                       "#{bold(green("#{passed} clean"))} | #{bold(red("#{issues} with issues"))}"
-                     else
-                       bold(green("#{total} clean"))
-                     end
+        files_parts = []
 
-        puts "  #{label("Files")} #{files_line}"
+        if issues.positive?
+          files_parts << bold(green("#{passed} clean"))
+          files_parts << bold(red("#{issues} with issues"))
+        else
+          files_parts << bold(green("#{total - results.skipped.count} clean"))
+        end
+
+        files_parts << dimmed("#{results.skipped.count} skipped") if results.skipped.any?
+
+        puts "  #{label("Files")} #{files_parts.join(" | ")}"
       end
 
       parser_parts = []
@@ -581,8 +590,9 @@ module Herb
       parser_parts << stat(results.analyze_parse_error.count, "analyze", :yellow) if results.analyze_parse_error.any?
       puts "  #{label("Parser")} #{parser_parts.join(" | ")}"
 
-      skipped = total - passed - results.validation_error.count - results.compilation_failed.count -
-                results.strict_compilation_failed.count - results.invalid_ruby.count
+      not_compiled = total - passed - results.skipped.count - results.validation_error.count -
+                     results.compilation_failed.count - results.strict_compilation_failed.count -
+                     results.invalid_ruby.count
 
       engine_parts = []
       engine_parts << stat(passed, "compiled", :green)
@@ -590,13 +600,17 @@ module Herb
       engine_parts << stat(results.compilation_failed.count, "compilation", :red) if results.compilation_failed.any?
       engine_parts << stat(results.strict_compilation_failed.count, "strict", :yellow) if results.strict_compilation_failed.any?
       engine_parts << stat(results.invalid_ruby.count, "produced invalid Ruby", :red) if results.invalid_ruby.any?
-      engine_parts << dimmed("#{skipped} skipped") if skipped.positive?
+      engine_parts << dimmed("#{not_compiled} not compiled") if not_compiled.positive?
       puts "  #{label("Engine")} #{engine_parts.join(" | ")}"
 
       if results.timeout.any?
         puts "  #{label("Timeout")} #{stat(results.timeout.count, "timed out", :yellow)}"
       end
 
+      if results.skipped.any?
+        puts "  #{label("Skipped")} #{dimmed("#{results.skipped.count} #{pluralize(results.skipped.count, "file")}")}"
+      end
+
       if duration
         puts "  #{label("Duration")} #{cyan(format_duration(duration))}"
       end
@@ -630,6 +644,7 @@ module Herb
       log.puts ""
       log.puts "--- Other ---"
       log.puts "⏱️ Timed out: #{results.timeout.count} (#{percentage(results.timeout.count, total)}%)"
+      log.puts "⊘ Skipped: #{results.skipped.count} (#{percentage(results.skipped.count, total)}%)"
 
       return unless duration
 
@@ -639,10 +654,27 @@ module Herb
     def print_file_lists(results, log)
       log_file_lists(results, log)
 
-      return unless results.problem_files.any?
-
       printed_section = false
 
+      if results.skipped.any?
+        printed_section = true
+
+        puts "\n"
+        puts " #{bold("Skipped files:")}"
+        puts " #{dimmed("These files were parsed successfully but skipped for compilation by the engine.")}"
+
+        results.skipped.each do |file|
+          relative = relative_path(file)
+          reason = results.skip_reasons[file]
+
+          puts ""
+          puts " #{cyan(relative)}:"
+          puts "   #{dimmed("⊘")} #{dimmed(reason)}"
+        end
+      end
+
+      return unless results.problem_files.any?
+
       ISSUE_TYPES.each do |type|
         file_list = results.send(type[:key])
         next unless file_list.any?
@@ -682,6 +714,15 @@ module Herb
     end
 
     def log_file_lists(results, log)
+      if results.skipped.any?
+        log.puts "\n#{heading("Files: Skipped")}"
+
+        results.skipped.each do |file|
+          reason = results.skip_reasons[file]
+          log.puts "#{file} - #{reason}"
+        end
+      end
+
       ISSUE_TYPES.each do |type|
         file_list = results.send(type[:key])
         next unless file_list.any?

data/lib/herb/version.rb

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

data/sig/herb/engine/compiler.rbs

@@ -5,6 +5,16 @@ module Herb
     class Compiler < ::Herb::Visitor
       EXPRESSION_TOKEN_TYPES: untyped
 
+      TRAILING_WHITESPACE: ::Regexp
+
+      TRAILING_INDENTATION: ::Regexp
+
+      TRAILING_INDENTATION_CAPTURE: ::Regexp
+
+      WHITESPACE_ONLY: ::Regexp
+
+      WHITESPACE_ONLY_CAPTURE: ::Regexp
+
       attr_reader tokens: untyped
 
       def initialize: (untyped engine, ?untyped options) -> untyped
@@ -85,6 +95,8 @@ module Herb
 
       private
 
+      def check_for_escaped_erb_tag!: (untyped opening) -> untyped
+
       def current_context: () -> untyped
 
       def push_context: (untyped context) -> untyped
@@ -134,6 +146,10 @@ module Herb
 
       def preceding_token_ends_with_newline?: () -> untyped
 
+      def left_trim?: (untyped node) -> untyped
+
+      def right_trim?: (untyped node) -> untyped
+
       def last_text_token: () -> untyped
 
       def extract_leading_space: () -> untyped

data/sig/herb/engine.rbs

@@ -27,6 +27,9 @@ module Herb
     class CompilationError < StandardError
     end
 
+    class GeneratorTemplateError < CompilationError
+    end
+
     class InvalidRubyError < CompilationError
       attr_reader compiled_source: untyped
 

data/src/analyze/analyze.c

@@ -75,8 +75,7 @@ static bool analyze_erb_content(const AST_NODE_T* node, void* data) {
 
     hb_string_T opening = erb_content_node->tag_opening->value;
 
-    if (!hb_string_equals(opening, hb_string("<%%")) && !hb_string_equals(opening, hb_string("<%%="))
-        && !hb_string_equals(opening, hb_string("<%#")) && !hb_string_equals(opening, hb_string("<%graphql"))) {
+    if (!hb_string_equals(opening, hb_string("<%#")) && !hb_string_equals(opening, hb_string("<%graphql"))) {
       analyzed_ruby_T* analyzed = herb_analyze_ruby(erb_content_node->content->value);
 
       erb_content_node->parsed = true;
@@ -1032,7 +1031,7 @@ void herb_analyze_parse_tree(
 
   herb_visit_node((AST_NODE_T*) document, detect_invalid_erb_structures, &invalid_context);
 
-  herb_analyze_parse_errors(document, source, allocator);
+  herb_analyze_parse_errors(document, source, options, allocator);
 
   herb_parser_match_html_tags_post_analyze(document, options, allocator);
 

data/src/analyze/parse_errors.c

@@ -11,6 +11,37 @@
 #include <stdlib.h>
 #include <string.h>
 
+static bool document_has_anonymous_keyword_rest(AST_DOCUMENT_NODE_T* document) {
+  if (!document || !document->children) { return false; }
+
+  for (size_t index = 0; index < hb_array_size(document->children); index++) {
+    AST_NODE_T* child = hb_array_get(document->children, index);
+    if (!child || child->type != AST_ERB_STRICT_LOCALS_NODE) { continue; }
+
+    AST_ERB_STRICT_LOCALS_NODE_T* strict_locals_node = (AST_ERB_STRICT_LOCALS_NODE_T*) child;
+    if (!strict_locals_node->locals) { continue; }
+
+    for (size_t local_index = 0; local_index < hb_array_size(strict_locals_node->locals); local_index++) {
+      AST_RUBY_STRICT_LOCAL_NODE_T* local = hb_array_get(strict_locals_node->locals, local_index);
+      if (local && local->double_splat && local->name == NULL) { return true; }
+    }
+  }
+
+  return false;
+}
+
+static bool should_skip_forwarding_error(
+  const pm_diagnostic_t* error,
+  bool strict_locals_enabled,
+  bool has_anonymous_keyword_rest
+) {
+  if (error->diag_id != PM_ERR_ARGUMENT_NO_FORWARDING_STAR_STAR) { return false; }
+
+  if (!strict_locals_enabled) { return true; }
+
+  return has_anonymous_keyword_rest;
+}
+
 static void parse_erb_content_errors(AST_NODE_T* erb_node, const char* source, hb_allocator_T* allocator) {
   if (!erb_node || erb_node->type != AST_ERB_CONTENT_NODE) { return; }
   AST_ERB_CONTENT_NODE_T* content_node = (AST_ERB_CONTENT_NODE_T*) erb_node;
@@ -45,11 +76,19 @@ static void parse_erb_content_errors(AST_NODE_T* erb_node, const char* source, h
   free(content);
 }
 
-void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source, hb_allocator_T* allocator) {
+void herb_analyze_parse_errors(
+  AST_DOCUMENT_NODE_T* document,
+  const char* source,
+  const parser_options_T* parser_options,
+  hb_allocator_T* allocator
+) {
   char* extracted_ruby = herb_extract_ruby_with_semicolons(source, allocator);
 
   if (!extracted_ruby) { return; }
 
+  bool strict_locals_enabled = parser_options && parser_options->strict_locals;
+  bool has_anonymous_keyword_rest = strict_locals_enabled && document_has_anonymous_keyword_rest(document);
+
   pm_parser_t parser;
   pm_options_t options = { 0, .partial_script = true };
   pm_parser_init(&parser, (const uint8_t*) extracted_ruby, strlen(extracted_ruby), &options);
@@ -58,6 +97,8 @@ void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source
 
   for (const pm_diagnostic_t* error = (const pm_diagnostic_t*) parser.error_list.head; error != NULL;
        error = (const pm_diagnostic_t*) error->node.next) {
+    if (should_skip_forwarding_error(error, strict_locals_enabled, has_anonymous_keyword_rest)) { continue; }
+
     size_t error_offset = (size_t) (error->location.start - parser.start);
 
     if (strstr(error->message, "unexpected ';'") != NULL) {

data/src/analyze/strict_locals.c

@@ -440,6 +440,20 @@ static hb_array_T* extract_strict_locals(
 
       hb_array_append(locals, local);
       hb_allocator_dealloc(allocator, name);
+    } else {
+      size_t params_in_content = (size_t) (params_open - content_bytes);
+      size_t operator_prism_start = (size_t) (keyword_rest_param->operator_loc.start - synthetic_start);
+      size_t operator_prism_end = (size_t) (keyword_rest_param->operator_loc.end - synthetic_start);
+      size_t content_start = params_in_content + (operator_prism_start - strlen(SYNTHETIC_PREFIX));
+      size_t content_end = params_in_content + (operator_prism_end - strlen(SYNTHETIC_PREFIX));
+
+      position_T start = byte_offset_to_position(source, erb_content_byte_offset + content_start);
+      position_T end = byte_offset_to_position(source, erb_content_byte_offset + content_end);
+
+      AST_RUBY_STRICT_LOCAL_NODE_T* local =
+        ast_ruby_strict_local_node_init(NULL, NULL, false, true, start, end, hb_array_init(0, allocator), allocator);
+
+      hb_array_append(locals, local);
     }
   }
 

data/src/include/analyze/analyze.h

@@ -44,7 +44,12 @@ typedef struct {
   hb_allocator_T* allocator;
 } invalid_erb_context_T;
 
-void herb_analyze_parse_errors(AST_DOCUMENT_NODE_T* document, const char* source, hb_allocator_T* allocator);
+void herb_analyze_parse_errors(
+  AST_DOCUMENT_NODE_T* document,
+  const char* source,
+  const parser_options_T* options,
+  hb_allocator_T* allocator
+);
 void herb_analyze_parse_tree(
   AST_DOCUMENT_NODE_T* document,
   const char* source,

data/src/include/version.h

@@ -1,6 +1,6 @@
 #ifndef HERB_VERSION_H
 #define HERB_VERSION_H
 
-#define HERB_VERSION "0.9.3"
+#define HERB_VERSION "0.9.4"
 
 #endif

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: herb
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.4
 platform: ruby
 authors:
 - Marco Roth