• Stars
  • Rank 2,340,999 (Top 50 %)
  • Language
  • License
    Apache License 2.0
  • Created almost 5 years ago
  • Updated about 1 year ago


There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

If you don't agree with the data

Build Status


A scala validation library without dependencies.

Let the code speak:

Validate a simple case class
case class Size(width: Int, height: Int)

object SizeValidator extends ModelValidator[Size] {
  override def apply(size: Size)(implicit context: Option[Context] = None) = {
      .field(_.width, "width")(isGreaterThan(0) and isSmallerOrEqual(5))
      .field(_.height, "height")(isGreaterThan(0) and isSmallerOrEqual(5))

val size = Size(0, 6)

val result: Xor[Size] = SizeValidator(size) 
result match {
  case Valid(s) =>
    println(s"valid $s")
  case iv: Invalid =>
    iv.errors.foreach(e => println(e.message))

// '0' must be greater than '0'.
// '6' must be smaller or equal to '5'.
Validate values wrapped in Option
val validator: Validator[Option[Int]] = optional(isPositive[Int])
val result: Xor[Option[Int]] = validator(Some(-1))
Validate elements in a List
val validator: Validator[List[Size]] = listValidator(SizeValidator)
val result: Xor[List[Size]] = validator(List(Size(0, 0), Size(1, 0)))
Validate keys or values in a Map
// pick the values
val validator: Validator[Map[String, Size]] = mapValidator[String, Size](tuple2Value(stringContains("one")))
val result: Xor[Map[String, Size]] = validator(Map("one" -> Size(0, 0)))
// pick the keys
val validator: Validator[Map[String, Size]] = mapValidator[String, Size](tuple2Key(stringContains("one")))
val result: Xor[Map[String, Size]] = validator(Map("one" -> Size(0, 0)))
Recursive fields are supported
case class Item(name: String, items: List[Item])

object ItemValidator extends ModelValidator[Item] {
  override def apply(item: Item)(implicit parent: Option[Context]) = {
      .field(_.name, "name")(stringNonEmpty)
      .field(_.items, "items")(listValidator(ItemValidator))

val item = Item("one", Item("two", Nil) :: Item("", Nil) :: Nil)

It's quick to create a custom Validator:
def stringContains(value: String) = Validator[String] { (s, context) =>
  if (s.contains(value)) Valid(s)
  else Invalid(Error(context, 'stringContains, Seq(s, value)))

Context is taken care of upstream, namely Check does the job when it is used to declare which fields of a class are to be validated. So you just need to perform the check for validity. If the value is valid, return Valid with the value and if not, return Invalid. Invalid requires the context (from upstream), as well as an error message key and a Seq of values which are to be used in the error message. Like String'{}' should contain '{}'.

Validate fields whose validity depends on the values of each other
case class Person(name: String, age: Int, birthday: LocalDate)

def AgeValidator = Validator[(Int, LocalDate)] {
  case ((age, birthday), context) =>
    val shouldBeAge = Period.between(birthday, LocalDate.now()).getYears
    val isValid = shouldBeAge == age
    if (isValid) Valid(age -> birthday)
    else Invalid(Error(context, 'wrongAge, Seq(age, birthday, shouldBeAge)))

object PersonValidator extends ModelValidator[Person] {
  override def apply(person: Person)(implicit parent: Option[Context]) = {
      .field(_.name, "name")(stringNonEmpty)
      .field(p => p.age -> p.birthday, "age")(AgeValidator)

PersonValidator(Person("max", 30, LocalDate.of(1950, 1, 1)))