haml_lint 0.53.0 → 0.76.0

data/lib/haml_lint/linter/rubocop.rb

@@ -4,18 +4,46 @@ require 'rubocop'
 require 'tempfile'
 
 module HamlLint
-  # Runs RuboCop on the Ruby code contained within HAML templates.
+  # Runs RuboCop on the Ruby code contained within Haml templates.
   #
   # The processing is done by extracting a Ruby file that matches the content, including
-  # the indentation, of the HAML file. This way, we can run RuboCop with autocorrect
-  # and get new Ruby code which should be HAML compatible.
+  # the indentation, of the Haml file. This way, we can run RuboCop with autocorrect
+  # and get new Ruby code which should be Haml compatible.
   #
-  # The ruby extraction makes "Chunks" which wrap each HAML constructs. The Chunks can then
-  # use the corrected Ruby code to apply the corrections back in the HAML using logic specific
+  # The ruby extraction makes "Chunks" which wrap each Haml constructs. The Chunks can then
+  # use the corrected Ruby code to apply the corrections back in the Haml using logic specific
   # to each type of Chunk.
   #
   # 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:)
+        @offenses = []
+        @config_store.instance_variable_set(:@options_config, config)
+        # Using stdin also disables RuboCop's result cache, which is intentional:
+        # it reconstructs offense positions from the on-disk Haml, not the Ruby we
+        # inspected, so reusing it misreports lines (sds/haml-lint#593).
+        @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
+    end
+
     include LinterRegistry
 
     supports_autocorrect(true)
@@ -54,7 +82,7 @@ module HamlLint
       @last_extracted_source = nil
       @last_new_ruby_source = nil
 
-      coordinator = HamlLint::RubyExtraction::Coordinator.new(document)
+      coordinator = HamlLint::RubyExtraction::Coordinator.new(document, autocorrect: @autocorrect)
 
       extracted_source = coordinator.extract_ruby_source
       if ENV['HAML_LINT_INTERNAL_DEBUG'] == 'true'
@@ -98,9 +126,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
@@ -117,7 +145,7 @@ module HamlLint
         # so the lints will be recorded then.
         @lints = []
 
-        msg = "Corrections couldn't be transfered: #{e.message} - Consider linting the file " \
+        msg = "Corrections couldn't be transferred: #{e.message} - Consider linting the file " \
               'without auto-correct and doing the changes manually.'
         if ENV['HAML_LINT_DEBUG'] == 'true'
           msg = "#{msg} DEBUG: Rubocop corrected Ruby code follows:\n#{new_ruby_code}\n------"
@@ -168,15 +196,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 +216,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 +225,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))
 
       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
@@ -276,7 +282,7 @@ module HamlLint
           end
         end
         record_lint(line, offense.message, offense.severity.name,
-                    corrected: autocorrected)
+                    corrected: autocorrected, correctable: offense.correctable?)
       end
     end
 
@@ -285,23 +291,38 @@ module HamlLint
     # @param line [#line] line number of the lint
     # @param message [String] error/warning to display to the user
     # @param severity [Symbol] RuboCop severity level for the offense
-    def record_lint(line, message, severity, corrected:)
+    # @param corrected [Boolean] whether RuboCop auto-corrected the offense
+    # @param correctable [Boolean] whether RuboCop is able to auto-correct the offense
+    def record_lint(line, message, severity, corrected:, correctable: false)
       # TODO: actual handling for RuboCop's new :info severity
       return if severity == :info
 
       @lints << HamlLint::Lint.new(self, @document.file, line, message,
                                    SEVERITY_MAP.fetch(severity, :warning),
-                                   corrected: corrected)
+                                   corrected: corrected, correctable: correctable)
+    end
+
+    # 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 flags that will be passed to RuboCop CLI.
+    # 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 +363,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/linter/ruby_comments.rb

@@ -1,14 +1,17 @@
 # frozen_string_literal: true
 
 module HamlLint
-  # Checks for Ruby comments that can be written as HAML comments.
+  # Checks for Ruby comments that can be written as Haml comments.
   class Linter::RubyComments < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     def visit_silent_script(node)
-      if code_comment?(node)
-        record_lint(node, 'Use `-#` for comments instead of `- #`')
-      end
+      return unless code_comment?(node)
+
+      corrected = correct_comment(node)
+      record_lint(node, 'Use `-#` for comments instead of `- #`', corrected: corrected)
     end
 
     private
@@ -16,5 +19,12 @@ module HamlLint
     def code_comment?(node)
       node.script =~ /\A\s+#/
     end
+
+    # @return [Boolean]
+    def correct_comment(node)
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      correct_line(index, line.sub(/\A(\s*)-\s+#/, '\1-#'))
+    end
   end
 end

data/lib/haml_lint/linter/space_before_script.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 module HamlLint
-  # Checks for Ruby script in HAML templates with no space after the `=`/`-`.
+  # Checks for Ruby script in Haml templates with no space after the `=`/`-`.
   class Linter::SpaceBeforeScript < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     MESSAGE_FORMAT = 'The %s symbol should have one space separating it from code'
 
     ALLOWED_SEPARATORS = [' ', '#'].freeze
@@ -33,18 +35,23 @@ module HamlLint
       # (need to do it this way as the parser strips whitespace from node)
       return unless tag_with_text[index - 1] != ' '
 
-      record_lint(node, MESSAGE_FORMAT % '=')
+      corrected = correct_inline_script(node, text)
+      record_lint(node, MESSAGE_FORMAT % '=', corrected: corrected)
     end
 
     def visit_script(node)
       # Plain text nodes with interpolation are converted to script nodes, so we
       # need to ignore them here.
       return unless document.source_lines[node.line - 1].lstrip.start_with?('=')
-      record_lint(node, MESSAGE_FORMAT % '=') if missing_space?(node)
+      return unless missing_space?(node)
+
+      record_lint(node, MESSAGE_FORMAT % '=', corrected: correct_leading_marker(node, '='))
     end
 
     def visit_silent_script(node)
-      record_lint(node, MESSAGE_FORMAT % '-') if missing_space?(node)
+      return unless missing_space?(node)
+
+      record_lint(node, MESSAGE_FORMAT % '-', corrected: correct_leading_marker(node, '-'))
     end
 
     private
@@ -53,5 +60,31 @@ module HamlLint
       text = node.script
       !ALLOWED_SEPARATORS.include?(text[0]) if text
     end
+
+    # Inserts one space after a leading `=`/`-` marker.
+    #
+    # @return [Boolean]
+    def correct_leading_marker(node, marker)
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      escaped = Regexp.escape(marker)
+      correct_line(index, line.sub(/\A(\s*#{escaped})(?=[^\s#{escaped}])/, '\1 '))
+    end
+
+    # Inserts a space after the `=` marker introducing a tag's inline script.
+    #
+    # @return [Boolean]
+    def correct_inline_script(node, text)
+      index = node.line - 1
+      line = autocorrected_lines[index]
+
+      pos = line.rindex("=#{text}")
+      if pos.nil? && (unquoted = strip_surrounding_quotes(text))
+        pos = line.rindex("=#{unquoted}")
+      end
+      return false unless pos
+
+      correct_line(index, "#{line[0..pos]} #{line[(pos + 1)..]}")
+    end
   end
 end

data/lib/haml_lint/linter/space_inside_hash_attributes.rb

@@ -6,6 +6,8 @@ module HamlLint
   class Linter::SpaceInsideHashAttributes < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     STYLE = {
       'no_space' => {
         start_regex: /\A\{[^ ]/,
@@ -24,11 +26,47 @@ module HamlLint
     def visit_tag(node)
       return unless node.hash_attributes?
 
-      style = STYLE[config['style'] == 'no_space' ? 'no_space' : 'space']
+      style_name = config['style'] == 'no_space' ? 'no_space' : 'space'
+      style = STYLE[style_name]
       source = node.hash_attributes_source
 
-      record_lint(node, style[:start_message]) unless source =~ style[:start_regex]
-      record_lint(node, style[:end_message]) unless source =~ style[:end_regex]
+      start_ok = source.match?(style[:start_regex])
+      end_ok = source.match?(style[:end_regex])
+      return if start_ok && end_ok
+
+      corrected = correct_hash_spacing(node, source, style_name)
+      record_lint(node, style[:start_message], corrected: corrected) unless start_ok
+      record_lint(node, style[:end_message], corrected: corrected) unless end_ok
+    end
+
+    private
+
+    # @return [Boolean]
+    def correct_hash_spacing(node, source, style_name)
+      return false unless source
+      return false if source.include?("\n") # multi-line hash: detection-only
+
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      return false unless line.include?(source)
+
+      fixed = corrected_hash_source(source, style_name)
+      return false if fixed == source
+
+      correct_line(index, line.sub(source) { fixed })
+    end
+
+    # @return [String]
+    def corrected_hash_source(source, style_name)
+      inner = source[1...-1].strip
+
+      if style_name == 'no_space'
+        "{#{inner}}"
+      elsif inner.empty?
+        '{ }'
+      else
+        "{ #{inner} }"
+      end
     end
   end
 end

data/lib/haml_lint/linter/strict_locals.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module HamlLint
+  # Checks for the presence of a `locals` magic comment at the beginning of a partial.
+  class Linter::StrictLocals < Linter
+    include LinterRegistry
+
+    DummyNode = Struct.new(:line)
+
+    # Enables the linter if the tree is for the right file type.
+    #
+    # @param [HamlLint::Tree::RootNode] the root of a syntax tree
+    # @return [true, false] whether the linter is enabled for the tree
+    def visit_root(root)
+      return unless enabled?(root)
+
+      # Rails technically allows the comment to be anywhere in the file,
+      # but as a best practice they should be at the top of the file.
+      # https://guides.rubyonrails.org/action_view_overview.html#strict-locals
+      # https://github.com/rails/rails/blob/v8.0.2/actionview/lib/action_view/template.rb#L368
+      found =
+        root.children
+            .take_while { |child| child.is_a?(HamlLint::Tree::HamlCommentNode) }
+            .any?(&:is_strict_locals?)
+
+      return if found
+
+      record_lint(DummyNode.new(1), failure_message)
+    end
+
+    private
+
+    # Checks whether the linter is enabled for the file.
+    #
+    # @api private
+    # @return [true, false]
+    def enabled?(root)
+      return false unless matcher.match?(File.basename(root.file))
+
+      # This linter can also be disabled by a comment at the top of the file
+      first_child = root.children.first
+      first_child.nil? || !first_child.disabled?(self)
+    end
+
+    # The type of files the linter is configured to check.
+    #
+    # @api private
+    # @return [String]
+    def file_types
+      @file_types ||= config['file_types'] || 'partial'
+    end
+
+    # The matcher to use for testing whether to check a file by file name.
+    #
+    # @api private
+    # @return [Regexp]
+    def matcher
+      @matcher ||= Regexp.new(config['matchers'][file_types] || '\A_.*\.haml\z')
+    end
+
+    # The error message when an `locals` comment is not found.
+    #
+    # @api private
+    # @return [String]
+    def failure_message
+      'Expected a strict `-# locals: ()` comment at the beginning of the file'
+    end
+  end
+end

data/lib/haml_lint/linter/tag_name.rb

@@ -5,11 +5,24 @@ module HamlLint
   class Linter::TagName < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     def visit_tag(node)
       tag = node.tag_name
-      return unless tag =~ /[A-Z]/
+      return unless /[A-Z]/.match?(tag)
+
+      corrected = correct_tag_name(node, tag)
+      record_lint(node, "`#{tag}` should be written in lowercase as `#{tag.downcase}`",
+                  corrected: corrected)
+    end
+
+    private
 
-      record_lint(node, "`#{tag}` should be written in lowercase as `#{tag.downcase}`")
+    # @return [Boolean]
+    def correct_tag_name(node, tag)
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      correct_line(index, line.sub(/(%)#{Regexp.escape(tag)}/, "\\1#{tag.downcase}"))
     end
   end
 end

data/lib/haml_lint/linter/trailing_empty_lines.rb

@@ -5,6 +5,8 @@ module HamlLint
   class Linter::TrailingEmptyLines < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     DummyNode = Struct.new(:line)
 
     def visit_root(root)
@@ -16,7 +18,17 @@ module HamlLint
 
       return unless document.source.end_with?("\n\n")
 
-      record_lint(line_number, 'Files should not end with trailing empty lines')
+      record_lint(line_number, 'Files should not end with trailing empty lines',
+                  corrected: autocorrect?)
+
+      apply_autocorrect(corrected_source)
+    end
+
+    private
+
+    def corrected_source
+      last_non_empty_index = document.source_lines.rindex { |line| !line.empty? } || 0
+      "#{document.source_lines[0..last_non_empty_index].join("\n")}\n"
     end
   end
 end

data/lib/haml_lint/linter/trailing_whitespace.rb

@@ -5,17 +5,30 @@ module HamlLint
   class Linter::TrailingWhitespace < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     DummyNode = Struct.new(:line)
 
     def visit_root(root)
+      new_lines = document.source_lines.dup
+      changed = false
+
       document.source_lines.each_with_index do |line, index|
-        next unless line =~ /\s+$/
+        next unless /\s+$/.match?(line)
 
         node = root.node_for_line(index + 1)
-        unless node.disabled?(self)
-          record_lint DummyNode.new(index + 1), 'Line contains trailing whitespace'
+        next if node.disabled?(self)
+
+        if autocorrect?
+          new_lines[index] = line.sub(/\s+$/, '')
+          changed = true
         end
+
+        record_lint(DummyNode.new(index + 1), 'Line contains trailing whitespace',
+                    corrected: autocorrect?)
       end
+
+      apply_autocorrect(new_lines.join("\n")) if changed
     end
   end
 end

data/lib/haml_lint/linter/unescaped_html.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module HamlLint
+  # Flags Haml's unescaped-output markers (`!=`, `!~`, and the unescaped
+  # plain-text `!`), which bypass HTML escaping.
+  #
+  # Like `raw`, `html_safe`, and `h()` in Rails, these make it easy to
+  # accidentally introduce XSS vulnerabilities when the output includes
+  # user-controlled data, e.g.:
+  #
+  #   != "Username: <strong>#{user.name}</strong>"
+  class Linter::UnescapedHtml < Linter
+    include LinterRegistry
+
+    MESSAGE =
+      'Avoid outputting unescaped HTML with `!`; it bypasses HTML escaping and ' \
+      'can introduce XSS vulnerabilities. Sanitize the value instead.'
+
+    def visit_script(node)
+      record_lint(node, MESSAGE) if /\A\s*!/.match?(node.source_code)
+    end
+
+    def visit_tag(node)
+      record_lint(node, MESSAGE) if node.unescape_html?
+    end
+  end
+end

data/lib/haml_lint/linter/unnecessary_interpolation.rb

@@ -11,21 +11,48 @@ module HamlLint
   class Linter::UnnecessaryInterpolation < Linter
     include LinterRegistry
 
+    supports_autocorrect(true)
+
     def visit_tag(node)
       return if node.script.length <= 2
 
       count = 0
       chars = 2 # Include surrounding quote chars
-      HamlLint::Utils.extract_interpolated_values(node.script) do |interpolated_code, _line|
+      interpolated_code = nil
+      HamlLint::Utils.extract_interpolated_values(node.script) do |code, _line|
         count += 1
         return if count > 1 # rubocop:disable Lint/NonLocalExitFromIterator
-        chars += interpolated_code.length + 3
+        chars += code.length + 3
+        interpolated_code = code
       end
 
       if chars == node.script.length
+        corrected = correct_interpolation(node, interpolated_code)
         record_lint(node, '`%... \#{expression}` can be written without ' \
-                          'interpolation as `%...= expression`')
+                          'interpolation as `%...= expression`', corrected: corrected)
       end
     end
+
+    private
+
+    # @return [Boolean]
+    def correct_interpolation(node, interpolated_code)
+      return false unless interpolated_code
+
+      index = node.line - 1
+      line = autocorrected_lines[index]
+      escaped = Regexp.escape(interpolated_code)
+
+      new_line =
+        if inline_content_is_string?(node)
+          line.sub(/=\s*"\#\{#{escaped}\}"\s*\z/, "= #{interpolated_code}")
+        else
+          line.sub(/\s+\#\{#{escaped}\}\s*\z/, "= #{interpolated_code}")
+        end
+
+      return false if new_line == line
+
+      correct_line(index, new_line)
+    end
   end
 end