Validation Inception

Introduction

The validation API provides macro-based helpers to generate Rule and Write for case classes (or any class with a companion object providing apply / and unapply methods).

The generated code:

• is completely typesafe
• is compiled
• does not rely on runtime introspection at all
• is strictly equivalent to a hand-written definition

Example

Traditionally, for a given case class Person we would define a Rule like this:

scala> case class Person(name: String, age: Int, lovesChocolate: Boolean) defined class Person 

import jto.validation._ import play.api.libs.json._ implicit val personRule: Rule[JsValue, Person] = From[JsValue] { __ => import jto.validation.playjson.Rules._ ((__ \ "name").read[String] ~ (__ \ "age").read[Int] ~ (__ \ "lovesChocolate").read[Boolean])(Person.apply) } 

Let's test it:

scala> val json = Json.parse("""{ | "name": "Julien", | "age": 28, | "lovesChocolate": true | }""") json: play.api.libs.json.JsValue = {"name":"Julien","age":28,"lovesChocolate":true} scala> personRule.validate(json) res1: jto.validation.VA[Person] = Valid(Person(Julien,28,true)) 

The exact same Rule can be generated using Rule.gen:

import jto.validation._ import play.api.libs.json._ implicit val personRule = { import jto.validation.playjson.Rules._ // let's not leak implicits everywhere Rule.gen[JsValue, Person] } 

The validation result is identical :

scala> val json = Json.parse("""{ | "name": "Julien", | "age": 28, | "lovesChocolate": true | }""") json: play.api.libs.json.JsValue = {"name":"Julien","age":28,"lovesChocolate":true} scala> personRule.validate(json) res3: jto.validation.VA[Person] = Valid(Person(Julien,28,true)) 

Similarly we can generate a Write:

import jto.validation._ import play.api.libs.json._ implicit val personWrite = { import jto.validation.playjson.Writes._ // let's no leak implicits everywhere Write.gen[Person, JsObject] } 

scala> personWrite.writes(Person("Julien", 28, true)) res5: play.api.libs.json.JsObject = {"name":"Julien","age":28,"lovesChocolate":true} 

Known limitations

• Don’t override the apply method of the companion object. The macro inspects the apply method to generate Rule/Write. Overloading the apply method creates an ambiguity the compiler will complain about.
• Macros only work when apply and unapply have corresponding input/output types. This is naturally true for case classes. However if you want to validate a trait, you must implement the same apply/unapply you would have in a case class.
• Validation Macros accept Option/Seq/List/Set & Map[String, _]. For other generic types, you'll have to test and possibly write your Rule/Write if it's not working out of the box.