io.vertx.json.schema.impl.SchemaValidatorImpl Maven / Gradle / Ivy

Go to download
package io.vertx.json.schema.impl;

import io.vertx.core.json.Json;
import io.vertx.core.json.JsonArray;
import io.vertx.core.json.JsonObject;
import io.vertx.json.schema.*;

import java.util.Objects;
import java.util.*;
import java.util.regex.Pattern;

import static io.vertx.json.schema.impl.SchemaRepositoryImpl.dereference;
import static io.vertx.json.schema.impl.Utils.*;

public class SchemaValidatorImpl implements SchemaValidatorInternal {

  private final Map lookup;

  private final JsonSchema schema;
  private final Draft draft;
  private final OutputFormat outputFormat;
  private final JsonFormatValidator formatValidator;

  public SchemaValidatorImpl(JsonSchema schema, JsonSchemaOptions options, Map lookup,
                             boolean dereference, JsonFormatValidator formatValidator) {
    Objects.requireNonNull(schema, "'schema' cannot be null");
    Objects.requireNonNull(options, "'options' cannot be null");
    Objects.requireNonNull(options.getOutputFormat(), "'options.outputFormat' cannot be null");
    Objects.requireNonNull(lookup, "'lookup' cannot be null");
    Objects.requireNonNull(formatValidator, "'formatValidator' cannot be null");

    this.formatValidator = formatValidator;
    this.schema = schema;
    // extract the draft from schema when no specific draft is configured in the options
    this.draft = options.getDraft() == null ?
      Draft.fromIdentifier(schema.get("$schema")) :
      options.getDraft();
    this.outputFormat = options.getOutputFormat();
    this.lookup = new HashMap<>(lookup);
    if (dereference) {
      URL baseUri = new URL(options.getBaseUri());
      // add the root schema
      dereference(this.lookup, schema, baseUri, "", true);
    }
  }

  @Override
  public JsonSchema schema() {
    return schema;
  }

  @Override
  public OutputUnit validate(Object instance) throws SchemaException {
    return validate(
      instance,
      schema,
      null,
      "#",
      "#",
      "#",
      new HashSet<>(),
      new HashMap<>());
  }

  /**
   * Validate an instance against a schema.
   *
   * @param _instance        this is the object instance to validate
   * @param schema           this is the current schema, it will change as we recurse the schema and do recursive calls with the
   *                         sub-schema
   * @param _recursiveAnchor when dealing with recursive anchors (pre 2020-12 draft) this is the schema that is the
   *                         anchor
   * @param instanceLocation tracks the instance location (needed to build the correct error messages)
   * @param schemaLocation   tracks the schema location (needed to build the correct error messages)
   * @param baseLocation     tracks the location from start to current schema (needed to build the correct error messages)
   * @param evaluated        tracks evaluated schemas needed for or/oneOf/anyOf/all/etc... like validations
   * @param dynamicContext   tracks the dynamic context needed for $dynamicRef (2020-12 draft). Keys start with # for
   *                         dynamic anchors, $ are used for 2019-09 fragments
   * @return the validation result
   * @throws SchemaException when the schema is not resolvable (unknown $ref)
   */
  private OutputUnit validate(final Object _instance, final JsonSchema schema, final JsonSchema _recursiveAnchor, final String instanceLocation, final String schemaLocation, final String baseLocation, final Set