rubocop 1.69.0 → 1.79.2

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

@@ -8,7 +8,7 @@ module RuboCop
       #
       # * `scientific` which enforces a mantissa between 1 (inclusive) and 10 (exclusive).
       # * `engineering` which enforces the exponent to be a multiple of 3 and the mantissa
-      #   to be between 0.1 (inclusive) and 10 (exclusive).
+      #   to be between 0.1 (inclusive) and 1000 (exclusive).
       # * `integral` which enforces the mantissa to always be a whole number without
       #   trailing zeroes.
       #
@@ -59,9 +59,10 @@ module RuboCop
       #
       class ExponentialNotation < Base
         include ConfigurableEnforcedStyle
+
         MESSAGES = {
-          scientific: 'Use a mantissa in [1, 10[.',
-          engineering: 'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.',
+          scientific: 'Use a mantissa >= 1 and < 10.',
+          engineering: 'Use an exponent divisible by 3 and a mantissa >= 0.1 and < 1000.',
           integral: 'Use an integer as mantissa, without trailing zero.'
         }.freeze
 
@@ -87,7 +88,7 @@ module RuboCop
           true
         end
 
-        def integral(node)
+        def integral?(node)
           mantissa, = node.source.split('e')
           /^-?[1-9](\d*[1-9])?$/.match?(mantissa)
         end
@@ -101,7 +102,7 @@ module RuboCop
           when :engineering
             !engineering?(node)
           when :integral
-            !integral(node)
+            !integral?(node)
           else
             false
           end

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

@@ -6,10 +6,23 @@ module RuboCop
       # Suggests `ENV.fetch` for the replacement of `ENV[]`.
       # `ENV[]` silently fails and returns `nil` when the environment variable is unset,
       # which may cause unexpected behaviors when the developer forgets to set it.
-      # On the other hand, `ENV.fetch` raises KeyError or returns the explicitly
+      # On the other hand, `ENV.fetch` raises `KeyError` or returns the explicitly
       # specified default value.
       #
-      # @example
+      # @example DefaultToNil: true (default)
+      #   # bad
+      #   ENV['X']
+      #   x = ENV['X']
+      #
+      #   # good
+      #   ENV.fetch('X', nil)
+      #   x = ENV.fetch('X', nil)
+      #
+      #   # also good
+      #   !ENV['X']
+      #   ENV['X'].some_method # (e.g. `.nil?`)
+      #
+      # @example DefaultToNil: false
       #   # bad
       #   ENV['X']
       #   x = ENV['X']
@@ -25,7 +38,9 @@ module RuboCop
       class FetchEnvVar < Base
         extend AutoCorrector
 
-        MSG = 'Use `ENV.fetch(%<key>s)` or `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+        MSG_WITH_NIL = 'Use `ENV.fetch(%<key>s, nil)` instead of `ENV[%<key>s]`.'
+        MSG_WITHOUT_NIL = 'Use `ENV.fetch(%<key>s)` instead of `ENV[%<key>s]`.'
+        RESTRICT_ON_SEND = [:[]].freeze
 
         # @!method env_with_bracket?(node)
         def_node_matcher :env_with_bracket?, <<~PATTERN
@@ -36,7 +51,7 @@ module RuboCop
           env_with_bracket?(node) do |name_node|
             break unless offensive?(node)
 
-            message = format(MSG, key: name_node.source)
+            message = format(offense_message, key: name_node.source)
             add_offense(node, message: message) do |corrector|
               corrector.replace(node, new_code(name_node))
             end
@@ -45,6 +60,14 @@ module RuboCop
 
         private
 
+        def default_to_nil?
+          cop_config.fetch('DefaultToNil', true)
+        end
+
+        def offense_message
+          default_to_nil? ? MSG_WITH_NIL : MSG_WITHOUT_NIL
+        end
+
         def allowed_var?(node)
           env_key_node = node.children.last
           env_key_node.str_type? && cop_config['AllowedVars'].include?(env_key_node.value)
@@ -52,12 +75,12 @@ module RuboCop
 
         def used_as_flag?(node)
           return false if node.root?
-          return true if used_if_condition_in_body(node)
+          return true if used_if_condition_in_body?(node)
 
           node.parent.send_type? && (node.parent.prefix_bang? || node.parent.comparison_method?)
         end
 
-        def used_if_condition_in_body(node)
+        def used_if_condition_in_body?(node)
           if_node = node.ancestors.find(&:if_type?)
 
           return false unless (condition = if_node&.condition)
@@ -124,7 +147,11 @@ module RuboCop
         end
 
         def new_code(name_node)
-          "ENV.fetch(#{name_node.source}, nil)"
+          if default_to_nil?
+            "ENV.fetch(#{name_node.source}, nil)"
+          else
+            "ENV.fetch(#{name_node.source})"
+          end
         end
       end
     end

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

@@ -8,6 +8,12 @@ module RuboCop
       # Only looks for full string matches, substrings within a longer string are not
       # considered.
       #
+      # However, only files that use the string `'/dev/null'` are targeted for detection.
+      # This is because the string `'NUL'` is not limited to the null device.
+      # This behavior results in false negatives when the `'/dev/null'` string is not used,
+      # but it is a trade-off to avoid false positives. `NULL:`
+      # Unlike `'NUL'`, `'NUL:'` is regarded as something like `C:` and is always detected.
+      #
       # NOTE: Uses inside arrays and hashes are ignored.
       #
       # @safety
@@ -42,11 +48,21 @@ module RuboCop
         REGEXP = %r{\A(/dev/null|NUL:?)\z}i.freeze
         MSG = 'Use `File::NULL` instead of `%<source>s`.'
 
+        def on_new_investigation
+          return unless (ast = processed_source.ast)
+
+          @contain_dev_null_string_in_file = ast.each_descendant(:str).any? do |str|
+            content = str.str_content
+
+            valid_string?(content) && content.downcase == '/dev/null' # rubocop:disable Style/FileNull
+          end
+        end
+
         def on_str(node)
           value = node.value
-
-          return if invalid_string?(value)
+          return unless valid_string?(value)
           return if acceptable?(node)
+          return if value.downcase == 'nul' && !@contain_dev_null_string_in_file # rubocop:disable Style/FileNull
           return unless REGEXP.match?(value)
 
           add_offense(node, message: format(MSG, source: value)) do |corrector|
@@ -56,8 +72,8 @@ module RuboCop
 
         private
 
-        def invalid_string?(value)
-          value.empty? || !value.valid_encoding?
+        def valid_string?(value)
+          !value.empty? && value.valid_encoding?
         end
 
         def acceptable?(node)

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

@@ -65,19 +65,23 @@ module RuboCop
 
         # @!method right_coerce?(node)
         def_node_matcher :right_coerce?, <<~PATTERN
-          (send _ :/ (send _ :to_f))
+          (send _ :/ #to_f_method?)
         PATTERN
         # @!method left_coerce?(node)
         def_node_matcher :left_coerce?, <<~PATTERN
-          (send (send _ :to_f) :/ _)
+          (send #to_f_method? :/ _)
         PATTERN
         # @!method both_coerce?(node)
         def_node_matcher :both_coerce?, <<~PATTERN
-          (send (send _ :to_f) :/ (send _ :to_f))
+          (send #to_f_method? :/ #to_f_method?)
         PATTERN
         # @!method any_coerce?(node)
         def_node_matcher :any_coerce?, <<~PATTERN
-          {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
+          {(send _ :/ #to_f_method?) (send #to_f_method? :/ _)}
+        PATTERN
+        # @!method to_f_method?(node)
+        def_node_matcher :to_f_method?, <<~PATTERN
+          (send !nil? :to_f)
         PATTERN
 
         def on_send(node)

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

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

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

@@ -3,16 +3,24 @@
 module RuboCop
   module Cop
     module Style
-      # Use a consistent style for named format string tokens.
+      # Use a consistent style for tokens within a format string.
       #
-      # NOTE: `unannotated` style cop only works for strings
-      # which are passed as arguments to those methods:
-      # `printf`, `sprintf`, `format`, `%`.
-      # The reason is that _unannotated_ format is very similar
-      # to encoded URLs or Date/Time formatting strings.
+      # By default, all strings are evaluated. In some cases, this may be undesirable,
+      # as they could be used as arguments to a method that does not consider
+      # them to be tokens, but rather other identifiers or just part of the string.
       #
-      # This cop's allowed methods can be customized with `AllowedMethods`.
-      # By default, there are no allowed methods.
+      # `AllowedMethods` or `AllowedPatterns` can be configured with in order to mark specific
+      # methods as always allowed, thereby avoiding an offense from the cop. By default, there
+      # are no allowed methods.
+      #
+      # Additionally, the cop can be made conservative by configuring it with
+      # `Mode: conservative` (default `aggressive`). In this mode, tokens (regardless
+      # of `EnforcedStyle`) are only considered if used in the format string argument to the
+      # methods `printf`, `sprintf`, `format` and `%`.
+      #
+      # NOTE: Tokens in the `unannotated` style (eg. `%s`) are always treated as if
+      # configured with `Conservative: true`. This is done in order to prevent false positives,
+      # because this format is very similar to encoded URLs or Date/Time formatting strings.
       #
       # @example EnforcedStyle: annotated (default)
       #
@@ -82,6 +90,20 @@ module RuboCop
       #   # good
       #   redirect('foo/%{bar_id}')
       #
+      # @example Mode: conservative, EnforcedStyle: annotated
+      #   # In `conservative` mode, offenses are only registered for strings
+      #   # given to a known formatting method.
+      #
+      #   # good
+      #   "%{greeting}"
+      #   foo("%{greeting}")
+      #
+      #   # bad
+      #   format("%{greeting}", greeting: 'Hello')
+      #   printf("%{greeting}", greeting: 'Hello')
+      #   sprintf("%{greeting}", greeting: 'Hello')
+      #   "%{greeting}" % { greeting: 'Hello' }
+      #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
         include AllowedMethods
@@ -153,8 +175,9 @@ module RuboCop
           corrector.replace(token_range, correction)
         end
 
-        def unannotated_format?(node, detected_style)
-          detected_style == :unannotated && !format_string_in_typical_context?(node)
+        def allowed_string?(node, detected_style)
+          (detected_style == :unannotated || conservative?) &&
+            !format_string_in_typical_context?(node)
         end
 
         def message(detected_style)
@@ -203,7 +226,7 @@ module RuboCop
         def collect_detections(node)
           detections = []
           tokens(node) do |detected_sequence, token_range|
-            unless unannotated_format?(node, detected_sequence.style)
+            unless allowed_string?(node, detected_sequence.style)
               detections << [detected_sequence, token_range]
             end
           end
@@ -222,6 +245,10 @@ module RuboCop
         def max_unannotated_placeholders_allowed
           cop_config['MaxUnannotatedPlaceholdersAllowed']
         end
+
+        def conservative?
+          cop_config.fetch('Mode', :aggressive).to_sym == :conservative
+        end
       end
     end
   end

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

@@ -151,7 +151,7 @@ module RuboCop
 
         def frozen_string_literal_comment(processed_source)
           processed_source.tokens.find do |token|
-            token.text.start_with?(FROZEN_STRING_LITERAL)
+            MagicComment.parse(token.text).frozen_string_literal_specified?
           end
         end
 
@@ -189,8 +189,9 @@ module RuboCop
 
         def enable_comment(corrector)
           comment = frozen_string_literal_comment(processed_source)
+          replacement = MagicComment.parse(comment.text).new_frozen_string_literal(true)
 
-          corrector.replace(line_range(comment.line), FROZEN_STRING_LITERAL_ENABLED)
+          corrector.replace(line_range(comment.line), replacement)
         end
 
         def insert_comment(corrector)

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

@@ -8,6 +8,9 @@ module RuboCop
       # reassign (possibly to redirect some stream) constants in Ruby, you'll get
       # an interpreter warning if you do so.
       #
+      # Additionally, `$stdout/$stderr/$stdin` can safely be accessed in a Ractor because they
+      # are ractor-local, while `STDOUT/STDERR/STDIN` will raise `Ractor::IsolationError`.
+      #
       # @safety
       #   Autocorrection is unsafe because `STDOUT` and `$stdout` may point to different
       #   objects, for example.

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

@@ -135,6 +135,7 @@ module RuboCop
           on_def(node)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         def on_if(node)
           return if accepted_form?(node)
@@ -213,7 +214,7 @@ module RuboCop
           if_branch = node.if_branch
           else_branch = node.else_branch
 
-          corrector.replace(node.loc.begin, "\n") if node.loc.begin&.is?('then')
+          corrector.replace(node.loc.begin, "\n") if node.then?
 
           if if_branch&.send_type? && heredoc?(if_branch.last_argument)
             autocorrect_heredoc_argument(corrector, node, if_branch, else_branch, guard)

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

@@ -44,17 +44,17 @@ module RuboCop
       class HashConversion < Base
         extend AutoCorrector
 
-        MSG_TO_H = 'Prefer ary.to_h to Hash[ary].'
-        MSG_LITERAL_MULTI_ARG = 'Prefer literal hash to Hash[arg1, arg2, ...].'
-        MSG_LITERAL_HASH_ARG = 'Prefer literal hash to Hash[key: value, ...].'
-        MSG_SPLAT = 'Prefer array_of_pairs.to_h to Hash[*array].'
+        MSG_TO_H = 'Prefer `ary.to_h` to `Hash[ary]`.'
+        MSG_LITERAL_MULTI_ARG = 'Prefer literal hash to `Hash[arg1, arg2, ...]`.'
+        MSG_LITERAL_HASH_ARG = 'Prefer literal hash to `Hash[key: value, ...]`.'
+        MSG_SPLAT = 'Prefer `array_of_pairs.to_h` to `Hash[*array]`.'
         RESTRICT_ON_SEND = %i[[]].freeze
 
         # @!method hash_from_array?(node)
         def_node_matcher :hash_from_array?, '(send (const {nil? cbase} :Hash) :[] ...)'
 
         def on_send(node)
-          return unless hash_from_array?(node)
+          return if part_of_ignored_node?(node) || !hash_from_array?(node)
 
           # There are several cases:
           # If there is one argument:
@@ -63,7 +63,8 @@ module RuboCop
           # If there is 0 or 2+ arguments:
           #   Hash[a1, a2, a3, a4] => {a1 => a2, a3 => a4}
           #   ...but don't suggest correction if there is odd number of them (it is a bug)
-          node.arguments.count == 1 ? single_argument(node) : multi_argument(node)
+          node.arguments.one? ? single_argument(node) : multi_argument(node)
+          ignore_node(node)
         end
 
         private
@@ -111,7 +112,12 @@ module RuboCop
         end
 
         def requires_parens?(node)
-          (node.call_type? && node.arguments.any? && !node.parenthesized?) || node.operator_keyword?
+          if node.call_type?
+            return false if node.method?(:[])
+            return true if node.arguments.any? && !node.parenthesized?
+          end
+
+          node.operator_keyword?
         end
 
         def multi_argument(node)
@@ -122,7 +128,9 @@ module RuboCop
               corrector.replace(node, args_to_hash(node.arguments))
 
               parent = node.parent
-              add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+              if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
+                add_parentheses(parent, corrector)
+              end
             end
           end
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for uses of `each_key` and `each_value` Hash methods.
+      # Checks for uses of `each_key` and `each_value` `Hash` methods.
       #
       # NOTE: If you have an array of two-element arrays, you can put
       #   parentheses around the block arguments to indicate that you're not
@@ -44,7 +44,7 @@ module RuboCop
 
         # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
-          ({block numblock} $(call (call _ ${:keys :values}) :each) ...)
+          (any_block $(call (call _ ${:keys :values}) :each) ...)
         PATTERN
 
         # @!method each_arguments(node)
@@ -74,6 +74,7 @@ module RuboCop
           check_unused_block_args(node, key, value)
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         # rubocop:disable Metrics/AbcSize
         def check_unused_block_args(node, key, value)
@@ -128,8 +129,8 @@ module RuboCop
           lvar_sources = node.body.each_descendant(:lvar).map(&:source)
 
           if block_arg.mlhs_type?
-            block_arg.each_descendant(:arg, :restarg).all? do |block_arg|
-              lvar_sources.none?(block_arg.source.delete_prefix('*'))
+            block_arg.each_descendant(:arg, :restarg).all? do |descendant|
+              lvar_sources.none?(descendant.source.delete_prefix('*'))
             end
           else
             lvar_sources.none?(block_arg.source.delete_prefix('*'))
@@ -162,10 +163,7 @@ module RuboCop
 
         def use_array_converter_method_as_preceding?(node)
           return false unless (preceding_method = node.children.first.children.first)
-          unless preceding_method.call_type? ||
-                 preceding_method.block_type? || preceding_method.numblock_type?
-            return false
-          end
+          return false unless preceding_method.type?(:call, :any_block)
 
           ARRAY_CONVERTER_METHODS.include?(preceding_method.method_name)
         end

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