rubocop 1.65.1 → 1.75.6

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

@@ -155,7 +155,7 @@ module RuboCop
           condition_variable = assignable_condition_value(node)
 
           head = heads.first
-          if head.assignment?
+          if head.respond_to?(:assignment?) && head.assignment?
             # The `send` node is used instead of the `indexasgn` node, so `name` cannot be used.
             # https://github.com/rubocop/rubocop-ast/blob/v1.29.0/lib/rubocop/ast/node/indexasgn_node.rb
             #
@@ -189,7 +189,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def check_expressions(node, expressions, insert_position)
           return if expressions.any?(&:nil?)
 
@@ -197,22 +197,41 @@ module RuboCop
 
           expressions.each do |expression|
             add_offense(expression) do |corrector|
-              next if node.if_type? && node.ternary?
+              next if node.if_type? && (node.ternary? || node.then?)
 
               range = range_by_whole_lines(expression.source_range, include_final_newline: true)
               corrector.remove(range)
               next if inserted_expression
 
-              if insert_position == :after_condition
-                corrector.insert_after(node, "\n#{expression.source}")
+              if node.parent&.assignment?
+                correct_assignment(corrector, node, expression, insert_position)
               else
-                corrector.insert_before(node, "#{expression.source}\n")
+                correct_no_assignment(corrector, node, expression, insert_position)
               end
+
               inserted_expression = true
             end
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        def correct_assignment(corrector, node, expression, insert_position)
+          if insert_position == :after_condition
+            assignment = node.parent.source_range.with(end_pos: node.source_range.begin_pos)
+            corrector.remove(assignment)
+            corrector.insert_after(node, "\n#{assignment.source}#{expression.source}")
+          else
+            corrector.insert_before(node.parent, "#{expression.source}\n")
+          end
+        end
+
+        def correct_no_assignment(corrector, node, expression, insert_position)
+          if insert_position == :after_condition
+            corrector.insert_after(node, "\n#{expression.source}")
+          else
+            corrector.insert_before(node, "#{expression.source}\n")
+          end
+        end
 
         def last_child_of_parent?(node)
           return true unless (parent = node.parent)

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

@@ -59,7 +59,6 @@ module RuboCop
       #   end
       #
       class IfInsideElse < Base
-        include IgnoredNode
         include RangeHelp
         extend AutoCorrector
 
@@ -71,7 +70,7 @@ module RuboCop
 
           else_branch = node.else_branch
 
-          return unless else_branch&.if_type? && else_branch&.if?
+          return unless else_branch&.if_type? && else_branch.if?
           return if allow_if_modifier_in_else_branch?(else_branch)
 
           add_offense(else_branch.loc.keyword) do |corrector|
@@ -98,34 +97,31 @@ module RuboCop
           else
             correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
           end
-
-          corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
-          return unless (if_branch = node.if_branch)
-
-          range = range_by_whole_lines(if_branch.source_range, include_final_newline: true)
-          corrector.remove(range)
         end
 
         def correct_to_elsif_from_modifier_form(corrector, node)
-          corrector.replace(node.parent.loc.else, <<~RUBY.chop)
-            elsif #{node.condition.source}
-            #{indent(node.if_branch)}#{node.if_branch.source}
-            end
-          RUBY
+          corrector.replace(node.parent.loc.else, "elsif #{node.condition.source}")
+
+          condition_range = range_between(
+            node.if_branch.source_range.end_pos, node.condition.source_range.end_pos
+          )
+          corrector.remove(condition_range)
         end
 
-        def correct_to_elsif_from_if_inside_else_form(corrector, node, condition)
+        def correct_to_elsif_from_if_inside_else_form(corrector, node, condition) # rubocop:disable Metrics/AbcSize
           corrector.replace(node.parent.loc.else, "elsif #{condition.source}")
 
           if_condition_range = if_condition_range(node, condition)
 
           if (if_branch = node.if_branch)
-            corrector.replace(if_condition_range, if_branch.source)
+            corrector.replace(if_condition_range, range_with_comments(if_branch).source)
+            corrector.remove(range_with_comments_and_lines(if_branch))
           else
             corrector.remove(range_by_whole_lines(if_condition_range, include_final_newline: true))
           end
 
           corrector.remove(condition)
+          corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
         end
 
         def then?(node)

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

@@ -23,6 +23,17 @@ module RuboCop
       # end
       # ----
       #
+      # The code `def method_name = body if condition` is considered a bad case by
+      # `Style/AmbiguousEndlessMethodDefinition` cop. So, to respect the user's intention to use
+      # an endless method definition in the `if` body, the following code is allowed:
+      #
+      # [source,ruby]
+      # ----
+      # if condition
+      #   def method_name = body
+      # end
+      # ----
+      #
       # NOTE: It is allowed when `defined?` argument has an undefined value,
       # because using the modifier form causes the following incompatibility:
       #
@@ -77,10 +88,14 @@ module RuboCop
           [Style::SoleNestedConditional]
         end
 
+        # rubocop:disable Metrics/AbcSize
         def on_if(node)
+          return if endless_method?(node.body)
+
           condition = node.condition
           return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
                     pattern_matching_nodes(condition).any?
+
           return unless (msg = message(node))
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
@@ -90,9 +105,14 @@ module RuboCop
             ignore_node(node)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
+        def endless_method?(body)
+          body&.any_def_type? && body.endless?
+        end
+
         def defined_nodes(condition)
           if condition.defined_type?
             [condition]
@@ -103,7 +123,7 @@ module RuboCop
 
         def defined_argument_is_undefined?(if_node, defined_node)
           defined_argument = defined_node.first_argument
-          return false unless defined_argument.lvar_type? || defined_argument.send_type?
+          return false unless defined_argument.type?(:lvar, :send)
 
           if_node.left_siblings.none? do |sibling|
             sibling.respond_to?(:lvasgn_type?) && sibling.lvasgn_type? &&
@@ -112,11 +132,11 @@ module RuboCop
         end
 
         def pattern_matching_nodes(condition)
-          if condition.match_pattern_type? || condition.match_pattern_p_type?
+          if condition.type?(:match_pattern, :match_pattern_p)
             [condition]
           else
             condition.each_descendant.select do |node|
-              node.match_pattern_type? || node.match_pattern_p_type?
+              node.type?(:match_pattern, :match_pattern_p)
             end
           end
         end
@@ -164,8 +184,8 @@ module RuboCop
 
         def too_long_due_to_comment_after_modifier?(node, comment)
           source_length = processed_source.lines[node.first_line - 1].length
-          source_length >= max_line_length &&
-            source_length - comment.source_range.length <= max_line_length
+
+          max_line_length.between?(source_length - comment.source_range.length, source_length)
         end
 
         def allowed_patterns

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

@@ -10,7 +10,7 @@ module RuboCop
       # `nonzero?` method is allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
-      # This cop targets only `if`s with a single `elsif` or `else` branch. The following
+      # This cop targets only ``if``s with a single `elsif` or `else` branch. The following
       # code will be allowed, because it has two `elsif` branches:
       #
       # [source,ruby]
@@ -67,7 +67,7 @@ module RuboCop
 
         # @!method if_with_boolean_literal_branches?(node)
         def_node_matcher :if_with_boolean_literal_branches?, <<~PATTERN
-          (if #return_boolean_value? {(true) (false) | (false) (true)})
+          (if #return_boolean_value? <true false>)
         PATTERN
         # @!method double_negative?(node)
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
@@ -155,8 +155,7 @@ module RuboCop
         end
 
         def require_parentheses?(condition)
-          condition.and_type? || condition.or_type? ||
-            (condition.send_type? && condition.comparison_method?)
+          condition.operator_keyword? || (condition.send_type? && condition.comparison_method?)
         end
       end
     end

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

@@ -18,28 +18,67 @@ module RuboCop
         extend AutoCorrector
 
         MSG_IF_ELSE = 'Do not use `if %<expr>s;` - use `if/else` instead.'
+        MSG_NEWLINE = 'Do not use `if %<expr>s;` - use a newline instead.'
         MSG_TERNARY = 'Do not use `if %<expr>s;` - use a ternary operator instead.'
 
         def on_normal_if_unless(node)
           return if node.parent&.if_type?
+          return if part_of_ignored_node?(node)
 
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
-          message = node.else_branch&.if_type? ? MSG_IF_ELSE : MSG_TERNARY
+          message = message(node)
 
-          add_offense(node, message: format(message, expr: node.condition.source)) do |corrector|
-            corrector.replace(node, autocorrect(node))
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
           end
+
+          ignore_node(node)
         end
 
         private
 
-        def autocorrect(node)
+        def message(node)
+          template = if require_newline?(node)
+                       MSG_NEWLINE
+                     elsif node.else_branch&.type?(:if, :begin) ||
+                           use_masgn_or_block_in_branches?(node)
+                       MSG_IF_ELSE
+                     else
+                       MSG_TERNARY
+                     end
+
+          format(template, expr: node.condition.source)
+        end
+
+        def autocorrect(corrector, node)
+          if require_newline?(node) || use_masgn_or_block_in_branches?(node)
+            corrector.replace(node.loc.begin, "\n")
+          else
+            corrector.replace(node, replacement(node))
+          end
+        end
+
+        def require_newline?(node)
+          node.branches.compact.any?(&:begin_type?) || use_return_with_argument?(node)
+        end
+
+        def use_masgn_or_block_in_branches?(node)
+          node.branches.compact.any? do |branch|
+            branch.type?(:masgn, :any_block)
+          end
+        end
+
+        def use_return_with_argument?(node)
+          node.if_branch&.return_type? && node.if_branch&.arguments&.any?
+        end
+
+        def replacement(node)
           return correct_elsif(node) if node.else_branch&.if_type?
 
-          then_code = node.if_branch ? node.if_branch.source : 'nil'
-          else_code = node.else_branch ? node.else_branch.source : 'nil'
+          then_code = node.if_branch ? build_expression(node.if_branch) : 'nil'
+          else_code = node.else_branch ? build_expression(node.else_branch) : 'nil'
 
           "#{node.condition.source} ? #{then_code} : #{else_code}"
         end
@@ -53,6 +92,15 @@ module RuboCop
           RUBY
         end
 
+        def build_expression(expr)
+          return expr.source unless require_argument_parentheses?(expr)
+
+          method = expr.source_range.begin.join(expr.loc.selector.end)
+          arguments = expr.first_argument.source_range.begin.join(expr.source_range.end)
+
+          "#{method.source}(#{arguments.source})"
+        end
+
         def build_else_branch(second_condition)
           result = <<~RUBY
             elsif #{second_condition.condition.source}
@@ -72,6 +120,12 @@ module RuboCop
 
           result
         end
+
+        def require_argument_parentheses?(node)
+          return false if !node.call_type? || node.arithmetic_operation?
+
+          !node.parenthesized? && node.arguments.any? && !node.method?(:[]) && !node.method?(:[]=)
+        end
       end
     end
   end

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

@@ -44,11 +44,15 @@ module RuboCop
         private
 
         def alternative_pattern_source(pattern)
+          collect_alternative_patterns(pattern).join(' | ')
+        end
+
+        def collect_alternative_patterns(pattern)
           return pattern.children.map(&:source) unless pattern.children.first.match_alt_type?
 
-          pattern_sources = alternative_pattern_source(pattern.children.first)
+          pattern_sources = collect_alternative_patterns(pattern.children.first)
 
-          (pattern_sources << pattern.children[1].source).join(' | ')
+          pattern_sources << pattern.children[1].source
         end
       end
     end

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

@@ -68,7 +68,7 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          if node.while_post_type? || node.until_post_type?
+          if node.type?(:while_post, :until_post)
             replace_begin_end_with_modifier(corrector, node)
           elsif node.modifier_form?
             replace_source(corrector, node.source_range, modifier_replacement(node))

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

@@ -41,12 +41,12 @@ module RuboCop
       #     f != 1
       #   end
       class InverseMethods < Base
-        include IgnoredNode
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `%<inverse>s` instead of inverting `%<method>s`.'
         CLASS_COMPARISON_METHODS = %i[<= >= < >].freeze
+        SAFE_NAVIGATION_INCOMPATIBLE_METHODS = (CLASS_COMPARISON_METHODS + %i[any? none?]).freeze
         EQUALITY_METHODS = %i[== != =~ !~ <= >= < >].freeze
         NEGATED_EQUALITY_METHODS = %i[!= !~].freeze
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
@@ -61,24 +61,24 @@ module RuboCop
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
             (send $(call $(...) $_ $...) :!)
-            (send ({block numblock} $(call $(...) $_) $...) :!)
+            (send (any_block $(call $(...) $_) $...) :!)
             (send (begin $(call $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          ({block numblock} $(call (...) $_) ... { $(call ... :!)
-                                                   $(send (...) {:!= :!~} ...)
-                                                   (begin ... $(call ... :!))
-                                                   (begin ... $(send (...) {:!= :!~} ...))
-                                                 })
+          (any_block $(call (...) $_) ... { $(call ... :!)
+                                            $(send (...) {:!= :!~} ...)
+                                            (begin ... $(call ... :!))
+                                            (begin ... $(send (...) {:!= :!~} ...))
+                                          })
         PATTERN
 
         def on_send(node)
           inverse_candidate?(node) do |method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
-            return if negated?(node) || relational_comparison_with_safe_navigation?(method_call)
+            return if negated?(node) || safe_navigation_incompatible?(method_call)
             return if part_of_ignored_node?(node)
             return if possible_class_hierarchy_check?(lhs, rhs, method)
 
@@ -106,6 +106,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -155,10 +156,6 @@ module RuboCop
           node.parent.respond_to?(:method?) && node.parent.method?(:!)
         end
 
-        def relational_comparison_with_safe_navigation?(node)
-          node.csend_type? && CLASS_COMPARISON_METHODS.include?(node.method_name)
-        end
-
         def not_to_receiver(node, method_call)
           node.loc.selector.begin.join(method_call.source_range.begin)
         end
@@ -167,6 +164,12 @@ module RuboCop
           method_call.source_range.end.join(node.source_range.end)
         end
 
+        def safe_navigation_incompatible?(node)
+          return false unless node.csend_type?
+
+          SAFE_NAVIGATION_INCOMPATIBLE_METHODS.include?(node.method_name)
+        end
+
         # When comparing classes, `!(Integer < Numeric)` is not the same as
         # `Integer > Numeric`.
         def possible_class_hierarchy_check?(lhs, rhs, method)

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

@@ -89,8 +89,8 @@ module RuboCop
 
         def inheritance_check?(node)
           argument = node.first_argument
-          node.method?(:<) &&
-            (argument.const_type? && argument.short_name.to_s.upcase != argument.short_name.to_s)
+          node.method?(:<) && argument.const_type? &&
+            argument.short_name.to_s.upcase != argument.short_name.to_s
         end
 
         def preferred_condition(node)

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

@@ -32,7 +32,7 @@ module RuboCop
 
           # To try to avoid doing two regex checks on every string,
           # shortcut out if the string does not look like an IP address
-          return false unless could_be_ip?(contents)
+          return false unless potential_ip?(contents)
 
           ::Resolv::IPv4::Regex.match?(contents) || ::Resolv::IPv6::Regex.match?(contents)
         end
@@ -52,7 +52,7 @@ module RuboCop
           Array(allowed_addresses).map(&:downcase)
         end
 
-        def could_be_ip?(str)
+        def potential_ip?(str)
           # If the string is too long, it can't be an IP
           return false if too_long?(str)
 

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(:any_block).any?
+
+          add_offense(node.loc.name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for blocks with one argument where `it` block parameter can be used.
+      #
+      # It provides three `EnforcedStyle` options:
+      #
+      # 1. `only_numbered_parameters` (default) ... Detects only numbered block parameters.
+      # 2. `always` ... Always uses the `it` block parameter.
+      # 3. `disallow` ... Disallows the `it` block parameter.
+      #
+      # A single numbered parameter is detected when `only_numbered_parameters` or `always`.
+      #
+      # @example EnforcedStyle: only_numbered_parameters (default)
+      #   # bad
+      #   block { do_something(_1) }
+      #
+      #   # good
+      #   block { do_something(it) }
+      #   block { |named_param| do_something(named_param) }
+      #
+      # @example EnforcedStyle: always
+      #   # bad
+      #   block { do_something(_1) }
+      #   block { |named_param| do_something(named_param) }
+      #
+      #   # good
+      #   block { do_something(it) }
+      #
+      # @example EnforcedStyle: disallow
+      #   # bad
+      #   block { do_something(it) }
+      #
+      #   # good
+      #   block { do_something(_1) }
+      #   block { |named_param| do_something(named_param) }
+      #
+      class ItBlockParameter < Base
+        include ConfigurableEnforcedStyle
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        MSG_USE_IT_BLOCK_PARAMETER = 'Use `it` block parameter.'
+        MSG_AVOID_IT_BLOCK_PARAMETER = 'Avoid using `it` block parameter.'
+
+        minimum_target_ruby_version 3.4
+
+        def on_block(node)
+          return unless style == :always
+          return unless node.arguments.one?
+
+          # `restarg`, `kwrestarg`, `blockarg` nodes can return early.
+          return unless node.first_argument.arg_type?
+
+          variables = find_block_variables(node, node.first_argument.source)
+
+          variables.each do |variable|
+            add_offense(variable, message: MSG_USE_IT_BLOCK_PARAMETER) do |corrector|
+              corrector.remove(node.arguments)
+              corrector.replace(variable, 'it')
+            end
+          end
+        end
+
+        def on_numblock(node)
+          return if style == :disallow
+          return unless node.children[1] == 1
+
+          variables = find_block_variables(node, '_1')
+
+          variables.each do |variable|
+            add_offense(variable, message: MSG_USE_IT_BLOCK_PARAMETER) do |corrector|
+              corrector.replace(variable, 'it')
+            end
+          end
+        end
+
+        def on_itblock(node)
+          return unless style == :disallow
+
+          variables = find_block_variables(node, 'it')
+
+          variables.each do |variable|
+            add_offense(variable, message: MSG_AVOID_IT_BLOCK_PARAMETER)
+          end
+        end
+
+        private
+
+        def find_block_variables(node, block_argument_name)
+          node.each_descendant(:lvar).select do |descendant|
+            descendant.source == block_argument_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # When passing an existing hash as keyword arguments, provide additional arguments
+      # directly rather than using `merge`.
+      #
+      # Providing arguments directly is more performant than using `merge`, and
+      # also leads to shorter and simpler code.
+      #
+      # @example
+      #   # bad
+      #   some_method(**opts.merge(foo: true))
+      #   some_method(**opts.merge(other_opts))
+      #
+      #   # good
+      #   some_method(**opts, foo: true)
+      #   some_method(**opts, **other_opts)
+      #
+      class KeywordArgumentsMerging < Base
+        extend AutoCorrector
+
+        MSG = 'Provide additional arguments directly rather than using `merge`.'
+
+        # @!method merge_kwargs?(node)
+        def_node_matcher :merge_kwargs?, <<~PATTERN
+          (send _ _
+            ...
+            (hash
+              (kwsplat
+                $(send $_ :merge $...))
+              ...))
+        PATTERN
+
+        def on_kwsplat(node)
+          return unless (ancestor = node.parent&.parent)
+
+          merge_kwargs?(ancestor) do |merge_node, hash_node, other_hash_node|
+            add_offense(merge_node) do |corrector|
+              autocorrect(corrector, node, hash_node, other_hash_node)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, kwsplat_node, hash_node, other_hash_node)
+          other_hash_node_replacement =
+            other_hash_node.map do |node|
+              if node.hash_type?
+                if node.braces?
+                  node.source[1...-1]
+                else
+                  node.source
+                end
+              else
+                "**#{node.source}"
+              end
+            end.join(', ')
+
+          corrector.replace(kwsplat_node, "**#{hash_node.source}, #{other_hash_node_replacement}")
+        end
+      end
+    end
+  end
+end