rubocop 0.78.0 → 1.13.0

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

data/lib/rubocop/cop/corrector.rb

@@ -8,156 +8,102 @@ 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
-      #
-      #   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
+    class Corrector < ::Parser::Source::TreeRewriter
+      NOOP_CONSUMER = ->(diagnostic) {} # noop
 
-        @corrections = corrections
-        @source_rewriter = Parser::Source::TreeRewriter.new(
-          source_buffer,
+      # @param source [Parser::Source::Buffer, or anything
+      #                leading to one via `(processed_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
+        diagnostics.consumer = NOOP_CONSUMER
       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
+
+      # 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 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}"