haml_lint 0.40.0 → 0.51.0

data/lib/haml_lint/ruby_extraction/coordinator.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module HamlLint::RubyExtraction
+  class UnableToTransferCorrections < StandardError; end
+
+  # Coordinates the entire RubyExtraction system.
+  #
+  # * Uses the extractor to generate chunks.
+  # * 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
+  #
+  # 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.
+  # After RuboCop does it's auto-correction, the markers are used to find the pieces of the
+  # corrected Ruby code that correspond to each Chunk.
+  class Coordinator
+    # @return [String] The prefix used for to handle `= foo` script's in the extracted Ruby code.
+    attr_reader :script_output_prefix
+
+    # @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)
+    attr_reader :assembled_ruby_lines
+
+    # @return [Array<String>] The ruby lines after correction by RuboCop
+    attr_reader :corrected_ruby_lines
+
+    def initialize(document)
+      @document = document
+      @ruby_chunks = nil
+      @assembled_ruby_lines = nil
+      @corrected_ruby_lines = nil
+      @source_map = {}
+      @script_output_prefix = nil
+
+      @haml_lines = nil
+    end
+
+    def extract_ruby_source
+      return @ruby_source if @ruby_source
+
+      pick_a_marker_prefix
+      pick_a_script_output_prefix
+
+      @ruby_chunks = HamlLint::RubyExtraction::ChunkExtractor.new(@document,
+                                                                  script_output_prefix: @script_output_prefix).extract
+      preprocess_chunks
+
+      @assembled_ruby_lines = []
+      @ruby_chunks.each do |ruby_chunk|
+        ruby_chunk.full_assemble(self)
+      end
+
+      # Making sure the generated source has a final newline
+      @assembled_ruby_lines << '' if @assembled_ruby_lines.last && !@assembled_ruby_lines.last.empty?
+
+      @ruby_source = RubySource.new(@assembled_ruby_lines.join("\n"), @source_map, @ruby_chunks)
+    end
+
+    def preprocess_chunks
+      return if @ruby_chunks.size < 2
+
+      new_chunks = [@ruby_chunks.first]
+      @ruby_chunks[1..].each do |ruby_chunk|
+        fused_chunk = new_chunks.last.fuse(ruby_chunk)
+        if fused_chunk
+          new_chunks[-1] = fused_chunk
+        else
+          new_chunks << ruby_chunk
+        end
+      end
+      @ruby_chunks = new_chunks
+    end
+
+    def haml_lines_with_corrections_applied(corrected_ruby_source)
+      @corrected_ruby_lines = corrected_ruby_source.split("\n")
+
+      @haml_lines = @document.source_lines.dup
+
+      if markers_conflict?(@assembled_ruby_lines, @corrected_ruby_lines)
+        raise UnableToTransferCorrections, 'The changes in the corrected ruby are not supported'
+      end
+
+      finished_with_empty_line = @haml_lines.last.empty?
+
+      # Going in reverse order, so that if we change the number of lines then the
+      # rest of the file will not be offset, which would make things harder
+      @ruby_chunks.reverse_each do |ruby_chunk|
+        ruby_chunk.transfer_correction(self, @corrected_ruby_lines, @haml_lines)
+      end
+
+      if finished_with_empty_line && !@haml_lines.last.empty?
+        @haml_lines << ''
+      end
+      @haml_lines
+    end
+
+    def add_lines(lines, haml_line_index:, skip_indexes_in_source_map: [])
+      nb_skipped_source_map_lines = 0
+      lines.size.times do |i|
+        if skip_indexes_in_source_map.include?(i)
+          nb_skipped_source_map_lines += 1
+        end
+
+        line_number = haml_line_index + 1
+        # If we skip the first line, we want to them to have the number of the following line
+        line_number = [line_number, line_number + i - nb_skipped_source_map_lines].max
+        @source_map[@assembled_ruby_lines.size + i + 1] = line_number
+      end
+      @assembled_ruby_lines.concat(lines)
+    end
+
+    def line_count
+      @assembled_ruby_lines.size
+    end
+
+    def add_marker(indent, haml_line_index:, name: 'marker')
+      add_lines(["#{' ' * indent}#{marker_prefix}_#{name}_#{@assembled_ruby_lines.size + 1}"],
+                haml_line_index: haml_line_index)
+      line_count
+    end
+
+    # If the ruby_lines have different markers in them, or are in a different order,
+    # then RuboCop did not alter them in a way that is compatible with this system.
+    def markers_conflict?(from_ruby_lines, to_ruby_lines)
+      from_markers = from_ruby_lines.grep(/#{marker_prefix}/, &:strip)
+      to_markers = to_ruby_lines.grep(/#{marker_prefix}/, &:strip)
+      from_markers != to_markers
+    end
+
+    def find_line_index_of_marker_in_corrections(line, name: 'marker')
+      marker = "#{marker_prefix}_#{name}_#{line}"
+
+      # In the best cases, the line didn't move
+      # Using end_with? because indentation may have been added
+      return line - 1 if @corrected_ruby_lines[line - 1]&.end_with?(marker)
+
+      @corrected_ruby_lines.index { |l| l.end_with?(marker) }
+    end
+
+    def extract_from_corrected_lines(start_marker_line_number, nb_lines)
+      cur_start_marker_index = find_line_index_of_marker_in_corrections(start_marker_line_number)
+      return if cur_start_marker_index.nil?
+
+      end_marker_line_number = start_marker_line_number + nb_lines + 1
+      cur_end_marker_index = find_line_index_of_marker_in_corrections(end_marker_line_number)
+      return if cur_end_marker_index.nil?
+
+      @corrected_ruby_lines[(cur_start_marker_index + 1)..(cur_end_marker_index - 1)]
+    end
+
+    def pick_a_marker_prefix
+      if @document.source.match?(/\bhaml_lint_/)
+        100.times do
+          suffix = SecureRandom.hex(10)
+          next if @document.source.include?(suffix)
+          @marker_prefix = "haml_lint#{suffix}"
+          return
+        end
+      else
+        @marker_prefix = 'haml_lint'
+      end
+    end
+
+    def pick_a_script_output_prefix
+      if @document.source.match?(/\bHL\.out\b/)
+        100.times do
+          suffix = SecureRandom.hex(10)
+          next if @document.source.include?(suffix)
+          @script_output_prefix = "HL.out#{suffix} = "
+          return
+        end
+      else
+        @script_output_prefix = 'HL.out = '
+      end
+    end
+  end
+end

data/lib/haml_lint/ruby_extraction/haml_comment_chunk.rb

@@ -0,0 +1,34 @@
+# 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 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,251 @@
+# frozen_string_literal: true
+
+require 'ripper'
+
+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 [String] The prefix for the first outputting string of this script. (One of = != &=)
+    #   The outputting scripts after the first are always with =
+    attr_reader :first_output_haml_prefix
+
+    # @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, # rubocop:disable Metrics/ParameterLists
+                   skip_line_indexes_in_source_map: [], first_output_haml_prefix: '=', **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
+      @first_output_haml_prefix = first_output_haml_prefix
+    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,
+                      first_output_haml_prefix: @first_output_haml_prefix)
+    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,
+                      first_output_haml_prefix: @first_output_haml_prefix)
+    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)
+      to_haml_lines = self.class.format_ruby_lines_to_haml_lines(
+        to_ruby_lines,
+        script_output_ruby_prefix: coordinator.script_output_prefix,
+        first_output_haml_prefix: @first_output_haml_prefix
+      )
+
+      haml_lines[@haml_line_index..haml_end_line_index] = to_haml_lines
+    end
+
+    ALLOW_EXPRESSION_AFTER_LINE_ENDING_WITH = %w[else begin ensure].freeze
+
+    def self.format_ruby_lines_to_haml_lines(to_ruby_lines, script_output_ruby_prefix:, first_output_haml_prefix: '=') # rubocop:disable Metrics
+      to_ruby_lines.reject! { |l| l.strip == 'end' }
+      return [] if to_ruby_lines.empty?
+
+      statement_start_line_indexes = find_statement_start_line_indexes(to_ruby_lines)
+
+      continued_line_indent_delta = 2
+      continued_line_min_indent = 2
+
+      cur_line_start_index = nil
+      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/
+          # whitespace or empty lines, we don't want any indentation
+          ''
+        elsif statement_start_line_indexes.include?(i)
+          cur_line_start_index = i
+          code_start = line.index(/\S/)
+          continued_line_min_indent = code_start + 2
+          if line[code_start..].start_with?(script_output_ruby_prefix)
+            line = line.sub(script_output_ruby_prefix, '')
+            # The next lines may have been too indented because of the "HL.out = " prefix
+            continued_line_indent_delta = 2 - script_output_ruby_prefix.size
+            new_line = "#{line[0...code_start]}#{haml_output_prefix} #{line[code_start..]}"
+            haml_output_prefix = '='
+            new_line
+          else
+            continued_line_indent_delta = 2
+            "#{line[0...code_start]}- #{line[code_start..]}"
+          end
+        else
+          unless to_ruby_lines[i - 1].end_with?(',')
+            line_start_indexes_that_need_pipes << cur_line_start_index
+          end
+
+          line = HamlLint::Utils.indent(line, continued_line_indent_delta)
+          cur_indent = line[/^ */].size
+          if cur_indent < continued_line_min_indent
+            line = HamlLint::Utils.indent(line, continued_line_min_indent - cur_indent)
+          end
+          line
+        end
+      end
+
+      # Starting from the end because we need to add newlines when 2 groups of lines need pipes, so that they are
+      # separate.
+      line_start_indexes_that_need_pipes.reverse_each do |cur_line_i|
+        loop do
+          cur_line = to_haml_lines[cur_line_i]
+          break if cur_line.nil? || cur_line.empty?
+          to_haml_lines[cur_line_i] = cur_line + ' |'
+          cur_line_i += 1
+
+          break if statement_start_line_indexes.include?(cur_line_i)
+        end
+
+        next_line = to_haml_lines[cur_line_i]
+        if next_line && HamlLint::RubyExtraction::ChunkExtractor::HAML_PARSER_INSTANCE.send(:is_multiline?, next_line)
+          to_haml_lines.insert(cur_line_i, '')
+        end
+      end
+
+      to_haml_lines
+    end
+
+    def self.find_statement_start_line_indexes(to_ruby_lines) # rubocop:disable Metrics
+      if to_ruby_lines.size == 1
+        if to_ruby_lines.first[/\S/]
+          return [0]
+        else
+          return []
+        end
+      end
+      statement_start_line_indexes = [] # 0-indexed
+      allow_expression_after_line_number = 0 # 1-indexed
+      last_do_keyword_line_number = nil # 1-indexed, like Ripper.lex
+
+      to_ruby_string = to_ruby_lines.join("\n")
+      if RUBY_VERSION < '3.1'
+        # Ruby 2.6's Ripper has issues when it encounters a else, when, elsif without a matching if/case before.
+        # It literally stop lexing at that point without any error.
+        # Ex from 2.7.8:
+        #   require 'ripper'
+        #   Ripper.lex("a\nelse\nb")
+        #   #=> [[[1, 0], :on_ident, "a", CMDARG], [[1, 1], :on_nl, "\n", BEG], [[2, 0], :on_kw, "else", BEG]]
+        # So we add enough ifs to last quite a few layer. Hopefully enough for all needs. To clarify, there would need
+        # as many "end" keyword in a single ScriptChunk followed by one of the problematic keyword for the problem
+        # to show up.
+        # Considering that a `end` without anything else on the line is removed from to_ruby_lines before getting here
+        # (in format_ruby_lines_to_haml_lines), 10 ifs should be plenty.
+        to_ruby_string = ('if a;' * 10) + to_ruby_string
+      end
+
+      last_line_number_seen = nil
+      Ripper.lex(to_ruby_string).each do |start_loc, token, str|
+        last_line_number_seen = start_loc[0]
+        if token == :on_nl
+          # :on_nl happens when we have a meaningful line change.
+          allow_expression_after_line_number = start_loc[0]
+          next
+        elsif token == :on_ignored_nl
+          # :on_ignored_nl happens for newlines within an expression, or consecutive newlines..
+          #    and some cases we care about such as a newline after the pipes after arguments of a block
+          if last_do_keyword_line_number == start_loc[0]
+            # When starting a block, Ripper.lex gives :on_ignored_nl
+            allow_expression_after_line_number = start_loc[0]
+          end
+          next
+        end
+
+        if allow_expression_after_line_number && str[/\S/]
+          if allow_expression_after_line_number < start_loc[0]
+            # Ripper.lex returns line numbers 1-indexed, we want 0-indexed
+            statement_start_line_indexes << start_loc[0] - 1
+          end
+          allow_expression_after_line_number = nil
+        end
+
+        if token == :on_comment
+          # :on_comment contain its own newline at the end of the content
+          allow_expression_after_line_number = start_loc[0]
+        elsif token == :on_kw
+          if str == 'do'
+            # Because of the possible arguments for the block, we can't simply set is_between_expressions to true
+            last_do_keyword_line_number = start_loc[0]
+          elsif ALLOW_EXPRESSION_AFTER_LINE_ENDING_WITH.include?(str)
+            allow_expression_after_line_number = start_loc[0]
+          end
+        end
+      end
+
+      # number is 1-indexed, and we want the line after it, so that's great
+      if last_line_number_seen < to_ruby_lines.size && to_ruby_lines[last_line_number_seen..].any? { |l| l[/\S/] }
+        # There are non-empty lines after the last line Ripper showed us, that's a problem!
+        msg = +'It seems Ripper did not properly process some source code. Please make sure you are on the '
+        msg << 'latest Haml-Lint version, then create an issue at '
+        msg << "https://github.com/sds/haml-lint/issues and include the following information:\n"
+        msg << "Ruby version: #{RUBY_VERSION}\n"
+        msg << "Haml-Lint version: #{HamlLint::VERSION}\n"
+        msg << "HAML version: #{Haml::VERSION}\n"
+        msg << "problematic source code:\n```\n#{to_ruby_lines.join("\n")}\n```"
+        raise msg
+      end
+
+      statement_start_line_indexes
+    end
+  end
+end

data/lib/haml_lint/ruby_extraction/tag_attributes_chunk.rb

@@ -0,0 +1,63 @@
+# 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) # rubocop:disable Metrics
+      return if @ruby_lines == to_ruby_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")
+
+      if to_ruby_lines.size > 1
+        min_indent = to_ruby_lines.first[/^\s*/]
+        to_ruby_lines.each.with_index do |line, i|
+          next if i == 0
+          next if line.start_with?(min_indent)
+          to_ruby_lines[i] = "#{min_indent}#{line.lstrip}"
+        end
+      end
+
+      to_ruby = unwrap(to_ruby_lines).join("\n")
+
+      affected_start_index = affected_haml.index(from_ruby)
+      if affected_start_index
+        affected_end_index = affected_start_index + from_ruby.size
+      else
+        regexp = HamlLint::Utils.regexp_for_parts(from_ruby.split("\n"), "(?:\s*\\|?\n)")
+        mo = affected_haml.match(regexp)
+        affected_start_index = mo.begin(0)
+        affected_end_index = mo.end(0)
+      end
+
+      affected_haml[affected_start_index...affected_end_index] = to_ruby
+
+      haml_lines[@haml_line_index..haml_end_line_index] = affected_haml.split("\n")
+
+      if haml_lines[haml_end_line_index].end_with?(' |')
+        haml_lines[haml_end_line_index].chop!.rstrip!
+      end
+    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