rubocop 1.54.1 → 1.64.1

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

@@ -136,7 +136,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_branches(node, branches)
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
@@ -149,9 +149,26 @@ module RuboCop
                     branches.any? { |branch| single_child_branch?(branch) }
 
           heads = branches.map { |branch| head(branch) }
-          check_expressions(node, heads, :before_condition) if duplicated_expressions?(node, heads)
+
+          return unless duplicated_expressions?(node, heads)
+
+          condition_variable = assignable_condition_value(node)
+
+          head = heads.first
+          if 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
+            #
+            # FIXME: It would be better to update `RuboCop::AST::OpAsgnNode` or its subclasses to
+            # handle `self.foo ||= value` as a solution, instead of using `head.node_parts[0].to_s`.
+            assigned_value = head.send_type? ? head.receiver.source : head.node_parts[0].to_s
+
+            return if condition_variable == assigned_value
+          end
+
+          check_expressions(node, heads, :before_condition)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def duplicated_expressions?(node, expressions)
           unique_expressions = expressions.uniq
@@ -164,6 +181,14 @@ module RuboCop
           node.condition.child_nodes.none? { |n| n.source == lhs.source if n.variable? }
         end
 
+        def assignable_condition_value(node)
+          if node.condition.call_type?
+            (receiver = node.condition.receiver) ? receiver.source : node.condition.source
+          elsif node.condition.variable?
+            node.condition.source
+          end
+        end
+
         # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def check_expressions(node, expressions, insert_position)
           return if expressions.any?(&:nil?)

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

@@ -112,9 +112,11 @@ module RuboCop
         end
 
         def message(node, keyword)
-          message_template = node.elsif? ? MSG_FOR_ELSIF : MSG
-
-          format(message_template, keyword: keyword)
+          if node.elsif?
+            MSG_FOR_ELSIF
+          else
+            format(MSG, keyword: keyword)
+          end
         end
 
         def return_boolean_value?(condition)

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

@@ -60,25 +60,25 @@ module RuboCop
         # @!method inverse_candidate?(node)
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
-            (send $(send $(...) $_ $...) :!)
-            (send ({block numblock} $(send $(...) $_) $...) :!)
-            (send (begin $(send $(...) $_ $...)) :!)
+            (send $(call $(...) $_ $...) :!)
+            (send ({block numblock} $(call $(...) $_) $...) :!)
+            (send (begin $(call $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          ({block numblock} $(send (...) $_) ... { $(send ... :!)
+          ({block numblock} $(call (...) $_) ... { $(call ... :!)
                                                    $(send (...) {:!= :!~} ...)
-                                                   (begin ... $(send ... :!))
+                                                   (begin ... $(call ... :!))
                                                    (begin ... $(send (...) {:!= :!~} ...))
                                                  })
         PATTERN
 
         def on_send(node)
-          inverse_candidate?(node) do |_method_call, lhs, method, rhs|
+          inverse_candidate?(node) do |method_call, lhs, method, rhs|
             return unless inverse_methods.key?(method)
-            return if negated?(node)
+            return if negated?(node) || relational_comparison_with_safe_navigation?(method_call)
             return if part_of_ignored_node?(node)
             return if possible_class_hierarchy_check?(lhs, rhs, method)
 
@@ -87,6 +87,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         def on_block(node)
           inverse_block?(node) do |_method_call, method, block|
@@ -154,16 +155,16 @@ 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)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.loc.selector.begin_pos,
-                                    method_call.source_range.begin_pos)
+          node.loc.selector.begin.join(method_call.source_range.begin)
         end
 
         def end_parentheses(node, method_call)
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    method_call.source_range.end_pos,
-                                    node.source_range.end_pos)
+          method_call.source_range.end.join(node.source_range.end)
         end
 
         # When comparing classes, `!(Integer < Numeric)` is not the same as

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

@@ -32,12 +32,14 @@ module RuboCop
       #   foo unless x != y
       #   foo unless x >= 10
       #   foo unless x.even?
+      #   foo unless odd?
       #
       #   # good
       #   foo if bar
       #   foo if x == y
       #   foo if x < 10
       #   foo if x.odd?
+      #   foo if even?
       #
       #   # bad (complex condition)
       #   foo unless x != y || x.even?
@@ -51,7 +53,7 @@ module RuboCop
       class InvertibleUnlessCondition < Base
         extend AutoCorrector
 
-        MSG = 'Favor `if` with inverted condition over `unless`.'
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
         def on_if(node)
           return unless node.unless?
@@ -59,7 +61,10 @@ module RuboCop
           condition = node.condition
           return unless invertible?(condition)
 
-          add_offense(node) do |corrector|
+          message = format(MSG, prefer: "#{node.inverse_keyword} #{preferred_condition(condition)}",
+                                current: "#{node.keyword} #{condition.source}")
+
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node.loc.keyword, node.inverse_keyword)
             autocorrect(corrector, condition)
           end
@@ -88,6 +93,43 @@ module RuboCop
             (argument.const_type? && argument.short_name.to_s.upcase != argument.short_name.to_s)
         end
 
+        def preferred_condition(node)
+          case node.type
+          when :begin    then "(#{preferred_condition(node.children.first)})"
+          when :send     then preferred_send_condition(node)
+          when :or, :and then preferred_logical_condition(node)
+          end
+        end
+
+        def preferred_send_condition(node) # rubocop:disable Metrics/CyclomaticComplexity
+          receiver_source = node.receiver&.source
+          return receiver_source if node.method?(:!)
+
+          # receiver may be implicit (self)
+          dotted_receiver_source = receiver_source ? "#{receiver_source}." : ''
+
+          inverse_method_name = inverse_methods[node.method_name]
+          return "#{dotted_receiver_source}#{inverse_method_name}" unless node.arguments?
+
+          argument_list = node.arguments.map(&:source).join(', ')
+          if node.operator_method?
+            return "#{receiver_source} #{inverse_method_name} #{argument_list}"
+          end
+
+          if node.parenthesized?
+            return "#{dotted_receiver_source}#{inverse_method_name}(#{argument_list})"
+          end
+
+          "#{dotted_receiver_source}#{inverse_method_name} #{argument_list}"
+        end
+
+        def preferred_logical_condition(node)
+          preferred_lhs = preferred_condition(node.lhs)
+          preferred_rhs = preferred_condition(node.rhs)
+
+          "#{preferred_lhs} #{node.inverse_operator} #{preferred_rhs}"
+        end
+
         def autocorrect(corrector, node)
           case node.type
           when :begin

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

@@ -20,6 +20,7 @@ module RuboCop
       #  lambda.(x, y)
       class LambdaCall < Base
         include ConfigurableEnforcedStyle
+        include IgnoredNode
         extend AutoCorrector
 
         MSG = 'Prefer the use of `%<prefer>s` over `%<current>s`.'
@@ -33,8 +34,12 @@ module RuboCop
             current = node.source
 
             add_offense(node, message: format(MSG, prefer: prefer, current: current)) do |corrector|
+              next if part_of_ignored_node?(node)
+
               opposite_style_detected
               corrector.replace(node, prefer)
+
+              ignore_node(node)
             end
           else
             correct_style_detected

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

@@ -44,9 +44,9 @@ module RuboCop
 
         # @!method map_and_compact?(node)
         def_node_matcher :map_and_compact?, <<~RUBY
-          (send
+          (call
             (block
-              (send _ :map)
+              (call _ :map)
               (args
                 $(arg _))
               {
@@ -85,6 +85,7 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -115,20 +116,17 @@ module RuboCop
         def truthy_branch_for_guard?(node)
           if_node = node.left_sibling
 
-          if if_node.if? || if_node.ternary?
-            if_node.else_branch.nil?
-          elsif if_node.unless?
-            if_node.if_branch.nil?
+          if if_node.if?
+            if_node.if_branch.arguments.any?
+          else
+            if_node.if_branch.arguments.none?
           end
         end
 
         def range(node)
-          buffer = node.source_range.source_buffer
           map_node = node.receiver.send_node
-          begin_pos = map_node.loc.selector.begin_pos
-          end_pos = node.source_range.end_pos
 
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+          map_node.loc.selector.join(node.source_range.end)
         end
       end
     end

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

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usages of `each` with `<<`, `push`, or `append` which
+      # can be replaced by `map`.
+      #
+      # If `PreferredMethods` is configured for `map` in `Style/CollectionMethods`,
+      # this cop uses the specified method for replacement.
+      #
+      # NOTE: The return value of `Enumerable#each` is `self`, whereas the
+      # return value of `Enumerable#map` is an `Array`. They are not autocorrected
+      # when a return value could be used because these types differ.
+      #
+      # NOTE: It only detects when the mapping destination is a local variable
+      # initialized as an empty array and referred to only by the pushing operation.
+      # This is because, if not, it's challenging to statically guarantee that the
+      # mapping destination variable remains an empty array:
+      #
+      # [source,ruby]
+      # ----
+      # ret = []
+      # src.each { |e| ret << e * 2 } # `<<` method may mutate `ret`
+      #
+      # dest = []
+      # src.each { |e| dest << transform(e, dest) } # `transform` method may mutate `dest`
+      # ----
+      #
+      # @safety
+      #   This cop is unsafe because not all objects that have an `each`
+      #   method also have a `map` method (e.g. `ENV`). Additionally, for calls
+      #   with a block, not all objects that have a `map` method return an array
+      #   (e.g. `Enumerator::Lazy`).
+      #
+      # @example
+      #   # bad
+      #   dest = []
+      #   src.each { |e| dest << e * 2 }
+      #   dest
+      #
+      #   # good
+      #   dest = src.map { |e| e * 2 }
+      #
+      #   # good - contains another operation
+      #   dest = []
+      #   src.each { |e| dest << e * 2; puts e }
+      #   dest
+      #
+      class MapIntoArray < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<new_method_name>s` instead of `each` to map elements into an array.'
+
+        # @!method each_block_with_push?(node)
+        def_node_matcher :each_block_with_push?, <<-PATTERN
+          [
+            ^({begin kwbegin} ...)
+            ({block numblock} (send !{nil? self} :each) _
+              (send (lvar _) {:<< :push :append} _))
+          ]
+        PATTERN
+
+        # @!method empty_array_asgn?(node)
+        def_node_matcher :empty_array_asgn?, '(lvasgn _ (array))'
+
+        # @!method lvar_ref?(node, name)
+        def_node_matcher :lvar_ref?, '(lvar %1)'
+
+        def self.joining_forces
+          VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          (@scopes ||= []) << scope
+        end
+
+        def on_block(node)
+          return unless each_block_with_push?(node)
+
+          dest_var = find_dest_var(node)
+          return unless (asgn = find_closest_assignment(node, dest_var))
+          return unless empty_array_asgn?(asgn)
+          return unless dest_used_only_for_mapping?(node, dest_var, asgn)
+
+          register_offense(node, dest_var, asgn)
+        end
+
+        alias on_numblock on_block
+
+        private
+
+        def find_dest_var(block)
+          node = block.body.receiver
+          name = node.children.first
+
+          candidates = @scopes.lazy.filter_map { |s| s.variables[name] }
+          candidates.find { |v| v.references.any? { |n| n.node.equal?(node) } }
+        end
+
+        def find_closest_assignment(block, dest_var)
+          dest_var.assignments.reverse_each.lazy.map(&:node).find do |node|
+            node.source_range.end_pos < block.source_range.begin_pos
+          end
+        end
+
+        def dest_used_only_for_mapping?(block, dest_var, asgn)
+          range = asgn.source_range.join(block.source_range)
+
+          asgn.parent.equal?(block.parent) &&
+            dest_var.references.one? { |r| range.contains?(r.node.source_range) } &&
+            dest_var.assignments.one? { |a| range.contains?(a.node.source_range) }
+        end
+
+        def register_offense(block, dest_var, asgn)
+          add_offense(block, message: format(MSG, new_method_name: new_method_name)) do |corrector|
+            next if return_value_used?(block)
+
+            corrector.replace(block.send_node.selector, new_method_name)
+            remove_assignment(corrector, asgn)
+            correct_push_node(corrector, block.body)
+            correct_return_value_handling(corrector, block, dest_var)
+          end
+        end
+
+        def new_method_name
+          default = 'map'
+          alternative = config.for_cop('Style/CollectionMethods').dig('PreferredMethods', default)
+          alternative || default
+        end
+
+        def return_value_used?(node)
+          parent = node.parent
+
+          case parent&.type
+          when nil
+            false
+          when :begin, :kwbegin
+            !node.right_sibling && return_value_used?(parent)
+          when :block, :numblock
+            !parent.void_context?
+          else
+            true
+          end
+        end
+
+        def remove_assignment(corrector, asgn)
+          range = range_with_surrounding_space(asgn.source_range, side: :right)
+          range = range_with_surrounding_space(range, side: :right, newlines: false)
+
+          corrector.remove(range)
+        end
+
+        def correct_push_node(corrector, push_node)
+          range = push_node.source_range
+          arg_range = push_node.first_argument.source_range
+
+          corrector.remove(range_between(range.begin_pos, arg_range.begin_pos))
+          corrector.remove(range_between(arg_range.end_pos, range.end_pos))
+        end
+
+        def correct_return_value_handling(corrector, block, dest_var)
+          next_node = block.right_sibling
+
+          if lvar_ref?(next_node, dest_var.name)
+            corrector.remove(range_with_surrounding_space(next_node.source_range, side: :left))
+          end
+
+          corrector.insert_before(block, "#{dest_var.name} = ")
+        end
+      end
+    end
+  end
+end

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

@@ -34,37 +34,47 @@ module RuboCop
 
         minimum_target_ruby_version 2.6
 
-        MSG = 'Pass a block to `to_h` instead of calling `%<method>s.to_h`.'
+        MSG = 'Pass a block to `to_h` instead of calling `%<method>s%<dot>sto_h`.'
         RESTRICT_ON_SEND = %i[to_h].freeze
 
-        # @!method map_to_h?(node)
-        def_node_matcher :map_to_h?, <<~PATTERN
+        # @!method map_to_h(node)
+        def_node_matcher :map_to_h, <<~PATTERN
           {
-            $(send ({block numblock} $(send _ {:map :collect}) ...) :to_h)
-            $(send $(send _ {:map :collect} (block_pass sym)) :to_h)
+            $(call ({block numblock} $(call _ {:map :collect}) ...) :to_h)
+            $(call $(call _ {:map :collect} (block_pass sym)) :to_h)
           }
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Layout::SingleLineBlockChain]
+        end
+
         def on_send(node)
-          return unless (to_h_node, map_node = map_to_h?(node))
+          return unless (to_h_node, map_node = map_to_h(node))
 
-          message = format(MSG, method: map_node.loc.selector.source)
+          message = format(MSG, method: map_node.loc.selector.source, dot: to_h_node.loc.dot.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
             # If the `to_h` call already has a block, do not autocorrect.
-            next if to_h_node.block_node
+            next if to_h_node.block_literal?
 
             autocorrect(corrector, to_h_node, map_node)
           end
         end
+        alias on_csend on_send
 
         private
 
+        # rubocop:disable Metrics/AbcSize
         def autocorrect(corrector, to_h, map)
           removal_range = range_between(to_h.loc.dot.begin_pos, to_h.loc.selector.end_pos)
 
           corrector.remove(range_with_surrounding_space(removal_range, side: :left))
+          if (map_dot = map.loc.dot)
+            corrector.replace(map_dot, to_h.loc.dot.source)
+          end
           corrector.replace(map.loc.selector, 'to_h')
         end
+        # rubocop:enable Metrics/AbcSize
       end
     end
   end

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

@@ -44,7 +44,7 @@ module RuboCop
           message = format(MSG, method: map_node.loc.selector.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
             # If the `to_set` call already has a block, do not autocorrect.
-            next if to_set_node.block_node
+            next if to_set_node.block_literal?
 
             autocorrect(corrector, to_set_node, map_node)
           end

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

@@ -86,6 +86,7 @@ module RuboCop
 
           def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
             call_in_literals?(node) ||
+              node.parent&.when_type? ||
               call_with_ambiguous_arguments?(node) ||
               call_in_logical_operators?(node) ||
               call_in_optional_arguments?(node) ||
@@ -124,24 +125,39 @@ module RuboCop
             node.parent&.class_type? && node.parent&.single_line?
           end
 
-          def call_with_ambiguous_arguments?(node)
+          def call_with_ambiguous_arguments?(node) # rubocop:disable Metrics/PerceivedComplexity
             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) ||
               node.descendants.any? do |n|
-                n.forwarded_args_type? || ambiguous_literal?(n) || logical_operator?(n) ||
-                  call_with_braced_block?(n)
+                n.forwarded_args_type? || n.block_type? || n.numblock_type? ||
+                  ambiguous_literal?(n) || logical_operator?(n)
               end
           end
 
           def call_with_braced_block?(node)
-            (node.send_type? || node.super_type?) && node.block_node&.braces?
+            (node.call_type? || node.super_type?) && node.block_node&.braces?
+          end
+
+          def call_in_argument_with_block?(node)
+            parent = node.parent&.block_type? && node.parent&.parent
+            return false unless parent
+
+            parent.call_type? || parent.super_type? || parent.yield_type?
           end
 
           def call_as_argument_or_chain?(node)
             node.parent &&
-              ((node.parent.send_type? && !assigned_before?(node.parent, node)) ||
-              node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
+              (node.parent.call_type? || node.parent.super_type? || node.parent.yield_type?) &&
+              !assigned_before?(node.parent, node)
+          end
+
+          def call_in_match_pattern?(node)
+            return false unless (parent = node.parent)
+
+            parent.match_pattern_type? || parent.match_pattern_p_type?
           end
 
           def hash_literal_in_arguments?(node)

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

@@ -218,15 +218,13 @@ module RuboCop
           send(style, node) # call require_parentheses or omit_parentheses
         end
         alias on_csend on_send
-        alias on_super on_send
         alias on_yield on_send
 
         private
 
         def args_begin(node)
           loc = node.loc
-          selector =
-            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+          selector = node.yield_type? ? loc.keyword : loc.selector
 
           resize_by = args_parenthesized?(node) ? 2 : 1
           selector.end.resize(resize_by)
@@ -239,7 +237,7 @@ module RuboCop
         def args_parenthesized?(node)
           return false unless node.arguments.one?
 
-          first_node = node.arguments.first
+          first_node = node.first_argument
           first_node.begin_type? && first_node.parenthesized_call?
         end
       end

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

@@ -8,6 +8,9 @@ module RuboCop
       # This cop can be customized allowed methods with `AllowedMethods`.
       # By default, there are no methods to allowed.
       #
+      # NOTE: This cop allows the use of `it()` without arguments in blocks,
+      # as in `0.times { it() }`, following `Lint/ItWithoutArgumentsInBlock` cop.
+      #
       # @example
       #   # bad
       #   object.some_method()
@@ -30,15 +33,18 @@ module RuboCop
 
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_send(node)
           return unless !node.arguments? && node.parenthesized?
           return if ineligible_node?(node)
           return if default_argument?(node)
           return if allowed_method_name?(node.method_name)
           return if same_name_assignment?(node)
+          return if parenthesized_it_method_in_block?(node)
 
           register_offense(node)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 
@@ -71,6 +77,20 @@ module RuboCop
           end
         end
 
+        # Respects `Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3's warning:
+        #
+        # $ ruby -e '0.times { begin; it; end }'
+        # -e:1: warning: `it` calls without arguments will refer to the first block param in
+        # Ruby 3.4; use it() or self.it
+        #
+        def parenthesized_it_method_in_block?(node)
+          return false unless node.method?(:it)
+          return false unless (block_node = node.each_ancestor(:block).first)
+          return false unless block_node.arguments.empty_and_without_delimiters?
+
+          !node.receiver && node.arguments.empty? && !node.block_literal?
+        end
+
         def any_assignment?(node)
           node.each_ancestor(*AST::Node::ASSIGNMENTS).any? do |asgn_node|
             # `obj.method = value` parses as (send ... :method= ...), and will

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

@@ -170,7 +170,7 @@ module RuboCop
           return true if node.arguments.any? do |arg|
             arg.forward_arg_type? || arg.restarg_type? || arg.kwrestarg_type?
           end
-          return false unless (last_argument = node.arguments.last)
+          return false unless (last_argument = node.last_argument)
 
           last_argument.blockarg_type? && last_argument.name.nil?
         end

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

@@ -7,12 +7,12 @@ module RuboCop
       # defining `respond_to_missing?`.
       #
       # @example
-      #   #bad
+      #   # bad
       #   def method_missing(name, *args)
       #     # ...
       #   end
       #
-      #   #good
+      #   # good
       #   def respond_to_missing?(name, include_private)
       #     # ...
       #   end