rubocop 1.71.1 → 1.92.0

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_lookup_method.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces the use of either `Hash#[]` or `Hash#fetch` for hash lookup.
+      #
+      # This cop can be configured to prefer either bracket-style (`[]`)
+      # or fetch-style lookup. It is disabled by default.
+      #
+      # When enforcing `fetch` style, only single-argument bracket access is flagged.
+      # When enforcing `brackets` style, only `fetch` calls with a single key
+      # argument are flagged (not those with default values or blocks).
+      #
+      # @safety
+      #   This cop is unsafe because `Hash#[]` and `Hash#fetch` have different
+      #   semantics. `Hash#[]` returns `nil` for missing keys, while `Hash#fetch`
+      #   raises a `KeyError`. Replacing one with the other can change program
+      #   behavior in cases where the key is missing.
+      #
+      #   Additionally, it cannot be guaranteed that the receiver is a `Hash`
+      #   or responds to the replacement method.
+      #
+      # @example EnforcedStyle: brackets (default)
+      #   # bad
+      #   hash.fetch(key)
+      #
+      #   # good
+      #   hash[key]
+      #
+      #   # good - fetch with default value is allowed
+      #   hash.fetch(key, default)
+      #
+      #   # good - fetch with block is allowed
+      #   hash.fetch(key) { default }
+      #
+      #   # good - `ENV.fetch` is left to `Style/FetchEnvVar` when it is enabled
+      #   ENV.fetch(key)
+      #
+      # @example EnforcedStyle: fetch
+      #   # bad
+      #   hash[key]
+      #
+      #   # good
+      #   hash.fetch(key)
+      #
+      # @example AllowedReceivers: ['Rails.cache']
+      #   # good
+      #   Rails.cache.fetch(name, options) { block }
+      #
+      class HashLookupMethod < Base
+        include ConfigurableEnforcedStyle
+        include AllowedReceivers
+        extend AutoCorrector
+
+        BRACKET_MSG = 'Use `Hash#[]` instead of `Hash#fetch`.'
+        FETCH_MSG = 'Use `Hash#fetch` instead of `Hash#[]`.'
+
+        RESTRICT_ON_SEND = %i[[] fetch].freeze
+
+        # @!method env_const?(node)
+        def_node_matcher :env_const?, '(const {nil? cbase} :ENV)'
+
+        def on_send(node)
+          return if (receiver = node.receiver) && allowed_receiver?(receiver)
+          return if part_of_ignored_node?(node)
+
+          if offense_for_brackets?(node)
+            ignore_node(node.first_argument)
+            add_offense(node.loc.selector, message: BRACKET_MSG) do |corrector|
+              correct_fetch_to_brackets(corrector, node)
+            end
+          elsif offense_for_fetch?(node)
+            ignore_node(node.first_argument)
+            add_offense(node, message: FETCH_MSG) do |corrector|
+              correct_brackets_to_fetch(corrector, node)
+            end
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def offense_for_brackets?(node)
+          return false if style != :brackets || !node.receiver
+          return false if !node.method?(:fetch) || !node.arguments.one?
+          return false if node.block_literal? || node.csend_type?
+
+          !exempt_from_brackets?(node)
+        end
+
+        def exempt_from_brackets?(node)
+          comment_before_dot?(node) || env_fetch_preferred?(node.receiver)
+        end
+
+        def comment_before_dot?(node)
+          processed_source.contains_comment?(node.receiver.source_range.end.join(node.loc.dot))
+        end
+
+        def env_fetch_preferred?(receiver)
+          env_const?(receiver) && processed_source.registry.enabled?(Style::FetchEnvVar, config)
+        end
+
+        def offense_for_fetch?(node)
+          style == :fetch && node.method?(:[]) && node.arguments.one? &&
+            !compound_assignment_target?(node)
+        end
+
+        def compound_assignment_target?(node)
+          node.parent&.type?(:op_asgn, :or_asgn, :and_asgn) && node.parent.children.first == node
+        end
+
+        def correct_fetch_to_brackets(corrector, node)
+          key = node.first_argument.source
+
+          corrector.replace(node.receiver.source_range.end.join(node.source_range.end), "[#{key}]")
+        end
+
+        def correct_brackets_to_fetch(corrector, node)
+          key = node.first_argument.source
+          replacement = node.loc.dot ? "fetch(#{key})" : ".fetch(#{key})"
+
+          corrector.replace(node.loc.selector.join(node.source_range.end), replacement)
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,22 @@ module RuboCop
       #   This cop is unsafe because it cannot be guaranteed that the receiver
       #   is a `Hash` or responds to the replacement method.
       #
+      #   Additionally, the replacement may change the order of the resulting
+      #   hash: `Hash#slice` returns entries in the order the keys are given,
+      #   whereas `select`, `filter`, and `reject` preserve the entry order of
+      #   the receiver.
+      #
+      #   For example:
+      #
+      #   [source,ruby]
+      #   ----
+      #   hash = {foo: 1, bar: 2, baz: 3}
+      #   keys = %i[baz foo]
+      #
+      #   hash.select { |k, _v| keys.include?(k) } # => {foo: 1, baz: 3}
+      #   hash.slice(*keys)                        # => {baz: 3, foo: 1}
+      #   ----
+      #
       # @example
       #
       #   # bad

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

@@ -76,6 +76,9 @@ module RuboCop
       #   # good
       #   {foo:, bar:}
       #
+      #   # good - allowed to mix syntaxes
+      #   {foo:, bar: baz}
+      #
       # @example EnforcedShorthandSyntax: never
       #
       #   # bad
@@ -139,6 +142,13 @@ module RuboCop
         MSG_HASH_ROCKETS = 'Use hash rockets syntax.'
         NO_MIXED_KEYS_STYLES = %i[ruby19_no_mixed_keys no_mixed_keys].freeze
 
+        # Omitting the last hash value of a call without parentheses adds the parentheses,
+        # which `Style/MethodCallWithArgsParentheses` and `Style/SuperWithArgsParentheses`
+        # would add again in the same pass.
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses, Style::SuperWithArgsParentheses]
+        end
+
         def on_hash(node)
           pairs = node.pairs
 
@@ -209,12 +219,12 @@ module RuboCop
         end
 
         def word_symbol_pair?(pair)
-          return false unless pair.key.type?(:sym, :dsym)
+          return false unless pair.key.any_sym_type?
 
           acceptable_19_syntax_symbol?(pair.key.source)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def acceptable_19_syntax_symbol?(sym_name)
           sym_name.delete_prefix!(':')
 
@@ -234,11 +244,12 @@ module RuboCop
           (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
+              next if pair.value_omission? && keyword_value?(pair)
+
               location = pair.source_range.begin.join(pair.loc.operator)
               add_offense(location, message: msg) do |corrector|
                 autocorrect(corrector, pair)
@@ -260,6 +271,8 @@ module RuboCop
 
           hash_node = pair_node.parent
           return unless hash_node.parent&.return_type? && !hash_node.braces?
+          # This runs once per pair, but the hash must only be wrapped once.
+          return unless pair_node.equal?(hash_node.pairs.first)
 
           corrector.wrap(hash_node, '{', '}')
         end
@@ -279,12 +292,16 @@ module RuboCop
         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(op))
+          corrector.remove(operator_range(pair_node))
+        end
+
+        def operator_range(pair_node)
+          op = pair_node.loc.operator
+
+          range_with_surrounding_space(op, newlines: !pair_node.value_omission?)
         end
 
         def autocorrect_no_mixed_keys(corrector, pair_node)

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

@@ -3,17 +3,19 @@
 module RuboCop
   module Cop
     module Style
-      # 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.
       # 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], ...]`
+      #   This cop identifies the receiver as a hash by checking for literal hash
+      #   syntax and common methods that are known to return hashes (e.g. `to_h`,
+      #   `merge`, `invert`, `group_by`, etc.). However, it is unsafe because it
+      #   is possible for a custom class to define one of these methods and return
+      #   something other than a hash.
       #
       # @example
       #   # bad
@@ -21,10 +23,18 @@ module RuboCop
       #   Hash[{a: 1, b: 2}.collect { |k, v| [foo(k), v] }]
       #   {a: 1, b: 2}.map { |k, v| [k.to_s, v] }.to_h
       #   {a: 1, b: 2}.to_h { |k, v| [k.to_s, v] }
+      #   foo.to_h.each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
+      #   foo.merge(bar).map { |k, v| [k.to_s, v] }.to_h
       #
       #   # good
       #   {a: 1, b: 2}.transform_keys { |k| foo(k) }
       #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
+      #   foo.to_h.transform_keys { |k| k.to_sym }
+      #   foo.merge(bar).transform_keys { |k| k.to_s }
+      #
+      #   # Won't register an offense - receiver is not known to be a hash
+      #   foo.bar.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+      #   baz.map { |k, v| [k.to_s, v] }.to_h
       class HashTransformKeys < Base
         include HashTransformMethod
         extend AutoCorrector
@@ -35,7 +45,7 @@ module RuboCop
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            (call !#array_receiver? :each_with_object (hash))
+            (call #hash_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg $_)
@@ -50,7 +60,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -61,7 +71,7 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg $_)
                 (arg _val))
@@ -72,7 +82,7 @@ module RuboCop
         # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            (call !#array_receiver? :to_h)
+            (call #hash_receiver? :to_h)
             (args
               (arg $_)
               (arg _val))

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

@@ -3,15 +3,17 @@
 module RuboCop
   module Cop
     module Style
-      # 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 values of a hash, and tries to use a simpler & faster
       # call to `transform_values` instead.
       #
       # @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], ...]`
+      #   This cop identifies the receiver as a hash by checking for literal hash
+      #   syntax and common methods that are known to return hashes (e.g. `to_h`,
+      #   `merge`, `invert`, `group_by`, etc.). However, it is unsafe because it
+      #   is possible for a custom class to define one of these methods and return
+      #   something other than a hash.
       #
       # @example
       #   # bad
@@ -19,10 +21,18 @@ module RuboCop
       #   Hash[{a: 1, b: 2}.collect { |k, v| [k, foo(v)] }]
       #   {a: 1, b: 2}.map { |k, v| [k, v * v] }.to_h
       #   {a: 1, b: 2}.to_h { |k, v| [k, v * v] }
+      #   foo.to_h.each_with_object({}) { |(k, v), h| h[k] = foo(v) }
+      #   foo.merge(bar).map { |k, v| [k, v.to_s] }.to_h
       #
       #   # good
       #   {a: 1, b: 2}.transform_values { |v| foo(v) }
       #   {a: 1, b: 2}.transform_values { |v| v * v }
+      #   foo.to_h.transform_values { |v| foo(v) }
+      #   foo.merge(bar).transform_values { |v| v.to_s }
+      #
+      #   # Won't register an offense - receiver is not known to be a hash
+      #   foo.bar.each_with_object({}) { |(k, v), h| h[k] = v.to_s }
+      #   baz.map { |k, v| [k, v.to_s] }.to_h
       class HashTransformValues < Base
         include HashTransformMethod
         extend AutoCorrector
@@ -33,7 +43,7 @@ module RuboCop
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            (call !#array_receiver? :each_with_object (hash))
+            (call #hash_receiver? :each_with_object (hash))
             (args
               (mlhs
                 (arg _key)
@@ -48,7 +58,7 @@ module RuboCop
             (const _ :Hash)
             :[]
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -59,7 +69,7 @@ module RuboCop
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           (call
             (block
-              (call !#array_receiver? {:map :collect})
+              (call #hash_receiver? {:map :collect})
               (args
                 (arg _key)
                 (arg $_))
@@ -70,7 +80,7 @@ module RuboCop
         # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            (call !#array_receiver? :to_h)
+            (call #hash_receiver? :to_h)
             (args
               (arg _key)
               (arg $_))

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

@@ -136,7 +136,7 @@ module RuboCop
 
         private
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_branches(node, branches)
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
@@ -168,7 +168,6 @@ module RuboCop
 
           check_expressions(node, heads, :before_condition)
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def duplicated_expressions?(node, expressions)
           unique_expressions = expressions.uniq
@@ -189,7 +188,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable-next Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def check_expressions(node, expressions, insert_position)
           return if expressions.any?(&:nil?)
 
@@ -197,10 +196,9 @@ module RuboCop
 
           expressions.each do |expression|
             add_offense(expression) do |corrector|
-              next if node.if_type? && node.ternary?
+              next if node.if_type? && (node.ternary? || node.then?)
 
-              range = range_by_whole_lines(expression.source_range, include_final_newline: true)
-              corrector.remove(range)
+              corrector.remove(removal_range(expression))
               next if inserted_expression
 
               if node.parent&.assignment?
@@ -213,26 +211,56 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        def removal_range(expression)
+          range = expression.source_range
+          whole_lines = range_by_whole_lines(range, include_final_newline: true)
+          return whole_lines if whole_lines.source.strip == expression.source
+
+          range_with_separator(range)
+        end
+
+        def range_with_separator(range)
+          source = range.source_buffer.source
+
+          if (following = source[range.end_pos..][/\A[ \t]*;[ \t]*/])
+            range.adjust(end_pos: following.length)
+          elsif (preceding = source[0...range.begin_pos][/[ \t]*;[ \t]*\z/])
+            range.adjust(begin_pos: -preceding.length)
+          else
+            range_with_surrounding_space(range, side: :right, newlines: false)
+          end
+        end
 
         def correct_assignment(corrector, node, expression, insert_position)
+          indentation = indentation_of(node.parent)
+
           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}")
+            corrector.insert_after(node, "\n#{indentation}#{assignment.source}#{expression.source}")
           else
-            corrector.insert_before(node.parent, "#{expression.source}\n")
+            corrector.insert_before(node.parent, "#{expression.source}\n#{indentation}")
           end
         end
 
         def correct_no_assignment(corrector, node, expression, insert_position)
+          indentation = indentation_of(node)
+
           if insert_position == :after_condition
-            corrector.insert_after(node, "\n#{expression.source}")
+            corrector.insert_after(node, "\n#{indentation}#{expression.source}")
           else
-            corrector.insert_before(node, "#{expression.source}\n")
+            corrector.insert_before(node, "#{expression.source}\n#{indentation}")
           end
         end
 
+        # The leading indentation of the line the conditional starts on, so a
+        # hoisted expression keeps the surrounding nesting instead of landing
+        # at column zero.
+        def indentation_of(node)
+          ' ' * node.source_range.column
+        end
+
         def last_child_of_parent?(node)
           return true unless (parent = node.parent)