rubocop 1.69.2 → 1.75.2

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

@@ -36,14 +36,13 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_send(node)
           return if ignored_node?(node)
 
-          receiver = node.receiver
-
-          return unless (receiver&.block_type? || receiver&.numblock_type?) &&
-                        receiver.loc.end.is?('end')
+          return unless (receiver = node.receiver)
+          return unless receiver.any_block_type? && receiver.keywords?
 
           range = range_between(receiver.loc.end.begin_pos, node.source_range.end_pos)
 

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

@@ -168,7 +168,7 @@ module RuboCop
 
         def anonymous_arguments?(node)
           return true if node.arguments.any? do |arg|
-            arg.forward_arg_type? || arg.restarg_type? || arg.kwrestarg_type?
+            arg.type?(:forward_arg, :restarg, :kwrestarg)
           end
           return false unless (last_argument = node.last_argument)
 

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

@@ -144,6 +144,8 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
+          node = node.ancestors.find { |ancestor| ancestor.loc.end } unless node.loc.end
+
           case empty_else_style
           when :empty
             corrector.insert_before(node.loc.end, 'else; nil; ')

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

@@ -28,10 +28,10 @@ module RuboCop
         MSG = 'Avoid multi-line chains of blocks.'
 
         def on_block(node)
-          node.send_node.each_node(:send, :csend) do |send_node|
+          node.send_node.each_node(:call) do |send_node|
             receiver = send_node.receiver
 
-            next unless (receiver&.block_type? || receiver&.numblock_type?) && receiver&.multiline?
+            next unless receiver&.any_block_type? && receiver.multiline?
 
             range = range_between(receiver.loc.end.begin_pos, node.send_node.source_range.end_pos)
 
@@ -44,6 +44,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
       end
     end
   end

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

@@ -50,7 +50,7 @@ module RuboCop
             corrector.remove(range_by_whole_lines(arguments.loc.end, include_final_newline: true))
           end
 
-          arguments_range = arguments_range(node)
+          arguments_range = range_with_surrounding_space(arguments_range(node), side: :left)
           # If the method name isn't on the same line as def, move it directly after def
           if arguments_range.first_line != opening_line(node)
             corrector.remove(node.loc.name)
@@ -66,14 +66,6 @@ module RuboCop
           processed_source[arguments.last_line - 1].strip
         end
 
-        def arguments_range(node)
-          range = range_between(
-            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
-          )
-
-          range_with_surrounding_space(range, side: :left)
-        end
-
         def opening_line(node)
           node.first_line
         end

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

@@ -55,6 +55,22 @@ module RuboCop
         MSG = 'Avoid comparing a variable with multiple items ' \
               'in a conditional, use `Array#include?` instead.'
 
+        # @!method simple_double_comparison?(node)
+        def_node_matcher :simple_double_comparison?, <<~PATTERN
+          (send lvar :== lvar)
+        PATTERN
+
+        # @!method simple_comparison_lhs(node)
+        def_node_matcher :simple_comparison_lhs, <<~PATTERN
+          (send ${lvar call} :== $_)
+        PATTERN
+
+        # @!method simple_comparison_rhs(node)
+        def_node_matcher :simple_comparison_rhs, <<~PATTERN
+          (send $_ :== ${lvar call})
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
         def on_or(node)
           root_of_or_node = root_of_or_node(node)
           return unless node == root_of_or_node
@@ -67,27 +83,16 @@ module RuboCop
 
           add_offense(range) do |corrector|
             elements = values.map(&:source).join(', ')
-            prefer_method = "[#{elements}].include?(#{variable_name(variable)})"
+            argument = variable.lvar_type? ? variable_name(variable) : variable.source
+            prefer_method = "[#{elements}].include?(#{argument})"
 
             corrector.replace(range, prefer_method)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
-        # @!method simple_double_comparison?(node)
-        def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
-
-        # @!method simple_comparison_lhs?(node)
-        def_node_matcher :simple_comparison_lhs?, <<~PATTERN
-          (send $lvar :== $_)
-        PATTERN
-
-        # @!method simple_comparison_rhs?(node)
-        def_node_matcher :simple_comparison_rhs?, <<~PATTERN
-          (send $_ :== $lvar)
-        PATTERN
-
         # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def find_offending_var(node, variables = Set.new, values = [])
           if node.or_type?
@@ -95,8 +100,8 @@ module RuboCop
             find_offending_var(node.rhs, variables, values)
           elsif simple_double_comparison?(node)
             return
-          elsif (var, obj = simple_comparison?(node))
-            return if allow_method_comparison? && obj.send_type?
+          elsif (var, obj = simple_comparison(node))
+            return if allow_method_comparison? && obj.call_type?
 
             variables << var
             return if variables.size > 1
@@ -125,12 +130,13 @@ module RuboCop
         end
 
         def comparison?(node)
-          simple_comparison?(node) || nested_comparison?(node)
+          !!simple_comparison(node) || nested_comparison?(node)
         end
 
-        def simple_comparison?(node)
-          if (var, obj = simple_comparison_lhs?(node)) ||
-             (obj, var = simple_comparison_rhs?(node))
+        def simple_comparison(node)
+          if (var, obj = simple_comparison_lhs(node)) || (obj, var = simple_comparison_rhs(node))
+            return if var.call_type? && !allow_method_comparison?
+
             [var, obj]
           end
         end

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

@@ -19,7 +19,7 @@ module RuboCop
       # acceptable value other than none, it will suppress the offenses
       # raised by this cop. It enforces frozen state.
       #
-      # NOTE: Regexp and Range literals are frozen objects since Ruby 3.0.
+      # NOTE: `Regexp` and `Range` literals are frozen objects since Ruby 3.0.
       #
       # NOTE: From Ruby 3.0, interpolated strings are not frozen when
       # `# frozen-string-literal: true` is used, so this cop enforces explicit
@@ -197,7 +197,7 @@ module RuboCop
         end
 
         def frozen_regexp_or_range_literals?(node)
-          target_ruby_version >= 3.0 && (node.regexp_type? || node.range_type?)
+          target_ruby_version >= 3.0 && node.type?(:regexp, :range)
         end
 
         def requires_parentheses?(node)
@@ -238,7 +238,7 @@ module RuboCop
 
         # @!method range_enclosed_in_parentheses?(node)
         def_node_matcher :range_enclosed_in_parentheses?, <<~PATTERN
-          (begin ({irange erange} _ _))
+          (begin (range _ _))
         PATTERN
       end
     end

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

@@ -74,7 +74,7 @@ module RuboCop
         end
 
         def unwrap_begin_nodes(node)
-          node = node.children.first while node && (node.begin_type? || node.kwbegin_type?)
+          node = node.children.first while node&.type?(:begin, :kwbegin)
 
           node
         end

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

@@ -35,7 +35,7 @@ module RuboCop
         def on_send(node)
           return unless node.parenthesized?
 
-          node.each_child_node(:send, :csend) do |nested|
+          node.each_child_node(:call) do |nested|
             next if allowed_omission?(nested)
 
             message = format(MSG, source: nested.source)

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

@@ -46,6 +46,38 @@ module RuboCop
       #     next unless a == 1
       #     puts a
       #   end
+      #
+      # @example AllowConsecutiveConditionals: false (default)
+      #   # bad
+      #   [1, 2].each do |a|
+      #     if a == 1
+      #       puts a
+      #     end
+      #     if a == 2
+      #       puts a
+      #     end
+      #   end
+      #
+      #   # good
+      #   [1, 2].each do |a|
+      #     if a == 1
+      #       puts a
+      #     end
+      #     next unless a == 2
+      #     puts a
+      #   end
+      #
+      # @example AllowConsecutiveConditionals: true
+      #   # good
+      #   [1, 2].each do |a|
+      #     if a == 1
+      #       puts a
+      #     end
+      #     if a == 2
+      #       puts a
+      #     end
+      #   end
+      #
       class Next < Base
         include ConfigurableEnforcedStyle
         include MinBodyLength
@@ -72,6 +104,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_while(node)
           check(node)
@@ -86,6 +119,9 @@ module RuboCop
 
           offending_node = offense_node(node.body)
 
+          return if allowed_consecutive_conditionals? &&
+                    consecutive_conditionals?(offending_node)
+
           add_offense(offense_location(offending_node)) do |corrector|
             if offending_node.modifier_form?
               autocorrect_modifier(corrector, offending_node)
@@ -227,6 +263,14 @@ module RuboCop
 
           corrector.remove_leading(buffer.line_range(lineno), adjustment) if adjustment.positive?
         end
+
+        def consecutive_conditionals?(if_node)
+          if_node.parent&.begin_type? && if_node.left_sibling&.if_type?
+        end
+
+        def allowed_consecutive_conditionals?
+          cop_config.fetch('AllowConsecutiveConditionals', false)
+        end
       end
     end
   end

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

@@ -33,39 +33,38 @@ module RuboCop
         RESTRICT_ON_SEND = %i[then yield_self].freeze
 
         def on_block(node)
+          return unless RESTRICT_ON_SEND.include?(node.method_name)
+
           check_method_node(node.send_node)
         end
-
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_send(node)
           return unless node.arguments.one? && node.first_argument.block_pass_type?
 
           check_method_node(node)
         end
+        alias on_csend on_send
 
         private
 
         def check_method_node(node)
-          return unless preferred_method?(node)
-
-          message = message(node)
-          add_offense(node.loc.selector, message: message) do |corrector|
-            prefer = style == :then && node.receiver.nil? ? 'self.then' : style
+          if preferred_method?(node)
+            correct_style_detected
+          else
+            opposite_style_detected
+            message = message(node)
+            add_offense(node.loc.selector, message: message) do |corrector|
+              prefer = style == :then && node.receiver.nil? ? 'self.then' : style
 
-            corrector.replace(node.loc.selector, prefer)
+              corrector.replace(node.loc.selector, prefer)
+            end
           end
         end
 
         def preferred_method?(node)
-          case style
-          when :then
-            node.method?(:yield_self)
-          when :yield_self
-            node.method?(:then)
-          else
-            false
-          end
+          node.method?(style)
         end
 
         def message(node)

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

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # Flags uses of OpenStruct, as it is now officially discouraged
+      # Flags uses of `OpenStruct`, as it is now officially discouraged
       # to be used for performance, version compatibility, and potential security issues.
       #
       # @safety
-      #
       #   Note that this cop may flag false positives; for instance, the following legal
       #   use of a hand-rolled `OpenStruct` type would be considered an offense:
       #
-      #   ```
+      #   [source,ruby]
+      #   -----
       #   module MyNamespace
       #     class OpenStruct # not the OpenStruct we're looking for
       #     end
@@ -20,7 +20,7 @@ module RuboCop
       #       OpenStruct.new # resolves to MyNamespace::OpenStruct
       #     end
       #   end
-      #   ```
+      #   -----
       #
       # @example
       #
@@ -61,7 +61,7 @@ module RuboCop
         def custom_class_or_module_definition?(node)
           parent = node.parent
 
-          (parent.class_type? || parent.module_type?) && node.left_siblings.empty?
+          parent.type?(:class, :module) && node.left_siblings.empty?
         end
       end
     end

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

@@ -69,11 +69,7 @@ module RuboCop
           elements = Array(node).compact
 
           # Account for edge case of `Constant::CONSTANT`
-          !node.array_type? || return_of_method_call?(node) || elements.any?(&:splat_type?)
-        end
-
-        def return_of_method_call?(node)
-          node.block_type? || node.send_type?
+          !node.array_type? || elements.any?(&:splat_type?)
         end
 
         def assignment_corrector(node, rhs, order)

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

@@ -94,8 +94,8 @@ module RuboCop
         end
 
         def require_parentheses?(node, condition_body)
-          return false if !node.while_type? && !node.until_type?
-          return false if !condition_body.block_type? && !condition_body.numblock_type?
+          return false unless node.type?(:while, :until)
+          return false unless condition_body.any_block_type?
 
           condition_body.send_node.block_literal? && condition_body.keywords?
         end

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

@@ -99,7 +99,7 @@ module RuboCop
         def string_source(node)
           if node.is_a?(String)
             node.scrub
-          elsif node.respond_to?(:type) && (node.str_type? || node.sym_type?)
+          elsif node.respond_to?(:type) && node.type?(:str, :sym)
             node.source
           end
         end

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

@@ -19,8 +19,7 @@ module RuboCop
         MSG = 'Use `proc` instead of `Proc.new`.'
 
         # @!method proc_new?(node)
-        def_node_matcher :proc_new?,
-                         '({block numblock} $(send (const {nil? cbase} :Proc) :new) ...)'
+        def_node_matcher :proc_new?, '(any_block $(send (const {nil? cbase} :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|
@@ -31,6 +30,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
       end
     end
   end

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

@@ -98,7 +98,7 @@ module RuboCop
 
         def style
           return super unless super == :same_as_string_literals
-          return :single_quotes unless string_literals_config['Enabled']
+          return :single_quotes unless config.cop_enabled?('Style/StringLiterals')
 
           string_literals_config['EnforcedStyle'].to_sym
         end

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

@@ -3,18 +3,18 @@
 module RuboCop
   module Cop
     module Style
-      # Checks the args passed to `fail` and `raise`. For exploded
-      # style (default), it recommends passing the exception class and message
-      # to `raise`, rather than construct an instance of the error. It will
-      # still allow passing just a message, or the construction of an error
-      # with more than one argument.
+      # Checks the args passed to `fail` and `raise`.
       #
-      # The exploded style works identically, but with the addition that it
-      # will also suggest constructing error objects when the exception is
-      # passed multiple arguments.
+      # Exploded style (default) enforces passing the exception class and message
+      # arguments separately, rather than constructing an instance of the error.
+      #
+      # Compact style enforces constructing an error instance.
+      #
+      # Both styles allow passing just a message, or an error instance when there is more
+      # than one argument.
       #
       # The exploded style has an `AllowedCompactTypes` configuration
-      # option that takes an Array of exception name Strings.
+      # option that takes an `Array` of exception name Strings.
       #
       # @safety
       #   This cop is unsafe because `raise Foo` calls `Foo.exception`, not `Foo.new`.
@@ -50,6 +50,9 @@ module RuboCop
 
         EXPLODED_MSG = 'Provide an exception class and message as arguments to `%<method>s`.'
         COMPACT_MSG = 'Provide an exception object as an argument to `%<method>s`.'
+        ACCEPTABLE_ARG_TYPES = %i[
+          hash forwarded_restarg splat forwarded_restarg forwarded_args
+        ].freeze
 
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
@@ -138,9 +141,8 @@ module RuboCop
 
           arg = args.first
 
-          # Allow code like `raise Ex.new(kw: arg)`.
-          # Allow code like `raise Ex.new(*args)`.
-          arg.hash_type? || arg.splat_type?
+          # Allow nodes that may forward more than one argument
+          ACCEPTABLE_ARG_TYPES.include?(arg.type)
         end
 
         def allowed_non_exploded_type?(arg)

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

@@ -36,7 +36,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int (irange int int) (erange int int)}))
+              {int (range int int)}))
         PATTERN
 
         # @!method rand_op_integer?(node)
@@ -45,7 +45,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int (irange int int) (erange int int)})
+              {int (range int int)})
             {:+ :-}
             int)
         PATTERN
@@ -56,7 +56,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int (irange int int) (erange int int)})
+              {int (range int int)})
             {:succ :pred :next})
         PATTERN
 

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

@@ -95,6 +95,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_kwbegin(node)
           return unless (target_node = offensive_kwbegins(node).to_a.last)
@@ -185,7 +186,7 @@ module RuboCop
         def contain_rescue_or_ensure?(node)
           first_child = node.children.first
 
-          first_child.rescue_type? || first_child.ensure_type?
+          first_child.type?(:rescue, :ensure)
         end
 
         def valid_context_using_only_begin?(node)

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

@@ -42,7 +42,28 @@ module RuboCop
       #     c
       #   end
       #
+      #   # bad
+      #   a.nil? ? true : a
+      #
+      #   # good
+      #   a.nil? || a
+      #
+      #   # bad
+      #   if a.nil?
+      #     true
+      #   else
+      #     a
+      #   end
+      #
+      #   # good
+      #   a.nil? || a
+      #
+      # @example AllowedMethods: ['nonzero?'] (default)
+      #   # good
+      #   num.nonzero? ? true : false
+      #
       class RedundantCondition < Base
+        include AllowedMethods
         include CommentsHelp
         include RangeHelp
         extend AutoCorrector
@@ -128,6 +149,16 @@ module RuboCop
           #   end
           return true if condition == if_branch
 
+          # e.g.
+          #   a.nil? ? true : a
+          # or
+          #   if a.nil?
+          #     true
+          #   else
+          #     a
+          #   end
+          return true if if_branch_is_true_type_and_else_is_not?(node)
+
           # e.g.
           #   if foo
           #     @value = foo
@@ -146,6 +177,18 @@ module RuboCop
             !use_hash_key_access?(if_branch)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def if_branch_is_true_type_and_else_is_not?(node)
+          return false unless node.ternary? || node.if?
+
+          cond = node.condition
+          return false unless cond.call_type?
+          return false if !cond.predicate_method? || allowed_method?(cond.method_name)
+
+          node.if_branch&.true_type? && node.else_branch && !node.else_branch.true_type?
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
         def branches_have_assignment?(node)
           _condition, if_branch, else_branch = *node # rubocop:disable InternalAffairs/NodeDestructuring
 
@@ -157,7 +200,7 @@ module RuboCop
         end
 
         def asgn_type?(node)
-          node.lvasgn_type? || node.ivasgn_type? || node.cvasgn_type? || node.gvasgn_type?
+          node.type?(:lvasgn, :ivasgn, :cvasgn, :gvasgn)
         end
 
         def branches_have_method?(node)
@@ -184,9 +227,17 @@ module RuboCop
           return false unless argument.hash_type?
           return false unless (node = argument.children.first)
 
-          node.kwsplat_type? || node.forwarded_kwrestarg_type?
+          node.type?(:kwsplat, :forwarded_kwrestarg)
+        end
+
+        def wrap_arguments_with_parens(condition)
+          method = condition.source_range.begin.join(condition.loc.selector.end)
+          arguments = condition.first_argument.source_range.begin.join(condition.source_range.end)
+
+          "#{method.source}(#{arguments.source})"
         end
 
+        # rubocop:disable Metrics/AbcSize
         def if_source(if_branch, arithmetic_operation)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')
@@ -194,10 +245,16 @@ module RuboCop
             argument_source = if_branch.first_argument.source
 
             "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
+          elsif if_branch.true_type?
+            condition = if_branch.parent.condition
+            return condition.source if condition.arguments.empty?
+
+            wrap_arguments_with_parens(condition)
           else
             if_branch.source
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
           if arithmetic_operation