libcruft-util/json/schema.cpp

/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * Copyright 2015-2018 Danny Robson <danny@nerdcruft.net>
 */

#include "schema.hpp"

#include "tree.hpp"
#include "except.hpp"

#include "../debug.hpp"
#include "../io.hpp"
#include "../maths.hpp"

#include <regex>


///////////////////////////////////////////////////////////////////////////////
struct length_error : public json::schema_error {
    length_error (const std::string &what):
        schema_error (what)
    { ; }
};


//-----------------------------------------------------------------------------
struct format_error : public json::schema_error {
    format_error (const std::string &what):
        schema_error (what)
    { ; }
};


///////////////////////////////////////////////////////////////////////////////
static void validate (json::tree::node&, const json::tree::object&);


///////////////////////////////////////////////////////////////////////////////
static void
validate (json::tree::object &node,
          const json::tree::object &schema)
{
    auto properties = schema.find ("properties");
    auto additional = schema.find ("additionalProperties");
    auto pattern    = schema.find ("patternProperties");

    if (properties != schema.cend ()) {
        for (const auto &kv: properties->second->as_object ()) {
            auto p = node.find (kv.first);
            if (p != node.cend ())
                validate (*p->second, kv.second->as_object ());
            else {
                try {
                    node.insert (kv.first, (*kv.second)["default"].clone ());
                    validate (node[kv.first], kv.second->as_object ());
                    continue;
                } catch (const json::key_error&)
                { ; }

                if (additional != schema.cend ()) {
                    if (additional->second->is_boolean () && !additional->second->as_bool ())
                        throw json::schema_error ("additionalProperties");

                    validate (*p->second, additional->second->as_object ());
                }
            }
        }
    }

    if (pattern != schema.cend ()) {
        for (auto &cond: pattern->second->as_object ()) {
            std::regex expr (cond.first, std::regex_constants::ECMAScript);

            for (auto &props: node) {
                if (std::regex_search (props.first, expr))
                    validate (*props.second, cond.second->as_object ());
            }
        }
    }

    if (schema.has ("dependencies"))
        not_implemented ();

    // properties must be checked after the 'properties' check has a chance to
    // create the defaulted entries.
    auto maxProperties = schema.find ("maxProperties");
    if (maxProperties != schema.cend ())
        if (node.size () > maxProperties->second->as_uint ())
            throw json::schema_error ("maxProperties");

    auto minProperties = schema.find ("minProperties");
    if (minProperties != schema.cend ())
        if (node.size () < minProperties->second->as_uint ())
            throw json::schema_error ("minProperties");

    auto required = schema.find ("required");
    if (required != schema.cend ())
        for (const auto &i: required->second->as_array ())
            if (!node.has (i.as_string ()))
                throw json::schema_error ("required");
}


//-----------------------------------------------------------------------------
static void
validate (json::tree::array &node,
          const json::tree::object &schema)
{
    // attempt to match the item and additionalItem schemas
    auto items = schema.find ("items");
    auto additional = schema.find ("additionalItems");

    if (items != schema.cend ()) {
        // items is an object, test all elements with it as a schema
        if (items->second->is_object ()) {
            for (auto &i: node)
                validate (i, items->second->as_object ());
        // items is a list of schemas, test n-elements with it as a schema
        } else if (items->second->is_array ()) {
            const auto &itemArray = items->second->as_array ();

            size_t i = 0;
            for (; i < itemArray.size () && i < node.size (); ++i)
                validate (node[i], itemArray[i].as_object ());

            // we've exhausted the schema list, use the additional schema
            if (i == itemArray.size ()) {
                if (additional->second->is_boolean ()) {
                    if (!additional->second->as_boolean ())
                        throw json::schema_error ("additional");
                } else if (additional->second->is_object ()) {
                    for ( ; i < node.size (); ++i)
                        validate (node[i], additional->second->as_object ());
                } else {
                    throw json::schema_error ("items");
                }
            }
        }
    }

    auto maxItems = schema.find ("maxItems");
    if (maxItems != schema.cend ())
        if (node.size () > maxItems->second->as_uint ())
            throw json::schema_error ("maxItems");

    auto minItems = schema.find ("minItems");
    if (minItems != schema.cend ())
        if (node.size () < minItems->second->as_uint ())
            throw json::schema_error ("minItems");

    // check all element are unique
    // XXX: uses a naive n^2 brute force search on equality because it's 2am
    // and I don't want to write a type aware comparator for the sort.
    auto unique = schema.find ("uniqueItems");
    if (unique != schema.cend () && unique->second->as_boolean ())
        for (size_t a = 0; a < node.size (); ++a)
            for (size_t b = a + 1; b < node.size (); ++b)
                if (node[a] == node[b])
                    throw json::schema_error ("uniqueItems");
}


//-----------------------------------------------------------------------------
static void
validate (json::tree::string &node,
          const json::tree::object &schema)
{
    const auto &val = node.native ();

    // check length is less than a maximum
    auto maxLength = schema.find ("maxLength");
    if (maxLength != schema.cend ()) {
        auto cmp = maxLength->second->as_number ().uint ();
        if (!util::is_integer (cmp))
            throw length_error ("maxLength");

        if (val.size () > cmp)
            throw length_error ("maxLength");
    }

    // check length is greater than a maximum
    auto minLength = schema.find ("minLength");
    if (minLength != schema.cend ()) {
        auto cmp = minLength->second->as_number ().uint ();
        if (!util::is_integer (cmp))
            throw length_error ("minLength");

        if (val.size () < cmp)
            throw length_error ("minLength");
    }

    // check the string conforms to a regex
    // Note: this uses the c++11 regex engine which slightly differs from ECMA 262
    auto pattern = schema.find ("pattern");
    if (pattern != schema.cend ()) {
        std::regex r (pattern->second->as_string ().native (),
                      std::regex_constants::ECMAScript);
        if (!std::regex_search (val, r))
            throw format_error ("pattern");
    }
}


//-----------------------------------------------------------------------------
template <typename T>
static void
validate_number (T val, const json::tree::object &schema) {
    using R = json::tree::number::repr_t;

    // check strictly positive integer multiple
    auto mult = schema.find ("multipleOf");
    if (mult != schema.cend ()) {
        const auto &div = mult->second->as_number ();

        switch (div.repr ()) {
            case R::REAL:  if (util::exactly_zero (std::fmod (val, div.real ()))) throw json::schema_error ("multipleOf"); break;
            case R::SINT:  if (util::exactly_zero (std::fmod (val, div.sint ()))) throw json::schema_error ("multipleOf"); break;
            case R::UINT:  if (util::exactly_zero (std::fmod (val, div.uint ()))) throw json::schema_error ("multipleOf"); break;
        }
    }

    // check maximum holds. exclusive requires max condition.
    auto max = schema.find ("maximum");
    auto exclusiveMax = schema.find ("exclusiveMaximum");
    if (max != schema.end ()) {
        const auto &cmp = max->second->as_number ();

        if (exclusiveMax != schema.end () && exclusiveMax->second->as_boolean ()) {
            switch (cmp.repr ()) {
            case R::REAL:
                if (T(val) >= cmp.real ())
                    throw json::schema_error ("exclusiveMax");
                break;

            case R::SINT:
                if (json::tree::number::sint_t(std::numeric_limits<T>::max ()) >= cmp.sint () &&
                    val >= T(cmp.sint ()))
                {
                    throw json::schema_error ("exclusiveMax");
                }
                break;

            case R::UINT:
                if (json::tree::number::uint_t(std::numeric_limits<T>::max ()) >= cmp.uint () &&
                    val >= T(cmp.uint ()))
                {
                    throw json::schema_error ("exclusiveMax");
                }
                break;
            }
        } else {
            switch (cmp.repr ()) {
            case R::REAL:
                if (T(val) > cmp.real ())
                    throw json::schema_error ("maximum");
                break;
            case R::SINT:
                if (json::tree::number::sint_t(std::numeric_limits<T>::max ()) >= cmp.sint () &&
                    val >= T(cmp.sint ()))
                {
                    throw json::schema_error ("maximum");
                }
                break;
            case R::UINT:
                if (json::tree::number::uint_t(std::numeric_limits<T>::max ()) >= cmp.uint () &&
                    val >= T(cmp.uint ()))
                {
                    throw json::schema_error ("maximum");
                }
                break;
            }
        }
    } else {
        if (exclusiveMax != schema.cend ())
            throw json::schema_error ("exclusiveMax");
    }

    // check minimum holds. exclusive requires min condition
    auto min = schema.find ("minimum");
    auto exclusiveMin = schema.find ("exclusiveMinimum");
    if (min != schema.end ()) {
        const auto &cmp = min->second->as_number ();

        if (exclusiveMin != schema.end () && exclusiveMin->second->as_boolean ()) {
            switch (cmp.repr ()) {
            case R::REAL:
                if (T(val) < cmp.real ())
                    throw json::schema_error ("exclusiveMin");
                break;
            case R::SINT:
                if (cmp.sint () > json::tree::number::sint_t(std::numeric_limits<T>::min ()) &&
                    val < T(cmp.sint ()))
                {
                    throw json::schema_error ("exclusiveMin");
                }
                break;
            case R::UINT:
                if (cmp.uint () > json::tree::number::uint_t(std::numeric_limits<T>::min ()) &&
                    val < T(cmp.uint ()))
                {
                    throw json::schema_error ("exclusiveMin");
                }
                break;
            }
        } else {
            switch (cmp.repr ()) {
            case R::REAL:
                if (T(val) <= cmp.real ())
                    throw json::schema_error ("minimum");
                break;

            case R::SINT:
                if (cmp.sint () >= json::tree::number::sint_t(std::numeric_limits<T>::min ()) &&
                    val <= T(cmp.sint ()))
                {
                    throw json::schema_error ("minimum");
                }
                break;

            case R::UINT:
                if (cmp.uint () >= json::tree::number::uint_t(std::numeric_limits<T>::min ()) &&
                    val <= T(cmp.uint ()))
                {
                    throw json::schema_error ("minimum");
                }
                break;
            }
        }
    } else {
        if (exclusiveMin != schema.cend ())
            throw json::schema_error ("exclusiveMin");
    }

}


//-----------------------------------------------------------------------------
static void
validate (json::tree::number &node,
          const json::tree::object &schema)
{
    using N = json::tree::number;
    using R = N::repr_t;

    switch (node.repr ()) {
    case R::REAL: validate_number<N::real_t> (node.real (), schema); break;
    case R::SINT: validate_number<N::sint_t> (node.sint (), schema); break;
    case R::UINT: validate_number<N::uint_t> (node.uint (), schema); break;
    }
}


//-----------------------------------------------------------------------------
static void
validate (json::tree::boolean&,
          const json::tree::object&)
{ ; }


//-----------------------------------------------------------------------------
static void
validate (json::tree::null&,
          const json::tree::object&)
{ ; }


//-----------------------------------------------------------------------------
static std::string
to_string (json::tree::type_t t)
{
    switch (t) {
        case json::tree::OBJECT:    return "object";
        case json::tree::ARRAY:     return "array";
        case json::tree::STRING:    return "string";
        case json::tree::NUMBER:    return "number";
        case json::tree::BOOLEAN:   return "boolean";
        case json::tree::NONE:      return "null";
    }

    unreachable ();
}


//-----------------------------------------------------------------------------
static bool
is_type_valid (const json::tree::node &node, const std::string &type)
{
    if (type == "integer")  return node.is_integer ();
    if (type == "number")   return node.is_number ();
    if (type == "string")   return node.is_string ();
    if (type == "object")   return node.is_object ();
    if (type == "array")    return node.is_array ();
    if (type == "boolean")  return node.is_boolean ();
    if (type == "null")     return node.is_null ();

    return false;
}


//-----------------------------------------------------------------------------
static void
validate (json::tree::node &node,
          const json::tree::object &schema)
{
    // check the value is in the prescribed list
    auto enumPos = schema.find ("enum");
    if (enumPos != schema.cend ()) {
        auto pos = std::find (enumPos->second->as_array ().cbegin (),
                              enumPos->second->as_array ().cend (),
                              node);
        if (pos == enumPos->second->as_array ().cend ())
            throw json::schema_error ("enum");
    }

    // check the value is the correct type
    auto type = schema.find ("type");
    if (type != schema.cend ()) {
        // check against a single named type
        if (type->second->is_string ()) {
            if (!is_type_valid (node, type->second->as_string ()))
                throw json::schema_error ("type");
        // check against an array of types
        } else if (type->second->is_array ()) {
            auto pos = std::find_if (type->second->as_array ().begin (),
                                     type->second->as_array ().end (),
                                     [&] (const auto &i) { return i.as_string () == to_string (node.type ()); });
            if (pos == type->second->as_array ().end ())
                throw json::schema_error ("type");
        } else
            throw json::schema_error ("type");
    }

    auto allOf = schema.find ("allOf");
    if (allOf != schema.cend ()) {
        for (const auto &i: allOf->second->as_array ())
            validate (node, i.as_object ());
    }

    auto anyOf = schema.find ("anyOf");
    if (anyOf != schema.cend ()) {
        bool success = false;
        for (const auto &i: anyOf->second->as_array ()) {
            try {
                validate (node, i.as_object ());
                success = true;
                break;
            } catch (const json::schema_error&)
            { continue; }
        }

        if (!success)
            throw json::schema_error ("anyOf");
    }

    auto oneOf = schema.find ("oneOf");
    if (oneOf != schema.cend ()) {
        unsigned count = 0;

        for (const auto &i: oneOf->second->as_array ()) {
            try {
                validate (node, i.as_object ());
                count++;
            } catch (const json::schema_error&)
            { ; }

            if (count > 1)
                throw json::schema_error ("oneOf");
        }

        if (count != 1)
            throw json::schema_error ("oneOf");
    }

    auto notSchema = schema.find ("not");
    if (notSchema != schema.cend ()) {
        for (const auto &i: notSchema->second->as_array ()) {
            bool valid = false;
            try {
                validate (node, i.as_object ());
                valid = true;
            } catch (const json::schema_error&)
            { ; }

            if (valid)
                throw json::schema_error ("not");
        }
    }

    switch (node.type ()) {
        case json::tree::OBJECT:    validate (node.as_object (),     schema); return;
        case json::tree::ARRAY:     validate (node.as_array (),      schema); return;
        case json::tree::STRING:    validate (node.as_string (),     schema); return;
        case json::tree::NUMBER:    validate (node.as_number (),     schema); return;
        case json::tree::BOOLEAN:   validate (node.as_boolean (),    schema); return;
        case json::tree::NONE:      validate (node.as_null (),       schema); return;
    }

    unreachable ();
}


//-----------------------------------------------------------------------------
void
json::schema::validate (json::tree::node &data,
                        const json::tree::object &schema)
{
    auto title = schema.find ("title");
    if (title != schema.cend ())
        if (!title->second->is_string ())
            throw json::schema_error ("title");

    auto description = schema.find ("description");
    if (description != schema.cend ())
        if (!description->second->is_string ())
            throw json::schema_error ("description");

    return ::validate (data, schema.as_object ());
}


//-----------------------------------------------------------------------------
void
json::schema::validate (json::tree::node &data,
                        const std::experimental::filesystem::path &schema_path)
{
    const util::mapped_file schema_data (schema_path);
    auto schema_object = json::tree::parse (util::view(schema_data).cast<const char*> ());
    validate (data, schema_object->as_object ());
}


///////////////////////////////////////////////////////////////////////////////
#include "constraint/except.hpp"
#include "constraint/base.hpp"

#include "../io.hpp"
#include "../view.hpp"

#include <map>

json::schema::validator::validator(std::experimental::filesystem::path const &path):
    validator (*json::tree::parse (path))
{ ; }


json::schema::validator::validator (json::tree::node const &definition):
    m_base (definition)
{ ; }


bool
json::schema::validator::validate (json::tree::node &data) const
{
    std::vector<util::json::schema::constraint::failure> res;
    m_base.validate (std::back_inserter(res), data);
    return res.empty ();
}