rubocop 1.71.1 → 1.92.0

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,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)
@@ -81,6 +81,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

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
       #
@@ -64,6 +68,7 @@ module RuboCop
       #   end
       #
       class BlockAlignment < Base
+        include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
         extend AutoCorrector
@@ -73,6 +78,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 +91,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def style_parameter_name
           'EnforcedStyleAlignWith'
@@ -114,6 +121,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
 
@@ -147,6 +155,32 @@ module RuboCop
                           else
                             start_for_line_node(node)
                           end
+
+          if using_tabs? && (indentation = anchor_indentation(ancestor_node, node))
+            replace_end_indentation(corrector, node, indentation)
+          else
+            shift_end_to_start_col(corrector, ancestor_node, node)
+          end
+        end
+
+        def anchor_indentation(ancestor_node, node)
+          if style == :start_of_block
+            do_line_anchor_loc(node, node.loc.begin).source_line[/\A\s*/]
+          else
+            anchor_loc = (ancestor_node || node).source_range
+            anchor_loc.source_line[/\A\s*/] if begins_its_line?(anchor_loc)
+          end
+        end
+
+        def replace_end_indentation(corrector, node, indentation)
+          loc_end = node.loc.end
+          whitespace = range_between(loc_end.begin_pos - loc_end.column, loc_end.begin_pos)
+          return if whitespace.source == indentation
+
+          corrector.replace(whitespace, indentation)
+        end
+
+        def shift_end_to_start_col(corrector, ancestor_node, node)
           start_col = compute_start_col(ancestor_node, node)
           loc_end = node.loc.end
           delta = start_col - loc_end.column
@@ -194,23 +228,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 +282,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 +296,43 @@ 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-next 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
+
+        # 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
@@ -162,8 +164,12 @@ module RuboCop
           cop_config['IndentOneStep']
         end
 
+        # Under tabs one step is a single tab character, which counts as one column
+        # regardless of the configured indentation width.
         def indentation_width
-          indent_one_step? ? configured_indentation_width : 0
+          return 0 unless indent_one_step?
+
+          using_tabs? ? 1 : configured_indentation_width
         end
 
         def incorrect_style(when_node, branch_type)
@@ -174,8 +180,10 @@ module RuboCop
             detect_incorrect_style(when_node)
 
             whitespace = whitespace_range(when_node)
+            next unless whitespace.source.strip.empty?
 
-            corrector.replace(whitespace, replacement(when_node)) if whitespace.source.strip.empty?
+            indentation = replacement(when_node)
+            corrector.replace(whitespace, indentation) if indentation
           end
         end
 
@@ -191,10 +199,7 @@ module RuboCop
         end
 
         def base_column(case_node, base)
-          case base
-          when :case then case_node.location.keyword.column
-          when :end  then case_node.location.end.column
-          end
+          base_location(case_node, base)&.column
         end
 
         def whitespace_range(node)
@@ -205,13 +210,26 @@ module RuboCop
         end
 
         def replacement(node)
+          base_loc = configured_base_location(node)
+
+          return ' ' * (base_loc.column + indentation_width) unless using_tabs?
+          return unless begins_its_line?(base_loc)
+
+          base_loc.source_line[/\A\s*/] + ("\t" * indentation_width)
+        end
+
+        def configured_base_location(node)
           case_node = node.each_ancestor(:case, :case_match).first
           base_type = cop_config[style_parameter_name] == 'end' ? :end : :case
 
-          column = base_column(case_node, base_type)
-          column += indentation_width
+          base_location(case_node, base_type)
+        end
 
-          ' ' * column
+        def base_location(case_node, base)
+          case base
+          when :case then case_node.location.keyword
+          when :end  then case_node.location.end
+          end
         end
       end
     end