class RuboCop::Cop::Style::HashConversion


# bad
@example AllowSplatArgument: false

Hash[*ary]
# good
@example AllowSplatArgument: true (default)
{key1 => value1, key2 => value2}
# good
Hash[key1, value1, key2, value2]
# bad
ary.to_h
# good

Hash[ary]
# bad
@example
So, ‘AllowSplatArgument` option is true by default to allow splat argument for simple code.<br>`Hash` can be replaced with `ary.each_slice(2).to_h` but it will be complicated.
Correction code from splat argument (`Hash`) is not simply determined. For example,
sequences of values to hashes.
Checks the usage of pre-2.1 `Hash` method of converting enumerables and

def allowed_splat_argument? 

def allowed_splat_argument?
  cop_config.fetch('AllowSplatArgument', true)
end

def args_to_hash(args) 

def args_to_hash(args)
  content = args.each_slice(2)
                .map { |arg1, arg2| "#{arg1.source} => #{arg2.source}" }
                .join(', ')
  "{#{content}}"
end

def multi_argument(node) 

def multi_argument(node)
  if node.arguments.count.odd?
    add_offense(node, message: MSG_LITERAL_MULTI_ARG)
  else
    add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
      corrector.replace(node, args_to_hash(node.arguments))
      parent = node.parent
      add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
    end
  end
end

def on_send(node) 

def on_send(node)
  return unless hash_from_array?(node)
  # There are several cases:
  # If there is one argument:
  #   Hash[ary] => ary.to_h
  #   Hash[*ary] => don't suggest corrections
  # 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)
end

def register_offense_for_hash(node, hash_argument) 

def register_offense_for_hash(node, hash_argument)
  add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
    corrector.replace(node, "{#{hash_argument.source}}")
    parent = node.parent
    add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
  end
end

def register_offense_for_zip_method(node, zip_method) 

def register_offense_for_zip_method(node, zip_method)
  add_offense(node, message: MSG_TO_H) do |corrector|
    if zip_method.parenthesized?
      corrector.insert_before(zip_method.loc.end, '[]')
    else
      corrector.insert_after(zip_method, '([])')
    end
  end
end

def requires_parens?(node) 

def requires_parens?(node)
  (node.call_type? && node.arguments.any? && !node.parenthesized?) ||
    node.or_type? || node.and_type?
end

def single_argument(node) 

def single_argument(node)
  first_argument = node.first_argument
  if first_argument.hash_type?
    register_offense_for_hash(node, first_argument)
  elsif first_argument.splat_type?
    add_offense(node, message: MSG_SPLAT) unless allowed_splat_argument?
  elsif use_zip_method_without_argument?(first_argument)
    register_offense_for_zip_method(node, first_argument)
  else
    add_offense(node, message: MSG_TO_H) do |corrector|
      replacement = first_argument.source
      replacement = "(#{replacement})" if requires_parens?(first_argument)
      corrector.replace(node, "#{replacement}.to_h")
    end
  end
end

def use_zip_method_without_argument?(first_argument) 

def use_zip_method_without_argument?(first_argument)
  return false unless first_argument&.send_type?
  first_argument.method?(:zip) && first_argument.arguments.empty?
end