1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-04 09:42:40 +02:00
vcmi/lib/json/JsonValidator.cpp
2024-05-15 17:05:17 +00:00

670 lines
21 KiB
C++

/*
* JsonValidator.cpp, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#include "StdInc.h"
#include "JsonValidator.h"
#include "JsonUtils.h"
#include "../VCMI_Lib.h"
#include "../filesystem/Filesystem.h"
#include "../modding/ModScope.h"
#include "../modding/CModHandler.h"
#include "../ScopeGuard.h"
VCMI_LIB_NAMESPACE_BEGIN
static std::string emptyCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
// check is not needed - e.g. incorporated into another check
return "";
}
static std::string notImplementedCheck(JsonValidator & validator,
const JsonNode & baseSchema,
const JsonNode & schema,
const JsonNode & data)
{
return "Not implemented entry in schema";
}
static std::string schemaListCheck(JsonValidator & validator,
const JsonNode & baseSchema,
const JsonNode & schema,
const JsonNode & data,
const std::string & errorMsg,
const std::function<bool(size_t)> & isValid)
{
std::string errors = "<tested schemas>\n";
size_t result = 0;
for(const auto & schemaEntry : schema.Vector())
{
std::string error = validator.check(schemaEntry, data);
if (error.empty())
{
result++;
}
else
{
errors += error;
errors += "<end of schema>\n";
}
}
if (isValid(result))
return "";
else
return validator.makeErrorMessage(errorMsg) + errors;
}
static std::string allOfCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
return schemaListCheck(validator, baseSchema, schema, data, "Failed to pass all schemas", [&schema](size_t count)
{
return count == schema.Vector().size();
});
}
static std::string anyOfCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
return schemaListCheck(validator, baseSchema, schema, data, "Failed to pass any schema", [](size_t count)
{
return count > 0;
});
}
static std::string oneOfCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
return schemaListCheck(validator, baseSchema, schema, data, "Failed to pass exactly one schema", [](size_t count)
{
return count == 1;
});
}
static std::string notCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (validator.check(schema, data).empty())
return validator.makeErrorMessage("Successful validation against negative check");
return "";
}
static std::string enumCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
for(const auto & enumEntry : schema.Vector())
{
if (data == enumEntry)
return "";
}
return validator.makeErrorMessage("Key must have one of predefined values");
}
static std::string constCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (data == schema)
return "";
return validator.makeErrorMessage("Key must have have constant value");
}
static std::string typeCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
static const std::unordered_map<std::string, JsonNode::JsonType> stringToType =
{
{"null", JsonNode::JsonType::DATA_NULL},
{"boolean", JsonNode::JsonType::DATA_BOOL},
{"number", JsonNode::JsonType::DATA_FLOAT},
{"integer", JsonNode::JsonType::DATA_INTEGER},
{"string", JsonNode::JsonType::DATA_STRING},
{"array", JsonNode::JsonType::DATA_VECTOR},
{"object", JsonNode::JsonType::DATA_STRUCT}
};
const auto & typeName = schema.String();
auto it = stringToType.find(typeName);
if(it == stringToType.end())
{
return validator.makeErrorMessage("Unknown type in schema:" + typeName);
}
JsonNode::JsonType type = it->second;
// for "number" type both float and integer are allowed
if(type == JsonNode::JsonType::DATA_FLOAT && data.isNumber())
return "";
if(type != data.getType() && data.getType() != JsonNode::JsonType::DATA_NULL)
return validator.makeErrorMessage("Type mismatch! Expected " + schema.String());
return "";
}
static std::string refCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
std::string URI = schema.String();
//node must be validated using schema pointed by this reference and not by data here
//Local reference. Turn it into more easy to handle remote ref
if (boost::algorithm::starts_with(URI, "#"))
{
const std::string name = validator.usedSchemas.back();
const std::string nameClean = name.substr(0, name.find('#'));
URI = nameClean + URI;
}
return validator.check(URI, data);
}
static std::string formatCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
auto formats = validator.getKnownFormats();
std::string errors;
auto checker = formats.find(schema.String());
if (checker != formats.end())
{
if (data.isString())
{
std::string result = checker->second(data);
if (!result.empty())
errors += validator.makeErrorMessage(result);
}
else
{
errors += validator.makeErrorMessage("Format value must be string: " + schema.String());
}
}
else
errors += validator.makeErrorMessage("Unsupported format type: " + schema.String());
return errors;
}
static std::string maxLengthCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (data.String().size() > schema.Float())
return validator.makeErrorMessage((boost::format("String is longer than %d symbols") % schema.Float()).str());
return "";
}
static std::string minLengthCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (data.String().size() < schema.Float())
return validator.makeErrorMessage((boost::format("String is shorter than %d symbols") % schema.Float()).str());
return "";
}
static std::string maximumCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (data.Float() > schema.Float())
return validator.makeErrorMessage((boost::format("Value is bigger than %d") % schema.Float()).str());
return "";
}
static std::string minimumCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (data.Float() < schema.Float())
return validator.makeErrorMessage((boost::format("Value is smaller than %d") % schema.Float()).str());
return "";
}
static std::string exclusiveMaximumCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (data.Float() >= schema.Float())
return validator.makeErrorMessage((boost::format("Value is bigger than %d") % schema.Float()).str());
return "";
}
static std::string exclusiveMinimumCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (data.Float() <= schema.Float())
return validator.makeErrorMessage((boost::format("Value is smaller than %d") % schema.Float()).str());
return "";
}
static std::string multipleOfCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
double result = data.Integer() / schema.Integer();
if (!vstd::isAlmostEqual(floor(result), result))
return validator.makeErrorMessage((boost::format("Value is not divisible by %d") % schema.Float()).str());
return "";
}
static std::string itemEntryCheck(JsonValidator & validator, const JsonVector & items, const JsonNode & schema, size_t index)
{
validator.currentPath.emplace_back();
validator.currentPath.back().Float() = static_cast<double>(index);
auto onExit = vstd::makeScopeGuard([&validator]()
{
validator.currentPath.pop_back();
});
if (!schema.isNull())
return validator.check(schema, items[index]);
return "";
}
static std::string itemsCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
std::string errors;
for (size_t i=0; i<data.Vector().size(); i++)
{
if (schema.getType() == JsonNode::JsonType::DATA_VECTOR)
{
if (schema.Vector().size() > i)
errors += itemEntryCheck(validator, data.Vector(), schema.Vector()[i], i);
}
else
{
errors += itemEntryCheck(validator, data.Vector(), schema, i);
}
}
return errors;
}
static std::string additionalItemsCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
std::string errors;
// "items" is struct or empty (defaults to empty struct) - validation always successful
const JsonNode & items = baseSchema["items"];
if (items.getType() != JsonNode::JsonType::DATA_VECTOR)
return "";
for (size_t i=items.Vector().size(); i<data.Vector().size(); i++)
{
if (schema.getType() == JsonNode::JsonType::DATA_STRUCT)
errors += itemEntryCheck(validator, data.Vector(), schema, i);
else if(!schema.isNull() && !schema.Bool())
errors += validator.makeErrorMessage("Unknown entry found");
}
return errors;
}
static std::string minItemsCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (data.Vector().size() < schema.Float())
return validator.makeErrorMessage((boost::format("Length is smaller than %d") % schema.Float()).str());
return "";
}
static std::string maxItemsCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (data.Vector().size() > schema.Float())
return validator.makeErrorMessage((boost::format("Length is bigger than %d") % schema.Float()).str());
return "";
}
static std::string uniqueItemsCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (schema.Bool())
{
for (auto itA = schema.Vector().begin(); itA != schema.Vector().end(); itA++)
{
auto itB = itA;
while (++itB != schema.Vector().end())
{
if (*itA == *itB)
return validator.makeErrorMessage("List must consist from unique items");
}
}
}
return "";
}
static std::string maxPropertiesCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (data.Struct().size() > schema.Float())
return validator.makeErrorMessage((boost::format("Number of entries is bigger than %d") % schema.Float()).str());
return "";
}
static std::string minPropertiesCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
if (data.Struct().size() < schema.Float())
return validator.makeErrorMessage((boost::format("Number of entries is less than %d") % schema.Float()).str());
return "";
}
static std::string uniquePropertiesCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
for (auto itA = data.Struct().begin(); itA != data.Struct().end(); itA++)
{
auto itB = itA;
while (++itB != data.Struct().end())
{
if (itA->second == itB->second)
return validator.makeErrorMessage("List must consist from unique items");
}
}
return "";
}
static std::string requiredCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
std::string errors;
for(const auto & required : schema.Vector())
{
if (data[required.String()].isNull())
errors += validator.makeErrorMessage("Required entry " + required.String() + " is missing");
}
return errors;
}
static std::string dependenciesCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
std::string errors;
for(const auto & deps : schema.Struct())
{
if (!data[deps.first].isNull())
{
if (deps.second.getType() == JsonNode::JsonType::DATA_VECTOR)
{
JsonVector depList = deps.second.Vector();
for(auto & depEntry : depList)
{
if (data[depEntry.String()].isNull())
errors += validator.makeErrorMessage("Property " + depEntry.String() + " required for " + deps.first + " is missing");
}
}
else
{
if (!validator.check(deps.second, data).empty())
errors += validator.makeErrorMessage("Requirements for " + deps.first + " are not fulfilled");
}
}
}
return errors;
}
static std::string propertyEntryCheck(JsonValidator & validator, const JsonNode &node, const JsonNode & schema, const std::string & nodeName)
{
validator.currentPath.emplace_back();
validator.currentPath.back().String() = nodeName;
auto onExit = vstd::makeScopeGuard([&validator]()
{
validator.currentPath.pop_back();
});
// there is schema specifically for this item
if (!schema.isNull())
return validator.check(schema, node);
return "";
}
static std::string propertiesCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
std::string errors;
for(const auto & entry : data.Struct())
errors += propertyEntryCheck(validator, entry.second, schema[entry.first], entry.first);
return errors;
}
static std::string additionalPropertiesCheck(JsonValidator & validator, const JsonNode & baseSchema, const JsonNode & schema, const JsonNode & data)
{
std::string errors;
for(const auto & entry : data.Struct())
{
if (baseSchema["properties"].Struct().count(entry.first) == 0)
{
// try generic additionalItems schema
if (schema.getType() == JsonNode::JsonType::DATA_STRUCT)
errors += propertyEntryCheck(validator, entry.second, schema, entry.first);
// or, additionalItems field can be bool which indicates if such items are allowed
else if(!schema.isNull() && !schema.Bool()) // present and set to false - error
errors += validator.makeErrorMessage("Unknown entry found: " + entry.first);
}
}
return errors;
}
static bool testFilePresence(const std::string & scope, const ResourcePath & resource)
{
#ifndef ENABLE_MINIMAL_LIB
std::set<std::string> allowedScopes;
if(scope != ModScope::scopeBuiltin() && !scope.empty()) // all real mods may have dependencies
{
//NOTE: recursive dependencies are not allowed at the moment - update code if this changes
bool found = true;
allowedScopes = VLC->modh->getModDependencies(scope, found);
if(!found)
return false;
allowedScopes.insert(ModScope::scopeBuiltin()); // all mods can use H3 files
}
allowedScopes.insert(scope); // mods can use their own files
for(const auto & entry : allowedScopes)
{
if (CResourceHandler::get(entry)->existsResource(resource))
return true;
}
#endif
return false;
}
#define TEST_FILE(scope, prefix, file, type) \
if (testFilePresence(scope, ResourcePath(prefix + file, type))) \
return ""
static std::string testAnimation(const std::string & path, const std::string & scope)
{
TEST_FILE(scope, "Sprites/", path, EResType::ANIMATION);
TEST_FILE(scope, "Sprites/", path, EResType::JSON);
return "Animation file \"" + path + "\" was not found";
}
static std::string textFile(const JsonNode & node)
{
TEST_FILE(node.getModScope(), "", node.String(), EResType::JSON);
return "Text file \"" + node.String() + "\" was not found";
}
static std::string musicFile(const JsonNode & node)
{
TEST_FILE(node.getModScope(), "Music/", node.String(), EResType::SOUND);
TEST_FILE(node.getModScope(), "", node.String(), EResType::SOUND);
return "Music file \"" + node.String() + "\" was not found";
}
static std::string soundFile(const JsonNode & node)
{
TEST_FILE(node.getModScope(), "Sounds/", node.String(), EResType::SOUND);
return "Sound file \"" + node.String() + "\" was not found";
}
static std::string animationFile(const JsonNode & node)
{
return testAnimation(node.String(), node.getModScope());
}
static std::string imageFile(const JsonNode & node)
{
TEST_FILE(node.getModScope(), "Data/", node.String(), EResType::IMAGE);
TEST_FILE(node.getModScope(), "Sprites/", node.String(), EResType::IMAGE);
if (node.String().find(':') != std::string::npos)
return testAnimation(node.String().substr(0, node.String().find(':')), node.getModScope());
return "Image file \"" + node.String() + "\" was not found";
}
static std::string videoFile(const JsonNode & node)
{
TEST_FILE(node.getModScope(), "Video/", node.String(), EResType::VIDEO);
TEST_FILE(node.getModScope(), "Video/", node.String(), EResType::VIDEO_LOW_QUALITY);
return "Video file \"" + node.String() + "\" was not found";
}
#undef TEST_FILE
JsonValidator::TValidatorMap createCommonFields()
{
JsonValidator::TValidatorMap ret;
ret["format"] = formatCheck;
ret["allOf"] = allOfCheck;
ret["anyOf"] = anyOfCheck;
ret["oneOf"] = oneOfCheck;
ret["enum"] = enumCheck;
ret["const"] = constCheck;
ret["type"] = typeCheck;
ret["not"] = notCheck;
ret["$ref"] = refCheck;
// fields that don't need implementation
ret["title"] = emptyCheck;
ret["$schema"] = emptyCheck;
ret["default"] = emptyCheck;
ret["defaultIOS"] = emptyCheck;
ret["defaultAndroid"] = emptyCheck;
ret["defaultWindows"] = emptyCheck;
ret["description"] = emptyCheck;
ret["definitions"] = emptyCheck;
// Not implemented
ret["propertyNames"] = notImplementedCheck;
ret["contains"] = notImplementedCheck;
ret["examples"] = notImplementedCheck;
return ret;
}
JsonValidator::TValidatorMap createStringFields()
{
JsonValidator::TValidatorMap ret = createCommonFields();
ret["maxLength"] = maxLengthCheck;
ret["minLength"] = minLengthCheck;
ret["pattern"] = notImplementedCheck;
return ret;
}
JsonValidator::TValidatorMap createNumberFields()
{
JsonValidator::TValidatorMap ret = createCommonFields();
ret["maximum"] = maximumCheck;
ret["minimum"] = minimumCheck;
ret["multipleOf"] = multipleOfCheck;
ret["exclusiveMaximum"] = exclusiveMaximumCheck;
ret["exclusiveMinimum"] = exclusiveMinimumCheck;
return ret;
}
JsonValidator::TValidatorMap createVectorFields()
{
JsonValidator::TValidatorMap ret = createCommonFields();
ret["items"] = itemsCheck;
ret["minItems"] = minItemsCheck;
ret["maxItems"] = maxItemsCheck;
ret["uniqueItems"] = uniqueItemsCheck;
ret["additionalItems"] = additionalItemsCheck;
return ret;
}
JsonValidator::TValidatorMap createStructFields()
{
JsonValidator::TValidatorMap ret = createCommonFields();
ret["additionalProperties"] = additionalPropertiesCheck;
ret["uniqueProperties"] = uniquePropertiesCheck;
ret["maxProperties"] = maxPropertiesCheck;
ret["minProperties"] = minPropertiesCheck;
ret["dependencies"] = dependenciesCheck;
ret["properties"] = propertiesCheck;
ret["required"] = requiredCheck;
ret["patternProperties"] = notImplementedCheck;
return ret;
}
JsonValidator::TFormatMap createFormatMap()
{
JsonValidator::TFormatMap ret;
ret["textFile"] = textFile;
ret["musicFile"] = musicFile;
ret["soundFile"] = soundFile;
ret["animationFile"] = animationFile;
ret["imageFile"] = imageFile;
ret["videoFile"] = videoFile;
//TODO:
// uri-reference
// uri-template
// json-pointer
return ret;
}
std::string JsonValidator::makeErrorMessage(const std::string &message)
{
std::string errors;
errors += "At ";
if (!currentPath.empty())
{
for(const JsonNode &path : currentPath)
{
errors += "/";
if (path.getType() == JsonNode::JsonType::DATA_STRING)
errors += path.String();
else
errors += std::to_string(static_cast<unsigned>(path.Float()));
}
}
else
errors += "<root>";
errors += "\n\t Error: " + message + "\n";
return errors;
}
std::string JsonValidator::check(const std::string & schemaName, const JsonNode & data)
{
usedSchemas.push_back(schemaName);
auto onscopeExit = vstd::makeScopeGuard([this]()
{
usedSchemas.pop_back();
});
return check(JsonUtils::getSchema(schemaName), data);
}
std::string JsonValidator::check(const JsonNode & schema, const JsonNode & data)
{
const TValidatorMap & knownFields = getKnownFieldsFor(data.getType());
std::string errors;
for(const auto & entry : schema.Struct())
{
auto checker = knownFields.find(entry.first);
if (checker != knownFields.end())
errors += checker->second(*this, schema, entry.second, data);
}
return errors;
}
const JsonValidator::TValidatorMap & JsonValidator::getKnownFieldsFor(JsonNode::JsonType type)
{
static const TValidatorMap commonFields = createCommonFields();
static const TValidatorMap numberFields = createNumberFields();
static const TValidatorMap stringFields = createStringFields();
static const TValidatorMap vectorFields = createVectorFields();
static const TValidatorMap structFields = createStructFields();
switch (type)
{
case JsonNode::JsonType::DATA_FLOAT:
case JsonNode::JsonType::DATA_INTEGER:
return numberFields;
case JsonNode::JsonType::DATA_STRING: return stringFields;
case JsonNode::JsonType::DATA_VECTOR: return vectorFields;
case JsonNode::JsonType::DATA_STRUCT: return structFields;
default: return commonFields;
}
}
const JsonValidator::TFormatMap & JsonValidator::getKnownFormats()
{
static const TFormatMap knownFormats = createFormatMap();
return knownFormats;
}
VCMI_LIB_NAMESPACE_END