Type Members

1.  final case class Context(baseUri: URI, path: JsonPointer, schemaPath: JsonPointer, readOnly: Boolean, refs: Refs, formats: Formats) extends Product with Serializable

   Contains context information as validator is executed.

   Contains context information as validator is executed.

   When schema validation is invoked the JSON Schema document is traversed and as the traversal occurs the JSON data is matched against the relevant constraints. The traversal of the Schema document needs to track the current base URI so it can resolve relative $id properties in the document itself. The paths of the current constraint and data are also maintained so that error messages can indicate the location within the data and also the location of the constraint of a failure.

   Other environment based information is kept to avoid passing implicit values to all validation methods. The information includes whether readOnly properties should be honoured and also a partial function used to validate format properties.

   Since the context is only used internally by the validation routines it is declare to be private within the project.

   baseUri

   for the current JSON Schema node

   path

   of the current JSON data node

   schemaPath

   of the current JSON Schema node

   readOnly

   true if the readOnly property should be honoured

   refs

   map containing reference resolution entries

   formats

   partial function used to validate format properties

2.  final case class EmailAddress extends Product with Serializable

   Contains the local and domain parts of an email address.

   Contains the local and domain parts of an email address.

   The local part consists of the user name or group to deliver the email to on the local machine. The domain part is the fully qualified machine name to which the mail is to be delivered. Both the local and domain values are set after any escaping has been processed. Any comments in the address have been removed.

   For example the email address:

   "fred.smith"@example.com (Fred Smith)

   will result in local being set to fred.smith and domain set to example.com. The comment (text enclosed in brackets) has been removed.

3.  type Formats = PartialFunction[(String, String), Option[Error]]

   Type of partial function required to handle format properties.

   Type of partial function required to handle format properties.

   The JSON Schema format property allows a type to be set for JSON string values. The JSON Schema Draft #7 defines a set of format types that should be supported. It is possible to extend this list and define your own formats by providing a partial function to handle your formats. See the withFormats method on SchemaValidator.

   The partial function takes a tuple containing the format type as a string and the value as a string. The function should return scala.None if the format validation succeeds, otherwise an Error should be returned wrapped in a Some.

4.  case class Hostname extends Product with Serializable

   Contains a valid hostname.

   Contains a valid hostname.

   The definition of a valid hostname can be found in RFC 1034, section 3.1.

   See also

   "RFC 1034, section 3.1"

5.  type Ids = Map[URI, JObject]

   Type of $$id map maintained with a schema.

   Type of $$id map maintained with a schema.

   Each Schema contains a map of fully qualified $$id URI values and its corresponding position in the JSON Schema. The map is used when resolving $ref references to locate URI definitions in a schema.

6.  final case class Ipv4Address extends Product with Serializable

   Contains an array of four numbers representing an IPv4 address.

   Contains an array of four numbers representing an IPv4 address.

   An IPv4 address consists of four unsigned bytes with values between 0 and 255. The bytes are represented as an array of short values as Java does not support an unsigned byte type. The array has the most significant value in index zero, with the least significant value in index three.

7.  final case class Ipv6Address extends Product with Serializable

   Contains an IPv6 address as eight integer values.

   Contains an IPv6 address as eight integer values.

   An IPv6 address is of the form:

   a:b:c:d:e:f:g:h

   where each component is a sixteen bit number. In hex between 0 and ffff. The address is stored as an array of eight numbers where each number represents a single component.

   For example the address:

   2001:DB8:0:0:8:800:200C:417A

   would be stored as an array of eight values:

   Array(0x2001, 0xD88, 0x0, 0x0, 0x8, 0x800, 0x200C, 0x417A)

8.  final case class JsonPointer extends Product with Serializable

   Contains the components making up a JSON Pointer.

   Contains the components making up a JSON Pointer.

   The components that make up the path in a JSON Pointer are stored as a vector. Each component has had any escape characters replaced with the underlying character (~0 => ~, ~1 => /). A series of methods are provided that allow paths to be built and resolved.

   The root path is represented by an empty JSON pointer:

   JsonPointer()

   Paths can be built up. For example

   JsonPointer() / "items" / 0 / "name"

   refers to the name property stored in the zeroth element of the items array.

   Paths can be resolved against a JSON document:

   JsonPointer.fromString("items/0/name").resolve(
     parse("""
       {
         "items": [
           {"name": "spanner"},
           {"name", "hammer"},
           {"name", "chisel"
         ]
       }"""
     )
   )

   would resolve to the value "spanner".

9.  type Refs = Map[URI, Option[JValue]]

   Type of $$ref map maintained with a schema.

   Type of $$ref map maintained with a schema.

   Each Schema contains a map for each fully qualified $$ref URI value and the position in a JSON Schema referenced by that URI. When a schema is read only local references are resolved, with external references being resolved when an external schema is resolved against the current schema. See the resolve method on Schema. Since an reference may not be resolved its location is defined as an scala.Option.

10.  final case class RelativeJsonPointer extends Product with Serializable

    Contains the components that make up a relative JSON Pointer.

    Contains the components that make up a relative JSON Pointer.

    A relative JSON Pointer is defined as a non-negative integer followed by either a JSON Pointer or a #. The number specifies the number of parent nodes to traverse before applying either a JSON Pointer path or in the case of a # output the current array index if in a JSON array or property key if in a JSON object.

    Example:

    {
      "foo": ["bar", "baz"],
      "highly": {
        "nested": {
          "objects": true
        }
      }
    }

    Starting from the value "baz" (inside "foo"), the following JSON strings evaluate to the accompanying values:

    "0"                         "baz"
    "1/0"                       "bar"
    "2/highly/nested/objects"   true
    "0#"                        1
    "1#"                        "foo"

11.  type Result[A] = Validated[NonEmptyList[Error], A]

    Generic type returned from validation and schema methods.

    Generic type returned from validation and schema methods.

    When a schema is loaded a number of errors my occur. These errors include bad URI identifiers and references. In order to allow multiple errors to be returned the Validated type is used with the error component defined as a list of Error errors. In the case of validation a list of errors is also generated and stored as a list of Error errors.

12.  case class Schema extends Product with Serializable

    Wraps a JSON Schema compliant tree.

    Wraps a JSON Schema compliant tree.

    A JSON Schema tree contains the definition of a schema used to validate a JSON data structure. In order to provide efficient validation and also fast navigation of the JSON Schema tree, all $id properties are extracted into a map and all $ref properties are resolved against that map where possible. Since a $ref may refer to an external schema it may not be possible to resolve all references when wrapping the JSON Schema.

    The resolution of all $ref references is achieved by calling the resolve() method with external JSON Schema documents. Where a reference can be resolved against the external document the entry in the refs map is updated. The refs map contains as a key the fully qualified URI specified by the $ref reference and the value points to a part of a JSON Schema resolved against the reference. If a reference has not been resolved its value is None and where resolved a Some value containing the referenced JSON Schema is found.

    When a JSON Schema is wrapped any internal references are resolved automatically, only external references need to added via the resolve() method. Consider the following three JSON Schema documents:

    val schema1 = parse("""
      {
        "$id": "cdp:/test/resources/reftableone#",
        "definitions": {
          "date": {
            "$id": "#date",
            "type": "string",
            "format": "partial-date"
          }
        }
      }"""
    )
    val schema2 = parse("""
      {
        "$id": "cdp:/test/resources/reftabletwo#",
        "definitions": {
          "start": {
            "$ref":"cdp:/test/resources/reftableone#date"
          },
          "end": {
            "$ref":"cdp:/test/resources/reftableone#date"
          }
        }
      }"""
    )
    val schema3 = parse("""
      {
        "$id": "cdp:/test/resources/reftablethree#",
        "properties": {
          "begin": {
            "$ref": "cdp:/test/resources/reftabletwo#/definitions/start"
          },
          "finish": {
            "$ref": "cdp:/test/resources/reftabletwo#/definitions/end"
          }
        }
      }"""
    )

    The following code is required to wrap schema3 and resolve all references:

    Schema(schema1).andThen { one =>
      Schema(schema2).andThen { two =>
        Schema(schema3).andThen { three =>
          three.resolve(two)
            .andThen(_.resolve(one))
        }
      }
    }

    The result of the above code is a wrapped schema3 with all references resolved. Note the order of resolution is important. schema2 is resolved against schema3 first (as it resolves the two references to schema2, but also introduces two new references to schema1), then schema1 is resolved (as it resolved the two references added by schema2).

    A list of unresolved references can be retrieved via the unresolved() method. The method returns a list of unresolved fully qualified URI values. The isResolved method will return true if all references have been resolved, otherwise false is returned.

    When a JSON Schema is wrapped its root $id value is extracted as a property. If a root $id URI is not specified then one is generated. The format of the generated URI is:

    ni:///md5;<md5 checksum>

    The <md5 checksum> is generated by converting the JSON Schema to a string and computing the string's md5 checksum. Such an approach ensures JSON Schema's that do not contain a root $id URI end up with a unique root URI.

13.  type SchemaResult = Validated[NonEmptyList[Error], Schema]

    Specific result type for loading JSON Schemas.

    Specific result type for loading JSON Schemas.

    When a JSON Schema is loaded either a Schema is created or a list of error is returned. This type defines the return type used when loading schemas.

14.  case class SchemaValidator extends Product with Serializable

    Allows a JSON Schema to be used to validate a JSON data object.

    Allows a JSON Schema to be used to validate a JSON data object.

    A validator wraps a Schema along with the formats partial function to allows JSON data object to be validated. The use of a partial function for resolving different formats allows third party formats to be supported.

    An example use is:

    val schema = parse("""
      {
        "properties": {
          "foo": {"type": "integer"},
          "bar": {"type": "string"}
        }
      }"""
    )
    val validator = Schema(schema).andThen(SchemaValidator(_))
    val result = validator.validate(data).isValid

    It is also possible to add in extra format values using a partial function:

    private implicit val bundle = MessagesBundle("com.example.Resources")
    val formats: PartialFunction[(String, String), Option[Message]] = {
      case ("phonenumber", value) =>
        "^[0-9]{8}$".r.findFirstIn(value) match {
          case None => Some(Message("BadPhoneNubmer", value))
          case Some(_) => None
        }
    }
    val validator = Schema(schema)
      .andThen(SchemaValidator(_).withFormats(formats))

    A standard set of formats are provided based on the JSON Schema Draft #7. In order to support formats outside the standard the withFormats() method should be provided with a partial function to cater for extra formats.

15.  abstract class SchemaWalker[A] extends AnyRef

    Provides a "visitor" pattern to walk a JSON Schema document.

    Provides a "visitor" pattern to walk a JSON Schema document.

    The walk method visits each node in a JSON Schema document. For each JSON Object encountered it invokes the abstract process method for each property defined within the JSON object. Along with each property name and value it passes in the JSON object containing the property and the base URI for the object. The base URI is determined by processing $$id properties found in the JSON Schema.

    Users should implement the abstract process method if they want to handle properties stored in a JSON Schema document. The method should return either an error in Error or a value defined by the A type generic. Since process accumulates results the type A must implement a Semigroup implicit value to combine A elements.

    Example:

    val walker = new SchemaWalker[Unit] {
      def process((path: JsonPointer, baseUri: URI, parent: JObject,
          name: String, value: JValue): Validated[Error, Unit] =
        (name, value) match {
          case ("$ref", JString(uri)) =>
            println(s"Found reference ${baseUri.resolve(uri)}")
          case _ =>
        }
    }
    
    walker.walk(new Uri(), parse("""{ <JSON Schema Document> }"""))

    A

    type returned from process method

16.  type ValidatorResult = Validated[NonEmptyList[Error], Unit]

    Specific result type for JSON validation.

    Specific result type for JSON validation.

    When a JSON Schema is validated against a JSON document the result is either a list of errors or Unit. If Unit is returned then the validation succeeded.