Spaces:
Sleeping
Sleeping
| /** | |
| * json-schema-draft-03 Environment | |
| * | |
| * @fileOverview Implementation of the third revision of the JSON Schema specification draft. | |
| * @author <a href="mailto:gary.court@gmail.com">Gary Court</a> | |
| * @version 1.5.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, | |
| TYPE_VALIDATORS, | |
| ENVIRONMENT, | |
| SCHEMA_00_JSON, | |
| HYPERSCHEMA_00_JSON, | |
| LINKS_00_JSON, | |
| SCHEMA_00, | |
| HYPERSCHEMA_00, | |
| LINKS_00, | |
| SCHEMA_01_JSON, | |
| HYPERSCHEMA_01_JSON, | |
| LINKS_01_JSON, | |
| SCHEMA_01, | |
| HYPERSCHEMA_01, | |
| LINKS_01, | |
| SCHEMA_02_JSON, | |
| HYPERSCHEMA_02_JSON, | |
| LINKS_02_JSON, | |
| SCHEMA_02, | |
| HYPERSCHEMA_02, | |
| LINKS_02, | |
| SCHEMA_03_JSON, | |
| HYPERSCHEMA_03_JSON, | |
| LINKS_03_JSON, | |
| SCHEMA_03, | |
| HYPERSCHEMA_03, | |
| LINKS_03; | |
| 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("validateReferences", true); | |
| ENVIRONMENT.setOption("enforceReferences", false); | |
| ENVIRONMENT.setOption("strict", false); | |
| // | |
| // draft-00 | |
| // | |
| SCHEMA_00_JSON = { | |
| "$schema" : "http://json-schema.org/draft-00/hyper-schema#", | |
| "id" : "http://json-schema.org/draft-00/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] === O[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(schema, self, "pattern", "Invalid pattern", schema.getValueOfProperty("pattern")); | |
| } | |
| } | |
| }, | |
| "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, subreport; | |
| //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 (JSV.isJSONSchema(key)) { //this is supported draft-03 and on | |
| subreport = JSV.createObject(report); | |
| subreport.errors = []; | |
| subreport.validated = JSV.clone(report.validated); | |
| if (key.validate(instance, subreport, parent, parentSchema, name).errors.length === 0) { | |
| //instance matches this schema | |
| report.addError(instance, schema, "disallow", "Instance is a disallowed type", disallowedTypes); | |
| return false; | |
| } | |
| } else 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"), | |
| strict = instance.getEnvironment().getOption("strict"), | |
| validator; | |
| for (x in attributeSchemas) { | |
| if (attributeSchemas[x] !== O[x]) { | |
| if (attributeSchemas[x].getValueOfProperty("validationRequired")) { | |
| JSV.pushUnique(propNames, x); | |
| } | |
| if (strict && attributeSchemas[x].getValueOfProperty("deprecated")) { | |
| JSV.popFirst(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); | |
| } | |
| } | |
| } | |
| } | |
| }; | |
| HYPERSCHEMA_00_JSON = { | |
| "$schema" : "http://json-schema.org/draft-00/hyper-schema#", | |
| "id" : "http://json-schema.org/draft-00/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"), | |
| selfReferenceVariable; | |
| 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]) { | |
| selfReferenceVariable = self.getValueOfProperty("selfReferenceVariable"); | |
| 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 === selfReferenceVariable) { | |
| value = instance.getValue(); | |
| } else { | |
| value = instance.getValueOfProperty(p1); | |
| } | |
| return value !== undefined ? String(value) : ""; | |
| }); | |
| return href ? JSV.formatURI(instance.resolveURI(href)) : href; | |
| }); | |
| } | |
| return links; | |
| }, | |
| "selfReferenceVariable" : "-this" | |
| }, | |
| "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" | |
| } | |
| ], | |
| "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; | |
| } | |
| //not needed as JSV.inherits does the job for us | |
| //"extends" : {"$ref" : "http://json-schema.org/schema#"} | |
| }; | |
| LINKS_00_JSON = { | |
| "$schema" : "http://json-schema.org/draft-00/hyper-schema#", | |
| "id" : "http://json-schema.org/draft-00/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(); | |
| } | |
| }; | |
| ENVIRONMENT.setOption("defaultFragmentDelimiter", "."); | |
| ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/draft-00/schema#"); //updated later | |
| SCHEMA_00 = ENVIRONMENT.createSchema(SCHEMA_00_JSON, true, "http://json-schema.org/draft-00/schema#"); | |
| HYPERSCHEMA_00 = ENVIRONMENT.createSchema(JSV.inherits(SCHEMA_00, ENVIRONMENT.createSchema(HYPERSCHEMA_00_JSON, true, "http://json-schema.org/draft-00/hyper-schema#"), true), true, "http://json-schema.org/draft-00/hyper-schema#"); | |
| ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/draft-00/hyper-schema#"); | |
| LINKS_00 = ENVIRONMENT.createSchema(LINKS_00_JSON, HYPERSCHEMA_00, "http://json-schema.org/draft-00/links#"); | |
| // | |
| // draft-01 | |
| // | |
| SCHEMA_01_JSON = JSV.inherits(SCHEMA_00_JSON, { | |
| "$schema" : "http://json-schema.org/draft-01/hyper-schema#", | |
| "id" : "http://json-schema.org/draft-01/schema#" | |
| }); | |
| HYPERSCHEMA_01_JSON = JSV.inherits(HYPERSCHEMA_00_JSON, { | |
| "$schema" : "http://json-schema.org/draft-01/hyper-schema#", | |
| "id" : "http://json-schema.org/draft-01/hyper-schema#" | |
| }); | |
| LINKS_01_JSON = JSV.inherits(LINKS_00_JSON, { | |
| "$schema" : "http://json-schema.org/draft-01/hyper-schema#", | |
| "id" : "http://json-schema.org/draft-01/links#" | |
| }); | |
| ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/draft-01/schema#"); //update later | |
| SCHEMA_01 = ENVIRONMENT.createSchema(SCHEMA_01_JSON, true, "http://json-schema.org/draft-01/schema#"); | |
| HYPERSCHEMA_01 = ENVIRONMENT.createSchema(JSV.inherits(SCHEMA_01, ENVIRONMENT.createSchema(HYPERSCHEMA_01_JSON, true, "http://json-schema.org/draft-01/hyper-schema#"), true), true, "http://json-schema.org/draft-01/hyper-schema#"); | |
| ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/draft-01/hyper-schema#"); | |
| LINKS_01 = ENVIRONMENT.createSchema(LINKS_01_JSON, HYPERSCHEMA_01, "http://json-schema.org/draft-01/links#"); | |
| // | |
| // draft-02 | |
| // | |
| SCHEMA_02_JSON = JSV.inherits(SCHEMA_01_JSON, { | |
| "$schema" : "http://json-schema.org/draft-02/hyper-schema#", | |
| "id" : "http://json-schema.org/draft-02/schema#", | |
| "properties" : { | |
| "uniqueItems" : { | |
| "type" : "boolean", | |
| "optional" : true, | |
| "default" : false, | |
| "parser" : function (instance, self) { | |
| return !!instance.getValue(); | |
| }, | |
| "validator" : function (instance, schema, self, report, parent, parentSchema, name) { | |
| var value, x, xl, y, yl; | |
| if (instance.getType() === "array" && schema.getAttribute("uniqueItems")) { | |
| value = instance.getProperties(); | |
| for (x = 0, xl = value.length - 1; x < xl; ++x) { | |
| for (y = x + 1, yl = value.length; y < yl; ++y) { | |
| if (value[x].equals(value[y])) { | |
| report.addError(instance, schema, "uniqueItems", "Array can only contain unique items", { x : x, y : y }); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }, | |
| "maxDecimal" : { | |
| "deprecated" : true | |
| }, | |
| "divisibleBy" : { | |
| "type" : "number", | |
| "minimum" : 0, | |
| "minimumCanEqual" : false, | |
| "optional" : true, | |
| "parser" : function (instance, self) { | |
| if (instance.getType() === "number") { | |
| return instance.getValue(); | |
| } | |
| }, | |
| "validator" : function (instance, schema, self, report, parent, parentSchema, name) { | |
| var divisor, value, digits; | |
| if (instance.getType() === "number") { | |
| divisor = schema.getAttribute("divisibleBy"); | |
| if (divisor === 0) { | |
| report.addError(instance, schema, "divisibleBy", "Nothing is divisible by 0", divisor); | |
| } else if (divisor !== 1) { | |
| value = instance.getValue(); | |
| digits = Math.max((value.toString().split(".")[1] || " ").length, (divisor.toString().split(".")[1] || " ").length); | |
| digits = parseFloat(((value / divisor) % 1).toFixed(digits)); //cut out floating point errors | |
| if (0 < digits && digits < 1) { | |
| report.addError(instance, schema, "divisibleBy", "Number is not divisible by " + divisor, divisor); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }, | |
| "fragmentResolution" : "slash-delimited" | |
| }); | |
| HYPERSCHEMA_02_JSON = JSV.inherits(HYPERSCHEMA_01_JSON, { | |
| "id" : "http://json-schema.org/draft-02/hyper-schema#", | |
| "properties" : { | |
| "fragmentResolution" : { | |
| "default" : "slash-delimited" | |
| } | |
| } | |
| }); | |
| LINKS_02_JSON = JSV.inherits(LINKS_01_JSON, { | |
| "$schema" : "http://json-schema.org/draft-02/hyper-schema#", | |
| "id" : "http://json-schema.org/draft-02/links#", | |
| "properties" : { | |
| "targetSchema" : { | |
| "$ref" : "hyper-schema#", | |
| //need this here because parsers are run before links are resolved | |
| "parser" : HYPERSCHEMA_01.getAttribute("parser") | |
| } | |
| } | |
| }); | |
| ENVIRONMENT.setOption("defaultFragmentDelimiter", "/"); | |
| ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/draft-02/schema#"); //update later | |
| SCHEMA_02 = ENVIRONMENT.createSchema(SCHEMA_02_JSON, true, "http://json-schema.org/draft-02/schema#"); | |
| HYPERSCHEMA_02 = ENVIRONMENT.createSchema(JSV.inherits(SCHEMA_02, ENVIRONMENT.createSchema(HYPERSCHEMA_02_JSON, true, "http://json-schema.org/draft-02/hyper-schema#"), true), true, "http://json-schema.org/draft-02/hyper-schema#"); | |
| ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/draft-02/hyper-schema#"); | |
| LINKS_02 = ENVIRONMENT.createSchema(LINKS_02_JSON, HYPERSCHEMA_02, "http://json-schema.org/draft-02/links#"); | |
| // | |
| // draft-03 | |
| // | |
| function getMatchedPatternProperties(instance, schema, report, self) { | |
| var matchedProperties = {}, patternProperties, pattern, regexp, properties, key; | |
| if (instance.getType() === "object") { | |
| patternProperties = schema.getAttribute("patternProperties"); | |
| properties = instance.getProperties(); | |
| for (pattern in patternProperties) { | |
| if (patternProperties[pattern] !== O[pattern]) { | |
| regexp = null; | |
| try { | |
| regexp = new RegExp(pattern); | |
| } catch (e) { | |
| if (report) { | |
| report.addError(schema, self, "patternProperties", "Invalid pattern", pattern); | |
| } | |
| } | |
| if (regexp) { | |
| for (key in properties) { | |
| if (properties[key] !== O[key] && regexp.test(key)) { | |
| matchedProperties[key] = matchedProperties[key] ? JSV.pushUnique(matchedProperties[key], patternProperties[pattern]) : [ patternProperties[pattern] ]; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return matchedProperties; | |
| } | |
| SCHEMA_03_JSON = JSV.inherits(SCHEMA_02_JSON, { | |
| "$schema" : "http://json-schema.org/draft-03/schema#", | |
| "id" : "http://json-schema.org/draft-03/schema#", | |
| "properties" : { | |
| "patternProperties" : { | |
| "type" : "object", | |
| "additionalProperties" : {"$ref" : "#"}, | |
| "default" : {}, | |
| "parser" : SCHEMA_02.getValueOfProperty("properties")["properties"]["parser"], | |
| "validator" : function (instance, schema, self, report, parent, parentSchema, name) { | |
| var matchedProperties, key, x; | |
| if (instance.getType() === "object") { | |
| matchedProperties = getMatchedPatternProperties(instance, schema, report, self); | |
| for (key in matchedProperties) { | |
| if (matchedProperties[key] !== O[key]) { | |
| x = matchedProperties[key].length; | |
| while (x--) { | |
| matchedProperties[key][x].validate(instance.getProperty(key), report, instance, schema, key); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }, | |
| "additionalProperties" : { | |
| "validator" : function (instance, schema, self, report, parent, parentSchema, name) { | |
| var additionalProperties, propertySchemas, properties, matchedProperties, key; | |
| if (instance.getType() === "object") { | |
| additionalProperties = schema.getAttribute("additionalProperties"); | |
| propertySchemas = schema.getAttribute("properties") || {}; | |
| properties = instance.getProperties(); | |
| matchedProperties = getMatchedPatternProperties(instance, schema); | |
| for (key in properties) { | |
| if (properties[key] !== O[key] && properties[key] && propertySchemas[key] === O[key] && matchedProperties[key] === O[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); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }, | |
| "items" : { | |
| "validator" : function (instance, schema, self, report, parent, parentSchema, name) { | |
| var properties, items, x, xl, itemSchema, additionalItems; | |
| if (instance.getType() === "array") { | |
| properties = instance.getProperties(); | |
| items = schema.getAttribute("items"); | |
| additionalItems = schema.getAttribute("additionalItems"); | |
| if (JSV.typeOf(items) === "array") { | |
| for (x = 0, xl = properties.length; x < xl; ++x) { | |
| itemSchema = items[x] || additionalItems; | |
| if (itemSchema !== false) { | |
| itemSchema.validate(properties[x], report, instance, schema, x); | |
| } else { | |
| report.addError(instance, schema, "additionalItems", "Additional items are not allowed", itemSchema); | |
| } | |
| } | |
| } else { | |
| itemSchema = items || additionalItems; | |
| for (x = 0, xl = properties.length; x < xl; ++x) { | |
| itemSchema.validate(properties[x], report, instance, schema, x); | |
| } | |
| } | |
| } | |
| } | |
| }, | |
| "additionalItems" : { | |
| "type" : [{"$ref" : "#"}, "boolean"], | |
| "default" : {}, | |
| "parser" : SCHEMA_02.getValueOfProperty("properties")["additionalProperties"]["parser"], | |
| "validator" : function (instance, schema, self, report, parent, parentSchema, name) { | |
| var additionalItems, properties, x, xl; | |
| //only validate if the "items" attribute is undefined | |
| if (instance.getType() === "array" && schema.getProperty("items").getType() === "undefined") { | |
| additionalItems = schema.getAttribute("additionalItems"); | |
| properties = instance.getProperties(); | |
| if (additionalItems !== false) { | |
| for (x = 0, xl = properties.length; x < xl; ++x) { | |
| additionalItems.validate(properties[x], report, instance, schema, x); | |
| } | |
| } else if (properties.length) { | |
| report.addError(instance, schema, "additionalItems", "Additional items are not allowed", additionalItems); | |
| } | |
| } | |
| } | |
| }, | |
| "optional" : { | |
| "validationRequired" : false, | |
| "deprecated" : true | |
| }, | |
| "required" : { | |
| "type" : "boolean", | |
| "default" : false, | |
| "parser" : function (instance, self) { | |
| return !!instance.getValue(); | |
| }, | |
| "validator" : function (instance, schema, self, report, parent, parentSchema, name) { | |
| if (instance.getType() === "undefined" && schema.getAttribute("required")) { | |
| report.addError(instance, schema, "required", "Property is required", true); | |
| } | |
| } | |
| }, | |
| "requires" : { | |
| "deprecated" : true | |
| }, | |
| "dependencies" : { | |
| "type" : "object", | |
| "additionalProperties" : { | |
| "type" : ["string", "array", {"$ref" : "#"}], | |
| "items" : { | |
| "type" : "string" | |
| } | |
| }, | |
| "default" : {}, | |
| "parser" : function (instance, self, arg) { | |
| function parseProperty(property) { | |
| var type = property.getType(); | |
| if (type === "string" || type === "array") { | |
| return property.getValue(); | |
| } else if (type === "object") { | |
| return property.getEnvironment().createSchema(property, self.getEnvironment().findSchema(self.resolveURI("#"))); | |
| } | |
| } | |
| if (instance.getType() === "object") { | |
| if (arg) { | |
| return parseProperty(instance.getProperty(arg)); | |
| } else { | |
| return JSV.mapObject(instance.getProperties(), parseProperty); | |
| } | |
| } | |
| //else | |
| return {}; | |
| }, | |
| "validator" : function (instance, schema, self, report, parent, parentSchema, name) { | |
| var dependencies, key, dependency, type, x, xl; | |
| if (instance.getType() === "object") { | |
| dependencies = schema.getAttribute("dependencies"); | |
| for (key in dependencies) { | |
| if (dependencies[key] !== O[key] && instance.getProperty(key).getType() !== "undefined") { | |
| dependency = dependencies[key]; | |
| type = JSV.typeOf(dependency); | |
| if (type === "string") { | |
| if (instance.getProperty(dependency).getType() === "undefined") { | |
| report.addError(instance, schema, "dependencies", 'Property "' + key + '" requires sibling property "' + dependency + '"', dependencies); | |
| } | |
| } else if (type === "array") { | |
| for (x = 0, xl = dependency.length; x < xl; ++x) { | |
| if (instance.getProperty(dependency[x]).getType() === "undefined") { | |
| report.addError(instance, schema, "dependencies", 'Property "' + key + '" requires sibling property "' + dependency[x] + '"', dependencies); | |
| } | |
| } | |
| } else if (JSV.isJSONSchema(dependency)) { | |
| dependency.validate(instance, report); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }, | |
| "minimumCanEqual" : { | |
| "deprecated" : true | |
| }, | |
| "maximumCanEqual" : { | |
| "deprecated" : true | |
| }, | |
| "exclusiveMinimum" : { | |
| "type" : "boolean", | |
| "default" : false, | |
| "parser" : function (instance, self) { | |
| return !!instance.getValue(); | |
| } | |
| }, | |
| "exclusiveMaximum" : { | |
| "type" : "boolean", | |
| "default" : false, | |
| "parser" : function (instance, self) { | |
| return !!instance.getValue(); | |
| } | |
| }, | |
| "minimum" : { | |
| "validator" : function (instance, schema, self, report, parent, parentSchema, name) { | |
| var minimum, exclusiveMinimum; | |
| if (instance.getType() === "number") { | |
| minimum = schema.getAttribute("minimum"); | |
| exclusiveMinimum = schema.getAttribute("exclusiveMinimum") || (!instance.getEnvironment().getOption("strict") && !schema.getAttribute("minimumCanEqual")); | |
| if (typeof minimum === "number" && (instance.getValue() < minimum || (exclusiveMinimum === true && instance.getValue() === minimum))) { | |
| report.addError(instance, schema, "minimum", "Number is less than the required minimum value", minimum); | |
| } | |
| } | |
| } | |
| }, | |
| "maximum" : { | |
| "validator" : function (instance, schema, self, report, parent, parentSchema, name) { | |
| var maximum, exclusiveMaximum; | |
| if (instance.getType() === "number") { | |
| maximum = schema.getAttribute("maximum"); | |
| exclusiveMaximum = schema.getAttribute("exclusiveMaximum") || (!instance.getEnvironment().getOption("strict") && !schema.getAttribute("maximumCanEqual")); | |
| if (typeof maximum === "number" && (instance.getValue() > maximum || (exclusiveMaximum === true && instance.getValue() === maximum))) { | |
| report.addError(instance, schema, "maximum", "Number is greater than the required maximum value", maximum); | |
| } | |
| } | |
| } | |
| }, | |
| "contentEncoding" : { | |
| "deprecated" : true | |
| }, | |
| "divisibleBy" : { | |
| "exclusiveMinimum" : true | |
| }, | |
| "disallow" : { | |
| "items" : { | |
| "type" : ["string", {"$ref" : "#"}] | |
| }, | |
| "parser" : SCHEMA_02_JSON["properties"]["type"]["parser"] | |
| }, | |
| "id" : { | |
| "type" : "string", | |
| "format" : "uri" | |
| }, | |
| "$ref" : { | |
| "type" : "string", | |
| "format" : "uri" | |
| }, | |
| "$schema" : { | |
| "type" : "string", | |
| "format" : "uri" | |
| } | |
| }, | |
| "dependencies" : { | |
| "exclusiveMinimum" : "minimum", | |
| "exclusiveMaximum" : "maximum" | |
| }, | |
| "initializer" : function (instance) { | |
| var link, extension, extended, | |
| schemaLink = instance.getValueOfProperty("$schema"), | |
| refLink = instance.getValueOfProperty("$ref"), | |
| idLink = instance.getValueOfProperty("id"); | |
| //if there is a link to a different schema, set reference | |
| if (schemaLink) { | |
| link = instance.resolveURI(schemaLink); | |
| instance.setReference("describedby", link); | |
| } | |
| //if instance has a URI link to itself, update it's own URI | |
| if (idLink) { | |
| link = instance.resolveURI(idLink); | |
| if (JSV.typeOf(link) === "string") { | |
| instance._uri = JSV.formatURI(link); | |
| } | |
| } | |
| //if there is a link to the full representation, set reference | |
| if (refLink) { | |
| link = instance.resolveURI(refLink); | |
| 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; | |
| } | |
| }); | |
| HYPERSCHEMA_03_JSON = JSV.inherits(HYPERSCHEMA_02_JSON, { | |
| "$schema" : "http://json-schema.org/draft-03/hyper-schema#", | |
| "id" : "http://json-schema.org/draft-03/hyper-schema#", | |
| "properties" : { | |
| "links" : { | |
| "selfReferenceVariable" : "@" | |
| }, | |
| "root" : { | |
| "deprecated" : true | |
| }, | |
| "contentEncoding" : { | |
| "deprecated" : false //moved from core to hyper | |
| }, | |
| "alternate" : { | |
| "deprecated" : true | |
| } | |
| } | |
| }); | |
| LINKS_03_JSON = JSV.inherits(LINKS_02_JSON, { | |
| "$schema" : "http://json-schema.org/draft-03/hyper-schema#", | |
| "id" : "http://json-schema.org/draft-03/links#", | |
| "properties" : { | |
| "href" : { | |
| "required" : true, | |
| "format" : "link-description-object-template" | |
| }, | |
| "rel" : { | |
| "required" : true | |
| }, | |
| "properties" : { | |
| "deprecated" : true | |
| }, | |
| "schema" : {"$ref" : "http://json-schema.org/draft-03/hyper-schema#"} | |
| } | |
| }); | |
| ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/draft-03/schema#"); //update later | |
| SCHEMA_03 = ENVIRONMENT.createSchema(SCHEMA_03_JSON, true, "http://json-schema.org/draft-03/schema#"); | |
| HYPERSCHEMA_03 = ENVIRONMENT.createSchema(JSV.inherits(SCHEMA_03, ENVIRONMENT.createSchema(HYPERSCHEMA_03_JSON, true, "http://json-schema.org/draft-03/hyper-schema#"), true), true, "http://json-schema.org/draft-03/hyper-schema#"); | |
| ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/draft-03/hyper-schema#"); | |
| LINKS_03 = ENVIRONMENT.createSchema(LINKS_03_JSON, true, "http://json-schema.org/draft-03/links#"); | |
| ENVIRONMENT.setOption("latestJSONSchemaSchemaURI", "http://json-schema.org/draft-03/schema#"); | |
| ENVIRONMENT.setOption("latestJSONSchemaHyperSchemaURI", "http://json-schema.org/draft-03/hyper-schema#"); | |
| ENVIRONMENT.setOption("latestJSONSchemaLinksURI", "http://json-schema.org/draft-03/links#"); | |
| // | |
| //Latest JSON Schema | |
| // | |
| //Hack, but WAY faster than instantiating a new schema | |
| ENVIRONMENT._schemas["http://json-schema.org/schema#"] = SCHEMA_03; | |
| ENVIRONMENT._schemas["http://json-schema.org/hyper-schema#"] = HYPERSCHEMA_03; | |
| ENVIRONMENT._schemas["http://json-schema.org/links#"] = LINKS_03; | |
| // | |
| //register environment | |
| // | |
| JSV.registerEnvironment("json-schema-draft-03", ENVIRONMENT); | |
| if (!JSV.getDefaultEnvironmentID() || JSV.getDefaultEnvironmentID() === "json-schema-draft-01" || JSV.getDefaultEnvironmentID() === "json-schema-draft-02") { | |
| JSV.setDefaultEnvironmentID("json-schema-draft-03"); | |
| } | |
| }()); |