rubocop 1.69.1 → 1.70.0

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

@@ -65,19 +65,23 @@ module RuboCop
 
         # @!method right_coerce?(node)
         def_node_matcher :right_coerce?, <<~PATTERN
-          (send _ :/ (send _ :to_f))
+          (send _ :/ #to_f_method?)
         PATTERN
         # @!method left_coerce?(node)
         def_node_matcher :left_coerce?, <<~PATTERN
-          (send (send _ :to_f) :/ _)
+          (send #to_f_method? :/ _)
         PATTERN
         # @!method both_coerce?(node)
         def_node_matcher :both_coerce?, <<~PATTERN
-          (send (send _ :to_f) :/ (send _ :to_f))
+          (send #to_f_method? :/ #to_f_method?)
         PATTERN
         # @!method any_coerce?(node)
         def_node_matcher :any_coerce?, <<~PATTERN
-          {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
+          {(send _ :/ #to_f_method?) (send #to_f_method? :/ _)}
+        PATTERN
+        # @!method to_f_method?(node)
+        def_node_matcher :to_f_method?, <<~PATTERN
+          (send !nil? :to_f)
         PATTERN
 
         def on_send(node)

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

@@ -10,8 +10,10 @@ module RuboCop
       # (`Hash#except` was added in Ruby 3.0.)
       #
       # For safe detection, it is limited to commonly used string and symbol comparisons
-      # when used `==`.
-      # And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object.
+      # when using `==` or `!=`.
+      #
+      # This cop doesn't check for `Hash#delete_if` and `Hash#keep_if` because they
+      # modify the receiver.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -51,44 +53,31 @@ module RuboCop
         MSG = 'Use `%<prefer>s` instead.'
         RESTRICT_ON_SEND = %i[reject select filter].freeze
 
-        # @!method bad_method_with_poro?(node)
-        def_node_matcher :bad_method_with_poro?, <<~PATTERN
-          (block
-            (call _ _)
-            (args
-              $(arg _)
-              (arg _))
-            {
-              $(send
-                _ {:== :!= :eql? :include?} _)
-              (send
-                $(send
-                  _ {:== :!= :eql? :include?} _) :!)
-              })
-        PATTERN
+        SUBSET_METHODS = %i[== != eql? include?].freeze
+        ACTIVE_SUPPORT_SUBSET_METHODS = (SUBSET_METHODS + %i[in? exclude?]).freeze
 
-        # @!method bad_method_with_active_support?(node)
-        def_node_matcher :bad_method_with_active_support?, <<~PATTERN
+        # @!method block_with_first_arg_check?(node)
+        def_node_matcher :block_with_first_arg_check?, <<~PATTERN
           (block
-            (send _ _)
+            (call _ _)
             (args
-              $(arg _)
+              $(arg _key)
               (arg _))
             {
               $(send
-                _ {:== :!= :eql? :in? :include? :exclude?} _)
+                {(lvar _key) $_ _ | _ $_ (lvar _key)})
               (send
                 $(send
-                  _ {:== :!= :eql? :in? :include? :exclude?} _) :!)
+                  {(lvar _key) $_ _ | _ $_ (lvar _key)}) :!)
               })
         PATTERN
 
         def on_send(node)
           block = node.parent
-          return unless bad_method?(block) && semantically_except_method?(node, block)
+          return unless extracts_hash_subset?(block) && semantically_except_method?(node, block)
 
           except_key = except_key(block)
-          return if except_key.nil? || !safe_to_register_offense?(block, except_key)
+          return unless safe_to_register_offense?(block, except_key)
 
           range = offense_range(node)
           preferred_method = "except(#{except_key_source(except_key)})"
@@ -101,42 +90,40 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def bad_method?(block)
-          if active_support_extensions_enabled?
-            bad_method_with_active_support?(block) do |key_arg, send_node|
-              if send_node.method?(:in?) && send_node.receiver&.source != key_arg.source
-                return false
-              end
-              return true if !send_node.method?(:include?) && !send_node.method?(:exclude?)
-
-              send_node.first_argument&.source == key_arg.source
-            end
-          else
-            bad_method_with_poro?(block) do |key_arg, send_node|
-              !send_node.method?(:include?) || send_node.first_argument&.source == key_arg.source
+        def extracts_hash_subset?(block)
+          block_with_first_arg_check?(block) do |key_arg, send_node, method|
+            return false unless supported_subset_method?(method)
+
+            case method
+            when :include?, :exclude?
+              send_node.first_argument.source == key_arg.source
+            when :in?
+              send_node.receiver.source == key_arg.source
+            else
+              true
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        def semantically_except_method?(send, block)
-          body = block.body
+        def supported_subset_method?(method)
+          if active_support_extensions_enabled?
+            ACTIVE_SUPPORT_SUBSET_METHODS.include?(method)
+          else
+            SUBSET_METHODS.include?(method)
+          end
+        end
 
-          negated = body.method?('!')
-          body = body.receiver if negated
+        def semantically_except_method?(node, block)
+          body, negated = extract_body_if_negated(block.body)
 
-          case send.method_name
-          when :reject
-            body.method?('==') || body.method?('eql?') || included?(negated, body)
-          when :select, :filter
-            body.method?('!=') || not_included?(negated, body)
+          if node.method?('reject')
+            body.method?('==') || body.method?('eql?') || included?(body, negated)
           else
-            false
+            body.method?('!=') || not_included?(body, negated)
           end
         end
 
-        def included?(negated, body)
+        def included?(body, negated)
           if negated
             body.method?('exclude?')
           else
@@ -144,25 +131,26 @@ module RuboCop
           end
         end
 
-        def not_included?(negated, body)
-          included?(!negated, body)
+        def not_included?(body, negated)
+          included?(body, !negated)
         end
 
         def safe_to_register_offense?(block, except_key)
-          extracted = extract_body_if_negated(block.body)
-          if extracted.method?('in?') || extracted.method?('include?') ||
-             extracted.method?('exclude?')
-            return true
-          end
-          return true if block.body.method?('eql?')
+          body = block.body
 
-          except_key.sym_type? || except_key.str_type?
+          if body.method?('==') || body.method?('!=')
+            except_key.sym_type? || except_key.str_type?
+          else
+            true
+          end
         end
 
         def extract_body_if_negated(body)
-          return body unless body.method?('!')
-
-          body.receiver
+          if body.method?('!')
+            [body.receiver, true]
+          else
+            [body, false]
+          end
         end
 
         def except_key_source(key)
@@ -187,12 +175,11 @@ module RuboCop
         end
 
         def except_key(node)
-          key_argument = node.argument_list.first.source
-          body = extract_body_if_negated(node.body)
+          key_arg = node.argument_list.first.source
+          body, = extract_body_if_negated(node.body)
           lhs, _method_name, rhs = *body
-          return if [lhs, rhs].map(&:source).none?(key_argument)
 
-          [lhs, rhs].find { |operand| operand.source != key_argument }
+          lhs.source == key_arg ? rhs : lhs
         end
 
         def offense_range(node)

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

@@ -137,6 +137,7 @@ module RuboCop
         MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
         MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash."
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
+        NO_MIXED_KEYS_STYLES = %i[ruby19_no_mixed_keys no_mixed_keys].freeze
 
         def on_hash(node)
           pairs = node.pairs
@@ -196,7 +197,7 @@ module RuboCop
         def autocorrect(corrector, node)
           if style == :hash_rockets || force_hash_rockets?(node.parent.pairs)
             autocorrect_hash_rockets(corrector, node)
-          elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
+          elsif NO_MIXED_KEYS_STYLES.include?(style)
             autocorrect_no_mixed_keys(corrector, node)
           else
             autocorrect_ruby19(corrector, node)
@@ -272,7 +273,9 @@ module RuboCop
         end
 
         def argument_without_space?(node)
-          node.argument? && node.source_range.begin_pos == node.parent.loc.selector.end_pos
+          return false if !node.argument? || !node.parent.loc.selector
+
+          node.source_range.begin_pos == node.parent.loc.selector.end_pos
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)

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

@@ -43,7 +43,7 @@ module RuboCop
           template = if require_newline?(node)
                        MSG_NEWLINE
                      elsif node.else_branch&.if_type? || node.else_branch&.begin_type? ||
-                           use_block_in_branches?(node)
+                           use_masgn_or_block_in_branches?(node)
                        MSG_IF_ELSE
                      else
                        MSG_TERNARY
@@ -53,7 +53,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          if require_newline?(node) || use_block_in_branches?(node)
+          if require_newline?(node) || use_masgn_or_block_in_branches?(node)
             corrector.replace(node.loc.begin, "\n")
           else
             corrector.replace(node, replacement(node))
@@ -64,8 +64,10 @@ module RuboCop
           node.branches.compact.any?(&:begin_type?) || use_return_with_argument?(node)
         end
 
-        def use_block_in_branches?(node)
-          node.branches.compact.any? { |branch| branch.block_type? || branch.numblock_type? }
+        def use_masgn_or_block_in_branches?(node)
+          node.branches.compact.any? do |branch|
+            branch.masgn_type? || branch.block_type? || branch.numblock_type?
+          end
         end
 
         def use_return_with_argument?(node)

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for assignments to a local `it` variable inside a block
+      # where `it` can refer to the first anonymous parameter as of Ruby 3.4.
+      #
+      # Although Ruby allows reassigning `it` in these cases, it could
+      # cause confusion if `it` is used as a block parameter elsewhere.
+      # For consistency, this also applies to numblocks and blocks with
+      # parameters, even though `it` cannot be used in those cases.
+      #
+      # @example
+      #   # bad
+      #   foo { it = 5 }
+      #   foo { |bar| it = bar }
+      #   foo { it = _2 }
+      #
+      #   # good - use a different variable name
+      #   foo { var = 5 }
+      #   foo { |bar| var = bar }
+      #   foo { bar = _2 }
+      class ItAssignment < Base
+        MSG = '`it` is the default block parameter; consider another name.'
+
+        def on_lvasgn(node)
+          return unless node.name == :it
+          return unless node.each_ancestor(:block, :numblock).any?
+
+          add_offense(node.loc.name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -135,17 +135,20 @@ module RuboCop
             node.parent&.class_type? && node.parent.single_line?
           end
 
-          def call_with_ambiguous_arguments?(node) # rubocop:disable Metrics/PerceivedComplexity
+          # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+          def call_with_ambiguous_arguments?(node)
             call_with_braced_block?(node) ||
               call_in_argument_with_block?(node) ||
               call_as_argument_or_chain?(node) ||
               call_in_match_pattern?(node) ||
               hash_literal_in_arguments?(node) ||
+              ambiguous_range_argument?(node) ||
               node.descendants.any? do |n|
                 n.forwarded_args_type? || n.block_type? || n.numblock_type? ||
                   ambiguous_literal?(n) || logical_operator?(n)
               end
           end
+          # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity
 
           def call_with_braced_block?(node)
             (node.call_type? || node.super_type?) && node.block_node&.braces?
@@ -177,6 +180,13 @@ module RuboCop
             end
           end
 
+          def ambiguous_range_argument?(node)
+            return true if (first_arg = node.first_argument)&.range_type? && first_arg.begin.nil?
+            return true if (last_arg = node.last_argument)&.range_type? && last_arg.end.nil?
+
+            false
+          end
+
           def allowed_multiline_call_with_parentheses?(node)
             cop_config['AllowParenthesesInMultilineCall'] && node.multiline?
           end

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

@@ -61,6 +61,8 @@ module RuboCop
       #   https://bugs.ruby-lang.org/issues/18396.
       # - Parentheses are required in anonymous arguments, keyword arguments
       #   and block passing in Ruby 3.2.
+      # - Parentheses are required when the first argument is a beginless range or
+      #   the last argument is an endless range.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #

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

@@ -107,7 +107,7 @@ module RuboCop
         end
 
         def variable_in_mass_assignment?(variable_name, node)
-          node.assignments.any? { |n| n.name == variable_name }
+          node.assignments.reject(&:send_type?).any? { |n| n.name == variable_name }
         end
 
         def offense_range(node)

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/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
@@ -63,29 +79,20 @@ module RuboCop
           return unless (variable, values = find_offending_var(node))
           return if values.size < comparisons_threshold
 
-          add_offense(node) do |corrector|
+          range = offense_range(values)
+
+          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(node, prefer_method)
+            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?
@@ -93,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
@@ -106,6 +113,10 @@ module RuboCop
         end
         # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
+        def offense_range(values)
+          values.first.parent.source_range.begin.join(values.last.parent.source_range.end)
+        end
+
         def variable_name(node)
           node.children[0]
         end
@@ -119,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

@@ -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/object_then.rb

@@ -33,9 +33,10 @@ 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
 
         def on_send(node)
@@ -43,29 +44,26 @@ module RuboCop
 
           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/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

@@ -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_current_directory_in_path.rb

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses a redundant current directory in path.
+      # Checks for paths given to `require_relative` that start with
+      # the current directory (`./`), which can be omitted.
       #
       # @example
       #

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

@@ -11,6 +11,9 @@ module RuboCop
       # will not register an offense, because it allows the initializer to take a different
       # number of arguments as its superclass potentially does.
       #
+      # NOTE: If an initializer takes any arguments and has an empty body, RuboCop
+      # assumes it to *not* be redundant. This is to prevent potential `ArgumentError`.
+      #
       # NOTE: If an initializer argument has a default value, RuboCop assumes it
       # to *not* be redundant.
       #
@@ -19,8 +22,10 @@ module RuboCop
       # initializer.
       #
       # @safety
-      #   This cop is unsafe because if subclass overrides `initialize` method with
-      #   a different arity than superclass.
+      #   This cop is unsafe because removing an empty initializer may alter
+      #   the behavior of the code, particularly if the superclass initializer
+      #   raises an exception. In such cases, the empty initializer may act as
+      #   a safeguard to prevent unintended errors from propagating.
       #
       # @example
       #   # bad
@@ -69,6 +74,10 @@ module RuboCop
       #   end
       #
       #   # good (changes the parameter requirements)
+      #   def initialize(_)
+      #   end
+      #
+      #   # good (changes the parameter requirements)
       #   def initialize(*)
       #   end
       #
@@ -111,7 +120,7 @@ module RuboCop
           return if acceptable?(node)
 
           if node.body.nil?
-            register_offense(node, MSG_EMPTY)
+            register_offense(node, MSG_EMPTY) if node.arguments.empty?
           else
             return if node.body.begin_type?