rubocop 0.93.1 → 1.79.2

data/lib/rubocop/cop/style/hash_except.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#except` method.
+      #
+      # This cop should only be enabled on Ruby version 3.0 or higher.
+      # (`Hash#except` was added in Ruby 3.0.)
+      #
+      # 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}.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) }
+      #
+      #   # 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 HashSubset
+        extend TargetRubyVersion
+        extend AutoCorrector
+
+        minimum_target_ruby_version 3.0
+
+        private
+
+        def semantically_subset_method?(node)
+          semantically_except_method?(node)
+        end
+
+        def preferred_method_name
+          'except'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use `Hash#dig` instead of chaining potentially null `fetch` calls.
+      #
+      # When `fetch(identifier, nil)` calls are chained on a hash, the expectation
+      # is that each step in the chain returns either `nil` or another hash,
+      # and in both cases, these can be simplified with a single call to `dig` with
+      # multiple arguments.
+      #
+      # If the 2nd parameter is `{}` or `Hash.new`, an offense will also be registered,
+      # as long as the final call in the chain is a nil value. If a non-nil value is given,
+      # the chain will not be registered as an offense, as the default value cannot be safely
+      # given with `dig`.
+      #
+      # NOTE: See `Style/DigChain` for replacing chains of `dig` calls with
+      # a single method call.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or that `fetch` or `dig` have the expected standard implementation.
+      #
+      # @example
+      #   # bad
+      #   hash.fetch('foo', nil)&.fetch('bar', nil)
+      #
+      #   # bad
+      #   # earlier members of the chain can return `{}` as long as the final `fetch`
+      #   # has `nil` as a default value
+      #   hash.fetch('foo', {}).fetch('bar', nil)
+      #
+      #   # good
+      #   hash.dig('foo', 'bar')
+      #
+      #   # ok - not handled by the cop since the final `fetch` value is non-nil
+      #   hash.fetch('foo', {}).fetch('bar', {})
+      #
+      class HashFetchChain < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use `%<replacement>s` instead.'
+        RESTRICT_ON_SEND = %i[fetch].freeze
+
+        minimum_target_ruby_version 2.3
+
+        # @!method diggable?(node)
+        def_node_matcher :diggable?, <<~PATTERN
+          (call _ :fetch $_arg {nil (hash) (send (const {nil? cbase} :Hash) :new)})
+        PATTERN
+
+        def on_send(node)
+          return if ignored_node?(node)
+          return if last_fetch_non_nil?(node)
+
+          last_replaceable_node, arguments = inspect_chain(node)
+          return unless last_replaceable_node
+          return unless arguments.size > 1
+
+          range = last_replaceable_node.selector.join(node.loc.end)
+          replacement = replacement(arguments)
+          message = format(MSG, replacement: replacement)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, replacement)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def last_fetch_non_nil?(node)
+          # When chaining `fetch` methods, `fetch(x, {})` is acceptable within
+          # the chain, as long as the last method in the chain has a `nil`
+          # default value.
+
+          return false unless node.method?(:fetch)
+
+          !node.last_argument&.nil_type?
+        end
+
+        def inspect_chain(node)
+          arguments = []
+
+          while (arg = diggable?(node))
+            arguments.unshift(arg)
+            ignore_node(node)
+            last_replaceable_node = node
+            node = node.receiver
+          end
+
+          [last_replaceable_node, arguments]
+        end
+
+        def replacement(arguments)
+          values = arguments.map(&:source).join(', ')
+          "dig(#{values})"
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where `case-when` represents a simple 1:1
+      # Checks for places where `case-when` represents a simple 1:1
       # mapping and can be replaced with a hash lookup.
       #
       # @example MinBranchesCount: 3 (default)
@@ -37,8 +37,11 @@ module RuboCop
       #   end
       #
       class HashLikeCase < Base
+        include MinBranchesCount
+
         MSG = 'Consider replacing `case-when` with a hash lookup.'
 
+        # @!method hash_like_case?(node)
         def_node_matcher :hash_like_case?, <<~PATTERN
           (case
             _
@@ -48,11 +51,10 @@ module RuboCop
         PATTERN
 
         def on_case(node)
-          return if node.when_branches.size < min_branches_count
+          return unless min_branches_count?(node)
 
           hash_like_case?(node) do |condition_nodes, body_nodes|
-            if nodes_of_same_type?(condition_nodes) &&
-               nodes_of_same_type?(body_nodes)
+            if nodes_of_same_type?(condition_nodes) && nodes_of_same_type?(body_nodes)
               add_offense(node)
             end
           end
@@ -63,13 +65,6 @@ module RuboCop
         def nodes_of_same_type?(nodes)
           nodes.all? { |node| node.type == nodes.first.type }
         end
-
-        def min_branches_count
-          length = cop_config['MinBranchesCount'] || 3
-          return length if length.is_a?(Integer) && length.positive?
-
-          raise 'MinBranchesCount needs to be a positive integer!'
-        end
       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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks hash literal syntax.
+      # Checks hash literal syntax.
       #
       # It can enforce either the use of the class hash rocket syntax or
       # the use of the newer Ruby 1.9 syntax (when applicable).
@@ -19,6 +19,19 @@ module RuboCop
       # * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
       # syntax hashes
       #
+      # This cop has `EnforcedShorthandSyntax` option.
+      # It can enforce either the use of the explicit hash value syntax or
+      # the use of Ruby 3.1's hash value shorthand syntax.
+      #
+      # The supported styles are:
+      #
+      # * always - forces use of the 3.1 syntax (e.g. {foo:})
+      # * never - forces use of explicit hash literal value
+      # * either - accepts both shorthand and explicit use of hash literal value
+      # * consistent - forces use of the 3.1 syntax only if all values can be omitted in the hash
+      # * either_consistent - accepts both shorthand and explicit use of hash literal value,
+      #                       but they must be consistent
+      #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
       #   {:a => 2}
@@ -54,26 +67,95 @@ module RuboCop
       #   # good
       #   {a: 1, b: 2}
       #   {:c => 3, 'd' => 4}
-      class HashSyntax < Cop
+      #
+      # @example EnforcedShorthandSyntax: always
+      #
+      #   # bad
+      #   {foo: foo, bar: bar}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
+      #   # good - allowed to mix syntaxes
+      #   {foo:, bar: baz}
+      #
+      # @example EnforcedShorthandSyntax: never
+      #
+      #   # bad
+      #   {foo:, bar:}
+      #
+      #   # good
+      #   {foo: foo, bar: bar}
+      #
+      # @example EnforcedShorthandSyntax: either (default)
+      #
+      #   # good
+      #   {foo: foo, bar: bar}
+      #
+      #   # good
+      #   {foo: foo, bar:}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
+      # @example EnforcedShorthandSyntax: consistent
+      #
+      #   # bad - `foo` and `bar` values can be omitted
+      #   {foo: foo, bar: bar}
+      #
+      #   # bad - `bar` value can be omitted
+      #   {foo:, bar: bar}
+      #
+      #   # bad - mixed syntaxes
+      #   {foo:, bar: baz}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
+      #   # good - can't omit `baz`
+      #   {foo: foo, bar: baz}
+      #
+      # @example EnforcedShorthandSyntax: either_consistent
+      #
+      #   # good - `foo` and `bar` values can be omitted, but they are consistent, so it's accepted
+      #   {foo: foo, bar: bar}
+      #
+      #   # bad - `bar` value can be omitted
+      #   {foo:, bar: bar}
+      #
+      #   # bad - mixed syntaxes
+      #   {foo:, bar: baz}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
+      #   # good - can't omit `baz`
+      #   {foo: foo, bar: baz}
+      class HashSyntax < Base
         include ConfigurableEnforcedStyle
+        include HashShorthandSyntax
         include RangeHelp
+        extend AutoCorrector
 
         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
 
           return if pairs.empty?
 
+          on_hash_for_mixed_shorthand(node)
+
           if style == :hash_rockets || force_hash_rockets?(pairs)
             hash_rockets_check(pairs)
           elsif style == :ruby19_no_mixed_keys
             ruby19_no_mixed_keys_check(pairs)
           elsif style == :no_mixed_keys
             no_mixed_keys_check(pairs)
-          elsif node.source.include?('=>')
+          else
             ruby19_check(pairs)
           end
         end
@@ -97,22 +179,10 @@ module RuboCop
         end
 
         def no_mixed_keys_check(pairs)
-          if !sym_indices?(pairs)
-            check(pairs, ':', MSG_NO_MIXED_KEYS)
-          else
+          if sym_indices?(pairs)
             check(pairs, pairs.first.inverse_delimiter, MSG_NO_MIXED_KEYS)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            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
-              autocorrect_no_mixed_keys(corrector, node)
-            else
-              autocorrect_ruby19(corrector, node)
-            end
+          else
+            check(pairs, ':', MSG_NO_MIXED_KEYS)
           end
         end
 
@@ -127,18 +197,29 @@ module RuboCop
 
         private
 
+        def autocorrect(corrector, node)
+          if style == :hash_rockets || force_hash_rockets?(node.parent.pairs)
+            autocorrect_hash_rockets(corrector, node)
+          elsif NO_MIXED_KEYS_STYLES.include?(style)
+            autocorrect_no_mixed_keys(corrector, node)
+          else
+            autocorrect_ruby19(corrector, node)
+          end
+        end
+
         def sym_indices?(pairs)
           pairs.all? { |p| word_symbol_pair?(p) }
         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
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def acceptable_19_syntax_symbol?(sym_name)
-          sym_name.sub!(/\A:/, '')
+          sym_name.delete_prefix!(':')
 
           if cop_config['PreferHashRocketsForNonAlnumEndingSymbols'] &&
              # Prefer { :production? => false } over { production?: false } and
@@ -151,15 +232,20 @@ module RuboCop
           # Most hash keys can be matched against a simple regex.
           return true if /\A[_a-z]\w*[?!]?\z/i.match?(sym_name)
 
-          # For more complicated hash keys, let the parser validate the syntax.
-          parse("{ #{sym_name}: :foo }").valid_syntax?
+          return false if target_ruby_version <= 2.1
+
+          (sym_name.start_with?("'") && sym_name.end_with?("'")) ||
+            (sym_name.start_with?('"') && sym_name.end_with?('"'))
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.delimiter == delim
               location = pair.source_range.begin.join(pair.loc.operator)
-              add_offense(pair, location: location, message: msg) do
+              add_offense(location, message: msg) do |corrector|
+                autocorrect(corrector, pair)
+
                 opposite_style_detected
               end
             else
@@ -173,10 +259,7 @@ module RuboCop
 
           space = argument_without_space?(pair_node.parent) ? ' ' : ''
 
-          corrector.replace(
-            range,
-            range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: ")
-          )
+          corrector.replace(range, range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: "))
 
           hash_node = pair_node.parent
           return unless hash_node.parent&.return_type? && !hash_node.braces?
@@ -189,20 +272,22 @@ module RuboCop
           operator = pair_node.loc.operator
 
           range = key.join(operator)
-          range_with_surrounding_space(range: range, side: :right)
+          range_with_surrounding_space(range, side: :right)
         end
 
         def argument_without_space?(node)
-          node.argument? &&
-            node.loc.expression.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)
           op = pair_node.loc.operator
 
           key_with_hash_rocket = ":#{pair_node.key.source}#{pair_node.inverse_delimiter(true)}"
+          key_with_hash_rocket += pair_node.key.source if pair_node.value_omission?
           corrector.replace(pair_node.key, key_with_hash_rocket)
-          corrector.remove(range_with_surrounding_space(range: op))
+          corrector.remove(range_with_surrounding_space(op))
         end
 
         def autocorrect_no_mixed_keys(corrector, pair_node)
@@ -214,8 +299,7 @@ module RuboCop
         end
 
         def force_hash_rockets?(pairs)
-          cop_config['UseHashRocketsWithSymbolValues'] &&
-            pairs.map(&:value).any?(&:sym_type?)
+          cop_config['UseHashRocketsWithSymbolValues'] && pairs.map(&:value).any?(&:sym_type?)
         end
       end
     end

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

@@ -3,18 +3,18 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of `_.each_with_object({}) {...}`,
-      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # Looks for uses of `+_.each_with_object({}) {...}+`,
+      # `+_.map {...}.to_h+`, and `+Hash[_.map {...}]+` that are actually just
       # transforming the keys of a hash, and tries to use a simpler & faster
       # call to `transform_keys` instead.
-      #
-      # This can produce false positives if we are transforming an enumerable
-      # of key-value-like pairs that isn't actually a hash, e.g.:
-      # `[[k1, v1], [k2, v2], ...]`
-      #
-      # This cop should only be enabled on Ruby version 2.5 or newer
+      # It should only be enabled on Ruby version 2.5 or newer.
       # (`transform_keys` was added in Ruby 2.5.)
       #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if we are
+      #   transforming an enumerable of key-value-like pairs that isn't actually
+      #   a hash, e.g.: `[[k1, v1], [k2, v2], ...]`
+      #
       # @example
       #   # bad
       #   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[foo(k)] = v }
@@ -27,38 +27,41 @@ module RuboCop
       #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
       class HashTransformKeys < Base
         include HashTransformMethod
-        extend TargetRubyVersion
         extend AutoCorrector
+        extend TargetRubyVersion
 
         minimum_target_ruby_version 2.5
 
+        # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} !#array_receiver? :each_with_object (hash))
+            (call !#array_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg $_)
                 (arg _val))
               (arg _memo))
-            ({send csend} (lvar _memo) :[]= $!`_memo $(lvar _val)))
+            (call (lvar _memo) :[]= $!`_memo $(lvar _val)))
         PATTERN
 
+        # @!method on_bad_hash_brackets_map(node)
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
             (const _ :Hash)
             :[]
             (block
-              ({send csend} !#array_receiver? {:map :collect})
+              (call !#array_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
               (array $_ $(lvar _val))))
         PATTERN
 
+        # @!method on_bad_map_to_h(node)
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
-          ({send csend}
+          (call
             (block
-              ({send csend} !#array_receiver? {:map :collect})
+              (call !#array_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -66,9 +69,10 @@ module RuboCop
             :to_h)
         PATTERN
 
+        # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            ({send csend} !#array_receiver? :to_h)
+            (call !#array_receiver? :to_h)
             (args
               (arg $_)
               (arg _val))