module KeyValidatable

# File lib/keyvalidatable/singleton_class.rb, line 70
def keys_for(key_value_pairs)
  pairs = (
    case
    when key_value_pairs.respond_to?(:to_hash)
      key_value_pairs.to_hash
    when key_value_pairs.respond_to?(:to_h)
      key_value_pairs.to_h
    else
      key_value_pairs
    end
  )

  case
  when pairs.respond_to?(:keys)
    pairs.keys
  when pairs.respond_to?(:members)
    pairs.members
  else
    raise TypeError, "#{key_value_pairs.inspect} is not pairs object"
  end
end

# File lib/keyvalidatable/singleton_class.rb, line 59
def valid_array?(keys, requirements)
  assert_requirements(requirements)
  validate_array(keys, requirements)
rescue InvalidKeysError
  false
else
  true
end

# File lib/keyvalidatable/singleton_class.rb, line 49
def valid_keys?(key_value_pairs, requirements)
  valid_array?(keys_for(key_value_pairs), requirements)
end

# File lib/keyvalidatable/singleton_class.rb, line 30
def validate_array(keys, requirements)
  assert_requirements(requirements)
  musts, lets = musts_for(requirements), lets_for(requirements)

  shortage_keys = shortage_elements(keys.to_ary, musts)
  excess_keys   = excess_elements(keys.to_ary, musts, lets)

  unless [*shortage_keys, *excess_keys].empty?
    raise InvalidKeysError,
          "Shortage: #{shortage_keys} / Excess: #{excess_keys}"
  end

  nil
end

# File lib/keyvalidatable/singleton_class.rb, line 12
def validate_keys_in_pairs(key_value_pairs, requirements)
  validate_array(keys_for(key_value_pairs), requirements)
end

# File lib/keyvalidatable/singleton_class.rb, line 103
def assert_requirements(requirements)
  raise ArgumentError unless requirements.respond_to?(:keys)

  unless (requirements.keys - [:must, :let]).empty?
    raise ArgumentError
  end

  musts, lets = requirements[:must], requirements[:let]

  if musts
    unless musts.kind_of?(Array) &&
           musts.all? { |key| key.respond_to?(:hash) && key.respond_to?(:eql?) }
      raise TypeError
    end
  end

  if lets
    unless lets.kind_of?(Array) &&
           lets.all? { |key| key.respond_to?(:hash) && key.respond_to?(:eql?) }
      raise TypeError
    end
  end

  unless musts || lets
    raise TypeError
  end

  if requirements.values.sum([]).empty?
    raise ArgumentError
  end
end

# File lib/keyvalidatable/singleton_class.rb, line 98
def excess_elements(elements, musts, lets)
  (elements - musts) - lets
end

# File lib/keyvalidatable/singleton_class.rb, line 139
def lets_for(requirements)
  requirements[:let] || []
end

# File lib/keyvalidatable/singleton_class.rb, line 135
def musts_for(requirements)
  requirements[:must] || []
end

# File lib/keyvalidatable/singleton_class.rb, line 94
def shortage_elements(elements, musts)
  musts - elements
end

# File lib/keyvalidatable.rb, line 19
def valid_keys?(requirements)
  KeyValidatable.__send__(__callee__, self, requirements)
end

# File lib/keyvalidatable.rb, line 12
def validate_keys(requirements)
  KeyValidatable.__send__(__callee__, self, requirements)
end