Needs more examples beyond simple

[nielsm]

Suppose I have a hash that has optional keys, but the keys that are provided must be in a list if they are provided.

VALID_FOO = [ONE,TWO]
VALID_BAR = [THREE,FOUR]

valid_hash = { foo: [ONE,TWO], bar: [THREE,FOUR]}
also_valid = {}
also_valid = {foo: [ONE]}
also_valid = {bar: [THREE]}
invalid = {foo: ONE}
invalid_also = {bar: ONE}
invalid_also = {bar: [ONE]}

Thus, bar and foo keys are optional. However, if they exist, they must be an array, whose values are in VALID_FOO or VALID_BAR as appropriate.

How would we specify that validation?

[samuel-hcl]

I usually define a method with all the logic to custom validate the keys in this case. Then I use a lambda to call that method and validate the key. Something like:

require 'hash_validator'

# the data you provided
VALID_FOO = [1,2]
VALID_BAR = [3,4]

valid_a = { foo: [1,2], bar: [3,4]}
valid_b = {}
valid_c = {foo: [1]}
valid_d = {bar: [3]}
invalid_a = {foo: 1}
invalid_b = {bar: 1}
invalid_c = {bar: [1]}

# assembling an array with your samples
samples = [valid_a, valid_b, valid_c, valid_d, invalid_a, invalid_b, invalid_c]

# the expected hash with lambdas
expected = {
  foo: ->(value) { foo_validation value },
  bar: ->(value) { bar_validation value }
}

# methods with the logic of the validation
def foo_validation(value)
  return true unless value
  value.each { |v| return false unless VALID_FOO.include? v } if value.is_a? Array
end

def bar_validation(value)
  return true unless value
  value.each { |v| return false unless VALID_BAR.include? v } if value.is_a? Array
end

# validating each of the samples you provided
samples.each do |sample|
  val = HashValidator.validate(sample, expected)
  puts val.valid?
  puts val.errors
end

If you run this code, you'll see that the first four hashes are OK, and the other three are invalid, just like you want.

Also, you can write a custom validator and use it just like the others.