rubocop 1.71.1 → 1.88.2

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
 

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

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,92 @@
+# 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)
+          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

@@ -76,7 +76,7 @@ module RuboCop
         end
 
         def on_send(node) # rubocop:disable InternalAffairs/OnSendWithoutOnCSend
-          new_identifier = node.first_argument
+          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_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/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,7 +52,7 @@ 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?(:[]=)) ||
+          return if !multiple_arguments?(node) || (node.call_type? && node.method?(:[]=)) ||
                     autocorrect_incompatible_with_other_cops?
 
           items = flattened_arguments(node)

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

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

@@ -18,6 +18,10 @@ module RuboCop
       # `either` (which is the default) : the `end` is allowed to be in either
       # location. The autocorrect will default to `start_of_line`.
       #
+      # When the `do` or `{` appears on a continuation line of multiline
+      # method arguments, the start of the line where the method is called
+      # is used as the alignment target instead of that continuation line.
+      #
       # @example EnforcedStyleAlignWith: either (default)
       #   # bad
       #
@@ -73,6 +77,7 @@ module RuboCop
         # @!method block_end_align_target?(node, child)
         def_node_matcher :block_end_align_target?, <<~PATTERN
           {assignment?
+           any_def
            splat
            and
            or
@@ -85,6 +90,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def style_parameter_name
           'EnforcedStyleAlignWith'
@@ -114,6 +120,7 @@ module RuboCop
           end_loc = block_node.loc.end
           return unless begins_its_line?(end_loc)
 
+          start_node = start_for_line_node(block_node) if style == :start_of_line
           start_loc = start_node.source_range
           return unless start_loc.column != end_loc.column || style == :start_of_block
 
@@ -194,23 +201,34 @@ module RuboCop
 
         def compute_do_source_line_column(node, end_loc)
           do_loc = node.loc.begin # Actually it's either do or {.
+          anchor_loc = do_line_anchor_loc(node, do_loc)
 
           # We've found that "end" is not aligned with the start node (which
           # can be a block, a variable assignment, etc). But we also allow
           # the "end" to be aligned with the start of the line where the "do"
           # is, which is a style some people use in multi-line chains of
           # blocks.
-          match = /\S.*/.match(do_loc.source_line)
+          match = /\S.*/.match(anchor_loc.source_line)
           indentation_of_do_line = match.begin(0)
-          return unless end_loc.column != indentation_of_do_line || style == :start_of_line
+          permitted_columns = permitted_do_line_columns(do_loc, indentation_of_do_line)
+          return if permitted_columns.include?(end_loc.column) && style != :start_of_line
 
           {
             source: match[0],
-            line: do_loc.line,
+            line: anchor_loc.line,
             column: indentation_of_do_line
           }
         end
 
+        # `end` aligned with an argument continuation line that holds the `do`
+        # was accepted before the anchor moved to the method dispatch line;
+        # keep accepting it so that such code does not become an offense.
+        def permitted_do_line_columns(do_loc, indentation_of_do_line)
+          columns = [indentation_of_do_line]
+          columns << (do_loc.source_line =~ /\S/) if style == :either
+          columns
+        end
+
         def loc_to_source_line_column(loc)
           {
             source: loc.source.lines.to_a.first.chomp,
@@ -237,7 +255,7 @@ module RuboCop
         def compute_start_col(ancestor_node, node)
           if style == :start_of_block
             do_loc = node.loc.begin
-            return do_loc.source_line =~ /\S/
+            return do_line_anchor_loc(node, do_loc).source_line =~ /\S/
           end
           (ancestor_node || node).source_range.column
         end
@@ -251,6 +269,44 @@ module RuboCop
 
           corrector.remove(range)
         end
+
+        # When the `do` or `{` is on a continuation line of multiline method
+        # arguments, the indentation of that line is not a meaningful
+        # alignment target; anchor on the method dispatch position instead.
+        def do_line_anchor_loc(node, do_loc)
+          if do_line_begins_inside_argument?(node, do_loc)
+            node.send_node.selector || node.send_node.source_range
+          else
+            do_loc
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def do_line_begins_inside_argument?(node, do_loc)
+          line_begin_pos = do_loc.begin_pos - do_loc.column
+          first_char_pos = line_begin_pos + (do_loc.source_line =~ /\S/)
+          return false unless inside_parentheses?(node, first_char_pos)
+
+          (node.send_node.arguments + node.arguments).any? do |argument|
+            argument.source_range.begin_pos <= first_char_pos &&
+              first_char_pos < argument.source_range.end_pos
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # The continuation line indentation is only an unmeaningful alignment target when
+        # it is dictated by an opening delimiter, i.e. the line begins inside `(` or `[`.
+        # For a bare argument list without parentheses the indentation is the author's
+        # deliberate alignment, so the anchor must not move to the method dispatch line.
+        def inside_parentheses?(node, pos)
+          preceding_tokens = processed_source.tokens.select do |token|
+            token.begin_pos >= node.source_range.begin_pos && token.begin_pos < pos
+          end
+          opens = preceding_tokens.count { |token| token.left_parens? || token.left_bracket? }
+          closes = preceding_tokens.count { |token| token.right_parens? || token.right_bracket? }
+
+          opens > closes
+        end
       end
     end
   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/case_indentation.rb

@@ -128,7 +128,9 @@ module RuboCop
           return if case_match_node.single_line?
           return if enforced_style_end? && end_and_last_conditional_same_line?(case_match_node)
 
-          case_match_node.each_in_pattern { |in_pattern_node| check_when(in_pattern_node, 'in') }
+          case_match_node.in_pattern_branches.each do |in_pattern_node|
+            check_when(in_pattern_node, 'in')
+          end
         end
 
         private