z-schema 3.19.1 → 3.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "z-schema",
-  "version": "3.19.1",
+  "version": "3.23.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,7 +60,7 @@
   "dependencies": {
     "lodash.get": "^4.0.0",
     "lodash.isequal": "^4.0.0",
-    "validator": "^9.0.0"
+    "validator": "^10.0.0"
   },
   "optionalDependencies": {
     "commander": "^2.7.1"
@@ -74,8 +74,6 @@
     "grunt-contrib-jasmine": "^1.1.0",
     "grunt-contrib-jshint": "^1.1.0",
     "grunt-contrib-uglify": "^3.1.0",
-    "grunt-jasmine-node": "^0.3.1",
-    "grunt-jasmine-node-coverage": "^2.0.1",
     "grunt-jscs": "^3.0.1",
     "grunt-lineending": "^1.0.0",
     "jasmine-node": "^1.14.5",

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

@@ -1,8 +1,8 @@
 "use strict";
 
-var FormatValidators  = require("./FormatValidators"),
-    Report            = require("./Report"),
-    Utils             = require("./Utils");
+var FormatValidators = require("./FormatValidators"),
+    Report           = require("./Report"),
+    Utils            = require("./Utils");
 
 var JsonValidators = {
     multipleOf: function (report, schema, json) {
@@ -11,7 +11,7 @@ var JsonValidators = {
             return;
         }
         if (Utils.whatIs(json / schema.multipleOf) !== "integer") {
-            report.addError("MULTIPLE_OF", [json, schema.multipleOf], null, schema.description);
+            report.addError("MULTIPLE_OF", [json, schema.multipleOf], null, schema);
         }
     },
     maximum: function (report, schema, json) {
@@ -21,11 +21,11 @@ var JsonValidators = {
         }
         if (schema.exclusiveMaximum !== true) {
             if (json > schema.maximum) {
-                report.addError("MAXIMUM", [json, schema.maximum], null, schema.description);
+                report.addError("MAXIMUM", [json, schema.maximum], null, schema);
             }
         } else {
             if (json >= schema.maximum) {
-                report.addError("MAXIMUM_EXCLUSIVE", [json, schema.maximum], null, schema.description);
+                report.addError("MAXIMUM_EXCLUSIVE", [json, schema.maximum], null, schema);
             }
         }
     },
@@ -39,11 +39,11 @@ var JsonValidators = {
         }
         if (schema.exclusiveMinimum !== true) {
             if (json < schema.minimum) {
-                report.addError("MINIMUM", [json, schema.minimum], null, schema.description);
+                report.addError("MINIMUM", [json, schema.minimum], null, schema);
             }
         } else {
             if (json <= schema.minimum) {
-                report.addError("MINIMUM_EXCLUSIVE", [json, schema.minimum], null, schema.description);
+                report.addError("MINIMUM_EXCLUSIVE", [json, schema.minimum], null, schema);
             }
         }
     },
@@ -56,7 +56,7 @@ var JsonValidators = {
             return;
         }
         if (Utils.ucs2decode(json).length > schema.maxLength) {
-            report.addError("MAX_LENGTH", [json.length, schema.maxLength], null, schema.description);
+            report.addError("MAX_LENGTH", [json.length, schema.maxLength], null, schema);
         }
     },
     minLength: function (report, schema, json) {
@@ -65,7 +65,7 @@ var JsonValidators = {
             return;
         }
         if (Utils.ucs2decode(json).length < schema.minLength) {
-            report.addError("MIN_LENGTH", [json.length, schema.minLength], null, schema.description);
+            report.addError("MIN_LENGTH", [json.length, schema.minLength], null, schema);
         }
     },
     pattern: function (report, schema, json) {
@@ -74,7 +74,7 @@ var JsonValidators = {
             return;
         }
         if (RegExp(schema.pattern).test(json) === false) {
-            report.addError("PATTERN", [schema.pattern, json], null, schema.description);
+            report.addError("PATTERN", [schema.pattern, json], null, schema);
         }
     },
     additionalItems: function (report, schema, json) {
@@ -86,7 +86,7 @@ var JsonValidators = {
         // the json is valid if its size is less than, or equal to, the size of "items".
         if (schema.additionalItems === false && Array.isArray(schema.items)) {
             if (json.length > schema.items.length) {
-                report.addError("ARRAY_ADDITIONAL_ITEMS", null, null, schema.description);
+                report.addError("ARRAY_ADDITIONAL_ITEMS", null, null, schema);
             }
         }
     },
@@ -99,7 +99,7 @@ var JsonValidators = {
             return;
         }
         if (json.length > schema.maxItems) {
-            report.addError("ARRAY_LENGTH_LONG", [json.length, schema.maxItems], null, schema.description);
+            report.addError("ARRAY_LENGTH_LONG", [json.length, schema.maxItems], null, schema);
         }
     },
     minItems: function (report, schema, json) {
@@ -108,7 +108,7 @@ var JsonValidators = {
             return;
         }
         if (json.length < schema.minItems) {
-            report.addError("ARRAY_LENGTH_SHORT", [json.length, schema.minItems], null, schema.description);
+            report.addError("ARRAY_LENGTH_SHORT", [json.length, schema.minItems], null, schema);
         }
     },
     uniqueItems: function (report, schema, json) {
@@ -119,7 +119,7 @@ var JsonValidators = {
         if (schema.uniqueItems === true) {
             var matches = [];
             if (Utils.isUniqueArray(json, matches) === false) {
-                report.addError("ARRAY_UNIQUE", matches, null, schema.description);
+                report.addError("ARRAY_UNIQUE", matches, null, schema);
             }
         }
     },
@@ -130,7 +130,7 @@ var JsonValidators = {
         }
         var keysCount = Object.keys(json).length;
         if (keysCount > schema.maxProperties) {
-            report.addError("OBJECT_PROPERTIES_MAXIMUM", [keysCount, schema.maxProperties], null, schema.description);
+            report.addError("OBJECT_PROPERTIES_MAXIMUM", [keysCount, schema.maxProperties], null, schema);
         }
     },
     minProperties: function (report, schema, json) {
@@ -140,7 +140,7 @@ var JsonValidators = {
         }
         var keysCount = Object.keys(json).length;
         if (keysCount < schema.minProperties) {
-            report.addError("OBJECT_PROPERTIES_MINIMUM", [keysCount, schema.minProperties], null, schema.description);
+            report.addError("OBJECT_PROPERTIES_MINIMUM", [keysCount, schema.minProperties], null, schema);
         }
     },
     required: function (report, schema, json) {
@@ -152,7 +152,7 @@ var JsonValidators = {
         while (idx--) {
             var requiredPropertyName = schema.required[idx];
             if (json[requiredPropertyName] === undefined) {
-                report.addError("OBJECT_MISSING_REQUIRED_PROPERTY", [requiredPropertyName], null, schema.description);
+                report.addError("OBJECT_MISSING_REQUIRED_PROPERTY", [requiredPropertyName], null, schema);
             }
         }
     },
@@ -208,7 +208,7 @@ var JsonValidators = {
                     }
                 }
                 if (s.length > 0) {
-                    report.addError("OBJECT_ADDITIONAL_PROPERTIES", [s], null, schema.description);
+                    report.addError("OBJECT_ADDITIONAL_PROPERTIES", [s], null, schema);
                 }
             }
         }
@@ -236,7 +236,7 @@ var JsonValidators = {
                     while (idx2--) {
                         var requiredPropertyName = dependencyDefinition[idx2];
                         if (json[requiredPropertyName] === undefined) {
-                            report.addError("OBJECT_DEPENDENCY_KEY", [requiredPropertyName, dependencyName], null, schema.description);
+                            report.addError("OBJECT_DEPENDENCY_KEY", [requiredPropertyName, dependencyName], null, schema);
                         }
                     }
                 }
@@ -246,23 +246,35 @@ 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);
         }
     },
-    /*
     type: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.2
-        // type is handled before this is called so ignore
+        var jsonType = Utils.whatIs(json);
+        if (typeof schema.type === "string") {
+            if (jsonType !== schema.type && (jsonType !== "integer" || schema.type !== "number")) {
+                report.addError("INVALID_TYPE", [schema.type, jsonType], null, schema);
+            }
+        } else {
+            if (schema.type.indexOf(jsonType) === -1 && (jsonType !== "integer" || schema.type.indexOf("number") === -1)) {
+                report.addError("INVALID_TYPE", [schema.type, jsonType], null, schema);
+            }
+        }
     },
-    */
     allOf: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.3.2
         var idx = schema.allOf.length;
@@ -286,7 +298,7 @@ var JsonValidators = {
         }
 
         if (passed === false) {
-            report.addError("ANY_OF_MISSING", undefined, subReports, schema.description);
+            report.addError("ANY_OF_MISSING", undefined, subReports, schema);
         }
     },
     oneOf: function (report, schema, json) {
@@ -304,16 +316,16 @@ var JsonValidators = {
         }
 
         if (passes === 0) {
-            report.addError("ONE_OF_MISSING", undefined, subReports, schema.description);
+            report.addError("ONE_OF_MISSING", undefined, subReports, schema);
         } else if (passes > 1) {
-            report.addError("ONE_OF_MULTIPLE", null, null, schema.description);
+            report.addError("ONE_OF_MULTIPLE", null, null, schema);
         }
     },
     not: function (report, schema, json) {
         // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.6.2
         var subReport = new Report(report);
         if (exports.validate.call(this, subReport, schema.not, json) === true) {
-            report.addError("NOT_PASSED", null, null, schema.description);
+            report.addError("NOT_PASSED", null, null, schema);
         }
     },
     definitions: function () { /*report, schema, json*/
@@ -328,17 +340,17 @@ var JsonValidators = {
                 // async
                 report.addAsyncTask(formatValidatorFn, [json], function (result) {
                     if (result !== true) {
-                        report.addError("INVALID_FORMAT", [schema.format, json], null, schema.description);
+                        report.addError("INVALID_FORMAT", [schema.format, json], null, schema);
                     }
                 });
             } else {
                 // sync
                 if (formatValidatorFn.call(this, json) !== true) {
-                    report.addError("INVALID_FORMAT", [schema.format, json], null, schema.description);
+                    report.addError("INVALID_FORMAT", [schema.format, json], null, schema);
                 }
             }
         } else if (this.options.ignoreUnknownFormats !== true) {
-            report.addError("UNKNOWN_FORMAT", [schema.format], null, schema.description);
+            report.addError("UNKNOWN_FORMAT", [schema.format], null, schema);
         }
     }
 };
@@ -450,7 +462,7 @@ exports.validate = function (report, schema, json) {
     // check if schema is an object
     var to = Utils.whatIs(schema);
     if (to !== "object") {
-        report.addError("SCHEMA_NOT_AN_OBJECT", [to], null, schema.description);
+        report.addError("SCHEMA_NOT_AN_OBJECT", [to], null, schema);
         return false;
     }
 
@@ -473,7 +485,7 @@ exports.validate = function (report, schema, json) {
         var maxRefs = 99;
         while (schema.$ref && maxRefs > 0) {
             if (!schema.__$refResolved) {
-                report.addError("REF_UNRESOLVED", [schema.$ref], null, schema.description);
+                report.addError("REF_UNRESOLVED", [schema.$ref], null, schema);
                 break;
             } else if (schema.__$refResolved === schema) {
                 break;
@@ -489,23 +501,12 @@ exports.validate = function (report, schema, json) {
     }
 
     // type checking first
-    // http://json-schema.org/latest/json-schema-validation.html#rfc.section.5.5.2.2
     var jsonType = Utils.whatIs(json);
     if (schema.type) {
-        if (typeof schema.type === "string") {
-            if (jsonType !== schema.type && (jsonType !== "integer" || schema.type !== "number")) {
-                report.addError("INVALID_TYPE", [schema.type, jsonType], null, schema.description);
-                if (this.options.breakOnFirstError) {
-                    return false;
-                }
-            }
-        } else {
-            if (schema.type.indexOf(jsonType) === -1 && (jsonType !== "integer" || schema.type.indexOf("number") === -1)) {
-                report.addError("INVALID_TYPE", [schema.type, jsonType], null, schema.description);
-                if (this.options.breakOnFirstError) {
-                    return false;
-                }
-            }
+        keys.splice(keys.indexOf("type"), 1);
+        JsonValidators.type.call(this, report, schema, json);
+        if (report.errors.length && this.options.breakOnFirstError) {
+            return false;
         }
     }
 

package/src/Report.js

@@ -42,7 +42,7 @@ Report.prototype.processAsyncTasks = function (timeout, callback) {
     function finish() {
         process.nextTick(function () {
             var valid = self.errors.length === 0,
-                err   = valid ? undefined : self.errors;
+                err = valid ? undefined : self.errors;
             callback(err, valid);
         });
     }
@@ -145,13 +145,13 @@ Report.prototype.hasError = function (errorCode, params) {
     return false;
 };
 
-Report.prototype.addError = function (errorCode, params, subReports, schemaDescription) {
+Report.prototype.addError = function (errorCode, params, subReports, schema) {
     if (!errorCode) { throw new Error("No errorCode passed into addError()"); }
 
-    this.addCustomError(errorCode, Errors[errorCode], params, subReports, schemaDescription);
+    this.addCustomError(errorCode, Errors[errorCode], params, subReports, schema);
 };
 
-Report.prototype.addCustomError = function (errorCode, errorMessage, params, subReports, schemaDescription) {
+Report.prototype.addCustomError = function (errorCode, errorMessage, params, subReports, schema) {
     if (this.errors.length >= this.reportOptions.maxErrors) {
         return;
     }
@@ -175,8 +175,15 @@ Report.prototype.addCustomError = function (errorCode, errorMessage, params, sub
         schemaId: this.getSchemaId()
     };
 
-    if (schemaDescription) {
-        err.description = schemaDescription;
+    if (schema && typeof schema === "string") {
+        err.description = schema;
+    } else if (schema && typeof schema === "object") {
+        if (schema.title) {
+            err.title = schema.title;
+        }
+        if (schema.description) {
+            err.description = schema.description;
+        }
     }
 
     if (subReports != null) {

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
@@ -112,6 +114,7 @@ function normalizeOptions(options) {
 function ZSchema(options) {
     this.cache = {};
     this.referenceCache = [];
+    this.validateOptions = {};
 
     this.options = normalizeOptions(options);
 
@@ -158,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!");