haml_lint 0.53.0 → 0.76.0

data/lib/haml_lint/ruby_extraction/chunk_extractor.rb

@@ -4,12 +4,12 @@
 module HamlLint::RubyExtraction
   # Extracts "chunks" of the haml file into instances of subclasses of HamlLint::RubyExtraction::BaseChunk.
   #
-  # This is the first step of generating Ruby code from a HAML file to then be processed by RuboCop.
+  # This is the first step of generating Ruby code from a Haml file to then be processed by RuboCop.
   # See HamlLint::RubyExtraction::BaseChunk for more details.
   class ChunkExtractor
     include HamlLint::HamlVisitor
 
-    attr_reader :script_output_prefix
+    attr_reader :script_output_prefix, :autocorrect
 
     HAML_PARSER_INSTANCE = if Haml::VERSION >= '5.0.0'
                              ::Haml::Parser.new({})
@@ -17,9 +17,14 @@ module HamlLint::RubyExtraction
                              ::Haml::Parser.new('', {})
                            end
 
-    def initialize(document, script_output_prefix:)
+    # Haml strips newlines when handling multi-line statements (using pipes or trailing comma)
+    # We don't. So the regex must be fixed to correctly detect the start of the string.
+    BLOCK_KEYWORD_REGEX = Regexp.new(Haml::Parser::BLOCK_KEYWORD_REGEX.source.sub('^', '\A'))
+
+    def initialize(document, script_output_prefix:, autocorrect: nil)
       @document = document
       @script_output_prefix = script_output_prefix
+      @autocorrect = autocorrect
     end
 
     def extract
@@ -119,7 +124,7 @@ module HamlLint::RubyExtraction
     def visit_script(node, &block)
       raw_first_line = @original_haml_lines[node.line - 1]
 
-      # ==, !, !==, &, &== means interpolation (was needed before HAML 2.2... it's still supported)
+      # ==, !, !==, &, &== means interpolation (was needed before Haml 2.2... it's still supported)
       # =, !=, &= mean actual ruby code is coming
       # Anything else is interpolation
       # The regex lists the case for Ruby Code. The 3 cases and making sure they are not followed by another = sign
@@ -164,20 +169,20 @@ module HamlLint::RubyExtraction
           prev_chunk.node == node.parent
         # When an outputting script is nested under another outputting script,
         # we want to block them from being merged together by rubocop, because
-        # this doesn't make sense in HAML.
+        # this doesn't make sense in Haml.
         # Example:
         #   = if this_is_short
         #     = this_is_short_too
         # Could become (after RuboCop):
         #   HL.out = (HL.out = this_is_short_too if this_is_short)
-        # Or in (broken) HAML style:
+        # Or in (broken) Haml style:
         #   = this_is_short_too = if this_is_short
         # By forcing this to start a chunk, there will be extra placeholders which
         # blocks rubocop from merging the lines.
         must_start_chunk = true
       elsif script_prefix != '='
         # In the few cases where &= and != are used to start the script,
-        # We need to remember and put it back in the final HAML. Fusing scripts together
+        # We need to remember and put it back in the final Haml. Fusing scripts together
         # would make that basically impossible. Instead, a script has a "first_output_prefix"
         # field for this specific case
         must_start_chunk = true
@@ -247,31 +252,29 @@ module HamlLint::RubyExtraction
     def visit_tag(node)
       indent = @original_haml_lines[node.line - 1].index(/\S/)
 
+      @ruby_chunks << PlaceholderMarkerChunk.new(node, 'tag', indent: indent)
+
+      current_line_index = visit_tag_attributes(node, indent: indent)
+      visit_tag_script(node, line_index: current_line_index, indent: indent)
+
       # We don't want to use a block because assignments in a block are local to that block,
       # so the semantics of the extracted ruby would be different from the one generated by
       # Haml. Those differences can make some cops, such as UselessAssignment, have false
       # positives
       code = 'begin'
-      @ruby_chunks << AdHocChunk.new(node,
-                                     [' ' * indent + code])
-      indent += 2
+      begin_chunk = AdHocChunk.new(node, [' ' * indent + code])
+      @ruby_chunks << begin_chunk
 
-      tag_chunk = PlaceholderMarkerChunk.new(node, 'tag', indent: indent)
-      @ruby_chunks << tag_chunk
-
-      current_line_index = visit_tag_attributes(node, indent: indent)
-      visit_tag_script(node, line_index: current_line_index, indent: indent)
+      indent += 2
 
       yield
 
       indent -= 2
 
-      if @ruby_chunks.last.equal?(tag_chunk)
+      if @ruby_chunks.last.equal?(begin_chunk)
         # So there is nothing going "in" the tag, remove the wrapping "begin" and replace the PlaceholderMarkerChunk
         # by one less indented
         @ruby_chunks.pop
-        @ruby_chunks.pop
-        @ruby_chunks << PlaceholderMarkerChunk.new(node, 'tag', indent: indent)
       else
         @ruby_chunks << AdHocChunk.new(node,
                                        [' ' * indent + 'ensure', ' ' * indent + '  HL.noop', ' ' * indent + 'end'],
@@ -297,7 +300,13 @@ module HamlLint::RubyExtraction
       end
 
       if attributes_code&.start_with?('{')
-        # Looks like the .foo(bar = 123) case. Ignoring.
+        # HTML-style (parens) attributes, e.g. %div(foo=foo), arrive as a synthesized hash string
+        # like '{"foo" => foo,}'. That text isn't present verbatim in the Haml, so we can't map
+        # RuboCop corrections back and intentionally don't autocorrect it. We still extract the
+        # attribute *values* as a non-correctable chunk so RuboCop sees variables used here;
+        # otherwise they look unused (false Lint/UselessAssignment, plus unsafe autocorrect that
+        # removes the assignment). See issue #648.
+        add_html_attributes_value_usage(node, attributes_code, indent: indent)
         attributes_code = nil
       end
 
@@ -342,6 +351,22 @@ module HamlLint::RubyExtraction
       final_line_index
     end
 
+    # For HTML-style (parens) attributes, adds the attribute value expressions as a
+    # non-autocorrectable chunk purely so RuboCop counts the variables/methods used there.
+    def add_html_attributes_value_usage(node, attributes_code, indent:)
+      ast = parse_ruby(attributes_code)
+      return unless ast&.type == :hash
+
+      value_sources = ast.children.filter_map do |pair|
+        next unless pair.type == :pair
+        pair.children[1]&.source
+      end
+      return if value_sources.empty?
+
+      lines = value_sources.map { |value| "#{' ' * indent}#{script_output_prefix}#{value}" }
+      @ruby_chunks << AdHocChunk.new(node, lines)
+    end
+
     # Visiting the script besides tag. The part to the right of the equal sign of
     # lines looking like `  %div= foo(bar)`
     def visit_tag_script(node, line_index:, indent:)
@@ -381,7 +406,7 @@ module HamlLint::RubyExtraction
       end
     end
 
-    # Visiting a HAML filter. Lines looking like `  :javascript` and the following lines
+    # Visiting a Haml filter. Lines looking like `  :javascript` and the following lines
     # that are nested.
     def visit_filter(node)
       # For unknown reasons, haml doesn't escape interpolations in filters.
@@ -389,10 +414,12 @@ module HamlLint::RubyExtraction
       filter_name_indent = @original_haml_lines[node.line - 1].index(/\S/)
       if node.filter_type == 'ruby'
         # The indentation in node.text is normalized, so that at least one line
-        # is indented by 0.
-        lines = node.text.split("\n")
+        # is indented by 0. Split("\n", -1) + pop keeps trailing blank lines (plain split drops them),
+        # which the end marker needs so it doesn't land right after the last code line.
+        lines = node.text.split("\n", -1)
+        lines.pop
         lines.map! do |line|
-          if line !~ /\S/
+          if !/\S/.match?(line)
             # whitespace or empty
             ''
           else
@@ -494,14 +521,14 @@ module HamlLint::RubyExtraction
     # The first and last lines may not be the complete lines from the Haml, only the Ruby parts
     # and the indentation between the first and last list.
 
-    # HAML transforms the ruby code in many ways as it parses a document. Often removing lines and/or
+    # Haml transforms the ruby code in many ways as it parses a document. Often removing lines and/or
     # indentation. This is quite annoying for us since we want the exact layout of the code to analyze it.
     #
     # This function receives the code as haml provides it and the line where it starts. It returns
     # the actual code as it is in the haml file, keeping breaks and indentation for the following lines.
     # In addition, the start position of the code in the first line.
     #
-    # The rules for handling multiline code in HAML are as follow:
+    # The rules for handling multiline code in Haml are as follow:
     # * if the line being processed ends with a space and a pipe, then append to the line (without
     #   newlines) every following lines that also end with a space and a pipe. This means the last line of
     #   the "block" also needs a pipe at the end.
@@ -548,7 +575,7 @@ module HamlLint::RubyExtraction
       joined_lines = lines.join("\n")
 
       if haml_processed_ruby_code.include?("\n")
-        haml_processed_ruby_code = haml_processed_ruby_code.gsub("\n", ' ')
+        haml_processed_ruby_code = haml_processed_ruby_code.tr("\n", ' ')
       end
 
       haml_processed_ruby_code.split(/[, ]/)
@@ -600,9 +627,12 @@ module HamlLint::RubyExtraction
         return [char_index, [haml_processed_ruby_code]]
       end
 
-      min_non_white_chars_to_add = haml_processed_ruby_code.scan(/\S/).size
+      # The +1 is for the closing brace, which we need
+      min_non_white_chars_to_add = haml_processed_ruby_code.scan(/\S/).size + 1
 
-      regexp = HamlLint::Utils.regexp_for_parts(haml_processed_ruby_code.split(/\s+/), '\\s+')
+      regexp = HamlLint::Utils.regexp_for_parts(
+        haml_processed_ruby_code.split(/\s+/), '\\s+', prefix: '\s*', suffix: '\s*(?=[)}])'
+      )
 
       joined_lines = first_line.rstrip
       process_multiline!(joined_lines)
@@ -624,7 +654,7 @@ module HamlLint::RubyExtraction
 
       first_line_offset = match.begin(0)
       raw_ruby = match[0]
-      ruby_lines = raw_ruby.split("\n")
+      ruby_lines = raw_ruby.split("\n", -1)
 
       [first_line_offset, ruby_lines]
     end
@@ -632,8 +662,19 @@ module HamlLint::RubyExtraction
     def wrap_lines(lines, wrap_depth)
       lines = lines.dup
       wrapping_prefix = 'W' * (wrap_depth - 1) + '('
+
+      # Strip leading/trailing space only when linting (not autocorrecting) to avoid SpaceInsideParens violations.
+      # Preserve spaces for fully nested attribute hashes that need no adjustment.
+      # Preserve spaces during autocorrect, so RuboCop can fix them and map corrections back correctly.
+      unless lines[0] =~ /^\s*$/ || autocorrect
+        leading_spaces = lines[0][/^\s*/].length
+        lines = lines.map { |line| line.gsub(/^\s{,#{leading_spaces}}/, '') }
+        lines[-1] = lines[-1].gsub(/\s+\z/, '')
+      end
+
       lines[0] = wrapping_prefix + lines[0]
       lines[-1] = lines[-1] + ')'
+
       lines
     end
 
@@ -673,7 +714,7 @@ module HamlLint::RubyExtraction
 
     def self.anonymous_block?(code)
       # Don't start with a comment and end with a `do`
-      # Definetly not perfect for the comment handling, but otherwise a more advanced parsing system is needed.
+      # Definitely not perfect for the comment handling, but otherwise a more advanced parsing system is needed.
       # Move the comment to its own line if it's annoying.
       code !~ /\A\s*#/ &&
         code =~ /\bdo\s*(\|[^|]*\|\s*)?(#.*)?\z/
@@ -686,12 +727,12 @@ module HamlLint::RubyExtraction
 
     LOOP_KEYWORDS = %w[for until while].freeze
     def self.block_keyword(code)
-      # Need to handle 'for'/'while' since regex stolen from HAML parser doesn't
+      # Need to handle 'for'/'while' since regex stolen from Haml parser doesn't
       if (keyword = code[/\A\s*([^\s]+)\s+/, 1]) && LOOP_KEYWORDS.include?(keyword)
         return keyword
       end
 
-      return unless keyword = code.scan(Haml::Parser::BLOCK_KEYWORD_REGEX)[0]
+      return unless keyword = code.scan(BLOCK_KEYWORD_REGEX)[0]
       keyword[0] || keyword[1]
     end
   end

data/lib/haml_lint/ruby_extraction/coordinator.rb

@@ -9,7 +9,7 @@ module HamlLint::RubyExtraction
   # * Preprocess the chunks to cleanup/fuse some of them.
   # * Generates the extracted ruby code from the Chunks.
   # * Handles the markers (see below)
-  # * Use the chunks to transfer corrections from corrected Ruby code back to HAML
+  # * Use the chunks to transfer corrections from corrected Ruby code back to Haml
   #
   # The generated Ruby code uses markers to wrap around the Ruby code from the chunks.
   # Those markers look like function calls, like: `haml_lint_marker_1`, so are valid ruby.
@@ -22,14 +22,18 @@ module HamlLint::RubyExtraction
     # @return [String] The prefix used for markers in the Ruby code
     attr_reader :marker_prefix
 
-    # @return [Array<String>] The ruby lines after extraction from HAML (before RuboCop)
+    # @return [Array<String>] The ruby lines after extraction from Haml (before RuboCop)
     attr_reader :assembled_ruby_lines
 
     # @return [Array<String>] The ruby lines after correction by RuboCop
     attr_reader :corrected_ruby_lines
 
-    def initialize(document)
+    # @return [Symbol, nil] The autocorrect mode (:safe, :all, or nil)
+    attr_reader :autocorrect
+
+    def initialize(document, autocorrect:)
       @document = document
+      @autocorrect = autocorrect
       @ruby_chunks = nil
       @assembled_ruby_lines = nil
       @corrected_ruby_lines = nil
@@ -46,7 +50,8 @@ module HamlLint::RubyExtraction
       pick_a_script_output_prefix
 
       @ruby_chunks = HamlLint::RubyExtraction::ChunkExtractor.new(@document,
-                                                                  script_output_prefix: @script_output_prefix).extract
+                                                                  script_output_prefix: @script_output_prefix,
+                                                                  autocorrect: autocorrect).extract
       preprocess_chunks
 
       @assembled_ruby_lines = []

data/lib/haml_lint/ruby_extraction/implicit_end_chunk.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::RubyExtraction
-  # HAML adds a `end` when code gets outdented. We need to add that to the Ruby too, this
+  # Haml adds a `end` when code gets outdented. We need to add that to the Ruby too, this
   # is the chunk for it.
   # However:
   # * we can't apply fixes to it, so there are no markers

data/lib/haml_lint/ruby_extraction/non_ruby_filter_chunk.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module HamlLint::RubyExtraction
-  # Chunk for dealing with every HAML filter other than `:ruby`
+  # Chunk for dealing with every Haml filter other than `:ruby`
   # The generated Ruby for these is just a HEREDOC, so interpolation is corrected at
   # the same time by RuboCop.
   class NonRubyFilterChunk < BaseChunk
@@ -14,7 +14,7 @@ module HamlLint::RubyExtraction
       to_content_lines = to_ruby_lines[1...-1]
 
       to_haml_lines = to_content_lines.map do |line|
-        if line !~ /\S/
+        if !/\S/.match?(line)
           # whitespace or empty
           ''
         else

data/lib/haml_lint/ruby_extraction/placeholder_marker_chunk.rb

@@ -5,7 +5,7 @@ module HamlLint::RubyExtraction
   # transfer the corrections it receives to the indentation of the associated lines.
   #
   # Also used so that Rubocop doesn't think that there is nothing in `if` and other such structures,
-  # so that it does corrections that make sense for the HAML.
+  # so that it does corrections that make sense for the Haml.
   class PlaceholderMarkerChunk < BaseChunk
     def initialize(node, marker_name, indent:, nb_lines: 1, **kwargs)
       @marker_name = marker_name

data/lib/haml_lint/ruby_extraction/ruby_filter_chunk.rb

@@ -19,7 +19,7 @@ module HamlLint::RubyExtraction
       haml_lines[@haml_line_index - 1] = HamlLint::Utils.indent(haml_lines[@haml_line_index - 1], delta_indent)
 
       to_haml_lines = to_ruby_lines.map do |line|
-        if line !~ /\S/
+        if !/\S/.match?(line)
           # whitespace or empty
           ''
         else

data/lib/haml_lint/ruby_extraction/script_chunk.rb

@@ -18,7 +18,7 @@ module HamlLint::RubyExtraction
     attr_reader :must_start_chunk
 
     # @return [Array<Integer>] Line indexes to ignore when building the source_map. For examples,
-    #   implicit `end` are on their own line in the Ruby file, but in the HAML, they are absent.
+    #   implicit `end` are on their own line in the Ruby file, but in the Haml, they are absent.
     attr_reader :skip_line_indexes_in_source_map
 
     # @return [HamlLint::RubyExtraction::BaseChunk] The previous chunk can affect how
@@ -113,7 +113,7 @@ module HamlLint::RubyExtraction
       line_start_indexes_that_need_pipes = []
       haml_output_prefix = first_output_haml_prefix
       to_haml_lines = to_ruby_lines.map.with_index do |line, i| # rubocop:disable Metrics/BlockLength
-        if line !~ /\S/
+        if !/\S/.match?(line)
           # whitespace or empty lines, we don't want any indentation
           ''
         elsif statement_start_line_indexes.include?(i)

data/lib/haml_lint/runner.rb

@@ -2,6 +2,8 @@
 
 require 'parallel'
 
+require_relative 'source'
+
 module HamlLint
   # Responsible for running the applicable linters against the desired files.
   class Runner
@@ -20,12 +22,14 @@ module HamlLint
     # @return [HamlLint::Report] a summary of all lints found
     def run(options = {})
       @config = load_applicable_config(options)
-      @files = extract_applicable_files(config, options)
-      @linter_selector = HamlLint::LinterSelector.new(config, options)
+      @sources = extract_applicable_sources(config, options)
+      @options = options
+      @linter_selector = build_linter_selector
       @fail_fast = options.fetch(:fail_fast, false)
       @cache = {}
       @autocorrect = options[:autocorrect]
       @autocorrect_only = options[:autocorrect_only]
+      @autocorrect_stdout = options[:stdin] && options[:stderr]
 
       report(options)
     end
@@ -48,16 +52,41 @@ module HamlLint
     #   @return [true, false]
     alias fail_fast? fail_fast
 
-    # The list of files to lint during this run.
+    # The list of sources to lint during this run.
     #
-    # @return [Array<String>]
-    attr_reader :files
+    # @return [Array<HamlLint::Source>]
+    attr_reader :sources
 
     # The selector for which linters to run during this run.
     #
     # @return [HamlLint::LinterSelector]
     attr_reader :linter_selector
 
+    PARALLEL_LINTER_SELECTOR_THREAD_KEY = :haml_lint_runner_parallel_linter_selectors
+
+    # Returns a fresh selector for this run.
+    #
+    # LinterSelector memoizes linter instances, and linters mutate instance
+    # state while processing a document. JRuby runs Parallel.map in threads, so
+    # parallel jobs must not share a selector.
+    #
+    # @return [HamlLint::LinterSelector]
+    def build_linter_selector
+      HamlLint::LinterSelector.new(config, @options)
+    end
+
+    # Returns a selector scoped to the current parallel worker.
+    #
+    # MRI runs Parallel.map in forked processes, so each worker can safely reuse
+    # its own linter instances. JRuby runs Parallel.map in threads, so this must
+    # be isolated per thread to avoid sharing mutable linter state.
+    #
+    # @return [HamlLint::LinterSelector]
+    def parallel_linter_selector
+      selectors = Thread.current[PARALLEL_LINTER_SELECTOR_THREAD_KEY] ||= {}.compare_by_identity
+      selectors[self] ||= build_linter_selector
+    end
+
     # Returns the {HamlLint::Configuration} that should be used given the
     # specified options.
     #
@@ -79,18 +108,20 @@ module HamlLint
     # Runs all provided linters using the specified config against the given
     # file.
     #
-    # @param file [String] path to file to lint
+    # @param source [HamlLint::Source] source to lint
     # @param linter_selector [HamlLint::LinterSelector]
     # @param config [HamlLint::Configuration]
-    def collect_lints(file, linter_selector, config)
+    def collect_lints(source, linter_selector, config)
       begin
-        document = HamlLint::Document.new(File.read(file), file: file, config: config)
+        document = HamlLint::Document.new source.contents, file: source.path,
+                                                           config: config,
+                                                           write_to_stdout: @autocorrect_stdout
       rescue HamlLint::Exceptions::ParseError => e
-        return [HamlLint::Lint.new(HamlLint::Linter::Syntax.new(config), file,
+        return [HamlLint::Lint.new(HamlLint::Linter::Syntax.new(config), source.path,
                                    e.line, e.to_s, :error)]
       end
 
-      linters = linter_selector.linters_for_file(file)
+      linters = linter_selector.linters_for_file(source.path)
       lint_arrays = []
 
       if @autocorrect
@@ -116,6 +147,9 @@ module HamlLint
       lint_arrays = []
 
       autocorrecting_linters = linters.select(&:supports_autocorrect?)
+                                      .each_with_index
+                                      .sort_by { |linter, index| [linter.class.autocorrect_priority, index] }
+                                      .map(&:first)
       lint_arrays << autocorrecting_linters.map do |linter|
         linter.run(document, autocorrect: @autocorrect)
       end
@@ -125,40 +159,46 @@ module HamlLint
       lint_arrays
     end
 
-    # Returns the list of files that should be linted given the specified
+    # Returns the list of sources that should be linted given the specified
     # configuration and options.
     #
     # @param config [HamlLint::Configuration]
     # @param options [Hash]
-    # @return [Array<String>]
-    def extract_applicable_files(config, options)
-      included_patterns = options[:files]
-      excluded_patterns = config['exclude']
-      excluded_patterns += options.fetch(:excluded_files, [])
+    # @return [Array<HamlLint::Source>]
+    def extract_applicable_sources(config, options)
+      if options[:stdin]
+        [HamlLint::Source.new(io: $stdin, path: options[:stdin])]
+      else
+        included_patterns = options[:files]
+        excluded_patterns = config['exclude']
+        excluded_patterns += options.fetch(:excluded_files, [])
 
-      HamlLint::FileFinder.new(config).find(included_patterns, excluded_patterns)
+        HamlLint::FileFinder.new(config).find(included_patterns, excluded_patterns).map do |file_path|
+          HamlLint::Source.new path: file_path
+        end
+      end
     end
 
-    # Process the files and add them to the given report.
+    # Process the sources and add them to the given report.
     #
     # @param report [HamlLint::Report]
     # @return [void]
-    def process_files(report)
-      files.each do |file|
-        process_file(file, report)
+    def process_sources(report)
+      sources.each do |source|
+        process_source(source, report)
         break if report.failed? && fail_fast?
       end
     end
 
     # Process a file and add it to the given report.
     #
-    # @param file [String] the name of the file to process
+    # @param source [HamlLint::Source] the source to process
     # @param report [HamlLint::Report]
     # @return [void]
-    def process_file(file, report)
-      lints = @cache[file] || collect_lints(file, linter_selector, config)
+    def process_source(source, report)
+      lints = @cache[source.path] || collect_lints(source, linter_selector, config)
       lints.each { |lint| report.add_lint(lint) }
-      report.finish_file(file, lints)
+      report.finish_file(source.path, lints)
     end
 
     # Generates a report based on the given options.
@@ -168,9 +208,9 @@ module HamlLint
     # @return [HamlLint::Report]
     def report(options)
       report = HamlLint::Report.new(reporter: options[:reporter], fail_level: options[:fail_level])
-      report.start(@files)
+      report.start(sources.map(&:path))
       warm_cache if options[:parallel]
-      process_files(report)
+      process_sources(report)
       report
     end
 
@@ -178,9 +218,9 @@ module HamlLint
     #
     # @return [void]
     def warm_cache
-      results = Parallel.map(files) do |file|
-        lints = collect_lints(file, linter_selector, config)
-        [file, lints]
+      results = Parallel.map(sources) do |source|
+        lints = collect_lints(source, parallel_linter_selector, config)
+        [source.path, lints]
       end
       @cache = results.to_h
     end

data/lib/haml_lint/source.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module HamlLint
+  # Wrapper class representing a single target for HamlLint::Runner to run against, comprised of a file path to
+  # eventually read from, and an optional IO argument to override with.
+  class Source
+    # @return [String] File path associated with the given IO object.
+    attr_reader :path
+
+    # Wraps an optional IO object and file path to a source object.
+    #
+    # @param [String] path
+    # @param [IO] io
+    def initialize(path: nil, io: nil)
+      @path = path
+      @file_path = File.expand_path(path) if path
+      @io = io
+    end
+
+    # @return [String] Contents of the given IO object.
+    def contents
+      @contents ||= @io&.read || File.read(@file_path)
+    end
+  end
+end

data/lib/haml_lint/spec/matchers/report_lint.rb

@@ -11,10 +11,11 @@ module HamlLint
         expected_message = options[:message]
         expected_severity = options[:severity]
         expected_corrected = options[:corrected]
+        expected_correctable = options[:correctable]
 
         match do |linter|
           has_lints?(linter, expected_line, count, expected_message, expected_severity,
-                     expected_corrected)
+                     expected_corrected, expected_correctable)
         end
 
         failure_message do |linter|
@@ -65,15 +66,16 @@ module HamlLint
             (expected_severity ? " with severity '#{expected_severity}'" : '')
         end
 
-        def has_lints?(linter, expected_line, count, expected_message, expected_severity, # rubocop:disable Metrics/ParameterLists
-                       expected_corrected)
+        def has_lints?(linter, expected_line, count, expected_message, expected_severity, # rubocop:disable Metrics/ParameterLists,Naming
+                       expected_corrected, expected_correctable)
           if expected_line
             has_expected_line_lints?(linter,
                                      expected_line,
                                      count,
                                      expected_message,
                                      expected_severity,
-                                     expected_corrected)
+                                     expected_corrected,
+                                     expected_correctable)
           elsif count
             linter.lints.count == count
           elsif expected_message
@@ -83,12 +85,13 @@ module HamlLint
           end
         end
 
-        def has_expected_line_lints?(linter, # rubocop:disable Metrics/ParameterLists
+        def has_expected_line_lints?(linter, # rubocop:disable Metrics/ParameterLists,Naming
                                      expected_line,
                                      count,
                                      expected_message,
                                      expected_severity,
-                                     expected_corrected)
+                                     expected_corrected,
+                                     expected_correctable)
           if count
             multiple_lints_match_line?(linter, expected_line, count)
           elsif expected_message
@@ -97,6 +100,8 @@ module HamlLint
             lint_on_line_matches_severity?(linter, expected_line, expected_severity)
           elsif !expected_corrected.nil?
             lint_on_line_matches_corrected?(linter, expected_line, expected_corrected)
+          elsif !expected_correctable.nil?
+            lint_on_line_matches_correctable?(linter, expected_line, expected_correctable)
           else
             lint_lines(linter).include?(expected_line)
           end
@@ -126,6 +131,12 @@ module HamlLint
             .any? { |lint| lint.line == expected_line && lint.corrected == expected_corrected }
         end
 
+        def lint_on_line_matches_correctable?(linter, expected_line, expected_correctable)
+          linter
+            .lints
+            .any? { |lint| lint.line == expected_line && lint.correctable == expected_correctable }
+        end
+
         def lint_messages_match?(linter, expected_message)
           # Using === to support regex to match anywhere in the string
           lint_messages(linter).all? { |message| expected_message === message } # rubocop:disable Style/CaseEquality