Cross-property validations

[joeldrapper]

I’ve been thinking about ways to support cross-property validations. Here’s one idea I had for this interface.

class Foo
  prop :name, String
  prop :min, Integer
  prop :max, Integer
  prop :pattern, Regexp

  validate("Min must be less than max") { |min, max| min < max }
end

The way this would work is we would look at the names of the parameters of the block given to validate and based on those names, send the corresponding values. Calling block.parameters on the above block would return this, so the names are available.

[[:opt, :min], [:opt, :max]]

I believe this could be done at load time so runtime execution is extremely fast. Perhaps block could be defined as a private method with a generated name, and the generated initialiser would just generate the code to call that method with the relevant parameters.

[joeldrapper]

I’m not sure if validate is the right word for this, but I can’t think of a better one at the moment. I would like to use validate for something else later on so I’d rather avoid using it for this.

[joeldrapper]

I should have mentioned the advantage of this over after_initialize is we could run it again when dependent properties are written to via writer methods and we can do it before updating instance variables. Even if Foo above is mutable, it could maintain its integrity.

[joeldrapper]

check_constraint is not a bad name because it’s similar to a database check constraint.

[stevegeek]

Others that pop to mind "verify", "confirm", "check" , "guarantee" (maybe too strong of a word!)

[brandonzylstra]

verify was the first alternative that came to mind for me, but confirm also sounds good to me. ensure of course can't be used, but enforce will work, and seems like it might be the most accurate description of what is being done.

[joeldrapper]

I quite like stipulate too. I’m trying to find words that read well when followed by an error message written in the correct tense.

class Example < Literal::Data
  prop :name, String
  prop :min, Integer
  prop :max, Integer
  prop :method, _Nilable(Symbol)
  prop :block, _Nilable(Proc), :&

  stipulate "name length must be between min and max" do |name, min, max|
    (min..max).cover? name.length
  end

  stipulate "you must provide either a method or a block but not both" do |method, block|
    !!method ^ !!block
  end
end

stipulate is nice because the definition is a perfect fit and yet its meaning is not overloaded by too many programming concepts.

The reason I don’t want to use validate is because I want to potentially use it like this

MyClass.validate(arguments)

And have it soft validate the arguments, returning a list of errors rather than raising.

Although this looks completely different, macros are just class methods, so they share the same name space.

[ncri]

Why not "constraint"? That was the word popping into my mind when hearing your talk today @joeldrapper.

[joeldrapper]

That's also a good word. But there's a type called _Constraint too and I didn't want to muddle the two things.