rubocop 1.69.2 → 1.75.1

data/lib/rubocop/cop/style/arguments_forwarding.rb

@@ -31,6 +31,20 @@ module RuboCop
       #
       # This cop handles not only method forwarding but also forwarding to `super`.
       #
+      # [NOTE]
+      # ====
+      # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
+      # no offense will be registered until Ruby 3.4:
+      #
+      # [source,ruby]
+      # ----
+      # def foo(&block)
+      #   # Using an anonymous block would be a syntax error on Ruby 3.3.0
+      #   block_method { bar(&block) }
+      # end
+      # ----
+      # ====
+      #
       # @example
       #   # bad
       #   def foo(*args, &block)
@@ -148,7 +162,7 @@ module RuboCop
 
           restarg, kwrestarg, blockarg = extract_forwardable_args(node.arguments)
           forwardable_args = redundant_forwardable_named_args(restarg, kwrestarg, blockarg)
-          send_nodes = node.each_descendant(:send, :csend, :super, :yield).to_a
+          send_nodes = node.each_descendant(:call, :super, :yield).to_a
 
           send_classifications = classify_send_nodes(
             node, send_nodes, non_splat_or_block_pass_lvar_references(node.body), forwardable_args
@@ -191,9 +205,7 @@ module RuboCop
 
           send_classifications.each do |send_node, c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
             if !forward_rest && !forward_kwrest && c != :all_anonymous
-              # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
-              # in Ruby 3.3.0.
-              if outside_block?(forward_block_arg)
+              if allow_anonymous_forwarding_in_block?(forward_block_arg)
                 register_forward_block_arg_offense(!forward_rest, node.arguments, block_arg)
                 register_forward_block_arg_offense(!forward_rest, send_node, forward_block_arg)
               end
@@ -214,24 +226,22 @@ module RuboCop
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def add_post_ruby_32_offenses(def_node, send_classifications, forwardable_args)
           return unless use_anonymous_forwarding?
-          return if send_inside_block?(send_classifications)
+          return unless all_forwarding_offenses_correctable?(send_classifications)
 
           rest_arg, kwrest_arg, block_arg = *forwardable_args
 
           send_classifications.each do |send_node, _c, forward_rest, forward_kwrest, forward_block_arg| # rubocop:disable Layout/LineLength
-            if outside_block?(forward_rest)
+            if allow_anonymous_forwarding_in_block?(forward_rest)
               register_forward_args_offense(def_node.arguments, rest_arg)
               register_forward_args_offense(send_node, forward_rest)
             end
 
-            if outside_block?(forward_kwrest)
+            if allow_anonymous_forwarding_in_block?(forward_kwrest)
               register_forward_kwargs_offense(!forward_rest, def_node.arguments, kwrest_arg)
               register_forward_kwargs_offense(!forward_rest, send_node, forward_kwrest)
             end
 
-            # Prevents `anonymous block parameter is also used within block (SyntaxError)` occurs
-            # in Ruby 3.3.0.
-            if outside_block?(forward_block_arg)
+            if allow_anonymous_forwarding_in_block?(forward_block_arg)
               register_forward_block_arg_offense(!forward_rest, def_node.arguments, block_arg)
               register_forward_block_arg_offense(!forward_rest, send_node, forward_block_arg)
             end
@@ -293,10 +303,25 @@ module RuboCop
           redundant_arg_names.include?(arg.source) ? arg : nil
         end
 
-        def outside_block?(node)
+        # Checks if forwarding is uses both in blocks and outside of blocks.
+        # On Ruby 3.3.0, anonymous block forwarding in blocks can be is a syntax
+        # error, so we only want to register an offense if we can change all occurrences.
+        def all_forwarding_offenses_correctable?(send_classifications)
+          return true if target_ruby_version >= 3.4
+
+          send_classifications.none? do |send_node, *|
+            send_node.each_ancestor(:any_block).any?
+          end
+        end
+
+        # Ruby 3.3.0 had a bug where accessing an anonymous block argument inside of a block
+        # was a syntax error in unambiguous cases: https://bugs.ruby-lang.org/issues/20090
+        # We disallow this also for earlier Ruby versions so that code is forwards compatible.
+        def allow_anonymous_forwarding_in_block?(node)
           return false unless node
+          return true if target_ruby_version >= 3.4
 
-          node.each_ancestor(:block, :numblock).none?
+          node.each_ancestor(:any_block).none?
         end
 
         def register_forward_args_offense(def_arguments_or_send, rest_arg_or_splat)
@@ -357,12 +382,6 @@ module RuboCop
           cop_config.fetch('UseAnonymousForwarding', false)
         end
 
-        def send_inside_block?(send_classifications)
-          send_classifications.any? do |send_node, *|
-            send_node.each_ancestor(:block, :numblock).any?
-          end
-        end
-
         def add_parens_if_missing(node, corrector)
           return if parentheses?(node)
           return if node.send_type? && node.method?(:[])
@@ -511,7 +530,7 @@ module RuboCop
           end
 
           def additional_kwargs?
-            @def_node.arguments.any? { |a| a.kwarg_type? || a.kwoptarg_type? }
+            @def_node.arguments.any? { |a| a.type?(:kwarg, :kwoptarg) }
           end
 
           def forward_additional_kwargs?
@@ -540,10 +559,7 @@ module RuboCop
         end
 
         def explicit_block_name?
-          block_forwarding_config = config.for_cop('Naming/BlockForwarding')
-          return false unless block_forwarding_config['Enabled']
-
-          block_forwarding_config['EnforcedStyle'] == 'explicit'
+          config.for_enabled_cop('Naming/BlockForwarding')['EnforcedStyle'] == 'explicit'
         end
       end
     end

data/lib/rubocop/cop/style/array_first_last.rb

@@ -42,14 +42,30 @@ module RuboCop
           return if node.parent && brace_method?(node.parent)
 
           preferred = (value.zero? ? 'first' : 'last')
-          add_offense(node.loc.selector, message: format(MSG, preferred: preferred)) do |corrector|
-            corrector.replace(node.loc.selector, ".#{preferred}")
+          offense_range = find_offense_range(node)
+
+          add_offense(offense_range, message: format(MSG, preferred: preferred)) do |corrector|
+            corrector.replace(offense_range, preferred_value(node, preferred))
           end
         end
         # rubocop:enable Metrics/AbcSize
+        alias on_csend on_send
 
         private
 
+        def preferred_value(node, value)
+          value = ".#{value}" unless node.loc.dot
+          value
+        end
+
+        def find_offense_range(node)
+          if node.loc.dot
+            node.loc.selector.join(node.source_range.end)
+          else
+            node.loc.selector
+          end
+        end
+
         def innermost_braces_node(node)
           node = node.receiver while node.receiver.send_type? && node.receiver.method?(:[])
           node

data/lib/rubocop/cop/style/array_intersect.rb

@@ -6,7 +6,8 @@ module RuboCop
       # In Ruby 3.1, `Array#intersect?` has been added.
       #
       # This cop identifies places where `(array1 & array2).any?`
-      # can be replaced by `array1.intersect?(array2)`.
+      # or `(array1.intersection(array2)).any?` can be replaced by
+      # `array1.intersect?(array2)`.
       #
       # The `array1.intersect?(array2)` method is faster than
       # `(array1 & array2).any?` and is more readable.
@@ -20,6 +21,10 @@ module RuboCop
       # [1].intersect?([1,2]) { |x| false } # => true
       # ----
       #
+      # NOTE: Although `Array#intersection` can take zero or multiple arguments,
+      # only cases where exactly one argument is provided can be replaced with
+      # `Array#intersect?` and are handled by this cop.
+      #
       # @safety
       #   This cop cannot guarantee that `array1` and `array2` are
       #   actually arrays while method `intersect?` is for arrays only.
@@ -30,6 +35,11 @@ module RuboCop
       #   (array1 & array2).empty?
       #   (array1 & array2).none?
       #
+      #   # bad
+      #   array1.intersection(array2).any?
+      #   array1.intersection(array2).empty?
+      #   array1.intersection(array2).none?
+      #
       #   # good
       #   array1.intersect?(array2)
       #   !array1.intersect?(array2)
@@ -53,65 +63,66 @@ module RuboCop
 
         minimum_target_ruby_version 3.1
 
-        # @!method regular_bad_intersection_check?(node)
-        def_node_matcher :regular_bad_intersection_check?, <<~PATTERN
-          (send
-            (begin
-              (send $(...) :& $(...))
-            ) ${:any? :empty? :none?}
-          )
-        PATTERN
+        PREDICATES = %i[any? empty? none?].to_set.freeze
+        ACTIVE_SUPPORT_PREDICATES = (PREDICATES + %i[present? blank?]).freeze
 
-        # @!method active_support_bad_intersection_check?(node)
-        def_node_matcher :active_support_bad_intersection_check?, <<~PATTERN
-          (send
-            (begin
-              (send $(...) :& $(...))
-            ) ${:present? :any? :blank? :empty? :none?}
+        # @!method bad_intersection_check?(node, predicates)
+        def_node_matcher :bad_intersection_check?, <<~PATTERN
+          (call
+            {
+              (begin (send $_ :& $_))
+              (call $_ :intersection $_)
+            }
+            $%1
           )
         PATTERN
 
-        MSG = 'Use `%<negated>s%<receiver>s.intersect?(%<argument>s)` ' \
-              'instead of `(%<receiver>s & %<argument>s).%<method_name>s`.'
+        MSG = 'Use `%<negated>s%<receiver>s%<dot>sintersect?(%<argument>s)` ' \
+              'instead of `%<existing>s`.'
         STRAIGHT_METHODS = %i[present? any?].freeze
         NEGATED_METHODS = %i[blank? empty? none?].freeze
         RESTRICT_ON_SEND = (STRAIGHT_METHODS + NEGATED_METHODS).freeze
 
         def on_send(node)
           return if node.block_literal?
-          return unless (receiver, argument, method_name = bad_intersection_check?(node))
+          return unless (receiver, argument, method_name = bad_intersection?(node))
 
-          message = message(receiver.source, argument.source, method_name)
+          dot = node.loc.dot.source
+          message = message(receiver.source, argument.source, method_name, dot, node.source)
 
           add_offense(node, message: message) do |corrector|
             bang = straight?(method_name) ? '' : '!'
 
-            corrector.replace(node, "#{bang}#{receiver.source}.intersect?(#{argument.source})")
+            corrector.replace(node, "#{bang}#{receiver.source}#{dot}intersect?(#{argument.source})")
           end
         end
+        alias on_csend on_send
 
         private
 
-        def bad_intersection_check?(node)
-          if active_support_extensions_enabled?
-            active_support_bad_intersection_check?(node)
-          else
-            regular_bad_intersection_check?(node)
-          end
+        def bad_intersection?(node)
+          predicates = if active_support_extensions_enabled?
+                         ACTIVE_SUPPORT_PREDICATES
+                       else
+                         PREDICATES
+                       end
+
+          bad_intersection_check?(node, predicates)
         end
 
         def straight?(method_name)
           STRAIGHT_METHODS.include?(method_name.to_sym)
         end
 
-        def message(receiver, argument, method_name)
+        def message(receiver, argument, method_name, dot, existing)
           negated = straight?(method_name) ? '' : '!'
           format(
             MSG,
             negated: negated,
             receiver: receiver,
             argument: argument,
-            method_name: method_name
+            dot: dot,
+            existing: existing
           )
         end
       end

data/lib/rubocop/cop/style/block_delimiters.rb

@@ -195,6 +195,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         def on_block(node)
           return if ignored_node?(node)
@@ -207,6 +208,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -346,9 +348,9 @@ module RuboCop
         # rubocop:disable Metrics/CyclomaticComplexity
         def get_blocks(node, &block)
           case node.type
-          when :block, :numblock
+          when :block, :numblock, :itblock
             yield node
-          when :send
+          when :send, :csend
             # When a method has an argument which is another method with a block,
             # that block needs braces, otherwise a syntax error will be introduced
             # for subsequent arguments.
@@ -369,9 +371,8 @@ module RuboCop
         end
         # rubocop:enable Metrics/CyclomaticComplexity
 
-        # rubocop:disable Metrics/CyclomaticComplexity
         def proper_block_style?(node)
-          return true if require_braces?(node) || require_do_end?(node)
+          return true if require_do_end?(node)
           return special_method_proper_block_style?(node) if special_method?(node.method_name)
 
           case style
@@ -381,15 +382,6 @@ module RuboCop
           when :always_braces       then braces_style?(node)
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity
-
-        def require_braces?(node)
-          return false unless node.braces?
-
-          node.each_ancestor(:send).any? do |send|
-            send.arithmetic_operation? && node.source_range.end_pos < send.loc.selector.begin_pos
-          end
-        end
 
         def require_do_end?(node)
           return false if node.braces? || node.multiline?
@@ -483,18 +475,14 @@ module RuboCop
         end
 
         def return_value_of_scope?(node)
-          return false unless node.parent
-
-          conditional?(node.parent) || array_or_range?(node.parent) ||
-            node.parent.children.last == node
-        end
+          return false unless (parent = node.parent)
 
-        def conditional?(node)
-          node.if_type? || node.operator_keyword?
+          parent.conditional? || parent.operator_keyword? || array_or_range?(parent) ||
+            parent.children.last == node
         end
 
         def array_or_range?(node)
-          node.array_type? || node.range_type?
+          node.type?(:array, :range)
         end
 
         def begin_required?(block_node)

data/lib/rubocop/cop/style/class_and_module_children.rb

@@ -3,14 +3,26 @@
 module RuboCop
   module Cop
     module Style
-      # Checks the style of children definitions at classes and
-      # modules. Basically there are two different styles:
+      # Checks that namespaced classes and modules are defined with a consistent style.
+      #
+      # With `nested` style, classes and modules should be defined separately (one constant
+      # on each line, without `::`). With `compact` style, classes and modules should be
+      # defined with fully qualified names (using `::` for namespaces).
+      #
+      # NOTE: The style chosen will affect `Module.nesting` for the class or module. Using
+      # `nested` style will result in each level being added, whereas `compact` style will
+      # only include the fully qualified class or module name.
+      #
+      # By default, `EnforcedStyle` applies to both classes and modules. If desired, separate
+      # styles can be defined for classes and modules by using `EnforcedStyleForClasses` and
+      # `EnforcedStyleForModules` respectively. If not set, or set to nil, the `EnforcedStyle`
+      # value will be used.
       #
       # @safety
       #   Autocorrection is unsafe.
       #
-      #   Moving from compact to nested children requires knowledge of whether the
-      #   outer parent is a module or a class. Moving from nested to compact requires
+      #   Moving from `compact` to `nested` children requires knowledge of whether the
+      #   outer parent is a module or a class. Moving from `nested` to `compact` requires
       #   verification that the outer parent is defined elsewhere. RuboCop does not
       #   have the knowledge to perform either operation safely and thus requires
       #   manual oversight.
@@ -42,16 +54,18 @@ module RuboCop
         def on_class(node)
           return if node.parent_class && style != :nested
 
-          check_style(node, node.body)
+          check_style(node, node.body, style_for_classes)
         end
 
         def on_module(node)
-          check_style(node, node.body)
+          check_style(node, node.body, style_for_modules)
         end
 
         private
 
         def nest_or_compact(corrector, node)
+          style = node.class_type? ? style_for_classes : style_for_modules
+
           if style == :nested
             nest_definition(corrector, node)
           else
@@ -126,9 +140,12 @@ module RuboCop
         end
 
         def unindent(corrector, node)
-          return if node.body.children.last.nil?
+          return unless node.body.children.last
+
+          last_child_leading_spaces = leading_spaces(node.body.children.last)
+          return if leading_spaces(node).size == last_child_leading_spaces.size
 
-          column_delta = configured_indentation_width - leading_spaces(node.body.children.last).size
+          column_delta = configured_indentation_width - last_child_leading_spaces.size
           return if column_delta.zero?
 
           AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
@@ -138,7 +155,7 @@ module RuboCop
           node.source_range.source_line[/\A\s*/]
         end
 
-        def check_style(node, body)
+        def check_style(node, body, style)
           return if node.identifier.namespace&.cbase_type?
 
           if style == :nested
@@ -158,7 +175,7 @@ module RuboCop
 
         def check_compact_style(node, body)
           parent = node.parent
-          return if parent&.class_type? || parent&.module_type?
+          return if parent&.type?(:class, :module)
 
           return unless needs_compacting?(body)
 
@@ -180,6 +197,14 @@ module RuboCop
         def compact_node_name?(node)
           node.identifier.source.include?('::')
         end
+
+        def style_for_classes
+          cop_config['EnforcedStyleForClasses'] || style
+        end
+
+        def style_for_modules
+          cop_config['EnforcedStyleForModules'] || style
+        end
       end
     end
   end

data/lib/rubocop/cop/style/collection_methods.rb

@@ -49,14 +49,15 @@ module RuboCop
         def on_block(node)
           check_method_node(node.send_node)
         end
-
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_send(node)
           return unless implicit_block?(node)
 
           check_method_node(node)
         end
+        alias on_csend on_send
 
         private
 

data/lib/rubocop/cop/style/combinable_defined.rb

@@ -55,7 +55,7 @@ module RuboCop
         def defined_calls(nodes)
           nodes.filter_map do |defined_node|
             subject = defined_node.first_argument
-            subject if subject.const_type? || subject.call_type?
+            subject if subject.type?(:const, :call)
           end
         end
 

data/lib/rubocop/cop/style/combinable_loops.rb

@@ -80,6 +80,7 @@ module RuboCop
         # rubocop:enable Metrics/CyclomaticComplexity
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_for(node)
           return unless node.parent&.begin_type?
@@ -98,7 +99,7 @@ module RuboCop
         end
 
         def same_collection_looping_block?(node, sibling)
-          return false if sibling.nil? || (!sibling.block_type? && !sibling.numblock_type?)
+          return false if sibling.nil? || !sibling.any_block_type?
 
           sibling.method?(node.method_name) &&
             sibling.receiver == node.receiver &&
@@ -118,7 +119,7 @@ module RuboCop
 
         def correct_end_of_block(corrector, node)
           return unless node.left_sibling.respond_to?(:braces?)
-          return if node.right_sibling&.block_type? || node.right_sibling&.numblock_type?
+          return if node.right_sibling&.any_block_type?
 
           end_of_block = node.left_sibling.braces? ? '}' : ' end'
           corrector.remove(node.loc.end)

data/lib/rubocop/cop/style/commented_keyword.rb

@@ -9,8 +9,8 @@ module RuboCop
       # These keywords are: `class`, `module`, `def`, `begin`, `end`.
       #
       # Note that some comments
-      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
-      # and RBS::Inline annotation comments are allowed.
+      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`),
+      # RBS::Inline annotation, and Steep annotation (`steep:ignore`) are allowed.
       #
       # Autocorrection removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
@@ -57,9 +57,11 @@ module RuboCop
 
         REGEXP = /(?<keyword>\S+).*#/.freeze
 
-        SUBCLASS_DEFINITION = /\A\s*class\s+\w+\s*<\s*\w+/.freeze
+        SUBCLASS_DEFINITION = /\A\s*class\s+(\w|::)+\s*<\s*(\w|::)+/.freeze
         METHOD_DEFINITION = /\A\s*def\s/.freeze
 
+        STEEP_REGEXP = /#\ssteep:ignore(\s|\z)/.freeze
+
         def on_new_investigation
           processed_source.comments.each do |comment|
             next unless offensive?(comment) && (match = source_line(comment).match(REGEXP))
@@ -86,6 +88,7 @@ module RuboCop
         def offensive?(comment)
           line = source_line(comment)
           return false if rbs_inline_annotation?(line, comment)
+          return false if steep_annotation?(comment)
 
           KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
@@ -105,6 +108,10 @@ module RuboCop
             false
           end
         end
+
+        def steep_annotation?(comment)
+          comment.text.match?(STEEP_REGEXP)
+        end
       end
     end
   end

data/lib/rubocop/cop/style/comparable_between.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for logical comparison which can be replaced with `Comparable#between?`.
+      #
+      # NOTE: `Comparable#between?` is on average slightly slower than logical comparison,
+      # although the difference generally isn't observable. If you require maximum
+      # performance, consider using logical comparison.
+      #
+      # @example
+      #
+      #   # bad
+      #   x >= min && x <= max
+      #
+      #   # bad
+      #   x <= max && x >= min
+      #
+      #   # good
+      #   x.between?(min, max)
+      #
+      class ComparableBetween < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<prefer>s` over logical comparison.'
+
+        # @!method logical_comparison_between_by_min_first?(node)
+        def_node_matcher :logical_comparison_between_by_min_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :>= $_min | $_min :<= $_value})
+            (send
+              {$_value :<= $_max | $_max :>= $_value}))
+        PATTERN
+
+        # @!method logical_comparison_between_by_max_first?(node)
+        def_node_matcher :logical_comparison_between_by_max_first?, <<~PATTERN
+          (and
+            (send
+              {$_value :<= $_max | $_max :>= $_value})
+            (send
+              {$_value :>= $_min | $_min :<= $_value}))
+        PATTERN
+
+        def on_and(node)
+          logical_comparison_between_by_min_first?(node) do |*args|
+            min_and_value, max_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+
+          logical_comparison_between_by_max_first?(node) do |*args|
+            max_and_value, min_and_value = args.each_slice(2).to_a
+
+            register_offense(node, min_and_value, max_and_value)
+          end
+        end
+
+        private
+
+        def register_offense(node, min_and_value, max_and_value)
+          value = (min_and_value & max_and_value).first
+          min = min_and_value.find { _1 != value }
+          max = max_and_value.find { _1 != value }
+
+          prefer = "#{value.source}.between?(#{min.source}, #{max.source})"
+          add_offense(node, message: format(MSG, prefer: prefer)) do |corrector|
+            corrector.replace(node, prefer)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/concat_array_literals.rb

@@ -86,7 +86,7 @@ module RuboCop
 
         def percent_literals_includes_only_basic_literals?(node)
           node.arguments.select(&:percent_literal?).all? do |arg|
-            arg.children.all? { |child| child.str_type? || child.sym_type? }
+            arg.children.all? { |child| child.type?(:str, :sym) }
           end
         end
       end