rubocop 1.88.2 → 1.90.0

data/lib/rubocop/cop/registry.rb

@@ -23,8 +23,8 @@ module RuboCop
         global.without_department(:Test).cops
       end
 
-      def self.qualified_cop_name(name, origin, warn: true)
-        global.qualified_cop_name(name, origin, warn: warn)
+      def self.qualified_cop_name(name, origin, warn: true, correct_namespace: true)
+        global.qualified_cop_name(name, origin, warn: warn, correct_namespace: correct_namespace)
       end
 
       # Changes momentarily the global registry
@@ -50,21 +50,37 @@ module RuboCop
 
       def initialize(cops = [], options = {})
         @departments = Set.new
+        # Maps each badge to its cop class, or to the fully qualified constant name (a `String`)
+        # when the cop is registered for lazy loading and its file is not loaded yet.
+        # A single insertion-ordered map keeps the registration order stable no matter when
+        # a lazy-loaded cop's file gets loaded, because reassigning an existing key preserves
+        # its position; the cop execution order depends on this order.
         @cops_by_badge = {}
-        @lazy_loaded_cops_by_badge = {}
 
         @enrollment_queue = cops
         @options = options
 
         @enabled_cache = {}.compare_by_identity
         @disabled_cache = {}.compare_by_identity
+        @disabled_names_cache = {}.compare_by_identity
         @warnings = {}
       end
 
-      def lazy_load(cop_name, constant_name)
-        badge = Badge.parse(cop_name)
+      # Registers a cop by its badge and constant name without loading the class.
+      # The constant is resolved (loading the cop's file through `autoload`) only
+      # when the cop class itself is needed.
+      #
+      # @param badge [Badge, String] the badge, or the qualified cop name
+      # @param constant_name [String] the fully qualified constant name
+      def lazy_load(badge, constant_name)
+        badge = Badge.parse(badge) if badge.is_a?(String)
+
+        # File any cops enlisted earlier first, so that the registration
+        # order follows the call order.
+        clear_enrollment_queue
+
         @departments << badge.department
-        @lazy_loaded_cops_by_badge[badge] = constant_name
+        @cops_by_badge[badge] = constant_name unless @cops_by_badge[badge].is_a?(Class)
       end
 
       def enlist(cop)
@@ -72,7 +88,16 @@ module RuboCop
       end
 
       def dismiss(cop)
-        raise "Cop #{cop} could not be dismissed" unless @enrollment_queue.delete(cop)
+        dismissed = !@enrollment_queue.delete(cop).nil?
+
+        # A lazy-loaded cop that was not enlisted yet is dismissed by removing its registration.
+        # Anonymous cop classes cannot have a badge.
+        if !cop.name.nil? && @cops_by_badge[cop.badge].is_a?(String)
+          @cops_by_badge.delete(cop.badge)
+          dismissed = true
+        end
+
+        raise "Cop #{cop} could not be dismissed" unless dismissed
       end
 
       # @return [Array<Symbol>] list of departments for current cops.
@@ -83,12 +108,26 @@ module RuboCop
 
       # @return [Registry] Cops for that specific department.
       def with_department(department)
-        with(cops.select { |cop| cop.department == department })
+        filter_by_badge { |badge| badge.department == department }
       end
 
       # @return [Registry] Cops not for a specific department.
       def without_department(department)
-        with(cops.reject { |cop| cop.department == department })
+        filter_by_badge { |badge| badge.department != department }
+      end
+
+      # Returns a new registry containing the cops whose badge satisfies the given block,
+      # keeping lazy-loaded cops unloaded.
+      #
+      # @api private
+      # @return [Registry]
+      def filter_by_badge(options = {})
+        clear_enrollment_queue
+        copy = self.class.new([], options)
+        @cops_by_badge.each do |badge, cop_or_name|
+          copy.add_entry(badge, cop_or_name) if yield(badge)
+        end
+        copy
       end
 
       # @return [Boolean] Checks if given name is department
@@ -97,7 +136,7 @@ module RuboCop
       end
 
       def contains_cop_matching?(names)
-        cops.any? { |cop| cop.match?(names) }
+        registered_badges.any? { |badge| badge.match_name?(names) }
       end
 
       # Convert a user provided cop name into a properly namespaced name
@@ -132,11 +171,19 @@ module RuboCop
       # @note Emits a warning if the provided name has an incorrect namespace
       #
       # @return [String] Qualified cop name
-      def qualified_cop_name(name, path, warn: true)
+      def qualified_cop_name(name, path, warn: true, correct_namespace: true)
         badge = Badge.parse(name)
         print_department_missing_warning(name, path) if warn && department_missing?(badge, name)
         return name if registered?(badge)
+        # A name qualified with the wrong department is returned as is when
+        # namespace correction is not wanted, so the caller can surface the
+        # mistake instead of silently acting on the corrected name.
+        return name if badge.qualified? && !correct_namespace
+
+        resolve_cop_name(badge, name, path, warn)
+      end
 
+      def resolve_cop_name(badge, name, path, warn)
         potential_badges = qualify_badge(badge)
 
         case potential_badges.size
@@ -160,9 +207,10 @@ module RuboCop
 
       def unqualified_cop_names
         clear_enrollment_queue
-        @unqualified_cop_names ||=
-          (@cops_by_badge.keys | @lazy_loaded_cops_by_badge.keys)
-          .to_set { |badge| File.basename(badge.to_s) } << 'RedundantCopDisableDirective'
+
+        @unqualified_cop_names ||= @cops_by_badge.keys.to_set do |badge|
+          File.basename(badge.to_s)
+        end << 'RedundantCopDisableDirective'
       end
 
       def qualify_badge(badge)
@@ -187,51 +235,64 @@ module RuboCop
 
       def length
         clear_enrollment_queue
-        @cops_by_badge.size + @lazy_loaded_cops_by_badge.size
+        @cops_by_badge.size
       end
 
+      # Returns the enabled cop classes, loading lazy-loaded cops only when they are enabled.
+      #
+      # @return [Array<Class>]
       def enabled(config)
-        @enabled_cache[config] ||= select { |cop| enabled?(cop, config) }
+        @enabled_cache[config] ||= registered_badges.filter_map do |badge|
+          next unless enabled_cop_name?(badge.to_s, config)
+
+          cop_or_name = @cops_by_badge[badge]
+          cop_or_name.is_a?(String) ? load_lazy_cop(badge) : cop_or_name
+        end
       end
 
       def disabled(config)
         @disabled_cache[config] ||= reject { |cop| enabled?(cop, config) }
       end
 
-      def enabled?(cop, config)
-        return true if options[:only]&.include?(cop.cop_name)
-
-        # We need to use `cop_name` in this case, because `for_cop` uses caching
-        # which expects cop names or cop classes as keys.
-        cfg = config.for_cop(cop.cop_name)
-
-        cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config)
-
-        if options.fetch(:safe, false)
-          cop_enabled && cfg.fetch('Safe', true)
-        else
-          cop_enabled
+      # Returns the names of the disabled cops without loading any of them.
+      #
+      # @api private
+      # @return [Array<String>]
+      def disabled_names(config)
+        @disabled_names_cache[config] ||= registered_badges.filter_map do |badge|
+          name = badge.to_s
+          name unless enabled_cop_name?(name, config)
         end
       end
 
-      def enabled_pending_cop?(cop_cfg, config)
+      def enabled?(cop, config)
+        enabled_cop_name?(cop.cop_name, config)
+      end
+
+      # @param cop [Class, String, nil] the cop class or the qualified cop name
+      def enabled_pending_cop?(cop_cfg, config, cop = nil)
         return false if @options[:disable_pending_cops]
+        return false unless cop_cfg.fetch('Enabled') == 'pending'
+        return true if @options[:enable_pending_cops]
+        return config.enabled_new_cops? unless cop
 
-        cop_cfg.fetch('Enabled') == 'pending' &&
-          (@options[:enable_pending_cops] || config.enabled_new_cops?)
+        cop_name = cop.is_a?(String) ? cop : cop.cop_name
+        config.enabled_new_cop?(cop_name)
       end
 
       def names
         clear_enrollment_queue
-        @cops_by_badge.keys.map(&:to_s) | @lazy_loaded_cops_by_badge.keys.map(&:to_s)
+        @cops_by_badge.keys.map(&:to_s)
       end
 
       def cops_for_department(department)
-        cops.select { |cop| cop.department == department.to_sym }
+        with_department(department.to_sym).cops
       end
 
       def names_for_department(department)
-        cops_for_department(department).map(&:cop_name)
+        department = department.to_sym
+
+        registered_badges.filter_map { |badge| badge.to_s if badge.department == department }
       end
 
       def ==(other)
@@ -259,7 +320,9 @@ module RuboCop
       def find_by_cop_name(cop_name)
         clear_enrollment_queue
         badge = Badge.parse(cop_name)
-        @cops_by_badge[badge] || load_lazy_cop(badge)
+        cop_or_name = @cops_by_badge[badge]
+
+        cop_or_name.is_a?(String) ? load_lazy_cop(badge) : cop_or_name
       end
 
       # When a cop name is given returns a single-element array with the cop class.
@@ -270,10 +333,33 @@ module RuboCop
         cop ? [cop] : cops_for_department(directive)
       end
 
+      # Loads all cops that are registered for lazy loading. Useful when lazily registered cops
+      # must not outlive the current global registry, e.g. before a temporary global registry is
+      # discarded in tests.
+      #
+      # @api private
+      def load_all_lazy_cops
+        # Take a snapshot because loading a cop can load (and thereby register)
+        # another lazy-loaded cop, e.g. its superclass.
+        badges = @cops_by_badge.keys
+
+        badges.each do |badge|
+          load_lazy_cop(badge) if @cops_by_badge[badge].is_a?(String)
+        end
+      end
+
       def freeze
         clear_enrollment_queue
         load_all_lazy_cops
         unqualified_cop_names # build cache
+
+        # Freeze the structural collections as well, so that a cop class defined after
+        # the freeze fails fast at its `enlist`/`lazy_load` call site instead of corrupting
+        # the registry and failing much later.
+        @cops_by_badge.freeze
+        @departments.freeze
+        @enrollment_queue.freeze
+
         super
       end
 
@@ -287,35 +373,83 @@ module RuboCop
         @warnings[path]
       end
 
+      protected
+
+      # Adds an already-loaded cop class or a lazy-load constant name under the given badge,
+      # used to build filtered copies.
+      def add_entry(badge, cop_or_name)
+        @departments << badge.department
+        @cops_by_badge[badge] = cop_or_name
+      end
+
       private
 
       def initialize_copy(reg)
-        initialize(reg.cops, reg.options)
+        super
+        @cops_by_badge = @cops_by_badge.dup
+        @enrollment_queue = @enrollment_queue.dup
+        @departments = @departments.dup
+        @enabled_cache = {}.compare_by_identity
+        @disabled_cache = {}.compare_by_identity
+        @disabled_names_cache = {}.compare_by_identity
+        @warnings = {}
+        @unqualified_cop_names = nil
       end
 
       def clear_enrollment_queue
         return if @enrollment_queue.empty?
 
         @enrollment_queue.each do |cop|
+          # Reassigning a badge that was registered for lazy loading keeps
+          # its original position in the insertion-ordered map.
           @cops_by_badge[cop.badge] = cop
           @departments << cop.department
         end
         @enrollment_queue = []
       end
 
-      def load_all_lazy_cops
-        @lazy_loaded_cops_by_badge.each_key { |badge| load_lazy_cop(badge) }
+      def registered_badges
+        clear_enrollment_queue
+        @cops_by_badge.keys
       end
 
-      def load_lazy_cop(badge)
-        constant_name = @lazy_loaded_cops_by_badge.delete(badge)
-        return unless constant_name
+      def enabled_cop_name?(cop_name, config)
+        return true if options[:only]&.include?(cop_name)
+
+        # We need to use the cop name in this case, because `for_cop` uses
+        # caching which expects cop names or cop classes as keys.
+        cfg = config.for_cop(cop_name)
 
-        @cops_by_badge[badge] = Kernel.const_get(constant_name)
+        cop_enabled = cfg.fetch('Enabled') == true || enabled_pending_cop?(cfg, config, cop_name)
+
+        if options.fetch(:safe, false)
+          cop_enabled && cfg.fetch('Safe', true)
+        else
+          cop_enabled
+        end
       end
 
-      def with(cops)
-        self.class.new(cops)
+      # @return [Class, nil] the loaded cop class, or nil if the cop excluded
+      #   itself from the registry while being loaded
+      def load_lazy_cop(badge)
+        constant_name = @cops_by_badge[badge]
+        return constant_name unless constant_name.is_a?(String)
+
+        cop = Kernel.const_get(constant_name)
+        if equal?(self.class.global)
+          # Resolving the constant fires the autoload, which makes
+          # `Base.inherited` enlist the class into the global registry.
+          # Enrolling through the queue keeps `exclude_from_registry` honored:
+          # a cop that dismissed itself leaves a dangling constant name behind
+          # and is removed from the registry.
+          clear_enrollment_queue
+          cop_or_name = @cops_by_badge[badge]
+          @cops_by_badge.delete(badge) if cop_or_name.is_a?(String)
+          cop_or_name.is_a?(Class) ? cop_or_name : nil
+        else
+          # `Base.inherited` enlists into the global registry, not this copy.
+          @cops_by_badge[badge] = cop
+        end
       end
 
       def resolve_badge(given_badge, real_badge, source_path, warn: true)
@@ -335,7 +469,7 @@ module RuboCop
 
       def registered?(badge)
         clear_enrollment_queue
-        @cops_by_badge.key?(badge) || @lazy_loaded_cops_by_badge.key?(badge)
+        @cops_by_badge.key?(badge)
       end
     end
   end

data/lib/rubocop/cop/security.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Security` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Security
+      extend LazyLoader
+
+      register_cop :CompoundHash, "#{__dir__}/security/compound_hash"
+      register_cop :Eval, "#{__dir__}/security/eval"
+      register_cop :IoMethods, "#{__dir__}/security/io_methods"
+      register_cop :JSONLoad, "#{__dir__}/security/json_load"
+      register_cop :MarshalLoad, "#{__dir__}/security/marshal_load"
+      register_cop :Open, "#{__dir__}/security/open"
+      register_cop :YAMLLoad, "#{__dir__}/security/yaml_load"
+    end
+  end
+end

data/lib/rubocop/cop/style/accessor_grouping.rb

@@ -100,7 +100,7 @@ module RuboCop
           comment_line?(processed_source[node.first_line - 2])
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def groupable_accessor?(node)
           return true unless (previous_expression = node.left_siblings.last)
 
@@ -122,7 +122,6 @@ module RuboCop
             previous_expression.access_modifier? ||
             node.first_line - previous_expression.last_line > 1 # there is a space between nodes
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def class_send_elements(class_node)
           class_def = class_node.body

data/lib/rubocop/cop/style/arguments_forwarding.rb

@@ -197,7 +197,7 @@ module RuboCop
           send_classifications.all? { |_, c, _, _| all_classifications.include?(c) }
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def add_forward_all_offenses(node, send_classifications, forwardable_args)
           rest_arg, kwrest_arg, block_arg = *forwardable_args
           registered_block_arg_offense = false
@@ -220,13 +220,12 @@ module RuboCop
 
           register_forward_all_offense(node, node.arguments, rest_arg || kwrest_arg)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         def forward_all_first_argument(node)
           node.arguments.reverse_each.find(&:forwarded_restarg_type?)
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
           return unless use_anonymous_forwarding?
           return unless all_forwarding_offenses_correctable?(send_classifications)
@@ -250,7 +249,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def non_splat_or_block_pass_lvar_references(body)
           body.each_descendant(:lvar, :lvasgn).filter_map do |lvar|
@@ -473,7 +471,7 @@ module RuboCop
 
           private
 
-          # rubocop:disable Metrics/CyclomaticComplexity
+          # rubocop:disable-next Metrics/CyclomaticComplexity
           def can_forward_all?
             return false if any_arg_referenced?
             return false if ruby_30_or_lower_optarg?
@@ -483,7 +481,6 @@ module RuboCop
 
             no_additional_args? || (target_ruby_version >= 3.0 && no_post_splat_args?)
           end
-          # rubocop:enable Metrics/CyclomaticComplexity
 
           # def foo(a = 41, ...) is a syntax error in 3.0.
           def ruby_30_or_lower_optarg?

data/lib/rubocop/cop/style/array_first_last.rb

@@ -31,7 +31,7 @@ module RuboCop
         MSG = 'Use `%<preferred>s`.'
         RESTRICT_ON_SEND = %i[[]].freeze
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
           return unless node.arguments.size == 1 && node.first_argument.int_type?
 
@@ -49,7 +49,6 @@ module RuboCop
             corrector.replace(offense_range, preferred_value(node, preferred))
           end
         end
-        # rubocop:enable Metrics/AbcSize
         alias on_csend on_send
 
         private

data/lib/rubocop/cop/style/array_intersect.rb

@@ -30,6 +30,11 @@ module RuboCop
       # only cases where exactly one argument is provided can be replaced with
       # `Array#intersect?` and are handled by this cop.
       #
+      # NOTE: In the block form, `include?` is only detected when its receiver is
+      # an array literal, because `include?` is defined with different semantics
+      # on many non-array classes (e.g. `String#include?` checks for substrings).
+      # `member?` does not have this restriction.
+      #
       # @safety
       #   This cop cannot guarantee that `array1` and `array2` are
       #   actually arrays while method `intersect?` is for arrays only.
@@ -47,7 +52,7 @@ module RuboCop
       #
       #   # bad
       #   array1.any? { |elem| array2.member?(elem) }
-      #   array1.none? { |elem| array2.include?(elem) }
+      #   array1.none? { |elem| [1, 2].include?(elem) }
       #
       #   # good
       #   array1.intersect?(array2)
@@ -121,15 +126,15 @@ module RuboCop
             (block
               (call $_receiver ${:any? :none?})
               (args (arg _key))
-              (send $_argument {:member? :include?} (lvar _key))
+              (send $!nil? ${:member? :include?} (lvar _key))
             )
             (numblock
               (call $_receiver ${:any? :none?}) 1
-              (send $_argument {:member? :include?} (lvar :_1))
+              (send $!nil? ${:member? :include?} (lvar :_1))
             )
             (itblock
               (call $_receiver ${:any? :none?}) :it
-              (send $_argument {:member? :include?} (lvar :it))
+              (send $!nil? ${:member? :include?} (lvar :it))
             )
           }
         PATTERN
@@ -156,7 +161,10 @@ module RuboCop
         alias on_csend on_send
 
         def on_block(node)
-          return unless (receiver, method_name, argument = any_none_block_intersection(node))
+          return unless (captures = any_none_block_intersection(node))
+
+          receiver, method_name, argument, block_method = captures
+          return if uncorrectable_block_intersection?(node, method_name, argument, block_method)
 
           dot = node.send_node.loc.dot.source
           bang = method_name == :any? ? '' : '!'
@@ -186,6 +194,17 @@ module RuboCop
           STRAIGHT_METHODS.include?(method_name.to_sym)
         end
 
+        def uncorrectable_block_intersection?(node, method_name, argument, block_method)
+          # `a&.none? { |elem| b.include?(elem) }` returns `nil` when `a` is `nil`,
+          # but the negated rewrite `!a&.intersect?(b)` returns `true` there, flipping the result.
+          return true if method_name == :none? && node.send_node.safe_navigation?
+
+          # `include?` is defined with different semantics on many non-array classes
+          # (e.g. `String#include?` checks for substrings), so it is only a reliable
+          # signal of an intersection check when the receiver is an array literal.
+          block_method == :include? && !argument.array_type?
+        end
+
         def register_offense(node, replacement)
           message = format(MSG, replacement: replacement, existing: node.source)
 

data/lib/rubocop/cop/style/bitwise_predicate.rb

@@ -70,7 +70,7 @@ module RuboCop
             (send _ :& _))
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def on_send(node)
           return unless node.receiver&.begin_type?
           return unless (preferred_method = preferred_method(node))
@@ -88,7 +88,6 @@ module RuboCop
             corrector.replace(node, preferred)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

data/lib/rubocop/cop/style/block_delimiters.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength
+# rubocop:disable-next Metrics/ClassLength
 module RuboCop
   module Cop
     module Style
@@ -344,7 +344,7 @@ module RuboCop
           node.respond_to?(:block_node) && node.block_node
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def get_blocks(node, &block)
           case node.type
           when :block, :numblock, :itblock
@@ -368,9 +368,8 @@ module RuboCop
             node.each_child_node { |child| get_blocks(child, &block) }
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
-        # rubocop:disable Metrics/CyclomaticComplexity -- inlined special_method checks to avoid double evaluation
+        # rubocop:disable-next Metrics/CyclomaticComplexity -- inlined special_method checks to avoid double evaluation
         def proper_block_style?(node)
           return true if require_do_end?(node)
 
@@ -385,7 +384,6 @@ module RuboCop
           when :always_braces       then node.braces?
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def require_do_end?(node)
           return false if node.braces? || node.multiline?
@@ -507,4 +505,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Metrics/ClassLength

data/lib/rubocop/cop/style/case_like_if.rb

@@ -98,7 +98,7 @@ module RuboCop
             node.elsif_conditional? && min_branches_count?(node)
         end
 
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/MethodLength
         def find_target(node)
           case node.type
           when :begin
@@ -116,7 +116,6 @@ module RuboCop
             find_target_in_send_node(node)
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def find_target_in_send_node(node)
           case node.method_name
@@ -181,7 +180,7 @@ module RuboCop
           conditions << condition if condition
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def condition_from_send_node(node, target)
           case node.method_name
           when :is_a?
@@ -196,7 +195,6 @@ module RuboCop
             condition_from_include_or_cover_node(node, target)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
 
         def condition_from_equality_node(node, target)
           condition = condition_from_binary_op(node.receiver, node.first_argument, target)