rubocop 1.71.1 → 1.92.1

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

@@ -8,16 +8,16 @@ module RuboCop
       # method.
       #
       # @example
-      #  # bad
-      #  def_node_matcher :foo?, <<~PATTERN
-      #    ...
-      #  PATTERN
+      #   # bad
+      #   def_node_matcher :foo?, <<~PATTERN
+      #     ...
+      #   PATTERN
       #
-      #  # good
-      #  # @!method foo?(node)
-      #  def_node_matcher :foo?, <<~PATTERN
-      #    ...
-      #  PATTERN
+      #   # good
+      #   # @!method foo?(node)
+      #   def_node_matcher :foo?, <<~PATTERN
+      #     ...
+      #   PATTERN
       #
       class NodeMatcherDirective < Base
         extend AutoCorrector
@@ -110,8 +110,8 @@ module RuboCop
         def directive_offense_type(directive, actual_name)
           return :missing_directive unless directive
 
-          return :wrong_scope if wrong_scope(directive, actual_name)
-          return :no_scope if no_scope(directive, actual_name)
+          return :wrong_scope if wrong_scope?(directive, actual_name)
+          return :no_scope if no_scope?(directive, actual_name)
 
           # The method directive being prefixed by 'self.' is always an offense.
           # The matched method_name does not contain the receiver but the
@@ -121,11 +121,11 @@ module RuboCop
           end
         end
 
-        def wrong_scope(directive, actual_name)
+        def wrong_scope?(directive, actual_name)
           !actual_name.start_with?('self.') && directive[:has_scope_directive]
         end
 
-        def no_scope(directive, actual_name)
+        def no_scope?(directive, actual_name)
           actual_name.start_with?('self.') && !directive[:has_scope_directive]
         end
 
@@ -146,7 +146,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/MethodLength
         def formatted_message(offense_type, directive, actual_name, method_name)
           case offense_type
           when :wrong_name
@@ -166,7 +166,6 @@ module RuboCop
             format(MSG, method: method_name)
           end
         end
-        # rubocop:enable Metrics/MethodLength
 
         def remove_receiver(current)
           current.delete_prefix('self.')
@@ -202,11 +201,8 @@ module RuboCop
         def add_newline?(node)
           # Determine if a blank line should be inserted before the new directive
           # in order to spread out pattern matchers
-          return false if node.sibling_index&.zero?
-          return false unless node.parent
-
-          prev_sibling = node.parent.child_nodes[node.sibling_index - 1]
-          return false unless prev_sibling && pattern_matcher?(prev_sibling)
+          prev_sibling = node.left_sibling
+          return false unless prev_sibling.is_a?(AST::Node) && pattern_matcher?(prev_sibling)
 
           node.loc.line == last_line(prev_sibling) + 1
         end

data/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_processor.rb

@@ -7,7 +7,7 @@ module RuboCop
         # AST Processor for NodePattern ASTs, for use with `InternalAffairs/NodePatternGroups`.
         #
         # Looks for sequences and subsequences where the first item is a `node_type` node,
-        # and converts them to `node_sequence` nodes (not a true `Rubocop::AST::NodePattern`
+        # and converts them to `node_sequence` nodes (not a true `RuboCop::AST::NodePattern`
         # node type).
         #
         # The resulting AST will be walked by `InternalAffairs::NodePatternGroups::ASTWalker`

data/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_walker.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # rubocop:disable InternalAffairs/RedundantSourceRange - node here is a `NodePattern::Node`
+      # rubocop:disable-next InternalAffairs/RedundantSourceRange -- node here is a `NodePattern::Node`
       class NodePatternGroups
         # Walks an AST that has been processed by `InternalAffairs::NodePatternGroups::Processor`
         # in order to find `node_type` and `node_sequence` nodes that can be replaced with a node
@@ -125,7 +125,6 @@ module RuboCop
           end
         end
       end
-      # rubocop:enable InternalAffairs/RedundantSourceRange
     end
   end
 end

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

@@ -27,7 +27,11 @@ module RuboCop
         MSG = 'Replace `%<names>s` in node pattern union with `%<replacement>s`.'
         RESTRICT_ON_SEND = %i[def_node_matcher def_node_search].freeze
         NODE_GROUPS = {
-          any_block: %i[block numblock],
+          any_block: %i[block numblock itblock],
+          any_def: %i[def defs],
+          any_match_pattern: %i[match_pattern match_pattern_p],
+          any_str: %i[str dstr xstr],
+          any_sym: %i[sym dsym],
           argument: %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg forward_arg shadowarg],
           boolean: %i[true false],
           call: %i[send csend],
@@ -208,7 +212,7 @@ module RuboCop
         # A heredoc can be a `dstr` without interpolation, but if there is interpolation
         # there'll be a `begin` node, in which case, we cannot evaluate the pattern.
         def acceptable_heredoc?(node)
-          node.type?(:str, :dstr) && node.heredoc? && node.each_child_node(:begin).none?
+          node.any_str_type? && node.heredoc? && node.each_child_node(:begin).none?
         end
 
         def process_pattern(pattern_node)

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

@@ -0,0 +1,85 @@
+# 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 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)
+          range = node.loc.selector.begin.join(node.source_range.end)
+
+          corrector.replace(range, "#{group_name}_type?")
+        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/on_send_without_on_csend.rb

@@ -75,8 +75,8 @@ module RuboCop
           @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
+        def on_send(node) # rubocop:disable InternalAffairs/OnSendWithoutOnCSend -- this cop is what enforces the rule, and does not apply to itself
+          return unless (new_identifier = node.first_argument)
           return unless new_identifier.basic_literal?
 
           new_identifier = new_identifier.value

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_context_config_parameter.rb

@@ -31,15 +31,9 @@ module RuboCop
             dup_arguments = arguments.dup
             dup_arguments.delete(config_node)
 
-            corrector.replace(offense_range(arguments), dup_arguments.map(&:source).join(', '))
+            corrector.replace(arguments_range(node), dup_arguments.map(&:source).join(', '))
           end
         end
-
-        private
-
-        def offense_range(arguments)
-          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
-        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_let_rubocop_config_new.rb

@@ -46,8 +46,7 @@ module RuboCop
 
         def on_block(node)
           return unless let_rubocop_config_new?(node)
-
-          describe = find_describe_method_node(node)
+          return unless (describe = find_describe_method_node(node))
 
           unless (exist_config = describe.last_argument.source == ':config')
             additional_message = ' and specify `:config` in `describe`'
@@ -65,7 +64,10 @@ module RuboCop
         private
 
         def find_describe_method_node(block_node)
-          block_node.ancestors.find { |node| node.block_type? && node.method?(:describe) }.send_node
+          describe = block_node.ancestors.find do |ancestor|
+            ancestor.block_type? && ancestor.method?(:describe)
+          end
+          describe&.send_node
         end
       end
     end

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

@@ -109,7 +109,7 @@ module RuboCop
         end
 
         def on_if(node)
-          traverse_condition(node.condition) do |cond|
+          node.condition.each_node(:send) do |cond|
             add_offense(cond, message: MSG_FOR_CONDITIONAL_USE) if style_detected_api_used?(cond)
           end
         end
@@ -134,12 +134,6 @@ module RuboCop
             no_acceptable_style_check(node) ||
             style_detected_check(node)
         end
-
-        def traverse_condition(condition, &block)
-          yield condition if condition.send_type?
-
-          condition.each_child_node { |child| traverse_condition(child, &block) }
-        end
       end
     end
   end

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

@@ -10,14 +10,25 @@ module RuboCop
         extend FileFinder
 
         ALLOWED_CONFIGURATIONS = %w[
-          Safe SafeAutoCorrect AutoCorrect Severity StyleGuide Details Reference Include Exclude
+          Safe SafeAutoCorrect AutoCorrect
+          Severity
+          StyleGuide
+          Details
+          Reference References
+          Include Exclude
         ].freeze
         RESTRICT_ON_SEND = %i[[] fetch].freeze
         MSG = '`%<name>s` is not defined in the configuration for `%<cop>s` ' \
               '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/useless_message_assertion.rb

@@ -7,11 +7,11 @@ module RuboCop
       #
       # @example
       #
-      #     # bad
-      #     expect(cop.messages).to eq([described_class::MSG])
+      #   # bad
+      #   expect(cop.messages).to eq([described_class::MSG])
       #
-      #     # good
-      #     expect(cop.messages).to eq(['Do not write bad code like that.'])
+      #   # good
+      #   expect(cop.messages).to eq(['Do not write bad code like that.'])
       #
       class UselessMessageAssertion < Base
         MSG = 'Do not specify cop behavior using `described_class::MSG`.'

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # Check for useless `RESTRICT_ON_SEND`.
+      # Checks for useless `RESTRICT_ON_SEND`.
       #
       # @example
       #   # bad

data/lib/rubocop/cop/internal_affairs.rb

@@ -7,7 +7,9 @@ require_relative 'internal_affairs/empty_line_between_expect_offense_and_correct
 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/itblock_handler'
 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'
@@ -16,6 +18,7 @@ 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'
@@ -36,19 +39,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/argument_alignment.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the arguments on a multi-line method call are aligned.
+      # Checks that the arguments on a multi-line method call are aligned.
       #
       # @example EnforcedStyle: with_first_argument (default)
       #   # good
@@ -52,8 +52,8 @@ module RuboCop
                            'following the first line of a multi-line method call.'
 
         def on_send(node)
-          return if !multiple_arguments?(node) || (node.send_type? && node.method?(:[]=)) ||
-                    autocorrect_incompatible_with_other_cops?
+          return if !multiple_arguments?(node) || (node.call_type? && node.method?(:[]=)) ||
+                    binary_operator_call?(node) || autocorrect_incompatible_with_other_cops?
 
           items = flattened_arguments(node)
 
@@ -64,6 +64,10 @@ module RuboCop
 
         private
 
+        def binary_operator_call?(node)
+          node.binary_operation? && !node.method?(:[]) && !node.loc.dot
+        end
+
         def autocorrect_incompatible_with_other_cops?
           with_first_argument_style? && enforce_hash_argument_with_separator?
         end
@@ -81,6 +85,8 @@ module RuboCop
           last_arg = node.last_argument
 
           if last_arg.hash_type? && !last_arg.braces?
+            return items if enforce_hash_argument_with_separator?
+
             items += last_arg.pairs
           else
             items << last_arg

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Check that the elements of a multi-line array literal are
+      # Checks that the elements of a multi-line array literal are
       # aligned.
       #
       # @example EnforcedStyle: with_first_element (default)

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

@@ -14,7 +14,7 @@ module RuboCop
       # `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
       # by default. On the other hand, `||= begin` that this cop targets tends to
       # align with the start of the line, it defaults to `EnforcedStyleAlignWith: start_of_line`.
-      # These style can be configured by each cop.
+      # These styles can be configured by each cop.
       #
       # @example EnforcedStyleAlignWith: start_of_line (default)
       #   # bad