rubocop-grantbirki 1.75.2

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

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # 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
+      #   working with a hash, and suppress RuboCop offenses.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash`. The `AllowedReceivers` configuration can mitigate,
+      #   but not fully resolve, this safety issue.
+      #
+      # @example
+      #   # bad
+      #   hash.keys.each { |k| p k }
+      #   hash.each { |k, unused_value| p k }
+      #
+      #   # good
+      #   hash.each_key { |k| p k }
+      #
+      #   # bad
+      #   hash.values.each { |v| p v }
+      #   hash.each { |unused_key, v| p v }
+      #
+      #   # good
+      #   hash.each_value { |v| p v }
+      #
+      # @example AllowedReceivers: ['execute']
+      #   # good
+      #   execute(sql).keys.each { |v| p v }
+      #   execute(sql).values.each { |v| p v }
+      class HashEachMethods < Base
+        include AllowedReceivers
+        include Lint::UnusedArgument
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        UNUSED_BLOCK_ARG_MSG = "#{MSG.chop} and remove the unused `%<unused_code>s` block argument."
+        ARRAY_CONVERTER_METHODS = %i[assoc chunk flatten rassoc sort sort_by to_a].freeze
+
+        # @!method kv_each(node)
+        def_node_matcher :kv_each, <<~PATTERN
+          (any_block $(call (call _ ${:keys :values}) :each) ...)
+        PATTERN
+
+        # @!method each_arguments(node)
+        def_node_matcher :each_arguments, <<~PATTERN
+          (block (call _ :each)(args $_key $_value) ...)
+        PATTERN
+
+        # @!method kv_each_with_block_pass(node)
+        def_node_matcher :kv_each_with_block_pass, <<~PATTERN
+          (call $(call _ ${:keys :values}) :each (block_pass (sym _)))
+        PATTERN
+
+        # @!method hash_mutated?(node, receiver)
+        def_node_matcher :hash_mutated?, <<~PATTERN
+          `(send %1 :[]= ...)
+        PATTERN
+
+        def on_block(node)
+          return unless handleable?(node)
+
+          kv_each(node) do |target, method|
+            register_kv_offense(target, method) and return
+          end
+
+          return unless (key, value = each_arguments(node))
+
+          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)
+          return if node.body.nil?
+
+          value_unused = unused_block_arg_exist?(node, value)
+          key_unused = unused_block_arg_exist?(node, key)
+          return if value_unused && key_unused
+
+          if value_unused
+            message = message('each_key', node.method_name, value.source)
+            unused_range = key.source_range.end.join(value.source_range.end)
+
+            register_each_args_offense(node, message, 'each_key', unused_range)
+          elsif key_unused
+            message = message('each_value', node.method_name, key.source)
+            unused_range = key.source_range.begin.join(value.source_range.begin)
+
+            register_each_args_offense(node, message, 'each_value', unused_range)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def on_block_pass(node)
+          kv_each_with_block_pass(node.parent) do |target, method|
+            register_kv_with_block_pass_offense(node, target, method)
+          end
+        end
+
+        private
+
+        def handleable?(node)
+          return false if use_array_converter_method_as_preceding?(node)
+          return false unless (root_receiver = root_receiver(node))
+          return false if hash_mutated?(node, root_receiver)
+
+          !root_receiver.literal? || root_receiver.hash_type?
+        end
+
+        def register_kv_offense(target, method)
+          return unless (parent_receiver = target.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
+
+          current = target.receiver.loc.selector.join(target.source_range.end).source
+
+          add_offense(kv_range(target), message: format_message(method, current)) do |corrector|
+            correct_key_value_each(target, corrector)
+          end
+        end
+
+        def unused_block_arg_exist?(node, block_arg)
+          lvar_sources = node.body.each_descendant(:lvar).map(&:source)
+
+          if block_arg.mlhs_type?
+            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('*'))
+          end
+        end
+
+        def message(prefer, method_name, unused_code)
+          format(
+            UNUSED_BLOCK_ARG_MSG, prefer: prefer, current: method_name, unused_code: unused_code
+          )
+        end
+
+        def register_each_args_offense(node, message, prefer, unused_range)
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node.send_node.loc.selector, prefer)
+            corrector.remove(unused_range)
+          end
+        end
+
+        def register_kv_with_block_pass_offense(node, target, method)
+          return unless (parent_receiver = node.parent.receiver.receiver)
+          return if allowed_receiver?(parent_receiver)
+
+          range = target.loc.selector.join(node.parent.loc.selector.end)
+
+          add_offense(range, message: format_message(method, range.source)) do |corrector|
+            corrector.replace(range, "each_#{method[0..-2]}")
+          end
+        end
+
+        def use_array_converter_method_as_preceding?(node)
+          return false unless (preceding_method = node.children.first.children.first)
+          return false unless preceding_method.type?(:call, :any_block)
+
+          ARRAY_CONVERTER_METHODS.include?(preceding_method.method_name)
+        end
+
+        def root_receiver(node)
+          receiver = node.receiver
+          if receiver&.receiver
+            root_receiver(receiver)
+          else
+            receiver
+          end
+        end
+
+        def format_message(method_name, current)
+          format(MSG, prefer: "each_#{method_name[0..-2]}", current: current)
+        end
+
+        def check_argument(variable)
+          return unless variable.block_argument?
+
+          (@block_args ||= []).push(variable)
+        end
+
+        def used?(arg)
+          @block_args.find { |var| var.declaration_node.loc == arg.loc }.used?
+        end
+
+        def correct_implicit(node, corrector, method_name)
+          corrector.replace(node, method_name)
+          correct_args(node, corrector)
+        end
+
+        def correct_key_value_each(node, corrector)
+          receiver = node.receiver.receiver
+          name = "each_#{node.receiver.method_name.to_s.chop}"
+          return correct_implicit(node, corrector, name) unless receiver
+
+          new_source = receiver.source + "#{node.loc.dot.source}#{name}"
+          corrector.replace(node, new_source)
+        end
+
+        def correct_args(node, corrector)
+          args = node.parent.arguments
+          name, = *args.children.find { |arg| used?(arg) }
+
+          corrector.replace(args, "|#{name}|")
+        end
+
+        def kv_range(outer_node)
+          outer_node.receiver.loc.selector.join(outer_node.loc.selector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where `case-when` represents a simple 1:1
+      # mapping and can be replaced with a hash lookup.
+      #
+      # @example MinBranchesCount: 3 (default)
+      #   # bad
+      #   case country
+      #   when 'europe'
+      #     'http://eu.example.com'
+      #   when 'america'
+      #     'http://us.example.com'
+      #   when 'australia'
+      #     'http://au.example.com'
+      #   end
+      #
+      #   # good
+      #   SITES = {
+      #     'europe'    => 'http://eu.example.com',
+      #     'america'   => 'http://us.example.com',
+      #     'australia' => 'http://au.example.com'
+      #   }
+      #   SITES[country]
+      #
+      # @example MinBranchesCount: 4
+      #   # good
+      #   case country
+      #   when 'europe'
+      #     'http://eu.example.com'
+      #   when 'america'
+      #     'http://us.example.com'
+      #   when 'australia'
+      #     'http://au.example.com'
+      #   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
+            _
+            (when
+              ${str_type? sym_type?}
+              $[!nil? recursive_basic_literal?])+ nil?)
+        PATTERN
+
+        def on_case(node)
+          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)
+              add_offense(node)
+            end
+          end
+        end
+
+        private
+
+        def nodes_of_same_type?(nodes)
+          nodes.all? { |node| node.type == nodes.first.type }
+        end
+      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