Ticket #5975: jsonSchema.diff

jsonSchema.js

@@ +1 @@
+dojo.provide("dojox.validate.jsonSchema");
+
+
+dojox.validate.jsonSchema.validate = function(/*Any*/instance,/*Object*/schema) {
+        // summary:
+        //      To use the validator call this with an instance object and an optional schema object.
+        //              If a schema is provided, it will be used to validate. If the instance object refers to a schema (self-validating), 
+        //              that schema will be used to validate and the schema parameter is not necessary (if both exist, 
+        //              both validations will occur).
+        //      instance:
+        //              The instance value/object to validate
+        // schema:
+        //              The schema to use to validate
+        // return: 
+        //              The validate method will return an object with two properties:
+        //                      valid: A boolean indicating if the instance is valid by the schema
+        //                      errors: An array of validation errors. If there are no errors, then an 
+        //                                      empty list will be returned. A validation error will have two properties: 
+        //                                              property: which indicates which property had the error
+        //                                              message: which indicates what the error was
+        //
+        return this._validate(instance,schema,false);
+};
+dojox.validate.jsonSchema.checkPropertyChange = function(/*Any*/value,/*Object*/schema) {
+        // summary:
+        //              The checkPropertyChange method will check to see if an value can legally be in property with the given schema
+        //              This is slightly different than the validate method in that it will fail if the schema is readonly and it will
+        //              not check for self-validation, it is assumed that the passed in value is already internally valid.  
+        //              The checkPropertyChange method will return the same object type as validate, see JSONSchema.validate for 
+        //              information.
+        //      instance:
+        //              The new instance value/object to check
+        // schema:
+        //              The schema to use to validate
+        // return: 
+        //              see dojox.validate.jsonSchema.validate
+        //
+        return this._validate(value,schema,true);
+};
+dojox.validate.jsonSchema._validate = function(/*Any*/instance,/*Object*/schema,/*Boolean*/ _changing) {
+        
+        
+        var errors = [];
+                // validate a value against a property definition
+        function checkProp(value, schema, path,i) {
+                if(typeof schema != 'object') {
+                        return;
+                }       
+                path += path ? typeof i == 'number' ? '[' + i + ']' : typeof i == 'undefined' ? '' : '.' + i : i;
+                function addError(message) {
+                        errors.push({property:path,message:message});
+                }
+                if(_changing && schema.readonly) {
+                        addError("is a readonly field, it can not be changed");
+                }
+                if(schema instanceof Array) {
+                        if(!(value instanceof Array)) {
+                                return [{property:path,message:"An array tuple is required"}];
+                        }
+                        for (i =0; i < schema.length; i++) {
+                                errors.concat(checkProp(value[i],schema[i],path,i));
+                        }
+                        return errors;
+                }
+                if(schema['extends']){ // if it extends another schema, it must pass that schema as well
+                        checkProp(value,schema['extends'],path,i);
+                }
+                // validate a value against a type definition
+                function checkType(type,value) {
+                        if(type) {
+                                if(typeof type == 'string' && type != 'any' 
+                                                && (type == 'null' ? value !== null : typeof value != type) 
+                                                && !(value instanceof Array && type == 'array')
+                                                && !(type == 'integer' && !(value%1))){
+                                        return [{property:path,message:(typeof value) + " value found, but a " + type + " is required"}];
+                                }
+                                if(type instanceof Array){
+                                        var unionErrors=[];
+                                        for (var j = 0; j < type.length; j++){// a union type 
+                                                if(!(unionErrors=checkType(type[j],value)).length){
+                                                        break;
+                                                }
+                                        }
+                                        if(unionErrors.length){
+                                                return unionErrors;
+                                        }
+                                }
+                                else if(typeof type == 'object') {
+                                        checkProp(value,type,path);
+                                } 
+                        }
+                        return [];
+                }
+                if(value !== null) {
+                        if(value === undefined) {
+                                if(!schema.optional){  
+                                        addError("is missing and it is not optional");
+                                }
+                        }
+                        else {
+                                errors = errors.concat(checkType(schema.type,value));
+                                if(schema.disallow && !checkType(schema.disallow,value).length){
+                                        addError(" disallowed value was matched");
+                                }
+                                if(value instanceof Array) {
+                                        if(schema.items) {
+                                                for (var i =0,l=value.length; i < l; i++) {
+                                                        errors.concat(checkProp(value[i],schema.items,path,i));
+                                                }                                                       
+                                        }
+                                        if(schema.minItems && value.length < schema.minItems) {
+                                                addError("There must be a minimum of " + schema.minItems + " in the array");
+                                        }
+                                        if(schema.maxItems && value.length > schema.maxItems) {
+                                                addError("There must be a maximum of " + schema.maxItems + " in the array");
+                                        }
+                                }
+                                else if(schema.properties && typeof value == 'object') {
+                                        errors.concat(checkObj(value,schema.properties,path,schema.additionalProperties));
+                                }
+                                if(schema.pattern && typeof value == 'string' && !value.match(schema.pattern)){
+                                        addError("does not match the regex pattern " + schema.pattern);
+                                }
+                                if(schema.maxLength && typeof value == 'string' && value.maxLength > schema.maxLength){
+                                        addError("may only be " + schema.maxLength + " characters long");
+                                }
+                                if(schema.minLength && typeof value == 'string' && value.minLength < schema.minLength){
+                                        addError("must be at least " + schema.minLength + " characters long");
+                                }
+                                if(typeof schema.minimum !== undefined && typeof value == typeof schema.minimum && schema.minimum > value){
+                                        addError("must have a minimum value of " + schema.minimum);
+                                }
+                                if(typeof schema.maximum !== undefined && typeof value == typeof schema.maximum && schema.maximum < value){
+                                        addError("must have a maximum value of " + schema.maximum);
+                                }
+                                if(schema.options && !schema.unconstrained) {
+                                        var l = schema.options.length;
+                                        var found;
+                                        for(var j = 0; j < l; j++){
+                                                if(schema.options[j].value===value) {
+                                                        found=1;
+                                                        break;
+                                                }
+                                        }
+                                        if(!found) {
+                                                var labels = [];
+                                                var options = schema.options;
+                                                for (var i = 0;i < options.length;i++) {
+                                                        labels.push(options[i].label || options[i].value);
+                                                }
+                                                addError("does not have a value in the options " + labels.join(", "));
+                                        }
+                                }
+                                if(typeof schema.maxDecimal == 'number' && (value * 10^schema.maxDecimal)%1){
+                                        addError("may only have " + schema.maxDecimal + " digits of decimal places");
+                                }
+                        }
+                }
+        
+        }
+        // validate an object against a schema
+        function checkObj(instance,objTypeDef,path,additionalProp) {
+        
+                if(typeof objTypeDef =='object') {
+                        if(typeof instance != 'object' || instance instanceof Array){
+                                errors.push({property:path,message:"an object is required"});
+                        }
+                        
+                        for(var i in objTypeDef){
+                                if(objTypeDef.hasOwnProperty(i)) {
+                                        var value = instance[i];
+                                        var propDef = objTypeDef[i];
+                                        checkProp(value,propDef,path,i);
+                                }
+                        }
+                }
+                for (var i in instance) {
+                        if(instance.hasOwnProperty(i) && objTypeDef && !objTypeDef[i] && additionalProp===false){
+                                errors.push({property:path,message:(typeof value) + "The property " + i + " is not defined in the objTypeDef and the objTypeDef does not allow additional properties"});
+                        }
+                        var requires = objTypeDef && objTypeDef[i] && objTypeDef[i].requires;
+                        if(requires && !(requires in instance)){
+                                errors.push({property:path,message:"the presence of the property " + i + " requires that " + requires + " also be present"});
+                        }
+                        value = instance[i];
+                        if(objTypeDef && typeof objTypeDef == 'object' && !(i in objTypeDef)){
+                                checkProp(value,additionalProp,path,i); 
+                        }
+//                              if(!_changing && value && value.type)
+//                              errors = errors.concat(checkObj(value,value.type,path + '.' + i));
+                        if(!_changing && value && value.$schema){
+                                errors = errors.concat(checkProp(value,value.$schema,path,i));
+                        }
+                }
+                return errors;
+        }
+        if(schema){
+                checkProp(instance,schema,'','');
+        }
+        if(!_changing && instance.$schema){
+                checkProp(instance,instance.$schema,'','');
+        }
+        return {valid:!errors.length,errors:errors};
+};
+/* will add this later
+        newFromSchema : function() {
+        }
+*/

tests/jsonSchema.js

@@ +1 @@
+dojo.provide("dojox.validate.tests.jsonSchema");
+dojo.require("dojox.validate.jsonSchema");
+dojo.require("dojox.json.ref");
+
+var simpleObj = {
+  "name" : "John Doe",
+  "age" : 30,
+  "schema":{
+          "type" : {
+            "name": {"type":"string",
+               "required":true},
+            "age" : {"type":"number",
+              "maximum":125}
+          }
+  }
+}
+var biggerObj = {
+  "name" : "John Doe",
+  "born" : "1979-03-23T06:26:07Z",
+  "gender" : "male",
+  tuple:[1,"a",false],
+  "address" : {"street":"123 S Main St",
+    "city":"Springfield",
+    "state":"CA"}
+  
+}
+var invalidBiggerObj = {
+  "name" : "John Doe",
+  "born" : false,
+  "gender" : "mal",
+  "address" : {"street":"123 S Main St",
+    "city":"Springfield",
+    "state":"CA"}
+  
+}
+var biggerSchema = {
+  "readonly":true,
+  "type":"object",
+  "properties":{
+    "name": {"type":"string",
+           length:5,
+       "optional":false},
+    "tuple":[{"type":"integer"},
+    {"type":"string"},
+    {"type":"boolean"}],
+    "born" : {"type":["number","string"], //allow for a numeric year, or a full date
+      "format":"date", //format when a string value is used
+      "minimum":1900, //min/max for when a number value is used
+      "maximum":2010
+    },
+    "gender" : {"type":"string",
+        "options":[{"label":"Male",value:"male"},{"label":"Female",value:"female"}]},
+            "address" : {"type":"object",
+                "properties":
+                {"street":{"type":"string"},
+                 "city":{"type":"string"},
+                 "state":{"type":"string"}}
+            }
+  }
+ }
+ var schemaForSchemas ={"description":"This is the JSON Schema for JSON Schemas.",
+ "type":["object","array"],
+ "items":{
+     "type":"object",
+     "properties":{"$ref":"$.properties"},
+     "description":"When the schema is an array, it indicates that it is enforcing tuple typing. Each item in the instance array must correspond to the item in the schema array"},
+ "properties":{
+     "type":{
+        "type":["string","array"],
+        "items":{"$ref":"$.properties.type"},
+        "description":"This is a type definition value. This can be a simple type, or a union type",
+        "options":["string","object","array","boolean","number","integer","null","any"],
+        "unconstrained":true,
+        "optional":true,
+        "default":"any"},
+     "optional":{
+        "type":"boolean",
+        "description":"This indicates that the instance property in the instance object is not required.",
+        "optional":true,
+        "default":false},
+     "properties":{
+        "type":"object",
+        "additionalProperties":{"$ref":"$"},
+        "description":"This is a definition for the properties of an object value",
+        "optional":true,
+        "default":{}
+     },
+     "items":{
+        "type":"object",
+        "properties":{"$ref":"$.properties"},
+        "description":"When the value is an array, this indicates the schema to use to validate each item in an array",
+        "optional":true,
+        "default":{}},
+     "additionalProperties":{
+        "type":["boolean","object"],
+        "properties":{"$ref":"$.properties"},
+        "description":"This provides a default property definition for all properties that are not explicitly defined in an object type definition.",
+        "optional":true,
+        "default":{}},
+     "specificity":{
+        "type":"number",
+        "description":"This indicates an order of specificity of properties. If an instance defines another property with a higher specificity than this one, than this instance property is required.",
+        "optional":true,
+        "default":false},
+     "unique":{
+        "type":"boolean",
+        "description":"This indicates that the instance property should have unique values. No other property with the same name in the instance object tree should have the same value.",
+        "optional":true,
+        "default":false},
+     "minimum":{
+        "type":"number",
+        "optional":true,
+        "description":"This indicates the minimum value for the instance property when the type of the instance value is a number, or it indicates the minimum number of values in an array when an array is the instance value."},
+     "maximum":{
+        "type":"number",
+        "optional":true,
+        "description":"This indicates the maximum value for the instance property when the type of the instance value is a number, or it indicates the maximum number of values in an array when an array is the instance value."},
+     "pattern":{
+        "type":"string",
+        "format":"regex",
+        "description":"When the instance value is a string, this provides a regular expression that a instance string value should match in order to be valid.",
+        "optional":true,
+        "default":".*"},
+     "maxLength" :{
+        "type":"number",
+        "optional":true,
+        "description":"When the instance value is a string, this indicates maximum length of the string."},
+     "minLength" :{
+        "type":"number",
+        "optional":true,
+        "description":"When the instance value is a string, this indicates minimum length of the string."},
+     "maxItems" :{
+        "type":"number",
+        "optional":true,
+        "description":"When the instance value is an array, this indicates maximum number of items."},
+     "minItems" :{
+        "type":"number",
+        "optional":true,
+        "description":"When the instance value is an array, this indicates minimum number of items."},
+     "options" : {
+        "type":[],
+        "optional":true,
+        "description":"This provides an enumeration of possible values that are valid for the instance property."},
+     "unconstrained":{
+        "type":"boolean",
+        "description":"When used in conjunction with the options property, this indicates a value can be used that is not in the list of options. This has no meaning when the options property is not a sibling.",
+        "optional":true,
+        "default":false},
+     "readonly":{
+        "type":"boolean",
+        "description":"This indicates that the instance property should not be changed (this is only for interaction, it has no effect for standalone validation).",
+        "optional":true,
+        "default":false},
+     "description":{
+        "type":"string",
+        "optional":true,
+        "description":"This provides a description of the purpose the instance property. The value can be a string or it can be an object with properties corresponding to various different instance languages (with an optional default property indicating the default description)."},
+     "format":{
+        "type":"string",
+        "optional":true,
+        "description":"This indicates what format the data is among some predefined formats which may include:\n\ndate - a string following the ISO format \naddress \nschema - a schema definition object \nperson \npage \nhtml - a string representing HTML"},
+     "default":{
+        "type":"any",
+        "optional":true,
+        "description":"This indicates the default for the instance property."},
+     "transient":{
+        "type":"boolean",
+        "optional":true,
+        "description":"This indicates that the property will be used for transient/volatile values that should not be persisted.",
+        "default":false},
+     "maxDecimal":{
+        "type":"integer",
+        "optional":true,
+        "description":"This indicates the maximum number of decimal places in a floating point number."},
+     "hidden":{
+        "type":"boolean",
+        "optional":true,
+        "description":"This indicates whether the property should be hidden in user interfaces."},      
+     "extends":{
+        "type":"object",
+        "properties":{"$ref":"$.properties"},
+        "description":"This indicates the schema extends the given schema. All instances of this schema must be valid to by the extended schema also.",
+        "optional":true,
+        "default":{}},          
+     "id":{
+        "type":["string","number"],
+        "optional":true,
+        "format":"url",
+        "unique":true}
+   }
+}
+schemaForSchemas = dojox.json.ref.resolveJson(schemaForSchemas);
+doh.register("dojox.validate.tests.jsonSchema",
+        [{
+                name:"isValidForSchema",
+                runTest: function(t) {
+                        doh.t(dojox.validate.jsonSchema.validate(simpleObj).valid); //a simple self-validating test
+                        doh.t(dojox.validate.jsonSchema.validate(biggerObj,biggerSchema).valid); //a bigger instance and schema
+                        doh.f(dojox.validate.jsonSchema.validate(invalidBiggerObj,biggerSchema).valid); //should have two errors
+                        doh.t(dojox.validate.jsonSchema.validate(schemaForSchemas,schemaForSchemas).valid); //test the schema for schemas against it's self. Narcissitic testing
+                        doh.t(dojox.validate.jsonSchema.validate(biggerSchema,schemaForSchemas).valid); //Test the big schema against the schema for schemas
+                }
+        },
+        {
+                name:"isValidPropertyChange", 
+                runTest: function(t) {
+                        doh.f(dojox.validate.jsonSchema.checkPropertyChange(biggerObj,biggerSchema).valid); //this should fail because of the 
+                        doh.t(dojox.validate.jsonSchema.checkPropertyChange(schemaForSchemas,schemaForSchemas).valid); //schema should be valid
+                }
+        }       
+]);