rubocop 0.93.1 → 1.79.2

data/lib/rubocop/cop/commissioner.rb

@@ -7,7 +7,7 @@ module RuboCop
     class Commissioner
       include RuboCop::AST::Traversal
 
-      RESTRICTED_CALLBACKS = %i[on_send on_csend].freeze
+      RESTRICTED_CALLBACKS = %i[on_send on_csend after_send after_csend].freeze
       private_constant :RESTRICTED_CALLBACKS
 
       # How a Commissioner returns the results of the investigation
@@ -45,8 +45,7 @@ module RuboCop
         @cops = cops
         @forces = forces
         @options = options
-        @callbacks = Hash.new { |h, k| h[k] = cops_callbacks_for(k) }
-        @restricted_map = {}
+        initialize_callbacks
 
         reset
       end
@@ -61,27 +60,30 @@ module RuboCop
         method_name = :"on_#{node_type}"
         next unless method_defined?(method_name)
 
-        if RESTRICTED_CALLBACKS.include?(method_name)
-          trigger_restricted = "trigger_restricted_cops(:on_#{node_type}, node)"
-        end
+        # Hacky: Comment-out code as needed
+        r = '#' unless RESTRICTED_CALLBACKS.include?(method_name) # has Restricted?
+        c = '#' if NO_CHILD_NODES.include?(node_type) # has Children?
 
         class_eval(<<~RUBY, __FILE__, __LINE__ + 1)
-          def on_#{node_type}(node)
-            trigger_responding_cops(:on_#{node_type}, node)
-            #{trigger_restricted}
-            #{'super(node)' unless NO_CHILD_NODES.include?(node_type)}
-          end
+                  def on_#{node_type}(node)                               # def on_send(node)
+                    trigger_responding_cops(:on_#{node_type}, node)       #   trigger_responding_cops(:on_send, node)
+              #{r}  trigger_restricted_cops(:on_#{node_type}, node)       #   trigger_restricted_cops(:on_send, node)
+          #{c}      super(node)                                           #   super(node)
+          #{c}      trigger_responding_cops(:after_#{node_type}, node)    #   trigger_responding_cops(:after_send, node)
+          #{c}#{r}  trigger_restricted_cops(:after_#{node_type}, node)    #   trigger_restricted_cops(:after_send, node)
+                  end                                                     # end
         RUBY
       end
 
       # @return [InvestigationReport]
-      def investigate(processed_source)
+      def investigate(processed_source, offset: 0, original: processed_source)
         reset
 
-        @cops.each { |cop| cop.send :begin_investigation, processed_source }
+        begin_investigation(processed_source, offset: offset, original: original)
         if processed_source.valid_syntax?
           invoke(:on_new_investigation, @cops)
-          invoke(:investigate, @forces, processed_source)
+          invoke_with_argument(:investigate, @forces, processed_source)
+
           walk(processed_source.ast) unless @cops.empty?
           invoke(:on_investigation_end, @cops)
         else
@@ -93,10 +95,16 @@ module RuboCop
 
       private
 
+      def begin_investigation(processed_source, offset:, original:)
+        @cops.each do |cop|
+          cop.begin_investigation(processed_source, offset: offset, original: original)
+        end
+      end
+
       def trigger_responding_cops(callback, node)
-        @callbacks[callback].each do |cop|
+        @callbacks[callback]&.each do |cop|
           with_cop_error_handling(cop, node) do
-            cop.send(callback, node)
+            cop.public_send(callback, node)
           end
         end
       end
@@ -105,44 +113,55 @@ module RuboCop
         @errors = []
       end
 
-      def cops_callbacks_for(callback)
-        callbacks = @cops.select do |cop|
-          cop.respond_to?(callback)
-        end
-        if RESTRICTED_CALLBACKS.include?(callback)
-          @restricted_map[callback] = restricted_map(callbacks)
+      def initialize_callbacks
+        @callbacks = build_callbacks(@cops)
+        @restricted_map = restrict_callbacks(@callbacks)
+      end
+
+      def build_callbacks(cops)
+        callbacks = {}
+        cops.each do |cop|
+          cop.callbacks_needed.each do |callback|
+            (callbacks[callback] ||= []) << cop
+          end
         end
         callbacks
       end
 
+      def restrict_callbacks(callbacks)
+        restricted = {}
+        RESTRICTED_CALLBACKS.each do |callback|
+          restricted[callback] = restricted_map(callbacks[callback])
+        end
+        restricted
+      end
+
       def trigger_restricted_cops(event, node)
         name = node.method_name
-        @restricted_map.fetch(event)[name]&.each do |cop|
+        @restricted_map[event][name]&.each do |cop|
           with_cop_error_handling(cop, node) do
-            cop.send(event, node)
+            cop.public_send(event, node)
           end
         end
       end
 
-      # Note: mutates `callbacks` in place
+      # NOTE: mutates `callbacks` in place
       def restricted_map(callbacks)
         map = {}
-        callbacks.select! do |cop|
+        callbacks&.select! do |cop|
           restrictions = cop.class.send :restrict_on_send
-          restrictions.each do |name|
-            (map[name] ||= []) << cop
-          end
+          restrictions.each { |name| (map[name] ||= []) << cop }
           restrictions.empty?
         end
         map
       end
 
-      def invoke(callback, cops, *args)
-        cops.each do |cop|
-          with_cop_error_handling(cop) do
-            cop.send(callback, *args)
-          end
-        end
+      def invoke(callback, cops)
+        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback) } }
+      end
+
+      def invoke_with_argument(callback, cops, arg)
+        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback, arg) } }
       end
 
       # Allow blind rescues here, since we're absorbing and packaging or
@@ -151,9 +170,11 @@ module RuboCop
       def with_cop_error_handling(cop, node = nil)
         yield
       rescue StandardError => e
-        raise e if @options[:raise_error]
+        raise e if @options[:raise_error] # For internal testing
 
         err = ErrorWithAnalyzedFileLocation.new(cause: e, node: node, cop: cop)
+        raise err if @options[:raise_cop_error] # From user-input option
+
         @errors << err
       end
     end

data/lib/rubocop/cop/cop.rb

@@ -7,7 +7,7 @@ module RuboCop
   module Cop
     # @deprecated Use Cop::Base instead
     # Legacy scaffold for Cops.
-    # See https://docs.rubocop.org/rubocop/cop_api_v1_changelog.html
+    # See https://docs.rubocop.org/rubocop/v1_upgrade_notes.html
     class Cop < Base
       attr_reader :offenses
 
@@ -18,16 +18,67 @@ module RuboCop
         def call(corrector)
           lambda.call(corrector)
         rescue StandardError => e
-          raise ErrorWithAnalyzedFileLocation.new(
-            cause: e, node: node, cop: cop
-          )
+          raise ErrorWithAnalyzedFileLocation.new(cause: e, node: node, cop: cop)
         end
       end
 
+      def self.inherited(_subclass)
+        super
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          Inheriting from `RuboCop::Cop::Cop` is deprecated. Use `RuboCop::Cop::Base` instead.
+          For more information, see https://docs.rubocop.org/rubocop/v1_upgrade_notes.html.
+        WARNING
+      end
+
+      def self.support_autocorrect?
+        method_defined?(:autocorrect)
+      end
+
+      def self.joining_forces
+        return unless method_defined?(:join_force?)
+
+        cop = new
+        Force.all.select { |force_class| cop.join_force?(force_class) }
+      end
+
+      ### Deprecated registry access
+
+      # @deprecated Use Registry.global
+      def self.registry
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.registry` is deprecated. Use `Registry.global` instead.
+        WARNING
+
+        Registry.global
+      end
+
+      # @deprecated Use Registry.all
+      def self.all
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.all` is deprecated. Use `Registry.all` instead.
+        WARNING
+
+        Registry.all
+      end
+
+      # @deprecated Use Registry.qualified_cop_name
+      def self.qualified_cop_name(name, origin)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop.qualified_cop_name` is deprecated. Use `Registry.qualified_cop_name` instead.
+        WARNING
+
+        Registry.qualified_cop_name(name, origin)
+      end
+
       def add_offense(node_or_range, location: :expression, message: nil, severity: nil, &block)
         @v0_argument = node_or_range
         range = find_location(node_or_range, location)
-        if block.nil? && !autocorrect?
+
+        # Since this range may be generated from Ruby code embedded in some
+        # template file, we convert it to location info in the original file.
+        range = range_for_original(range)
+
+        if block.nil? && !self.class.support_autocorrect?
           super(range, message: message, severity: severity)
         else
           super(range, message: message, severity: severity) do |corrector|
@@ -43,26 +94,19 @@ module RuboCop
 
       # @deprecated Use class method
       def support_autocorrect?
-        # warn 'deprecated, use cop.class.support_autocorrect?' TODO
-        self.class.support_autocorrect?
-      end
-
-      def self.support_autocorrect?
-        method_defined?(:autocorrect)
-      end
-
-      def self.joining_forces
-        return unless method_defined?(:join_force?)
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `support_autocorrect?` is deprecated. Use `cop.class.support_autocorrect?`.
+        WARNING
 
-        cop = new
-        Force.all.select do |force_class|
-          cop.join_force?(force_class)
-        end
+        self.class.support_autocorrect?
       end
 
       # @deprecated
       def corrections
-        # warn 'Cop#corrections is deprecated' TODO
+        warn Rainbow(<<~WARNING).yellow, uplevel: 1
+          `Cop#corrections` is deprecated.
+        WARNING
+
         return [] unless @last_corrector
 
         Legacy::CorrectionsProxy.new(@last_corrector)
@@ -80,37 +124,21 @@ module RuboCop
         super
       end
 
-      ### Deprecated registry access
-
-      # @deprecated Use Registry.global
-      def self.registry
-        Registry.global
-      end
-
-      # @deprecated Use Registry.all
-      def self.all
-        Registry.all
-      end
-
-      # @deprecated Use Registry.qualified_cop_name
-      def self.qualified_cop_name(name, origin)
-        Registry.qualified_cop_name(name, origin)
-      end
+      # Called before any investigation
+      # @api private
+      def begin_investigation(processed_source, offset: 0, original: processed_source)
+        super
+        @offenses = current_offenses
+        @last_corrector = @current_corrector
 
-      # @deprecated
-      # Open issue if there's a valid use case to include this in Base
-      def parse(source, path = nil)
-        ProcessedSource.new(source, target_ruby_version, path)
+        # We need to keep track of the original source and offset,
+        # because `processed_source` here may be an embedded code in it.
+        @current_offset = offset
+        @current_original = original
       end
 
       private
 
-      def begin_investigation(processed_source)
-        super
-        @offenses = @current_offenses
-        @last_corrector = @current_corrector
-      end
-
       # Override Base
       def callback_argument(_range)
         @v0_argument
@@ -130,20 +158,16 @@ module RuboCop
 
         return unless lambda
 
-        suppress_clobbering do
-          lambda.call(corrector)
-        end
+        suppress_clobbering { lambda.call(corrector) }
       end
 
       def correction_lambda
-        return unless correction_strategy == :attempt_correction && support_autocorrect?
+        return unless self.class.support_autocorrect?
 
-        dedup_on_node(@v0_argument) do
-          autocorrect(@v0_argument)
-        end
+        dedupe_on_node(@v0_argument) { autocorrect(@v0_argument) }
       end
 
-      def dedup_on_node(node)
+      def dedupe_on_node(node)
         @corrected_nodes ||= {}.compare_by_identity
         yield unless @corrected_nodes.key?(node)
       ensure
@@ -155,6 +179,14 @@ module RuboCop
       rescue ::Parser::ClobberingError
         # ignore Clobbering errors
       end
+
+      def range_for_original(range)
+        ::Parser::Source::Range.new(
+          @current_original.buffer,
+          range.begin_pos + @current_offset,
+          range.end_pos + @current_offset
+        )
+      end
     end
   end
 end

data/lib/rubocop/cop/corrector.rb

@@ -9,6 +9,22 @@ module RuboCop
     # The nodes modified by the corrections should be part of the
     # AST of the source_buffer.
     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`]
       #
@@ -23,21 +39,18 @@ module RuboCop
         )
 
         # Don't print warnings to stderr if corrections conflict with each other
-        diagnostics.consumer = ->(diagnostic) {}
+        diagnostics.consumer = NOOP_CONSUMER
       end
 
       alias rewrite process # Legacy
 
       # Removes `size` characters prior to the source range.
       #
-      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
       # @param [Integer] size
       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
-        )
+        to_remove = range.with(begin_pos: range.begin_pos - size, end_pos: range.begin_pos)
         remove(to_remove)
       end
 
@@ -45,7 +58,7 @@ module RuboCop
       # If `size` is greater than the size of `range`, the removed region can
       # overrun the end of `range`.
       #
-      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
       # @param [Integer] size
       def remove_leading(node_or_range, size)
         range = to_range(node_or_range)
@@ -57,7 +70,7 @@ module RuboCop
       # If `size` is greater than the size of `range`, the removed region can
       # overrun the beginning of `range`.
       #
-      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      # @param [Parser::Source::Range, RuboCop::AST::Node] range or node
       # @param [Integer] size
       def remove_trailing(node_or_range, size)
         range = to_range(node_or_range)
@@ -65,18 +78,24 @@ module RuboCop
         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)
+      # 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)
 
-        unless source.is_a? ::Parser::Source::Buffer
-          raise TypeError, 'Expected argument to lead to a Parser::Source::Buffer ' \
-                           "but got #{source.inspect}"
+        if range1.end_pos == range2.begin_pos
+          insert_before(range1, range2.source)
+          remove(range2)
+        elsif range2.end_pos == range1.begin_pos
+          insert_before(range2, range1.source)
+          remove(range1)
+        else
+          replace(range1, range2.source)
+          replace(range2, range1.source)
         end
-
-        source
       end
 
       private
@@ -85,13 +104,13 @@ module RuboCop
       def to_range(node_or_range)
         range = case node_or_range
                 when ::RuboCop::AST::Node, ::Parser::Source::Comment
-                  node_or_range.loc.expression
+                  node_or_range.source_range
                 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}"
+                        "RuboCop::AST::Node, got #{node_or_range.class}"
                 end
         validate_buffer(range.source_buffer)
         range
@@ -110,8 +129,8 @@ module RuboCop
                 "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,20 +12,17 @@ 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
+          expr = node.respond_to?(:loc) ? node.source_range : 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
+          each_line(expr) do |line_begin_pos|
+            autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges)
           end
         end
 
@@ -50,15 +47,14 @@ module RuboCop
           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)
+            corrector.remove(range)
           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
+          node.each_node(:str, :dstr, :xstr).filter_map { |n| inside_string_range(n) }
         end
 
         def inside_string_range(node)
@@ -79,21 +75,19 @@ 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)
           processed_source.comments.select(&:document?).any? do |c|
-            within?(c.loc.expression, expr)
+            within?(c.source_range, 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?(' ')
+          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)
@@ -102,17 +96,6 @@ module RuboCop
           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|

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

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    # This class does condition auto-correction
+    # This class does condition autocorrection
     class ConditionCorrector
       class << self
         def correct_negative_condition(corrector, node)

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,24 +29,19 @@ 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
 
       def offending_range
+        begin_range = block_node.source_range.begin
+
         if block_node.arguments?
-          replacement_range(argument_node.loc.expression.end_pos)
+          begin_range.join(argument_node.source_range.end)
         else
-          replacement_range(block_node.loc.begin.end_pos)
+          begin_range.join(block_node.loc.begin.end)
         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

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    # This class does empty line auto-correction
+    # This class does empty line autocorrection
     class EmptyLineCorrector
       class << self
         def correct(corrector, node)