herb 0.9.2-arm-linux-gnu → 0.9.4-arm-linux-gnu

data/lib/herb/errors.rb

@@ -1258,5 +1258,273 @@ module Herb
       end
     end
 
+    class StrictLocalsPositionalArgumentError < Error
+      include Colors
+
+      #|  name: String?,
+      #| }
+
+      attr_reader :name #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, name)
+        super(type, location, message)
+        @name = name
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_strict_locals_positional_argument_error
+      def to_hash
+        super.merge(
+          name: name
+        ) #: Herb::serialized_strict_locals_positional_argument_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("└── name: #{green(name.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class StrictLocalsBlockArgumentError < Error
+      include Colors
+
+      #|  name: String?,
+      #| }
+
+      attr_reader :name #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, name)
+        super(type, location, message)
+        @name = name
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_strict_locals_block_argument_error
+      def to_hash
+        super.merge(
+          name: name
+        ) #: Herb::serialized_strict_locals_block_argument_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("└── name: #{green(name.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class StrictLocalsSplatArgumentError < Error
+      include Colors
+
+      #|  name: String?,
+      #| }
+
+      attr_reader :name #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, name)
+        super(type, location, message)
+        @name = name
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_strict_locals_splat_argument_error
+      def to_hash
+        super.merge(
+          name: name
+        ) #: Herb::serialized_strict_locals_splat_argument_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("└── name: #{green(name.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class StrictLocalsMissingParenthesisError < Error
+      include Colors
+
+      #|  rest: String?,
+      #| }
+
+      attr_reader :rest #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, rest)
+        super(type, location, message)
+        @rest = rest
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_strict_locals_missing_parenthesis_error
+      def to_hash
+        super.merge(
+          rest: rest
+        ) #: Herb::serialized_strict_locals_missing_parenthesis_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("└── rest: #{green(rest.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class StrictLocalsDuplicateDeclarationError < Error
+      include Colors
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("└── message: #{green(message.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class VoidElementContentError < Error
+      include Colors
+
+      #|  tag_name: Herb::Token?,
+      #|  helper_name: String?,
+      #|  content_type: String?,
+      #| }
+
+      attr_reader :tag_name #: Herb::Token?
+      attr_reader :helper_name #: String?
+      attr_reader :content_type #: String?
+
+      #: (String, Location?, String, Herb::Token, String, String) -> void
+      def initialize(type, location, message, tag_name, helper_name, content_type)
+        super(type, location, message)
+        @tag_name = tag_name
+        @helper_name = helper_name
+        @content_type = content_type
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_void_element_content_error
+      def to_hash
+        super.merge(
+          tag_name: tag_name,
+          helper_name: helper_name,
+          content_type: content_type
+        ) #: Herb::serialized_void_element_content_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("├── tag_name: ")
+        output += tag_name ? tag_name.tree_inspect : magenta("∅")
+        output += "\n"
+        output += white("├── helper_name: #{green(helper_name.inspect)}\n")
+        output += white("└── content_type: #{green(content_type.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class DotNotationCasingError < Error
+      include Colors
+
+      #|  segment: Herb::Token?,
+      #| }
+
+      attr_reader :segment #: Herb::Token?
+
+      #: (String, Location?, String, Herb::Token) -> void
+      def initialize(type, location, message, segment)
+        super(type, location, message)
+        @segment = segment
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_dot_notation_casing_error
+      def to_hash
+        super.merge(
+          segment: segment
+        ) #: Herb::serialized_dot_notation_casing_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("└── segment: ")
+        output += segment ? segment.tree_inspect : magenta("∅")
+        output += "\n"
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
   end
 end

data/lib/herb/parser_options.rb

@@ -7,6 +7,7 @@ module Herb
     attr_reader :analyze #: bool
     attr_reader :action_view_helpers #: bool
     attr_reader :render_nodes #: bool
+    attr_reader :strict_locals #: bool
     attr_reader :prism_program #: bool
     attr_reader :prism_nodes #: bool
     attr_reader :prism_nodes_deep #: bool
@@ -16,17 +17,19 @@ module Herb
     DEFAULT_ANALYZE = true #: bool
     DEFAULT_ACTION_VIEW_HELPERS = false #: bool
     DEFAULT_RENDER_NODES = false #: bool
+    DEFAULT_STRICT_LOCALS = false #: bool
     DEFAULT_PRISM_PROGRAM = false #: bool
     DEFAULT_PRISM_NODES = false #: bool
     DEFAULT_PRISM_NODES_DEEP = false #: bool
 
-    #: (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: 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, render_nodes: DEFAULT_RENDER_NODES, 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, ?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, 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 = strict
       @track_whitespace = track_whitespace
       @analyze = analyze
       @action_view_helpers = action_view_helpers
       @render_nodes = render_nodes
+      @strict_locals = strict_locals
       @prism_nodes = prism_nodes
       @prism_nodes_deep = prism_nodes_deep
       @prism_program = prism_program
@@ -40,6 +43,7 @@ module Herb
         analyze: @analyze,
         action_view_helpers: @action_view_helpers,
         render_nodes: @render_nodes,
+        strict_locals: @strict_locals,
         prism_nodes: @prism_nodes,
         prism_nodes_deep: @prism_nodes_deep,
         prism_program: @prism_program,
@@ -54,6 +58,7 @@ module Herb
         "analyze=#{@analyze}\n  " \
         "action_view_helpers=#{@action_view_helpers}\n  " \
         "render_nodes=#{@render_nodes}\n  " \
+        "strict_locals=#{@strict_locals}\n  " \
         "prism_nodes=#{@prism_nodes}\n  " \
         "prism_nodes_deep=#{@prism_nodes_deep}\n  " \
         "prism_program=#{@prism_program}>"

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.2"
+  VERSION = "0.9.4"
 end