rubocop 1.30.1 → 1.64.0

data/lib/rubocop/config_obsoletion.rb

@@ -15,6 +15,8 @@ module RuboCop
       'changed_parameters' => ChangedParameter,
       'changed_enforced_styles' => ChangedEnforcedStyles
     }.freeze
+    LOAD_RULES_CACHE = {} # rubocop:disable Style/MutableConstant
+    private_constant :LOAD_RULES_CACHE
 
     attr_reader :rules, :warnings
 
@@ -47,12 +49,18 @@ module RuboCop
 
     # Default rules for obsoletions are in config/obsoletion.yml
     # Additional rules files can be added with `RuboCop::ConfigObsoletion.files << filename`
-    def load_rules
-      rules = self.class.files.each_with_object({}) do |filename, hash|
-        hash.merge!(YAML.safe_load(File.read(filename))) do |_key, first, second|
-          first.merge(second)
+    def load_rules # rubocop:disable Metrics/AbcSize
+      rules = LOAD_RULES_CACHE[self.class.files] ||=
+        self.class.files.each_with_object({}) do |filename, hash|
+          hash.merge!(YAML.safe_load(File.read(filename)) || {}) do |_key, first, second|
+            case first
+            when Hash
+              first.merge(second)
+            when Array
+              first.concat(second)
+            end
+          end
         end
-      end
 
       cop_rules = rules.slice(*COP_RULE_CLASSES.keys)
       parameter_rules = rules.slice(*PARAMETER_RULE_CLASSES.keys)
@@ -63,11 +71,11 @@ module RuboCop
     # Cop rules are keyed by the name of the original cop
     def load_cop_rules(rules)
       rules.flat_map do |rule_type, data|
-        data.map do |cop_name, configuration|
+        data.filter_map do |cop_name, configuration|
           next unless configuration # allow configurations to be disabled with `CopName: ~`
 
           COP_RULE_CLASSES[rule_type].new(@config, cop_name, configuration)
-        end.compact
+        end
       end
     end
 

data/lib/rubocop/config_validator.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'pathname'
-
 module RuboCop
   # Handles validation of configuration, for example cop names, parameter
   # names, and Ruby versions.
@@ -20,6 +18,7 @@ module RuboCop
     # @api private
     CONFIG_CHECK_KEYS = %w[Enabled Safe SafeAutoCorrect AutoCorrect].to_set.freeze
     CONFIG_CHECK_DEPARTMENTS = %w[pending override_department].freeze
+    CONFIG_CHECK_AUTOCORRECTS = %w[always contextual disabled].freeze
     private_constant :CONFIG_CHECK_KEYS, :CONFIG_CHECK_DEPARTMENTS
 
     def_delegators :@config, :smart_loaded_path, :for_all_cops
@@ -107,7 +106,7 @@ module RuboCop
       return if unknown_cops.empty?
 
       if ConfigLoader.ignore_unrecognized_cops
-        warn Rainbow('The following cops or departments are not '\
+        warn Rainbow('The following cops or departments are not ' \
                      'recognized and will be ignored:').yellow
         warn unknown_cops.join("\n")
 
@@ -162,7 +161,7 @@ module RuboCop
       return unless syntax_config && default_config.merge(syntax_config) != default_config
 
       raise ValidationError,
-            "configuration for Syntax cop found in #{smart_loaded_path}\n" \
+            "configuration for Lint/Syntax cop found in #{smart_loaded_path}\n" \
             'It\'s not possible to disable this cop.'
     end
 
@@ -250,23 +249,31 @@ module RuboCop
       end
     end
 
+    # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
     def check_cop_config_value(hash, parent = nil)
       hash.each do |key, value|
         check_cop_config_value(value, key) if value.is_a?(Hash)
 
         next unless CONFIG_CHECK_KEYS.include?(key) && value.is_a?(String)
 
-        next if key == 'Enabled' && CONFIG_CHECK_DEPARTMENTS.include?(value)
+        if key == 'Enabled' && !CONFIG_CHECK_DEPARTMENTS.include?(value)
+          supposed_values = 'a boolean'
+        elsif key == 'AutoCorrect' && !CONFIG_CHECK_AUTOCORRECTS.include?(value)
+          supposed_values = '`always`, `contextual`, `disabled`, or a boolean'
+        else
+          next
+        end
 
-        raise ValidationError, msg_not_boolean(parent, key, value)
+        raise ValidationError, param_error_message(parent, key, value, supposed_values)
       end
     end
+    # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
     # FIXME: Handling colors in exception messages like this is ugly.
-    def msg_not_boolean(parent, key, value)
+    def param_error_message(parent, key, value, supposed_values)
       "#{Rainbow('').reset}" \
-        "Property #{Rainbow(key).yellow} of cop #{Rainbow(parent).yellow}" \
-        " is supposed to be a boolean and #{Rainbow(value).yellow} is not."
+        "Property #{Rainbow(key).yellow} of #{Rainbow(parent).yellow} cop " \
+        "is supposed to be #{supposed_values} and #{Rainbow(value).yellow} is not."
     end
   end
 end

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -32,10 +32,15 @@ module RuboCop
         # allow turning off autocorrect on a cop by cop basis
         return true unless cop_config
 
-        return false if cop_config['AutoCorrect'] == false
+        # `false` is the same as `disabled` for backward compatibility.
+        return false if ['disabled', false].include?(cop_config['AutoCorrect'])
+
+        # When LSP is enabled, it is considered as editing source code,
+        # and autocorrection with `AutoCorrect: contextual` will not be performed.
+        return false if contextual_autocorrect? && LSP.enabled?
 
         # :safe_autocorrect is a derived option based on several command-line
-        # arguments - see Rubocop::Options#add_autocorrection_options
+        # arguments - see RuboCop::Options#add_autocorrection_options
         return safe_autocorrect? if @options.fetch(:safe_autocorrect, false)
 
         true
@@ -43,18 +48,24 @@ module RuboCop
 
       private
 
-      def disable_offense(range)
-        heredoc_range = surrounding_heredoc(range)
-        if heredoc_range
-          disable_offense_before_and_after(range_by_lines(heredoc_range))
+      def disable_offense(offense_range)
+        range = surrounding_heredoc(offense_range) || surrounding_percent_array(offense_range)
+
+        if range
+          disable_offense_before_and_after(range_by_lines(range))
+        else
+          disable_offense_with_eol_or_surround_comment(offense_range)
+        end
+      end
+
+      def disable_offense_with_eol_or_surround_comment(range)
+        eol_comment = " # rubocop:todo #{cop_name}"
+        needed_line_length = (range.source_line + eol_comment).length
+
+        if needed_line_length <= max_line_length
+          disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
         else
-          eol_comment = " # rubocop:todo #{cop_name}"
-          needed_line_length = (range.source_line + eol_comment).length
-          if needed_line_length <= max_line_length
-            disable_offense_at_end_of_line(range_of_first_line(range), eol_comment)
-          else
-            disable_offense_before_and_after(range_by_lines(range))
-          end
+          disable_offense_before_and_after(range_by_lines(range))
         end
       end
 
@@ -65,10 +76,22 @@ module RuboCop
         heredoc_nodes = processed_source.ast.each_descendant.select do |node|
           node.respond_to?(:heredoc?) && node.heredoc?
         end
-        heredoc_nodes.map { |node| node.loc.expression.join(node.loc.heredoc_end) }
+        heredoc_nodes.map { |node| node.source_range.join(node.loc.heredoc_end) }
                      .find { |range| range.contains?(offense_range) }
       end
 
+      def surrounding_percent_array(offense_range)
+        return nil if offense_range.empty?
+
+        percent_array = processed_source.ast.each_descendant.select do |node|
+          node.array_type? && node.percent_literal?
+        end
+
+        percent_array.map(&:source_range).find do |range|
+          offense_range.begin_pos > range.begin_pos && range.overlaps?(offense_range)
+        end
+      end
+
       def range_of_first_line(range)
         begin_of_first_line = range.begin_pos - range.column
         end_of_first_line = begin_of_first_line + range.source_line.length

data/lib/rubocop/cop/badge.rb

@@ -10,7 +10,7 @@ module RuboCop
     # allow for badge references in source files that omit the department for
     # RuboCop to infer.
     class Badge
-      attr_reader :department, :cop_name
+      attr_reader :department, :department_name, :cop_name
 
       def self.for(class_name)
         parts = class_name.split('::')
@@ -18,19 +18,23 @@ module RuboCop
         new(name_deep_enough ? parts[2..] : parts.last(2))
       end
 
+      @parse_cache = {}
+
       def self.parse(identifier)
-        new(identifier.split('/').map { |i| camel_case(i) })
+        @parse_cache[identifier] ||= new(identifier.split('/').map! { |i| camel_case(i) })
       end
 
       def self.camel_case(name_part)
         return 'RSpec' if name_part == 'rspec'
+        return name_part unless name_part.match?(/^[a-z]|_[a-z]/)
 
-        name_part.gsub(/^\w|_\w/) { |match| match[-1, 1].upcase }
+        name_part.gsub(/^[a-z]|_[a-z]/) { |match| match[-1, 1].upcase }
       end
 
       def initialize(class_name_parts)
         department_parts = class_name_parts[0...-1]
         @department = (department_parts.join('/').to_sym unless department_parts.empty?)
+        @department_name = @department&.to_s
         @cop_name = class_name_parts.last
       end
 
@@ -40,7 +44,8 @@ module RuboCop
       alias eql? ==
 
       def hash
-        [department, cop_name].hash
+        # Do hashing manually to reduce Array allocations.
+        department.hash ^ cop_name.hash # rubocop:disable Security/CompoundHash
       end
 
       def match?(other)

data/lib/rubocop/cop/base.rb

@@ -48,24 +48,109 @@ module RuboCop
       InvestigationReport = Struct.new(:cop, :processed_source, :offenses, :corrector)
 
       # List of methods names to restrict calls for `on_send` / `on_csend`
-      RESTRICT_ON_SEND = Set[].freeze
+      RESTRICT_ON_SEND = Set[].freeze # rubocop:disable InternalAffairs/UselessRestrictOnSend
 
       # List of cops that should not try to autocorrect at the same
       # time as this cop
       #
-      # @return [Array<RuboCop::Cop::Cop>]
+      # @return [Array<RuboCop::Cop::Base>]
       #
       # @api public
       def self.autocorrect_incompatible_with
         []
       end
 
-      # Cops (other than builtin) are encouraged to implement this
+      # Returns an url to view this cops documentation online.
+      # Requires 'DocumentationBaseURL' to be set for your department.
+      # Will follow the convention of RuboCops own documentation structure,
+      # overwrite this method to accommodate your custom layout.
       # @return [String, nil]
       #
       # @api public
-      def self.documentation_url
-        Documentation.url_for(self) if builtin?
+      def self.documentation_url(config = nil)
+        Documentation.url_for(self, config)
+      end
+
+      def self.inherited(subclass)
+        super
+        subclass.instance_variable_set(:@gem_requirements, gem_requirements.dup)
+        Registry.global.enlist(subclass)
+      end
+
+      # Call for abstract Cop classes
+      def self.exclude_from_registry
+        Registry.global.dismiss(self)
+      end
+
+      # Returns if class supports autocorrect.
+      # It is recommended to extend AutoCorrector instead of overriding
+      def self.support_autocorrect?
+        false
+      end
+
+      ### Naming
+
+      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?(badge.department_name)
+      end
+
+      # Override and return the Force class(es) you need to join
+      def self.joining_forces; end
+
+      ### Persistence
+
+      # Override if your cop should be called repeatedly for multiple investigations
+      # Between calls to `on_new_investigation` and `on_investigation_end`,
+      # the result of `processed_source` will remain constant.
+      # You should invalidate any caches that depend on the current `processed_source`
+      # in the `on_new_investigation` callback.
+      # If your cop does autocorrections, be aware that your instance may be called
+      # multiple times with the same `processed_source.path` but different content.
+      def self.support_multiple_source?
+        false
+      end
+
+      ## Gem requirements
+
+      @gem_requirements = {}
+
+      class << self
+        attr_reader :gem_requirements
+
+        # Register a version requirement for the given gem name.
+        # This cop will be skipped unless the target satisfies *all* requirements.
+        # @param [String] gem_name
+        # @param [Array<String>] version_requirements The version requirements,
+        #   using the same syntax as a Gemfile, e.g. ">= 1.2.3"
+        #
+        #   If omitted, any version of the gem will be accepted.
+        #
+        #   https://guides.rubygems.org/patterns/#declaring-dependencies
+        #
+        # @api public
+        def requires_gem(gem_name, *version_requirements)
+          @gem_requirements[gem_name] = Gem::Requirement.new(version_requirements)
+        end
       end
 
       def initialize(config = nil, options = nil)
@@ -92,9 +177,6 @@ module RuboCop
         # Typically do nothing here
       end
 
-      # Override and return the Force class(es) you need to join
-      def self.joining_forces; end
-
       # Gets called if no message is specified when calling `add_offense` or
       # `add_global_offense`
       # Cops are discouraged to override this; instead pass your message directly
@@ -107,8 +189,9 @@ module RuboCop
       def add_global_offense(message = nil, severity: nil)
         severity = find_severity(nil, severity)
         message = find_message(nil, message)
-        @current_offenses <<
-          Offense.new(severity, Offense::NO_LOCATION, message, name, :unsupported)
+        range = Offense::NO_LOCATION
+        status = enabled_line?(range.line) ? :unsupported : :disabled
+        current_offenses << Offense.new(severity, range, message, name, status)
       end
 
       # Adds an offense on the specified range (or node with an expression)
@@ -126,7 +209,11 @@ module RuboCop
 
         status, corrector = enabled_line?(range.line) ? correct(range, &block) : :disabled
 
-        @current_offenses << Offense.new(severity, range, message, name, status, corrector)
+        # 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)
+
+        current_offenses << Offense.new(severity, range, message, name, status, corrector)
       end
 
       # This method should be overridden when a cop's behavior depends
@@ -148,48 +235,6 @@ module RuboCop
         nil
       end
 
-      def self.inherited(subclass)
-        super
-        Registry.global.enlist(subclass)
-      end
-
-      # Call for abstract Cop classes
-      def self.exclude_from_registry
-        Registry.global.dismiss(self)
-      end
-
-      # Returns if class supports autocorrect.
-      # It is recommended to extend AutoCorrector instead of overriding
-      def self.support_autocorrect?
-        false
-      end
-
-      ### Naming
-
-      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
-
       def cop_name
         @cop_name ||= self.class.cop_name
       end
@@ -216,11 +261,22 @@ module RuboCop
         @config.target_ruby_version
       end
 
+      def parser_engine
+        @config.parser_engine
+      end
+
       def target_rails_version
         @config.target_rails_version
       end
 
+      def active_support_extensions_enabled?
+        @config.active_support_extensions_enabled?
+      end
+
       def relevant_file?(file)
+        return false unless target_satisfies_all_gem_version_requirements?
+        return true unless @config.clusivity_config_for_badge?(self.class.badge)
+
         file == RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME ||
           (file_name_matches_any?(file, 'Include', true) &&
             !file_name_matches_any?(file, 'Exclude', false))
@@ -232,20 +288,7 @@ module RuboCop
 
       # There should be very limited reasons for a Cop to do it's own parsing
       def parse(source, path = nil)
-        ProcessedSource.new(source, target_ruby_version, path)
-      end
-
-      ### Persistence
-
-      # Override if your cop should be called repeatedly for multiple investigations
-      # Between calls to `on_new_investigation` and `on_investigation_end`,
-      # the result of `processed_source` will remain constant.
-      # You should invalidate any caches that depend on the current `processed_source`
-      # in the `on_new_investigation` callback.
-      # If your cop does autocorrections, be aware that your instance may be called
-      # multiple times with the same `processed_source.path` but different content.
-      def self.support_multiple_source?
-        false
+        ProcessedSource.new(source, target_ruby_version, path, parser_engine: parser_engine)
       end
 
       # @api private
@@ -266,6 +309,7 @@ module RuboCop
 
       ### Reserved for Commissioner
 
+      # rubocop:disable Layout/ClassStructure
       # @api private
       def callbacks_needed
         self.class.callbacks_needed
@@ -274,10 +318,41 @@ module RuboCop
       # @api private
       def self.callbacks_needed
         @callbacks_needed ||= public_instance_methods.select do |m|
-          m.match?(/^on_|^after_/) &&
+          m.start_with?(/on_|after_/) &&
             !Base.method_defined?(m) # exclude standard "callbacks" like 'on_begin_investigation'
         end
       end
+      # rubocop:enable Layout/ClassStructure
+
+      # Called before any investigation
+      # @api private
+      def begin_investigation(processed_source, offset: 0, original: processed_source)
+        @current_offenses = nil
+        @current_offense_locations = nil
+        @currently_disabled_lines = nil
+        @processed_source = processed_source
+        @current_corrector = nil
+
+        # 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
+
+      # @api private
+      def always_autocorrect?
+        # `true` is the same as `'always'` for backward compatibility.
+        ['always', true].include?(cop_config.fetch('AutoCorrect', 'always'))
+      end
+
+      # @api private
+      def contextual_autocorrect?
+        cop_config.fetch('AutoCorrect', 'always') == 'contextual'
+      end
+
+      def inspect # :nodoc:
+        "#<#{self.class.name}:#{object_id} @config=#{@config} @options=#{@options}>"
+      end
 
       private
 
@@ -288,7 +363,7 @@ module RuboCop
       end
 
       def apply_correction(corrector)
-        @current_corrector&.merge!(corrector) if corrector
+        current_corrector&.merge!(corrector) if corrector
       end
 
       ### Reserved for Commissioner:
@@ -301,36 +376,31 @@ module RuboCop
         @currently_disabled_lines ||= Set.new
       end
 
-      private_class_method def self.restrict_on_send
-        @restrict_on_send ||= self::RESTRICT_ON_SEND.to_a.freeze
+      def current_corrector
+        @current_corrector ||= Corrector.new(@processed_source) if @processed_source.valid_syntax?
       end
 
-      # Called before any investigation
-      def begin_investigation(processed_source)
-        @current_offenses = []
-        @current_offense_locations = nil
-        @currently_disabled_lines = nil
-        @processed_source = processed_source
-        @current_corrector = Corrector.new(@processed_source) if @processed_source.valid_syntax?
+      def current_offenses
+        @current_offenses ||= []
+      end
+
+      private_class_method def self.restrict_on_send
+        @restrict_on_send ||= self::RESTRICT_ON_SEND.to_a.freeze
       end
 
+      EMPTY_OFFENSES = [].freeze
+      private_constant :EMPTY_OFFENSES
       # Called to complete an investigation
       def complete_investigation
-        InvestigationReport.new(self, processed_source, @current_offenses, @current_corrector)
+        InvestigationReport.new(
+          self, processed_source, @current_offenses || EMPTY_OFFENSES, @current_corrector
+        )
       ensure
         reset_investigation
       end
 
       ### Actually private methods
 
-      def self.builtin?
-        return false unless (m = instance_methods(false).first) # any custom method will do
-
-        path, _line = instance_method(m).source_location
-        path.start_with?(__dir__)
-      end
-      private_class_method :builtin?
-
       def reset_investigation
         @currently_disabled_lines = @current_offenses = @processed_source = @current_corrector = nil
       end
@@ -354,7 +424,7 @@ module RuboCop
       def use_corrector(range, corrector)
         if autocorrect?
           attempt_correction(range, corrector)
-        elsif corrector && cop_config.fetch('AutoCorrect', true)
+        elsif corrector && (always_autocorrect? || (contextual_autocorrect? && !LSP.enabled?))
           :uncorrected
         else
           :unsupported
@@ -385,7 +455,7 @@ module RuboCop
 
       def range_from_node_or_range(node_or_range)
         if node_or_range.respond_to?(:loc)
-          node_or_range.loc.expression
+          node_or_range.source_range
         elsif node_or_range.is_a?(::Parser::Source::Range)
           node_or_range
         else
@@ -408,15 +478,8 @@ module RuboCop
         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)
-
-          # Try with relative path.
-          path ||= config.path_relative_to_config(file)
-          match_path?(pattern, path)
-        end
+        patterns = FilePatterns.from(patterns)
+        patterns.match?(config.path_relative_to_config(file)) || patterns.match?(file)
       end
 
       def enabled_line?(line_number)
@@ -445,6 +508,26 @@ module RuboCop
           warn(Rainbow(message).red)
         end
       end
+
+      def range_for_original(range)
+        ::Parser::Source::Range.new(
+          @current_original.buffer,
+          range.begin_pos + @current_offset,
+          range.end_pos + @current_offset
+        )
+      end
+
+      def target_satisfies_all_gem_version_requirements?
+        self.class.gem_requirements.all? do |gem_name, version_req|
+          all_gem_versions_in_target = @config.gem_versions_in_target
+          next false unless all_gem_versions_in_target
+
+          gem_version_in_target = all_gem_versions_in_target[gem_name]
+          next false unless gem_version_in_target
+
+          version_req.satisfied_by?(gem_version_in_target)
+        end
+      end
     end
   end
 end

data/lib/rubocop/cop/bundler/duplicated_gem.rb

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Bundler
       # A Gem's requirements should be listed only once in a Gemfile.
+      #
       # @example
       #   # bad
       #   gem 'rubocop'
@@ -38,7 +39,7 @@ module RuboCop
       class DuplicatedGem < Base
         include RangeHelp
 
-        MSG = 'Gem `%<gem_name>s` requirements already given on line '\
+        MSG = 'Gem `%<gem_name>s` requirements already given on line ' \
               '%<line_of_first_occurrence>d of the Gemfile.'
 
         def on_new_investigation