rubocop 1.69.2 → 1.73.1

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

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # Use node groups (`any_block`, `argument`, `boolean`, `call`, `numeric`, `range`)
+      # in node patterns instead of a union (`{ ... }`) of the member types of the group.
+      #
+      # @example
+      #   # bad
+      #   def_node_matcher :my_matcher, <<~PATTERN
+      #     {send csend}
+      #   PATTERN
+      #
+      #   # good
+      #   def_node_matcher :my_matcher, <<~PATTERN
+      #     call
+      #   PATTERN
+      #
+      class NodePatternGroups < Base
+        require_relative 'node_pattern_groups/ast_processor'
+        require_relative 'node_pattern_groups/ast_walker'
+
+        include RangeHelp
+        extend AutoCorrector
+
+        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],
+          argument: %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg forward_arg shadowarg],
+          boolean: %i[true false],
+          call: %i[send csend],
+          numeric: %i[int float rational complex],
+          range: %i[irange erange]
+        }.freeze
+
+        def on_new_investigation
+          @walker = ASTWalker.new
+        end
+
+        # When a Node Pattern matcher is defined, investigate the pattern string to search
+        # for node types that can be replaced with a node group (ie. `{send csend}` can be
+        # replaced with `call`).
+        #
+        # In order to deal with node patterns in an efficient and non-brittle way, we will
+        # parse the Node Pattern string given to this `send` node using
+        # `RuboCop::AST::NodePattern::Parser::WithMeta`. `WithMeta` is important! We need
+        # location information so that we can calculate the exact locations within the
+        # pattern to report and correct.
+        #
+        # The resulting AST is processed by `NodePatternGroups::ASTProccessor` which rewrites
+        # the AST slightly to handle node sequences (ie. `(send _ :foo ...)`). See the
+        # documentation of that class for more details.
+        #
+        # Then the processed AST is walked, and metadata is collected for node types that
+        # can be replaced with a node group.
+        #
+        # Finally, the metadata is used to register offenses and make corrections, using
+        # the location data captured earlier. The ranges captured while parsing the Node
+        # Pattern are offset using the string argument to this `send` node to ensure
+        # that offenses are registered at the correct location.
+        #
+        def on_send(node)
+          pattern_node = node.arguments[1]
+          return unless acceptable_heredoc?(pattern_node) || pattern_node.str_type?
+
+          process_pattern(pattern_node)
+          return if node_groups.nil?
+
+          apply_range_offsets(pattern_node)
+
+          node_groups.each_with_index do |group, index|
+            register_offense(group, index)
+          end
+        end
+
+        def after_send(_)
+          @walker.reset!
+        end
+
+        private
+
+        def node_groups
+          @walker.node_groups
+        end
+
+        # rubocop:disable InternalAffairs/RedundantSourceRange -- `node` here is a NodePatternNode
+        def register_offense(group, index)
+          replacement = replacement(group)
+          message = format(
+            MSG,
+            names: group.node_types.map { |node| node.source_range.source }.join('`, `'),
+            replacement: replacement
+          )
+
+          add_offense(group.offense_range, message: message) do |corrector|
+            # Only correct one group at a time to avoid clobbering.
+            # Other offenses will be corrected in the subsequent iterations of the
+            # correction loop.
+            next if index.positive?
+
+            if group.other_elements?
+              replace_types_with_node_group(corrector, group, replacement)
+            else
+              replace_union(corrector, group, replacement)
+            end
+          end
+        end
+
+        def replacement(group)
+          if group.sequence?
+            # If the original nodes were in a sequence (ie. wrapped in parentheses),
+            # use it to generate the resulting NodePattern syntax.
+            first_node_type = group.node_types.first
+            template = first_node_type.source_range.source
+            template.sub(first_node_type.child.to_s, group.name.to_s)
+          else
+            group.name
+          end
+        end
+        # rubocop:enable InternalAffairs/RedundantSourceRange
+
+        # When there are other elements in the union, remove the node types that can be replaced.
+        def replace_types_with_node_group(corrector, group, replacement)
+          ranges = group.ranges.map.with_index do |range, index|
+            # Collect whitespace and pipes preceding each element
+            range_for_full_union_element(range, index, group.pipe)
+          end
+
+          ranges.each { |range| corrector.remove(range) }
+
+          corrector.insert_before(ranges.first, replacement)
+        end
+
+        # If the union contains pipes, remove the pipe character as well.
+        # Unfortunately we don't get the location of the pipe in `loc` object, so we have
+        # to find it.
+        def range_for_full_union_element(range, index, pipe)
+          if index.positive?
+            range = if pipe
+                      range_with_preceding_pipe(range)
+                    else
+                      range_with_surrounding_space(range: range, side: :left, newlines: true)
+                    end
+          end
+
+          range
+        end
+
+        # Collect a preceding pipe and any whitespace left of the pipe
+        def range_with_preceding_pipe(range)
+          pos = range.begin_pos - 1
+
+          while pos
+            unless processed_source.buffer.source[pos].match?(/[\s|]/)
+              return range.with(begin_pos: pos + 1)
+            end
+
+            pos -= 1
+          end
+
+          range
+        end
+
+        # When there are no other elements, the entire union can be replaced
+        def replace_union(corrector, group, replacement)
+          corrector.replace(group.ranges.first, replacement)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        # Calculate the ranges for each node within the pattern string that will
+        # be replaced or removed. Takes the offset of the string node into account.
+        def apply_range_offsets(pattern_node)
+          range, offset = range_with_offset(pattern_node)
+
+          node_groups.each do |node_group|
+            node_group.ranges ||= []
+            node_group.offense_range = pattern_range(range, node_group.union, offset)
+
+            if node_group.other_elements?
+              node_group.node_types.each do |node_type|
+                node_group.ranges << pattern_range(range, node_type, offset)
+              end
+            else
+              node_group.ranges << node_group.offense_range
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def pattern_range(range, node, offset)
+          begin_pos = node.source_range.begin_pos
+          end_pos = node.source_range.end_pos
+          size = end_pos - begin_pos
+
+          range.adjust(begin_pos: begin_pos + offset).resize(size)
+        end
+
+        def range_with_offset(pattern_node)
+          if pattern_node.heredoc?
+            [pattern_node.loc.heredoc_body, 0]
+          else
+            [pattern_node.source_range, pattern_node.loc.begin.size]
+          end
+        end
+
+        # 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?
+        end
+
+        def process_pattern(pattern_node)
+          parser = RuboCop::AST::NodePattern::Parser::WithMeta.new
+          ast = parser.parse(pattern_value(pattern_node))
+          ast = ASTProcessor.new.process(ast)
+          @walker.walk(ast)
+        rescue RuboCop::AST::NodePattern::Invalid
+          # if the pattern is invalid, no offenses will be registered
+        end
+
+        def pattern_value(pattern_node)
+          pattern_node.heredoc? ? pattern_node.loc.heredoc_body.source : pattern_node.value
+        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_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,12 @@ 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'
@@ -32,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,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
@@ -188,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.lhs while node.op_asgn_type? || node.masgn_type?
+          node = node.lhs while node.type?(:op_asgn, :masgn)
           node
         end