class RuboCop::Cop::Style::HashEachMethods

execute(sql).values.each { |v| p v }
execute(sql).keys.each { |v| p v }
# good
@example AllowedReceivers: [‘execute’]
hash.each_value { |v| p v }
hash.each_key { |k| p k }
# good
hash.values.each { |v| p v }
hash.keys.each { |k| p k }
# bad
@example
but not fully resolve, this safety issue.
is a ‘Hash`. The `AllowedReceivers` configuration can mitigate,
This cop is unsafe because it cannot be guaranteed that the receiver
@safety
working with a hash, and suppress RuboCop offenses.
parentheses around the block arguments to indicate that you’re not
NOTE: If you have an array of two-element arrays, you can put
This cop checks for uses of ‘each_key` and `each_value` Hash methods.

def allowed_receiver?(receiver) 

def allowed_receiver?(receiver)
  receiver_name = receiver.send_type? ? receiver.method_name.to_s : receiver.source
  allowed_receivers.include?(receiver_name)
end

def allowed_receivers 

def allowed_receivers
  cop_config.fetch('AllowedReceivers', [])
end

def check_argument(variable) 

def check_argument(variable)
  return unless variable.block_argument?
  (@block_args ||= []).push(variable)
end

def correct_args(node, corrector) 

def correct_args(node, corrector)
  args = node.parent.arguments
  name, = *args.children.find { |arg| used?(arg) }
  corrector.replace(args, "|#{name}|")
end

def correct_implicit(node, corrector, method_name) 

def correct_implicit(node, corrector, method_name)
  corrector.replace(node, method_name)
  correct_args(node, corrector)
end

def correct_key_value_each(node, corrector) 

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 + ".#{name}"
  corrector.replace(node, new_source)
end

def kv_range(outer_node) 

def kv_range(outer_node)
  outer_node.receiver.loc.selector.join(outer_node.loc.selector)
end

def on_block(node) 

def on_block(node)
  register_kv_offense(node)
end

def register_kv_offense(node) 

def register_kv_offense(node)
  kv_each(node) do |target, method|
    parent_receiver = target.receiver.receiver
    return unless parent_receiver
    return if allowed_receiver?(parent_receiver)
    msg = format(message, prefer: "each_#{method[0..-2]}", current: "#{method}.each")
    add_offense(kv_range(target), message: msg) do |corrector|
      correct_key_value_each(target, corrector)
    end
  end
end

def used?(arg) 

def used?(arg)
  @block_args.find { |var| var.declaration_node.loc == arg.loc }.used?
end