rubocop 1.66.1 → 1.69.1

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

@@ -23,10 +23,21 @@ module RuboCop
       #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k == :bar }
       #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k != :bar }
       #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k != :bar }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k.eql?(:bar) }
+      #
+      #   # bad
       #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[bar].include?(k) }
       #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[bar].include?(k) }
       #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| !%i[bar].include?(k) }
       #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| !%i[bar].exclude?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| %i[bar].exclude?(k) }
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k.in?(%i[bar]) }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !k.in?(%i[bar]) }
+      #
       #   # good
       #   {foo: 1, bar: 2, baz: 3}.except(:bar)
       #
@@ -73,9 +84,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          method_name = node.method_name
           block = node.parent
-          return unless bad_method?(method_name, block) && semantically_except_method?(node, block)
+          return unless bad_method?(block) && semantically_except_method?(node, block)
 
           except_key = except_key(block)
           return if except_key.nil? || !safe_to_register_offense?(block, except_key)
@@ -92,7 +102,7 @@ module RuboCop
         private
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def bad_method?(method_name, block)
+        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
@@ -104,8 +114,6 @@ module RuboCop
             end
           else
             bad_method_with_poro?(block) do |key_arg, send_node|
-              return false if method_name == :reject && block.body.method?(:!)
-
               !send_node.method?(:include?) || send_node.first_argument&.source == key_arg.source
             end
           end
@@ -129,11 +137,15 @@ module RuboCop
         end
 
         def included?(negated, body)
-          body.method?('include?') || body.method?('in?') || (negated && body.method?('exclude?'))
+          if negated
+            body.method?('exclude?')
+          else
+            body.method?('include?') || body.method?('in?')
+          end
         end
 
         def not_included?(negated, body)
-          body.method?('exclude?') || (negated && (body.method?('include?') || body.method?('in?')))
+          included?(!negated, body)
         end
 
         def safe_to_register_offense?(block, except_key)

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

@@ -68,7 +68,7 @@ module RuboCop
       #   {a: 1, b: 2}
       #   {:c => 3, 'd' => 4}
       #
-      # @example EnforcedShorthandSyntax: always (default)
+      # @example EnforcedShorthandSyntax: always
       #
       #   # bad
       #   {foo: foo, bar: bar}
@@ -84,7 +84,7 @@ module RuboCop
       #   # good
       #   {foo: foo, bar: bar}
       #
-      # @example EnforcedShorthandSyntax: either
+      # @example EnforcedShorthandSyntax: either (default)
       #
       #   # good
       #   {foo: foo, bar: bar}

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|

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

@@ -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

@@ -23,6 +23,7 @@ module RuboCop
 
         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?(';')
@@ -32,13 +33,14 @@ module RuboCop
           add_offense(node, message: message) do |corrector|
             autocorrect(corrector, node)
           end
+
+          ignore_node(node)
         end
 
         private
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def message(node)
-          template = if node.if_branch&.begin_type?
+          template = if require_newline?(node)
                        MSG_NEWLINE
                      elsif node.else_branch&.if_type? || node.else_branch&.begin_type? ||
                            use_block_in_branches?(node)
@@ -49,20 +51,27 @@ module RuboCop
 
           format(template, expr: node.condition.source)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def autocorrect(corrector, node)
-          if node.branches.compact.any?(&:begin_type?) || use_block_in_branches?(node)
+          if require_newline?(node) || use_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_block_in_branches?(node)
           node.branches.compact.any? { |branch| branch.block_type? || branch.numblock_type? }
         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?
 
@@ -81,16 +90,14 @@ module RuboCop
           RUBY
         end
 
-        # rubocop:disable Metrics/AbcSize
         def build_expression(expr)
-          return expr.source if !expr.call_type? || expr.parenthesized? || expr.arguments.empty?
+          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
-        # rubocop:enable Metrics/AbcSize
 
         def build_else_branch(second_condition)
           result = <<~RUBY
@@ -111,6 +118,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/inverse_methods.rb

@@ -41,7 +41,6 @@ module RuboCop
       #     f != 1
       #   end
       class InverseMethods < Base
-        include IgnoredNode
         include RangeHelp
         extend AutoCorrector
 

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

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

@@ -68,7 +68,7 @@ module RuboCop
 
           return unless offending_selector?(node, selector)
 
-          add_offense(node.send_node.source_range, message: message(node, selector)) do |corrector|
+          add_offense(node.send_node, message: message(node, selector)) do |corrector|
             if node.send_node.lambda_literal?
               LambdaLiteralToMethodCorrector.new(node).call(corrector)
             else

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

@@ -20,7 +20,6 @@ module RuboCop
       #  lambda.(x, y)
       class LambdaCall < Base
         include ConfigurableEnforcedStyle
-        include IgnoredNode
         extend AutoCorrector
 
         MSG = 'Prefer the use of `%<prefer>s` over `%<current>s`.'
@@ -45,6 +44,7 @@ module RuboCop
             correct_style_detected
           end
         end
+        alias on_csend on_send
 
         private
 
@@ -55,9 +55,10 @@ module RuboCop
         def prefer(node)
           receiver = node.receiver.source
           arguments = node.arguments.map(&:source).join(', ')
+          dot = node.loc.dot.source
           method = explicit_style? ? "call(#{arguments})" : "(#{arguments})"
 
-          "#{receiver}.#{method}"
+          "#{receiver}#{dot}#{method}"
         end
 
         def implicit_style?

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

@@ -13,8 +13,10 @@ module RuboCop
       # 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.
+      # NOTE: It only detects when the mapping destination is either:
+      # * a local variable initialized as an empty array and referred to only by the
+      # pushing operation;
+      # * or, if it is the single block argument to a `[].tap` block.
       # This is because, if not, it's challenging to statically guarantee that the
       # mapping destination variable remains an empty array:
       #
@@ -42,6 +44,14 @@ module RuboCop
       #   # good
       #   dest = src.map { |e| e * 2 }
       #
+      #   # bad
+      #   [].tap do |dest|
+      #     src.each { |e| dest << e * 2 }
+      #   end
+      #
+      #   # good
+      #   dest = src.map { |e| e * 2 }
+      #
       #   # good - contains another operation
       #   dest = []
       #   src.each { |e| dest << e * 2; puts e }
@@ -53,12 +63,17 @@ module RuboCop
 
         MSG = 'Use `%<new_method_name>s` instead of `each` to map elements into an array.'
 
+        # @!method suitable_argument_node?(node)
+        def_node_matcher :suitable_argument_node?, <<-PATTERN
+          !{splat forwarded-restarg forwarded-args (hash (forwarded-kwrestarg)) (block-pass nil?)}
+        PATTERN
+
         # @!method each_block_with_push?(node)
         def_node_matcher :each_block_with_push?, <<-PATTERN
           [
-            ^({begin kwbegin} ...)
+            ^({begin kwbegin block} ...)
             ({block numblock} (send !{nil? self} :each) _
-              (send (lvar _) {:<< :push :append} {send lvar begin}))
+              (send (lvar _) {:<< :push :append} #suitable_argument_node?))
           ]
         PATTERN
 
@@ -74,6 +89,16 @@ module RuboCop
           )
         PATTERN
 
+        # @!method empty_array_tap(node)
+        def_node_matcher :empty_array_tap, <<~PATTERN
+          ^^$(
+            block
+              (send (array) :tap)
+              (args (arg _))
+              ...
+          )
+        PATTERN
+
         # @!method lvar_ref?(node, name)
         def_node_matcher :lvar_ref?, '(lvar %1)'
 
@@ -89,9 +114,14 @@ module RuboCop
           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)
+
+          if offending_empty_array_tap?(node, dest_var)
+            asgn = dest_var.declaration_node
+          else
+            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)
+          end
 
           register_offense(node, dest_var, asgn)
         end
@@ -108,6 +138,15 @@ module RuboCop
           candidates.find { |v| v.references.any? { |n| n.node.equal?(node) } }
         end
 
+        def offending_empty_array_tap?(node, dest_var)
+          return false unless (tap_block_node = empty_array_tap(dest_var.declaration_node))
+
+          # A `tap` block only offends if the array push is the only thing in it;
+          # otherwise we cannot guarantee that the block variable is still an empty
+          # array when pushed to.
+          tap_block_node.body == 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
@@ -127,7 +166,13 @@ module RuboCop
             next if return_value_used?(block)
 
             corrector.replace(block.send_node.selector, new_method_name)
-            remove_assignment(corrector, asgn)
+
+            if (tap_block_node = empty_array_tap(dest_var.declaration_node))
+              remove_tap(corrector, block, tap_block_node)
+            else
+              remove_assignment(corrector, asgn)
+            end
+
             correct_push_node(corrector, block.body)
             correct_return_value_handling(corrector, block, dest_var)
           end
@@ -159,6 +204,12 @@ module RuboCop
           corrector.remove(range)
         end
 
+        def remove_tap(corrector, node, block_node)
+          range = range_between(block_node.source_range.begin_pos, node.source_range.begin_pos)
+          corrector.remove(range)
+          corrector.remove(range_with_surrounding_space(block_node.loc.end, side: :left))
+        end
+
         def correct_push_node(corrector, push_node)
           range = push_node.source_range
           arg_range = push_node.first_argument.source_range

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

@@ -7,6 +7,8 @@ module RuboCop
         # Style omit_parentheses
         # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
         module OmitParentheses
+          include RangeHelp
+
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
           OMIT_MSG = 'Omit parentheses for method calls with arguments.'
           private_constant :OMIT_MSG
@@ -30,10 +32,13 @@ module RuboCop
           end
 
           def autocorrect(corrector, node)
+            range = args_begin(node)
             if parentheses_at_the_end_of_multiline_call?(node)
-              corrector.replace(args_begin(node), ' \\')
+              # Whitespace after line continuation (`\ `) is a syntax error
+              with_whitespace = range_with_surrounding_space(range, side: :right, newlines: false)
+              corrector.replace(with_whitespace, ' \\')
             else
-              corrector.replace(args_begin(node), ' ')
+              corrector.replace(range, ' ')
             end
             corrector.remove(node.loc.end)
           end
@@ -47,11 +52,11 @@ module RuboCop
             node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
           end
 
-          def require_parentheses_for_hash_value_omission?(node)
+          def require_parentheses_for_hash_value_omission?(node) # rubocop:disable Metrics/PerceivedComplexity
             return false unless (last_argument = node.last_argument)
             return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
 
-            node.parent&.conditional? || !last_expression?(node)
+            node.parent&.conditional? || node.parent&.single_line? || !last_expression?(node)
           end
 
           # Require hash value omission be enclosed in parentheses to prevent the following issue:
@@ -127,7 +132,7 @@ module RuboCop
           end
 
           def call_in_single_line_inheritance?(node)
-            node.parent&.class_type? && node.parent&.single_line?
+            node.parent&.class_type? && node.parent.single_line?
           end
 
           def call_with_ambiguous_arguments?(node) # rubocop:disable Metrics/PerceivedComplexity
@@ -147,7 +152,7 @@ module RuboCop
           end
 
           def call_in_argument_with_block?(node)
-            parent = node.parent&.block_type? && node.parent&.parent
+            parent = node.parent&.block_type? && node.parent.parent
             return false unless parent
 
             parent.call_type? || parent.super_type? || parent.yield_type?
@@ -198,7 +203,7 @@ module RuboCop
           end
 
           def logical_operator?(node)
-            (node.and_type? || node.or_type?) && node.logical_operator?
+            node.operator_keyword? && node.logical_operator?
           end
 
           def hash_literal?(node)
@@ -211,7 +216,7 @@ module RuboCop
 
           def unary_literal?(node)
             (node.numeric_type? && node.sign?) ||
-              (node.parent&.send_type? && node.parent&.unary_operation?)
+              (node.parent&.send_type? && node.parent.unary_operation?)
           end
 
           def assigned_before?(node, target)

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

@@ -71,9 +71,11 @@ module RuboCop
           return false if node.receiver
 
           any_assignment?(node) do |asgn_node|
-            next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?
-
-            asgn_node.loc.name.source == node.method_name.to_s
+            if asgn_node.masgn_type?
+              variable_in_mass_assignment?(node.method_name, asgn_node)
+            else
+              asgn_node.loc.name.source == node.method_name.to_s
+            end
           end
         end
 
@@ -98,20 +100,14 @@ module RuboCop
             # `obj.method ||= value` parses as (or-asgn (send ...) ...)
             # which IS an `asgn_node`. Similarly, `obj.method += value` parses
             # as (op-asgn (send ...) ...), which is also an `asgn_node`.
-            if asgn_node.shorthand_asgn?
-              asgn_node, _value = *asgn_node
-              next if asgn_node.send_type?
-            end
+            next if asgn_node.shorthand_asgn? && asgn_node.lhs.send_type?
 
             yield asgn_node
           end
         end
 
         def variable_in_mass_assignment?(variable_name, node)
-          mlhs_node, _mrhs_node = *node
-          var_nodes = *mlhs_node
-
-          var_nodes.any? { |n| n.to_a.first == variable_name }
+          node.assignments.any? { |n| n.name == variable_name }
         end
 
         def offense_range(node)

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

@@ -6,19 +6,49 @@ module RuboCop
       # Checks for the presence of `method_missing` without also
       # defining `respond_to_missing?`.
       #
+      # Not defining `respond_to_missing?` will cause metaprogramming
+      # methods like `respond_to?` to behave unexpectedly:
+      #
+      # [source,ruby]
+      # ----
+      # class StringDelegator
+      #   def initialize(string)
+      #     @string = string
+      #   end
+      #
+      #   def method_missing(name, *args)
+      #     @string.send(name, *args)
+      #   end
+      # end
+      #
+      # delegator = StringDelegator.new("foo")
+      # # Claims to not respond to `upcase`.
+      # delegator.respond_to?(:upcase) # => false
+      # # But you can call it.
+      # delegator.upcase # => FOO
+      # ----
+      #
       # @example
       #   # bad
       #   def method_missing(name, *args)
-      #     # ...
+      #     if @delegate.respond_to?(name)
+      #       @delegate.send(name, *args)
+      #     else
+      #       super
+      #     end
       #   end
       #
       #   # good
       #   def respond_to_missing?(name, include_private)
-      #     # ...
+      #     @delegate.respond_to?(name) || super
       #   end
       #
       #   def method_missing(name, *args)
-      #     # ...
+      #     if @delegate.respond_to?(name)
+      #       @delegate.send(name, *args)
+      #     else
+      #       super
+      #     end
       #   end
       #
       class MissingRespondToMissing < Base

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

@@ -39,11 +39,11 @@ module RuboCop
         BRACES_MSG = 'Wrap multiline memoization blocks in `(` and `)`.'
 
         def on_or_asgn(node)
-          _lhs, rhs = *node
+          rhs = node.expression
 
           return unless bad_rhs?(rhs)
 
-          add_offense(node.source_range) do |corrector|
+          add_offense(node) do |corrector|
             if style == :keyword
               keyword_autocorrect(rhs, corrector)
             else