z-schema 3.18.4 → 3.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "z-schema",
-  "version": "3.18.4",
+  "version": "3.21.0",
   "description": "JSON schema validator",
   "homepage": "https://github.com/zaggino/z-schema",
   "authors": [
@@ -31,8 +31,8 @@
     "README.md"
   ],
   "scripts": {
-    "prepublish": "grunt",
-    "test": "grunt test && grunt lint"
+    "prepublish": "npm test && grunt",
+    "test": "jasmine-node test/ && grunt lint"
   },
   "testling": {
     "scripts": [
@@ -60,26 +60,24 @@
   "dependencies": {
     "lodash.get": "^4.0.0",
     "lodash.isequal": "^4.0.0",
-    "validator": "^8.0.0"
+    "validator": "^10.0.0"
   },
   "optionalDependencies": {
     "commander": "^2.7.1"
   },
   "devDependencies": {
-    "coveralls": "latest",
+    "coveralls": "^3.0.0",
     "grunt": "^1.0.1",
-    "grunt-cli": "latest",
     "grunt-browserify": "^5.2.0",
-    "grunt-contrib-copy": "latest",
-    "grunt-contrib-jasmine": "latest",
-    "grunt-contrib-jshint": "latest",
-    "grunt-contrib-uglify": "latest",
-    "grunt-jasmine-node": "latest",
-    "grunt-jasmine-node-coverage": "^1.2.0",
-    "grunt-jscs": "latest",
-    "grunt-lineending": "latest",
-    "jasmine-node": "latest",
-    "jasmine-reporters": "latest",
-    "remapify": "latest"
+    "grunt-cli": "^1.2.0",
+    "grunt-contrib-copy": "^1.0.0",
+    "grunt-contrib-jasmine": "^1.1.0",
+    "grunt-contrib-jshint": "^1.1.0",
+    "grunt-contrib-uglify": "^3.1.0",
+    "grunt-jscs": "^3.0.1",
+    "grunt-lineending": "^1.0.0",
+    "jasmine-node": "^1.14.5",
+    "jasmine-reporters": "^2.2.1",
+    "remapify": "^2.1.0"
   }
 }

package/src/Errors.js

@@ -5,6 +5,7 @@ module.exports = {
     INVALID_TYPE:                           "Expected type {0} but found type {1}",
     INVALID_FORMAT:                         "Object didn't pass validation for format {0}: {1}",
     ENUM_MISMATCH:                          "No enum match for: {0}",
+    ENUM_CASE_MISMATCH:                     "Enum does not match case for: {0}",
     ANY_OF_MISSING:                         "Data does not match any schemas from 'anyOf'",
     ONE_OF_MISSING:                         "Data does not match any schemas from 'oneOf'",
     ONE_OF_MULTIPLE:                        "Data is valid against more than one schema from 'oneOf'",

package/src/JsonValidation.js

@@ -246,15 +246,20 @@ var JsonValidators = {
     enum: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.1.2
         var match = false,
+            caseInsensitiveMatch = false,
             idx = schema.enum.length;
         while (idx--) {
             if (Utils.areEqual(json, schema.enum[idx])) {
                 match = true;
                 break;
+            } else if (Utils.areEqual(json, schema.enum[idx]), { caseInsensitiveComparison: true }) {
+                caseInsensitiveMatch = true;
             }
         }
+
         if (match === false) {
-            report.addError("ENUM_MISMATCH", [json], null, schema.description);
+            var error = caseInsensitiveMatch && this.options.enumCaseInsensitiveComparison ? "ENUM_CASE_MISMATCH" : "ENUM_MISMATCH";
+            report.addError(error, [json], null, schema.description);
         }
     },
     /*

package/src/Report.js

@@ -57,7 +57,8 @@ Report.prototype.processAsyncTasks = function (timeout, callback) {
         };
     }
 
-    if (tasksCount === 0 || this.errors.length > 0) {
+    // finish if tasks are completed or there are any errors and breaking on first error was requested
+    if (tasksCount === 0 || (this.errors.length > 0 && this.options.breakOnFirstError)) {
         finish();
         return;
     }

package/src/SchemaCache.js

@@ -121,7 +121,15 @@ exports.getSchemaByUri = function (report, uri, root) {
 
             var remoteReport = new Report(report);
             if (SchemaCompilation.compileSchema.call(this, remoteReport, result)) {
-                SchemaValidation.validateSchema.call(this, remoteReport, result);
+                var savedOptions = this.options;
+                try {
+                    // If custom validationOptions were provided to setRemoteReference(),
+                    // use them instead of the default options
+                    this.options = result.__$validationOptions || this.options;
+                    SchemaValidation.validateSchema.call(this, remoteReport, result);
+                } finally {
+                    this.options = savedOptions;
+                }
             }
             var remoteReportIsValid = remoteReport.isValid();
             if (!remoteReportIsValid) {

package/src/Utils.js

@@ -41,7 +41,11 @@ exports.whatIs = function (what) {
 
 };
 
-exports.areEqual = function areEqual(json1, json2) {
+exports.areEqual = function areEqual(json1, json2, options) {
+
+    options = options || {};
+    var caseInsensitiveComparison = options.caseInsensitiveComparison || false;
+
     // http://json-schema.org/latest/json-schema-core.html#rfc.section.3.6
 
     // Two JSON values are said to be equal if and only if:
@@ -52,6 +56,12 @@ exports.areEqual = function areEqual(json1, json2) {
     if (json1 === json2) {
         return true;
     }
+    if (
+      caseInsensitiveComparison === true &&
+      typeof json1 === "string" && typeof json2 === "string" &&
+      json1.toUpperCase() === json2.toUpperCase()) {
+        return true;
+    }
 
     var i, len;
 
@@ -64,7 +74,7 @@ exports.areEqual = function areEqual(json1, json2) {
         // items at the same index are equal according to this definition; or
         len = json1.length;
         for (i = 0; i < len; i++) {
-            if (!areEqual(json1[i], json2[i])) {
+            if (!areEqual(json1[i], json2[i], { caseInsensitiveComparison: caseInsensitiveComparison })) {
                 return false;
             }
         }
@@ -76,13 +86,13 @@ exports.areEqual = function areEqual(json1, json2) {
         // have the same set of property names; and
         var keys1 = Object.keys(json1);
         var keys2 = Object.keys(json2);
-        if (!areEqual(keys1, keys2)) {
+        if (!areEqual(keys1, keys2, { caseInsensitiveComparison: caseInsensitiveComparison })) {
             return false;
         }
         // values for a same property name are equal according to this definition.
         len = keys1.length;
         for (i = 0; i < len; i++) {
-            if (!areEqual(json1[keys1[i]], json2[keys1[i]])) {
+            if (!areEqual(json1[keys1[i]], json2[keys1[i]], { caseInsensitiveComparison: caseInsensitiveComparison })) {
                 return false;
             }
         }

package/src/ZSchema.js

@@ -22,6 +22,8 @@ var defaultOptions = {
     forceAdditional: false,
     // assume additionalProperties and additionalItems are defined as "false" where appropriate
     assumeAdditional: false,
+    // do case insensitive comparison for enums
+    enumCaseInsensitiveComparison: false,
     // force items to be defined on "array" types
     forceItems: false,
     // force minItems to be defined on "array" types
@@ -60,15 +62,8 @@ var defaultOptions = {
     customValidator: null
 };
 
-/*
-    constructor
-*/
-function ZSchema(options) {
-    this.cache = {};
-    this.referenceCache = [];
-
-    this.setRemoteReference("http://json-schema.org/draft-04/schema", Draft4Schema);
-    this.setRemoteReference("http://json-schema.org/draft-04/hyper-schema", Draft4HyperSchema);
+function normalizeOptions(options) {
+    var normalized;
 
     // options
     if (typeof options === "object") {
@@ -94,22 +89,40 @@ function ZSchema(options) {
             }
         }
 
-        this.options = options;
+        normalized = options;
     } else {
-        this.options = Utils.clone(defaultOptions);
+        normalized = Utils.clone(defaultOptions);
     }
 
-    if (this.options.strictMode === true) {
-        this.options.forceAdditional  = true;
-        this.options.forceItems       = true;
-        this.options.forceMaxLength   = true;
-        this.options.forceProperties  = true;
-        this.options.noExtraKeywords  = true;
-        this.options.noTypeless       = true;
-        this.options.noEmptyStrings   = true;
-        this.options.noEmptyArrays    = true;
+    if (normalized.strictMode === true) {
+        normalized.forceAdditional  = true;
+        normalized.forceItems       = true;
+        normalized.forceMaxLength   = true;
+        normalized.forceProperties  = true;
+        normalized.noExtraKeywords  = true;
+        normalized.noTypeless       = true;
+        normalized.noEmptyStrings   = true;
+        normalized.noEmptyArrays    = true;
     }
 
+    return normalized;
+}
+
+/*
+    constructor
+*/
+function ZSchema(options) {
+    this.cache = {};
+    this.referenceCache = [];
+    this.validateOptions = {};
+
+    this.options = normalizeOptions(options);
+
+    // Disable strict validation for the built-in schemas
+    var metaschemaOptions = normalizeOptions({ });
+
+    this.setRemoteReference("http://json-schema.org/draft-04/schema", Draft4Schema, metaschemaOptions);
+    this.setRemoteReference("http://json-schema.org/draft-04/hyper-schema", Draft4HyperSchema, metaschemaOptions);
 }
 
 /*
@@ -148,6 +161,8 @@ ZSchema.prototype.validate = function (json, schema, options, callback) {
     }
     if (!options) { options = {}; }
 
+    this.validateOptions = options;
+
     var whatIs = Utils.whatIs(schema);
     if (whatIs !== "string" && whatIs !== "object") {
         var e = new Error("Invalid .validate call - schema must be an string or object but " + whatIs + " was passed!");
@@ -257,12 +272,17 @@ ZSchema.prototype.getMissingRemoteReferences = function () {
     }
     return missingRemoteReferences;
 };
-ZSchema.prototype.setRemoteReference = function (uri, schema) {
+ZSchema.prototype.setRemoteReference = function (uri, schema, validationOptions) {
     if (typeof schema === "string") {
         schema = JSON.parse(schema);
     } else {
         schema = Utils.cloneDeep(schema);
     }
+
+    if (validationOptions) {
+        schema.__$validationOptions = normalizeOptions(validationOptions);
+    }
+
     SchemaCache.cacheSchemaByUri.call(this, uri, schema);
 };
 ZSchema.prototype.getResolvedSchema = function (schema) {