rubocop 1.69.2 → 1.75.1

data/lib/rubocop/cop/internal_affairs/node_type_group.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks that node types are checked against their group when all types of a
+      # group are checked.
+      #
+      # @example
+      #   # bad
+      #   node.type?(:irange, :erange)
+      #
+      #   # good
+      #   node.range_type?
+      #
+      #   # bad
+      #   node.type?(:irange, :erange, :send, :csend)
+      #
+      #   # good
+      #   node.type?(:range, :call)
+      #
+      class NodeTypeGroup < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Use `:%<group>s` instead of individually listing group types.'
+
+        RESTRICT_ON_SEND = %i[type? each_ancestor each_child_node each_descendant each_node].freeze
+
+        def on_send(node)
+          return unless node.receiver
+
+          symbol_args = node.arguments.select(&:sym_type?)
+          return if symbol_args.none?
+
+          NodePatternGroups::NODE_GROUPS.each do |group_name, group_types|
+            next unless group_satisfied?(group_types, symbol_args)
+
+            offense_range = arguments_range(node)
+            add_offense(offense_range, message: format(MSG, group: group_name)) do |corrector|
+              autocorrect(corrector, node, symbol_args, group_name, group_types)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def arguments_range(node)
+          range_between(
+            node.first_argument.source_range.begin_pos,
+            node.last_argument.source_range.end_pos
+          )
+        end
+
+        def group_satisfied?(group_types, symbol_args)
+          group_types.all? { |type| symbol_args.any? { |arg| arg.value == type } }
+        end
+
+        def autocorrect(corrector, node, symbol_args, group_name, group_types)
+          if node.method?(:type?) && node.arguments.count == group_types.count
+            autocorrect_to_explicit_predicate(corrector, node, group_name)
+          else
+            autocorrect_keep_method(corrector, symbol_args, group_name, group_types)
+          end
+        end
+
+        def autocorrect_to_explicit_predicate(corrector, node, group_name)
+          corrector.replace(node.selector, "#{group_name}_type?")
+          corrector.remove(arguments_range(node))
+        end
+
+        def autocorrect_keep_method(corrector, symbol_args, group_name, group_types)
+          first_replaced = false
+          symbol_args.each do |arg|
+            next unless group_types.include?(arg.value)
+
+            if first_replaced
+              range = range_with_surrounding_space(arg.source_range)
+              range = range_with_surrounding_comma(range, :left)
+              corrector.remove(range)
+            else
+              first_replaced = true
+              corrector.replace(arg, ":#{group_name}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/node_type_multiple_predicates.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Use `node.type?(:foo, :bar)` instead of `node.foo_type? || node.bar_type?`,
+      # and `!node.type?(:foo, :bar)` instead of `!node.foo_type? && !node.bar_type?`.
+      #
+      # @example
+      #
+      #   # bad
+      #   node.str_type? || node.sym_type?
+      #
+      #   # good
+      #   node.type?(:str, :sym)
+      #
+      #   # bad
+      #   node.type?(:str, :sym) || node.boolean_type?
+      #
+      #   # good
+      #   node.type?(:str, :sym, :boolean)
+      #
+      #   # bad
+      #   !node.str_type? && !node.sym_type?
+      #
+      #   # good
+      #   !node.type?(:str, :sym)
+      #
+      #   # bad
+      #   !node.type?(:str, :sym) && !node.boolean_type?
+      #
+      #   # good
+      #   !node.type?(:str, :sym, :boolean)
+      #
+      class NodeTypeMultiplePredicates < Base
+        extend AutoCorrector
+
+        MSG_OR = 'Use `%<replacement>s` instead of checking for multiple node types.'
+        MSG_AND = 'Use `%<replacement>s` instead of checking against multiple node types.'
+
+        # @!method one_of_node_types?(node)
+        def_node_matcher :one_of_node_types?, <<~PATTERN
+          (or $(call _receiver #type_predicate?) (call _receiver #type_predicate?))
+        PATTERN
+
+        # @!method or_another_type?(node)
+        def_node_matcher :or_another_type?, <<~PATTERN
+          (or {
+            $(call _receiver :type? sym+) (call _receiver #type_predicate?) |
+            (call _receiver #type_predicate?) $(call _receiver :type? sym+)
+          })
+        PATTERN
+
+        # @!method none_of_node_types?(node)
+        def_node_matcher :none_of_node_types?, <<~PATTERN
+          (and
+            (send $(call _receiver #type_predicate?) :!)
+            (send (call _receiver #type_predicate?) :!)
+          )
+        PATTERN
+
+        # @!method and_not_another_type?(node)
+        def_node_matcher :and_not_another_type?, <<~PATTERN
+          (and {
+            (send $(call _receiver :type? sym+) :!) (send (call _receiver #type_predicate?) :!) |
+            (send (call _receiver #type_predicate?) :!) (send $(call _receiver :type? sym+) :!)
+          })
+        PATTERN
+
+        def on_or(node)
+          return unless (send_node = one_of_node_types?(node) || or_another_type?(node))
+          return unless send_node.receiver
+
+          replacement = replacement(node, send_node)
+          add_offense(node, message: format(MSG_OR, replacement: replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        def on_and(node)
+          return unless (send_node = none_of_node_types?(node) || and_not_another_type?(node))
+          return unless send_node.receiver
+
+          replacement = "!#{replacement(node, send_node)}"
+
+          add_offense(node, message: format(MSG_AND, replacement: replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def type_predicate?(method_name)
+          method_name.end_with?('_type?')
+        end
+
+        def replacement(node, send_node)
+          send_node = send_node.children.first if send_node.method?(:!)
+
+          types = types(node)
+          receiver = send_node.receiver.source
+          dot = send_node.loc.dot.source
+
+          "#{receiver}#{dot}type?(:#{types.join(', :')})"
+        end
+
+        def types(node)
+          [types_in_branch(node.lhs), types_in_branch(node.rhs)]
+        end
+
+        def types_in_branch(branch)
+          branch = branch.children.first if branch.method?(:!)
+
+          if branch.method?(:type?)
+            branch.arguments.map(&:value)
+          elsif branch.method?(:defined_type?)
+            # `node.defined_type?` relates to `node.type == :defined?`
+            'defined?'
+          else
+            branch.method_name.to_s.delete_suffix('_type?')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/node_type_predicate.rb

@@ -21,16 +21,17 @@ module RuboCop
 
         # @!method node_type_check(node)
         def_node_matcher :node_type_check, <<~PATTERN
-          (send (send $_ :type) :== (sym $_))
+          (send (call _ :type) :== (sym $_))
         PATTERN
 
         def on_send(node)
-          node_type_check(node) do |receiver, node_type|
+          node_type_check(node) do |node_type|
             return unless Parser::Meta::NODE_TYPES.include?(node_type)
 
             message = format(MSG, type: node_type)
             add_offense(node, message: message) do |corrector|
-              range = node.source_range.with(begin_pos: receiver.source_range.end_pos + 1)
+              range = node.receiver.loc.selector.join(node.source_range.end)
+
               corrector.replace(range, "#{node_type}_type?")
             end
           end

data/lib/rubocop/cop/internal_affairs/on_send_without_on_csend.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Checks for cops that define `on_send` without define `on_csend`.
+      #
+      # Although in some cases it can be predetermined that safe navigation
+      # will never be used with the code checked by a specific cop, in general
+      # it is good practice to handle safe navigation methods if handling any
+      # `send` node.
+      #
+      # NOTE: It is expected to disable this cop for cops that check for method calls
+      # on receivers that cannot be nil (`self`, a literal, a constant), and
+      # method calls that will never have a receiver (ruby keywords like `raise`,
+      # macros like `attr_reader`, DSL methods, etc.), and other checks that wouldn't
+      # make sense to support safe navigation.
+      #
+      # @example
+      #   # bad
+      #   class MyCop < RuboCop::Cop:Base
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good - explicit method definition
+      #   class MyCop < RuboCop::Cop:Base
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #
+      #     def on_csend(node)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good - alias
+      #   class MyCop < RuboCop::Cop:Base
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #     alias on_csend on_send
+      #   end
+      #
+      #   # good - alias_method
+      #   class MyCop < RuboCop::Cop:Base
+      #     def on_send(node)
+      #       # ...
+      #     end
+      #     alias_method :on_csend, :on_send
+      #   end
+      class OnSendWithoutOnCSend < Base
+        RESTRICT_ON_SEND = %i[alias_method].freeze
+        MSG = 'Cop defines `on_send` but not `on_csend`.'
+
+        def on_new_investigation
+          @on_send_definition = nil
+          @on_csend_definition = nil
+        end
+
+        def on_investigation_end
+          return unless @on_send_definition && !@on_csend_definition
+
+          add_offense(@on_send_definition)
+        end
+
+        def on_def(node)
+          @on_send_definition = node if node.method?(:on_send)
+          @on_csend_definition = node if node.method?(:on_csend)
+        end
+
+        def on_alias(node)
+          @on_send_definition = node if node.new_identifier.value == :on_send
+          @on_csend_definition = node if node.new_identifier.value == :on_csend
+        end
+
+        def on_send(node) # rubocop:disable InternalAffairs/OnSendWithoutOnCSend
+          new_identifier = node.first_argument
+          return unless new_identifier.basic_literal?
+
+          new_identifier = new_identifier.value
+
+          @on_send_definition = node if new_identifier == :on_send
+          @on_csend_definition = node if new_identifier == :on_csend
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/plugin.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module InternalAffairs
+    # A Plugin for `InternalAffairs` department, which has internal cops.
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-internal_affairs',
+          version: Version::STRING,
+          homepage: 'https://github.com/rubocop/rubocop/tree/master/lib/rubocop/cop/internal_affairs',
+          description: 'A collection of RuboCop cops to check for internal affairs.'
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        require_relative '../internal_affairs'
+
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: Pathname.new(__dir__).join('../../../../config/internal_affairs.yml')
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/cop/internal_affairs/redundant_described_class_as_subject.rb

@@ -38,23 +38,24 @@ module RuboCop
 
           describe = find_describe_method_node(node)
 
-          unless (exist_config = describe.last_argument.source == ':config')
-            additional_message = ' and specify `:config` in `describe`'
-          end
+          should_append_config = describe && describe.last_argument.source != ':config'
+          additional_message = ' and specify `:config` in `describe`' if should_append_config
 
           message = format(MSG, additional_message: additional_message)
 
           add_offense(node, message: message) do |corrector|
             corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
 
-            corrector.insert_after(describe.last_argument, ', :config') unless exist_config
+            corrector.insert_after(describe.last_argument, ', :config') if should_append_config
           end
         end
 
         private
 
         def find_describe_method_node(block_node)
-          block_node.ancestors.find { |node| node.block_type? && node.method?(:describe) }.send_node
+          block_node.ancestors.find do |node|
+            node.block_type? && node.method?(:describe)
+          end&.send_node
         end
       end
     end

data/lib/rubocop/cop/internal_affairs/redundant_source_range.rb

@@ -47,7 +47,7 @@ module RuboCop
         # @!method redundant_source_range(node)
         def_node_matcher :redundant_source_range, <<~PATTERN
           {
-            (send $(send _ :source_range) :source)
+            (call $(call _ :source_range) :source)
             (send nil? :add_offense $(send _ :source_range) ...)
             (send _ {
               :replace :insert_before :insert_before_multi :insert_after :insert_after_multi
@@ -59,6 +59,7 @@ module RuboCop
 
         def on_send(node)
           return unless (source_range = redundant_source_range(node))
+          return unless source_range.receiver
           return if source_range.receiver.send_type? && source_range.receiver.method?(:buffer)
 
           selector = source_range.loc.selector
@@ -67,6 +68,7 @@ module RuboCop
             corrector.remove(source_range.loc.dot.join(selector))
           end
         end
+        alias on_csend on_send
       end
     end
   end

data/lib/rubocop/cop/internal_affairs/single_line_comparison.rb

@@ -34,8 +34,8 @@ module RuboCop
         # @!method single_line_comparison(node)
         def_node_matcher :single_line_comparison, <<~PATTERN
           {
-            (send (send $_receiver {:line :first_line}) {:== :!=} (send _receiver :last_line))
-            (send (send $_receiver :last_line) {:== :!=} (send _receiver {:line :first_line}))
+            (send (call $_receiver {:line :first_line}) {:== :!=} (call _receiver :last_line))
+            (send (call $_receiver :last_line) {:== :!=} (call _receiver {:line :first_line}))
           }
         PATTERN
 
@@ -43,7 +43,8 @@ module RuboCop
           return unless (receiver = single_line_comparison(node))
 
           bang = node.method?(:!=) ? '!' : ''
-          preferred = "#{bang}#{extract_receiver(receiver)}.single_line?"
+          dot = receiver.parent.loc.dot.source
+          preferred = "#{bang}#{extract_receiver(receiver)}#{dot}single_line?"
 
           add_offense(node, message: format(MSG, preferred: preferred)) do |corrector|
             corrector.replace(node, preferred)
@@ -53,7 +54,7 @@ module RuboCop
         private
 
         def extract_receiver(node)
-          node = node.receiver if node.send_type? && %i[loc source_range].include?(node.method_name)
+          node = node.receiver if node.call_type? && %i[loc source_range].include?(node.method_name)
           node.source
         end
       end

data/lib/rubocop/cop/internal_affairs/undefined_config.rb

@@ -17,7 +17,13 @@ module RuboCop
               'in `config/default.yml`.'
         CONFIG_PATH = find_file_upwards('config/default.yml', Dir.pwd)
         CONFIG = if CONFIG_PATH
-                   ConfigLoader.load_yaml_configuration(CONFIG_PATH)
+                   begin
+                     original_debug = ConfigLoader.debug
+                     ConfigLoader.debug = false
+                     ConfigLoader.load_yaml_configuration(CONFIG_PATH)
+                   ensure
+                     ConfigLoader.debug = original_debug
+                   end
                  else
                    {}
                  end

data/lib/rubocop/cop/internal_affairs.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 require_relative 'internal_affairs/cop_description'
+require_relative 'internal_affairs/cop_enabled'
 require_relative 'internal_affairs/create_empty_file'
 require_relative 'internal_affairs/empty_line_between_expect_offense_and_correction'
 require_relative 'internal_affairs/example_description'
 require_relative 'internal_affairs/example_heredoc_delimiter'
 require_relative 'internal_affairs/inherit_deprecated_cop_class'
 require_relative 'internal_affairs/lambda_or_proc'
+require_relative 'internal_affairs/location_exists'
 require_relative 'internal_affairs/location_expression'
 require_relative 'internal_affairs/location_line_equality_comparison'
 require_relative 'internal_affairs/method_name_end_with'
@@ -14,9 +16,13 @@ require_relative 'internal_affairs/method_name_equal'
 require_relative 'internal_affairs/node_destructuring'
 require_relative 'internal_affairs/node_first_or_last_argument'
 require_relative 'internal_affairs/node_matcher_directive'
+require_relative 'internal_affairs/node_pattern_groups'
+require_relative 'internal_affairs/node_type_group'
+require_relative 'internal_affairs/node_type_multiple_predicates'
 require_relative 'internal_affairs/node_type_predicate'
 require_relative 'internal_affairs/numblock_handler'
 require_relative 'internal_affairs/offense_location_keyword'
+require_relative 'internal_affairs/on_send_without_on_csend'
 require_relative 'internal_affairs/operator_keyword'
 require_relative 'internal_affairs/processed_source_buffer_name'
 require_relative 'internal_affairs/redundant_context_config_parameter'
@@ -32,19 +38,3 @@ require_relative 'internal_affairs/style_detected_api_use'
 require_relative 'internal_affairs/undefined_config'
 require_relative 'internal_affairs/useless_message_assertion'
 require_relative 'internal_affairs/useless_restrict_on_send'
-
-module RuboCop
-  # Patch in the InternalAffairs specific config values
-  module InternalAffairs
-    def self.inject!
-      path = File.join(ConfigLoader::RUBOCOP_HOME, 'config', 'internal_affairs.yml')
-      hash = ConfigLoader.load_yaml_configuration(path)
-      config = Config.new(hash, path)
-      puts "configuration from #{path}" if ConfigLoader.debug?
-      config = ConfigLoader.merge_with_default(config, path)
-      ConfigLoader.instance_variable_set(:@default_configuration, config)
-    end
-  end
-end
-
-RuboCop::InternalAffairs.inject!

data/lib/rubocop/cop/layout/access_modifier_indentation.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Layout
       # Bare access modifiers (those not applying to specific methods) should be
-      # indented as deep as method definitions, or as deep as the class/module
+      # indented as deep as method definitions, or as deep as the `class`/`module`
       # keyword, depending on configuration.
       #
       # @example EnforcedStyle: indent (default)

data/lib/rubocop/cop/layout/argument_alignment.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the arguments on a multi-line method definition are aligned.
+      # Check that the arguments on a multi-line method call are aligned.
       #
       # @example EnforcedStyle: with_first_argument (default)
       #   # good
@@ -141,16 +141,10 @@ module RuboCop
         end
 
         def enforce_hash_argument_with_separator?
-          return false unless hash_argument_config['Enabled']
-
           RuboCop::Cop::Layout::HashAlignment::SEPARATOR_ALIGNMENT_STYLES.any? do |style|
-            hash_argument_config[style]&.include?('separator')
+            config.for_enabled_cop('Layout/HashAlignment')[style]&.include?('separator')
           end
         end
-
-        def hash_argument_config
-          config.for_cop('Layout/HashAlignment')
-        end
       end
     end
   end

data/lib/rubocop/cop/layout/block_alignment.rb

@@ -73,6 +73,8 @@ module RuboCop
         # @!method block_end_align_target?(node, child)
         def_node_matcher :block_end_align_target?, <<~PATTERN
           {assignment?
+           def
+           defs
            splat
            and
            or
@@ -85,6 +87,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def style_parameter_name
           'EnforcedStyleAlignWith'
@@ -188,7 +191,7 @@ module RuboCop
         # In offense message, we want to show the assignment LHS rather than
         # the entire assignment.
         def find_lhs_node(node)
-          node = node.lhs while node.op_asgn_type? || node.masgn_type?
+          node = node.lhs while node.type?(:op_asgn, :masgn)
           node
         end
 

data/lib/rubocop/cop/layout/block_end_newline.rb

@@ -43,6 +43,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

data/lib/rubocop/cop/layout/class_structure.rb

@@ -3,23 +3,23 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks if the code style follows the ExpectedOrder configuration:
+      # Checks if the code style follows the `ExpectedOrder` configuration:
       #
       # `Categories` allows us to map macro names into a category.
       #
       # Consider an example of code style that covers the following order:
       #
-      # * Module inclusion (include, prepend, extend)
+      # * Module inclusion (`include`, `prepend`, `extend`)
       # * Constants
-      # * Associations (has_one, has_many)
-      # * Public attribute macros (attr_accessor, attr_writer, attr_reader)
-      # * Other macros (validates, validate)
+      # * Associations (`has_one`, `has_many`)
+      # * Public attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
+      # * Other macros (`validates`, `validate`)
       # * Public class methods
       # * Initializer
       # * Public instance methods
-      # * Protected attribute macros (attr_accessor, attr_writer, attr_reader)
+      # * Protected attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
       # * Protected instance methods
-      # * Private attribute macros (attr_accessor, attr_writer, attr_reader)
+      # * Private attribute macros (`attr_accessor`, `attr_writer`, `attr_reader`)
       # * Private instance methods
       #
       # You can configure the following order:
@@ -236,7 +236,7 @@ module RuboCop
 
           return [] unless class_def
 
-          if class_def.def_type? || class_def.send_type?
+          if class_def.type?(:def, :send)
             [class_def]
           else
             class_def.children.compact
@@ -289,7 +289,7 @@ module RuboCop
         def marked_as_private_constant?(node, name)
           return false unless node.method?(:private_constant)
 
-          node.arguments.any? { |arg| (arg.sym_type? || arg.str_type?) && arg.value == name }
+          node.arguments.any? { |arg| arg.type?(:sym, :str) && arg.value == name }
         end
 
         def end_position_for(node)

data/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb

@@ -155,10 +155,10 @@ module RuboCop
         end
 
         def all_elements_aligned?(elements)
-          elements.flat_map do |e|
-            if e.hash_type?
-              e.each_child_node.map { |child| child.loc.column }
-            else
+          if elements.first.hash_type?
+            elements.first.each_child_node.map { |child| child.loc.column }
+          else
+            elements.flat_map do |e|
               e.loc.column
             end
           end.uniq.count == 1

data/lib/rubocop/cop/layout/dot_position.rb

@@ -120,7 +120,7 @@ module RuboCop
         end
 
         def heredoc?(node)
-          (node.str_type? || node.dstr_type?) && node.heredoc?
+          node.type?(:str, :dstr) && node.heredoc?
         end
 
         def end_range(node)