rubocop 0.80.0 → 1.42.0

data/lib/rubocop/cop/corrector.rb

@@ -8,163 +8,121 @@ module RuboCop
     # Important!
     # The nodes modified by the corrections should be part of the
     # AST of the source_buffer.
-    class Corrector
-      #
-      # @param source_buffer [Parser::Source::Buffer]
-      # @param corrections [Array(#call)]
-      #   Array of Objects that respond to #call. They will receive the
-      #   corrector itself and should use its method to modify the source.
-      #
-      # @example
-      #
-      #   class AndOrCorrector
-      #     def initialize(node)
-      #       @node = node
-      #     end
-      #
-      #     def call(corrector)
-      #       replacement = (@node.type == :and ? '&&' : '||')
-      #       corrector.replace(@node.loc.operator, replacement)
-      #     end
-      #   end
+    class Corrector < ::Parser::Source::TreeRewriter
+      NOOP_CONSUMER = ->(diagnostic) {} # noop
+
+      # Duck typing for get to a ::Parser::Source::Buffer
+      def self.source_buffer(source)
+        source = source.processed_source if source.respond_to?(:processed_source)
+        source = source.buffer if source.respond_to?(:buffer)
+        source = source.source_buffer if source.respond_to?(:source_buffer)
+
+        unless source.is_a? ::Parser::Source::Buffer
+          raise TypeError, 'Expected argument to lead to a Parser::Source::Buffer ' \
+                           "but got #{source.inspect}"
+        end
+
+        source
+      end
+
+      # @param source [Parser::Source::Buffer, or anything
+      #                leading to one via `(processed_source.)buffer`]
       #
-      #   corrections = [AndOrCorrector.new(node)]
-      #   corrector = Corrector.new(source_buffer, corrections)
-      def initialize(source_buffer, corrections = [])
-        @source_buffer = source_buffer
-        raise 'source_buffer should be a Parser::Source::Buffer' unless \
-          source_buffer.is_a? Parser::Source::Buffer
-
-        @corrections = corrections
-        @source_rewriter = Parser::Source::TreeRewriter.new(
-          source_buffer,
+      #   corrector = Corrector.new(cop)
+      def initialize(source)
+        source = self.class.source_buffer(source)
+        super(
+          source,
           different_replacements: :raise,
           swallowed_insertions: :raise,
           crossing_deletions: :accept
         )
 
-        @diagnostics = []
         # Don't print warnings to stderr if corrections conflict with each other
-        @source_rewriter.diagnostics.consumer = lambda do |diagnostic|
-          @diagnostics << diagnostic
-        end
+        diagnostics.consumer = NOOP_CONSUMER
       end
 
-      attr_reader :corrections, :diagnostics
-
-      # Does the actual rewrite and returns string corresponding to
-      # the rewritten source.
-      #
-      # @return [String]
-      def rewrite
-        @corrections.each do |correction|
-          begin
-            @source_rewriter.transaction do
-              correction.call(self)
-            end
-          rescue ErrorWithAnalyzedFileLocation => e
-            raise e unless e.cause.is_a?(::Parser::ClobberingError)
-          end
-        end
-
-        @source_rewriter.process
-      end
-
-      # Removes the source range.
-      #
-      # @param [Parser::Source::Range] range
-      def remove(range)
-        validate_range range
-        @source_rewriter.remove(range)
-      end
-
-      # Inserts new code before the given source range.
-      #
-      # @param [Parser::Source::Range] range
-      # @param [String] content
-      def insert_before(range, content)
-        validate_range range
-        # TODO: Fix Cops using bad ranges instead
-        if range.end_pos > @source_buffer.source.size
-          range = range.with(end_pos: @source_buffer.source.size)
-        end
-
-        @source_rewriter.insert_before(range, content)
-      end
-
-      # Inserts new code after the given source range.
-      #
-      # @param [Parser::Source::Range] range
-      # @param [String] content
-      def insert_after(range, content)
-        validate_range range
-        @source_rewriter.insert_after(range, content)
-      end
-
-      # Replaces the code of the source range `range` with `content`.
-      #
-      # @param [Parser::Source::Range] range
-      # @param [String] content
-      def replace(range, content)
-        validate_range range
-        @source_rewriter.replace(range, content)
-      end
+      alias rewrite process # Legacy
 
       # Removes `size` characters prior to the source range.
       #
-      # @param [Parser::Source::Range] range
+      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
       # @param [Integer] size
-      def remove_preceding(range, size)
-        validate_range range
-        to_remove = Parser::Source::Range.new(range.source_buffer,
-                                              range.begin_pos - size,
-                                              range.begin_pos)
-        @source_rewriter.remove(to_remove)
+      def remove_preceding(node_or_range, size)
+        range = to_range(node_or_range)
+        to_remove = range.with(begin_pos: range.begin_pos - size, end_pos: range.begin_pos)
+        remove(to_remove)
       end
 
       # Removes `size` characters from the beginning of the given range.
       # If `size` is greater than the size of `range`, the removed region can
       # overrun the end of `range`.
       #
-      # @param [Parser::Source::Range] range
+      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
       # @param [Integer] size
-      def remove_leading(range, size)
-        validate_range range
-        to_remove = Parser::Source::Range.new(range.source_buffer,
-                                              range.begin_pos,
-                                              range.begin_pos + size)
-        @source_rewriter.remove(to_remove)
+      def remove_leading(node_or_range, size)
+        range = to_range(node_or_range)
+        to_remove = range.with(end_pos: range.begin_pos + size)
+        remove(to_remove)
       end
 
       # Removes `size` characters from the end of the given range.
       # If `size` is greater than the size of `range`, the removed region can
       # overrun the beginning of `range`.
       #
-      # @param [Parser::Source::Range] range
+      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
       # @param [Integer] size
-      def remove_trailing(range, size)
-        validate_range range
-        to_remove = Parser::Source::Range.new(range.source_buffer,
-                                              range.end_pos - size,
-                                              range.end_pos)
-        @source_rewriter.remove(to_remove)
+      def remove_trailing(node_or_range, size)
+        range = to_range(node_or_range)
+        to_remove = range.with(begin_pos: range.end_pos - size)
+        remove(to_remove)
+      end
+
+      # Swaps sources at the given ranges.
+      #
+      # @param [Parser::Source::Range, RuboCop::AST::Node] node_or_range1
+      # @param [Parser::Source::Range, RuboCop::AST::Node] node_or_range2
+      def swap(node_or_range1, node_or_range2)
+        range1 = to_range(node_or_range1)
+        range2 = to_range(node_or_range2)
+
+        replace(range1, range2.source)
+        replace(range2, range1.source)
       end
 
       private
 
       # :nodoc:
-      def validate_range(range)
-        buffer = range.source_buffer
-        return if buffer == @source_buffer
+      def to_range(node_or_range)
+        range = case node_or_range
+                when ::RuboCop::AST::Node, ::Parser::Source::Comment
+                  node_or_range.loc.expression
+                when ::Parser::Source::Range
+                  node_or_range
+                else
+                  raise TypeError,
+                        'Expected a Parser::Source::Range, Comment or ' \
+                        "RuboCop::AST::Node, got #{node_or_range.class}"
+                end
+        validate_buffer(range.source_buffer)
+        range
+      end
+
+      def check_range_validity(node_or_range)
+        super(to_range(node_or_range))
+      end
+
+      def validate_buffer(buffer)
+        return if buffer == source_buffer
 
-        unless buffer.is_a?(Parser::Source::Buffer)
+        unless buffer.is_a?(::Parser::Source::Buffer)
           # actually this should be enforced by parser gem
           raise 'Corrector expected range source buffer to be a ' \
                 "Parser::Source::Buffer, but got #{buffer.class}"
         end
         raise "Correction target buffer #{buffer.object_id} " \
-              "name:#{buffer.name.inspect}" \
-              " is not current #{@source_buffer.object_id} " \
+              "name:#{buffer.name.inspect} " \
+              "is not current #{@source_buffer.object_id} " \
               "name:#{@source_buffer.name.inspect} under investigation"
       end
     end

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

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    # This class does auto-correction of nodes that should just be moved to
+    # This class does autocorrection of nodes that should just be moved to
     # the left or to the right, amount being determined by the instance
     # variable column_delta.
     class AlignmentCorrector
@@ -12,7 +12,7 @@ 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
@@ -21,21 +21,18 @@ module RuboCop
 
           taboo_ranges = inside_string_ranges(node)
 
-          lambda do |corrector|
-            each_line(expr) do |line_begin_pos|
-              autocorrect_line(corrector, line_begin_pos, expr, column_delta,
-                               taboo_ranges)
-            end
+          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
@@ -47,11 +44,9 @@ module RuboCop
           # string literals
           return if taboo_ranges.any? { |t| within?(range, t) }
 
-          if column_delta.positive?
-            unless range.resize(1).source == "\n"
-              corrector.insert_before(range, ' ' * column_delta)
-            end
-          elsif range.source =~ /\A[ \t]+\z/
+          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
@@ -59,8 +54,7 @@ module RuboCop
         def inside_string_ranges(node)
           return [] unless node.is_a?(Parser::AST::Node)
 
-          node.each_node(:str, :dstr, :xstr).map { |n| inside_string_range(n) }
-              .compact
+          node.each_node(:str, :dstr, :xstr).map { |n| inside_string_range(n) }.compact
         end
 
         def inside_string_range(node)
@@ -81,8 +75,7 @@ module RuboCop
         def delimited_string_literal?(node)
           loc = node.location
 
-          loc.respond_to?(:begin) && loc.begin &&
-            loc.respond_to?(:end) && loc.end
+          loc.respond_to?(:begin) && loc.begin && loc.respond_to?(:end) && loc.end
         end
 
         def block_comment_within?(expr)
@@ -92,12 +85,9 @@ module RuboCop
         end
 
         def calculate_range(expr, line_begin_pos, column_delta)
-          if column_delta.positive?
-            return range_between(line_begin_pos, line_begin_pos)
-          end
+          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?(' ')
+          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)
@@ -112,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

@@ -2,17 +2,14 @@
 
 module RuboCop
   module Cop
-    # This class does condition auto-correction
+    # This class does condition autocorrection
     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

@@ -2,17 +2,16 @@
 
 module RuboCop
   module Cop
-    # This class auto-corrects `#each` enumeration to `for` iteration.
+    # This class autocorrects `#each` enumeration to `for` iteration.
     class EachToForCorrector
       extend NodePattern::Macros
 
-      CORRECTION_WITH_ARGUMENTS =
-        'for %<variables>s in %<collection>s do'
+      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

@@ -2,23 +2,22 @@
 
 module RuboCop
   module Cop
-    # This class does empty line auto-correction
+    # This class does empty line autocorrection
     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
-              corrector.remove(range)
-            when :empty_lines
-              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

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    # This class auto-corrects `for` iteration to `#each` enumeration.
+    # This class autocorrects `for` iteration to `#each` enumeration.
     class ForToEachCorrector
       extend NodePattern::Macros
 
@@ -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
@@ -36,7 +35,9 @@ module RuboCop
       end
 
       def requires_parentheses?
-        collection_node.range_type?
+        return true if collection_node.send_type? && collection_node.operator_method?
+
+        collection_node.range_type? || collection_node.or_type? || collection_node.and_type?
       end
 
       def end_position

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class autocorrects `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

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    # This class auto-corrects lambda literal to method notation.
+    # This class autocorrects lambda literal to method notation.
     class LambdaLiteralToMethodCorrector
       def initialize(block_node)
         @block_node = block_node
@@ -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
         )
@@ -87,8 +87,8 @@ 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
 
@@ -129,7 +129,7 @@ module RuboCop
       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,14 @@ module RuboCop
         end
 
         def semicolon(node)
-          @semicolon ||= {}
-          @semicolon[node.object_id] ||= tokens(node).find(&:semicolon?)
+          @semicolon ||= {}.compare_by_identity
+          @semicolon[node] ||= processed_source.sorted_tokens.select(&:semicolon?).find do |token|
+            same_line?(token, node.body) && trailing_class_definition?(token, node.body)
+          end
+        end
+
+        def trailing_class_definition?(token, body)
+          token.column < body.loc.column
         end
       end
     end