module KeyValidatable

Constants

VERSION

Public Class Methods

assert_keys(key_value_pairs, requirements)
assert_keys_in_pairs(key_value_pairs, requirements)
Also aliased as: assert_keys
assert_members(key_value_pairs, requirements)
assert_members_in_pairs(key_value_pairs, requirements)
Also aliased as: assert_members
keys_for(key_value_pairs) click to toggle source

@param [Hash, to_hash, to_h, Struct, keys, members] key_value_pairs @return [Array]

# 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
valid_array?(keys, requirements) click to toggle source

@param [Array, to_ary] keys @param [Hash] requirements @option requirements [Array] :must @option requirements [Array] :let

# 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
valid_keys?(key_value_pairs, requirements) click to toggle source

@param [Hash, to_hash, to_h, Struct, keys, members] key_value_pairs @param [Hash] requirements @option requirements [Array] :must @option requirements [Array] :let

# File lib/keyvalidatable/singleton_class.rb, line 49
def valid_keys?(key_value_pairs, requirements)
  valid_array?(keys_for(key_value_pairs), requirements)
end
Also aliased as: valid_members?
valid_members?(key_value_pairs, requirements)
Alias for: valid_keys?
validate_array(keys, requirements) click to toggle source

@param [Array, to_ary] keys @param [Hash] requirements @option requirements [Array] :must @option requirements [Array] :let @return [nil] @raise [InvalidKeysError] if pairs is deficient for requirements

# 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
validate_keys(key_value_pairs, requirements)
validate_keys_in_pairs(key_value_pairs, requirements) click to toggle source

@param [Hash, to_hash, to_h, Struct, keys, members] key_value_pairs @param [Hash] requirements @option requirements [Array] :must @option requirements [Array] :let @return [nil] @raise [InvalidKeysError] if pairs is deficient for requirements

# 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
validate_members(key_value_pairs, requirements)
validate_members_in_pairs(key_value_pairs, requirements)
Also aliased as: validate_members

Private Class Methods

assert_requirements(requirements) click to toggle source

@param [Hash] requirements

# 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
excess_elements(elements, musts, lets) click to toggle source
# File lib/keyvalidatable/singleton_class.rb, line 98
def excess_elements(elements, musts, lets)
  (elements - musts) - lets
end
lets_for(requirements) click to toggle source
# File lib/keyvalidatable/singleton_class.rb, line 139
def lets_for(requirements)
  requirements[:let] || []
end
musts_for(requirements) click to toggle source
# File lib/keyvalidatable/singleton_class.rb, line 135
def musts_for(requirements)
  requirements[:must] || []
end
shortage_elements(elements, musts) click to toggle source
# File lib/keyvalidatable/singleton_class.rb, line 94
def shortage_elements(elements, musts)
  musts - elements
end

Public Instance Methods

assert_keys(requirements)
Alias for: validate_keys
valid_keys?(requirements) click to toggle source

@param [Hash] requirements

# File lib/keyvalidatable.rb, line 19
def valid_keys?(requirements)
  KeyValidatable.__send__(__callee__, self, requirements)
end
Also aliased as: valid_members?
valid_members?(requirements)
Alias for: valid_keys?
validate_keys(requirements) click to toggle source

@param [Hash] requirements

# File lib/keyvalidatable.rb, line 12
def validate_keys(requirements)
  KeyValidatable.__send__(__callee__, self, requirements)
end
Also aliased as: validate_members, assert_keys
validate_members(requirements)
Alias for: validate_keys