haml_lint 0.45.0 → 0.47.0

data/lib/haml_lint/ruby_extraction/haml_comment_chunk.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # Chunk for haml comments. Lines like `  -# Some commenting!`.
+  # Only deals with indentation while correcting, but can also be fused to a ScriptChunk.
+  class HamlCommentChunk < BaseChunk
+    def fuse(following_chunk)
+      return unless following_chunk.is_a?(HamlCommentChunk)
+
+      # We only merge consecutive comments
+      # The main reason to want to at least merge those is
+      # so that an empty comment doesn't get removed by rubocop by mistake
+      return if @haml_line_index + 1 != following_chunk.haml_line_index
+
+      HamlCommentChunk.new(node, @ruby_lines + following_chunk.ruby_lines, end_marker_indent: end_marker_indent)
+    end
+
+    def fuse_script_chunk(following_chunk)
+      return if following_chunk.end_marker_indent.nil?
+      return if following_chunk.must_start_chunk
+
+      nb_blank_lines_between = following_chunk.haml_line_index - haml_line_index - nb_haml_lines
+      blank_lines = nb_blank_lines_between > 0 ? [''] * nb_blank_lines_between : []
+      new_lines = @ruby_lines + blank_lines + following_chunk.ruby_lines
+
+      source_map_skips = @skip_line_indexes_in_source_map
+      source_map_skips.concat(following_chunk.skip_line_indexes_in_source_map
+                                .map { |i| i + @ruby_lines.size })
+
+      ScriptChunk.new(node,
+                      new_lines,
+                      haml_line_index: haml_line_index,
+                      skip_line_indexes_in_source_map: source_map_skips,
+                      end_marker_indent: following_chunk.end_marker_indent,
+                      previous_chunk: previous_chunk)
+    end
+
+    def transfer_correction_logic(_coordinator, to_ruby_lines, haml_lines)
+      if to_ruby_lines.empty?
+        haml_lines.slice!(@haml_line_index..haml_end_line_index)
+        return
+      end
+      delta_indent = min_indent_of(to_ruby_lines) - min_indent_of(@ruby_lines)
+
+      HamlLint::Utils.map_subset!(haml_lines, @haml_line_index..haml_end_line_index) do |l|
+        HamlLint::Utils.indent(l, delta_indent)
+      end
+    end
+
+    def min_indent_of(lines)
+      lines.map { |l| l.index(/\S/) }.compact.min
+    end
+  end
+end

data/lib/haml_lint/ruby_extraction/implicit_end_chunk.rb

@@ -0,0 +1,17 @@
+# 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
+  # is the chunk for it.
+  # However:
+  # * we can't apply fixes to it, so there are no markers
+  # * this is a distinct class so that a ScriptChunk can fuse this ImplicitEnd into itself,
+  #   So that we can generate bigger chunks of uninterrupted Ruby.
+  class ImplicitEndChunk < BaseChunk
+    def wrap_in_markers
+      false
+    end
+
+    def transfer_correction(coordinator, all_corrected_ruby_lines, haml_lines); end
+  end
+end

data/lib/haml_lint/ruby_extraction/interpolation_chunk.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # Deals with interpolation within a plain text, filter, etc.
+  # Can only handling single line interpolation, so will be skipped if it takes
+  # more than one line or if the correction takes more than one line.
+  #
+  # Stores the char index to know where in the line to do the replacements.
+  class InterpolationChunk < BaseChunk
+    def initialize(*args, start_char_index:, **kwargs)
+      super(*args, **kwargs)
+      @start_char_index = start_char_index
+    end
+
+    def transfer_correction_logic(coordinator, to_ruby_lines, haml_lines)
+      return if @ruby_lines.size != 1
+      return if to_ruby_lines.size != 1
+
+      from_ruby_line = @ruby_lines.first.partition(coordinator.script_output_prefix).last
+      to_ruby_line = to_ruby_lines.first.partition(coordinator.script_output_prefix).last
+
+      haml_line = haml_lines[@haml_line_index]
+      haml_line[@start_char_index...(@start_char_index + from_ruby_line.size)] = to_ruby_line
+    end
+  end
+end

data/lib/haml_lint/ruby_extraction/non_ruby_filter_chunk.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # 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
+    def transfer_correction_logic(_coordinator, to_ruby_lines, haml_lines)
+      delta_indent = to_ruby_lines.first.index(/\S/) - @ruby_lines.first.index(/\S/)
+
+      haml_lines[@haml_line_index] = HamlLint::Utils.indent(haml_lines[@haml_line_index], delta_indent)
+
+      # Ignoring the starting <<~HAML_LINT_FILTER and ending end
+      to_content_lines = to_ruby_lines[1...-1]
+
+      to_haml_lines = to_content_lines.map do |line|
+        if line !~ /\S/
+          # whitespace or empty
+          ''
+        else
+          line
+        end
+      end
+
+      haml_lines[(@haml_line_index + 1)..haml_end_line_index] = to_haml_lines
+    end
+
+    def skip_line_indexes_in_source_map
+      [@ruby_lines.size - 1]
+    end
+  end
+end

data/lib/haml_lint/ruby_extraction/placeholder_marker_chunk.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # This chunk just adds a marker (with a custom name) to the generated Ruby and only attempts to
+  # 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.
+  class PlaceholderMarkerChunk < BaseChunk
+    def initialize(node, marker_name, indent:, nb_lines: 1, **kwargs)
+      @marker_name = marker_name
+      @indent = indent
+      @nb_lines = nb_lines
+      super(node, nil, **kwargs.merge(end_marker_indent: @indent))
+    end
+
+    def full_assemble(coordinator)
+      @start_marker_line_number = coordinator.add_marker(@indent, name: @marker_name,
+                                                       haml_line_index: haml_line_index)
+    end
+
+    def transfer_correction(coordinator, all_corrected_ruby_lines, haml_lines)
+      marker_index = coordinator.find_line_index_of_marker_in_corrections(@start_marker_line_number,
+                                                                          name: @marker_name)
+      new_indent = all_corrected_ruby_lines[marker_index].index(/\S/)
+      return if new_indent == @indent
+      (haml_line_index..haml_end_line_index).each do |i|
+        haml_lines[i] = HamlLint::Utils.indent(haml_lines[i], new_indent - @indent)
+      end
+    end
+
+    def haml_end_line_index
+      haml_line_index + @nb_lines - 1
+    end
+
+    def end_marker_indent
+      @indent
+    end
+  end
+end

data/lib/haml_lint/ruby_extraction/ruby_filter_chunk.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # Chunk for dealing with `:ruby` filter.
+  class RubyFilterChunk < BaseChunk
+    attr_reader :start_marker_indent
+
+    def initialize(*args, start_marker_indent:, **kwargs)
+      super(*args, **kwargs)
+      @start_marker_indent = start_marker_indent
+    end
+
+    def transfer_correction_logic(coordinator, to_ruby_lines, haml_lines)
+      marker_index = coordinator.find_line_index_of_marker_in_corrections(@start_marker_line_number)
+
+      new_name_indent = coordinator.corrected_ruby_lines[marker_index].index(/\S/)
+
+      delta_indent = new_name_indent - @start_marker_indent
+      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/
+          # whitespace or empty
+          ''
+        else
+          "  #{line}"
+        end
+      end
+
+      haml_lines[@haml_line_index..haml_end_line_index] = to_haml_lines
+    end
+  end
+end

data/lib/haml_lint/ruby_extraction/ruby_source.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  RubySource = Struct.new(:source, :source_map, :ruby_chunks)
+end

data/lib/haml_lint/ruby_extraction/script_chunk.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # Chunk for handling outputting and silent scripts, so `  = foo` and `  - bar`
+  # Does NOT handle a script beside a tag (ex: `%div= spam`)
+  class ScriptChunk < BaseChunk
+    MID_BLOCK_KEYWORDS = %w[else elsif when rescue ensure].freeze
+
+    # @return [Boolean] true if this ScriptChunk must be at the beginning of a chunk.
+    #   This blocks this ScriptChunk from being fused to a ScriptChunk that is before it.
+    #   Needed to handle some patterns of outputting script.
+    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.
+    attr_reader :skip_line_indexes_in_source_map
+
+    # @return [HamlLint::RubyExtraction::BaseChunk] The previous chunk can affect how
+    #   our starting marker must be indented.
+    attr_reader :previous_chunk
+
+    def initialize(*args, previous_chunk:, must_start_chunk: false,
+                   skip_line_indexes_in_source_map: [], **kwargs)
+      super(*args, **kwargs)
+      @must_start_chunk = must_start_chunk
+      @skip_line_indexes_in_source_map = skip_line_indexes_in_source_map
+      @previous_chunk = previous_chunk
+    end
+
+    def fuse(following_chunk)
+      case following_chunk
+      when ScriptChunk
+        fuse_script_chunk(following_chunk)
+      when ImplicitEndChunk
+        fuse_implicit_end(following_chunk)
+      end
+    end
+
+    def fuse_script_chunk(following_chunk)
+      return if following_chunk.end_marker_indent.nil?
+      return if following_chunk.must_start_chunk
+
+      nb_blank_lines_between = following_chunk.haml_line_index - haml_line_index - nb_haml_lines
+      blank_lines = nb_blank_lines_between > 0 ? [''] * nb_blank_lines_between : []
+      new_lines = @ruby_lines + blank_lines + following_chunk.ruby_lines
+
+      source_map_skips = @skip_line_indexes_in_source_map
+      source_map_skips.concat(following_chunk.skip_line_indexes_in_source_map
+                                .map { |i| i + @ruby_lines.size })
+
+      ScriptChunk.new(node,
+                      new_lines,
+                      haml_line_index: haml_line_index,
+                      skip_line_indexes_in_source_map: source_map_skips,
+                      end_marker_indent: following_chunk.end_marker_indent,
+                      previous_chunk: previous_chunk)
+    end
+
+    def fuse_implicit_end(following_chunk)
+      new_lines = @ruby_lines.dup
+      last_non_empty_line_index = new_lines.rindex { |line| line =~ /\S/ }
+
+      # There is only one line in ImplicitEndChunk
+      new_end_index = last_non_empty_line_index + 1
+      new_lines.insert(new_end_index, following_chunk.ruby_lines.first)
+      source_map_skips = @skip_line_indexes_in_source_map + [new_end_index]
+
+      ScriptChunk.new(node,
+                      new_lines,
+                      haml_line_index: haml_line_index,
+                      skip_line_indexes_in_source_map: source_map_skips,
+                      end_marker_indent: following_chunk.end_marker_indent,
+                      previous_chunk: previous_chunk)
+    end
+
+    def start_marker_indent
+      default_indent = super
+      default_indent += 2 if MID_BLOCK_KEYWORDS.include?(ChunkExtractor.block_keyword(ruby_lines.first))
+      [default_indent, previous_chunk&.end_marker_indent || previous_chunk&.start_marker_indent].compact.max
+    end
+
+    def transfer_correction_logic(coordinator, to_ruby_lines, haml_lines) # rubocop:disable Metrics
+      to_ruby_lines.reject! { |l| l.strip == 'end' }
+
+      output_comment_prefix = ' ' + coordinator.script_output_prefix.rstrip
+      to_ruby_lines.map! do |line|
+        if line.lstrip.start_with?('#' + output_comment_prefix)
+          line = line.dup
+          comment_index = line.index('#')
+          removal_start_index = comment_index + 1
+          removal_end_index = removal_start_index + output_comment_prefix.size
+          line[removal_start_index...removal_end_index] = ''
+          # It will be removed again below, but will know its suposed to be a =
+          line.insert(comment_index, coordinator.script_output_prefix)
+        end
+        line
+      end
+
+      continued_line_indent_delta = 2
+
+      to_haml_lines = to_ruby_lines.map.with_index do |line, i|
+        if line !~ /\S/
+          # whitespace or empty lines, we don't want any indentation
+          ''
+        elsif line_starts_script?(to_ruby_lines, i)
+          code_start = line.index(/\S/)
+          if line[code_start..].start_with?(coordinator.script_output_prefix)
+            line = line.sub(coordinator.script_output_prefix, '')
+            continued_line_indent_delta = 2 - coordinator.script_output_prefix.size
+            "#{line[0...code_start]}= #{line[code_start..]}"
+          else
+            continued_line_indent_delta = 2
+            "#{line[0...code_start]}- #{line[code_start..]}"
+          end
+        else
+          HamlLint::Utils.indent(line, continued_line_indent_delta)
+        end
+      end
+
+      haml_lines[@haml_line_index..haml_end_line_index] = to_haml_lines
+    end
+
+    def unfinished_script_line?(lines, line_index)
+      !!lines[line_index][/,[ \t]*\z/]
+    end
+
+    def line_starts_script?(lines, line_index)
+      return true if line_index == 0
+      !unfinished_script_line?(lines, line_index - 1)
+    end
+  end
+end

data/lib/haml_lint/ruby_extraction/tag_attributes_chunk.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # Chunk for handling the a tag attributes, such as `%div{style: 'yes_please'}`
+  class TagAttributesChunk < BaseChunk
+    def initialize(*args, indent_to_remove:, **kwargs)
+      super(*args, **kwargs)
+      @indent_to_remove = indent_to_remove
+    end
+
+    def transfer_correction_logic(_coordinator, to_ruby_lines, haml_lines)
+      affected_haml_lines = haml_lines[@haml_line_index..haml_end_line_index]
+
+      affected_haml = affected_haml_lines.join("\n")
+
+      from_ruby = unwrap(@ruby_lines).join("\n")
+      to_ruby = unwrap(to_ruby_lines).join("\n")
+
+      affected_start_index = affected_haml.index(from_ruby)
+      affected_end_index = affected_start_index + from_ruby.size
+      affected_haml[affected_start_index...affected_end_index] = to_ruby
+
+      haml_lines[@haml_line_index..haml_end_line_index] = affected_haml.split("\n")
+    end
+
+    def unwrap(lines)
+      lines = lines.dup
+      lines[0] = lines[0].sub(/^\s*/, '').sub(/W+\(/, '')
+      lines[-1] = lines[-1].sub(/\)\s*\Z/, '')
+
+      if @indent_to_remove
+        HamlLint::Utils.map_after_first!(lines) do |line|
+          line.sub(/^ {1,#{@indent_to_remove}}/, '')
+        end
+      end
+      lines
+    end
+  end
+end

data/lib/haml_lint/ruby_extraction/tag_script_chunk.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  # Chunk for handling outputting scripts after a tag, such as `%div= spam`
+  class TagScriptChunk < BaseChunk
+    def transfer_correction_logic(coordinator, to_ruby_lines, haml_lines) # rubocop:disable Metrics/AbcSize
+      # TODO: add checks that we have commas at the end of each line except the last one
+
+      from_ruby_line = @ruby_lines.first
+      to_ruby_line = to_ruby_lines.first
+
+      to_line_indent = to_ruby_line.index(/\S/)
+
+      from_ruby_line = from_ruby_line.sub(coordinator.script_output_prefix, '').sub(/^\s+/, '')
+      to_ruby_line = to_ruby_line.sub(coordinator.script_output_prefix, '').sub(/^\s+/, '')
+
+      affected_start_index = haml_lines[@haml_line_index].rindex(from_ruby_line)
+
+      haml_lines[@haml_line_index][affected_start_index..-1] = to_ruby_line
+
+      indent_delta = affected_start_index - coordinator.script_output_prefix.size - to_line_indent
+
+      HamlLint::Utils.map_after_first!(to_ruby_lines) do |line|
+        HamlLint::Utils.indent(line, indent_delta)
+      end
+
+      haml_lines[(@haml_line_index + 1)..haml_end_line_index] = to_ruby_lines[1..]
+    end
+  end
+end

data/lib/haml_lint/ruby_extractor.rb

@@ -24,7 +24,7 @@ module HamlLint
   # The translation won't be perfect, and won't make any real sense, but the
   # relationship between variable declarations/uses and the flow control graph
   # will remain intact.
-  class RubyExtractor # rubocop:disable Metrics/ClassLength
+  class RubyExtractor
     include HamlVisitor
 
     # Stores the extracted source and a map of lines of generated source to the
@@ -73,8 +73,9 @@ module HamlLint
 
         # Attributes can either be a method call or a literal hash, so wrap it
         # in a method call itself in order to avoid having to differentiate the
-        # two.
-        add_line("{}.merge(#{attributes_code})", node)
+        # two. Use the tag name for the method to differentiate different tag types
+        # for RuboCop and prevent erroneous warnings.
+        add_line("#{node.tag_name}(#{attributes_code})", node)
       end
 
       check_tag_static_hash_source(node)
@@ -128,7 +129,7 @@ module HamlLint
     def visit_filter(node)
       if node.filter_type == 'ruby'
         node.text.split("\n").each_with_index do |line, index|
-          add_line(line, node.line + index + 1, false)
+          add_line(line, node.line + index + 1, discard_blanks: false)
         end
       else
         add_dummy_puts(node, ":#{node.filter_type}")
@@ -161,17 +162,17 @@ module HamlLint
       @output_count += 1
     end
 
-    def add_line(code, node_or_line, discard_blanks = true)
+    def add_line(code, node_or_line, discard_blanks: true)
       return if code.empty? && discard_blanks
 
       indent_level = @indent_level
 
-      if node_or_line.respond_to?(:line)
+      if node_or_line.respond_to?(:line) && mid_block_keyword?(code)
         # Since mid-block keywords are children of the corresponding start block
         # keyword, we need to reduce their indentation level by 1. However, we
         # don't do this unless this is an actual tag node (a raw line number
         # means this came from a `:ruby` filter).
-        indent_level -= 1 if mid_block_keyword?(code)
+        indent_level -= 1
       end
 
       indent = (' ' * 2 * indent_level)
@@ -196,7 +197,7 @@ module HamlLint
     end
 
     def anonymous_block?(text)
-      text =~ /\bdo\s*(\|\s*[^\|]*\s*\|)?(\s*#.*)?\z/
+      text =~ /\bdo\s*(\|\s*[^|]*\s*\|)?(\s*#.*)?\z/
     end
 
     START_BLOCK_KEYWORDS = %w[if unless case begin for until while].freeze
@@ -212,8 +213,8 @@ module HamlLint
     LOOP_KEYWORDS = %w[for until while].freeze
     def block_keyword(text)
       # Need to handle 'for'/'while' since regex stolen from HAML parser doesn't
-      if keyword = text[/\A\s*([^\s]+)\s+/, 1]
-        return keyword if LOOP_KEYWORDS.include?(keyword)
+      if (keyword = text[/\A\s*([^\s]+)\s+/, 1]) && LOOP_KEYWORDS.include?(keyword)
+        return keyword
       end
 
       return unless keyword = text.scan(Haml::Parser::BLOCK_KEYWORD_REGEX)[0]

data/lib/haml_lint/runner.rb

@@ -24,6 +24,8 @@ module HamlLint
       @linter_selector = HamlLint::LinterSelector.new(config, options)
       @fail_fast = options.fetch(:fail_fast, false)
       @cache = {}
+      @autocorrect = options[:autocorrect]
+      @autocorrect_only = options[:autocorrect_only]
 
       report(options)
     end
@@ -88,9 +90,39 @@ module HamlLint
                                    e.line, e.to_s, :error)]
       end
 
-      linter_selector.linters_for_file(file).map do |linter|
-        linter.run(document)
-      end.flatten
+      linters = linter_selector.linters_for_file(file)
+      lint_arrays = []
+
+      if @autocorrect
+        lint_arrays << autocorrect_document(document, linters)
+      end
+
+      unless @autocorrect_only
+        lint_arrays << linters.map do |linter|
+          linter.run(document)
+        end
+      end
+      lint_arrays.flatten
+    end
+
+    # Out of the provided linters, runs those that support autocorrect
+    # against the specified document.
+    # Updates the document and returns the lints that were corrected.
+    #
+    # @param document [HamlLint::Document]
+    # @param linter_selector [HamlLint::LinterSelector]
+    # @return [Array<HamlLint::Lint>]
+    def autocorrect_document(document, linters)
+      lint_arrays = []
+
+      autocorrecting_linters = linters.select(&:supports_autocorrect?)
+      lint_arrays << autocorrecting_linters.map do |linter|
+        linter.run(document, autocorrect: @autocorrect)
+      end
+
+      document.write_to_disk!
+
+      lint_arrays
     end
 
     # Returns the list of files that should be linted given the specified

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

@@ -10,9 +10,11 @@ module HamlLint
         expected_line = options[:line]
         expected_message = options[:message]
         expected_severity = options[:severity]
+        expected_corrected = options[:corrected]
 
         match do |linter|
-          has_lints?(linter, expected_line, count, expected_message, expected_severity)
+          has_lints?(linter, expected_line, count, expected_message, expected_severity,
+                     expected_corrected)
         end
 
         failure_message do |linter|
@@ -63,13 +65,15 @@ module HamlLint
             (expected_severity ? " with severity '#{expected_severity}'" : '')
         end
 
-        def has_lints?(linter, expected_line, count, expected_message, expected_severity)
+        def has_lints?(linter, expected_line, count, expected_message, expected_severity, # rubocop:disable Metrics/ParameterLists
+                       expected_corrected)
           if expected_line
             has_expected_line_lints?(linter,
                                      expected_line,
                                      count,
                                      expected_message,
-                                     expected_severity)
+                                     expected_severity,
+                                     expected_corrected)
           elsif count
             linter.lints.count == count
           elsif expected_message
@@ -79,17 +83,20 @@ module HamlLint
           end
         end
 
-        def has_expected_line_lints?(linter,
+        def has_expected_line_lints?(linter, # rubocop:disable Metrics/ParameterLists
                                      expected_line,
                                      count,
                                      expected_message,
-                                     expected_severity)
+                                     expected_severity,
+                                     expected_corrected)
           if count
             multiple_lints_match_line?(linter, expected_line, count)
           elsif expected_message
             lint_on_line_matches_message?(linter, expected_line, expected_message)
           elsif expected_severity
             lint_on_line_matches_severity?(linter, expected_line, expected_severity)
+          elsif !expected_corrected.nil?
+            lint_on_line_matches_corrected?(linter, expected_line, expected_corrected)
           else
             lint_lines(linter).include?(expected_line)
           end
@@ -101,9 +108,10 @@ module HamlLint
         end
 
         def lint_on_line_matches_message?(linter, expected_line, expected_message)
+          # Using === to support regex to match anywhere in the string
           linter
             .lints
-            .any? { |lint| lint.line == expected_line && lint.message == expected_message }
+            .any? { |lint| lint.line == expected_line && expected_message === lint.message } # rubocop:disable Style/CaseEquality
         end
 
         def lint_on_line_matches_severity?(linter, expected_line, expected_severity)
@@ -112,8 +120,15 @@ module HamlLint
             .any? { |lint| lint.line == expected_line && lint.severity == expected_severity }
         end
 
+        def lint_on_line_matches_corrected?(linter, expected_line, expected_corrected)
+          linter
+            .lints
+            .any? { |lint| lint.line == expected_line && lint.corrected == expected_corrected }
+        end
+
         def lint_messages_match?(linter, expected_message)
-          lint_messages(linter).all? { |message| message == expected_message }
+          # Using === to support regex to match anywhere in the string
+          lint_messages(linter).all? { |message| expected_message === message } # rubocop:disable Style/CaseEquality
         end
 
         def lint_lines(linter)

data/lib/haml_lint/spec/normalize_indent.rb

@@ -6,8 +6,8 @@ module HamlLint
     # for writing code without having the leading indentation count.
     module IndentNormalizer
       def normalize_indent(code)
-        leading_indent = code[/^(\s*)/, 1]
-        code.lstrip.gsub(/\n#{leading_indent}/, "\n")
+        leading_indent = code[/([ \t]*)/, 1]
+        code.gsub(/^#{leading_indent}/, '')
       end
     end
   end

data/lib/haml_lint/spec/shared_linter_context.rb

@@ -14,13 +14,21 @@ module HamlLint
           }
         end
 
+        let(:autocorrect) { nil }
+
         let(:config) { options[:config].for_linter(described_class) }
 
         let(:document) { HamlLint::Document.new(normalize_indent(haml), options) }
 
+        # :run_or_raise, :run, or nil to not auto-call something
+        let(:run_method_to_use) { :run_or_raise }
+
         subject { described_class.new(config) }
 
-        before { subject.run(document) }
+        before do
+          next unless run_method_to_use
+          subject.send(run_method_to_use, document, autocorrect: autocorrect)
+        end
       end
     end
   end