rubocop 0.51.0 → 0.87.0

data/lib/rubocop/cop/corrector.rb

@@ -8,127 +8,111 @@ module RuboCop
     # Important!
     # The nodes modified by the corrections should be part of the
     # AST of the source_buffer.
-    class Corrector
+    class Corrector < ::Parser::Source::TreeRewriter
+      # @param source [Parser::Source::Buffer, or anything
+      #                leading to one via `(processed_source.)buffer`]
       #
-      # @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
-      #
-      #   corrections = [AndOrCorrector.new(node)]
-      #   corrector = Corrector.new(source_buffer, corrections)
-      def initialize(source_buffer, corrections = [])
-        @source_buffer = source_buffer
-        @corrections = corrections
-        @source_rewriter = Parser::Source::Rewriter.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
-      end
-
-      attr_reader :corrections, :diagnostics
-
-      # Does the actual rewrite and returns string corresponding to
-      # the rewritten source.
-      #
-      # @return [String]
-      def rewrite
-        # rubocop:disable Lint/HandleExceptions
-        @corrections.each do |correction|
-          begin
-            @source_rewriter.transaction do
-              correction.call(self)
-            end
-          rescue ::Parser::ClobberingError
-          end
-        end
-        # rubocop:enable Lint/HandleExceptions
-
-        @source_rewriter.process
-      end
-
-      # Removes the source range.
-      #
-      # @param [Parser::Source::Range] range
-      def remove(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)
-        @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)
-        @source_rewriter.insert_after(range, content)
+        diagnostics.consumer = ->(diagnostic) {}
       end
 
-      # Replaces the code of the source range `range` with `content`.
-      #
-      # @param [Parser::Source::Range] range
-      # @param [String] content
-      def replace(range, content)
-        @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)
-        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)
-        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)
-        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
+
+      # 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
+
+      private
+
+      # :nodoc:
+      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)
+          # 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:#{@source_buffer.name.inspect} under investigation"
       end
     end
   end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does auto-correction 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
+      extend RangeHelp
+      extend Alignment
+
+      class << self
+        attr_reader :processed_source
+
+        def correct(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)
+
+          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
+          end
+        end
+
+        def align_end(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) }
+        end
+
+        private
+
+        def autocorrect_line(corrector, line_begin_pos, expr, column_delta,
+                             taboo_ranges)
+          range = calculate_range(expr, line_begin_pos, column_delta)
+          # 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?
+            corrector.insert_before(range, ' ' * column_delta) unless range.resize(1).source == "\n"
+          elsif /\A[ \t]+\z/.match?(range.source)
+            remove(range, corrector)
+          end
+        end
+
+        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
+        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)
+          processed_source.comments.select(&:document?).any? do |c|
+            within?(c.loc.expression, expr)
+          end
+        end
+
+        def calculate_range(expr, line_begin_pos, column_delta)
+          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)
+          original_stderr = $stderr
+          $stderr = StringIO.new # Avoid error messages on console
+          corrector.remove(range)
+        rescue RuntimeError
+          range = range_between(range.begin_pos + 1, range.end_pos + 1)
+          retry if /^ +$/.match?(range.source)
+        ensure
+          $stderr = original_stderr
+        end
+
+        def each_line(expr)
+          line_begin_pos = expr.begin_pos
+          expr.source.each_line do |line|
+            yield line_begin_pos
+            line_begin_pos += line.length
+          end
+        end
+
+        def whitespace_range(node)
+          begin_pos = node.loc.end.begin_pos
+
+          range_between(begin_pos - node.loc.end.column, begin_pos)
+        end
+
+        def alignment_column(align_to)
+          if !align_to
+            0
+          elsif align_to.respond_to?(:loc)
+            align_to.source_range.column
+          else
+            align_to.column
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does condition auto-correction
+    class ConditionCorrector
+      class << self
+        def correct_negative_condition(node)
+          condition = negated_condition(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.keyword, node.inverse_keyword)
+            corrector.replace(condition, condition.children.first.source)
+          end
+        end
+
+        private
+
+        def negated_condition(node)
+          condition = node.condition
+          condition = condition.children.first while condition.begin_type?
+          condition
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class auto-corrects `#each` enumeration to `for` iteration.
+    class EachToForCorrector
+      extend NodePattern::Macros
+
+      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
+        @argument_node = block_node.arguments
+      end
+
+      def call(corrector)
+        corrector.replace(offending_range, correction)
+      end
+
+      private
+
+      attr_reader :block_node, :collection_node, :argument_node
+
+      def correction
+        if block_node.arguments?
+          format(CORRECTION_WITH_ARGUMENTS,
+                 collection: collection_node.source,
+                 variables: argument_node.children.first.source)
+        else
+          format(CORRECTION_WITHOUT_ARGUMENTS,
+                 enumerable: collection_node.source)
+        end
+      end
+
+      def offending_range
+        if block_node.arguments?
+          replacement_range(argument_node.loc.expression.end_pos)
+        else
+          replacement_range(block_node.loc.begin.end_pos)
+        end
+      end
+
+      def replacement_range(end_pos)
+        Parser::Source::Range.new(block_node.loc.expression.source_buffer,
+                                  block_node.loc.expression.begin_pos,
+                                  end_pos)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does empty line auto-correction
+    class EmptyLineCorrector
+      class << self
+        def correct(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
+          end
+        end
+
+        def insert_before(node)
+          ->(corrector) { corrector.insert_before(node, "\n") }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class auto-corrects `for` iteration to `#each` enumeration.
+    class ForToEachCorrector
+      extend NodePattern::Macros
+
+      CORRECTION = '%<collection>s.each do |%<argument>s|'
+
+      def initialize(for_node)
+        @for_node        = for_node
+        @variable_node   = for_node.variable
+        @collection_node = for_node.collection
+      end
+
+      def call(corrector)
+        corrector.replace(offending_range, correction)
+      end
+
+      private
+
+      attr_reader :for_node, :variable_node, :collection_node
+
+      def correction
+        format(CORRECTION, collection: collection_source,
+                           argument: variable_node.source)
+      end
+
+      def collection_source
+        if requires_parentheses?
+          "(#{collection_node.source})"
+        else
+          collection_node.source
+        end
+      end
+
+      def requires_parentheses?
+        collection_node.range_type?
+      end
+
+      def end_position
+        if for_node.do?
+          keyword_begin.end_pos
+        else
+          collection_end.end_pos
+        end
+      end
+
+      def keyword_begin
+        for_node.loc.begin
+      end
+
+      def collection_end
+        if collection_node.begin_type?
+          collection_node.loc.end
+        else
+          collection_node.loc.expression
+        end
+      end
+
+      def offending_range
+        replacement_range(end_position)
+      end
+
+      def replacement_range(end_pos)
+        Parser::Source::Range.new(for_node.loc.expression.source_buffer,
+                                  for_node.loc.expression.begin_pos,
+                                  end_pos)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class auto-corrects lambda literal to method notation.
+    class LambdaLiteralToMethodCorrector
+      def initialize(block_node)
+        @block_node = block_node
+        @method     = block_node.send_node
+        @arguments  = block_node.arguments
+      end
+
+      def call(corrector)
+        # Check for unparenthesized args' preceding and trailing whitespaces.
+        remove_unparenthesized_whitespace(corrector)
+
+        # Avoid correcting to `lambdado` by inserting whitespace
+        # if none exists before or after the lambda arguments.
+        insert_separating_space(corrector)
+
+        replace_selector(corrector)
+        remove_arguments(corrector)
+
+        replace_delimiters(corrector)
+
+        insert_arguments(corrector)
+      end
+
+      private
+
+      attr_reader :block_node, :method, :arguments
+
+      def remove_unparenthesized_whitespace(corrector)
+        return if arguments.empty? || arguments.parenthesized_call?
+
+        remove_leading_whitespace(corrector)
+        remove_trailing_whitespace(corrector)
+      end
+
+      def insert_separating_space(corrector)
+        return unless needs_separating_space?
+
+        corrector.insert_before(block_begin, ' ')
+      end
+
+      def replace_selector(corrector)
+        corrector.replace(method, 'lambda')
+      end
+
+      def remove_arguments(corrector)
+        return if arguments.empty_and_without_delimiters?
+
+        corrector.remove(arguments)
+      end
+
+      def insert_arguments(corrector)
+        return if arguments.empty?
+
+        arg_str = " |#{lambda_arg_string}|"
+        corrector.insert_after(block_node.loc.begin, arg_str)
+      end
+
+      def remove_leading_whitespace(corrector)
+        corrector.remove_preceding(
+          arguments,
+          arguments.source_range.begin_pos -
+            block_node.send_node.source_range.end_pos
+        )
+      end
+
+      def remove_trailing_whitespace(corrector)
+        size = block_begin.begin_pos - arguments.source_range.end_pos - 1
+        corrector.remove_preceding(block_begin, size) if size.positive?
+      end
+
+      def replace_delimiters(corrector)
+        return if block_node.braces? || !arg_to_unparenthesized_call?
+
+        corrector.insert_after(block_begin, ' ') unless separating_space?
+
+        corrector.replace(block_begin, '{')
+        corrector.replace(block_end, '}')
+      end
+
+      def lambda_arg_string
+        arguments.children.map(&:source).join(', ')
+      end
+
+      def needs_separating_space?
+        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&.end_pos
+      end
+
+      def arguments_begin_pos
+        arguments.loc.begin&.begin_pos
+      end
+
+      def block_end
+        block_node.loc.end
+      end
+
+      def block_begin
+        block_node.loc.begin
+      end
+
+      def selector_end
+        method.loc.selector.end
+      end
+
+      def arg_to_unparenthesized_call?
+        current_node = block_node
+
+        parent = current_node.parent
+
+        if parent&.pair_type?
+          current_node = parent.parent
+          parent = current_node.parent
+        end
+
+        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/)
+      end
+    end
+  end
+end