haml_lint 0.62.0 → 0.64.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3754327462146047a8677d8e91b7d47e3d538f2459f2d3ebd583ad2dafc92c3b
-  data.tar.gz: 33ccb58e67c32798c90da242cc8708e763f93a1509c6083d54b351453f587a5f
+  metadata.gz: 73a515adb6ca4915d07c747133e7a657e04bd8d6a5c41cf5cd63a0adf3e03316
+  data.tar.gz: efb5d688d181d7906a28bef3f25b1080e1e38e2461d9343db554ed5a98037296
 SHA512:
-  metadata.gz: 8a9ece6eda4dac35772948661486fc6c4fada9d3071b8b4ff52d37bab8930d032d0138a95f59a1a54c760951001010102317965e11aea2fd6dec4a35c7528aac
-  data.tar.gz: 67d13e3d045dd804f7f93c662dd8dfb833ac8104a2c52bd1699ba9201861630e686228de725ede55d469a9b3c15a02fcf0b910b843c3d425314e59721ae01ba0
+  metadata.gz: 7a6c42a2be6709314fb8bff476e8a0ff80f0054895eeaa795b8fd741039a580bfb6ced6b0a45b293cdbe0641676a412909363b99f3638a5f8f4f5dd910de736a
+  data.tar.gz: 7165be1ef28719e4a08ad60a26aa6d0a8f8e1ca0507c5376cbfa776e813320fbb3fbd4357c7d74809393cd9c676ca009bab3d8d36b48770de7ffda4c680ed3a2

data/lib/haml_lint/document.rb

@@ -14,6 +14,9 @@ module HamlLint
     # @return [String] Haml template file path
     attr_reader :file
 
+    # @return [Boolean] true if source was read directly from `file` on-disk (rather than from stdin)
+    attr_reader :file_on_disk
+
     # @return [Boolean] true if source changes (from autocorrect) should be written to stdout instead of disk
     attr_reader :write_to_stdout
 
@@ -39,12 +42,14 @@ module HamlLint
     # @param source [String] Haml code to parse
     # @param options [Hash]
     # @option options :file [String] file name of document that was parsed
+    # @option options :file_on_disk [Boolean] true if source was read straight from `file` on disk
     # @option options :write_to_stdout [Boolean] true if source changes should be written to stdout
     # @raise [Haml::Parser::Error] if there was a problem parsing the document
     def initialize(source, options)
       @config = options[:config]
       @file = options.fetch(:file, STRING_SOURCE)
       @write_to_stdout = options[:write_to_stdout]
+      @file_on_disk = options[:file_on_disk] && @file != STRING_SOURCE
       @source_was_changed = false
       process_source(source)
     end

data/lib/haml_lint/linter/rubocop.rb

@@ -16,6 +16,46 @@ module HamlLint
   #
   # The work is spread across the classes in the HamlLint::RubyExtraction module.
   class Linter::RuboCop < Linter
+    # Processes a ruby file and reports RuboCop offenses
+    class Runner < ::RuboCop::Runner
+      attr_reader :offenses
+
+      def run(haml_path, ruby_code, config:, allow_cache: false)
+        @allow_cache = allow_cache
+        @offenses = []
+        @config_store.instance_variable_set(:@options_config, config)
+        @options[:stdin] = ruby_code
+        super([haml_path])
+      end
+
+      def corrected_code
+        @options[:stdin]
+      end
+
+      # Executed when a file has been scanned by RuboCop, adding the reported
+      # offenses to our collection.
+      #
+      # @param _file [String]
+      # @param offenses [Array<RuboCop::Cop::Offense>]
+      def file_finished(_file, offenses)
+        @offenses = offenses
+      end
+
+      # RuboCop caches results by taking a hash of the file contents & path, among other things.
+      # It disables its cache when working on file-content from stdin.
+      # Unfortunately we always use RuboCop's stdin, even when we're linting a file on-disk.
+      # So, override RuboCop::Runner#cached_run? so that it'll allow caching results, so long
+      # as haml-lint itself isn't being invoked with files on stdin.
+      def cached_run?
+        return false unless @allow_cache
+
+        @cached_run ||=
+          (@options[:cache] == 'true' ||
+          (@options[:cache] != 'false' && @config_store.for_pwd.for_all_cops['UseCache'])) &&
+          !@options[:auto_gen_config]
+      end
+    end
+
     include LinterRegistry
 
     supports_autocorrect(true)
@@ -98,9 +138,9 @@ module HamlLint
 
     def rubocop_config_for(path)
       user_config_path = ENV['HAML_LINT_RUBOCOP_CONF'] || config['config_file']
-      user_config_path ||= self.class.rubocop_config_store.user_rubocop_config_path_for(path)
+      user_config_path ||= rubocop_config_store.user_rubocop_config_path_for(path)
       user_config_path = File.absolute_path(user_config_path)
-      self.class.rubocop_config_store.config_object_pointing_to(user_config_path)
+      rubocop_config_store.config_object_pointing_to(user_config_path)
     end
 
     # Extracted here so that tests can stub this to always return true
@@ -168,15 +208,13 @@ module HamlLint
       false
     end
 
-    # A single CLI instance is shared between files to avoid RuboCop
+    # A single RuboCop runner is shared between files to avoid RuboCop
     # having to repeatedly reload .rubocop.yml.
-    def self.rubocop_cli # rubocop:disable Lint/IneffectiveAccessModifier
-      # The ivar is stored on the class singleton rather than the Linter instance
-      # because it can't be Marshal.dump'd (as used by Parallel.map)
-      @rubocop_cli ||= ::RuboCop::CLI.new
+    def rubocop_runner
+      @rubocop_runner ||= Runner.new(rubocop_options, ::RuboCop::ConfigStore.new)
     end
 
-    def self.rubocop_config_store # rubocop:disable Lint/IneffectiveAccessModifier
+    def rubocop_config_store
       @rubocop_config_store ||= RubocopConfigStore.new
     end
 
@@ -190,7 +228,7 @@ module HamlLint
     def process_ruby_source(ruby_code, source_map)
       filename = document.file || 'ruby_script.rb'
 
-      offenses, corrected_ruby = run_rubocop(self.class.rubocop_cli, ruby_code, filename)
+      offenses, corrected_ruby = run_rubocop(rubocop_runner, ruby_code, filename)
 
       extract_lints_from_offenses(offenses, source_map)
       corrected_ruby
@@ -199,55 +237,35 @@ module HamlLint
     # Runs RuboCop, returning the offenses and corrected code. Raises when RuboCop
     # fails to run correctly.
     #
-    # @param rubocop_cli [RuboCop::CLI] There to simplify tests by using a stub
+    # @param rubocop_runner [HamlLint::Linter::RuboCop::Runner] There to simplify tests by using a stub
     # @param ruby_code [String] The ruby code to run through RuboCop
     # @param path [String] the path to tell RuboCop we are running
     # @return [Array<RuboCop::Cop::Offense>, String]
-    def run_rubocop(rubocop_cli, ruby_code, path) # rubocop:disable Metrics
-      rubocop_status = nil
-      stdout_str, stderr_str = HamlLint::Utils.with_captured_streams(ruby_code) do
-        rubocop_cli.config_store.instance_variable_set(:@options_config, rubocop_config_for(path))
-        rubocop_status = rubocop_cli.run(rubocop_flags + ['--stdin', path])
-      end
+    def run_rubocop(rubocop_runner, ruby_code, path) # rubocop:disable Metrics
+      rubocop_runner.run(path, ruby_code, config: rubocop_config_for(path), allow_cache: @document&.file_on_disk)
 
       if ENV['HAML_LINT_INTERNAL_DEBUG'] == 'true'
-        if OffenseCollector.offenses.empty?
+        if rubocop_runner.offenses.empty?
           puts "------ No lints found by RuboCop in #{@document.file}"
         else
           puts "------ Raw lints found by RuboCop in #{@document.file}"
-          OffenseCollector.offenses.each do |offense|
+          rubocop_runner.offenses.each do |offense|
             puts offense
           end
           puts '------'
         end
       end
 
-      unless [::RuboCop::CLI::STATUS_SUCCESS, ::RuboCop::CLI::STATUS_OFFENSES].include?(rubocop_status)
-        if stderr_str.start_with?('Infinite loop')
-          msg = "RuboCop exited unsuccessfully with status #{rubocop_status}." \
-              ' This appears to be due to an autocorrection infinite loop.'
-          if ENV['HAML_LINT_DEBUG'] == 'true'
-            msg += " DEBUG: RuboCop's output:\n"
-            msg += stderr_str.strip
-          else
-            msg += " First line of RuboCop's output (Use --debug mode to see more):\n"
-            msg += stderr_str.each_line.first.strip
-          end
-
-          raise HamlLint::Exceptions::InfiniteLoopError, msg
-        end
-
-        raise HamlLint::Exceptions::ConfigurationError,
-              "RuboCop exited unsuccessfully with status #{rubocop_status}." \
-              ' Here is its output to check the stack trace or see if there was' \
-              " a misconfiguration:\n#{stderr_str}"
-      end
-
       if @autocorrect
-        corrected_ruby = stdout_str.partition("#{'=' * 20}\n").last
+        corrected_ruby = rubocop_runner.corrected_code
       end
 
-      [OffenseCollector.offenses, corrected_ruby]
+      [rubocop_runner.offenses, corrected_ruby]
+    rescue ::RuboCop::Error => e
+      raise HamlLint::Exceptions::ConfigurationError,
+            "RuboCop raised #{e}." \
+            ' Here is its output to check the stack trace or see if there was' \
+            " a misconfiguration:\n#{e.message}\n#{e.backtrace}"
     end
 
     # Aggregates RuboCop offenses and converts them to {HamlLint::Lint}s
@@ -294,14 +312,27 @@ module HamlLint
                                    corrected: corrected)
     end
 
-    # Returns flags that will be passed to RuboCop CLI.
+    # rubocop:disable Style/MutableConstant
+    # Using BaseFormatter suppresses any default output
+    DEFAULT_FLAGS = %w[--format RuboCop::Formatter::BaseFormatter]
+    begin
+      ::RuboCop::Options.new.parse(['--raise-cop-error'])
+      DEFAULT_FLAGS << '--raise-cop-error'
+    rescue OptionParser::InvalidOption
+      # older versions of RuboCop don't support this flag
+    end
+    DEFAULT_FLAGS.freeze
+    # rubocop:enable Style/MutableConstant
+
+    # Returns options that will be passed to the RuboCop runner.
     #
-    # @return [Array<String>]
-    def rubocop_flags
-      flags = %w[--format HamlLint::OffenseCollector]
+    # @return [Hash]
+    def rubocop_options
+      flags = DEFAULT_FLAGS
       flags += ignored_cops_flags
       flags += rubocop_autocorrect_flags
-      flags
+      options, _args = ::RuboCop::Options.new.parse(flags)
+      options
     end
 
     def rubocop_autocorrect_flags
@@ -342,29 +373,19 @@ module HamlLint
       return [] if ignored_cops.empty?
       ['--except', ignored_cops.uniq.join(',')]
     end
-  end
 
-  # Collects offenses detected by RuboCop.
-  class OffenseCollector < ::RuboCop::Formatter::BaseFormatter
-    class << self
-      # List of offenses reported by RuboCop.
-      attr_accessor :offenses
-    end
-
-    # Executed when RuboCop begins linting.
-    #
-    # @param _target_files [Array<String>]
-    def started(_target_files)
-      self.class.offenses = []
+    # Exclude ivars that don't marshal properly
+    def marshal_dump
+      excluded_ivars = %i[@rubocop_runner @rubocop_config_store @user_config_path_to_config_object]
+      (instance_variables - excluded_ivars).to_h do |ivar|
+        [ivar, instance_variable_get(ivar)]
+      end
     end
 
-    # Executed when a file has been scanned by RuboCop, adding the reported
-    # offenses to our collection.
-    #
-    # @param _file [String]
-    # @param offenses [Array<RuboCop::Cop::Offense>]
-    def file_finished(_file, offenses)
-      self.class.offenses += offenses
+    def marshal_load(ivars)
+      ivars.each do |k, v|
+        instance_variable_set(k, v)
+      end
     end
   end
 

data/lib/haml_lint/runner.rb

@@ -89,6 +89,7 @@ module HamlLint
       begin
         document = HamlLint::Document.new source.contents, file: source.path,
                                                            config: config,
+                                                           file_on_disk: !source.stdin?,
                                                            write_to_stdout: @autocorrect_stdout
       rescue HamlLint::Exceptions::ParseError => e
         return [HamlLint::Lint.new(HamlLint::Linter::Syntax.new(config), source.path,

data/lib/haml_lint/source.rb

@@ -20,5 +20,10 @@ module HamlLint
     def contents
       @contents ||= @io&.read || File.read(path)
     end
+
+    # @return [boolean] true if we're reading from stdin rather than a file path
+    def stdin?
+      !@io.nil?
+    end
   end
 end

data/lib/haml_lint/utils.rb

@@ -249,34 +249,6 @@ module HamlLint
       $!
     end
 
-    # Overrides the global stdin, stdout and stderr while within the block, to
-    # push a string in stdin, and capture both stdout and stderr which are returned.
-    #
-    # @param stdin_str [String] the string to push in as stdin
-    # @param _block [Block] the block to perform with the overridden std streams
-    # @return [String, String]
-    def with_captured_streams(stdin_str, &_block)
-      original_stdin = $stdin
-      # The dup is needed so that stdin_data isn't altered (encoding-wise at least)
-      $stdin = StringIO.new(stdin_str.dup)
-      begin
-        original_stdout = $stdout
-        $stdout = StringIO.new
-        begin
-          original_stderr = $stderr
-          $stderr = StringIO.new
-          yield
-          [$stdout.string, $stderr.string]
-        ensure
-          $stderr = original_stderr
-        end
-      ensure
-        $stdout = original_stdout
-      end
-    ensure
-      $stdin = original_stdin
-    end
-
     def regexp_for_parts(parts, join_regexp, prefix: nil, suffix: nil)
       regexp_code = parts.map { |c| Regexp.quote(c) }.join(join_regexp)
       regexp_code = "#{prefix}#{regexp_code}#{suffix}"

data/lib/haml_lint/version.rb

@@ -2,5 +2,5 @@
 
 # Defines the gem version.
 module HamlLint
-  VERSION = '0.62.0'
+  VERSION = '0.64.0'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: haml_lint
 version: !ruby/object:Gem::Version
-  version: 0.62.0
+  version: 0.64.0
 platform: ruby
 authors:
 - Shane da Silva
 bindir: bin
 cert_chain: []
-date: 2025-04-08 00:00:00.000000000 Z
+date: 2025-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: haml