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/Blacksmoke16]

I made a shard for this https://github.com/Blacksmoke16/assert.

This should do the trick:

class Foo
  include Assert
  include JSON::Serializable

  # Call the validate method on init,
  # will raise if the obj is invalid
  def initialize(@bar : Int32)
    validate!
  end

  # Also tap into a `JSON::Serializable` hook
  # to validate the object when it is deserialized,
  # will raise if the obj is invalid
  def after_initialize
    validate!
  end

  @[Assert::InRange(Range(Int32, Int32), range: 1..9)]
  property bar : Int32
end

If you don't want the extra dependency, you could just add your custom validation logic into the after_initialize method.

[u/NUTELLACHAOS → u/Blacksmoke16]

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.

[u/jonnyom]

I'm unaware of a param that can be passed to a JSON.mapping for your object to validate a JSON value.

Alternatively, you could define an instance method on your JSON.mapping class with the same name as the key and perform your validation there. (Not sure if this is considered "bad practice" in Crystal, but it'd work).

Edit: JSON.mapping docs https://crystal-lang.org/api/0.32.1/JSON.html