rubocop 1.67.0 → 1.73.0

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/numblock_handler.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module InternalAffairs
-      # Checks for missing `numblock handlers. The blocks with numbered
+      # Checks for missing `numblock` handlers. The blocks with numbered
       # arguments introduced in Ruby 2.7 are parsed with a node type of
       # `numblock` instead of block. Cops that define `block` handlers
       # need to define `numblock` handlers or disable this cope for them.

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/operator_keyword.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Enforces the use of `node.operator_keyword?` instead of `node.and_type? || node.or_type?`.
+      #
+      # @example
+      #   # bad
+      #   node.and_type? || node.or_type?
+      #   node.or_type? || node.and_type?
+      #
+      #   # good
+      #   node.operator_keyword?
+      #
+      class OperatorKeyword < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s`.'
+        PREFERRED_METHOD = 'operator_keyword?'
+
+        # @!method and_or_type(node)
+        def_node_matcher :and_or_type, <<~PATTERN
+          {
+            (or $(send _node :and_type?) $(send _node :or_type?))
+            (or $(send _node :or_type?) $(send _node :and_type?))
+            (or
+              (or _ $(send _node :and_type?)) $(send _node :or_type?))
+            (or
+              (or _ $(send _node :or_type?)) $(send _node :and_type?))
+          }
+        PATTERN
+
+        def on_or(node)
+          return unless (lhs, rhs = and_or_type(node))
+
+          begin_range = lhs.receiver&.source_range || lhs.loc.selector
+          offense = begin_range.join(rhs.source_range.end)
+          prefer = lhs.receiver ? "#{lhs.receiver.source}.#{PREFERRED_METHOD}" : PREFERRED_METHOD
+
+          add_offense(offense, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(offense, prefer)
+          end
+        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_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/style_detected_api_use.rb

@@ -50,8 +50,6 @@ module RuboCop
       #   end
       #
       class StyleDetectedApiUse < Base
-        include RangeHelp
-
         MSG_FOR_POSITIVE_WITHOUT_NEGATIVE =
           '`correct_style_detected` method called without ' \
           'calling a negative `*_style_detected` method.'

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_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'
 require_relative 'internal_affairs/redundant_described_class_as_subject'
@@ -31,19 +37,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,8 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Here we check if 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
@@ -142,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/array_alignment.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Layout
-      # Here we check if the elements of a multi-line array literal are
+      # Check 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

@@ -40,7 +40,6 @@ module RuboCop
       #
       class BeginEndAlignment < Base
         include EndKeywordAlignment
-        include RangeHelp
         extend AutoCorrector
 
         MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'

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
@@ -127,7 +129,6 @@ module RuboCop
                              start_loc,
                              end_loc,
                              do_source_line_column)
-
           error_source_line_column = if style == :start_of_block
                                        do_source_line_column
                                      else
@@ -189,7 +190,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 while node.op_asgn_type? || node.masgn_type?
+          node = node.lhs while node.type?(:op_asgn, :masgn)
           node
         end
 

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/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)

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

@@ -49,7 +49,7 @@ module RuboCop
         end
 
         def on_rescue(node)
-          return unless node.loc.respond_to?(:else) && node.loc.else
+          return unless node.loc?(:else)
 
           check_alignment(base_range_of_rescue(node), node.loc.else)
         end
@@ -92,7 +92,7 @@ module RuboCop
           case parent.type
           when :def, :defs then base_for_method_definition(parent)
           when :kwbegin then parent.loc.begin
-          when :block
+          when :block, :numblock
             assignment_node = assignment_node(parent)
             if same_line?(parent, assignment_node)
               assignment_node.source_range

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

@@ -189,7 +189,7 @@ module RuboCop
         end
 
         def offense_location(node)
-          if node.loc.respond_to?(:end) && node.loc.end
+          if node.loc?(:end)
             node.loc.end
           else
             node
@@ -200,7 +200,7 @@ module RuboCop
           parent = node.parent
           return false unless parent
 
-          parent.begin_type? && parent.single_line?
+          parent.begin_type? && same_line?(node, node.right_sibling)
         end
 
         # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`: