JsonSchema.h

Go to the documentation of this file.

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * JsonSchema.h
 * A Json Schema, see json-schema.org
 * Copyright (C) 2014 Simon Newton
 */

#ifndef INCLUDE_OLA_WEB_JSONSCHEMA_H_
#define INCLUDE_OLA_WEB_JSONSCHEMA_H_

#include <ola/base/Macro.h>
#include <ola/stl/STLUtils.h>
#include <ola/web/Json.h>
#include <ola/web/JsonTypes.h>
#include <deque>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>

namespace ola {
namespace web {

class SchemaDefinitions;

class ValidatorInterface : public JsonValueConstVisitorInterface {
 public:
  typedef std::vector<ValidatorInterface*> ValidatorList;

  virtual ~ValidatorInterface() {}

  virtual bool IsValid() const = 0;

  // Do we need a "GetError" here?

  virtual JsonObject* GetSchema() const = 0;

  virtual void SetSchema(const std::string &schema) = 0;

  virtual void SetId(const std::string &id) = 0;

  virtual void SetTitle(const std::string &title) = 0;

  virtual void SetDescription(const std::string &title) = 0;

  virtual void SetDefaultValue(const JsonValue *value) = 0;

  virtual const JsonValue *GetDefaultValue() const = 0;
};

class BaseValidator : public ValidatorInterface {
 protected:
  explicit BaseValidator(JsonType type)
      : m_is_valid(true),
        m_type(type) {
  }

 public:
  virtual ~BaseValidator();

  virtual bool IsValid() const { return m_is_valid; }

  virtual void Visit(const JsonString&) {
    m_is_valid = false;
  }

  virtual void Visit(const JsonBool&) {
    m_is_valid = false;
  }

  virtual void Visit(const JsonNull&) {
    m_is_valid = false;
  }

  virtual void Visit(const JsonRawValue&) {
    m_is_valid = false;
  }

  virtual void Visit(const JsonObject&) {
    m_is_valid = false;
  }

  virtual void Visit(const JsonArray&) {
    m_is_valid = false;
  }

  virtual void Visit(const JsonUInt&) {
    m_is_valid = false;
  }

  virtual void Visit(const JsonUInt64&) {
    m_is_valid = false;
  }

  virtual void Visit(const JsonInt&) {
    m_is_valid = false;
  }

  virtual void Visit(const JsonInt64&) {
    m_is_valid = false;
  }

  virtual void Visit(const JsonDouble&) {
    m_is_valid = false;
  }

  virtual JsonObject* GetSchema() const;

  void SetSchema(const std::string &schema);

  void SetId(const std::string &id);

  void SetTitle(const std::string &title);

  void SetDescription(const std::string &title);

  void SetDefaultValue(const JsonValue *value);

  const JsonValue *GetDefaultValue() const;

  void AddEnumValue(const JsonValue *value);

 protected:
  bool m_is_valid;
  JsonType m_type;
  std::string m_schema;
  std::string m_id;
  std::string m_title;
  std::string m_description;
  std::auto_ptr<const JsonValue> m_default_value;
  std::vector<const JsonValue*> m_enums;

  bool CheckEnums(const JsonValue &value);

  // Child classes can hook in here to extend the schema.
  virtual void ExtendSchema(JsonObject *schema) const {
    (void) schema;
  }
};

class WildcardValidator : public BaseValidator {
 public:
  WildcardValidator() : BaseValidator(JSON_UNDEFINED) {}

  bool IsValid() const { return true; }
};

class ReferenceValidator : public ValidatorInterface {
 public:
  ReferenceValidator(const SchemaDefinitions *definitions,
                     const std::string &schema);

  bool IsValid() const;

  void Visit(const JsonString &value);
  void Visit(const JsonBool &value);
  void Visit(const JsonNull &value);
  void Visit(const JsonRawValue &value);
  void Visit(const JsonObject &value);
  void Visit(const JsonArray &value);
  void Visit(const JsonUInt &value);
  void Visit(const JsonUInt64 &value);
  void Visit(const JsonInt &value);
  void Visit(const JsonInt64 &value);
  void Visit(const JsonDouble &value);

  JsonObject* GetSchema() const;

  void SetSchema(const std::string &schema);
  void SetId(const std::string &id);
  void SetTitle(const std::string &title);
  void SetDescription(const std::string &title);
  void SetDefaultValue(const JsonValue *value);
  const JsonValue *GetDefaultValue() const;

 private:
  const SchemaDefinitions *m_definitions;
  const std::string m_schema;
  ValidatorInterface *m_validator;

  template <typename T>
  void Validate(const T &value);
};

class StringValidator : public BaseValidator {
 public:
  struct Options {
    Options()
      : min_length(0),
        max_length(-1) {
    }

    unsigned int min_length;
    int max_length;
    // Formats & Regexes aren't supported.
    // std::string pattern
    // std::string format
  };

  explicit StringValidator(const Options &options)
      : BaseValidator(JSON_STRING),
        m_options(options) {
  }

  void Visit(const JsonString &str);

 private:
  const Options m_options;

  void ExtendSchema(JsonObject *schema) const;

  DISALLOW_COPY_AND_ASSIGN(StringValidator);
};

class BoolValidator : public BaseValidator {
 public:
  BoolValidator() : BaseValidator(JSON_BOOLEAN) {}

  void Visit(const JsonBool &value) { m_is_valid = CheckEnums(value); }

 private:
  DISALLOW_COPY_AND_ASSIGN(BoolValidator);
};

class NullValidator : public BaseValidator {
 public:
  NullValidator() : BaseValidator(JSON_NULL) {}

  void Visit(const JsonNull &value) { m_is_valid = CheckEnums(value); }

 private:
  DISALLOW_COPY_AND_ASSIGN(NullValidator);
};

class NumberConstraint {
 public:
  virtual ~NumberConstraint() {}

  virtual bool IsValid(const JsonNumber &value) = 0;

  virtual void ExtendSchema(JsonObject *schema) const = 0;
};

class MultipleOfConstraint : public NumberConstraint {
 public:
  explicit MultipleOfConstraint(const JsonNumber *value)
      : m_multiple_of(value) {
  }

  bool IsValid(const JsonNumber &value) {
    return value.MultipleOf(*m_multiple_of);
  }

  void ExtendSchema(JsonObject *schema) const {
    schema->AddValue("multipleOf", m_multiple_of->Clone());
  }

 private:
  std::auto_ptr<const JsonNumber> m_multiple_of;
};

class MaximumConstraint : public NumberConstraint {
 public:
  MaximumConstraint(const JsonNumber *limit, bool is_exclusive)
      : m_limit(limit),
        m_has_exclusive(true),
        m_is_exclusive(is_exclusive) {
  }

  explicit MaximumConstraint(const JsonNumber *limit)
      : m_limit(limit),
        m_has_exclusive(false) {
  }

  bool IsValid(const JsonNumber &value) {
    return (m_has_exclusive && m_is_exclusive) ? value < *m_limit
        : value <= *m_limit;
  }

  void ExtendSchema(JsonObject *schema) const {
    schema->AddValue("maximum", m_limit->Clone());
    if (m_has_exclusive) {
      schema->Add("exclusiveMaximum", m_is_exclusive);
    }
  }

 private:
  std::auto_ptr<const JsonNumber> m_limit;
  bool m_has_exclusive, m_is_exclusive;
};

class MinimumConstraint : public NumberConstraint {
 public:
  MinimumConstraint(const JsonNumber *limit, bool is_exclusive)
      : m_limit(limit),
        m_has_exclusive(true),
        m_is_exclusive(is_exclusive) {
  }

  explicit MinimumConstraint(const JsonNumber *limit)
      : m_limit(limit),
        m_has_exclusive(false) {
  }

  bool IsValid(const JsonNumber &value) {
    return (m_has_exclusive && m_is_exclusive) ? value > *m_limit
        : value >= *m_limit;
  }

  void ExtendSchema(JsonObject *schema) const {
    schema->AddValue("minimum", m_limit->Clone());
    if (m_has_exclusive) {
      schema->Add("exclusiveMinimum", m_is_exclusive);
    }
  }

 private:
  std::auto_ptr<const JsonNumber> m_limit;
  bool m_has_exclusive, m_is_exclusive;
};

class IntegerValidator : public BaseValidator {
 public:
  IntegerValidator() : BaseValidator(JSON_INTEGER) {}
  virtual ~IntegerValidator();

  void AddConstraint(NumberConstraint *constraint);

  void Visit(const JsonUInt&);
  void Visit(const JsonInt&);
  void Visit(const JsonUInt64&);
  void Visit(const JsonInt64&);
  virtual void Visit(const JsonDouble&);

 protected:
  explicit IntegerValidator(JsonType type) : BaseValidator(type) {}

  void CheckValue(const JsonNumber &value);

 private:
  std::vector<NumberConstraint*> m_constraints;

  void ExtendSchema(JsonObject *schema) const;

  DISALLOW_COPY_AND_ASSIGN(IntegerValidator);
};


class NumberValidator : public IntegerValidator {
 public:
  NumberValidator() : IntegerValidator(JSON_NUMBER) {}

  void Visit(const JsonDouble&);

 private:
  DISALLOW_COPY_AND_ASSIGN(NumberValidator);
};

class ObjectValidator : public BaseValidator, JsonObjectPropertyVisitor {
 public:
  struct Options {
    Options()
      : max_properties(-1),
        min_properties(0),
        has_required_properties(false),
        has_allow_additional_properties(false) {
    }

    void SetRequiredProperties(
        const std::set<std::string> &required_properties_arg) {
      required_properties = required_properties_arg;
      has_required_properties = true;
    }

    void SetAdditionalProperties(bool allow_additional) {
      has_allow_additional_properties = true;
      allow_additional_properties = allow_additional;
    }

    int max_properties;
    unsigned int min_properties;
    bool has_required_properties;
    std::set<std::string> required_properties;
    bool has_allow_additional_properties;
    bool allow_additional_properties;
  };

  explicit ObjectValidator(const Options &options);
  ~ObjectValidator();

  void AddValidator(const std::string &property, ValidatorInterface *validator);

  void SetAdditionalValidator(ValidatorInterface *validator);

  void AddSchemaDependency(const std::string &property,
                           ValidatorInterface *validator);

  void AddPropertyDependency(const std::string &property,
                             const std::set<std::string> &properties);

  void Visit(const JsonObject &obj);

  void VisitProperty(const std::string &property, const JsonValue &value);

 private:
  typedef std::set<std::string> StringSet;
  typedef std::map<std::string, ValidatorInterface*> PropertyValidators;
  typedef std::map<std::string, ValidatorInterface*> SchemaDependencies;
  typedef std::map<std::string, StringSet> PropertyDependencies;

  const Options m_options;

  PropertyValidators m_property_validators;
  std::auto_ptr<ValidatorInterface> m_additional_property_validator;
  PropertyDependencies m_property_dependencies;
  SchemaDependencies m_schema_dependencies;

  StringSet m_seen_properties;

  void ExtendSchema(JsonObject *schema) const;

  DISALLOW_COPY_AND_ASSIGN(ObjectValidator);
};

class ArrayValidator : public BaseValidator {
 public:
  class Items {
   public:
    explicit Items(ValidatorInterface *validator)
      : m_validator(validator) {
    }

    explicit Items(ValidatorList *validators)
      : m_validator(NULL),
        m_validator_list(*validators) {
    }

    ~Items() {
      STLDeleteElements(&m_validator_list);
    }

    ValidatorInterface* Validator() const { return m_validator.get(); }
    const ValidatorList& Validators() const { return m_validator_list; }

   private:
    std::auto_ptr<ValidatorInterface> m_validator;
    ValidatorList m_validator_list;

    DISALLOW_COPY_AND_ASSIGN(Items);
  };

  class AdditionalItems {
   public:
    explicit AdditionalItems(bool allow_additional)
        : m_allowed(allow_additional),
          m_validator(NULL) {
    }

    explicit AdditionalItems(ValidatorInterface *validator)
        : m_allowed(true),
          m_validator(validator) {
    }

    ValidatorInterface* Validator() const { return m_validator.get(); }
    bool AllowAdditional() const { return m_allowed; }

   private:
    bool m_allowed;
    std::auto_ptr<ValidatorInterface> m_validator;

    DISALLOW_COPY_AND_ASSIGN(AdditionalItems);
  };

  struct Options {
    Options()
      : max_items(-1),
        min_items(0),
        unique_items(false) {
    }

    int max_items;
    unsigned int min_items;
    bool unique_items;
  };

  ArrayValidator(Items *items, AdditionalItems *additional_items,
                 const Options &options);

  ~ArrayValidator();

  void Visit(const JsonArray &array);

 private:
  typedef std::deque<ValidatorInterface*> ValidatorQueue;

  const std::auto_ptr<Items> m_items;
  const std::auto_ptr<AdditionalItems> m_additional_items;
  const Options m_options;

  // This is used if items is missing, or if additionalItems is true.
  std::auto_ptr<WildcardValidator> m_wildcard_validator;

  class ArrayElementValidator : public BaseValidator {
   public:
    ArrayElementValidator(const ValidatorList &validators,
                          ValidatorInterface *default_validator);

    void Visit(const JsonString&);
    void Visit(const JsonBool&);
    void Visit(const JsonNull&);
    void Visit(const JsonRawValue&);
    void Visit(const JsonObject&);
    void Visit(const JsonArray &array);
    void Visit(const JsonUInt&);
    void Visit(const JsonUInt64&);
    void Visit(const JsonInt&);
    void Visit(const JsonInt64&);
    void Visit(const JsonDouble&);

   private:
    ValidatorQueue m_item_validators;
    ValidatorInterface *m_default_validator;

    template <typename T>
    void ValidateItem(const T &item);

    DISALLOW_COPY_AND_ASSIGN(ArrayElementValidator);
  };

  void ExtendSchema(JsonObject *schema) const;
  ArrayElementValidator* ConstructElementValidator() const;

  DISALLOW_COPY_AND_ASSIGN(ArrayValidator);
};


class ConjunctionValidator : public BaseValidator {
 public:
  ConjunctionValidator(const std::string &keyword, ValidatorList *validators);
  virtual ~ConjunctionValidator();

  void Visit(const JsonString &value) {
    Validate(value);
  }

  void Visit(const JsonBool &value) {
    Validate(value);
  }

  void Visit(const JsonNull &value) {
    Validate(value);
  }

  void Visit(const JsonRawValue &value) {
    Validate(value);
  }

  void Visit(const JsonObject &value) {
    Validate(value);
  }

  void Visit(const JsonArray &value) {
    Validate(value);
  }

  void Visit(const JsonUInt &value) {
    Validate(value);
  }

  void Visit(const JsonUInt64 &value) {
    Validate(value);
  }

  void Visit(const JsonInt &value) {
    Validate(value);
  }

  void Visit(const JsonInt64 &value) {
    Validate(value);
  }

  void Visit(const JsonDouble &value) {
    Validate(value);
  }

 protected:
  std::string m_keyword;
  ValidatorList m_validators;

  void ExtendSchema(JsonObject *schema) const;

  virtual void Validate(const JsonValue &value) = 0;
};

class AllOfValidator : public ConjunctionValidator {
 public:
  explicit AllOfValidator(ValidatorList *validators)
      : ConjunctionValidator("allOf", validators) {
  }

 protected:
  void Validate(const JsonValue &value);

 private:
  DISALLOW_COPY_AND_ASSIGN(AllOfValidator);
};

class AnyOfValidator : public ConjunctionValidator {
 public:
  explicit AnyOfValidator(ValidatorList *validators)
      : ConjunctionValidator("anyOf", validators) {
  }

 protected:
  void Validate(const JsonValue &value);

 private:
  DISALLOW_COPY_AND_ASSIGN(AnyOfValidator);
};

class OneOfValidator : public ConjunctionValidator {
 public:
  explicit OneOfValidator(ValidatorList *validators)
      : ConjunctionValidator("oneOf", validators) {
  }

 protected:
  void Validate(const JsonValue &value);

 private:
  DISALLOW_COPY_AND_ASSIGN(OneOfValidator);
};

class NotValidator : public BaseValidator {
 public:
  explicit NotValidator(ValidatorInterface *validator)
      : BaseValidator(JSON_UNDEFINED),
        m_validator(validator) {
  }

  void Visit(const JsonString &value) {
    Validate(value);
  }

  void Visit(const JsonBool &value) {
    Validate(value);
  }

  void Visit(const JsonNull &value) {
    Validate(value);
  }

  void Visit(const JsonRawValue &value) {
    Validate(value);
  }

  void Visit(const JsonObject &value) {
    Validate(value);
  }

  void Visit(const JsonArray &value) {
    Validate(value);
  }

  void Visit(const JsonUInt &value) {
    Validate(value);
  }

  void Visit(const JsonUInt64 &value) {
    Validate(value);
  }

  void Visit(const JsonInt &value) {
    Validate(value);
  }

  void Visit(const JsonInt64 &value) {
    Validate(value);
  }

  void Visit(const JsonDouble &value) {
    Validate(value);
  }

 private:
  std::auto_ptr<ValidatorInterface> m_validator;

  void Validate(const JsonValue &value);

  void ExtendSchema(JsonObject *schema) const;

  DISALLOW_COPY_AND_ASSIGN(NotValidator);
};

class SchemaDefinitions {
 public:
  SchemaDefinitions() {}
  ~SchemaDefinitions();

  void Add(const std::string &schema_name, ValidatorInterface *validator);
  ValidatorInterface *Lookup(const std::string &schema_name) const;

  void AddToJsonObject(JsonObject *json) const;

  bool HasDefinitions() const { return !m_validators.empty(); }

 private:
  typedef std::map<std::string, ValidatorInterface*> SchemaMap;

  SchemaMap m_validators;

  DISALLOW_COPY_AND_ASSIGN(SchemaDefinitions);
};


class JsonSchema {
 public:
  ~JsonSchema() {}

  /*
   * @brief The URI which defines which version of the schema this is.
   */
  std::string SchemaURI() const;

  bool IsValid(const JsonValue &value);

  const JsonObject* AsJson() const;

  static JsonSchema* FromString(const std::string& schema_string,
                                std::string *error);

 private:
  std::string m_schema_uri;
  std::auto_ptr<ValidatorInterface> m_root_validator;
  std::auto_ptr<SchemaDefinitions> m_schema_defs;

  JsonSchema(const std::string &schema_url,
             ValidatorInterface *root_validator,
             SchemaDefinitions *schema_defs);

  DISALLOW_COPY_AND_ASSIGN(JsonSchema);
};

}  // namespace web
}  // namespace ola
#endif  // INCLUDE_OLA_WEB_JSONSCHEMA_H_