Fix to recognize safe navigation when config is enabled

lovro-bikic · bbatsov · commit 4981738e7546 · 2025-01-10T09:30:44.000+02:00
diff --git a/changelog/fix_style_hash_except_when_using_safe_navigation_with_active_support.md b/changelog/fix_style_hash_except_when_using_safe_navigation_with_active_support.md
@@ -0,0 +1 @@
+* [#13517](https://github.com/rubocop/rubocop/pull/13517): Fixes `Style/HashExcept` to recognize safe navigation when `ActiveSupportExtensionsEnabled` config is enabled. ([@lovro-bikic][])
diff --git a/lib/rubocop/cop/style/hash_except.rb b/lib/rubocop/cop/style/hash_except.rb
@@ -10,8 +10,10 @@ module Style
       # (`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
@@ -51,44 +53,31 @@ class HashExcept < Base
         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
+        SUBSET_METHODS = %i[== != eql? include?].freeze
+        ACTIVE_SUPPORT_SUBSET_METHODS = (SUBSET_METHODS + %i[in? exclude?]).freeze
 
-        # @!method bad_method_with_active_support?(node)
-        def_node_matcher :bad_method_with_active_support?, <<~PATTERN
+        # @!method block_with_first_arg_check?(node)
+        def_node_matcher :block_with_first_arg_check?, <<~PATTERN
           (block
-            (send _ _)
+            (call _ _)
             (args
-              $(arg _)
+              $(arg _key)
               (arg _))
             {
               $(send
-                _ {:== :!= :eql? :in? :include? :exclude?} _)
+                {(lvar _key) $_ _ | _ $_ (lvar _key)})
               (send
                 $(send
-                  _ {:== :!= :eql? :in? :include? :exclude?} _) :!)
+                  {(lvar _key) $_ _ | _ $_ (lvar _key)}) :!)
               })
         PATTERN
 
         def on_send(node)
           block = node.parent
-          return unless bad_method?(block) && semantically_except_method?(node, block)
+          return unless extracts_hash_subset?(block) && semantically_except_method?(node, block)
 
           except_key = except_key(block)
-          return if except_key.nil? || !safe_to_register_offense?(block, except_key)
+          return unless safe_to_register_offense?(block, except_key)
 
           range = offense_range(node)
           preferred_method = "except(#{except_key_source(except_key)})"
@@ -101,68 +90,67 @@ def on_send(node)
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        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
-                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|
-              !send_node.method?(:include?) || send_node.first_argument&.source == key_arg.source
+        def extracts_hash_subset?(block)
+          block_with_first_arg_check?(block) do |key_arg, send_node, method|
+            return false unless supported_subset_method?(method)
+
+            case method
+            when :include?, :exclude?
+              send_node.first_argument.source == key_arg.source
+            when :in?
+              send_node.receiver.source == key_arg.source
+            else
+              true
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        def semantically_except_method?(send, block)
-          body = block.body
+        def supported_subset_method?(method)
+          if active_support_extensions_enabled?
+            ACTIVE_SUPPORT_SUBSET_METHODS.include?(method)
+          else
+            SUBSET_METHODS.include?(method)
+          end
+        end
 
-          negated = body.method?('!')
-          body = body.receiver if negated
+        def semantically_except_method?(node, block)
+          body, negated = extract_body_if_negated(block.body)
 
-          case send.method_name
-          when :reject
-            body.method?('==') || body.method?('eql?') || included?(negated, body)
-          when :select, :filter
-            body.method?('!=') || not_included?(negated, body)
+          if node.method?('reject')
+            body.method?('==') || body.method?('eql?') || included?(body, negated)
           else
-            false
+            body.method?('!=') || not_included?(body, negated)
           end
         end
 
-        def included?(negated, body)
+        def included?(body, negated)
           if negated
             body.method?('exclude?')
           else
             body.method?('include?') || body.method?('in?')
           end
         end
 
-        def not_included?(negated, body)
-          included?(!negated, body)
+        def not_included?(body, negated)
+          included?(body, !negated)
         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?')
+          body = block.body
 
-          except_key.sym_type? || except_key.str_type?
+          if body.method?('==') || body.method?('!=')
+            except_key.sym_type? || except_key.str_type?
+          else
+            true
+          end
         end
 
         def extract_body_if_negated(body)
-          return body unless body.method?('!')
-
-          body.receiver
+          if body.method?('!')
+            [body.receiver, true]
+          else
+            [body, false]
+          end
         end
 
         def except_key_source(key)
@@ -187,12 +175,11 @@ def decorate_source(value)
         end
 
         def except_key(node)
-          key_argument = node.argument_list.first.source
-          body = extract_body_if_negated(node.body)
+          key_arg = 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 }
+          lhs.source == key_arg ? rhs : lhs
         end
 
         def offense_range(node)
diff --git a/spec/rubocop/cop/style/hash_except_spec.rb b/spec/rubocop/cop/style/hash_except_spec.rb
@@ -96,6 +96,18 @@
           {foo: 1, bar: 2, baz: 3}.reject { |k, v| k.in?(%i[foo bar]) }
         RUBY
       end
+
+      it 'does not register offenses when using safe navigation `reject` and calling `key.in?` method with symbol array' do
+        expect_no_offenses(<<~RUBY)
+          {foo: 1, bar: 2, baz: 3}&.reject { |k, v| k.in?(%i[foo bar]) }
+        RUBY
+      end
+
+      it 'does not register offenses when using `reject` and calling `in?` method with key' do
+        expect_no_offenses(<<~RUBY)
+          {foo: 1, bar: 2, baz: 3}.reject { |k, v| %i[foo bar].in?(k) }
+        RUBY
+      end
     end
 
     context 'using `include?`' do
@@ -188,6 +200,12 @@
         RUBY
       end
 
+      it 'does not register offenses when using safe navigation `reject` and calling `!exclude?` method with symbol array' do
+        expect_no_offenses(<<~RUBY)
+          {foo: 1, bar: 2, baz: 3}&.reject { |k, v| !%i[foo bar].exclude?(k) }
+        RUBY
+      end
+
       it 'does not register an offense when using `reject` and calling `exclude?` method on a key' do
         expect_no_offenses(<<~RUBY)
           {foo: 1, bar: 2, baz: 3}.reject { |k, v| k.exclude?('oo') }
@@ -207,6 +225,24 @@
       RUBY
     end
 
+    it 'does not register an offense when using `select` and other than comparison by string and symbol using `!=`' do
+      expect_no_offenses(<<~RUBY)
+        hash.select { |k, v| k != 0.0 }
+      RUBY
+    end
+
+    it 'does not register an offense when using `select` and other than comparison by string and symbol using `==` with bang' do
+      expect_no_offenses(<<~RUBY)
+        hash.select { |k, v| !(k == 0.0) }
+      RUBY
+    end
+
+    it 'does not register an offense when using `reject` and other than comparison by string and symbol using `!=` with bang' do
+      expect_no_offenses(<<~RUBY)
+        hash.reject { |k, v| !(k != 0.0) }
+      RUBY
+    end
+
     it 'does not register an offense when using `delete_if` and comparing with `lvar == :sym`' do
       expect_no_offenses(<<~RUBY)
         {foo: 1, bar: 2, baz: 3}.delete_if { |k, v| k == :bar }
@@ -225,6 +261,18 @@
       RUBY
     end
 
+    it 'does not register an offense when using more than two block arguments' do
+      expect_no_offenses(<<~RUBY)
+        {foo: 1, bar: 2, baz: 3}.reject { |k, v, o| k == :bar }
+      RUBY
+    end
+
+    it 'does not register an offense when calling `include?` method without a param' do
+      expect_no_offenses(<<~RUBY)
+        {foo: 1, bar: 2, baz: 3}.reject { |k, v| %i[foo bar].include? }
+      RUBY
+    end
+
     context 'when `AllCops/ActiveSupportExtensionsEnabled: true`' do
       let(:config) do
         RuboCop::Config.new('AllCops' => {
@@ -322,6 +370,17 @@
           RUBY
         end
 
+        it 'registers and corrects an offense when using safe navigation `reject` and calling `key.in?` method with symbol array' do
+          expect_offense(<<~RUBY)
+            {foo: 1, bar: 2, baz: 3}&.reject { |k, v| k.in?(%i[foo bar]) }
+                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `except(:foo, :bar)` instead.
+          RUBY
+
+          expect_correction(<<~RUBY)
+            {foo: 1, bar: 2, baz: 3}&.except(:foo, :bar)
+          RUBY
+        end
+
         it 'registers and corrects an offense when using `select` and calling `!key.in?` method with symbol array' do
           expect_offense(<<~RUBY)
             {foo: 1, bar: 2, baz: 3}.select { |k, v| !k.in?(%i[foo bar]) }
@@ -396,6 +455,12 @@
           RUBY
         end
 
+        it 'does not register an offense when using `reject` and calling `in?` method with key' do
+          expect_no_offenses(<<~RUBY)
+            {foo: 1, bar: 2, baz: 3}.reject { |k, v| %i[foo bar].in?(k) }
+          RUBY
+        end
+
         it 'does not register an offense when using `reject` and calling `in?` method with symbol array and second block value' do
           expect_no_offenses(<<~RUBY)
             {foo: 1, bar: 2, baz: 3}.reject { |k, v| v.in?([1, 2]) }
@@ -503,6 +568,17 @@
           RUBY
         end
 
+        it 'registers and corrects an offense when using safe navigation `reject` and calling `!exclude?` method with symbol array' do
+          expect_offense(<<~RUBY)
+            {foo: 1, bar: 2, baz: 3}&.reject { |k, v| !%i[foo bar].exclude?(k) }
+                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Use `except(:foo, :bar)` instead.
+          RUBY
+
+          expect_correction(<<~RUBY)
+            {foo: 1, bar: 2, baz: 3}&.except(:foo, :bar)
+          RUBY
+        end
+
         it 'registers and corrects an offense when using `select` and calling `exclude?` method with symbol array' do
           expect_offense(<<~RUBY)
             {foo: 1, bar: 2, baz: 3}.select { |k, v| %i[foo bar].exclude?(k) }
@@ -602,6 +678,24 @@
         RUBY
       end
 
+      it 'does not register an offense when using `select` and other than comparison by string and symbol using `!=`' do
+        expect_no_offenses(<<~RUBY)
+          hash.select { |k, v| k != 0.0 }
+        RUBY
+      end
+
+      it 'does not register an offense when using `select` and other than comparison by string and symbol using `==` with bang' do
+        expect_no_offenses(<<~RUBY)
+          hash.select { |k, v| !(k == 0.0) }
+        RUBY
+      end
+
+      it 'does not register an offense when using `reject` and other than comparison by string and symbol using `!=` with bang' do
+        expect_no_offenses(<<~RUBY)
+          hash.reject { |k, v| !(k != 0.0) }
+        RUBY
+      end
+
       it 'does not register an offense when using `delete_if` and comparing with `lvar == :sym`' do
         expect_no_offenses(<<~RUBY)
           {foo: 1, bar: 2, baz: 3}.delete_if { |k, v| k == :bar }
@@ -619,6 +713,18 @@
           {foo: 1, bar: 2, baz: 3}.reject { |k, v| v.eql? :bar }
         RUBY
       end
+
+      it 'does not register an offense when using more than two block arguments' do
+        expect_no_offenses(<<~RUBY)
+          {foo: 1, bar: 2, baz: 3}.reject { |k, v, z| k == :bar }
+        RUBY
+      end
+
+      it 'does not register an offense when calling `include?` method without a param' do
+        expect_no_offenses(<<~RUBY)
+          {foo: 1, bar: 2, baz: 3}.reject { |k, v| %i[foo bar].include? }
+        RUBY
+      end
     end
 
     it 'does not register an offense when using `reject` and comparing with `lvar != :key`' do

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+* [#13517](https://github.com/rubocop/rubocop/pull/13517): Fixes `Style/HashExcept` to recognize safe navigation when `ActiveSupportExtensionsEnabled` config is enabled. ([@lovro-bikic][])