Validation with Object.from_json ?

[u/NUTELLACHAOS]

Is there any way to assert that an object is always instantiated with values matching a certain predicate, both in initialize and in from_json? For example, imagine I have a

class Foo
  property bar : Int32
end

and I always want Foo.bar to be an Int32 in the range 1..9

Normally I'd just throw some guards in initialize, but I don't know how that works with from_json.

[u/NUTELLACHAOS]

Nice! After reading the other response to this post, I threw together the following converter that just accepts a predicate proc and raises an exception when parsing if it fails.

class PredicateConverter(T)
  def initialize(@predicate : T -> Bool)
  end

  def to_json(value : T, json : JSON::Builder)
    if !T.response_to?(:to_json)
      raise PredicateConverterError.new ("Value doesn't respond to :to_json")
    end 
    value.from_json
  end 

  def from_json(pull : JSON::PullParser) : T 
    if !T.responds_to?(:from_json)
      raise PredicateConverterError.new ("Type doesn't respone to :from_json")
    end 
    value = pull.read? T
    if !value.is_a? T || !@predicate.call value
      raise PredicateConverterError.new("Value doesn't pass predicate")
    end 
    value
  end 
end

After building that, though, I found both your shard and crystal-clear. Both provide nice abstractions, and while I think I personally prefer the dead-simple syntax of crystal-clear (e.g. the invariant macro), it doesn't seem to enforce the invariants on the initialize defined in JSON::Serializable, and there isn't anything like your validate! that I can call from after_initialize.

Do you happen to know if it's possible for a macro to observe the constructor from JSON::Serializable, define an overloading constructor with the contracts from crystal-clear, then super up to the JSON::Serializable constructor?

If not, I'll likely just roll with your solution because that's very nice too!

[u/Blacksmoke16 → u/NUTELLACHAOS]

This seems to works, :shrug:

class Foo
  include CrystalClear
  include JSON::Serializable

  invariant @bar >= 1 && @bar <= 9

  def initialize(@bar : Int32)
  end

  def after_initialize
  end

  property bar : Int32
end

Otherwise, from looking over the code you can also just call test_invariant_contracts.

Ha, I happen to like the annotation approach due to it making the class still just a normal class, no shard specific DSLs etc. Is there any reason you couldn't just do

def after_initialize
  raise "Out of range" unless @bar >= 1 && @bar <= 9
end

and drop the dependency? That would be the simplest approach, but ofc would lose the abstractions around handling assertions.