|
|
@@ -0,0 +1,3700 @@
|
|
|
+// This is a build of https://github.com/garycourt/JSV at 0aa11852537069b0830569ef1eab11a36b65b3ab with jsv.js, schema03 and URI.js appended.
|
|
|
+// The build contains a few lines of custom code to handle format validation.
|
|
|
+// Custom code is wrapped in comments that start with "JOSHFIRE"
|
|
|
+(function(global, require) {
|
|
|
+var exports = {};
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ * URI.js
|
|
|
+ *
|
|
|
+ * @fileoverview An RFC 3986 compliant, scheme extendable URI parsing/validating/resolving library for JavaScript.
|
|
|
+ * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
|
|
|
+ * @version 1.2
|
|
|
+ * @see http://github.com/garycourt/uri-js
|
|
|
+ * @license URI.js v1.2 (c) 2010 Gary Court. License: http://github.com/garycourt/uri-js
|
|
|
+ */
|
|
|
+
|
|
|
+/**
|
|
|
+ * 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.
|
|
|
+ */
|
|
|
+
|
|
|
+/*jslint white: true, sub: true, onevar: true, undef: true, eqeqeq: true, newcap: true, immed: true, indent: 4 */
|
|
|
+/*global exports:true, require:true */
|
|
|
+
|
|
|
+if (typeof exports === "undefined") {
|
|
|
+ exports = {};
|
|
|
+}
|
|
|
+if (typeof require !== "function") {
|
|
|
+ require = function (id) {
|
|
|
+ return exports;
|
|
|
+ };
|
|
|
+}
|
|
|
+(function () {
|
|
|
+ var
|
|
|
+ /**
|
|
|
+ * @param {...string} sets
|
|
|
+ * @return {string}
|
|
|
+ */
|
|
|
+ mergeSet = function (sets) {
|
|
|
+ var set = arguments[0],
|
|
|
+ x = 1,
|
|
|
+ nextSet = arguments[x];
|
|
|
+
|
|
|
+ while (nextSet) {
|
|
|
+ set = set.slice(0, -1) + nextSet.slice(1);
|
|
|
+ nextSet = arguments[++x];
|
|
|
+ }
|
|
|
+
|
|
|
+ return set;
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {string} str
|
|
|
+ * @return {string}
|
|
|
+ */
|
|
|
+ subexp = function (str) {
|
|
|
+ return "(?:" + str + ")";
|
|
|
+ },
|
|
|
+
|
|
|
+ ALPHA$$ = "[A-Za-z]",
|
|
|
+ CR$ = "[\\x0D]",
|
|
|
+ DIGIT$$ = "[0-9]",
|
|
|
+ DQUOTE$$ = "[\\x22]",
|
|
|
+ HEXDIG$$ = mergeSet(DIGIT$$, "[A-Fa-f]"), //case-insensitive
|
|
|
+ LF$$ = "[\\x0A]",
|
|
|
+ SP$$ = "[\\x20]",
|
|
|
+ PCT_ENCODED$ = subexp("%" + HEXDIG$$ + HEXDIG$$),
|
|
|
+ GEN_DELIMS$$ = "[\\:\\/\\?\\#\\[\\]\\@]",
|
|
|
+ SUB_DELIMS$$ = "[\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\=]",
|
|
|
+ RESERVED$$ = mergeSet(GEN_DELIMS$$, SUB_DELIMS$$),
|
|
|
+ UNRESERVED$$ = mergeSet(ALPHA$$, DIGIT$$, "[\\-\\.\\_\\~]"),
|
|
|
+ SCHEME$ = subexp(ALPHA$$ + mergeSet(ALPHA$$, DIGIT$$, "[\\+\\-\\.]") + "*"),
|
|
|
+ USERINFO$ = subexp(subexp(PCT_ENCODED$ + "|" + mergeSet(UNRESERVED$$, SUB_DELIMS$$, "[\\:]")) + "*"),
|
|
|
+ DEC_OCTET$ = subexp(subexp("25[0-5]") + "|" + subexp("2[0-4]" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("[1-9]" + DIGIT$$) + "|" + DIGIT$$),
|
|
|
+ IPV4ADDRESS$ = subexp(DEC_OCTET$ + "\\." + DEC_OCTET$ + "\\." + DEC_OCTET$ + "\\." + DEC_OCTET$),
|
|
|
+ H16$ = subexp(HEXDIG$$ + "{1,4}"),
|
|
|
+ LS32$ = subexp(subexp(H16$ + "\\:" + H16$) + "|" + IPV4ADDRESS$),
|
|
|
+ IPV6ADDRESS$ = subexp(mergeSet(UNRESERVED$$, SUB_DELIMS$$, "[\\:]") + "+"), //FIXME
|
|
|
+ IPVFUTURE$ = subexp("v" + HEXDIG$$ + "+\\." + mergeSet(UNRESERVED$$, SUB_DELIMS$$, "[\\:]") + "+"),
|
|
|
+ IP_LITERAL$ = subexp("\\[" + subexp(IPV6ADDRESS$ + "|" + IPVFUTURE$) + "\\]"),
|
|
|
+ REG_NAME$ = subexp(subexp(PCT_ENCODED$ + "|" + mergeSet(UNRESERVED$$, SUB_DELIMS$$)) + "*"),
|
|
|
+ HOST$ = subexp(IP_LITERAL$ + "|" + IPV4ADDRESS$ + "|" + REG_NAME$),
|
|
|
+ PORT$ = subexp(DIGIT$$ + "*"),
|
|
|
+ AUTHORITY$ = subexp(subexp(USERINFO$ + "@") + "?" + HOST$ + subexp("\\:" + PORT$) + "?"),
|
|
|
+ PCHAR$ = subexp(PCT_ENCODED$ + "|" + mergeSet(UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@]")),
|
|
|
+ SEGMENT$ = subexp(PCHAR$ + "*"),
|
|
|
+ SEGMENT_NZ$ = subexp(PCHAR$ + "+"),
|
|
|
+ SEGMENT_NZ_NC$ = subexp(subexp(PCT_ENCODED$ + "|" + mergeSet(UNRESERVED$$, SUB_DELIMS$$, "[\\@]")) + "+"),
|
|
|
+ PATH_ABEMPTY$ = subexp(subexp("\\/" + SEGMENT$) + "*"),
|
|
|
+ PATH_ABSOLUTE$ = subexp("\\/" + subexp(SEGMENT_NZ$ + PATH_ABEMPTY$) + "?"), //simplified
|
|
|
+ PATH_NOSCHEME$ = subexp(SEGMENT_NZ_NC$ + PATH_ABEMPTY$), //simplified
|
|
|
+ PATH_ROOTLESS$ = subexp(SEGMENT_NZ$ + PATH_ABEMPTY$), //simplified
|
|
|
+ PATH_EMPTY$ = subexp(""), //simplified
|
|
|
+ PATH$ = subexp(PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$),
|
|
|
+ QUERY$ = subexp(subexp(PCHAR$ + "|[\\/\\?]") + "*"),
|
|
|
+ FRAGMENT$ = subexp(subexp(PCHAR$ + "|[\\/\\?]") + "*"),
|
|
|
+ HIER_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$),
|
|
|
+ URI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"),
|
|
|
+ RELATIVE_PART$ = subexp(subexp("\\/\\/" + AUTHORITY$ + PATH_ABEMPTY$) + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$),
|
|
|
+ RELATIVE_REF$ = subexp(RELATIVE_PART$ + subexp("\\?" + QUERY$) + "?" + subexp("\\#" + FRAGMENT$) + "?"),
|
|
|
+ URI_REFERENCE$ = subexp(URI$ + "|" + RELATIVE_REF$),
|
|
|
+ ABSOLUTE_URI$ = subexp(SCHEME$ + "\\:" + HIER_PART$ + subexp("\\?" + QUERY$) + "?"),
|
|
|
+
|
|
|
+ URI_REF = new RegExp("^" + subexp("(" + URI$ + ")|(" + RELATIVE_REF$ + ")") + "$"),
|
|
|
+ GENERIC_REF = new RegExp("^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$"),
|
|
|
+ RELATIVE_REF = new RegExp("^(){0}" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_NOSCHEME$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?" + subexp("\\#(" + FRAGMENT$ + ")") + "?$"),
|
|
|
+ ABSOLUTE_REF = new RegExp("^(" + SCHEME$ + ")\\:" + subexp(subexp("\\/\\/(" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?)") + "?(" + PATH_ABEMPTY$ + "|" + PATH_ABSOLUTE$ + "|" + PATH_ROOTLESS$ + "|" + PATH_EMPTY$ + ")") + subexp("\\?(" + QUERY$ + ")") + "?$"),
|
|
|
+ SAMEDOC_REF = new RegExp("^" + subexp("\\#(" + FRAGMENT$ + ")") + "?$"),
|
|
|
+ AUTHORITY = new RegExp("^" + subexp("(" + USERINFO$ + ")@") + "?(" + HOST$ + ")" + subexp("\\:(" + PORT$ + ")") + "?$"),
|
|
|
+
|
|
|
+ NOT_SCHEME = new RegExp(mergeSet("[^]", ALPHA$$, DIGIT$$, "[\\+\\-\\.]"), "g"),
|
|
|
+ NOT_USERINFO = new RegExp(mergeSet("[^\\%\\:]", UNRESERVED$$, SUB_DELIMS$$), "g"),
|
|
|
+ NOT_HOST = new RegExp(mergeSet("[^\\%]", UNRESERVED$$, SUB_DELIMS$$), "g"),
|
|
|
+ NOT_PATH = new RegExp(mergeSet("[^\\%\\/\\:\\@]", UNRESERVED$$, SUB_DELIMS$$), "g"),
|
|
|
+ NOT_PATH_NOSCHEME = new RegExp(mergeSet("[^\\%\\/\\@]", UNRESERVED$$, SUB_DELIMS$$), "g"),
|
|
|
+ NOT_QUERY = new RegExp(mergeSet("[^\\%]", UNRESERVED$$, SUB_DELIMS$$, "[\\:\\@\\/\\?]"), "g"),
|
|
|
+ NOT_FRAGMENT = NOT_QUERY,
|
|
|
+ ESCAPE = new RegExp(mergeSet("[^]", UNRESERVED$$, SUB_DELIMS$$), "g"),
|
|
|
+ UNRESERVED = new RegExp(UNRESERVED$$, "g"),
|
|
|
+ OTHER_CHARS = new RegExp(mergeSet("[^\\%]", UNRESERVED$$, RESERVED$$), "g"),
|
|
|
+ PCT_ENCODEDS = new RegExp(PCT_ENCODED$ + "+", "g"),
|
|
|
+ URI_PARSE = /^(?:([^:\/?#]+):)?(?:\/\/((?:([^\/?#@]*)@)?([^\/?#:]*)(?:\:(\d*))?))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?/i,
|
|
|
+ RDS1 = /^\.\.?\//,
|
|
|
+ RDS2 = /^\/\.(\/|$)/,
|
|
|
+ RDS3 = /^\/\.\.(\/|$)/,
|
|
|
+ RDS4 = /^\.\.?$/,
|
|
|
+ RDS5 = /^\/?.*?(?=\/|$)/,
|
|
|
+ NO_MATCH_IS_UNDEFINED = ("").match(/(){0}/)[1] === undefined,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {string} chr
|
|
|
+ * @return {string}
|
|
|
+ */
|
|
|
+ pctEncChar = function (chr) {
|
|
|
+ var c = chr.charCodeAt(0);
|
|
|
+
|
|
|
+ if (c < 128) {
|
|
|
+ return "%" + c.toString(16).toUpperCase();
|
|
|
+ }
|
|
|
+ else if ((c > 127) && (c < 2048)) {
|
|
|
+ return "%" + ((c >> 6) | 192).toString(16).toUpperCase() + "%" + ((c & 63) | 128).toString(16).toUpperCase();
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ return "%" + ((c >> 12) | 224).toString(16).toUpperCase() + "%" + (((c >> 6) & 63) | 128).toString(16).toUpperCase() + "%" + ((c & 63) | 128).toString(16).toUpperCase();
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {string} str
|
|
|
+ * @return {string}
|
|
|
+ */
|
|
|
+ pctDecUnreserved = function (str) {
|
|
|
+ var newStr = "",
|
|
|
+ i = 0,
|
|
|
+ c, s;
|
|
|
+
|
|
|
+ while (i < str.length) {
|
|
|
+ c = parseInt(str.substr(i + 1, 2), 16);
|
|
|
+
|
|
|
+ if (c < 128) {
|
|
|
+ s = String.fromCharCode(c);
|
|
|
+ if (s.match(UNRESERVED)) {
|
|
|
+ newStr += s;
|
|
|
+ } else {
|
|
|
+ newStr += str.substr(i, 3);
|
|
|
+ }
|
|
|
+ i += 3;
|
|
|
+ }
|
|
|
+ else if ((c > 191) && (c < 224)) {
|
|
|
+ newStr += str.substr(i, 6);
|
|
|
+ i += 6;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ newStr += str.substr(i, 9);
|
|
|
+ i += 9;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return newStr;
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {string} str
|
|
|
+ * @return {string}
|
|
|
+ */
|
|
|
+ pctDecChars = function (str) {
|
|
|
+ var newStr = "",
|
|
|
+ i = 0,
|
|
|
+ c, c2, c3;
|
|
|
+
|
|
|
+ while (i < str.length) {
|
|
|
+ c = parseInt(str.substr(i + 1, 2), 16);
|
|
|
+
|
|
|
+ if (c < 128) {
|
|
|
+ newStr += String.fromCharCode(c);
|
|
|
+ i += 3;
|
|
|
+ }
|
|
|
+ else if ((c > 191) && (c < 224)) {
|
|
|
+ c2 = parseInt(str.substr(i + 4, 2), 16);
|
|
|
+ newStr += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
|
|
|
+ i += 6;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ c2 = parseInt(str.substr(i + 4, 2), 16);
|
|
|
+ c3 = parseInt(str.substr(i + 7, 2), 16);
|
|
|
+ newStr += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
|
|
|
+ i += 9;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return newStr;
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @return {string}
|
|
|
+ */
|
|
|
+ typeOf = function (o) {
|
|
|
+ return o === undefined ? "undefined" : (o === null ? "null" : Object.prototype.toString.call(o).split(" ").pop().split("]").shift().toLowerCase());
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @constructor
|
|
|
+ * @implements URIComponents
|
|
|
+ */
|
|
|
+ Components = function () {
|
|
|
+ this.errors = [];
|
|
|
+ },
|
|
|
+
|
|
|
+ /** @namespace */
|
|
|
+ URI = {};
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Components
|
|
|
+ */
|
|
|
+
|
|
|
+ Components.prototype = {
|
|
|
+ /**
|
|
|
+ * @type String
|
|
|
+ */
|
|
|
+
|
|
|
+ scheme : undefined,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type String
|
|
|
+ */
|
|
|
+
|
|
|
+ authority : undefined,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type String
|
|
|
+ */
|
|
|
+
|
|
|
+ userinfo : undefined,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type String
|
|
|
+ */
|
|
|
+
|
|
|
+ host : undefined,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type number
|
|
|
+ */
|
|
|
+
|
|
|
+ port : undefined,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type string
|
|
|
+ */
|
|
|
+
|
|
|
+ path : undefined,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type string
|
|
|
+ */
|
|
|
+
|
|
|
+ query : undefined,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type string
|
|
|
+ */
|
|
|
+
|
|
|
+ fragment : undefined,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type string
|
|
|
+ * @values "uri", "absolute", "relative", "same-document"
|
|
|
+ */
|
|
|
+
|
|
|
+ reference : undefined,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @type Array
|
|
|
+ */
|
|
|
+
|
|
|
+ errors : undefined
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * URI
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @namespace
|
|
|
+ */
|
|
|
+
|
|
|
+ URI.SCHEMES = {};
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {string} uriString
|
|
|
+ * @param {Options} [options]
|
|
|
+ * @returns {URIComponents}
|
|
|
+ */
|
|
|
+
|
|
|
+ URI.parse = function (uriString, options) {
|
|
|
+ var matches,
|
|
|
+ components = new Components(),
|
|
|
+ schemeHandler;
|
|
|
+
|
|
|
+ uriString = uriString ? uriString.toString() : "";
|
|
|
+ options = options || {};
|
|
|
+
|
|
|
+ if (options.reference === "suffix") {
|
|
|
+ uriString = (options.scheme ? options.scheme + ":" : "") + "//" + uriString;
|
|
|
+ }
|
|
|
+
|
|
|
+ matches = uriString.match(URI_REF);
|
|
|
+
|
|
|
+ if (matches) {
|
|
|
+ if (matches[1]) {
|
|
|
+ //generic URI
|
|
|
+ matches = uriString.match(GENERIC_REF);
|
|
|
+ } else {
|
|
|
+ //relative URI
|
|
|
+ matches = uriString.match(RELATIVE_REF);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!matches) {
|
|
|
+ if (!options.tolerant) {
|
|
|
+ components.errors.push("URI is not strictly valid.");
|
|
|
+ }
|
|
|
+ matches = uriString.match(URI_PARSE);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (matches) {
|
|
|
+ if (NO_MATCH_IS_UNDEFINED) {
|
|
|
+ //store each component
|
|
|
+ components.scheme = matches[1];
|
|
|
+ components.authority = matches[2];
|
|
|
+ components.userinfo = matches[3];
|
|
|
+ components.host = matches[4];
|
|
|
+ components.port = parseInt(matches[5], 10);
|
|
|
+ components.path = matches[6] || "";
|
|
|
+ components.query = matches[7];
|
|
|
+ components.fragment = matches[8];
|
|
|
+
|
|
|
+ //fix port number
|
|
|
+ if (isNaN(components.port)) {
|
|
|
+ components.port = matches[5];
|
|
|
+ }
|
|
|
+ } else { //IE FIX for improper RegExp matching
|
|
|
+ //store each component
|
|
|
+ components.scheme = matches[1] || undefined;
|
|
|
+ components.authority = (uriString.indexOf("//") !== -1 ? matches[2] : undefined);
|
|
|
+ components.userinfo = (uriString.indexOf("@") !== -1 ? matches[3] : undefined);
|
|
|
+ components.host = (uriString.indexOf("//") !== -1 ? matches[4] : undefined);
|
|
|
+ components.port = parseInt(matches[5], 10);
|
|
|
+ components.path = matches[6] || "";
|
|
|
+ components.query = (uriString.indexOf("?") !== -1 ? matches[7] : undefined);
|
|
|
+ components.fragment = (uriString.indexOf("#") !== -1 ? matches[8] : undefined);
|
|
|
+
|
|
|
+ //fix port number
|
|
|
+ if (isNaN(components.port)) {
|
|
|
+ components.port = (uriString.match(/\/\/.*\:(?:\/|\?|\#|$)/) ? matches[4] : undefined);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //determine reference type
|
|
|
+ if (!components.scheme && !components.authority && !components.path && !components.query) {
|
|
|
+ components.reference = "same-document";
|
|
|
+ } else if (!components.scheme) {
|
|
|
+ components.reference = "relative";
|
|
|
+ } else if (!components.fragment) {
|
|
|
+ components.reference = "absolute";
|
|
|
+ } else {
|
|
|
+ components.reference = "uri";
|
|
|
+ }
|
|
|
+
|
|
|
+ //check for reference errors
|
|
|
+ if (options.reference && options.reference !== "suffix" && options.reference !== components.reference) {
|
|
|
+ components.errors.push("URI is not a " + options.reference + " reference.");
|
|
|
+ }
|
|
|
+
|
|
|
+ //check if a handler for the scheme exists
|
|
|
+ schemeHandler = URI.SCHEMES[components.scheme || options.scheme];
|
|
|
+ if (schemeHandler && schemeHandler.parse) {
|
|
|
+ //perform extra parsing
|
|
|
+ schemeHandler.parse(components, options);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ components.errors.push("URI can not be parsed.");
|
|
|
+ }
|
|
|
+
|
|
|
+ return components;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @private
|
|
|
+ * @param {URIComponents} components
|
|
|
+ * @returns {string|undefined}
|
|
|
+ */
|
|
|
+
|
|
|
+ URI._recomposeAuthority = function (components) {
|
|
|
+ var uriTokens = [];
|
|
|
+
|
|
|
+ if (components.userinfo !== undefined || components.host !== undefined || typeof components.port === "number") {
|
|
|
+ if (components.userinfo !== undefined) {
|
|
|
+ uriTokens.push(components.userinfo.toString().replace(NOT_USERINFO, pctEncChar));
|
|
|
+ uriTokens.push("@");
|
|
|
+ }
|
|
|
+ if (components.host !== undefined) {
|
|
|
+ uriTokens.push(components.host.toString().toLowerCase().replace(NOT_HOST, pctEncChar));
|
|
|
+ }
|
|
|
+ if (typeof components.port === "number") {
|
|
|
+ uriTokens.push(":");
|
|
|
+ uriTokens.push(components.port.toString(10));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return uriTokens.length ? uriTokens.join("") : undefined;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {string} input
|
|
|
+ * @returns {string}
|
|
|
+ */
|
|
|
+
|
|
|
+ URI.removeDotSegments = function (input) {
|
|
|
+ var output = [], s;
|
|
|
+
|
|
|
+ while (input.length) {
|
|
|
+ if (input.match(RDS1)) {
|
|
|
+ input = input.replace(RDS1, "");
|
|
|
+ } else if (input.match(RDS2)) {
|
|
|
+ input = input.replace(RDS2, "/");
|
|
|
+ } else if (input.match(RDS3)) {
|
|
|
+ input = input.replace(RDS3, "/");
|
|
|
+ output.pop();
|
|
|
+ } else if (input === "." || input === "..") {
|
|
|
+ input = "";
|
|
|
+ } else {
|
|
|
+ s = input.match(RDS5)[0];
|
|
|
+ input = input.slice(s.length);
|
|
|
+ output.push(s);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return output.join("");
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {URIComponents} components
|
|
|
+ * @param {Options} [options]
|
|
|
+ * @returns {string}
|
|
|
+ */
|
|
|
+
|
|
|
+ URI.serialize = function (components, options) {
|
|
|
+ var uriTokens = [],
|
|
|
+ schemeHandler,
|
|
|
+ s;
|
|
|
+ options = options || {};
|
|
|
+
|
|
|
+ //check if a handler for the scheme exists
|
|
|
+ schemeHandler = URI.SCHEMES[components.scheme || options.scheme];
|
|
|
+ if (schemeHandler && schemeHandler.serialize) {
|
|
|
+ //perform extra serialization
|
|
|
+ schemeHandler.serialize(components, options);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (options.reference !== "suffix" && components.scheme) {
|
|
|
+ uriTokens.push(components.scheme.toString().toLowerCase().replace(NOT_SCHEME, ""));
|
|
|
+ uriTokens.push(":");
|
|
|
+ }
|
|
|
+
|
|
|
+ components.authority = URI._recomposeAuthority(components);
|
|
|
+ if (components.authority !== undefined) {
|
|
|
+ if (options.reference !== "suffix") {
|
|
|
+ uriTokens.push("//");
|
|
|
+ }
|
|
|
+
|
|
|
+ uriTokens.push(components.authority);
|
|
|
+
|
|
|
+ if (components.path && components.path.charAt(0) !== "/") {
|
|
|
+ uriTokens.push("/");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (components.path) {
|
|
|
+ s = URI.removeDotSegments(components.path.toString().replace(/%2E/ig, "."));
|
|
|
+
|
|
|
+ if (components.scheme) {
|
|
|
+ s = s.replace(NOT_PATH, pctEncChar);
|
|
|
+ } else {
|
|
|
+ s = s.replace(NOT_PATH_NOSCHEME, pctEncChar);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (components.authority === undefined) {
|
|
|
+ s = s.replace(/^\/\//, "/%2F"); //don't allow the path to start with "//"
|
|
|
+ }
|
|
|
+ uriTokens.push(s);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (components.query) {
|
|
|
+ uriTokens.push("?");
|
|
|
+ uriTokens.push(components.query.toString().replace(NOT_QUERY, pctEncChar));
|
|
|
+ }
|
|
|
+
|
|
|
+ if (components.fragment) {
|
|
|
+ uriTokens.push("#");
|
|
|
+ uriTokens.push(components.fragment.toString().replace(NOT_FRAGMENT, pctEncChar));
|
|
|
+ }
|
|
|
+
|
|
|
+ return uriTokens
|
|
|
+ .join('') //merge tokens into a string
|
|
|
+ .replace(PCT_ENCODEDS, pctDecUnreserved) //undecode unreserved characters
|
|
|
+ //.replace(OTHER_CHARS, pctEncChar) //replace non-URI characters
|
|
|
+ .replace(/%[0-9A-Fa-f]{2}/g, function (str) { //uppercase percent encoded characters
|
|
|
+ return str.toUpperCase();
|
|
|
+ })
|
|
|
+ ;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {URIComponents} base
|
|
|
+ * @param {URIComponents} relative
|
|
|
+ * @param {Options} [options]
|
|
|
+ * @param {boolean} [skipNormalization]
|
|
|
+ * @returns {URIComponents}
|
|
|
+ */
|
|
|
+
|
|
|
+ URI.resolveComponents = function (base, relative, options, skipNormalization) {
|
|
|
+ var target = new Components();
|
|
|
+
|
|
|
+ if (!skipNormalization) {
|
|
|
+ base = URI.parse(URI.serialize(base, options), options); //normalize base components
|
|
|
+ relative = URI.parse(URI.serialize(relative, options), options); //normalize relative components
|
|
|
+ }
|
|
|
+ options = options || {};
|
|
|
+
|
|
|
+ if (!options.tolerant && relative.scheme) {
|
|
|
+ target.scheme = relative.scheme;
|
|
|
+ target.authority = relative.authority;
|
|
|
+ target.userinfo = relative.userinfo;
|
|
|
+ target.host = relative.host;
|
|
|
+ target.port = relative.port;
|
|
|
+ target.path = URI.removeDotSegments(relative.path);
|
|
|
+ target.query = relative.query;
|
|
|
+ } else {
|
|
|
+ if (relative.authority !== undefined) {
|
|
|
+ target.authority = relative.authority;
|
|
|
+ target.userinfo = relative.userinfo;
|
|
|
+ target.host = relative.host;
|
|
|
+ target.port = relative.port;
|
|
|
+ target.path = URI.removeDotSegments(relative.path);
|
|
|
+ target.query = relative.query;
|
|
|
+ } else {
|
|
|
+ if (!relative.path) {
|
|
|
+ target.path = base.path;
|
|
|
+ if (relative.query !== undefined) {
|
|
|
+ target.query = relative.query;
|
|
|
+ } else {
|
|
|
+ target.query = base.query;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (relative.path.charAt(0) === "/") {
|
|
|
+ target.path = URI.removeDotSegments(relative.path);
|
|
|
+ } else {
|
|
|
+ if (base.authority !== undefined && !base.path) {
|
|
|
+ target.path = "/" + relative.path;
|
|
|
+ } else if (!base.path) {
|
|
|
+ target.path = relative.path;
|
|
|
+ } else {
|
|
|
+ target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative.path;
|
|
|
+ }
|
|
|
+ target.path = URI.removeDotSegments(target.path);
|
|
|
+ }
|
|
|
+ target.query = relative.query;
|
|
|
+ }
|
|
|
+ target.authority = base.authority;
|
|
|
+ target.userinfo = base.userinfo;
|
|
|
+ target.host = base.host;
|
|
|
+ target.port = base.port;
|
|
|
+ }
|
|
|
+ target.scheme = base.scheme;
|
|
|
+ }
|
|
|
+
|
|
|
+ target.fragment = relative.fragment;
|
|
|
+
|
|
|
+ return target;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {string} baseURI
|
|
|
+ * @param {string} relativeURI
|
|
|
+ * @param {Options} [options]
|
|
|
+ * @returns {string}
|
|
|
+ */
|
|
|
+
|
|
|
+ URI.resolve = function (baseURI, relativeURI, options) {
|
|
|
+ return URI.serialize(URI.resolveComponents(URI.parse(baseURI, options), URI.parse(relativeURI, options), options, true), options);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {string|URIComponents} uri
|
|
|
+ * @param {Options} options
|
|
|
+ * @returns {string|URIComponents}
|
|
|
+ */
|
|
|
+
|
|
|
+ URI.normalize = function (uri, options) {
|
|
|
+ if (typeof uri === "string") {
|
|
|
+ return URI.serialize(URI.parse(uri, options), options);
|
|
|
+ } else if (typeOf(uri) === "object") {
|
|
|
+ return URI.parse(URI.serialize(uri, options), options);
|
|
|
+ }
|
|
|
+
|
|
|
+ return uri;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {string|URIComponents} uriA
|
|
|
+ * @param {string|URIComponents} uriB
|
|
|
+ * @param {Options} options
|
|
|
+ */
|
|
|
+
|
|
|
+ URI.equal = function (uriA, uriB, options) {
|
|
|
+ if (typeof uriA === "string") {
|
|
|
+ uriA = URI.serialize(URI.parse(uriA, options), options);
|
|
|
+ } else if (typeOf(uriA) === "object") {
|
|
|
+ uriA = URI.serialize(uriA, options);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (typeof uriB === "string") {
|
|
|
+ uriB = URI.serialize(URI.parse(uriB, options), options);
|
|
|
+ } else if (typeOf(uriB) === "object") {
|
|
|
+ uriB = URI.serialize(uriB, options);
|
|
|
+ }
|
|
|
+
|
|
|
+ return uriA === uriB;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {string} str
|
|
|
+ * @returns {string}
|
|
|
+ */
|
|
|
+
|
|
|
+ URI.escapeComponent = function (str) {
|
|
|
+ return str && str.toString().replace(ESCAPE, pctEncChar);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @param {string} str
|
|
|
+ * @returns {string}
|
|
|
+ */
|
|
|
+
|
|
|
+ URI.unescapeComponent = function (str) {
|
|
|
+ return str && str.toString().replace(PCT_ENCODEDS, pctDecChars);
|
|
|
+ };
|
|
|
+
|
|
|
+ //export API
|
|
|
+ exports.Components = Components;
|
|
|
+ exports.URI = URI;
|
|
|
+
|
|
|
+ //name-safe export API
|
|
|
+ exports["URI"] = {
|
|
|
+ "SCHEMES" : URI.SCHEMES,
|
|
|
+ "parse" : URI.parse,
|
|
|
+ "removeDotSegments" : URI.removeDotSegments,
|
|
|
+ "serialize" : URI.serialize,
|
|
|
+ "resolveComponents" : URI.resolveComponents,
|
|
|
+ "resolve" : URI.resolve,
|
|
|
+ "normalize" : URI.normalize,
|
|
|
+ "equal" : URI.equal,
|
|
|
+ "escapeComponent" : URI.escapeComponent,
|
|
|
+ "unescapeComponent" : URI.unescapeComponent
|
|
|
+ };
|
|
|
+
|
|
|
+}());
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ /**
|
|
|
+ * JSV: JSON Schema Validator
|
|
|
+ *
|
|
|
+ * @fileOverview A JavaScript implementation of a extendable, fully compliant JSON Schema validator.
|
|
|
+ * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
|
|
|
+ * @version 3.5
|
|
|
+ * @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 */
|
|
|
+
|
|
|
+var exports = exports || this,
|
|
|
+ require = require || function () {
|
|
|
+ return exports;
|
|
|
+ };
|
|
|
+
|
|
|
+(function () {
|
|
|
+
|
|
|
+ var URI = require("./uri/uri").URI,
|
|
|
+ O = {},
|
|
|
+ I2H = "0123456789abcdef".split(""),
|
|
|
+ mapArray, filterArray, searchArray,
|
|
|
+
|
|
|
+ JSV;
|
|
|
+
|
|
|
+ //
|
|
|
+ // Utility functions
|
|
|
+ //
|
|
|
+
|
|
|
+ function typeOf(o) {
|
|
|
+ return o === undefined ? "undefined" : (o === null ? "null" : Object.prototype.toString.call(o).split(" ").pop().split("]").shift().toLowerCase());
|
|
|
+ }
|
|
|
+
|
|
|
+ /** @inner */
|
|
|
+ function F() {}
|
|
|
+
|
|
|
+ function createObject(proto) {
|
|
|
+ F.prototype = proto || {};
|
|
|
+ return new F();
|
|
|
+ }
|
|
|
+
|
|
|
+ function mapObject(obj, func, scope) {
|
|
|
+ var newObj = {}, key;
|
|
|
+ for (key in obj) {
|
|
|
+ if (obj[key] !== O[key]) {
|
|
|
+ newObj[key] = func.call(scope, obj[key], key, obj);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return newObj;
|
|
|
+ }
|
|
|
+
|
|
|
+ /** @ignore */
|
|
|
+ mapArray = function (arr, func, scope) {
|
|
|
+ var x = 0, xl = arr.length, newArr = new Array(xl);
|
|
|
+ for (; x < xl; ++x) {
|
|
|
+ newArr[x] = func.call(scope, arr[x], x, arr);
|
|
|
+ }
|
|
|
+ return newArr;
|
|
|
+ };
|
|
|
+
|
|
|
+ if (Array.prototype.map) {
|
|
|
+ /** @ignore */
|
|
|
+ mapArray = function (arr, func, scope) {
|
|
|
+ return Array.prototype.map.call(arr, func, scope);
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ /** @ignore */
|
|
|
+ filterArray = function (arr, func, scope) {
|
|
|
+ var x = 0, xl = arr.length, newArr = [];
|
|
|
+ for (; x < xl; ++x) {
|
|
|
+ if (func.call(scope, arr[x], x, arr)) {
|
|
|
+ newArr[newArr.length] = arr[x];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return newArr;
|
|
|
+ };
|
|
|
+
|
|
|
+ if (Array.prototype.filter) {
|
|
|
+ /** @ignore */
|
|
|
+ filterArray = function (arr, func, scope) {
|
|
|
+ return Array.prototype.filter.call(arr, func, scope);
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ /** @ignore */
|
|
|
+ searchArray = function (arr, o) {
|
|
|
+ var x = 0, xl = arr.length;
|
|
|
+ for (; x < xl; ++x) {
|
|
|
+ if (arr[x] === o) {
|
|
|
+ return x;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return -1;
|
|
|
+ };
|
|
|
+
|
|
|
+ if (Array.prototype.indexOf) {
|
|
|
+ /** @ignore */
|
|
|
+ searchArray = function (arr, o) {
|
|
|
+ return Array.prototype.indexOf.call(arr, o);
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ function toArray(o) {
|
|
|
+ return o !== undefined && o !== null ? (o instanceof Array && !o.callee ? o : (typeof o.length !== "number" || o.split || o.setInterval || o.call ? [ o ] : Array.prototype.slice.call(o))) : [];
|
|
|
+ }
|
|
|
+
|
|
|
+ function keys(o) {
|
|
|
+ var result = [], key;
|
|
|
+
|
|
|
+ switch (typeOf(o)) {
|
|
|
+ case "object":
|
|
|
+ for (key in o) {
|
|
|
+ if (o[key] !== O[key]) {
|
|
|
+ result[result.length] = key;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case "array":
|
|
|
+ for (key = o.length - 1; key >= 0; --key) {
|
|
|
+ result[key] = key;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ function pushUnique(arr, o) {
|
|
|
+ if (searchArray(arr, o) === -1) {
|
|
|
+ arr.push(o);
|
|
|
+ }
|
|
|
+ return arr;
|
|
|
+ }
|
|
|
+
|
|
|
+ function popFirst(arr, o) {
|
|
|
+ var index = searchArray(arr, o);
|
|
|
+ if (index > -1) {
|
|
|
+ arr.splice(index, 1);
|
|
|
+ }
|
|
|
+ return arr;
|
|
|
+ }
|
|
|
+
|
|
|
+ function randomUUID() {
|
|
|
+ return [
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ "-",
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ "-4", //set 4 high bits of time_high field to version
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ "-",
|
|
|
+ I2H[(Math.floor(Math.random() * 0x10) & 0x3) | 0x8], //specify 2 high bits of clock sequence
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ "-",
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)],
|
|
|
+ I2H[Math.floor(Math.random() * 0x10)]
|
|
|
+ ].join("");
|
|
|
+ }
|
|
|
+
|
|
|
+ function escapeURIComponent(str) {
|
|
|
+ return encodeURIComponent(str).replace(/!/g, '%21').replace(/'/g, '%27').replace(/\(/g, '%28').replace(/\)/g, '%29').replace(/\*/g, '%2A');
|
|
|
+ }
|
|
|
+
|
|
|
+ function formatURI(uri) {
|
|
|
+ if (typeof uri === "string" && uri.indexOf("#") === -1) {
|
|
|
+ uri += "#";
|
|
|
+ }
|
|
|
+ return uri;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Defines an error, found by a schema, with an instance.
|
|
|
+ * This class can only be instantiated by {@link Report#addError}.
|
|
|
+ *
|
|
|
+ * @name ValidationError
|
|
|
+ * @class
|
|
|
+ * @see Report#addError
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The URI of the instance that has the error.
|
|
|
+ *
|
|
|
+ * @name ValidationError.prototype.uri
|
|
|
+ * @type String
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The URI of the schema that generated the error.
|
|
|
+ *
|
|
|
+ * @name ValidationError.prototype.schemaUri
|
|
|
+ * @type String
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The name of the schema attribute that generated the error.
|
|
|
+ *
|
|
|
+ * @name ValidationError.prototype.attribute
|
|
|
+ * @type String
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * An user-friendly (English) message about what failed to validate.
|
|
|
+ *
|
|
|
+ * @name ValidationError.prototype.message
|
|
|
+ * @type String
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * The value of the schema attribute that generated the error.
|
|
|
+ *
|
|
|
+ * @name ValidationError.prototype.details
|
|
|
+ * @type Any
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Reports are returned from validation methods to describe the result of a validation.
|
|
|
+ *
|
|
|
+ * @name Report
|
|
|
+ * @class
|
|
|
+ * @see JSONSchema#validate
|
|
|
+ * @see Environment#validate
|
|
|
+ */
|
|
|
+
|
|
|
+ function Report() {
|
|
|
+ /**
|
|
|
+ * An array of {@link ValidationError} objects that define all the errors generated by the schema against the instance.
|
|
|
+ *
|
|
|
+ * @name Report.prototype.errors
|
|
|
+ * @type Array
|
|
|
+ * @see Report#addError
|
|
|
+ */
|
|
|
+ this.errors = [];
|
|
|
+
|
|
|
+ /**
|
|
|
+ * A hash table of every instance and what schemas were validated against it.
|
|
|
+ * <p>
|
|
|
+ * The key of each item in the table is the URI of the instance that was validated.
|
|
|
+ * The value of this key is an array of strings of URIs of the schema that validated it.
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @name Report.prototype.validated
|
|
|
+ * @type Object
|
|
|
+ * @see Report#registerValidation
|
|
|
+ * @see Report#isValidatedBy
|
|
|
+ */
|
|
|
+ this.validated = {};
|
|
|
+
|
|
|
+ /**
|
|
|
+ * If the report is generated by {@link Environment#validate}, this field is the generated instance.
|
|
|
+ *
|
|
|
+ * @name Report.prototype.instance
|
|
|
+ * @type JSONInstance
|
|
|
+ * @see Environment#validate
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * If the report is generated by {@link Environment#validate}, this field is the generated schema.
|
|
|
+ *
|
|
|
+ * @name Report.prototype.schema
|
|
|
+ * @type JSONSchema
|
|
|
+ * @see Environment#validate
|
|
|
+ */
|
|
|
+
|
|
|
+ /**
|
|
|
+ * If the report is generated by {@link Environment#validate}, this field is the schema's schema.
|
|
|
+ * This value is the same as calling <code>schema.getSchema()</code>.
|
|
|
+ *
|
|
|
+ * @name Report.prototype.schemaSchema
|
|
|
+ * @type JSONSchema
|
|
|
+ * @see Environment#validate
|
|
|
+ * @see JSONSchema#getSchema
|
|
|
+ */
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Adds a {@link ValidationError} object to the <a href="#errors"><code>errors</code></a> field.
|
|
|
+ *
|
|
|
+ * @param {JSONInstance|String} instance The instance (or instance URI) that is invalid
|
|
|
+ * @param {JSONSchema|String} schema The schema (or schema URI) that was validating the instance
|
|
|
+ * @param {String} attr The attribute that failed to validated
|
|
|
+ * @param {String} message A user-friendly message on why the schema attribute failed to validate the instance
|
|
|
+ * @param {Any} details The value of the schema attribute
|
|
|
+ */
|
|
|
+
|
|
|
+ Report.prototype.addError = function (instance, schema, attr, message, details) {
|
|
|
+ this.errors.push({
|
|
|
+ uri : instance instanceof JSONInstance ? instance.getURI() : instance,
|
|
|
+ schemaUri : schema instanceof JSONInstance ? schema.getURI() : schema,
|
|
|
+ attribute : attr,
|
|
|
+ message : message,
|
|
|
+ details : details
|
|
|
+ });
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Registers that the provided instance URI has been validated by the provided schema URI.
|
|
|
+ * This is recorded in the <a href="#validated"><code>validated</code></a> field.
|
|
|
+ *
|
|
|
+ * @param {String} uri The URI of the instance that was validated
|
|
|
+ * @param {String} schemaUri The URI of the schema that validated the instance
|
|
|
+ */
|
|
|
+
|
|
|
+ Report.prototype.registerValidation = function (uri, schemaUri) {
|
|
|
+ if (!this.validated[uri]) {
|
|
|
+ this.validated[uri] = [ schemaUri ];
|
|
|
+ } else {
|
|
|
+ this.validated[uri].push(schemaUri);
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns if an instance with the provided URI has been validated by the schema with the provided URI.
|
|
|
+ *
|
|
|
+ * @param {String} uri The URI of the instance
|
|
|
+ * @param {String} schemaUri The URI of a schema
|
|
|
+ * @returns {Boolean} If the instance has been validated by the schema.
|
|
|
+ */
|
|
|
+
|
|
|
+ Report.prototype.isValidatedBy = function (uri, schemaUri) {
|
|
|
+ return !!this.validated[uri] && searchArray(this.validated[uri], schemaUri) !== -1;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * A wrapper class for binding an Environment, URI and helper methods to an instance.
|
|
|
+ * This class is most commonly instantiated with {@link Environment#createInstance}.
|
|
|
+ *
|
|
|
+ * @name JSONInstance
|
|
|
+ * @class
|
|
|
+ * @param {Environment} env The environment this instance belongs to
|
|
|
+ * @param {JSONInstance|Any} json The value of the instance
|
|
|
+ * @param {String} [uri] The URI of the instance. If undefined, the URI will be a randomly generated UUID.
|
|
|
+ * @param {String} [fd] The fragment delimiter for properties. If undefined, uses the environment default.
|
|
|
+ */
|
|
|
+
|
|
|
+ function JSONInstance(env, json, uri, fd) {
|
|
|
+ if (json instanceof JSONInstance) {
|
|
|
+ if (typeof fd !== "string") {
|
|
|
+ fd = json._fd;
|
|
|
+ }
|
|
|
+ if (typeof uri !== "string") {
|
|
|
+ uri = json._uri;
|
|
|
+ }
|
|
|
+ json = json._value;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (typeof uri !== "string") {
|
|
|
+ uri = "urn:uuid:" + randomUUID() + "#";
|
|
|
+ } else if (uri.indexOf(":") === -1) {
|
|
|
+ uri = formatURI(URI.resolve("urn:uuid:" + randomUUID() + "#", uri));
|
|
|
+ }
|
|
|
+
|
|
|
+ this._env = env;
|
|
|
+ this._value = json;
|
|
|
+ this._uri = uri;
|
|
|
+ this._fd = fd || this._env._options["defaultFragmentDelimiter"];
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the environment the instance is bound to.
|
|
|
+ *
|
|
|
+ * @returns {Environment} The environment of the instance
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONInstance.prototype.getEnvironment = function () {
|
|
|
+ return this._env;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the name of the type of the instance.
|
|
|
+ *
|
|
|
+ * @returns {String} The name of the type of the instance
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONInstance.prototype.getType = function () {
|
|
|
+ return typeOf(this._value);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the JSON value of the instance.
|
|
|
+ *
|
|
|
+ * @returns {Any} The actual JavaScript value of the instance
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONInstance.prototype.getValue = function () {
|
|
|
+ return this._value;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the URI of the instance.
|
|
|
+ *
|
|
|
+ * @returns {String} The URI of the instance
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONInstance.prototype.getURI = function () {
|
|
|
+ return this._uri;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns a resolved URI of a provided relative URI against the URI of the instance.
|
|
|
+ *
|
|
|
+ * @param {String} uri The relative URI to resolve
|
|
|
+ * @returns {String} The resolved URI
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONInstance.prototype.resolveURI = function (uri) {
|
|
|
+ return formatURI(URI.resolve(this._uri, uri));
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns an array of the names of all the properties.
|
|
|
+ *
|
|
|
+ * @returns {Array} An array of strings which are the names of all the properties
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONInstance.prototype.getPropertyNames = function () {
|
|
|
+ return keys(this._value);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns a {@link JSONInstance} of the value of the provided property name.
|
|
|
+ *
|
|
|
+ * @param {String} key The name of the property to fetch
|
|
|
+ * @returns {JSONInstance} The instance of the property value
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONInstance.prototype.getProperty = function (key) {
|
|
|
+ var value = this._value ? this._value[key] : undefined;
|
|
|
+ if (value instanceof JSONInstance) {
|
|
|
+ return value;
|
|
|
+ }
|
|
|
+ //else
|
|
|
+ return new JSONInstance(this._env, value, this._uri + this._fd + escapeURIComponent(key), this._fd);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns all the property instances of the target instance.
|
|
|
+ * <p>
|
|
|
+ * If the target instance is an Object, then the method will return a hash table of {@link JSONInstance}s of all the properties.
|
|
|
+ * If the target instance is an Array, then the method will return an array of {@link JSONInstance}s of all the items.
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @returns {Object|Array|undefined} The list of instances for all the properties
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONInstance.prototype.getProperties = function () {
|
|
|
+ var type = typeOf(this._value),
|
|
|
+ self = this;
|
|
|
+
|
|
|
+ if (type === "object") {
|
|
|
+ return mapObject(this._value, function (value, key) {
|
|
|
+ if (value instanceof JSONInstance) {
|
|
|
+ return value;
|
|
|
+ }
|
|
|
+ return new JSONInstance(self._env, value, self._uri + self._fd + escapeURIComponent(key), self._fd);
|
|
|
+ });
|
|
|
+ } else if (type === "array") {
|
|
|
+ return mapArray(this._value, function (value, key) {
|
|
|
+ if (value instanceof JSONInstance) {
|
|
|
+ return value;
|
|
|
+ }
|
|
|
+ return new JSONInstance(self._env, value, self._uri + self._fd + escapeURIComponent(key), self._fd);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the JSON value of the provided property name.
|
|
|
+ * This method is a faster version of calling <code>instance.getProperty(key).getValue()</code>.
|
|
|
+ *
|
|
|
+ * @param {String} key The name of the property
|
|
|
+ * @returns {Any} The JavaScript value of the instance
|
|
|
+ * @see JSONInstance#getProperty
|
|
|
+ * @see JSONInstance#getValue
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONInstance.prototype.getValueOfProperty = function (key) {
|
|
|
+ if (this._value) {
|
|
|
+ if (this._value[key] instanceof JSONInstance) {
|
|
|
+ return this._value[key]._value;
|
|
|
+ }
|
|
|
+ return this._value[key];
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Return if the provided value is the same as the value of the instance.
|
|
|
+ *
|
|
|
+ * @param {JSONInstance|Any} instance The value to compare
|
|
|
+ * @returns {Boolean} If both the instance and the value match
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONInstance.prototype.equals = function (instance) {
|
|
|
+ if (instance instanceof JSONInstance) {
|
|
|
+ return this._value === instance._value;
|
|
|
+ }
|
|
|
+ //else
|
|
|
+ return this._value === instance;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Warning: Not a generic clone function
|
|
|
+ * Produces a JSV acceptable clone
|
|
|
+ */
|
|
|
+
|
|
|
+ function clone(obj, deep) {
|
|
|
+ var newObj, x;
|
|
|
+
|
|
|
+ if (obj instanceof JSONInstance) {
|
|
|
+ obj = obj.getValue();
|
|
|
+ }
|
|
|
+
|
|
|
+ switch (typeOf(obj)) {
|
|
|
+ case "object":
|
|
|
+ if (deep) {
|
|
|
+ newObj = {};
|
|
|
+ for (x in obj) {
|
|
|
+ if (obj[x] !== O[x]) {
|
|
|
+ newObj[x] = clone(obj[x], deep);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return newObj;
|
|
|
+ } else {
|
|
|
+ return createObject(obj);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case "array":
|
|
|
+ if (deep) {
|
|
|
+ newObj = new Array(obj.length);
|
|
|
+ x = obj.length;
|
|
|
+ while (--x >= 0) {
|
|
|
+ newObj[x] = clone(obj[x], deep);
|
|
|
+ }
|
|
|
+ return newObj;
|
|
|
+ } else {
|
|
|
+ return Array.prototype.slice.call(obj);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ return obj;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * This class binds a {@link JSONInstance} with a {@link JSONSchema} to provided context aware methods.
|
|
|
+ *
|
|
|
+ * @name JSONSchema
|
|
|
+ * @class
|
|
|
+ * @param {Environment} env The environment this schema belongs to
|
|
|
+ * @param {JSONInstance|Any} json The value of the schema
|
|
|
+ * @param {String} [uri] The URI of the schema. If undefined, the URI will be a randomly generated UUID.
|
|
|
+ * @param {JSONSchema|Boolean} [schema] The schema to bind to the instance. If <code>undefined</code>, the environment's default schema will be used. If <code>true</code>, the instance's schema will be itself.
|
|
|
+ * @extends JSONInstance
|
|
|
+ */
|
|
|
+
|
|
|
+ function JSONSchema(env, json, uri, schema) {
|
|
|
+ var fr;
|
|
|
+ JSONInstance.call(this, env, json, uri);
|
|
|
+
|
|
|
+ if (schema === true) {
|
|
|
+ this._schema = this;
|
|
|
+ } else if (json instanceof JSONSchema && !(schema instanceof JSONSchema)) {
|
|
|
+ this._schema = json._schema; //TODO: Make sure cross environments don't mess everything up
|
|
|
+ } else {
|
|
|
+ this._schema = schema instanceof JSONSchema ? schema : this._env.getDefaultSchema() || JSONSchema.createEmptySchema(this._env);
|
|
|
+ }
|
|
|
+
|
|
|
+ //determine fragment delimiter from schema
|
|
|
+ fr = this._schema.getValueOfProperty("fragmentResolution");
|
|
|
+ if (fr === "dot-delimited") {
|
|
|
+ this._fd = ".";
|
|
|
+ } else if (fr === "slash-delimited") {
|
|
|
+ this._fd = "/";
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ JSONSchema.prototype = createObject(JSONInstance.prototype);
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates an empty schema.
|
|
|
+ *
|
|
|
+ * @param {Environment} env The environment of the schema
|
|
|
+ * @returns {JSONSchema} The empty schema, who's schema is itself.
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONSchema.createEmptySchema = function (env) {
|
|
|
+ var schema = createObject(JSONSchema.prototype);
|
|
|
+ JSONInstance.call(schema, env, {}, undefined, undefined);
|
|
|
+ schema._schema = schema;
|
|
|
+ return schema;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the schema of the schema.
|
|
|
+ *
|
|
|
+ * @returns {JSONSchema} The schema of the schema
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONSchema.prototype.getSchema = function () {
|
|
|
+ return this._schema;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the value of the provided attribute name.
|
|
|
+ * <p>
|
|
|
+ * This method is different from {@link JSONInstance#getProperty} as the named property
|
|
|
+ * is converted using a parser defined by the schema's schema before being returned. This
|
|
|
+ * makes the return value of this method attribute dependent.
|
|
|
+ * </p>
|
|
|
+ *
|
|
|
+ * @param {String} key The name of the attribute
|
|
|
+ * @param {Any} [arg] Some attribute parsers accept special arguments for returning resolved values. This is attribute dependent.
|
|
|
+ * @returns {JSONSchema|Any} The value of the attribute
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONSchema.prototype.getAttribute = function (key, arg) {
|
|
|
+ var schemaProperty, parser, property, result;
|
|
|
+
|
|
|
+ if (!arg && this._attributes && this._attributes.hasOwnProperty(key)) {
|
|
|
+ return this._attributes[key];
|
|
|
+ }
|
|
|
+
|
|
|
+ schemaProperty = this._schema.getProperty("properties").getProperty(key);
|
|
|
+ parser = schemaProperty.getValueOfProperty("parser");
|
|
|
+ property = this.getProperty(key);
|
|
|
+ if (typeof parser === "function") {
|
|
|
+ result = parser(property, schemaProperty, arg);
|
|
|
+ if (!arg && this._attributes) {
|
|
|
+ this._attributes[key] = result;
|
|
|
+ }
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+ //else
|
|
|
+ return property.getValue();
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns all the attributes of the schema.
|
|
|
+ *
|
|
|
+ * @returns {Object} A map of all parsed attribute values
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONSchema.prototype.getAttributes = function () {
|
|
|
+ var properties, schemaProperties, key, schemaProperty, parser;
|
|
|
+
|
|
|
+ if (!this._attributes && this.getType() === "object") {
|
|
|
+ properties = this.getProperties();
|
|
|
+ schemaProperties = this._schema.getProperty("properties");
|
|
|
+ this._attributes = {};
|
|
|
+ for (key in properties) {
|
|
|
+ if (properties[key] !== O[key]) {
|
|
|
+ schemaProperty = schemaProperties && schemaProperties.getProperty(key);
|
|
|
+ parser = schemaProperty && schemaProperty.getValueOfProperty("parser");
|
|
|
+ if (typeof parser === "function") {
|
|
|
+ this._attributes[key] = parser(properties[key], schemaProperty);
|
|
|
+ } else {
|
|
|
+ this._attributes[key] = properties[key].getValue();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return clone(this._attributes, false);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Convenience method for retrieving a link or link object from a schema.
|
|
|
+ * This method is the same as calling <code>schema.getAttribute("links", [rel, instance])[0];</code>.
|
|
|
+ *
|
|
|
+ * @param {String} rel The link relationship
|
|
|
+ * @param {JSONInstance} [instance] The instance to resolve any URIs from
|
|
|
+ * @returns {String|Object|undefined} If <code>instance</code> is provided, a string containing the resolve URI of the link is returned.
|
|
|
+ * If <code>instance</code> is not provided, a link object is returned with details of the link.
|
|
|
+ * If no link with the provided relationship exists, <code>undefined</code> is returned.
|
|
|
+ * @see JSONSchema#getAttribute
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONSchema.prototype.getLink = function (rel, instance) {
|
|
|
+ var schemaLinks = this.getAttribute("links", [rel, instance]);
|
|
|
+ if (schemaLinks && schemaLinks.length && schemaLinks[schemaLinks.length - 1]) {
|
|
|
+ return schemaLinks[schemaLinks.length - 1];
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Validates the provided instance against the target schema and returns a {@link Report}.
|
|
|
+ *
|
|
|
+ * @param {JSONInstance|Any} instance The instance to validate; may be a {@link JSONInstance} or any JavaScript value
|
|
|
+ * @param {Report} [report] A {@link Report} to concatenate the result of the validation to. If <code>undefined</code>, a new {@link Report} is created.
|
|
|
+ * @param {JSONInstance} [parent] The parent/containing instance of the provided instance
|
|
|
+ * @param {JSONSchema} [parentSchema] The schema of the parent/containing instance
|
|
|
+ * @param {String} [name] The name of the parent object's property that references the instance
|
|
|
+ * @returns {Report} The result of the validation
|
|
|
+ */
|
|
|
+
|
|
|
+ JSONSchema.prototype.validate = function (instance, report, parent, parentSchema, name) {
|
|
|
+ var validator = this._schema.getValueOfProperty("validator");
|
|
|
+
|
|
|
+ if (!(instance instanceof JSONInstance)) {
|
|
|
+ instance = this.getEnvironment().createInstance(instance);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!(report instanceof Report)) {
|
|
|
+ report = new Report();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (typeof validator === "function" && !report.isValidatedBy(instance.getURI(), this.getURI())) {
|
|
|
+ report.registerValidation(instance.getURI(), this.getURI());
|
|
|
+ validator(instance, this, this._schema, report, parent, parentSchema, name);
|
|
|
+ }
|
|
|
+
|
|
|
+ return report;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Merges two schemas/instances together.
|
|
|
+ */
|
|
|
+
|
|
|
+ function inherits(base, extra, extension) {
|
|
|
+ var baseType = typeOf(base),
|
|
|
+ extraType = typeOf(extra),
|
|
|
+ child, x;
|
|
|
+
|
|
|
+ if (extraType === "undefined") {
|
|
|
+ return clone(base, true);
|
|
|
+ } else if (baseType === "undefined" || extraType !== baseType) {
|
|
|
+ return clone(extra, true);
|
|
|
+ } else if (extraType === "object") {
|
|
|
+ if (base instanceof JSONSchema) {
|
|
|
+ base = base.getAttributes();
|
|
|
+ }
|
|
|
+ if (extra instanceof JSONSchema) {
|
|
|
+ extra = extra.getAttributes();
|
|
|
+ if (extra["extends"] && extension && extra["extends"] instanceof JSONSchema) {
|
|
|
+ extra["extends"] = [ extra["extends"] ];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ child = clone(base, true); //this could be optimized as some properties get overwritten
|
|
|
+ for (x in extra) {
|
|
|
+ if (extra[x] !== O[x]) {
|
|
|
+ child[x] = inherits(base[x], extra[x], extension);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return child;
|
|
|
+ } else {
|
|
|
+ return clone(extra, true);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * An Environment is a sandbox of schemas thats behavior is different from other environments.
|
|
|
+ *
|
|
|
+ * @name Environment
|
|
|
+ * @class
|
|
|
+ */
|
|
|
+
|
|
|
+ function Environment() {
|
|
|
+ this._id = randomUUID();
|
|
|
+ this._schemas = {};
|
|
|
+ this._options = {};
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns a clone of the target environment.
|
|
|
+ *
|
|
|
+ * @returns {Environment} A new {@link Environment} that is a exact copy of the target environment
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.clone = function () {
|
|
|
+ var env = new Environment();
|
|
|
+ env._schemas = createObject(this._schemas);
|
|
|
+ env._options = createObject(this._options);
|
|
|
+
|
|
|
+ return env;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns a new {@link JSONInstance} of the provided data.
|
|
|
+ *
|
|
|
+ * @param {JSONInstance|Any} data The value of the instance
|
|
|
+ * @param {String} [uri] The URI of the instance. If undefined, the URI will be a randomly generated UUID.
|
|
|
+ * @returns {JSONInstance} A new {@link JSONInstance} from the provided data
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.createInstance = function (data, uri) {
|
|
|
+ var instance;
|
|
|
+ uri = formatURI(uri);
|
|
|
+
|
|
|
+ if (data instanceof JSONInstance && (!uri || data.getURI() === uri)) {
|
|
|
+ return data;
|
|
|
+ }
|
|
|
+ //else
|
|
|
+ instance = new JSONInstance(this, data, uri);
|
|
|
+
|
|
|
+ return instance;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates a new {@link JSONSchema} from the provided data, and registers it with the environment.
|
|
|
+ *
|
|
|
+ * @param {JSONInstance|Any} data The value of the schema
|
|
|
+ * @param {JSONSchema|Boolean} [schema] The schema to bind to the instance. If <code>undefined</code>, the environment's default schema will be used. If <code>true</code>, the instance's schema will be itself.
|
|
|
+ * @param {String} [uri] The URI of the schema. If undefined, the URI will be a randomly generated UUID.
|
|
|
+ * @returns {JSONSchema} A new {@link JSONSchema} from the provided data
|
|
|
+ * @throws {InitializationError} If a schema that is not registered with the environment is referenced
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.createSchema = function (data, schema, uri) {
|
|
|
+ var instance,
|
|
|
+ initializer;
|
|
|
+ uri = formatURI(uri);
|
|
|
+
|
|
|
+ if (data instanceof JSONSchema && (!uri || data._uri === uri) && (!schema || data._schema.equals(schema))) {
|
|
|
+ return data;
|
|
|
+ }
|
|
|
+
|
|
|
+ instance = new JSONSchema(this, data, uri, schema);
|
|
|
+
|
|
|
+ initializer = instance.getSchema().getValueOfProperty("initializer");
|
|
|
+ if (typeof initializer === "function") {
|
|
|
+ instance = initializer(instance);
|
|
|
+ }
|
|
|
+
|
|
|
+ //register schema
|
|
|
+ this._schemas[instance._uri] = instance;
|
|
|
+ this._schemas[uri] = instance;
|
|
|
+
|
|
|
+ //build & cache the rest of the schema
|
|
|
+ instance.getAttributes();
|
|
|
+
|
|
|
+ return instance;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates an empty schema.
|
|
|
+ *
|
|
|
+ * @param {Environment} env The environment of the schema
|
|
|
+ * @returns {JSONSchema} The empty schema, who's schema is itself.
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.createEmptySchema = function () {
|
|
|
+ var schema = JSONSchema.createEmptySchema(this);
|
|
|
+ this._schemas[schema._uri] = schema;
|
|
|
+ return schema;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the schema registered with the provided URI.
|
|
|
+ *
|
|
|
+ * @param {String} uri The absolute URI of the required schema
|
|
|
+ * @returns {JSONSchema|undefined} The request schema, or <code>undefined</code> if not found
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.findSchema = function (uri) {
|
|
|
+ return this._schemas[formatURI(uri)];
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the specified environment option to the specified value.
|
|
|
+ *
|
|
|
+ * @param {String} name The name of the environment option to set
|
|
|
+ * @param {Any} value The new value of the environment option
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.setOption = function (name, value) {
|
|
|
+ this._options[name] = value;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the specified environment option.
|
|
|
+ *
|
|
|
+ * @param {String} name The name of the environment option to set
|
|
|
+ * @returns {Any} The value of the environment option
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.getOption = function (name) {
|
|
|
+ return this._options[name];
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the default fragment delimiter of the environment.
|
|
|
+ *
|
|
|
+ * @deprecated Use {@link Environment#setOption} with option "defaultFragmentDelimiter"
|
|
|
+ * @param {String} fd The fragment delimiter character
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.setDefaultFragmentDelimiter = function (fd) {
|
|
|
+ if (typeof fd === "string" && fd.length > 0) {
|
|
|
+ this._options["defaultFragmentDelimiter"] = fd;
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the default fragment delimiter of the environment.
|
|
|
+ *
|
|
|
+ * @deprecated Use {@link Environment#getOption} with option "defaultFragmentDelimiter"
|
|
|
+ * @returns {String} The fragment delimiter character
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.getDefaultFragmentDelimiter = function () {
|
|
|
+ return this._options["defaultFragmentDelimiter"];
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the URI of the default schema for the environment.
|
|
|
+ *
|
|
|
+ * @deprecated Use {@link Environment#setOption} with option "defaultSchemaURI"
|
|
|
+ * @param {String} uri The default schema URI
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.setDefaultSchemaURI = function (uri) {
|
|
|
+ if (typeof uri === "string") {
|
|
|
+ this._options["defaultSchemaURI"] = formatURI(uri);
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the default schema of the environment.
|
|
|
+ *
|
|
|
+ * @returns {JSONSchema} The default schema
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.getDefaultSchema = function () {
|
|
|
+ return this.findSchema(this._options["defaultSchemaURI"]);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Validates both the provided schema and the provided instance, and returns a {@link Report}.
|
|
|
+ * If the schema fails to validate, the instance will not be validated.
|
|
|
+ *
|
|
|
+ * @param {JSONInstance|Any} instanceJSON The {@link JSONInstance} or JavaScript value to validate.
|
|
|
+ * @param {JSONSchema|Any} schemaJSON The {@link JSONSchema} or JavaScript value to use in the validation. This will also be validated againt the schema's schema.
|
|
|
+ * @returns {Report} The result of the validation
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype.validate = function (instanceJSON, schemaJSON) {
|
|
|
+ var instance,
|
|
|
+ schema,
|
|
|
+ schemaSchema,
|
|
|
+ report = new Report();
|
|
|
+
|
|
|
+ try {
|
|
|
+ instance = this.createInstance(instanceJSON);
|
|
|
+ report.instance = instance;
|
|
|
+ } catch (e) {
|
|
|
+ report.addError(e.uri, e.schemaUri, e.attribute, e.message, e.details);
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ schema = this.createSchema(schemaJSON);
|
|
|
+ report.schema = schema;
|
|
|
+
|
|
|
+ schemaSchema = schema.getSchema();
|
|
|
+ report.schemaSchema = schemaSchema;
|
|
|
+ } catch (e) {
|
|
|
+ report.addError(e.uri, e.schemaUri, e.attribute, e.message, e.details);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (schemaSchema) {
|
|
|
+ schemaSchema.validate(schema, report);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (report.errors.length) {
|
|
|
+ return report;
|
|
|
+ }
|
|
|
+
|
|
|
+ return schema.validate(instance, report);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * @private
|
|
|
+ */
|
|
|
+
|
|
|
+ Environment.prototype._checkForInvalidInstances = function (stackSize, schemaURI) {
|
|
|
+ var result = [],
|
|
|
+ stack = [
|
|
|
+ [schemaURI, this._schemas[schemaURI]]
|
|
|
+ ],
|
|
|
+ counter = 0,
|
|
|
+ item, uri, instance, schema, properties, key;
|
|
|
+
|
|
|
+ while (counter++ < stackSize && stack.length) {
|
|
|
+ item = stack.shift();
|
|
|
+ uri = item[0];
|
|
|
+ instance = item[1];
|
|
|
+
|
|
|
+ if (instance instanceof JSONSchema) {
|
|
|
+ if (this._schemas[instance._uri] !== instance) {
|
|
|
+ result.push("Instance " + uri + " does not match " + instance._uri);
|
|
|
+ } else {
|
|
|
+ //schema = instance.getSchema();
|
|
|
+ //stack.push([uri + "/{schema}", schema]);
|
|
|
+
|
|
|
+ properties = instance.getAttributes();
|
|
|
+ for (key in properties) {
|
|
|
+ if (properties[key] !== O[key]) {
|
|
|
+ stack.push([uri + "/" + escapeURIComponent(key), properties[key]]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if (typeOf(instance) === "object") {
|
|
|
+ properties = instance;
|
|
|
+ for (key in properties) {
|
|
|
+ if (properties.hasOwnProperty(key)) {
|
|
|
+ stack.push([uri + "/" + escapeURIComponent(key), properties[key]]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if (typeOf(instance) === "array") {
|
|
|
+ properties = instance;
|
|
|
+ for (key = 0; key < properties.length; ++key) {
|
|
|
+ stack.push([uri + "/" + escapeURIComponent(key), properties[key]]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return result.length ? result : counter;
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * A globaly accessible object that provides the ability to create and manage {@link Environments},
|
|
|
+ * as well as providing utility methods.
|
|
|
+ *
|
|
|
+ * @namespace
|
|
|
+ */
|
|
|
+
|
|
|
+ JSV = {
|
|
|
+ _environments : {},
|
|
|
+ _defaultEnvironmentID : "",
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns if the provide value is an instance of {@link JSONInstance}.
|
|
|
+ *
|
|
|
+ * @param o The value to test
|
|
|
+ * @returns {Boolean} If the provide value is an instance of {@link JSONInstance}
|
|
|
+ */
|
|
|
+
|
|
|
+ isJSONInstance : function (o) {
|
|
|
+ return o instanceof JSONInstance;
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns if the provide value is an instance of {@link JSONSchema}.
|
|
|
+ *
|
|
|
+ * @param o The value to test
|
|
|
+ * @returns {Boolean} If the provide value is an instance of {@link JSONSchema}
|
|
|
+ */
|
|
|
+
|
|
|
+ isJSONSchema : function (o) {
|
|
|
+ return o instanceof JSONSchema;
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates and returns a new {@link Environment} that is a clone of the environment registered with the provided ID.
|
|
|
+ * If no environment ID is provided, the default environment is cloned.
|
|
|
+ *
|
|
|
+ * @param {String} [id] The ID of the environment to clone. If <code>undefined</code>, the default environment ID is used.
|
|
|
+ * @returns {Environment} A newly cloned {@link Environment}
|
|
|
+ * @throws {Error} If there is no environment registered with the provided ID
|
|
|
+ */
|
|
|
+
|
|
|
+ createEnvironment : function (id) {
|
|
|
+ id = id || this._defaultEnvironmentID;
|
|
|
+
|
|
|
+ if (!this._environments[id]) {
|
|
|
+ throw new Error("Unknown Environment ID");
|
|
|
+ }
|
|
|
+ //else
|
|
|
+ return this._environments[id].clone();
|
|
|
+ },
|
|
|
+
|
|
|
+ Environment : Environment,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Registers the provided {@link Environment} with the provided ID.
|
|
|
+ *
|
|
|
+ * @param {String} id The ID of the environment
|
|
|
+ * @param {Environment} env The environment to register
|
|
|
+ */
|
|
|
+
|
|
|
+ registerEnvironment : function (id, env) {
|
|
|
+ id = id || (env || 0)._id;
|
|
|
+ if (id && !this._environments[id] && env instanceof Environment) {
|
|
|
+ env._id = id;
|
|
|
+ this._environments[id] = env;
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets which registered ID is the default environment.
|
|
|
+ *
|
|
|
+ * @param {String} id The ID of the registered environment that is default
|
|
|
+ * @throws {Error} If there is no registered environment with the provided ID
|
|
|
+ */
|
|
|
+
|
|
|
+ setDefaultEnvironmentID : function (id) {
|
|
|
+ if (typeof id === "string") {
|
|
|
+ if (!this._environments[id]) {
|
|
|
+ throw new Error("Unknown Environment ID");
|
|
|
+ }
|
|
|
+
|
|
|
+ this._defaultEnvironmentID = id;
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the ID of the default environment.
|
|
|
+ *
|
|
|
+ * @returns {String} The ID of the default environment
|
|
|
+ */
|
|
|
+
|
|
|
+ getDefaultEnvironmentID : function () {
|
|
|
+ return this._defaultEnvironmentID;
|
|
|
+ },
|
|
|
+
|
|
|
+ //
|
|
|
+ // Utility Functions
|
|
|
+ //
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the name of the type of the provided value.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {Any} o The value to determine the type of
|
|
|
+ * @returns {String} The name of the type of the value
|
|
|
+ */
|
|
|
+ typeOf : typeOf,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Return a new object that inherits all of the properties of the provided object.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {Object} proto The prototype of the new object
|
|
|
+ * @returns {Object} A new object that inherits all of the properties of the provided object
|
|
|
+ */
|
|
|
+ createObject : createObject,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns a new object with each property transformed by the iterator.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {Object} obj The object to transform
|
|
|
+ * @param {Function} iterator A function that returns the new value of the provided property
|
|
|
+ * @param {Object} [scope] The value of <code>this</code> in the iterator
|
|
|
+ * @returns {Object} A new object with each property transformed
|
|
|
+ */
|
|
|
+ mapObject : mapObject,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns a new array with each item transformed by the iterator.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {Array} arr The array to transform
|
|
|
+ * @param {Function} iterator A function that returns the new value of the provided item
|
|
|
+ * @param {Object} scope The value of <code>this</code> in the iterator
|
|
|
+ * @returns {Array} A new array with each item transformed
|
|
|
+ */
|
|
|
+ mapArray : mapArray,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns a new array that only contains the items allowed by the iterator.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {Array} arr The array to filter
|
|
|
+ * @param {Function} iterator The function that returns true if the provided property should be added to the array
|
|
|
+ * @param {Object} scope The value of <code>this</code> within the iterator
|
|
|
+ * @returns {Array} A new array that contains the items allowed by the iterator
|
|
|
+ */
|
|
|
+ filterArray : filterArray,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns the first index in the array that the provided item is located at.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {Array} arr The array to search
|
|
|
+ * @param {Any} o The item being searched for
|
|
|
+ * @returns {Number} The index of the item in the array, or <code>-1</code> if not found
|
|
|
+ */
|
|
|
+ searchArray : searchArray,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns an array representation of a value.
|
|
|
+ * <ul>
|
|
|
+ * <li>For array-like objects, the value will be casted as an Array type.</li>
|
|
|
+ * <li>If an array is provided, the function will simply return the same array.</li>
|
|
|
+ * <li>For a null or undefined value, the result will be an empty Array.</li>
|
|
|
+ * <li>For all other values, the value will be the first element in a new Array. </li>
|
|
|
+ * </ul>
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {Any} o The value to convert into an array
|
|
|
+ * @returns {Array} The value as an array
|
|
|
+ */
|
|
|
+ toArray : toArray,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns an array of the names of all properties of an object.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {Object|Array} o The object in question
|
|
|
+ * @returns {Array} The names of all properties
|
|
|
+ */
|
|
|
+ keys : keys,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Mutates the array by pushing the provided value onto the array only if it is not already there.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {Array} arr The array to modify
|
|
|
+ * @param {Any} o The object to add to the array if it is not already there
|
|
|
+ * @returns {Array} The provided array for chaining
|
|
|
+ */
|
|
|
+ pushUnique : pushUnique,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Mutates the array by removing the first item that matches the provided value in the array.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {Array} arr The array to modify
|
|
|
+ * @param {Any} o The object to remove from the array
|
|
|
+ * @returns {Array} The provided array for chaining
|
|
|
+ */
|
|
|
+ popFirst : popFirst,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Creates a copy of the target object.
|
|
|
+ * <p>
|
|
|
+ * This method will create a new instance of the target, and then mixin the properties of the target.
|
|
|
+ * If <code>deep</code> is <code>true</code>, then each property will be cloned before mixin.
|
|
|
+ * </p>
|
|
|
+ * <p><b>Warning</b>: This is not a generic clone function, as it will only properly clone objects and arrays.</p>
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {Any} o The value to clone
|
|
|
+ * @param {Boolean} [deep=false] If each property should be recursively cloned
|
|
|
+ * @returns A cloned copy of the provided value
|
|
|
+ */
|
|
|
+ clone : clone,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Generates a pseudo-random UUID.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @returns {String} A new universally unique ID
|
|
|
+ */
|
|
|
+ randomUUID : randomUUID,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Properly escapes a URI component for embedding into a URI string.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {String} str The URI component to escape
|
|
|
+ * @returns {String} The escaped URI component
|
|
|
+ */
|
|
|
+ escapeURIComponent : escapeURIComponent,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Returns a URI that is formated for JSV. Currently, this only ensures that the URI ends with a hash tag (<code>#</code>).
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {String} uri The URI to format
|
|
|
+ * @returns {String} The URI formatted for JSV
|
|
|
+ */
|
|
|
+ formatURI : formatURI,
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Merges two schemas/instance together.
|
|
|
+ *
|
|
|
+ * @event //utility
|
|
|
+ * @param {JSONSchema|Any} base The old value to merge
|
|
|
+ * @param {JSONSchema|Any} extra The new value to merge
|
|
|
+ * @param {Boolean} extension If the merge is a JSON Schema extension
|
|
|
+ * @return {Any} The modified base value
|
|
|
+ */
|
|
|
+
|
|
|
+ inherits : inherits
|
|
|
+ };
|
|
|
+
|
|
|
+ this.JSV = JSV; //set global object
|
|
|
+ exports.JSV = JSV; //export to CommonJS
|
|
|
+
|
|
|
+ require("./environments"); //load default environments
|
|
|
+
|
|
|
+}());
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+/**
|
|
|
+ * 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.3
|
|
|
+ * @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,
|
|
|
+ InitializationError,
|
|
|
+ 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;
|
|
|
+
|
|
|
+ InitializationError = function InitializationError(instance, schema, attr, message, details) {
|
|
|
+ Error.call(this, message);
|
|
|
+
|
|
|
+ this.uri = instance.getURI();
|
|
|
+ this.schemaUri = schema.getURI();
|
|
|
+ this.attribute = attr;
|
|
|
+ this.message = message;
|
|
|
+ this.description = message; //IE
|
|
|
+ this.details = details;
|
|
|
+ }
|
|
|
+ InitializationError.prototype = new Error();
|
|
|
+ InitializationError.prototype.constructor = InitializationError;
|
|
|
+ InitializationError.prototype.name = "InitializationError";
|
|
|
+
|
|
|
+ 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("strict", false);
|
|
|
+ ENVIRONMENT.setOption("validateReferences", false); //updated later
|
|
|
+
|
|
|
+ //
|
|
|
+ // 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 then 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 then 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 then 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 then the required maximum", maxItems);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ "pattern" : {
|
|
|
+ "type" : "string",
|
|
|
+ "optional" : true,
|
|
|
+ "format" : "regex",
|
|
|
+
|
|
|
+ "parser" : function (instance, self) {
|
|
|
+ if (instance.getType() === "string") {
|
|
|
+ try {
|
|
|
+ return new RegExp(instance.getValue());
|
|
|
+ } catch (e) {
|
|
|
+ return e;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ "validator" : function (instance, schema, self, report, parent, parentSchema, name) {
|
|
|
+ var pattern;
|
|
|
+ try {
|
|
|
+ pattern = schema.getAttribute("pattern");
|
|
|
+ if (pattern instanceof Error) {
|
|
|
+ report.addError(schema, self, "pattern", "Invalid pattern", schema.getValueOfProperty("pattern"));
|
|
|
+ } else 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 then 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 then 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);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+
|
|
|
+ // JOSHFIRE: added a couple of format validators for "uri" and "email"
|
|
|
+ "formatValidators" : {
|
|
|
+ "uri": function (instance, report) {
|
|
|
+ // Regular expression from @diegoperini taken from:
|
|
|
+ // http://mathiasbynens.be/demo/url-regex
|
|
|
+ // ... and only slightly adjusted for use in JavaScript
|
|
|
+ var reUri = /^(?:(?:https?):\/\/)(?:\S+(?::\S*)?@)?(?:(?!10(?:\.\d{1,3}){3})(?!127(?:\.\d{1,3}){3})(?!169\.254(?:\.\d{1,3}){2})(?!192\.168(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]+\-?)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]+\-?)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})))(?::\d{2,5})?(?:\/[^\s]*)?$/i;
|
|
|
+ return !!reUri.test(instance._value);
|
|
|
+ },
|
|
|
+ "email": function (instance, report) {
|
|
|
+ // Regular expression taken from:
|
|
|
+ // http://www.regular-expressions.info/email.html
|
|
|
+ var reEmail = /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}$/i;
|
|
|
+ return !!reEmail.test(instance._value);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // JOSHFIRE: end of custom code
|
|
|
+ // "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 then 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, update instance
|
|
|
+ link = instance._schema.getLink("describedby", instance);
|
|
|
+ if (link && instance._schema._uri !== link) {
|
|
|
+ if (instance._env._schemas[link]) {
|
|
|
+ instance._schema = instance._env._schemas[link];
|
|
|
+ initializer = instance._schema.getValueOfProperty("initializer");
|
|
|
+ if (typeof initializer === "function") {
|
|
|
+ return initializer(instance); //this function will finish initialization
|
|
|
+ } else {
|
|
|
+ return instance; //no further initialization
|
|
|
+ }
|
|
|
+ } else if (instance._env._options["validateReferences"]) {
|
|
|
+ throw new InitializationError(instance, instance._schema, "{link:describedby}", "Unknown schema reference", link);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //if there is a link to the full representation, replace instance
|
|
|
+ link = instance._schema.getLink("full", instance);
|
|
|
+ if (link && instance._uri !== link) {
|
|
|
+ if (instance._env._schemas[link]) {
|
|
|
+ instance = instance._env._schemas[link];
|
|
|
+ return instance; //retrieved schemas are guaranteed to be initialized
|
|
|
+ } else if (instance._env._options["validateReferences"]) {
|
|
|
+ throw new InitializationError(instance, instance._schema, "{link:full}", "Unknown schema reference", 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);
|
|
|
+ }
|
|
|
+
|
|
|
+ //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);
|
|
|
+ }
|
|
|
+
|
|
|
+ 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#");
|
|
|
+
|
|
|
+ //We need to reinitialize these 3 schemas as they all reference each other
|
|
|
+ SCHEMA_00 = ENVIRONMENT.createSchema(SCHEMA_00.getValue(), HYPERSCHEMA_00, "http://json-schema.org/draft-00/schema#");
|
|
|
+ HYPERSCHEMA_00 = ENVIRONMENT.createSchema(HYPERSCHEMA_00.getValue(), HYPERSCHEMA_00, "http://json-schema.org/draft-00/hyper-schema#");
|
|
|
+ LINKS_00 = ENVIRONMENT.createSchema(LINKS_00.getValue(), 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#");
|
|
|
+
|
|
|
+ //We need to reinitialize these 3 schemas as they all reference each other
|
|
|
+ SCHEMA_01 = ENVIRONMENT.createSchema(SCHEMA_01.getValue(), HYPERSCHEMA_01, "http://json-schema.org/draft-01/schema#");
|
|
|
+ HYPERSCHEMA_01 = ENVIRONMENT.createSchema(HYPERSCHEMA_01.getValue(), HYPERSCHEMA_01, "http://json-schema.org/draft-01/hyper-schema#");
|
|
|
+ LINKS_01 = ENVIRONMENT.createSchema(LINKS_01.getValue(), 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;
|
|
|
+ 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 && ((instance.getValue() / divisor) % 1) !== 0) {
|
|
|
+ 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#");
|
|
|
+
|
|
|
+ //We need to reinitialize these 3 schemas as they all reference each other
|
|
|
+ SCHEMA_02 = ENVIRONMENT.createSchema(SCHEMA_02.getValue(), HYPERSCHEMA_02, "http://json-schema.org/draft-02/schema#");
|
|
|
+ HYPERSCHEMA_02 = ENVIRONMENT.createSchema(HYPERSCHEMA_02.getValue(), HYPERSCHEMA_02, "http://json-schema.org/draft-02/hyper-schema#");
|
|
|
+ LINKS_02 = ENVIRONMENT.createSchema(LINKS_02.getValue(), 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 then 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 then 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, update instance
|
|
|
+ if (schemaLink) {
|
|
|
+ link = instance.resolveURI(schemaLink);
|
|
|
+ if (link && instance._schema._uri !== link) {
|
|
|
+ if (instance._env._schemas[link]) {
|
|
|
+ instance._schema = instance._env._schemas[link];
|
|
|
+ initializer = instance._schema.getValueOfProperty("initializer");
|
|
|
+ if (typeof initializer === "function") {
|
|
|
+ return initializer(instance); //this function will finish initialization
|
|
|
+ } else {
|
|
|
+ return instance; //no further initialization
|
|
|
+ }
|
|
|
+ } else if (instance._env._options["validateReferences"]) {
|
|
|
+ throw new InitializationError(instance, instance._schema, "$schema", "Unknown schema reference", link);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //if there is a link to the full representation, replace instance
|
|
|
+ if (refLink) {
|
|
|
+ link = instance.resolveURI(refLink);
|
|
|
+ if (link && instance._uri !== link) {
|
|
|
+ if (instance._env._schemas[link]) {
|
|
|
+ instance = instance._env._schemas[link];
|
|
|
+ return instance; //retrieved schemas are guaranteed to be initialized
|
|
|
+ } else if (instance._env._options["validateReferences"]) {
|
|
|
+ throw new InitializationError(instance, instance._schema, "$ref", "Unknown schema reference", 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);
|
|
|
+ }
|
|
|
+
|
|
|
+ //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);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ 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("validateReferences", true);
|
|
|
+ ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/draft-03/schema#"); //update later
|
|
|
+
|
|
|
+ //prevent reference errors
|
|
|
+ ENVIRONMENT.createSchema({}, true, "http://json-schema.org/draft-03/schema#");
|
|
|
+ ENVIRONMENT.createSchema({}, true, "http://json-schema.org/draft-03/hyper-schema#");
|
|
|
+ ENVIRONMENT.createSchema({}, true, "http://json-schema.org/draft-03/links#");
|
|
|
+
|
|
|
+ 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#");
|
|
|
+ LINKS_03 = ENVIRONMENT.createSchema(LINKS_03_JSON, true, "http://json-schema.org/draft-03/links#");
|
|
|
+
|
|
|
+ ENVIRONMENT.setOption("defaultSchemaURI", "http://json-schema.org/draft-03/hyper-schema#");
|
|
|
+
|
|
|
+ //We need to reinitialize these schemas as they reference each other
|
|
|
+ HYPERSCHEMA_03 = ENVIRONMENT.createSchema(HYPERSCHEMA_03.getValue(), HYPERSCHEMA_03, "http://json-schema.org/draft-03/hyper-schema#");
|
|
|
+
|
|
|
+ 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 then 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");
|
|
|
+ }
|
|
|
+
|
|
|
+}());
|
|
|
+
|
|
|
+
|
|
|
+global.JSONFormValidator = exports.JSV;
|
|
|
+})(this, false);
|
