DefaultRules

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
implicit def arrayR[I, O](implicit arg0: ClassTag[O], r: RuleLike[I, O]): Rule[Seq[I], Array[O]]

lift a Rule[I, O] to a Rule of Rule[Seq[I], Array[O]]
lift a Rule[I, O] to a Rule of Rule[Seq[I], Array[O]]
```
(Path \ "foo").read(array(notEmpty)) // create a Rules validating that an Array contains non-empty Strings
```
r
A Rule[I, O] to lift
returns
A new Rule

Definition Classes
GenericRules
final def asInstanceOf[T0]: T0

Definition Classes
Any
def checked[I](implicit b: RuleLike[I, Boolean]): Rule[I, Boolean]

A Rule for HTML checkboxes
A Rule for HTML checkboxes

Definition Classes
GenericRules
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def date(format: String = "yyyy-MM-dd", corrector: (String) ⇒ String = identity): Rule[String, Date]

Rule for the java.util.Date type.
Rule for the java.util.Date type.
corrector
a simple string transformation function that can be used to transform input String before parsing. Useful when standards are not exactly respected and require a few tweaks

Definition Classes
DateRules
implicit val date: Rule[String, Date]

default Rule for the java.util.Date type.
default Rule for the java.util.Date type. It uses the default date format: yyyy-MM-dd

Definition Classes
DateRules
def email: Rule[String, String]

Validate that a String is a valid email
Validate that a String is a valid email
```
(Path \ "email").read(email) // This String is an email
```
Definition Classes
GenericRules
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equalTo[T](t: T): Rule[T, T]

Create a Rule of equality
Create a Rule of equality
```
(Path \ "foo").read(equalTo("bar"))
```
Definition Classes
GenericRules
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit def headAs[I, O](implicit c: RuleLike[I, O]): Rule[Seq[I], O]

Create a Rule validation that a Seq[I] is not empty, and attempt to convert it's first element as a O
Create a Rule validation that a Seq[I] is not empty, and attempt to convert it's first element as a O
```
(Path \ "foo").read(headAs(int))
```
Definition Classes
GenericRules
def ignored[I, O](o: O): (Path) ⇒ Rule[I, O]

Create a "constant" Rule which is always a success returning value o (Path \ "x").
Create a "constant" Rule which is always a success returning value o (Path \ "x").read(ignored(42))

Definition Classes
GenericRules
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val isoDate: Rule[String, Date]

ISO 8601 Reads
ISO 8601 Reads

Definition Classes
DateRules
implicit val jodaDate: Rule[String, DateTime]

the default implicit JodaDate reads It uses the default date format: yyyy-MM-dd
the default implicit JodaDate reads It uses the default date format: yyyy-MM-dd

Definition Classes
DateRules
def jodaDateRule(pattern: String, corrector: (String) ⇒ String = identity): Rule[String, DateTime]

Rule for the org.joda.time.DateTime type.
Rule for the org.joda.time.DateTime type.
pattern
a date pattern, as specified in java.text.SimpleDateFormat.
corrector
a simple string transformation function that can be used to transform input String before parsing. Useful when standards are not exactly respected and require a few tweaks

Definition Classes
DateRules
implicit val jodaLocalDate: Rule[String, LocalDate]

the default implicit Rule for org.joda.time.LocalDate
the default implicit Rule for org.joda.time.LocalDate

Definition Classes
DateRules
implicit def jodaLocalDateRule(pattern: String, corrector: (String) ⇒ String = identity): Rule[String, LocalDate]

Definition Classes
DateRules
implicit def jodaTime: Rule[Long, DateTime]

default Rule for the java.util.DateTime type.
default Rule for the java.util.DateTime type.

Definition Classes
DateRules
implicit def listR[I, O](implicit r: RuleLike[I, O]): Rule[Seq[I], List[O]]

lift a Rule[I, O] to a Rule of Rule[Seq[I], List[O]]
lift a Rule[I, O] to a Rule of Rule[Seq[I], List[O]]
```
(Path \ "foo").read(list(notEmpty)) // create a Rules validating that an List contains non-empty Strings
```
r
A Rule[I, O] to lift
returns
A new Rule

Definition Classes
GenericRules
def mapR[K, O](r: RuleLike[K, O], p: RuleLike[I, Seq[(String, K)]]): Rule[I, Map[String, O]]

def max[T](m: T)(implicit o: Ordering[T]): Rule[T, T]

(Path \ "foo").read(max(0)) // validate that there's a negative int at (Path \ "foo")

Definition Classes: GenericRules

def maxLength(l: Int): Rule[String, String]

(Path \ "foo").read(maxLength(5)) // The length of this String must be <= 5

Definition Classes: GenericRules

def min[T](m: T)(implicit o: Ordering[T]): Rule[T, T]

(Path \ "foo").read(min(0)) // validate that there's a positive int at (Path \ "foo")

Definition Classes: GenericRules

def minLength(l: Int): Rule[String, String]

(Path \ "foo").read(minLength(5)) // The length of this String must be >= 5

Definition Classes: GenericRules

final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def noConstraint[From]: (From) ⇒ Validation[ValidationError, From]

A Rule that always succeed
A Rule that always succeed

Definition Classes
GenericRules
def not[I, O](r: RuleLike[I, O]): Rule[I, I]

Definition Classes
GenericRules
def notEmpty: Rule[String, String]

a Rule validating that a String is not empty.
a Rule validating that a String is not empty.
Definition Classes
GenericRules
Note
This Rule does NOT trim the String beforehand
(Path \ "foo").read(notEmpty)
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def opt[J, O](r: ⇒ RuleLike[J, O], noneValues: RuleLike[I, I]*)(implicit pick: (Path) ⇒ RuleLike[I, I], coerce: RuleLike[I, J]): (Path) ⇒ Rule[I, Option[O]]

Attributes
protected
def pattern(regex: Regex): Rule[String, String]

Validate that a String matches the provided regex
Validate that a String matches the provided regex
```
(Path \ "foo").read(pattern("[a-z]".r)) // This String contains only letters
```
Definition Classes
GenericRules
implicit def seqR[I, O](implicit r: RuleLike[I, O]): Rule[Seq[I], Seq[O]]

lift a Rule[I, O] to a Rule of Rule[Seq[I], Seq[O]]
lift a Rule[I, O] to a Rule of Rule[Seq[I], Seq[O]]
```
(Path \ "foo").read(seq(notEmpty)) // create a Rules validating that an Seq contains non-empty Strings
```
r
A Rule[I, O] to lift
returns
A new Rule

Definition Classes
GenericRules
implicit def setR[I, O](implicit r: RuleLike[I, O]): Rule[Seq[I], Set[O]]

lift a Rule[I, O] to a Rule of Rule[Seq[I], Set[O]]
lift a Rule[I, O] to a Rule of Rule[Seq[I], Set[O]]
```
(Path \ "foo").read(set(notEmpty)) // create a Rules validating that a Set contains non-empty Strings
```
r
A Rule[I, O] to lift
returns
A new Rule

Definition Classes
GenericRules
implicit val sqlDate: Rule[String, Date]

the default implicit Rule for java.sql.Date
the default implicit Rule for java.sql.Date

Definition Classes
DateRules
def sqlDateRule(pattern: String, corrector: (String) ⇒ String = identity): Rule[String, Date]

Rule for the java.sql.Date type.
Rule for the java.sql.Date type.
pattern
a date pattern, as specified in java.text.SimpleDateFormat.
corrector
a simple string transformation function that can be used to transform input String before parsing. Useful when standards are not exactly respected and require a few tweaks

Definition Classes
DateRules
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
implicit def traversableR[I, O](implicit r: RuleLike[I, O]): Rule[Seq[I], Traversable[O]]

lift a Rule[I, O] to a Rule of Rule[Seq[I], Traversable[O]]
lift a Rule[I, O] to a Rule of Rule[Seq[I], Traversable[O]]
```
(Path \ "foo").read(traversable(notEmpty)) // create a Rules validating that an Traversable contains non-empty Strings
```
r
A Rule[I, O] to lift
returns
A new Rule

Definition Classes
GenericRules
def validateWith[I](msg: String, args: Any*)(pred: (I) ⇒ Boolean): Rule[I, I]

Create a new constraint, verifying that the provided predicate is satisfied.
Create a new constraint, verifying that the provided predicate is satisfied.
```
def notEmpty = validateWith[String]("validation.nonemptytext"){ !_.isEmpty }
```
msg
The error message to return if predicate pred is not satisfied
args
Arguments for the ValidationError
pred
A predicate to satify
returns
A new Rule validating data of type I against a predicate p

Definition Classes
GenericRules
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

trait DefaultRules[I] extends GenericRules with DateRules

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

implicit def arrayR[I, O](implicit arg0: ClassTag[O], r: RuleLike[I, O]): Rule[Seq[I], Array[O]]

final def asInstanceOf[T0]: T0

def checked[I](implicit b: RuleLike[I, Boolean]): Rule[I, Boolean]

def clone(): AnyRef

def date(format: String = "yyyy-MM-dd", corrector: (String) ⇒ String = identity): Rule[String, Date]

implicit val date: Rule[String, Date]

def email: Rule[String, String]

final def eq(arg0: AnyRef): Boolean

def equalTo[T](t: T): Rule[T, T]

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

implicit def headAs[I, O](implicit c: RuleLike[I, O]): Rule[Seq[I], O]

def ignored[I, O](o: O): (Path) ⇒ Rule[I, O]

final def isInstanceOf[T0]: Boolean

val isoDate: Rule[String, Date]

implicit val jodaDate: Rule[String, DateTime]

def jodaDateRule(pattern: String, corrector: (String) ⇒ String = identity): Rule[String, DateTime]

implicit val jodaLocalDate: Rule[String, LocalDate]

implicit def jodaLocalDateRule(pattern: String, corrector: (String) ⇒ String = identity): Rule[String, LocalDate]

implicit def jodaTime: Rule[Long, DateTime]

implicit def listR[I, O](implicit r: RuleLike[I, O]): Rule[Seq[I], List[O]]

def mapR[K, O](r: RuleLike[K, O], p: RuleLike[I, Seq[(String, K)]]): Rule[I, Map[String, O]]

def max[T](m: T)(implicit o: Ordering[T]): Rule[T, T]

def maxLength(l: Int): Rule[String, String]

def min[T](m: T)(implicit o: Ordering[T]): Rule[T, T]

def minLength(l: Int): Rule[String, String]

final def ne(arg0: AnyRef): Boolean

def noConstraint[From]: (From) ⇒ Validation[ValidationError, From]

def not[I, O](r: RuleLike[I, O]): Rule[I, I]

def notEmpty: Rule[String, String]

final def notify(): Unit

final def notifyAll(): Unit

def opt[J, O](r: ⇒ RuleLike[J, O], noneValues: RuleLike[I, I]*)(implicit pick: (Path) ⇒ RuleLike[I, I], coerce: RuleLike[I, J]): (Path) ⇒ Rule[I, Option[O]]

def pattern(regex: Regex): Rule[String, String]

implicit def seqR[I, O](implicit r: RuleLike[I, O]): Rule[Seq[I], Seq[O]]

implicit def setR[I, O](implicit r: RuleLike[I, O]): Rule[Seq[I], Set[O]]

implicit val sqlDate: Rule[String, Date]

def sqlDateRule(pattern: String, corrector: (String) ⇒ String = identity): Rule[String, Date]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

implicit def traversableR[I, O](implicit r: RuleLike[I, O]): Rule[Seq[I], Traversable[O]]

def validateWith[I](msg: String, args: Any*)(pred: (I) ⇒ Boolean): Rule[I, I]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from DateRules

Inherited from GenericRules

Inherited from AnyRef

Inherited from Any

Ungrouped