`visit': undefined method `visit_#<Dry::Validation::Schema::Rule:0x00000001ee9098>' for #<Dry::Validation::RuleCompiler:0x00000001ee8648> (NoMethodError) about dry-validation

[solnic]

Hey there, thanks for the report. There a couple of issues here. First of all root.filled? is not needed when you have root.hash?, which implies that if it's there and it's a hash then it's definitely filled. Secondly, calling multiple predicates without composing them logically with & / | operators is not supported; in general every block must return a rule and it's going to be composed with the outer one. The exception is key construct, which is special, as it establishes a set of rules that can be applied to its value, that's why you can define nested rules for many keys.

In other words:

class Schema < Dry::Validation::Schema
  key(:foo) do |foo|
    # this won't work because the last rule returned is composed with the outer `key` rule:
    foo.filled?
    foo.size?(10..100)

    # you want this:
    foo.filled? & foo.size?(10..100)
  end
end

And here's a working example of what you tried to do:

require 'json'
require 'dry-validation'
require 'dry/validation/schema/form'

class StatSchema < Dry::Validation::Schema::Form
  key(:stats) do |stats|
    stats.hash? do
      stats.key(:strength) do |strength|
        strength.key(:description, &:filled?)
      end
    end
  end
end

json = JSON.parse <<-EOT
{
    "stats": {
        "strength": {
            "description": "Increases physical damage"
        }
    }
}
EOT

schema = StatSchema.new

puts schema.messages(json).inspect

# #<Dry::Validation::Schema::Result params={:stats=>{:strength=>{:description=>"Increases physical damage"}}} errors=[]>

Notice that I used Schema::Form (although we may want to introduce Schema::JSON too!) which is needed for json input, as keys are stringified and you may want to use coercions too, which are automatically configured based on your type expectations. Also notice that each is not needed as its purpose is to be used with arrays, not hashes.

Oh and it's using master, as I improved many things, I'll release 0.2.1 later today.

Having said all of that, I have to admit that we could do something to provide meaningful feedback when rules are defined incorrectly, I believe it should be possible. In example we could check if somebody is trying to use each against an input that is expected to be something else than an array and in that case simply raise a meaningful error. The same applies to defining multiple predicates without composing them logically with operators, in that case we also want to raise an error, alternatively we may just assume that all predicates should be composed with & implicitly, but I'm not sure if that's a good strategy since it wouldn't be explicit from the dsl pov and may confuse people. Remember that rules are applied using predicate logic, so foo.str? & foo.size?(10..100) won't check the size when foo is not a string, this is a huge difference between dry-validation and most (or all) of the other validation libs in Ruby.

I hope this is helpful and thanks for trying out this lib :)

[zackp30]

Oh wow! Thanks for the informative and quick reply. I'll keep this in mind, fantastic library by the way! Using it to validate JSON (for now) for a card game I'm creating with some friends. Thanks again! 😄