953 lines
29 KiB
JavaScript
953 lines
29 KiB
JavaScript
/**
|
|
* json-schema-draft-01 Environment
|
|
*
|
|
* @fileOverview Implementation of the first revision of the JSON Schema specification draft.
|
|
* @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
|
|
* @version 1.7.1
|
|
* @see http://github.com/garycourt/JSV
|
|
*/
|
|
|
|
/*
|
|
* Copyright 2010 Gary Court. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification, are
|
|
* permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice, this list of
|
|
* conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
|
* of conditions and the following disclaimer in the documentation and/or other materials
|
|
* provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY GARY COURT ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARY COURT OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* The views and conclusions contained in the software and documentation are those of the
|
|
* authors and should not be interpreted as representing official policies, either expressed
|
|
* or implied, of Gary Court or the JSON Schema specification.
|
|
*/
|
|
|
|
/*jslint white: true, sub: true, onevar: true, undef: true, eqeqeq: true, newcap: true, immed: true, indent: 4 */
|
|
/*global require */
|
|
|
|
(function () {
|
|
var O = {},
|
|
JSV = require('./jsv').JSV,
|
|
ENVIRONMENT,
|
|
TYPE_VALIDATORS,
|
|
SCHEMA,
|
|
HYPERSCHEMA,
|
|
LINKS;
|
|
|
|
TYPE_VALIDATORS = {
|
|
"string" : function (instance, report) {
|
|
return instance.getType() === "string";
|
|
},
|
|
|
|
"number" : function (instance, report) {
|
|
return instance.getType() === "number";
|
|
},
|
|
|
|
"integer" : function (instance, report) {
|
|
return instance.getType() === "number" && instance.getValue() % 1 === 0;
|
|
},
|
|
|
|
"boolean" : function (instance, report) {
|
|
return instance.getType() === "boolean";
|
|
},
|
|
|
|
"object" : function (instance, report) {
|
|
return instance.getType() === "object";
|
|
},
|
|
|
|
"array" : function (instance, report) {
|
|
return instance.getType() === "array";
|
|
},
|
|
|
|
"null" : function (instance, report) {
|
|
return instance.getType() === "null";
|
|
},
|
|
|
|
"any" : function (instance, report) {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
ENVIRONMENT = new JSV.Environment();
|
|
ENVIRONMENT.setOption("defaultFragmentDelimiter", ".");
|
|
ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/schema#"); //updated later
|
|
|
|
SCHEMA = ENVIRONMENT.createSchema({
|
|
"$schema" : "http://json-schema.org/hyper-schema#",
|
|
"id" : "http://json-schema.org/schema#",
|
|
"type" : "object",
|
|
|
|
"properties" : {
|
|
"type" : {
|
|
"type" : ["string", "array"],
|
|
"items" : {
|
|
"type" : ["string", {"$ref" : "#"}]
|
|
},
|
|
"optional" : true,
|
|
"uniqueItems" : true,
|
|
"default" : "any",
|
|
|
|
"parser" : function (instance, self) {
|
|
var parser;
|
|
|
|
if (instance.getType() === "string") {
|
|
return instance.getValue();
|
|
} else if (instance.getType() === "object") {
|
|
return instance.getEnvironment().createSchema(
|
|
instance,
|
|
self.getEnvironment().findSchema(self.resolveURI("#"))
|
|
);
|
|
} else if (instance.getType() === "array") {
|
|
parser = self.getValueOfProperty("parser");
|
|
return JSV.mapArray(instance.getProperties(), function (prop) {
|
|
return parser(prop, self);
|
|
});
|
|
}
|
|
//else
|
|
return "any";
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var requiredTypes = JSV.toArray(schema.getAttribute("type")),
|
|
x, xl, type, subreport, typeValidators;
|
|
|
|
//for instances that are required to be a certain type
|
|
if (instance.getType() !== "undefined" && requiredTypes && requiredTypes.length) {
|
|
typeValidators = self.getValueOfProperty("typeValidators") || {};
|
|
|
|
//ensure that type matches for at least one of the required types
|
|
for (x = 0, xl = requiredTypes.length; x < xl; ++x) {
|
|
type = requiredTypes[x];
|
|
if (JSV.isJSONSchema(type)) {
|
|
subreport = JSV.createObject(report);
|
|
subreport.errors = [];
|
|
subreport.validated = JSV.clone(report.validated);
|
|
if (type.validate(instance, subreport, parent, parentSchema, name).errors.length === 0) {
|
|
return true; //instance matches this schema
|
|
}
|
|
} else {
|
|
if (typeValidators[type] !== O[type] && typeof typeValidators[type] === "function") {
|
|
if (typeValidators[type](instance, report)) {
|
|
return true; //type is valid
|
|
}
|
|
} else {
|
|
return true; //unknown types are assumed valid
|
|
}
|
|
}
|
|
}
|
|
|
|
//if we get to this point, type is invalid
|
|
report.addError(instance, schema, "type", "Instance is not a required type", requiredTypes);
|
|
return false;
|
|
}
|
|
//else, anything is allowed if no type is specified
|
|
return true;
|
|
},
|
|
|
|
"typeValidators" : TYPE_VALIDATORS
|
|
},
|
|
|
|
"properties" : {
|
|
"type" : "object",
|
|
"additionalProperties" : {"$ref" : "#"},
|
|
"optional" : true,
|
|
"default" : {},
|
|
|
|
"parser" : function (instance, self, arg) {
|
|
var env = instance.getEnvironment(),
|
|
selfEnv = self.getEnvironment();
|
|
if (instance.getType() === "object") {
|
|
if (arg) {
|
|
return env.createSchema(instance.getProperty(arg), selfEnv.findSchema(self.resolveURI("#")));
|
|
} else {
|
|
return JSV.mapObject(instance.getProperties(), function (instance) {
|
|
return env.createSchema(instance, selfEnv.findSchema(self.resolveURI("#")));
|
|
});
|
|
}
|
|
}
|
|
//else
|
|
return {};
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var propertySchemas, key;
|
|
//this attribute is for object type instances only
|
|
if (instance.getType() === "object") {
|
|
//for each property defined in the schema
|
|
propertySchemas = schema.getAttribute("properties");
|
|
for (key in propertySchemas) {
|
|
if (propertySchemas[key] !== O[key] && propertySchemas[key]) {
|
|
//ensure that instance property is valid
|
|
propertySchemas[key].validate(instance.getProperty(key), report, instance, schema, key);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"items" : {
|
|
"type" : [{"$ref" : "#"}, "array"],
|
|
"items" : {"$ref" : "#"},
|
|
"optional" : true,
|
|
"default" : {},
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "object") {
|
|
return instance.getEnvironment().createSchema(instance, self.getEnvironment().findSchema(self.resolveURI("#")));
|
|
} else if (instance.getType() === "array") {
|
|
return JSV.mapArray(instance.getProperties(), function (instance) {
|
|
return instance.getEnvironment().createSchema(instance, self.getEnvironment().findSchema(self.resolveURI("#")));
|
|
});
|
|
}
|
|
//else
|
|
return instance.getEnvironment().createEmptySchema();
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var properties, items, x, xl, itemSchema, additionalProperties;
|
|
|
|
if (instance.getType() === "array") {
|
|
properties = instance.getProperties();
|
|
items = schema.getAttribute("items");
|
|
additionalProperties = schema.getAttribute("additionalProperties");
|
|
|
|
if (JSV.typeOf(items) === "array") {
|
|
for (x = 0, xl = properties.length; x < xl; ++x) {
|
|
itemSchema = items[x] || additionalProperties;
|
|
if (itemSchema !== false) {
|
|
itemSchema.validate(properties[x], report, instance, schema, x);
|
|
} else {
|
|
report.addError(instance, schema, "additionalProperties", "Additional items are not allowed", itemSchema);
|
|
}
|
|
}
|
|
} else {
|
|
itemSchema = items || additionalProperties;
|
|
for (x = 0, xl = properties.length; x < xl; ++x) {
|
|
itemSchema.validate(properties[x], report, instance, schema, x);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"optional" : {
|
|
"type" : "boolean",
|
|
"optional" : true,
|
|
"default" : false,
|
|
|
|
"parser" : function (instance, self) {
|
|
return !!instance.getValue();
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
if (instance.getType() === "undefined" && !schema.getAttribute("optional")) {
|
|
report.addError(instance, schema, "optional", "Property is required", false);
|
|
}
|
|
},
|
|
|
|
"validationRequired" : true
|
|
},
|
|
|
|
"additionalProperties" : {
|
|
"type" : [{"$ref" : "#"}, "boolean"],
|
|
"optional" : true,
|
|
"default" : {},
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "object") {
|
|
return instance.getEnvironment().createSchema(instance, self.getEnvironment().findSchema(self.resolveURI("#")));
|
|
} else if (instance.getType() === "boolean" && instance.getValue() === false) {
|
|
return false;
|
|
}
|
|
//else
|
|
return instance.getEnvironment().createEmptySchema();
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var additionalProperties, propertySchemas, properties, key;
|
|
//we only need to check against object types as arrays do their own checking on this property
|
|
if (instance.getType() === "object") {
|
|
additionalProperties = schema.getAttribute("additionalProperties");
|
|
propertySchemas = schema.getAttribute("properties") || {};
|
|
properties = instance.getProperties();
|
|
for (key in properties) {
|
|
if (properties[key] !== O[key] && properties[key] && !propertySchemas[key]) {
|
|
if (JSV.isJSONSchema(additionalProperties)) {
|
|
additionalProperties.validate(properties[key], report, instance, schema, key);
|
|
} else if (additionalProperties === false) {
|
|
report.addError(instance, schema, "additionalProperties", "Additional properties are not allowed", additionalProperties);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"requires" : {
|
|
"type" : ["string", {"$ref" : "#"}],
|
|
"optional" : true,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "string") {
|
|
return instance.getValue();
|
|
} else if (instance.getType() === "object") {
|
|
return instance.getEnvironment().createSchema(instance, self.getEnvironment().findSchema(self.resolveURI("#")));
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var requires;
|
|
if (instance.getType() !== "undefined" && parent && parent.getType() !== "undefined") {
|
|
requires = schema.getAttribute("requires");
|
|
if (typeof requires === "string") {
|
|
if (parent.getProperty(requires).getType() === "undefined") {
|
|
report.addError(instance, schema, "requires", 'Property requires sibling property "' + requires + '"', requires);
|
|
}
|
|
} else if (JSV.isJSONSchema(requires)) {
|
|
requires.validate(parent, report); //WATCH: A "requires" schema does not support the "requires" attribute
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"minimum" : {
|
|
"type" : "number",
|
|
"optional" : true,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "number") {
|
|
return instance.getValue();
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var minimum, minimumCanEqual;
|
|
if (instance.getType() === "number") {
|
|
minimum = schema.getAttribute("minimum");
|
|
minimumCanEqual = schema.getAttribute("minimumCanEqual");
|
|
if (typeof minimum === "number" && (instance.getValue() < minimum || (minimumCanEqual === false && instance.getValue() === minimum))) {
|
|
report.addError(instance, schema, "minimum", "Number is less than the required minimum value", minimum);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"maximum" : {
|
|
"type" : "number",
|
|
"optional" : true,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "number") {
|
|
return instance.getValue();
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var maximum, maximumCanEqual;
|
|
if (instance.getType() === "number") {
|
|
maximum = schema.getAttribute("maximum");
|
|
maximumCanEqual = schema.getAttribute("maximumCanEqual");
|
|
if (typeof maximum === "number" && (instance.getValue() > maximum || (maximumCanEqual === false && instance.getValue() === maximum))) {
|
|
report.addError(instance, schema, "maximum", "Number is greater than the required maximum value", maximum);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"minimumCanEqual" : {
|
|
"type" : "boolean",
|
|
"optional" : true,
|
|
"requires" : "minimum",
|
|
"default" : true,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "boolean") {
|
|
return instance.getValue();
|
|
}
|
|
//else
|
|
return true;
|
|
}
|
|
},
|
|
|
|
"maximumCanEqual" : {
|
|
"type" : "boolean",
|
|
"optional" : true,
|
|
"requires" : "maximum",
|
|
"default" : true,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "boolean") {
|
|
return instance.getValue();
|
|
}
|
|
//else
|
|
return true;
|
|
}
|
|
},
|
|
|
|
"minItems" : {
|
|
"type" : "integer",
|
|
"optional" : true,
|
|
"minimum" : 0,
|
|
"default" : 0,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "number") {
|
|
return instance.getValue();
|
|
}
|
|
//else
|
|
return 0;
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var minItems;
|
|
if (instance.getType() === "array") {
|
|
minItems = schema.getAttribute("minItems");
|
|
if (typeof minItems === "number" && instance.getProperties().length < minItems) {
|
|
report.addError(instance, schema, "minItems", "The number of items is less than the required minimum", minItems);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"maxItems" : {
|
|
"type" : "integer",
|
|
"optional" : true,
|
|
"minimum" : 0,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "number") {
|
|
return instance.getValue();
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var maxItems;
|
|
if (instance.getType() === "array") {
|
|
maxItems = schema.getAttribute("maxItems");
|
|
if (typeof maxItems === "number" && instance.getProperties().length > maxItems) {
|
|
report.addError(instance, schema, "maxItems", "The number of items is greater than the required maximum", maxItems);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"pattern" : {
|
|
"type" : "string",
|
|
"optional" : true,
|
|
"format" : "regex",
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "string") {
|
|
return instance.getValue();
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var pattern;
|
|
try {
|
|
pattern = new RegExp(schema.getAttribute("pattern"));
|
|
if (instance.getType() === "string" && pattern && !pattern.test(instance.getValue())) {
|
|
report.addError(instance, schema, "pattern", "String does not match pattern", pattern.toString());
|
|
}
|
|
} catch (e) {
|
|
report.addError(instance, schema, "pattern", "Invalid pattern", e);
|
|
}
|
|
}
|
|
},
|
|
|
|
"minLength" : {
|
|
"type" : "integer",
|
|
"optional" : true,
|
|
"minimum" : 0,
|
|
"default" : 0,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "number") {
|
|
return instance.getValue();
|
|
}
|
|
//else
|
|
return 0;
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var minLength;
|
|
if (instance.getType() === "string") {
|
|
minLength = schema.getAttribute("minLength");
|
|
if (typeof minLength === "number" && instance.getValue().length < minLength) {
|
|
report.addError(instance, schema, "minLength", "String is less than the required minimum length", minLength);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"maxLength" : {
|
|
"type" : "integer",
|
|
"optional" : true,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "number") {
|
|
return instance.getValue();
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var maxLength;
|
|
if (instance.getType() === "string") {
|
|
maxLength = schema.getAttribute("maxLength");
|
|
if (typeof maxLength === "number" && instance.getValue().length > maxLength) {
|
|
report.addError(instance, schema, "maxLength", "String is greater than the required maximum length", maxLength);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"enum" : {
|
|
"type" : "array",
|
|
"optional" : true,
|
|
"minItems" : 1,
|
|
"uniqueItems" : true,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "array") {
|
|
return instance.getValue();
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var enums, x, xl;
|
|
if (instance.getType() !== "undefined") {
|
|
enums = schema.getAttribute("enum");
|
|
if (enums) {
|
|
for (x = 0, xl = enums.length; x < xl; ++x) {
|
|
if (instance.equals(enums[x])) {
|
|
return true;
|
|
}
|
|
}
|
|
report.addError(instance, schema, "enum", "Instance is not one of the possible values", enums);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"title" : {
|
|
"type" : "string",
|
|
"optional" : true
|
|
},
|
|
|
|
"description" : {
|
|
"type" : "string",
|
|
"optional" : true
|
|
},
|
|
|
|
"format" : {
|
|
"type" : "string",
|
|
"optional" : true,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "string") {
|
|
return instance.getValue();
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var format, formatValidators;
|
|
if (instance.getType() === "string") {
|
|
format = schema.getAttribute("format");
|
|
formatValidators = self.getValueOfProperty("formatValidators");
|
|
if (typeof format === "string" && formatValidators[format] !== O[format] && typeof formatValidators[format] === "function" && !formatValidators[format].call(this, instance, report)) {
|
|
report.addError(instance, schema, "format", "String is not in the required format", format);
|
|
}
|
|
}
|
|
},
|
|
|
|
"formatValidators" : {}
|
|
},
|
|
|
|
"contentEncoding" : {
|
|
"type" : "string",
|
|
"optional" : true
|
|
},
|
|
|
|
"default" : {
|
|
"type" : "any",
|
|
"optional" : true
|
|
},
|
|
|
|
"maxDecimal" : {
|
|
"type" : "integer",
|
|
"optional" : true,
|
|
"minimum" : 0,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "number") {
|
|
return instance.getValue();
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var maxDecimal, decimals;
|
|
if (instance.getType() === "number") {
|
|
maxDecimal = schema.getAttribute("maxDecimal");
|
|
if (typeof maxDecimal === "number") {
|
|
decimals = instance.getValue().toString(10).split('.')[1];
|
|
if (decimals && decimals.length > maxDecimal) {
|
|
report.addError(instance, schema, "maxDecimal", "The number of decimal places is greater than the allowed maximum", maxDecimal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"disallow" : {
|
|
"type" : ["string", "array"],
|
|
"items" : {"type" : "string"},
|
|
"optional" : true,
|
|
"uniqueItems" : true,
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "string" || instance.getType() === "array") {
|
|
return instance.getValue();
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var disallowedTypes = JSV.toArray(schema.getAttribute("disallow")),
|
|
x, xl, key, typeValidators;
|
|
|
|
//for instances that are required to be a certain type
|
|
if (instance.getType() !== "undefined" && disallowedTypes && disallowedTypes.length) {
|
|
typeValidators = self.getValueOfProperty("typeValidators") || {};
|
|
|
|
//ensure that type matches for at least one of the required types
|
|
for (x = 0, xl = disallowedTypes.length; x < xl; ++x) {
|
|
key = disallowedTypes[x];
|
|
if (typeValidators[key] !== O[key] && typeof typeValidators[key] === "function") {
|
|
if (typeValidators[key](instance, report)) {
|
|
report.addError(instance, schema, "disallow", "Instance is a disallowed type", disallowedTypes);
|
|
return false;
|
|
}
|
|
}
|
|
/*
|
|
else {
|
|
report.addError(instance, schema, "disallow", "Instance may be a disallowed type", disallowedTypes);
|
|
return false;
|
|
}
|
|
*/
|
|
}
|
|
|
|
//if we get to this point, type is valid
|
|
return true;
|
|
}
|
|
//else, everything is allowed if no disallowed types are specified
|
|
return true;
|
|
},
|
|
|
|
"typeValidators" : TYPE_VALIDATORS
|
|
},
|
|
|
|
"extends" : {
|
|
"type" : [{"$ref" : "#"}, "array"],
|
|
"items" : {"$ref" : "#"},
|
|
"optional" : true,
|
|
"default" : {},
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "object") {
|
|
return instance.getEnvironment().createSchema(instance, self.getEnvironment().findSchema(self.resolveURI("#")));
|
|
} else if (instance.getType() === "array") {
|
|
return JSV.mapArray(instance.getProperties(), function (instance) {
|
|
return instance.getEnvironment().createSchema(instance, self.getEnvironment().findSchema(self.resolveURI("#")));
|
|
});
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var extensions = schema.getAttribute("extends"), x, xl;
|
|
if (extensions) {
|
|
if (JSV.isJSONSchema(extensions)) {
|
|
extensions.validate(instance, report, parent, parentSchema, name);
|
|
} else if (JSV.typeOf(extensions) === "array") {
|
|
for (x = 0, xl = extensions.length; x < xl; ++x) {
|
|
extensions[x].validate(instance, report, parent, parentSchema, name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"optional" : true,
|
|
"default" : {},
|
|
"fragmentResolution" : "dot-delimited",
|
|
|
|
"parser" : function (instance, self) {
|
|
if (instance.getType() === "object") {
|
|
return instance.getEnvironment().createSchema(instance, self);
|
|
}
|
|
},
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var propNames = schema.getPropertyNames(),
|
|
x, xl,
|
|
attributeSchemas = self.getAttribute("properties"),
|
|
validator;
|
|
|
|
for (x in attributeSchemas) {
|
|
if (attributeSchemas[x] !== O[x] && attributeSchemas[x].getValueOfProperty("validationRequired")) {
|
|
JSV.pushUnique(propNames, x);
|
|
}
|
|
}
|
|
|
|
for (x = 0, xl = propNames.length; x < xl; ++x) {
|
|
if (attributeSchemas[propNames[x]] !== O[propNames[x]]) {
|
|
validator = attributeSchemas[propNames[x]].getValueOfProperty("validator");
|
|
if (typeof validator === "function") {
|
|
validator(instance, schema, attributeSchemas[propNames[x]], report, parent, parentSchema, name);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"initializer" : function (instance) {
|
|
var link, extension, extended;
|
|
|
|
//if there is a link to a different schema, set reference
|
|
link = instance._schema.getLink("describedby", instance);
|
|
if (link && instance._schema._uri !== link) {
|
|
instance.setReference("describedby", link);
|
|
}
|
|
|
|
//if instance has a URI link to itself, update it's own URI
|
|
link = instance._schema.getLink("self", instance);
|
|
if (JSV.typeOf(link) === "string") {
|
|
instance._uri = JSV.formatURI(link);
|
|
}
|
|
|
|
//if there is a link to the full representation, set reference
|
|
link = instance._schema.getLink("full", instance);
|
|
if (link && instance._uri !== link) {
|
|
instance.setReference("full", link);
|
|
}
|
|
|
|
//extend schema
|
|
extension = instance.getAttribute("extends");
|
|
if (JSV.isJSONSchema(extension)) {
|
|
extended = JSV.inherits(extension, instance, true);
|
|
instance = instance._env.createSchema(extended, instance._schema, instance._uri);
|
|
}
|
|
|
|
return instance;
|
|
}
|
|
}, true, "http://json-schema.org/schema#");
|
|
|
|
HYPERSCHEMA = ENVIRONMENT.createSchema(JSV.inherits(SCHEMA, ENVIRONMENT.createSchema({
|
|
"$schema" : "http://json-schema.org/hyper-schema#",
|
|
"id" : "http://json-schema.org/hyper-schema#",
|
|
|
|
"properties" : {
|
|
"links" : {
|
|
"type" : "array",
|
|
"items" : {"$ref" : "links#"},
|
|
"optional" : true,
|
|
|
|
"parser" : function (instance, self, arg) {
|
|
var links,
|
|
linkSchemaURI = self.getValueOfProperty("items")["$ref"],
|
|
linkSchema = self.getEnvironment().findSchema(linkSchemaURI),
|
|
linkParser = linkSchema && linkSchema.getValueOfProperty("parser");
|
|
arg = JSV.toArray(arg);
|
|
|
|
if (typeof linkParser === "function") {
|
|
links = JSV.mapArray(instance.getProperties(), function (link) {
|
|
return linkParser(link, linkSchema);
|
|
});
|
|
} else {
|
|
links = JSV.toArray(instance.getValue());
|
|
}
|
|
|
|
if (arg[0]) {
|
|
links = JSV.filterArray(links, function (link) {
|
|
return link["rel"] === arg[0];
|
|
});
|
|
}
|
|
|
|
if (arg[1]) {
|
|
links = JSV.mapArray(links, function (link) {
|
|
var instance = arg[1],
|
|
href = link["href"];
|
|
href = href.replace(/\{(.+)\}/g, function (str, p1, offset, s) {
|
|
var value;
|
|
if (p1 === "-this") {
|
|
value = instance.getValue();
|
|
} else {
|
|
value = instance.getValueOfProperty(p1);
|
|
}
|
|
return value !== undefined ? String(value) : "";
|
|
});
|
|
return href ? JSV.formatURI(instance.resolveURI(href)) : href;
|
|
});
|
|
}
|
|
|
|
return links;
|
|
}
|
|
},
|
|
|
|
"fragmentResolution" : {
|
|
"type" : "string",
|
|
"optional" : true,
|
|
"default" : "dot-delimited"
|
|
},
|
|
|
|
"root" : {
|
|
"type" : "boolean",
|
|
"optional" : true,
|
|
"default" : false
|
|
},
|
|
|
|
"readonly" : {
|
|
"type" : "boolean",
|
|
"optional" : true,
|
|
"default" : false
|
|
},
|
|
|
|
"pathStart" : {
|
|
"type" : "string",
|
|
"optional" : true,
|
|
"format" : "uri",
|
|
|
|
"validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
var pathStart;
|
|
if (instance.getType() !== "undefined") {
|
|
pathStart = schema.getAttribute("pathStart");
|
|
if (typeof pathStart === "string") {
|
|
//TODO: Find out what pathStart is relative to
|
|
if (instance.getURI().indexOf(pathStart) !== 0) {
|
|
report.addError(instance, schema, "pathStart", "Instance's URI does not start with " + pathStart, pathStart);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"mediaType" : {
|
|
"type" : "string",
|
|
"optional" : true,
|
|
"format" : "media-type"
|
|
},
|
|
|
|
"alternate" : {
|
|
"type" : "array",
|
|
"items" : {"$ref" : "#"},
|
|
"optional" : true
|
|
}
|
|
},
|
|
|
|
"links" : [
|
|
{
|
|
"href" : "{$ref}",
|
|
"rel" : "full"
|
|
},
|
|
|
|
{
|
|
"href" : "{$schema}",
|
|
"rel" : "describedby"
|
|
},
|
|
|
|
{
|
|
"href" : "{id}",
|
|
"rel" : "self"
|
|
}
|
|
]//,
|
|
|
|
//not needed as JSV.inherits does the job for us
|
|
//"extends" : {"$ref" : "http://json-schema.org/schema#"}
|
|
}, SCHEMA), true), true, "http://json-schema.org/hyper-schema#");
|
|
|
|
ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/hyper-schema#");
|
|
|
|
LINKS = ENVIRONMENT.createSchema({
|
|
"$schema" : "http://json-schema.org/hyper-schema#",
|
|
"id" : "http://json-schema.org/links#",
|
|
"type" : "object",
|
|
|
|
"properties" : {
|
|
"href" : {
|
|
"type" : "string"
|
|
},
|
|
|
|
"rel" : {
|
|
"type" : "string"
|
|
},
|
|
|
|
"method" : {
|
|
"type" : "string",
|
|
"default" : "GET",
|
|
"optional" : true
|
|
},
|
|
|
|
"enctype" : {
|
|
"type" : "string",
|
|
"requires" : "method",
|
|
"optional" : true
|
|
},
|
|
|
|
"properties" : {
|
|
"type" : "object",
|
|
"additionalProperties" : {"$ref" : "hyper-schema#"},
|
|
"optional" : true,
|
|
|
|
"parser" : function (instance, self, arg) {
|
|
var env = instance.getEnvironment(),
|
|
selfEnv = self.getEnvironment(),
|
|
additionalPropertiesSchemaURI = self.getValueOfProperty("additionalProperties")["$ref"];
|
|
if (instance.getType() === "object") {
|
|
if (arg) {
|
|
return env.createSchema(instance.getProperty(arg), selfEnv.findSchema(self.resolveURI(additionalPropertiesSchemaURI)));
|
|
} else {
|
|
return JSV.mapObject(instance.getProperties(), function (instance) {
|
|
return env.createSchema(instance, selfEnv.findSchema(self.resolveURI(additionalPropertiesSchemaURI)));
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
"parser" : function (instance, self) {
|
|
var selfProperties = self.getProperty("properties");
|
|
if (instance.getType() === "object") {
|
|
return JSV.mapObject(instance.getProperties(), function (property, key) {
|
|
var propertySchema = selfProperties.getProperty(key),
|
|
parser = propertySchema && propertySchema.getValueOfProperty("parser");
|
|
if (typeof parser === "function") {
|
|
return parser(property, propertySchema);
|
|
}
|
|
//else
|
|
return property.getValue();
|
|
});
|
|
}
|
|
return instance.getValue();
|
|
}
|
|
}, HYPERSCHEMA, "http://json-schema.org/links#");
|
|
|
|
JSV.registerEnvironment("json-schema-draft-00", ENVIRONMENT);
|
|
JSV.registerEnvironment("json-schema-draft-01", JSV.createEnvironment("json-schema-draft-00"));
|
|
|
|
if (!JSV.getDefaultEnvironmentID()) {
|
|
JSV.setDefaultEnvironmentID("json-schema-draft-01");
|
|
}
|
|
|
|
}()); |