rubocop 0.86.0 → 0.87.0

data/lib/rubocop/cop/corrector.rb

@@ -8,117 +8,25 @@ 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
-        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
-      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, Rubocop::AST::Node] range or node
-      def remove(node_or_range)
-        range = to_range(node_or_range)
-        @source_rewriter.remove(range)
-      end
-
-      # Inserts new code before the given source range.
-      #
-      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
-      # @param [String] content
-      def insert_before(node_or_range, content)
-        range = to_range(node_or_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, Rubocop::AST::Node] range or node
-      # @param [String] content
-      def insert_after(node_or_range, content)
-        range = to_range(node_or_range)
-        @source_rewriter.insert_after(range, content)
+        diagnostics.consumer = ->(diagnostic) {}
       end
 
-      # Wraps the given source range with the given before and after texts
-      #
-      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
-      # @param [String] before
-      # @param [String] after
-      def wrap(node_or_range, before, after)
-        range = to_range(node_or_range)
-        @source_rewriter.wrap(range, before, after)
-      end
-
-      # Replaces the code of the source range `range` with `content`.
-      #
-      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
-      # @param [String] content
-      def replace(node_or_range, content)
-        range = to_range(node_or_range)
-        @source_rewriter.replace(range, content)
-      end
+      alias rewrite process # Legacy
 
       # Removes `size` characters prior to the source range.
       #
@@ -126,10 +34,11 @@ module RuboCop
       # @param [Integer] size
       def remove_preceding(node_or_range, size)
         range = to_range(node_or_range)
-        to_remove = Parser::Source::Range.new(range.source_buffer,
-                                              range.begin_pos - size,
-                                              range.begin_pos)
-        @source_rewriter.remove(to_remove)
+        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.
@@ -140,10 +49,8 @@ module RuboCop
       # @param [Integer] size
       def remove_leading(node_or_range, size)
         range = to_range(node_or_range)
-        to_remove = Parser::Source::Range.new(range.source_buffer,
-                                              range.begin_pos,
-                                              range.begin_pos + size)
-        @source_rewriter.remove(to_remove)
+        to_remove = range.with(end_pos: range.begin_pos + size)
+        remove(to_remove)
       end
 
       # Removes `size` characters from the end of the given range.
@@ -154,10 +61,22 @@ module RuboCop
       # @param [Integer] size
       def remove_trailing(node_or_range, size)
         range = to_range(node_or_range)
-        to_remove = Parser::Source::Range.new(range.source_buffer,
-                                              range.end_pos - size,
-                                              range.end_pos)
-        @source_rewriter.remove(to_remove)
+        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
@@ -178,8 +97,12 @@ module RuboCop
         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
+        return if buffer == source_buffer
 
         unless buffer.is_a?(::Parser::Source::Buffer)
           # actually this should be enforced by parser gem

data/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb

@@ -28,7 +28,7 @@ module RuboCop
       class RubyVersionGlobalsUsage < Cop
         MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
 
-        def_node_matcher :ruby_version?, '(const nil? :RUBY_VERSION)'
+        def_node_matcher :ruby_version?, '(const {cbase nil?} :RUBY_VERSION)'
 
         def_node_search :gem_specification?, <<~PATTERN
           (block

data/lib/rubocop/cop/generator.rb

@@ -54,7 +54,7 @@ module RuboCop
               #   # good
               #   good_foo_method(args)
               #
-              class %<cop_name>s < Cop
+              class %<cop_name>s < Base
                 # TODO: Implement the cop in here.
                 #
                 # In many cases, you can use a node matcher for matching node pattern.

data/lib/rubocop/cop/internal_affairs/node_type_predicate.rb

@@ -13,7 +13,9 @@ module RuboCop
       #   # good
       #   node.send_type?
       #
-      class NodeTypePredicate < Cop
+      class NodeTypePredicate < Base
+        extend AutoCorrector
+
         MSG = 'Use `#%<type>s_type?` to check node type.'
 
         def_node_matcher :node_type_check, <<~PATTERN
@@ -21,21 +23,16 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          node_type_check(node) do |_receiver, node_type|
+          node_type_check(node) do |receiver, node_type|
             return unless Parser::Meta::NODE_TYPES.include?(node_type)
 
-            add_offense(node, message: format(MSG, type: node_type))
-          end
-        end
-
-        def autocorrect(node)
-          receiver, node_type = node_type_check(node)
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            receiver.loc.expression.end_pos + 1,
-                                            node.loc.expression.end_pos)
-
-          lambda do |corrector|
-            corrector.replace(range, "#{node_type}_type?")
+            message = format(MSG, type: node_type)
+            add_offense(node, message: message) do |corrector|
+              range = node.loc.expression.with(
+                begin_pos: receiver.loc.expression.end_pos + 1
+              )
+              corrector.replace(range, "#{node_type}_type?")
+            end
           end
         end
       end

data/lib/rubocop/cop/layout/case_indentation.rb

@@ -67,10 +67,11 @@ module RuboCop
       #   else
       #     y / 3
       #   end
-      class CaseIndentation < Cop
+      class CaseIndentation < Base
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Indent `when` %<depth>s `%<base>s`.'
 
@@ -82,16 +83,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          whitespace = whitespace_range(node)
-
-          return false unless whitespace.source.strip.empty?
-
-          lambda do |corrector|
-            corrector.replace(whitespace, replacement(node))
-          end
-        end
-
         private
 
         def check_when(when_node)
@@ -114,22 +105,30 @@ module RuboCop
         end
 
         def incorrect_style(when_node)
+          add_offense(when_node.loc.keyword) do |corrector|
+            detect_incorrect_style(when_node)
+
+            whitespace = whitespace_range(when_node)
+
+            corrector.replace(whitespace, replacement(when_node)) if whitespace.source.strip.empty?
+          end
+        end
+
+        def detect_incorrect_style(when_node)
           when_column = when_node.loc.keyword.column
           base_column = base_column(when_node.parent, alternative_style)
 
-          add_offense(when_node, location: :keyword, message: message(style)) do
-            if when_column == base_column
-              opposite_style_detected
-            else
-              unrecognized_style_detected
-            end
+          if when_column == base_column
+            opposite_style_detected
+          else
+            unrecognized_style_detected
           end
         end
 
-        def message(base)
+        def find_message(*)
           depth = indent_one_step? ? 'one step more than' : 'as deep as'
 
-          format(MSG, depth: depth, base: base)
+          format(MSG, depth: depth, base: style)
         end
 
         def base_column(case_node, base)

data/lib/rubocop/cop/layout/empty_lines_around_attribute_accessor.rb

@@ -62,6 +62,7 @@ module RuboCop
       #
       class EmptyLinesAroundAttributeAccessor < Cop
         include RangeHelp
+        include AllowedMethods
 
         MSG = 'Add an empty line after attribute accessor.'
 
@@ -114,14 +115,6 @@ module RuboCop
         def allow_alias_syntax?
           cop_config.fetch('AllowAliasSyntax', true)
         end
-
-        def allowed_method?(name)
-          allowed_methods.include?(name.to_s)
-        end
-
-        def allowed_methods
-          cop_config.fetch('AllowedMethods', [])
-        end
       end
     end
   end

data/lib/rubocop/cop/layout/first_argument_indentation.rb

@@ -241,6 +241,10 @@ module RuboCop
             .select { |c| begins_its_line?(c.loc.expression) }
             .map { |c| c.loc.line }
         end
+
+        def on_new_investigation
+          @comment_lines = nil
+        end
       end
     end
   end

data/lib/rubocop/cop/layout/hash_alignment.rb

@@ -219,8 +219,7 @@ module RuboCop
           correct_node(node, delta)
         end
 
-        attr_accessor :offences_by
-        attr_accessor :column_deltas
+        attr_accessor :offences_by, :column_deltas
 
         private
 

data/lib/rubocop/cop/layout/multiline_block_layout.rb

@@ -105,7 +105,6 @@ module RuboCop
         def add_offense_for_expression(node, expr, msg)
           expression = expr.source_range
           range = range_between(expression.begin_pos, expression.end_pos)
-
           add_offense(node, location: range, message: msg)
         end
 

data/lib/rubocop/cop/layout/space_around_block_parameters.rb

@@ -24,9 +24,10 @@ module RuboCop
       #   # good
       #   {}.each { | x, y | puts x }
       #   ->( x, y ) { puts x }
-      class SpaceAroundBlockParameters < Cop
+      class SpaceAroundBlockParameters < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         def on_block(node)
           arguments = node.arguments
@@ -38,23 +39,6 @@ module RuboCop
           check_each_arg(arguments)
         end
 
-        # @param target [RuboCop::AST::Node,Parser::Source::Range]
-        def autocorrect(target)
-          lambda do |corrector|
-            if target.is_a?(RuboCop::AST::Node)
-              if target.parent.children.first == target
-                corrector.insert_before(target, ' ')
-              else
-                corrector.insert_after(target, ' ')
-              end
-            elsif /^\s+$/.match?(target.source)
-              corrector.remove(target)
-            else
-              corrector.insert_after(target, ' ')
-            end
-          end
-        end
-
         private
 
         def pipes(arguments)
@@ -97,7 +81,7 @@ module RuboCop
 
           check_no_space(opening_pipe.end_pos, first.begin_pos,
                          'Space before first')
-          check_no_space(last_end_pos_inside_pipes(last.end_pos),
+          check_no_space(last_end_pos_inside_pipes(last),
                          closing_pipe.begin_pos, 'Space after last')
         end
 
@@ -118,7 +102,7 @@ module RuboCop
 
         def check_closing_pipe_space(args, closing_pipe)
           last         = args.last.source_range
-          last_end_pos = last_end_pos_inside_pipes(last.end_pos)
+          last_end_pos = last_end_pos_inside_pipes(last)
 
           check_space(last_end_pos, closing_pipe.begin_pos, last,
                       'after last block parameter')
@@ -126,8 +110,9 @@ module RuboCop
                          'Extra space after last')
         end
 
-        def last_end_pos_inside_pipes(pos)
-          processed_source.buffer.source[pos] == ',' ? pos + 1 : pos
+        def last_end_pos_inside_pipes(range)
+          pos = range.end_pos
+          range.source_buffer.source[pos] == ',' ? pos + 1 : pos
         end
 
         def check_each_arg(args)
@@ -151,7 +136,14 @@ module RuboCop
           return if space_begin_pos != space_end_pos
 
           target = node || range
-          add_offense(target, location: range, message: "Space #{msg} missing.")
+          message = "Space #{msg} missing."
+          add_offense(target, message: message) do |corrector|
+            if node
+              corrector.insert_before(node, ' ')
+            else
+              corrector.insert_after(target, ' ')
+            end
+          end
         end
 
         def check_no_space(space_begin_pos, space_end_pos, msg)
@@ -160,8 +152,10 @@ module RuboCop
           range = range_between(space_begin_pos, space_end_pos)
           return if range.source.include?("\n")
 
-          add_offense(range, location: range,
-                             message: "#{msg} block parameter detected.")
+          message = "#{msg} block parameter detected."
+          add_offense(range, message: message) do |corrector|
+            corrector.remove(range)
+          end
         end
       end
     end