rubocop 1.69.0 → 1.76.1

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,12 +132,10 @@ module RuboCop
         end
 
         def pattern_matching_nodes(condition)
-          if condition.match_pattern_type? || condition.match_pattern_p_type?
+          if condition.any_match_pattern_type?
             [condition]
           else
-            condition.each_descendant.select do |node|
-              node.match_pattern_type? || node.match_pattern_p_type?
-            end
+            condition.each_descendant.select(&:any_match_pattern_type?)
           end
         end
 
@@ -164,8 +182,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_unless_modifier_of_if_unless.rb

@@ -28,19 +28,16 @@ module RuboCop
 
         MSG = 'Avoid modifier `%<keyword>s` after another conditional.'
 
+        # rubocop:disable Metrics/AbcSize
         def on_if(node)
           return unless node.modifier_form? && node.body.if_type?
 
           add_offense(node.loc.keyword, message: format(MSG, keyword: node.keyword)) do |corrector|
-            keyword = node.if? ? 'if' : 'unless'
-
-            corrector.replace(node, <<~RUBY.chop)
-              #{keyword} #{node.condition.source}
-              #{node.if_branch.source}
-              end
-            RUBY
+            corrector.wrap(node.if_branch, "#{node.keyword} #{node.condition.source}\n", "\nend")
+            corrector.remove(node.if_branch.source_range.end.join(node.condition.source_range.end))
           end
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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 _ :!) :!)'

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

@@ -42,8 +42,8 @@ module RuboCop
         def message(node)
           template = if require_newline?(node)
                        MSG_NEWLINE
-                     elsif node.else_branch&.if_type? || node.else_branch&.begin_type? ||
-                           use_block_in_branches?(node)
+                     elsif node.else_branch&.type?(:if, :begin) ||
+                           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.type?(:masgn, :any_block)
+          end
         end
 
         def use_return_with_argument?(node)

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

@@ -46,6 +46,7 @@ module RuboCop
 
         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
@@ -60,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)
 
@@ -105,6 +106,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -154,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
@@ -166,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,119 @@
+# 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 four `EnforcedStyle` options:
+      #
+      # 1. `allow_single_line` (default) ... Always uses the `it` block parameter in a single line.
+      # 2. `only_numbered_parameters` ... Detects only numbered block parameters.
+      # 3. `always` ... Always uses the `it` block parameter.
+      # 4. `disallow` ... Disallows the `it` block parameter.
+      #
+      # A single numbered parameter is detected when `allow_single_line`,
+      # `only_numbered_parameters`, or `always`.
+      #
+      # @example EnforcedStyle: allow_single_line (default)
+      #   # bad
+      #   block do
+      #     do_something(it)
+      #   end
+      #   block { do_something(_1) }
+      #
+      #   # good
+      #   block { do_something(it) }
+      #   block { |named_param| do_something(named_param) }
+      #
+      # @example EnforcedStyle: only_numbered_parameters
+      #   # 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_PARAMETER = 'Use `it` block parameter.'
+        MSG_AVOID_IT_PARAMETER = 'Avoid using `it` block parameter.'
+        MSG_AVOID_IT_PARAMETER_MULTI_LINE = 'Avoid using numbered parameters for multi-line blocks.'
+
+        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_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_PARAMETER) do |corrector|
+              corrector.replace(variable, 'it')
+            end
+          end
+        end
+
+        def on_itblock(node)
+          case style
+          when :allow_single_line
+            return if node.single_line?
+
+            add_offense(node, message: MSG_AVOID_IT_PARAMETER_MULTI_LINE)
+          when :disallow
+            variables = find_block_variables(node, 'it')
+
+            variables.each do |variable|
+              add_offense(variable, message: MSG_AVOID_IT_PARAMETER)
+            end
+          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_parameters_order.rb

@@ -42,22 +42,28 @@ module RuboCop
           return if kwarg_nodes.empty?
 
           add_offense(node) do |corrector|
-            if node.parent.find(&:kwoptarg_type?) == node
-              corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+            defining_node = node.each_ancestor(:any_def, :block).first
+            next if processed_source.contains_comment?(arguments_range(defining_node))
+            next unless node.parent.find(&:kwoptarg_type?) == node
 
-              arguments = node.each_ancestor(:def, :defs, :block).first.arguments
-              append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
-
-              remove_kwargs(kwarg_nodes, corrector)
-            end
+            autocorrect(corrector, node, defining_node, kwarg_nodes)
           end
         end
 
         private
 
+        def autocorrect(corrector, node, defining_node, kwarg_nodes)
+          corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+
+          arguments = defining_node.arguments
+          append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
+
+          remove_kwargs(kwarg_nodes, corrector)
+        end
+
         def append_newline_to_last_kwoptarg(arguments, corrector)
           last_argument = arguments.last
-          return if last_argument.kwrestarg_type? || last_argument.blockarg_type?
+          return if last_argument.type?(:kwrestarg, :blockarg)
 
           last_kwoptarg = arguments.reverse.find(&:kwoptarg_type?)
           corrector.insert_after(last_kwoptarg, "\n") unless arguments.parent.block_type?

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

@@ -77,6 +77,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 

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

@@ -44,6 +44,7 @@ module RuboCop
             correct_style_detected
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -53,10 +54,16 @@ module RuboCop
 
         def prefer(node)
           receiver = node.receiver.source
-          arguments = node.arguments.map(&:source).join(', ')
-          method = explicit_style? ? "call(#{arguments})" : "(#{arguments})"
+          dot = node.loc.dot.source
+          call_arguments = if node.arguments.empty?
+                             ''
+                           else
+                             arguments = node.arguments.map(&:source).join(', ')
+                             "(#{arguments})"
+                           end
+          method = explicit_style? ? "call#{call_arguments}" : "(#{arguments})"
 
-          "#{receiver}.#{method}"
+          "#{receiver}#{dot}#{method}"
         end
 
         def implicit_style?

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

@@ -36,7 +36,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `\\` instead of `+` or `<<` to concatenate those strings.'
+        MSG = 'Use `\\` instead of `%<operator>s` to concatenate multiline strings.'
         CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
         COMPLEX_STRING_BEGIN_TOKEN = :tSTRING_BEG
@@ -61,14 +61,20 @@ module RuboCop
           successor = tokens[index + 2]
 
           return unless eligible_token_set?(predecessor, operator, successor)
-
           return if same_line?(operator, successor)
 
           next_successor = token_after_last_string(successor, index)
-
           return unless eligible_next_successor?(next_successor)
 
-          add_offense(operator.pos) { |corrector| autocorrect(corrector, operator.pos) }
+          register_offense(operator)
+        end
+
+        def register_offense(operator)
+          message = format(MSG, operator: operator.text)
+
+          add_offense(operator.pos, message: message) do |corrector|
+            autocorrect(corrector, operator.pos)
+          end
         end
 
         def autocorrect(corrector, operator_range)

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

@@ -72,7 +72,7 @@ module RuboCop
         def_node_matcher :each_block_with_push?, <<-PATTERN
           [
             ^({begin kwbegin block} ...)
-            ({block numblock} (send !{nil? self} :each) _
+            (any_block (send !{nil? self} :each) _
               (send (lvar _) {:<< :push :append} #suitable_argument_node?))
           ]
         PATTERN
@@ -127,6 +127,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -211,9 +212,11 @@ module RuboCop
         end
 
         def correct_push_node(corrector, push_node)
+          arg_node = push_node.first_argument
           range = push_node.source_range
-          arg_range = push_node.first_argument.source_range
+          arg_range = arg_node.source_range
 
+          corrector.wrap(arg_node, '{ ', ' }') if arg_node.hash_type? && !arg_node.braces?
           corrector.remove(range_between(range.begin_pos, arg_range.begin_pos))
           corrector.remove(range_between(arg_range.end_pos, range.end_pos))
         end

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

@@ -40,11 +40,16 @@ module RuboCop
         # @!method map_to_h(node)
         def_node_matcher :map_to_h, <<~PATTERN
           {
-            $(call ({block numblock} $(call _ {:map :collect}) ...) :to_h)
+            $(call (any_block $(call _ {:map :collect}) ...) :to_h)
             $(call $(call _ {:map :collect} (block_pass sym)) :to_h)
           }
         PATTERN
 
+        # @!method destructuring_argument(node)
+        def_node_matcher :destructuring_argument, <<~PATTERN
+          (args $(mlhs (arg _)+))
+        PATTERN
+
         def self.autocorrect_incompatible_with
           [Layout::SingleLineBlockChain]
         end
@@ -73,6 +78,12 @@ module RuboCop
             corrector.replace(map_dot, to_h.loc.dot.source)
           end
           corrector.replace(map.loc.selector, 'to_h')
+
+          return unless map.parent.block_type?
+
+          if (argument = destructuring_argument(map.parent.arguments))
+            corrector.replace(argument, argument.source[1..-2])
+          end
         end
         # rubocop:enable Metrics/AbcSize
       end

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

@@ -33,8 +33,8 @@ module RuboCop
         # @!method map_to_set?(node)
         def_node_matcher :map_to_set?, <<~PATTERN
           {
-            $(send ({block numblock} $(send _ {:map :collect}) ...) :to_set)
-            $(send $(send _ {:map :collect} (block_pass sym)) :to_set)
+            $(call (any_block $(call _ {:map :collect}) ...) :to_set)
+            $(call $(call _ {:map :collect} (block_pass sym)) :to_set)
           }
         PATTERN
 
@@ -49,6 +49,7 @@ module RuboCop
             autocorrect(corrector, to_set_node, map_node)
           end
         end
+        alias on_csend on_send
 
         private