Merge branch 'master' of git://github.com/dvv/json-schema

Conflicts:
	lib/validate.js

Author: kriszyp

lib/validate.js

@@ -1,15 +1,15 @@
-/** 
- * JSONSchema Validator - Validates JavaScript objects using JSON Schemas 
+/**
+ * JSONSchema Validator - Validates JavaScript objects using JSON Schemas
  *	(http://www.json.com/json-schema-proposal/)
  *
  * Copyright (c) 2007 Kris Zyp SitePen (www.sitepen.com)
  * Licensed under the MIT (MIT-LICENSE.txt) license.
 To use the validator call the validate function 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). 
-The validate method will return an array of validation errors. If there are no errors, then an 
-empty list will be returned. A validation error will have two properties: 
+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).
+The validate method will return 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
  */
@@ -24,43 +24,47 @@ exports.Integer = {type:"integer"};
 Object.type = "object";
 Array.type = "array";
 Date.type = "date";
-exports.validate = validate; 
+exports.validate = validate;
 function validate(/*Any*/instance,/*Object*/schema) {
 		// Summary:
 		//  	To use the validator call JSONSchema.validate 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). 
+		// 		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).
 		// 		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: 
+		// 			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 validate(instance,schema,false);
+		return validate(instance, schema, {changing: false});//, coerce: false, existingOnly: false});
 	};
-exports.checkPropertyChange = function(/*Any*/value,/*Object*/schema, /*String*/ property) {
+exports.checkPropertyChange = function(/*Any*/value,/*Object*/schema, /*String*/property) {
 		// 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 
+		// 		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.
 		//
-		return validate(value,schema, property || "property");
+		return validate(value, schema, {changing: property || "property"});
 	};
-var validate = exports._validate = function(/*Any*/instance,/*Object*/schema,/*Boolean*/ _changing) {
-	
+var validate = exports._validate = function(/*Any*/instance,/*Object*/schema,/*Object*/options) {
+
+	if (!options) options = {};
+	var _changing = options.changing;
+
 	var errors = [];
-		// validate a value against a property definition
+	// validate a value against a property definition
 	function checkProp(value, schema, path,i){
+
 		var l;
 		path += path ? typeof i == 'number' ? '[' + i + ']' : typeof i == 'undefined' ? '' : '.' + i : i;
 		function addError(message){
 			errors.push({property:path,message:message});
 		}
-		
+
 		if((typeof schema != 'object' || schema instanceof Array) && (path || typeof schema != 'function') && !(schema && schema.type)){
 			if(typeof schema == 'function'){
 				if(!(value instanceof schema)){
@@ -80,16 +84,16 @@ var validate = exports._validate = function(/*Any*/instance,/*Object*/schema,/*B
 		// 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) && 
+				if(typeof type == 'string' && type != 'any' &&
+						(type == 'null' ? value !== null : typeof value != type) &&
 						!(value instanceof Array && type == 'array') &&
 						!(value instanceof Date && type == 'date') &&
 						!(type == 'integer' && value%1===0)){
 					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 
+					for(var j = 0; j < type.length; j++){ // a union type
 						if(!(unionErrors=checkType(type[j],value)).length){
 							break;
 						}
@@ -99,17 +103,17 @@ var validate = exports._validate = function(/*Any*/instance,/*Object*/schema,/*B
 					}
 				}else if(typeof type == 'object'){
 					var priorErrors = errors;
-					errors = []; 
+					errors = [];
 					checkProp(value,type,path);
 					var theseErrors = errors;
 					errors = priorErrors;
-					return theseErrors; 
-				} 
+					return theseErrors;
+				}
 			}
 			return [];
 		}
 		if(value === undefined){
-			if(!schema.optional && !schema.get){  
+			if(!schema.optional && !schema.get){
 				addError("is missing and it is not optional");
 			}
 		}else{
@@ -120,15 +124,15 @@ var validate = exports._validate = function(/*Any*/instance,/*Object*/schema,/*B
 			if(value !== null){
 				if(value instanceof Array){
 					if(schema.items){
-						if(schema.items instanceof Array){
-							for(i=0,l=value.length; i<l; i++){
-								errors.concat(checkProp(value[i],schema.items[i],path,i));
-							}
-						}else{
-							for(i=0,l=value.length; i<l; i++){
-								errors.concat(checkProp(value[i],schema.items,path,i));
-							}
-						}							
+						var itemsIsArray = schema.items instanceof Array;
+						var propDef = schema.items;
+						for (i = 0, l = value.length; i < l; i += 1) {
+							if (itemsIsArray)
+								propDef = schema.items[i];
+							if (options.coerce)
+								value[i] = options.coerce(value[i], propDef);
+							errors.concat(checkProp(value[i],propDef,path,i));
+						}
 					}
 					if(schema.minItems && value.length < schema.minItems){
 						addError("There must be a minimum of " + schema.minItems + " in the array");
@@ -148,11 +152,11 @@ var validate = exports._validate = function(/*Any*/instance,/*Object*/schema,/*B
 				if(schema.minLength && typeof value == 'string' && value.length < schema.minLength){
 					addError("must be at least " + schema.minLength + " characters long");
 				}
-				if(typeof schema.minimum !== undefined && typeof value == typeof schema.minimum && 
+				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 && 
+				if(typeof schema.maximum !== undefined && typeof value == typeof schema.maximum &&
 						schema.maximum < value){
 					addError("must have a maximum value of " + schema.maximum);
 				}
@@ -170,7 +174,7 @@ var validate = exports._validate = function(/*Any*/instance,/*Object*/schema,/*B
 						addError("does not have a value in the enumeration " + enumer.join(", "));
 					}
 				}
-				if(typeof schema.maxDecimal == 'number' && 
+				if(typeof schema.maxDecimal == 'number' &&
 					(value.toString().match(new RegExp("\\.[0-9]{" + (schema.maxDecimal + 1) + ",}")))){
 					addError("may only have " + schema.maxDecimal + " digits of decimal places");
 				}
@@ -180,7 +184,7 @@ var validate = exports._validate = function(/*Any*/instance,/*Object*/schema,/*B
 	}
 	// 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"});
@@ -189,33 +193,40 @@ var validate = exports._validate = function(/*Any*/instance,/*Object*/schema,/*B
 			for(var i in objTypeDef){ 
 				if(objTypeDef.hasOwnProperty(i)){
 					var value = instance[i];
+					// skip _not_ specified properties
+					if (value === undefined && options.existingOnly) continue;
 					var propDef = objTypeDef[i];
-                    // set default
-                    if(value === undefined && propDef["default"]){
-                        value = instance[i] = propDef["default"];
-                    }
-                    if(propDef.coerce && exports.coerce && i in instance){
-                    	value = instance[i] = exports.coerce(value, propDef);
-                    }
+					// set default
+					if(value === undefined && propDef["default"]){
+						value = instance[i] = propDef["default"];
+					}
+					if(options.coerce && i in instance){
+						value = instance[i] = options.coerce(value, propDef);
+					}
 					checkProp(value,propDef,path,i);
 				}
 			}
 		}
 		for(i in instance){
 			if(instance.hasOwnProperty(i) && !(i.charAt(0) == '_' && i.charAt(1) == '_') && objTypeDef && !objTypeDef[i] && additionalProp===false){
-				errors.push({property:path,message:(typeof value) + "The property " + i +
+				if (options.filter) {
+					delete instance[i];
+					continue;
+				} else {
+					errors.push({property:path,message:(typeof value) + "The property " + i +
 						" is not defined in the schema and the schema 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(additionalProp && (!(objTypeDef && typeof objTypeDef == 'object') || !(i in objTypeDef))){
-                if(additionalProp.coerce && exports.coerce){
-                	value = instance[i] = exports.coerce(value, additionalProp);
-                }
-				checkProp(value,additionalProp,path,i); 
+				if(options.coerce){
+					value = instance[i] = options.coerce(value, additionalProp);
+				}
+				checkProp(value,additionalProp,path,i);
 			}
 			if(!_changing && value && value.$schema){
 				errors = errors.concat(checkProp(value,value.$schema,path,i));
@@ -237,8 +248,8 @@ exports.mustBeValid = function(result){
 	// result: the result returned from checkPropertyChange or validate
 	if(!result.valid){
 		throw new TypeError(result.errors.map(function(error){return "for property " + error.property + ': ' + error.message;}).join(", \n"));
-	}	
+	}
 }
 
 return exports;
-});
+});