rubocop 0.66.0 → 1.25.1

data/lib/rubocop/cop/correctors/alignment_corrector.rb

@@ -12,54 +12,70 @@ module RuboCop
       class << self
         attr_reader :processed_source
 
-        def correct(processed_source, node, column_delta)
+        def correct(corrector, processed_source, node, column_delta)
           return unless node
 
           @processed_source = processed_source
           expr = node.respond_to?(:loc) ? node.loc.expression : node
           return if block_comment_within?(expr)
 
-          lambda do |corrector|
-            each_line(expr) do |line_begin_pos|
-              autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                               heredoc_ranges(node))
-            end
+          taboo_ranges = inside_string_ranges(node)
+
+          each_line(expr) do |line_begin_pos|
+            autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges)
           end
         end
 
-        def align_end(processed_source, node, align_to)
+        def align_end(corrector, processed_source, node, align_to)
           @processed_source = processed_source
           whitespace = whitespace_range(node)
           return false unless whitespace.source.strip.empty?
 
           column = alignment_column(align_to)
-          ->(corrector) { corrector.replace(whitespace, ' ' * column) }
+          corrector.replace(whitespace, ' ' * column)
         end
 
         private
 
         def autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                             heredoc_ranges)
+                             taboo_ranges)
           range = calculate_range(expr, line_begin_pos, column_delta)
-          # We must not change indentation of heredoc strings.
-          return if heredoc_ranges.any? { |h| within?(range, h) }
-
-          if column_delta > 0
-            unless range.source == "\n"
-              # TODO: Fix ranges instead of using `begin`
-              corrector.insert_before(range.begin, ' ' * column_delta)
-            end
-          elsif range.source =~ /\A[ \t]+\z/
+          # We must not change indentation of heredoc strings or inside other
+          # string literals
+          return if taboo_ranges.any? { |t| within?(range, t) }
+
+          if column_delta.positive? && range.resize(1).source != "\n"
+            corrector.insert_before(range, ' ' * column_delta)
+          elsif /\A[ \t]+\z/.match?(range.source)
             remove(range, corrector)
           end
         end
 
-        def heredoc_ranges(node)
+        def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 
-          node.each_node(:dstr)
-              .select(&:heredoc?)
-              .map { |n| n.loc.heredoc_body.join(n.loc.heredoc_end) }
+          node.each_node(:str, :dstr, :xstr).map { |n| inside_string_range(n) }.compact
+        end
+
+        def inside_string_range(node)
+          loc = node.location
+
+          if node.heredoc?
+            loc.heredoc_body.join(loc.heredoc_end)
+          elsif delimited_string_literal?(node)
+            loc.begin.end.join(loc.end.begin)
+          end
+        end
+
+        # Some special kinds of string literals are not composed of literal
+        # characters between two delimiters:
+        # - The source map of `?a` responds to :begin and :end but its end is
+        #   nil.
+        # - The source map of `__FILE__` responds to neither :begin nor :end.
+        def delimited_string_literal?(node)
+          loc = node.location
+
+          loc.respond_to?(:begin) && loc.begin && loc.respond_to?(:end) && loc.end
         end
 
         def block_comment_within?(expr)
@@ -69,15 +85,15 @@ module RuboCop
         end
 
         def calculate_range(expr, line_begin_pos, column_delta)
-          starts_with_space =
-            expr.source_buffer.source[line_begin_pos].start_with?(' ')
-          pos_to_remove = if column_delta > 0 || starts_with_space
-                            line_begin_pos
-                          else
-                            line_begin_pos - column_delta.abs
-                          end
-
-          range_between(pos_to_remove, pos_to_remove + column_delta.abs)
+          return range_between(line_begin_pos, line_begin_pos) if column_delta.positive?
+
+          starts_with_space = expr.source_buffer.source[line_begin_pos].start_with?(' ')
+
+          if starts_with_space
+            range_between(line_begin_pos, line_begin_pos + column_delta.abs)
+          else
+            range_between(line_begin_pos - column_delta.abs, line_begin_pos)
+          end
         end
 
         def remove(range, corrector)
@@ -86,7 +102,7 @@ module RuboCop
           corrector.remove(range)
         rescue RuntimeError
           range = range_between(range.begin_pos + 1, range.end_pos + 1)
-          retry if range.source =~ /^ +$/
+          retry if /^ +$/.match?(range.source)
         ensure
           $stderr = original_stderr
         end

data/lib/rubocop/cop/correctors/condition_corrector.rb

@@ -5,14 +5,11 @@ module RuboCop
     # This class does condition auto-correction
     class ConditionCorrector
       class << self
-        def correct_negative_condition(node)
+        def correct_negative_condition(corrector, node)
           condition = negated_condition(node)
 
-          lambda do |corrector|
-            corrector.replace(node.loc.keyword, node.inverse_keyword)
-            corrector.replace(condition.source_range,
-                              condition.children.first.source)
-          end
+          corrector.replace(node.loc.keyword, node.inverse_keyword)
+          corrector.replace(condition, condition.children.first.source)
         end
 
         private

data/lib/rubocop/cop/correctors/each_to_for_corrector.rb

@@ -6,13 +6,12 @@ module RuboCop
     class EachToForCorrector
       extend NodePattern::Macros
 
-      CORRECTION_WITH_ARGUMENTS =
-        'for %<variables>s in %<collection>s do'.freeze
-      CORRECTION_WITHOUT_ARGUMENTS = 'for _ in %<enumerable>s do'.freeze
+      CORRECTION_WITH_ARGUMENTS = 'for %<variables>s in %<collection>s do'
+      CORRECTION_WITHOUT_ARGUMENTS = 'for _ in %<enumerable>s do'
 
       def initialize(block_node)
         @block_node = block_node
-        @collection_node = block_node.send_node.receiver
+        @collection_node = block_node.receiver
         @argument_node = block_node.arguments
       end
 
@@ -30,8 +29,7 @@ module RuboCop
                  collection: collection_node.source,
                  variables: argument_node.children.first.source)
         else
-          format(CORRECTION_WITHOUT_ARGUMENTS,
-                 enumerable: collection_node.source)
+          format(CORRECTION_WITHOUT_ARGUMENTS, enumerable: collection_node.source)
         end
       end
 

data/lib/rubocop/cop/correctors/empty_line_corrector.rb

@@ -5,20 +5,19 @@ module RuboCop
     # This class does empty line auto-correction
     class EmptyLineCorrector
       class << self
-        def correct(node)
+        def correct(corrector, node)
           offense_style, range = node
-          lambda do |corrector|
-            case offense_style
-            when :no_empty_lines then
-              corrector.remove(range)
-            when :empty_lines then
-              corrector.insert_before(range, "\n")
-            end
+
+          case offense_style
+          when :no_empty_lines
+            corrector.remove(range)
+          when :empty_lines
+            corrector.insert_before(range, "\n")
           end
         end
 
-        def insert_before(node)
-          ->(corrector) { corrector.insert_before(node.source_range, "\n") }
+        def insert_before(corrector, node)
+          corrector.insert_before(node, "\n")
         end
       end
     end

data/lib/rubocop/cop/correctors/for_to_each_corrector.rb

@@ -6,7 +6,7 @@ module RuboCop
     class ForToEachCorrector
       extend NodePattern::Macros
 
-      CORRECTION = '%<collection>s.each do |%<argument>s|'.freeze
+      CORRECTION = '%<collection>s.each do |%<argument>s|'
 
       def initialize(for_node)
         @for_node        = for_node
@@ -23,8 +23,7 @@ module RuboCop
       attr_reader :for_node, :variable_node, :collection_node
 
       def correction
-        format(CORRECTION, collection: collection_source,
-                           argument: variable_node.source)
+        format(CORRECTION, collection: collection_source, argument: variable_node.source)
       end
 
       def collection_source

data/lib/rubocop/cop/correctors/if_then_corrector.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class auto-corrects `if...then` structures to a multiline `if` statement
+    class IfThenCorrector
+      DEFAULT_INDENTATION_WIDTH = 2
+
+      def initialize(if_node, indentation: nil)
+        @if_node = if_node
+        @indentation = indentation || DEFAULT_INDENTATION_WIDTH
+      end
+
+      def call(corrector)
+        corrector.replace(if_node, replacement)
+      end
+
+      private
+
+      attr_reader :if_node, :indentation
+
+      def replacement(node = if_node, indentation = nil)
+        indentation = ' ' * node.source_range.column if indentation.nil?
+        if_branch_source = node.if_branch&.source || 'nil'
+        elsif_indentation = indentation if node.respond_to?(:elsif?) && node.elsif?
+
+        if_branch = <<~RUBY
+          #{elsif_indentation}#{node.keyword} #{node.condition.source}
+          #{indentation}#{branch_body_indentation}#{if_branch_source}
+        RUBY
+
+        else_branch = rewrite_else_branch(node.else_branch, indentation)
+        if_branch + else_branch
+      end
+
+      def rewrite_else_branch(else_branch, indentation)
+        if else_branch.nil?
+          'end'
+        elsif else_branch.if_type? && else_branch.elsif?
+          replacement(else_branch, indentation)
+        else
+          <<~RUBY.chomp
+            #{indentation}else
+            #{indentation}#{branch_body_indentation}#{else_branch.source}
+            #{indentation}end
+          RUBY
+        end
+      end
+
+      def branch_body_indentation
+        @branch_body_indentation ||= (' ' * indentation).freeze
+      end
+    end
+  end
+end

data/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb

@@ -44,13 +44,13 @@ module RuboCop
       end
 
       def replace_selector(corrector)
-        corrector.replace(method.source_range, 'lambda')
+        corrector.replace(method, 'lambda')
       end
 
       def remove_arguments(corrector)
         return if arguments.empty_and_without_delimiters?
 
-        corrector.remove(arguments.source_range)
+        corrector.remove(arguments)
       end
 
       def insert_arguments(corrector)
@@ -62,7 +62,7 @@ module RuboCop
 
       def remove_leading_whitespace(corrector)
         corrector.remove_preceding(
-          arguments.source_range,
+          arguments,
           arguments.source_range.begin_pos -
             block_node.send_node.source_range.end_pos
         )
@@ -70,7 +70,7 @@ module RuboCop
 
       def remove_trailing_whitespace(corrector)
         size = block_begin.begin_pos - arguments.source_range.end_pos - 1
-        corrector.remove_preceding(block_begin, size) if size > 0
+        corrector.remove_preceding(block_begin, size) if size.positive?
       end
 
       def replace_delimiters(corrector)
@@ -87,17 +87,17 @@ module RuboCop
       end
 
       def needs_separating_space?
-        block_begin.begin_pos == arguments_end_pos &&
-          selector_end.end_pos == arguments_begin_pos ||
+        (block_begin.begin_pos == arguments_end_pos &&
+          selector_end.end_pos == arguments_begin_pos) ||
           block_begin.begin_pos == selector_end.end_pos
       end
 
       def arguments_end_pos
-        arguments.loc.end && arguments.loc.end.end_pos
+        arguments.loc.end&.end_pos
       end
 
       def arguments_begin_pos
-        arguments.loc.begin && arguments.loc.begin.begin_pos
+        arguments.loc.begin&.begin_pos
       end
 
       def block_end
@@ -117,19 +117,19 @@ module RuboCop
 
         parent = current_node.parent
 
-        if parent && parent.pair_type?
+        if parent&.pair_type?
           current_node = parent.parent
           parent = current_node.parent
         end
 
-        return false unless parent && parent.send_type?
+        return false unless parent&.send_type?
         return false if parent.parenthesized_call?
 
         current_node.sibling_index > 1
       end
 
       def separating_space?
-        block_begin.source_buffer.source[block_begin.begin_pos + 2].match(/\s/)
+        block_begin.source_buffer.source[block_begin.begin_pos + 2].match?(/\s/)
       end
     end
   end

data/lib/rubocop/cop/correctors/line_break_corrector.rb

@@ -16,21 +16,19 @@ module RuboCop
                                   processed_source:)
           @processed_source = processed_source
           range = first_part_of(node.to_a.last)
-          eol_comment = end_of_line_comment(node.source_range.line)
+          eol_comment = processed_source.comment_at_line(node.source_range.line)
 
           break_line_before(range: range, node: node, corrector: corrector,
                             configured_width: configured_width)
-          move_comment(eol_comment: eol_comment, node: node,
-                       corrector: corrector)
+          move_comment(eol_comment: eol_comment, node: node, corrector: corrector)
           remove_semicolon(node, corrector)
         end
 
-        def break_line_before(range:, node:, corrector:, indent_steps: 1,
-                              configured_width:)
+        def break_line_before(range:, node:, corrector:, configured_width:,
+                              indent_steps: 1)
           corrector.insert_before(
             range,
-            "\n" + ' ' * (node.loc.keyword.column +
-                          indent_steps * configured_width)
+            "\n#{' ' * (node.loc.keyword.column + (indent_steps * configured_width))}"
           )
         end
 
@@ -38,9 +36,8 @@ module RuboCop
           return unless eol_comment
 
           text = eol_comment.loc.expression.source
-          corrector.insert_before(node.source_range,
-                                  text + "\n" + (' ' * node.loc.keyword.column))
-          corrector.remove(eol_comment.loc.expression)
+          corrector.insert_before(node, "#{text}\n#{' ' * node.loc.keyword.column}")
+          corrector.remove(eol_comment)
         end
 
         private
@@ -52,8 +49,8 @@ module RuboCop
         end
 
         def semicolon(node)
-          @semicolon ||= {}
-          @semicolon[node.object_id] ||= tokens(node).find(&:semicolon?)
+          @semicolon ||= {}.compare_by_identity
+          @semicolon[node] ||= processed_source.tokens_within(node).find(&:semicolon?)
         end
       end
     end

data/lib/rubocop/cop/correctors/multiline_literal_brace_corrector.rb

@@ -8,12 +8,17 @@ module RuboCop
       include MultilineLiteralBraceLayout
       include RangeHelp
 
-      def initialize(node, processed_source)
+      def self.correct(corrector, node, processed_source)
+        new(corrector, node, processed_source).call
+      end
+
+      def initialize(corrector, node, processed_source)
+        @corrector = corrector
         @node = node
         @processed_source = processed_source
       end
 
-      def call(corrector)
+      def call
         if closing_brace_on_same_line?(node)
           correct_same_line_brace(corrector)
         else
@@ -29,21 +34,45 @@ module RuboCop
 
       private
 
-      attr_reader :node, :processed_source
+      attr_reader :corrector, :node, :processed_source
 
       def correct_same_line_brace(corrector)
-        corrector.insert_before(node.loc.end, "\n".freeze)
+        corrector.insert_before(node.loc.end, "\n")
       end
 
       def correct_next_line_brace(corrector)
-        corrector.remove(
-          range_with_surrounding_space(range: node.loc.end, side: :left)
+        corrector.remove(range_with_surrounding_space(range: node.loc.end, side: :left))
+
+        corrector.insert_before(
+          last_element_range_with_trailing_comma(node).end,
+          content_if_comment_present(corrector, node)
         )
+      end
 
-        corrector.insert_after(
-          last_element_range_with_trailing_comma(node),
+      def content_if_comment_present(corrector, node)
+        range = range_with_surrounding_space(
+          range: children(node).last.source_range,
+          side: :right
+        ).end.resize(1)
+        if range.source == '#'
+          select_content_to_be_inserted_after_last_element(corrector, node)
+        else
           node.loc.end.source
+        end
+      end
+
+      def select_content_to_be_inserted_after_last_element(corrector, node)
+        range = range_between(
+          node.loc.end.begin_pos,
+          range_by_whole_lines(node.loc.expression).end.end_pos
         )
+
+        remove_trailing_content_of_comment(corrector, range)
+        range.source
+      end
+
+      def remove_trailing_content_of_comment(corrector, range)
+        corrector.remove(range)
       end
 
       def last_element_range_with_trailing_comma(node)

data/lib/rubocop/cop/correctors/ordered_gem_corrector.rb

@@ -4,9 +4,10 @@ module RuboCop
   module Cop
     # This auto-corrects gem dependency order
     class OrderedGemCorrector
-      extend OrderedGemNode
-
       class << self
+        include OrderedGemNode
+        include RangeHelp
+
         attr_reader :processed_source, :comments_as_separators
 
         def correct(processed_source, node,
@@ -17,26 +18,24 @@ module RuboCop
           current_range = declaration_with_comment(node)
           previous_range = declaration_with_comment(previous_declaration)
 
-          lambda do |corrector|
-            swap_range(corrector, current_range, previous_range)
-          end
+          ->(corrector) { swap_range(corrector, current_range, previous_range) }
         end
 
         private
 
         def declaration_with_comment(node)
           buffer = processed_source.buffer
-          begin_pos = get_source_range(node, comments_as_separators).begin_pos
+          begin_pos = range_by_whole_lines(get_source_range(node, comments_as_separators)).begin_pos
           end_line = buffer.line_for_position(node.loc.expression.end_pos)
-          end_pos = buffer.line_range(end_line).end_pos
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+          end_pos = range_by_whole_lines(buffer.line_range(end_line),
+                                         include_final_newline: true).end_pos
+
+          range_between(begin_pos, end_pos)
         end
 
         def swap_range(corrector, range1, range2)
-          src1 = range1.source
-          src2 = range2.source
-          corrector.replace(range1, src2)
-          corrector.replace(range2, src1)
+          corrector.insert_before(range2, range1.source)
+          corrector.remove(range1)
         end
       end
     end

data/lib/rubocop/cop/correctors/parentheses_corrector.rb

@@ -5,21 +5,18 @@ module RuboCop
     # This auto-corrects parentheses
     class ParenthesesCorrector
       class << self
-        def correct(node)
-          lambda do |corrector|
-            corrector.remove(node.loc.begin)
-            corrector.remove(node.loc.end)
+        def correct(corrector, node)
+          corrector.remove(node.loc.begin)
+          corrector.remove(node.loc.end)
+          return unless ternary_condition?(node) && next_char_is_question_mark?(node)
 
-            if ternary_condition?(node) && next_char_is_question_mark?(node)
-              corrector.insert_after(node.loc.end, ' ')
-            end
-          end
+          corrector.insert_after(node.loc.end, ' ')
         end
 
         private
 
         def ternary_condition?(node)
-          node.parent && node.parent.if_type? && node.parent.ternary?
+          node.parent&.if_type? && node.parent&.ternary?
         end
 
         def next_char_is_question_mark?(node)

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -13,23 +13,18 @@ module RuboCop
         @preferred_delimiters = preferred_delimiters
       end
 
-      def correct(node, char)
+      def correct(corrector, node, char)
         escape = escape_words?(node)
         char = char.upcase if escape
         delimiters = delimiters_for("%#{char}")
         contents = new_contents(node, escape, delimiters)
-        wrap_contents(node, contents, char, delimiters)
+        wrap_contents(corrector, node, contents, char, delimiters)
       end
 
       private
 
-      def wrap_contents(node, contents, char, delimiters)
-        lambda do |corrector|
-          corrector.replace(
-            node.source_range,
-            "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
-          )
-        end
+      def wrap_contents(corrector, node, contents, char, delimiters)
+        corrector.replace(node, "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}")
       end
 
       def escape_words?(node)
@@ -37,9 +32,7 @@ module RuboCop
       end
 
       def delimiters_for(type)
-        PreferredDelimiters
-          .new(type, config, preferred_delimiters)
-          .delimiters
+        PreferredDelimiters.new(type, config, preferred_delimiters).delimiters
       end
 
       def new_contents(node, escape, delimiters)
@@ -53,7 +46,7 @@ module RuboCop
       def autocorrect_multiline_words(node, escape, delimiters)
         contents = process_multiline_words(node, escape, delimiters)
         contents << end_content(node.source)
-        contents.join('')
+        contents.join
       end
 
       def autocorrect_words(node, escape, delimiters)
@@ -66,12 +59,8 @@ module RuboCop
         base_line_num = node.first_line
         prev_line_num = base_line_num
         node.children.map.with_index do |word_node, index|
-          line_breaks = line_breaks(word_node,
-                                    node.source,
-                                    prev_line_num,
-                                    base_line_num,
-                                    index)
-          prev_line_num = word_node.first_line
+          line_breaks = line_breaks(word_node, node.source, prev_line_num, base_line_num, index)
+          prev_line_num = word_node.last_line
           content = fix_escaped_content(word_node, escape, delimiters)
           line_breaks + content
         end
@@ -94,11 +83,11 @@ module RuboCop
         begin_line_num = previous_line_num - base_line_num + 1
         end_line_num = node.first_line - base_line_num + 1
         lines = source_in_lines[begin_line_num...end_line_num]
-        "\n#{(lines.join("\n").split(node.source).first || '')}"
+        "\n#{lines.join("\n").split(node.source).first || ''}"
       end
 
       def fix_escaped_content(word_node, escape, delimiters)
-        content = word_node.children.first.to_s
+        content = +word_node.children.first.to_s
         content = escape_string(content) if escape
         substitute_escaped_delimiters(content, delimiters)
         content
@@ -110,7 +99,7 @@ module RuboCop
 
       def end_content(source)
         result = /\A(\s*)\]/.match(source.split("\n").last)
-        ("\n" + result[1]) if result
+        "\n#{result[1]}" if result
       end
     end
   end

data/lib/rubocop/cop/correctors/punctuation_corrector.rb

@@ -5,22 +5,20 @@ module RuboCop
     # This auto-corrects punctuation
     class PunctuationCorrector
       class << self
-        def remove_space(space_before)
-          ->(corrector) { corrector.remove(space_before) }
+        def remove_space(corrector, space_before)
+          corrector.remove(space_before)
         end
 
-        def add_space(token)
-          ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
+        def add_space(corrector, token)
+          corrector.replace(token.pos, "#{token.pos.source} ")
         end
 
-        def swap_comma(range)
+        def swap_comma(corrector, range)
           return unless range
 
-          lambda do |corrector|
-            case range.source
-            when ',' then corrector.remove(range)
-            else          corrector.insert_after(range, ',')
-            end
+          case range.source
+          when ',' then corrector.remove(range)
+          else          corrector.insert_after(range, ',')
           end
         end
       end