rubocop 0.82.0 → 1.18.4

data/lib/rubocop/cop/commissioner.rb

@@ -7,15 +7,47 @@ module RuboCop
     class Commissioner
       include RuboCop::AST::Traversal
 
+      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
+      # as a list of Cop::InvestigationReport and any errors caught
+      # during the investigation.
+      # Immutable
+      # Consider creation API private
+      InvestigationReport = Struct.new(:processed_source, :cop_reports, :errors) do
+        def cops
+          @cops ||= cop_reports.map(&:cop)
+        end
+
+        def offenses_per_cop
+          @offenses_per_cop ||= cop_reports.map(&:offenses)
+        end
+
+        def correctors
+          @correctors ||= cop_reports.map(&:corrector)
+        end
+
+        def offenses
+          @offenses ||= offenses_per_cop.flatten(1)
+        end
+
+        def merge(investigation)
+          InvestigationReport.new(processed_source,
+                                  cop_reports + investigation.cop_reports,
+                                  errors + investigation.errors)
+        end
+      end
+
       attr_reader :errors
 
       def initialize(cops, forces = [], options = {})
         @cops = cops
         @forces = forces
         @options = options
-        @callbacks = {}
+        initialize_callbacks
 
-        reset_errors
+        reset
       end
 
       # Create methods like :on_send, :on_super, etc. They will be called
@@ -28,105 +60,97 @@ module RuboCop
         method_name = :"on_#{node_type}"
         next unless method_defined?(method_name)
 
-        define_method(method_name) do |node|
-          trigger_responding_cops(method_name, node)
-          super(node) unless NO_CHILD_NODES.include?(node_type)
-        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)                               # 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)
-        reset_errors
-        remove_irrelevant_cops(processed_source.file_path)
-        reset_callbacks
-        prepare(processed_source)
-        invoke_custom_processing(@cops, processed_source)
-        invoke_custom_processing(@forces, processed_source)
-        walk(processed_source.ast) unless processed_source.blank?
-        invoke_custom_post_walk_processing(@cops, processed_source)
-        @cops.flat_map(&:offenses)
+        reset
+
+        @cops.each { |cop| cop.send :begin_investigation, processed_source }
+        if processed_source.valid_syntax?
+          invoke(:on_new_investigation, @cops)
+          invoke(:investigate, @forces, processed_source)
+          walk(processed_source.ast) unless @cops.empty?
+          invoke(:on_investigation_end, @cops)
+        else
+          invoke(:on_other_file, @cops)
+        end
+        reports = @cops.map { |cop| cop.send(:complete_investigation) }
+        InvestigationReport.new(processed_source, reports, @errors)
       end
 
       private
 
       def trigger_responding_cops(callback, node)
-        @callbacks[callback] ||= @cops.select do |cop|
-          cop.respond_to?(callback)
-        end
-        @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
 
-      def reset_errors
+      def reset
         @errors = []
       end
 
-      def remove_irrelevant_cops(filename)
-        @cops.reject! do |cop|
-          cop.excluded_file?(filename) ||
-            !support_target_ruby_version?(cop) ||
-            !support_target_rails_version?(cop)
-        end
+      def initialize_callbacks
+        @callbacks = build_callbacks(@cops)
+        @restricted_map = restrict_callbacks(@callbacks)
       end
 
-      def support_target_ruby_version?(cop)
-        return true unless cop.class.respond_to?(:support_target_ruby_version?)
-
-        cop.class.support_target_ruby_version?(cop.target_ruby_version)
-      end
-
-      def support_target_rails_version?(cop)
-        return true unless cop.class.respond_to?(:support_target_rails_version?)
-
-        cop.class.support_target_rails_version?(cop.target_rails_version)
-      end
-
-      def reset_callbacks
-        @callbacks.clear
+      def build_callbacks(cops)
+        callbacks = {}
+        cops.each do |cop|
+          cop.callbacks_needed.each do |callback|
+            (callbacks[callback] ||= []) << cop
+          end
+        end
+        callbacks
       end
 
-      # TODO: Bad design.
-      def prepare(processed_source)
-        @cops.each { |cop| cop.processed_source = processed_source }
+      def restrict_callbacks(callbacks)
+        restricted = {}
+        RESTRICTED_CALLBACKS.each do |callback|
+          restricted[callback] = restricted_map(callbacks[callback])
+        end
+        restricted
       end
 
-      # There are cops/forces that require their own custom processing.
-      # If they define the #investigate method, all input parameters passed
-      # to the commissioner will be passed to the cop too in order to do
-      # its own processing.
-      #
-      # These custom processors are invoked before the AST traversal,
-      # so they can build initial state that is later used by callbacks
-      # during the AST traversal.
-      def invoke_custom_processing(cops_or_forces, processed_source)
-        cops_or_forces.each do |cop|
-          next unless cop.respond_to?(:investigate)
-
-          with_cop_error_handling(cop) do
-            cop.investigate(processed_source)
+      def trigger_restricted_cops(event, node)
+        name = node.method_name
+        @restricted_map[event][name]&.each do |cop|
+          with_cop_error_handling(cop, node) do
+            cop.public_send(event, node)
           end
         end
       end
 
-      # There are cops that require their own custom processing **after**
-      # the AST traversal. By performing the walk before invoking these
-      # custom processors, we allow these cops to build their own
-      # state during the primary AST traversal instead of performing their
-      # own AST traversals. Minimizing the number of walks is more efficient.
-      #
-      # If they define the #investigate_post_walk method, all input parameters
-      # passed to the commissioner will be passed to the cop too in order to do
-      # its own processing.
-      def invoke_custom_post_walk_processing(cops, processed_source)
-        cops.each do |cop|
-          next unless cop.respond_to?(:investigate_post_walk)
-
-          with_cop_error_handling(cop) do
-            cop.investigate_post_walk(processed_source)
-          end
+      # NOTE: mutates `callbacks` in place
+      def restricted_map(callbacks)
+        map = {}
+        callbacks&.select! do |cop|
+          restrictions = cop.class.send :restrict_on_send
+          restrictions.each { |name| (map[name] ||= []) << cop }
+          restrictions.empty?
         end
+        map
+      end
+
+      def invoke(callback, cops, *args)
+        cops.each { |cop| with_cop_error_handling(cop) { cop.send(callback, *args) } }
       end
 
       # Allow blind rescues here, since we're absorbing and packaging or

data/lib/rubocop/cop/cop.rb

@@ -1,140 +1,37 @@
 # frozen_string_literal: true
 
 require 'uri'
+require_relative 'legacy/corrections_proxy'
 
 module RuboCop
   module Cop
-    # A scaffold for concrete cops.
-    #
-    # The Cop class is meant to be extended.
-    #
-    # Cops track offenses and can autocorrect them on the fly.
-    #
-    # A commissioner object is responsible for traversing the AST and invoking
-    # the specific callbacks on each cop.
-    # If a cop needs to do its own processing of the AST or depends on
-    # something else, it should define the `#investigate` method and do
-    # the processing there.
-    #
-    # @example
-    #
-    #   class CustomCop < Cop
-    #     def investigate(processed_source)
-    #       # Do custom processing
-    #     end
-    #   end
-    class Cop
-      extend RuboCop::AST::Sexp
-      extend NodePattern::Macros
-      include RuboCop::AST::Sexp
-      include Util
-      include IgnoredNode
-      include AutocorrectLogic
+    # @deprecated Use Cop::Base instead
+    # Legacy scaffold for Cops.
+    # See https://docs.rubocop.org/rubocop/cop_api_v1_changelog.html
+    class Cop < Base
+      attr_reader :offenses
 
+      exclude_from_registry
+
+      # @deprecated
       Correction = Struct.new(:lambda, :node, :cop) do
         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
 
-      attr_reader :config, :offenses, :corrections
-      attr_accessor :processed_source # TODO: Bad design.
-
-      @registry = Registry.new
-
-      class << self
-        attr_reader :registry
-      end
-
-      def self.all
-        registry.without_department(:Test).cops
-      end
-
-      def self.qualified_cop_name(name, origin)
-        registry.qualified_cop_name(name, origin)
-      end
-
-      def self.inherited(subclass)
-        registry.enlist(subclass)
-      end
-
-      def self.badge
-        @badge ||= Badge.for(name)
-      end
-
-      def self.cop_name
-        badge.to_s
-      end
-
-      def self.department
-        badge.department
-      end
-
-      def self.lint?
-        department == :Lint
-      end
-
-      # Returns true if the cop name or the cop namespace matches any of the
-      # given names.
-      def self.match?(given_names)
-        return false unless given_names
-
-        given_names.include?(cop_name) ||
-          given_names.include?(department.to_s)
-      end
-
-      # List of cops that should not try to autocorrect at the same
-      # time as this cop
-      #
-      # @return [Array<RuboCop::Cop::Cop>]
-      #
-      # @api public
-      def self.autocorrect_incompatible_with
-        []
-      end
-
-      def initialize(config = nil, options = nil)
-        @config = config || Config.new
-        @options = options || { debug: false }
-
-        @offenses = []
-        @corrections = []
-        @corrected_nodes = {}
-        @corrected_nodes.compare_by_identity
-        @processed_source = nil
-      end
-
-      def join_force?(_force_class)
-        false
-      end
-
-      def cop_config
-        # Use department configuration as basis, but let individual cop
-        # configuration override.
-        @cop_config ||= @config.for_cop(self.class.department.to_s)
-                               .merge(@config.for_cop(self))
-      end
-
-      def message(_node = nil)
-        self.class::MSG
-      end
-
-      def add_offense(node, location: :expression, message: nil, severity: nil)
-        loc = find_location(node, location)
-
-        return if duplicate_location?(loc)
-
-        severity = find_severity(node, severity)
-        message = find_message(node, message)
-
-        status = enabled_line?(loc.line) ? correct(node) : :disabled
-
-        @offenses << Offense.new(severity, loc, message, name, status)
-        yield if block_given? && status != :disabled
+      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? && !support_autocorrect?
+          super(range, message: message, severity: severity)
+        else
+          super(range, message: message, severity: severity) do |corrector|
+            emulate_v0_callsequence(corrector, &block)
+          end
+        end
       end
 
       def find_location(node, loc)
@@ -142,154 +39,107 @@ module RuboCop
         loc.is_a?(Symbol) ? node.loc.public_send(loc) : loc
       end
 
-      def duplicate_location?(location)
-        @offenses.any? { |o| o.location == location }
-      end
-
-      def correct(node)
-        reason = reason_to_not_correct(node)
-        return reason if reason
-
-        @corrected_nodes[node] = true
-        if support_autocorrect?
-          correction = autocorrect(node)
-          return :uncorrected unless correction
-
-          @corrections << Correction.new(correction, node, self)
-          :corrected
-        elsif disable_uncorrectable?
-          disable_uncorrectable(node)
-          :corrected_with_todo
-        end
-      end
-
-      def reason_to_not_correct(node)
-        return :unsupported unless correctable?
-        return :uncorrected unless autocorrect?
-        return :already_corrected if @corrected_nodes.key?(node)
-
-        nil
+      # @deprecated Use class method
+      def support_autocorrect?
+        # warn 'deprecated, use cop.class.support_autocorrect?' TODO
+        self.class.support_autocorrect?
       end
 
-      def disable_uncorrectable(node)
-        return unless node
-
-        @disabled_lines ||= {}
-        line = node.location.line
-        return if @disabled_lines.key?(line)
-
-        @disabled_lines[line] = true
-        @corrections << Correction.new(disable_offense(node), node, self)
+      def self.support_autocorrect?
+        method_defined?(:autocorrect)
       end
 
-      def config_to_allow_offenses
-        Formatter::DisabledConfigFormatter
-          .config_to_allow_offenses[cop_name] ||= {}
-      end
+      def self.joining_forces
+        return unless method_defined?(:join_force?)
 
-      def config_to_allow_offenses=(hash)
-        Formatter::DisabledConfigFormatter.config_to_allow_offenses[cop_name] =
-          hash
+        cop = new
+        Force.all.select { |force_class| cop.join_force?(force_class) }
       end
 
-      def target_ruby_version
-        @config.target_ruby_version
-      end
+      # @deprecated
+      def corrections
+        # warn 'Cop#corrections is deprecated' TODO
+        return [] unless @last_corrector
 
-      def target_rails_version
-        @config.target_rails_version
+        Legacy::CorrectionsProxy.new(@last_corrector)
       end
 
-      def parse(source, path = nil)
-        ProcessedSource.new(source, target_ruby_version, path)
+      # Called before all on_... have been called
+      def on_new_investigation
+        investigate(processed_source) if respond_to?(:investigate)
+        super
       end
 
-      def cop_name
-        @cop_name ||= self.class.cop_name
+      # Called after all on_... have been called
+      def on_investigation_end
+        investigate_post_walk(processed_source) if respond_to?(:investigate_post_walk)
+        super
       end
 
-      alias name cop_name
+      ### Deprecated registry access
 
-      def relevant_file?(file)
-        file_name_matches_any?(file, 'Include', true) &&
-          !file_name_matches_any?(file, 'Exclude', false)
+      # @deprecated Use Registry.global
+      def self.registry
+        Registry.global
       end
 
-      def excluded_file?(file)
-        !relevant_file?(file)
+      # @deprecated Use Registry.all
+      def self.all
+        Registry.all
       end
 
-      # This method should be overridden when a cop's behavior depends
-      # on state that lives outside of these locations:
-      #
-      #   (1) the file under inspection
-      #   (2) the cop's source code
-      #   (3) the config (eg a .rubocop.yml file)
-      #
-      # For example, some cops may want to look at other parts of
-      # the codebase being inspected to find violations. A cop may
-      # use the presence or absence of file `foo.rb` to determine
-      # whether a certain violation exists in `bar.rb`.
-      #
-      # Overriding this method allows the cop to indicate to RuboCop's
-      # ResultCache system when those external dependencies change,
-      # ie when the ResultCache should be invalidated.
-      def external_dependency_checksum
-        nil
+      # @deprecated Use Registry.qualified_cop_name
+      def self.qualified_cop_name(name, origin)
+        Registry.qualified_cop_name(name, origin)
       end
 
       private
 
-      def find_message(node, message)
-        annotate(message || message(node))
+      def begin_investigation(processed_source)
+        super
+        @offenses = @current_offenses
+        @last_corrector = @current_corrector
       end
 
-      def annotate(message)
-        RuboCop::Cop::MessageAnnotator.new(
-          config, cop_name, cop_config, @options
-        ).annotate(message)
+      # Override Base
+      def callback_argument(_range)
+        @v0_argument
       end
 
-      def file_name_matches_any?(file, parameter, default_result)
-        patterns = cop_config[parameter]
-        return default_result unless patterns
-
-        path = nil
-        patterns.any? do |pattern|
-          # Try to match the absolute path, as Exclude properties are absolute.
-          next true if match_path?(pattern, file)
+      def apply_correction(corrector)
+        suppress_clobbering { super }
+      end
 
-          # Try with relative path.
-          path ||= config.path_relative_to_config(file)
-          match_path?(pattern, path)
+      # Just for legacy
+      def emulate_v0_callsequence(corrector)
+        lambda = correction_lambda
+        yield corrector if block_given?
+        unless corrector.empty?
+          raise 'Your cop must inherit from Cop::Base and extend AutoCorrector'
         end
-      end
 
-      def enabled_line?(line_number)
-        return true if @options[:ignore_disable_comments] || !@processed_source
+        return unless lambda
 
-        @processed_source.comment_config.cop_enabled_at_line?(self, line_number)
+        suppress_clobbering { lambda.call(corrector) }
       end
 
-      def find_severity(_node, severity)
-        custom_severity || severity || default_severity
-      end
+      def correction_lambda
+        return unless support_autocorrect?
 
-      def default_severity
-        self.class.lint? ? :warning : :convention
+        dedup_on_node(@v0_argument) { autocorrect(@v0_argument) }
       end
 
-      def custom_severity
-        severity = cop_config['Severity']
-        return unless severity
+      def dedup_on_node(node)
+        @corrected_nodes ||= {}.compare_by_identity
+        yield unless @corrected_nodes.key?(node)
+      ensure
+        @corrected_nodes[node] = true
+      end
 
-        if Severity::NAMES.include?(severity.to_sym)
-          severity.to_sym
-        else
-          message = "Warning: Invalid severity '#{severity}'. " \
-            "Valid severities are #{Severity::NAMES.join(', ')}."
-          warn(Rainbow(message).red)
-        end
+      def suppress_clobbering
+        yield
+      rescue ::Parser::ClobberingError
+        # ignore Clobbering errors
       end
     end
   end