rubocop 1.89.0 → 1.91.0

data/lib/rubocop/cop/lint/to_enum_arguments.rb

@@ -135,7 +135,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         def argument_match?(send_arg, def_arg)
           def_arg_name = def_arg.children[0]
 
@@ -157,7 +157,6 @@ module RuboCop
             send_arg.forwarded_args_type?
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
         def keyword_hash_argument?(send_arg)
           send_arg.hash_type? && !send_arg.braces?

data/lib/rubocop/cop/lint/unreachable_code.rb

@@ -83,7 +83,7 @@ module RuboCop
           }
         PATTERN
 
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/MethodLength
         def flow_expression?(node)
           return report_on_flow_command?(node) if flow_command?(node)
 
@@ -102,7 +102,6 @@ module RuboCop
             false
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def check_if(node)
           if_branch = node.if_branch

data/lib/rubocop/cop/lint/unused_private_method.rb

@@ -14,10 +14,17 @@ module RuboCop
       # in the indexed project (regardless of the receiver), when it is the source
       # of an `alias`, or when its name appears in the same file as a symbol or
       # inside a string literal (covering `send(:name)` and declarative DSLs like
-      # `before_action :name`). Methods defined in classes or modules with
-      # descendants are not checked, since they may be invoked through `super`
-      # or inherited dispatch, and neither are methods whose names are built
-      # dynamically (e.g. `send("do_#{action}")`).
+      # `before_action :name`). An interpolated symbol or string with a literal
+      # prefix (e.g. `send(:"format_#{type}")`) counts as a reference to every
+      # method whose name starts with that prefix; fully dynamic names cannot
+      # be detected. Methods defined in classes or modules with descendants are
+      # not checked, since they may be invoked through `super` or inherited
+      # dispatch.
+      #
+      # Methods whose names are composed by a framework (e.g. Rails
+      # `attribute_method_suffix` generating `attribute?` methods) can be
+      # excluded from the check with `AllowedNames` (exact names) or
+      # `AllowedPatterns` (regular expressions).
       #
       # The cop is disabled by default because symbol-based references from
       # *other* files (e.g. a Rails callback declared in a concern) cannot be
@@ -49,28 +56,56 @@ module RuboCop
       #     end
       #   end
       #
+      # @example AllowedNames: ['attribute?']
+      #   # good - the name is explicitly allowed
+      #   class Contact
+      #     private
+      #
+      #     def attribute?
+      #     end
+      #   end
+      #
+      # @example AllowedPatterns: ['_hook\z']
+      #   # good - the name matches an allowed pattern
+      #   class Service
+      #     private
+      #
+      #     def before_save_hook
+      #     end
+      #   end
+      #
       class UnusedPrivateMethod < Base
+        include AllowedPattern
         include ProjectIndexHelp
 
         MSG = 'Private method `%<method>s` appears to be unused.'
 
         IDENTIFIER_PATTERN = /[a-zA-Z_]\w*[?!=]?/.freeze
+        NAME_PREFIX_PATTERN = /[a-zA-Z_]\w*\z/.freeze
 
         # Methods invoked implicitly by the Ruby runtime.
-        IMPLICITLY_INVOKED_METHODS = %i[initialize initialize_copy initialize_clone
-                                        initialize_dup method_missing respond_to_missing?
-                                        marshal_dump marshal_load].to_set.freeze
+        IMPLICITLY_INVOKED_METHODS = %i[
+          initialize initialize_copy initialize_clone initialize_dup
+          method_missing respond_to_missing? marshal_dump marshal_load
+          coerce instance_variables_to_inspect
+          inherited included extended prepended
+          append_features extend_object prepend_features
+          const_missing const_added
+          method_added method_removed method_undefined
+          singleton_method_added singleton_method_removed singleton_method_undefined
+        ].to_set.freeze
 
         class << self
-          # The reference-name set is derived once per index and shared by the
-          # per-file cop instances.
-          def reference_names_cache
-            @reference_names_cache ||= {}.compare_by_identity
-          end
+          # The reference-name set is a property of the index, not of the cop
+          # instance, so all per-file instances share one computation. A
+          # single-entry cache (instead of a hash keyed by index) avoids
+          # retaining stale graphs in long-lived processes.
+          attr_accessor :cached_reference_names
         end
 
         def on_new_investigation
           @literal_names = nil
+          @literal_name_prefixes = nil
           super
         end
 
@@ -90,6 +125,7 @@ module RuboCop
 
         def checkable_declaration(node)
           return nil if IMPLICITLY_INVOKED_METHODS.include?(node.method_name)
+          return nil if allowed_name?(node.method_name)
           return nil if node.each_ancestor(:any_def, :any_block, :sclass).any?
           return nil unless (namespace_node = node.each_ancestor(:class, :module).first)
 
@@ -97,6 +133,12 @@ module RuboCop
           declaration if declaration&.private?
         end
 
+        def allowed_name?(method_name)
+          name = method_name.to_s
+
+          cop_config.fetch('AllowedNames', []).include?(name) || matches_allowed_pattern?(name)
+        end
+
         def method_declaration(node, namespace_node)
           namespace = resolve_constant_in_index(namespace_node.identifier)
           return nil unless namespace.is_a?(Rubydex::Namespace)
@@ -107,13 +149,22 @@ module RuboCop
         def referenced?(method_name)
           name = method_name.to_s
 
-          referenced_names.include?(name) || literal_names.include?(name)
+          referenced_names.include?(name) || literal_names.include?(name) ||
+            literal_name_prefixes.any? { |prefix| name.start_with?(prefix) }
         end
 
         def referenced_names
-          self.class.reference_names_cache[project_index] ||=
-            project_index.method_references
-                         .to_set { |reference| reference.name.delete_suffix('()') }
+          index, names = self.class.cached_reference_names
+          return names if index.equal?(project_index)
+
+          compute_referenced_names.tap do |computed|
+            self.class.cached_reference_names = [project_index, computed]
+          end
+        end
+
+        def compute_referenced_names
+          project_index.method_references
+                       .to_set { |reference| reference.name.delete_suffix('()') }
         end
 
         # Symbol literals and identifier-like tokens inside string literals in the
@@ -127,11 +178,37 @@ module RuboCop
               if literal.sym_type?
                 names << literal.value.to_s
               else
-                literal.value.scan(IDENTIFIER_PATTERN) { |token| names << token }
+                # `scan` raises on binary string literals with invalid byte sequences.
+                value = literal.value
+                value = value.scrub unless value.valid_encoding?
+                value.scan(IDENTIFIER_PATTERN) { |token| names << token }
               end
             end
         end
 
+        # The leading literal fragment of an interpolated symbol or string acts
+        # as a method-name prefix: `send(:"format_#{type}")` may invoke any
+        # method whose name starts with `format_`. Only the leading fragment
+        # qualifies (a mid-string fragment is not a name prefix), and a fully
+        # dynamic name contributes nothing.
+        def literal_name_prefixes
+          @literal_name_prefixes ||=
+            processed_source.ast.each_descendant(:dsym, :dstr)
+                            .with_object(Set.new) do |literal, prefixes|
+              prefix = interpolation_prefix(literal)
+              prefixes << prefix if prefix
+            end
+        end
+
+        def interpolation_prefix(node)
+          return nil if node.children.all?(&:str_type?)
+
+          leading_fragment = node.children.first
+          return nil unless leading_fragment&.str_type?
+
+          leading_fragment.value[NAME_PREFIX_PATTERN]
+        end
+
         # A method defined in a class or module with descendants may be invoked
         # through `super` or inherited dispatch, which the index does not track.
         def owner_with_descendants?(declaration)

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -210,7 +210,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
             if child.send_type? && access_modifier?(child)
@@ -228,7 +228,6 @@ module RuboCop
 
           [cur_vis, unused]
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_send_node(node, cur_vis, unused)
           if node.bare_access_modifier?

data/lib/rubocop/cop/lint/useless_assignment.rb

@@ -173,7 +173,7 @@ module RuboCop
           node.receiver.nil? && !node.arguments?
         end
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable-next Metrics/AbcSize
         def autocorrect(corrector, assignment)
           if assignment.exception_assignment?
             remove_exception_assignment_part(corrector, assignment.node)
@@ -189,7 +189,6 @@ module RuboCop
             remove_local_variable_assignment_part(corrector, assignment.node)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def remove_exception_assignment_part(corrector, node)
           range = node.parent.children.first&.source_range || node.parent.location.keyword

data/lib/rubocop/cop/lint/useless_constant_scoping.rb

@@ -10,6 +10,11 @@ module RuboCop
       # It does not support autocorrection due to behavior change and multiple ways to fix it.
       # Or a public constant may be intended.
       #
+      # Constant assignments that define classes or modules via `Class.new`, `Module.new`,
+      # `Struct.new`, or `Data.define` are allowed. Those forms are class and module definitions
+      # written with assignment syntax, and match the common practice of placing nested
+      # `class` / `module` bodies after `private` without intending private constant visibility.
+      #
       # @example
       #
       #   # bad
@@ -29,6 +34,19 @@ module RuboCop
       #     PUBLIC_CONST = 42 # If private scope is not intended.
       #   end
       #
+      #   # good - class/module definitions via assignment, same as nested `class`/`module`
+      #   class Foo
+      #     private
+      #
+      #     def some_private_method
+      #     end
+      #
+      #     MyClass = Class.new
+      #     MyModule = Module.new
+      #     MyStruct = Struct.new(:name)
+      #     MyData = Data.define(:name)
+      #   end
+      #
       class UselessConstantScoping < Base
         MSG = 'Useless `private` access modifier for constant scope.'
 
@@ -37,9 +55,27 @@ module RuboCop
           (send nil? :private_constant $...)
         PATTERN
 
+        # Matches class/module-like constant assignments. Nested `class` / `module`
+        # keyword definitions are not visited by this cop; these assignment forms are
+        # the equivalent syntax and should be treated the same way.
+        # @!method class_or_module_definition_assignment?(node)
+        def_node_matcher :class_or_module_definition_assignment?, <<~PATTERN
+          {
+            (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+            (send (const {nil? cbase} :Data) :define ...)
+            (any_block
+              {
+                (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+                (send (const {nil? cbase} :Data) :define ...)
+              }
+              ...)
+          }
+        PATTERN
+
         def on_casgn(node)
           return unless after_private_modifier?(node.left_siblings)
           return if private_constantize?(node.right_siblings, node.name)
+          return if class_or_module_definition_assignment?(node.expression)
 
           add_offense(node)
         end

data/lib/rubocop/cop/lint/useless_method_definition.rb

@@ -59,7 +59,7 @@ module RuboCop
         end
 
         def use_rest_or_optional_args?(node)
-          node.arguments.any? { |arg| arg.type?(:restarg, :optarg, :kwoptarg) }
+          node.arguments.any? { |arg| arg.type?(:restarg, :optarg, :kwoptarg, :kwrestarg) }
         end
 
         def delegating?(node, def_node)

data/lib/rubocop/cop/lint/useless_rescue.rb

@@ -56,7 +56,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity
         def only_reraising?(resbody_node)
           return false if use_exception_variable_in_ensure?(resbody_node)
 
@@ -70,7 +70,6 @@ module RuboCop
 
           exception_objects(resbody_node).include?(exception_name)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
         def use_exception_variable_in_ensure?(resbody_node)
           return false unless (exception_variable = resbody_node.exception_variable)

data/lib/rubocop/cop/lint/utils/nil_receiver_checker.rb

@@ -12,6 +12,8 @@ module RuboCop
             @receiver = receiver
             @additional_nil_methods = additional_nil_methods
             @checked_nodes = {}.compare_by_identity
+            @receiver_binding_name = binding_name(receiver)
+            @receiver_binding_scope = binding_scope(receiver) if @receiver_binding_name
           end
 
           def cant_be_nil?
@@ -20,7 +22,7 @@ module RuboCop
 
           private
 
-          # rubocop:disable Metrics
+          # rubocop:disable-next Metrics
           def _cant_be_nil?(node, receiver)
             return false unless node
 
@@ -34,7 +36,9 @@ module RuboCop
             when :def, :defs, :class, :module, :sclass
               return false
             when :send
-              return non_nil_method?(node.method_name) if node.receiver == receiver
+              if node.receiver == receiver && same_binding_as_receiver?(node.receiver)
+                return non_nil_method?(node.method_name)
+              end
 
               node.arguments.each do |argument|
                 return true if _cant_be_nil?(argument, receiver)
@@ -74,13 +78,12 @@ module RuboCop
               false
             end
           end
-          # rubocop:enable Metrics
 
           def non_nil_method?(method_name)
             !NIL_METHODS.include?(method_name) && !@additional_nil_methods.include?(method_name)
           end
 
-          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+          # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
           def sole_condition_of_parent_if?(node)
             child = node
             parent = node.parent
@@ -104,12 +107,63 @@ module RuboCop
 
             false
           end
-          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
           def non_nil_condition?(condition, node)
-            return true if condition == node
+            return true if condition == node && same_binding_as_receiver?(condition)
+            return false unless condition.csend_type?
+
+            root_receiver = csend_root_receiver(condition)
+
+            root_receiver == node && same_binding_as_receiver?(root_receiver)
+          end
+
+          # Structurally equal occurrences can be different variables: `it` binds to
+          # its innermost block, and a block parameter can shadow an outer variable of
+          # the same name. Evidence about such a receiver only holds when both occurrences
+          # resolve to the same binding.
+          def same_binding_as_receiver?(occurrence)
+            return true unless @receiver_binding_name
+
+            binding_scope(occurrence).equal?(@receiver_binding_scope)
+          end
+
+          # The name whose binding can differ between structurally equal occurrences:
+          # a local variable (block parameters included), or a bare `it` call, which is
+          # how `it` parses when the target Ruby version is below 3.4 even though the code
+          # may run on 3.4+ where `it` is the implicit block parameter.
+          def binding_name(node)
+            if node.lvar_type?
+              node.children.first
+            elsif node.send_type? && !node.receiver && node.method?(:it) && node.arguments.empty?
+              :it
+            end
+          end
+
+          def binding_scope(occurrence)
+            node = occurrence
+
+            while (parent = node.parent)
+              case parent.type
+              when :block, :numblock, :itblock
+                # Only the body is inside the block's scope; the send node and the arguments of
+                # the block node evaluate in the outer scope.
+                return parent if parent.body.equal?(node) && block_binds_name?(parent)
+              when :def, :defs, :class, :module, :sclass
+                return parent
+              end
+
+              node = parent
+            end
+
+            nil
+          end
+
+          def block_binds_name?(block_node)
+            name = @receiver_binding_name
+
+            return true if block_node.argument_list.any? { |argument| argument.name == name }
 
-            condition.csend_type? && csend_root_receiver(condition) == node
+            name == :it && block_node.arguments.empty?
           end
 
           # Whether control reaches `node` by falling through its left siblings rather than by

data/lib/rubocop/cop/lint/void.rb

@@ -153,7 +153,7 @@ module RuboCop
           check_expression(case_node.else_branch) if case_node.else_branch
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_void_op(node, &block)
           node = node.children.first while node&.begin_type?
           return unless node&.call_type? && OPERATORS.include?(node.method_name)
@@ -168,7 +168,6 @@ module RuboCop
             autocorrect_void_op(corrector, node)
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def check_var(node)
           return unless node.variable? || node.const_type?

data/lib/rubocop/cop/lint.rb

@@ -13,6 +13,7 @@ module RuboCop
       register_cop :AmbiguousOperatorPrecedence, "#{__dir__}/lint/ambiguous_operator_precedence"
       register_cop :AmbiguousRange, "#{__dir__}/lint/ambiguous_range"
       register_cop :AmbiguousRegexpLiteral, "#{__dir__}/lint/ambiguous_regexp_literal"
+      register_cop :ArgumentMismatch, "#{__dir__}/lint/argument_mismatch"
       register_cop :ArrayLiteralInRegexp, "#{__dir__}/lint/array_literal_in_regexp"
       register_cop :AssignmentInCondition, "#{__dir__}/lint/assignment_in_condition"
       register_cop :BigDecimalNew, "#{__dir__}/lint/big_decimal_new"
@@ -75,6 +76,7 @@ module RuboCop
       register_cop :LiteralAssignmentInCondition, "#{__dir__}/lint/literal_assignment_in_condition"
       register_cop :LiteralInInterpolation, "#{__dir__}/lint/literal_in_interpolation"
       register_cop :Loop, "#{__dir__}/lint/loop"
+      register_cop :MisplacedMagicComment, "#{__dir__}/lint/misplaced_magic_comment"
       register_cop :MissingCopEnableDirective, "#{__dir__}/lint/missing_cop_enable_directive"
       register_cop :MissingSuper, "#{__dir__}/lint/missing_super"
       register_cop :MixedCaseRange, "#{__dir__}/lint/mixed_case_range"
@@ -128,6 +130,7 @@ module RuboCop
       register_cop :ShadowedException, "#{__dir__}/lint/shadowed_exception"
       register_cop :ShadowingOuterLocalVariable, "#{__dir__}/lint/shadowing_outer_local_variable"
       register_cop :StructNewOverride, "#{__dir__}/lint/struct_new_override"
+      register_cop :SuperArgumentMismatch, "#{__dir__}/lint/super_argument_mismatch"
       register_cop :SuppressedException, "#{__dir__}/lint/suppressed_exception"
       register_cop :SuppressedExceptionInNumberConversion, "#{__dir__}/lint/suppressed_exception_in_number_conversion"
       register_cop :SymbolConversion, "#{__dir__}/lint/symbol_conversion"

data/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -49,7 +49,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def complexity_score_for(node)
           case node.type
           when :case
@@ -74,7 +74,6 @@ module RuboCop
             super
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         def simple_in_pattern?(in_pattern_node)
           # `in_pattern_node.children[1]` is the guard (`if`/`unless`), or `nil`.

data/lib/rubocop/cop/migration/department_name.rb

@@ -2,7 +2,7 @@
 
 # Lint/RedundantCopDisableDirective needs to be disabled so as
 # to be able to provide examples of rubocop:disable comments.
-# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable-next Lint/RedundantCopDisableDirective -- the examples below read as real directives
 module RuboCop
   module Cop
     module Migration
@@ -85,4 +85,3 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/RedundantCopDisableDirective

data/lib/rubocop/cop/mixin/alignment.rb

@@ -66,7 +66,7 @@ module RuboCop
       end
 
       # @deprecated Use processed_source.line_with_comment?(line)
-      def end_of_line_comment(line) # rubocop:disable Naming/PredicateMethod
+      def end_of_line_comment(line) # rubocop:disable Naming/PredicateMethod -- a deprecated shim kept under its original name
         warn Rainbow(<<~WARNING).yellow, uplevel: 1
           `end_of_line_comment` is deprecated. Use `processed_source.line_with_comment?` instead.
         WARNING

data/lib/rubocop/cop/mixin/annotation_comment.rb

@@ -45,7 +45,7 @@ module RuboCop
         match.captures
       end
 
-      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Style/MutableConstant
+      KEYWORDS_REGEX_CACHE = {} # rubocop:disable Style/MutableConstant -- a cache, written to at runtime
       private_constant :KEYWORDS_REGEX_CACHE
 
       def regex

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -64,7 +64,7 @@ module RuboCop
       # Returns the end line of a node, which might be a comment and not part of the AST
       # End line is considered either the line at which another node starts, or
       # the line at which the parent node ends.
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def find_end_line(node)
         if node.if_type?
           if node.else?
@@ -89,7 +89,6 @@ module RuboCop
           end
         end || node.loc.end.line
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/rubocop/cop/mixin/configurable_enforced_style.rb

@@ -25,7 +25,7 @@ module RuboCop
       end
       private_constant :SYMBOL_TO_STRING_CACHE
 
-      # rubocop:disable Metrics
+      # rubocop:disable-next Metrics
       def style_detected(detected)
         return if no_acceptable_style?
 
@@ -51,7 +51,6 @@ module RuboCop
           config_to_allow_offenses[style_parameter_name] = updated_list.first
         end
       end
-      # rubocop:enable Metrics
 
       def no_acceptable_style?
         config_to_allow_offenses['Enabled'] == false

data/lib/rubocop/cop/mixin/hash_alignment_styles.rb

@@ -55,7 +55,7 @@ module RuboCop
       # Common functionality for checking alignment of hash values.
       module ValueAlignment
         def checkable_layout?(node)
-          !node.pairs_on_same_line? && !node.mixed_delimiters?
+          !node.pairs_on_same_line? && !node.mixed_delimiters? && alignable_values?(node)
         end
 
         def deltas(first_pair, current_pair)
@@ -68,6 +68,16 @@ module RuboCop
 
         private
 
+        def alignable_values?(node)
+          return false if node.pairs.first.value_omission?
+
+          node.pairs.none? { |pair| value_on_later_line?(pair) }
+        end
+
+        def value_on_later_line?(pair)
+          pair.value && pair.key.last_line != pair.value.first_line
+        end
+
         def separator_delta(first_pair, current_pair, key_delta)
           if current_pair.hash_rocket?
             hash_rocket_delta(first_pair, current_pair) - key_delta

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -87,13 +87,17 @@ module RuboCop
       def ignore_mixed_hash_shorthand_syntax?(hash_node)
         target_ruby_version <= 3.0 ||
           !%w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
-          !hash_node.hash_type?
+          !hash_node.hash_type? || hash_rockets_enforced?(hash_node)
       end
 
       def ignore_hash_shorthand_syntax?(pair_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
           %w[consistent either_consistent].include?(enforced_shorthand_syntax) ||
-          !pair_node.parent.hash_type?
+          !pair_node.parent.hash_type? || hash_rockets_enforced?(pair_node.parent)
+      end
+
+      def hash_rockets_enforced?(hash_node)
+        style == :hash_rockets || force_hash_rockets?(hash_node.pairs)
       end
 
       def enforced_shorthand_syntax
@@ -117,7 +121,7 @@ module RuboCop
           use_modifier_form_without_parenthesized_method_call?(method_dispatch_node)
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def def_node_that_require_parentheses(node)
         last_pair = node.parent.pairs.last
         return unless last_pair.key.source == last_pair.value.source
@@ -131,7 +135,6 @@ module RuboCop
 
         DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def find_ancestor_method_dispatch_node(node)
         return unless (ancestor = node.parent.parent)

data/lib/rubocop/cop/mixin/hash_subset.rb

@@ -5,7 +5,7 @@ module RuboCop
     # Common functionality for Style/HashExcept and Style/HashSlice cops.
     # It registers an offense on methods with blocks that are equivalent
     # to Hash#except or Hash#slice.
-    # rubocop:disable Metrics/ModuleLength
+    # rubocop:disable-next Metrics/ModuleLength
     module HashSubset
       include RangeHelp
       extend NodePattern::Macros
@@ -206,6 +206,5 @@ module RuboCop
         range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
       end
     end
-    # rubocop:enable Metrics/ModuleLength
   end
 end

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -38,7 +38,7 @@ module RuboCop
          (block (send _ :each_with_object (hash)) ...)}
       PATTERN
 
-      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler
+      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler, InternalAffairs/ItblockHandler -- the patterns matched here all name their block parameters
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end