rubocop 1.66.0 → 1.72.1

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

@@ -10,8 +10,10 @@ module RuboCop
       # (`Hash#except` was added in Ruby 3.0.)
       #
       # For safe detection, it is limited to commonly used string and symbol comparisons
-      # when used `==`.
-      # And do not check `Hash#delete_if` and `Hash#keep_if` to change receiver object.
+      # when using `==` or `!=`.
+      #
+      # This cop doesn't check for `Hash#delete_if` and `Hash#keep_if` because they
+      # modify the receiver.
       #
       # @safety
       #   This cop is unsafe because it cannot be guaranteed that the receiver
@@ -23,6 +25,9 @@ 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) }
@@ -30,161 +35,44 @@ module RuboCop
       #   # good
       #   {foo: 1, bar: 2, baz: 3}.except(:bar)
       #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #
+      #   # good
+      #   {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) }
+      #
+      #   # good
+      #   {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]) }
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #
+      #   # 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)
+      #
       class HashExcept < Base
-        include RangeHelp
+        include HashSubset
         extend TargetRubyVersion
         extend AutoCorrector
 
         minimum_target_ruby_version 3.0
 
-        MSG = 'Use `%<prefer>s` instead.'
-        RESTRICT_ON_SEND = %i[reject select filter].freeze
-
-        # @!method bad_method_with_poro?(node)
-        def_node_matcher :bad_method_with_poro?, <<~PATTERN
-          (block
-            (call _ _)
-            (args
-              $(arg _)
-              (arg _))
-            {
-              $(send
-                _ {:== :!= :eql? :include?} _)
-              (send
-                $(send
-                  _ {:== :!= :eql? :include?} _) :!)
-              })
-        PATTERN
-
-        # @!method bad_method_with_active_support?(node)
-        def_node_matcher :bad_method_with_active_support?, <<~PATTERN
-          (block
-            (send _ _)
-            (args
-              $(arg _)
-              (arg _))
-            {
-              $(send
-                _ {:== :!= :eql? :in? :include? :exclude?} _)
-              (send
-                $(send
-                  _ {:== :!= :eql? :in? :include? :exclude?} _) :!)
-              })
-        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)
-
-          except_key = except_key(block)
-          return if except_key.nil? || !safe_to_register_offense?(block, except_key)
-
-          range = offense_range(node)
-          preferred_method = "except(#{except_key_source(except_key)})"
-
-          add_offense(range, message: format(MSG, prefer: preferred_method)) do |corrector|
-            corrector.replace(range, preferred_method)
-          end
-        end
-        alias on_csend on_send
-
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def bad_method?(method_name, block)
-          if active_support_extensions_enabled?
-            bad_method_with_active_support?(block) do |key_arg, send_node|
-              if send_node.method?(:in?) && send_node.receiver&.source != key_arg.source
-                return false
-              end
-              return true if !send_node.method?(:include?) && !send_node.method?(:exclude?)
-
-              send_node.first_argument&.source == key_arg.source
-            end
-          else
-            bad_method_with_poro?(block) do |key_arg, send_node|
-              return false if method_name == :reject && block.body.method?(:!)
-
-              !send_node.method?(:include?) || send_node.first_argument&.source == key_arg.source
-            end
-          end
-        end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-        def semantically_except_method?(send, block)
-          body = block.body
-
-          negated = body.method?('!')
-          body = body.receiver if negated
-
-          case send.method_name
-          when :reject
-            body.method?('==') || body.method?('eql?') || included?(negated, body)
-          when :select, :filter
-            body.method?('!=') || not_included?(negated, body)
-          else
-            false
-          end
-        end
-
-        def included?(negated, body)
-          body.method?('include?') || body.method?('in?') || (negated && body.method?('exclude?'))
-        end
-
-        def not_included?(negated, body)
-          body.method?('exclude?') || (negated && (body.method?('include?') || body.method?('in?')))
-        end
-
-        def safe_to_register_offense?(block, except_key)
-          extracted = extract_body_if_negated(block.body)
-          if extracted.method?('in?') || extracted.method?('include?') ||
-             extracted.method?('exclude?')
-            return true
-          end
-          return true if block.body.method?('eql?')
-
-          except_key.sym_type? || except_key.str_type?
-        end
-
-        def extract_body_if_negated(body)
-          return body unless body.method?('!')
-
-          body.receiver
-        end
-
-        def except_key_source(key)
-          if key.array_type?
-            key = if key.percent_literal?
-                    key.each_value.map { |v| decorate_source(v) }
-                  else
-                    key.each_value.map(&:source)
-                  end
-            return key.join(', ')
-          end
-
-          key.literal? ? key.source : "*#{key.source}"
-        end
-
-        def decorate_source(value)
-          return ":\"#{value.source}\"" if value.dsym_type?
-          return "\"#{value.source}\"" if value.dstr_type?
-          return ":#{value.source}" if value.sym_type?
-
-          "'#{value.source}'"
-        end
-
-        def except_key(node)
-          key_argument = node.argument_list.first.source
-          body = extract_body_if_negated(node.body)
-          lhs, _method_name, rhs = *body
-          return if [lhs, rhs].map(&:source).none?(key_argument)
-
-          [lhs, rhs].find { |operand| operand.source != key_argument }
+        def semantically_subset_method?(node)
+          semantically_except_method?(node)
         end
 
-        def offense_range(node)
-          range_between(node.loc.selector.begin_pos, node.parent.loc.end.end_pos)
+        def preferred_method_name
+          'except'
         end
       end
     end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods
+      # that can be replaced with `Hash#slice` method.
+      #
+      # This cop should only be enabled on Ruby version 2.5 or higher.
+      # (`Hash#slice` was added in Ruby 2.5.)
+      #
+      # For safe detection, it is limited to commonly used string and symbol comparisons
+      # when using `==` or `!=`.
+      #
+      # This cop doesn't check for `Hash#delete_if` and `Hash#keep_if` because they
+      # modify the receiver.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement method.
+      #
+      # @example
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k == :bar }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| k != :bar }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| k == :bar }
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k.eql?(:bar) }
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| %i[bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| !%i[bar].include?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.filter {|k, v| %i[bar].include?(k) }
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.slice(:bar)
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[bar].exclude?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[bar].exclude?(k) }
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k.in?(%i[bar]) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| !k.in?(%i[bar]) }
+      #
+      # @example AllCops:ActiveSupportExtensionsEnabled: true
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| !%i[bar].exclude?(k) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| %i[bar].exclude?(k) }
+      #
+      #   # bad
+      #   {foo: 1, bar: 2, baz: 3}.select {|k, v| k.in?(%i[bar]) }
+      #   {foo: 1, bar: 2, baz: 3}.reject {|k, v| !k.in?(%i[bar]) }
+      #
+      #   # good
+      #   {foo: 1, bar: 2, baz: 3}.slice(:bar)
+      #
+      class HashSlice < Base
+        include HashSubset
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        minimum_target_ruby_version 2.5
+
+        private
+
+        def semantically_subset_method?(node)
+          semantically_slice_method?(node)
+        end
+
+        def preferred_method_name
+          'slice'
+        end
+      end
+    end
+  end
+end

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

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

@@ -203,17 +203,36 @@ module RuboCop
               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
 
+        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|

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

@@ -103,7 +103,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 +112,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

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

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

@@ -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,14 +33,17 @@ module RuboCop
           add_offense(node, message: message) do |corrector|
             autocorrect(corrector, node)
           end
+
+          ignore_node(node)
         end
 
         private
 
         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?
+                     elsif node.else_branch&.type?(:if, :begin) ||
+                           use_masgn_or_block_in_branches?(node)
                        MSG_IF_ELSE
                      else
                        MSG_TERNARY
@@ -49,13 +53,27 @@ module RuboCop
         end
 
         def autocorrect(corrector, node)
-          if node.if_branch&.begin_type? || node.else_branch&.begin_type?
+          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?
 
@@ -74,16 +92,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
@@ -104,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/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,7 +41,6 @@ module RuboCop
       #     f != 1
       #   end
       class InverseMethods < Base
-        include IgnoredNode
         include RangeHelp
         extend AutoCorrector
 
@@ -61,18 +60,18 @@ 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)

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