canjs-rails 0.1.0

data/vendor/assets/javascripts/can.observe.delegate.js

@@ -0,0 +1,359 @@
+(function(can, window, undefined){
+	
+	
+	
+	// ** - 'this' will be the deepest item changed
+	// * - 'this' will be any changes within *, but * will be the 
+	//     this returned
+	
+	// tells if the parts part of a delegate matches the broken up props of the event
+	// gives the prop to use as 'this'
+	// - parts - the attribute name of the delegate split in parts ['foo','*']
+	// - props - the split props of the event that happened ['foo','bar','0']
+	// - returns - the attribute to delegate too ('foo.bar'), or null if not a match 
+	var matches = function(parts, props){
+		//check props parts are the same or 
+		var len = parts.length,
+			i =0,
+			// keeps the matched props we will use
+			matchedProps = [],
+			prop;
+		
+		// if the event matches
+		for(i; i< len; i++){
+			prop =  props[i]
+			// if no more props (but we should be matching them)
+			// return null
+			if( typeof prop !== 'string' ) {
+				return null;
+			} else
+			// if we have a "**", match everything
+			if( parts[i] == "**" ) {
+				return props.join(".");
+			} else 
+			// a match, but we want to delegate to "*"
+			if (parts[i] == "*"){
+				// only do this if there is nothing after ...
+				matchedProps.push(prop);
+			}
+			else if(  prop === parts[i]  ) {
+				matchedProps.push(prop);
+			} else {
+				return null;
+			}
+		}
+		return matchedProps.join(".");
+	},
+		// gets a change event and tries to figure out which
+		// delegates to call
+		delegate = function(event, prop, how, newVal, oldVal){
+			// pre-split properties to save some regexp time
+			var props = prop.split("."),
+				delegates = (this._observe_delegates || []).slice(0),
+				delegate,
+				attr,
+				matchedAttr,
+				hasMatch,
+				valuesEqual;
+			event.attr = prop;
+			event.lastAttr = props[props.length -1 ];
+			
+			// for each delegate
+			for(var i =0; delegate = delegates[i++];){
+				
+				// if there is a batchNum, this means that this
+				// event is part of a series of events caused by a single 
+				// attrs call.  We don't want to issue the same event
+				// multiple times
+				// setting the batchNum happens later
+				if((event.batchNum && delegate.batchNum === event.batchNum) || delegate.undelegated ){
+					continue;
+				}
+				
+				// reset match and values tests
+				hasMatch = undefined;
+				valuesEqual = true;
+				
+				// for each attr in a delegate
+				for(var a =0 ; a < delegate.attrs.length; a++){
+					
+					attr = delegate.attrs[a];
+					
+					// check if it is a match
+					if(matchedAttr = matches(attr.parts, props)){
+						hasMatch = matchedAttr;
+					}
+					// if it has a value, make sure it's the right value
+					// if it's set, we should probably check that it has a 
+					// value no matter what
+					if(attr.value && valuesEqual /* || delegate.hasValues */){
+						valuesEqual = attr.value === ""+this.attr(attr.attr)
+					} else if (valuesEqual && delegate.attrs.length > 1){
+						// if there are multiple attributes, each has to at
+						// least have some value
+						valuesEqual = this.attr(attr.attr) !== undefined
+					}
+				}
+				
+				// if there is a match and valuesEqual ... call back
+
+				if(hasMatch && valuesEqual) {
+					// how to get to the changed property from the delegate
+					var from = prop.replace(hasMatch+".","");
+					
+					// if this event is part of a batch, set it on the delegate
+					// to only send one event
+					if(event.batchNum ){
+						delegate.batchNum = event.batchNum
+					}
+					
+					// if we listen to change, fire those with the same attrs
+					// TODO: the attrs should probably be using from
+					if(  delegate.event === 'change' ){
+						arguments[1] = from;
+						event.curAttr = hasMatch;
+						delegate.callback.apply(this.attr(hasMatch), can.makeArray( arguments));
+					} else if(delegate.event === how ){
+						
+						// if it's a match, callback with the location of the match
+						delegate.callback.apply(this.attr(hasMatch), [event,newVal, oldVal, from]);
+					} else if(delegate.event === 'set' && 
+							 how == 'add' ) {
+						// if we are listening to set, we should also listen to add
+						delegate.callback.apply(this.attr(hasMatch), [event,newVal, oldVal, from]);
+					}
+				}
+				
+			}
+		};
+		
+	can.extend(can.Observe.prototype,{
+		/**
+		 * @function can.Observe.prototype.delegate
+		 * @parent can.Observe.delegate
+		 * @plugin can/observe/delegate
+		 * 
+		 * `delegate( selector, event, handler(ev,newVal,oldVal,from) )` listen for changes 
+		 * in a child attribute from the parent. The child attribute
+		 * does not have to exist.
+		 * 
+		 *     
+		 *     // create an observable
+		 *     var observe = can.Observe({
+		 *       foo : {
+		 *         bar : "Hello World"
+		 *       }
+		 *     })
+		 *     
+		 *     //listen to changes on a property
+		 *     observe.delegate("foo.bar","change", function(ev, prop, how, newVal, oldVal){
+		 *       // foo.bar has been added, set, or removed
+		 *       this //-> 
+		 *     });
+		 * 
+		 *     // change the property
+		 *     observe.attr('foo.bar',"Goodbye Cruel World")
+		 * 
+		 * ## Types of events
+		 * 
+		 * Delegate lets you listen to add, set, remove, and change events on property.
+		 * 
+		 * __add__
+		 * 
+		 * An add event is fired when a new property has been added.
+		 * 
+		 *     var o = new can.Control({});
+		 *     o.delegate("name","add", function(ev, value){
+		 *       // called once
+		 *       can.$('#name').show()
+		 *     })
+		 *     o.attr('name',"Justin")
+		 *     o.attr('name',"Brian");
+		 *     
+		 * Listening to add events is useful for 'setup' functionality (in this case
+		 * showing the <code>#name</code> element.
+		 * 
+		 * __set__
+		 * 
+		 * Set events are fired when a property takes on a new value.  set events are
+		 * always fired after an add.
+		 * 
+		 *     o.delegate("name","set", function(ev, value){
+		 *       // called twice
+		 *       can.$('#name').text(value)
+		 *     })
+		 *     o.attr('name',"Justin")
+		 *     o.attr('name',"Brian");
+		 * 
+		 * __remove__
+		 * 
+		 * Remove events are fired after a property is removed.
+		 * 
+		 *     o.delegate("name","remove", function(ev){
+		 *       // called once
+		 *       $('#name').text(value)
+		 *     })
+		 *     o.attr('name',"Justin");
+		 *     o.removeAttr('name');
+		 * 
+		 * ## Wildcards - matching multiple properties
+		 * 
+		 * Sometimes, you want to know when any property within some part 
+		 * of an observe has changed. Delegate lets you use wildcards to 
+		 * match any property name.  The following listens for any change
+		 * on an attribute of the params attribute:
+		 * 
+		 *     var o = can.Control({
+		 *       options : {
+		 *         limit : 100,
+		 *         offset: 0,
+		 *         params : {
+		 *           parentId: 5
+		 *         }
+		 *       }
+		 *     })
+		 *     o.delegate('options.*','change', function(){
+		 *       alert('1');
+		 *     })
+		 *     o.delegate('options.**','change', function(){
+		 *       alert('2');
+		 *     })
+		 *     
+		 *     // alerts 1
+		 *     // alerts 2
+		 *     o.attr('options.offset',100)
+		 *     
+		 *     // alerts 2
+		 *     o.attr('options.params.parentId',6);
+		 * 
+		 * Using a single wildcard (<code>*</code>) matches single level
+		 * properties.  Using a double wildcard (<code>**</code>) matches
+		 * any deep property.
+		 * 
+		 * ## Listening on multiple properties and values
+		 * 
+		 * Delegate lets you listen on multiple values at once.  The following listens
+		 * for first and last name changes:
+		 * 
+		 *     var o = new can.Observe({
+		 *       name : {first: "Justin", last: "Meyer"}
+		 *     })
+		 *     
+		 *     o.bind("name.first,name.last", 
+		 *            "set",
+		 *            function(ev,newVal,oldVal,from){
+		 *     
+		 *     })
+		 * 
+		 * ## Listening when properties are a particular value
+		 * 
+		 * Delegate lets you listen when a property is __set__ to a specific value:
+		 * 
+		 *     var o = new can.Observe({
+		 *       name : "Justin"
+		 *     })
+		 *     
+		 *     o.bind("name=Brian", 
+		 *            "set",
+		 *            function(ev,newVal,oldVal,from){
+		 *     
+		 *     })
+		 * 
+		 * @param {String} selector The attributes you want to listen for changes in.
+		 * 
+		 *   Selector should be the property or 
+		 *   property names of the element you are searching.  Examples:
+		 * 
+		 *     "name" - listens to the "name" property changing
+		 *     "name, address" - listens to "name" or "address" changing
+		 *     "name address" - listens to "name" or "address" changing
+		 *     "address.*" - listens to property directly in address
+		 *     "address.**" - listens to any property change in address
+		 *     "foo=bar" - listens when foo is "bar"
+		 * 
+		 * @param {String} event The event name.  One of ("set","add","remove","change")
+		 * @param {Function} handler(ev,newVal,oldVal,prop) The callback handler 
+		 * called with:
+		 * 
+		 *  - newVal - the new value set on the observe
+		 *  - oldVal - the old value set on the observe
+		 *  - prop - the prop name that was changed
+		 * 
+		 * @return {jQuery.Delegate} the delegate for chaining
+		 */
+		delegate :  function(selector, event, handler){
+			selector = can.trim(selector);
+			var delegates = this._observe_delegates || (this._observe_delegates = []),
+				attrs = [];
+			
+			// split selector by spaces
+			selector.replace(/([^\s=]+)=?([^\s]+)?/g, function(whole, attr, value){
+			  attrs.push({
+			  	// the attribute name
+				attr: attr,
+				// the attribute's pre-split names (for speed)
+				parts: attr.split('.'),
+				// the value associated with this prop
+				value: value
+			  })
+			}); 
+			
+			// delegates has pre-processed info about the event
+			delegates.push({
+				// the attrs name for unbinding
+				selector : selector,
+				// an object of attribute names and values {type: 'recipe',id: undefined}
+				// undefined means a value was not defined
+				attrs : attrs,
+				callback : handler,
+				event: event
+			});
+			if(delegates.length === 1){
+				this.bind("change",delegate)
+			}
+			return this;
+		},
+		/**
+		 * @function can.Observe.prototype.undelegate
+		 * @parent can.Observe.delegate
+		 * 
+		 * `undelegate( selector, event, handler )` removes a delegated event handler from an observe.
+		 * 
+		 *     observe.undelegate("name","set", handler )
+		 * 
+		 * @param {String} selector the attribute name of the object you want to undelegate from.
+		 * @param {String} event the event name
+		 * @param {Function} handler the callback handler
+		 * @return {jQuery.Delegate} the delegate for chaining
+		 */
+		undelegate : function(selector, event, handler){
+			selector = can.trim(selector);
+			
+			var i =0,
+				delegates = this._observe_delegates || [],
+				delegateOb;
+			if(selector){
+				while(i < delegates.length){
+					delegateOb = delegates[i];
+					if( delegateOb.callback === handler ||
+						(!handler && delegateOb.selector === selector) ){
+						delegateOb.undelegated = true;
+						delegates.splice(i,1)
+					} else {
+						i++;
+					}
+				}
+			} else {
+				// remove all delegates
+				delegates = [];
+			}
+			if(!delegates.length){
+				//can.removeData(this, "_observe_delegates");
+				this.unbind("change",delegate)
+			}
+			return this;
+		}
+	});
+	// add helpers for testing .. 
+	can.Observe.prototype.delegate.matches = matches;
+})(this.can, this )

data/vendor/assets/javascripts/can.observe.setter.js

@@ -0,0 +1,58 @@
+(function(can, window, undefined){
+
+/**
+ * Like [can.camelize|camelize], but the first part is also capitalized
+ * @param {String} s
+ * @return {String} the classized string
+ */
+can.classize =  function( s , join) {
+	// this can be moved out ..
+	// used for getter setter
+	var parts = s.split(can.undHash),
+		i = 0;
+	for (; i < parts.length; i++ ) {
+		parts[i] = can.capitalize(parts[i]);
+	}
+
+	return parts.join(join || '');
+}
+
+var classize = can.classize,
+	proto =  can.Observe.prototype,
+	old = proto.__set;
+
+proto.__set = function(prop, value, current, success, error){
+	// check if there's a setter
+	var cap = classize(prop),
+		setName = "set" + cap,
+		errorCallback = function( errors ) {
+			var stub = error && error.call(self, errors);
+			
+			// if 'setter' is on the page it will trigger
+			// the error itself and we dont want to trigger
+			// the event twice. :)
+			if(stub !== false){
+				can.trigger(self, "error", [prop, errors], true);
+			}
+			
+			return false;
+		},
+		self = this;
+		
+	// if we have a setter
+	if ( this[setName] &&
+		// call the setter, if returned value is undefined,
+		// this means the setter is async so we 
+		// do not call update property and return right away
+		( value = this[setName](value, 
+			function(){ old.call(self,prop, value, current, success, errorCallback) },
+			errorCallback ) ) === undefined ) {
+		return;
+	}
+	
+	old.call(self,prop, value, current, success, errorCallback);
+	
+	return this;
+};
+
+})(this.can, this )

data/vendor/assets/javascripts/can.observe.validations.js

@@ -0,0 +1,374 @@
+(function(can, window, undefined){
+//validations object is by property.  You can have validations that
+//span properties, but this way we know which ones to run.
+//  proc should return true if there's an error or the error message
+var validate = function(attrNames, options, proc) {
+	// normalize argumetns
+	if(!proc){
+		proc = options;
+		options = {};
+	}
+	
+	options = options || {};
+	attrNames = can.makeArray(attrNames)
+	
+	// run testIf if it exists
+	if(options.testIf && !options.testIf.call(this)){
+		return;
+	}
+	
+	var self = this;
+	can.each(attrNames, function(attrName) {
+		// Add a test function for each attribute
+		if(!self.validations[attrName]){
+			self.validations[attrName] = [];
+		}
+		
+		self.validations[attrName].push(function(newVal){
+			// if options has a message return that, otherwise, return the error
+			var res = proc.call(this, newVal, attrName);
+			return res === undefined ? undefined : (options.message || res);
+		})
+	});   
+};
+
+var old = can.Observe.prototype.__set;
+can.Observe.prototype.__set = function(prop, value, current, success, error){	
+	var self = this,
+		validations = self.constructor.validations,
+		errorCallback = function( errors ) {
+			var stub = error && error.call(self, errors);
+			
+			// if 'setter' is on the page it will trigger
+			// the error itself and we dont want to trigger
+			// the event twice. :)
+			if(stub !== false){
+				can.trigger(self, "error", [prop, errors], true);
+			}
+			
+			return false;
+		};
+	
+	old.call(self, prop, value, current, success, errorCallback);
+	
+	if (validations && validations[prop]){
+		var errors = self.errors(prop);
+		errors && errorCallback(errors)
+	}
+	
+	return this;
+}
+
+can.each([ can.Observe, can.Model ], function(clss){
+	// in some cases model might not be defined quite yet.
+	if(clss === undefined){
+		return;
+	}
+	var oldSetup = clss.setup;
+	
+	can.extend(clss, {
+		setup : function(superClass){
+			oldSetup.apply(this, arguments);
+			if (!this.validations || superClass.validations === this.validations) {
+				this.validations = {};
+			}
+		},
+   		/**
+    	* @function can.Observe.static.validate
+    	* @parent can.Observe.validations
+    	* `validate(attrNames, [options,] validateProc(value, attrName) )` validates each of the 
+    	* specified attributes with the given `validateProc` function.  The function
+    	* should return a value if there is an error.  By default, the return value is
+    	* the error message.  Validations should be set in the Constructor's static init method.
+    	* 
+    	* The following example validates that a person's age is a number:
+    	* 
+    	*     Person = can.Observe({
+    	* 	    init : function(){
+    	* 	      this.validate(["age"], function(val){
+    	* 	        if( typeof val === 'number' ){
+    	* 	    	  return "must be a number"
+    	* 	        }
+    	* 	      })
+    	* 	    }
+    	*     },{})
+    	* 
+    	* 
+    	* The error message can be overwritten with `options` __message__ property:
+    	* 
+    	*     Person = can.Observe({
+    	* 	    init : function(){
+    	* 	      this.validate(
+    	* 	        "age", 
+    	*           {message: "must be a number"}, 
+    	*           function(val){
+    	* 	          if( typeof val === 'number' ){
+    	* 	    	    return true
+    	* 	          }
+    	* 	      })
+    	*       }
+    	*     },{})
+    	* 
+    	* @param {Array|String} attrNames Attribute name(s) to to validate
+    	* 
+    	* @param {Object} [options] Options for the 
+    	* validations.  Valid options include 'message' and 'testIf'.
+    	* 
+    	* @param {Function} validateProc(value,attrName) Function used to validate each 
+    	* given attribute. Returns nothing if valid and an error message 
+    	* otherwise. Function is called in the instance context and takes the 
+    	* `value` and `attrName` to validate.
+    	* 
+    	*/
+   		validate: validate,
+   
+   		/**
+    	 * @attribute can.Observe.static.validationMessages
+    	 * @parent can.Observe.validations
+    	 * 
+    	 * `validationMessages` has the default validation error messages that will be returned by the builtin
+    	 * validation methods. These can be overwritten by assigning new messages
+    	 * to `can.Observe.validationMessages` in your application setup.
+    	 * 
+    	 * The following messages (with defaults) are available:
+    	 * 
+    	 *  * format - "is invalid"
+    	 *  * inclusion - "is not a valid option (perhaps out of range)"
+    	 *  * lengthShort - "is too short"
+    	 *  * lengthLong - "is too long"
+    	 *  * presence - "can't be empty"
+    	 *  * range - "is out of range"
+    	 * 
+    	 * It is important to steal can/observe/validations before 
+    	 * overwriting the messages, otherwise the changes will
+    	 * be lost once steal loads it later.
+    	 * 
+    	 * ## Example
+    	 * 
+    	 *     can.Observe.validationMessages.format = "is invalid dummy!"
+    	 */
+   		validationMessages : {
+       		format      : "is invalid",
+       		inclusion   : "is not a valid option (perhaps out of range)",
+       		lengthShort : "is too short",
+       		lengthLong  : "is too long",
+       		presence    : "can't be empty",
+       		range       : "is out of range"
+   		},
+
+   		/**
+    	 * @function can.Observe.static.validateFormatOf
+    	 * @parent can.Observe.validations
+    	 * 
+    	 * `validateFormatOf(attrNames, regexp, options)` validates where the values of 
+    	 * specified attributes are of the correct form by
+    	 * matching it against the regular expression provided.
+    	 * 
+    	 *     init : function(){
+    	 * 	     this.validateFormatOf(["email"],/[\w\.]+@]w+\.\w+/,{
+    	 * 	       message : "invalid email"
+    	 *       })
+    	 *     }
+    	 * 
+    	 * @param {Array|String} attrNames Attribute name(s) to to validate
+    	 * @param {RegExp} regexp Regular expression used to match for validation
+    	 * @param {Object} [options] Options for the validations.  Valid options include 'message' and 'testIf'.
+    	 */
+   		validateFormatOf: function(attrNames, regexp, options) {
+      		validate.call(this, attrNames, options, function(value) {
+         		if( (typeof value != 'undefined' && value != '')
+         			&& String(value).match(regexp) == null ) {
+            		return this.constructor.validationMessages.format;
+         		}
+      		});
+   		},
+
+   		/**
+    	 * @function can.Observe.static.validateInclusionOf
+    	 * @parent can.Observe.validations
+    	 * 
+    	 * Validates whether the values of the specified attributes are available in a particular
+    	 * array.
+    	 * 
+    	 *     init : function(){
+    	 *       this.validateInclusionOf(["salutation"],["Mr.","Mrs.","Dr."])  
+    	 *     }
+    	 * 
+    	 * @param {Array|String} attrNames Attribute name(s) to to validate
+    	 * @param {Array} inArray Array of options to test for inclusion
+    	 * @param {Object} [options] Options for the validations.  Valid options include 'message' and 'testIf'.
+    	 */
+   		validateInclusionOf: function(attrNames, inArray, options) {
+      		validate.call(this, attrNames, options, function(value) {
+         		if(typeof value == 'undefined'){
+					return;
+				}
+
+         		if(can.grep(inArray, function(elm) { return (elm == value); }).length == 0){
+					return this.constructor.validationMessages.inclusion;
+				}
+      		});
+   		},
+
+   		/**
+    	 * @function can.Observe.static.validateLengthOf
+    	 * @parent can.Observe.validations
+    	 * 
+    	 * Validates that the specified attributes' lengths are in the given range.  
+    	 * 
+    	 *     init : function(){
+    	 *       this.validateInclusionOf(["suffix"],3,5)  
+    	 *     }
+    	 * 
+    	 * @param {Number} min Minimum length (inclusive)
+    	 * @param {Number} max Maximum length (inclusive)
+    	 * @param {Object} [options] Options for the validations.  Valid options include 'message' and 'testIf'.
+    	 */
+   		validateLengthOf: function(attrNames, min, max, options) {
+      		validate.call(this, attrNames, options, function(value) {
+         		if((typeof value == 'undefined' && min > 0) || value.length < min){
+            		return this.constructor.validationMessages.lengthShort + " (min=" + min + ")";
+         		} else if(typeof value != 'undefined' && value.length > max){
+					return this.constructor.validationMessages.lengthLong + " (max=" + max + ")";
+				}	
+      		});
+   		},
+
+   		/**
+    	 * @function can.Observe.static.validatePresenceOf
+    	 * @parent can.Observe.validations
+    	 * 
+    	 * Validates that the specified attributes are not blank.
+    	 * 
+    	 *     init : function(){
+    	 *       this.validatePresenceOf(["name"])  
+    	 *     }
+    	 * 
+    	 * @param {Array|String} attrNames Attribute name(s) to to validate
+    	 * @param {Object} [options] Options for the validations.  Valid options include 'message' and 'testIf'.
+    	 */
+   		validatePresenceOf: function(attrNames, options) {
+      		validate.call(this, attrNames, options, function(value) {
+         		if(typeof value == 'undefined' || value == "" || value === null){
+					return this.constructor.validationMessages.presence;
+				}
+      		});
+   		},
+
+   		/**
+    	 * @function can.Observe.static.validateRangeOf
+    	 * @parent can.Observe.validations
+    	 * 
+    	 * Validates that the specified attributes are in the given numeric range.
+    	 * 
+    	 *     init : function(){
+    	 *       this.validateRangeOf(["age"],21, 130);  
+    	 *     }
+    	 * 
+    	 * @param {Array|String} attrNames Attribute name(s) to to validate
+    	 * @param {Number} low Minimum value (inclusive)
+    	 * @param {Number} hi Maximum value (inclusive)
+    	 * @param {Object} [options] (optional) Options for the validations.  Valid options include 'message' and 'testIf'.
+    	 */
+   		validateRangeOf: function(attrNames, low, hi, options) {
+      		validate.call(this, attrNames, options, function(value) {
+         		if(typeof value != 'undefined' && value < low || value > hi){
+					return this.constructor.validationMessages.range + " [" + low + "," + hi + "]";
+				}
+      		});
+   		}
+	});
+});
+
+can.extend(can.Observe.prototype, {
+
+	/**
+	 * @function can.Observe.prototype.errors
+	 * @parent can.Observe.validations
+	 * 
+	 * Runs the validations on this observe.  You can
+	 * also pass it an array of attributes to run only those attributes.
+	 * It returns nothing if there are no errors, or an object
+	 * of errors by attribute.
+	 * 
+	 * To use validations, it's suggested you use the 
+	 * observe/validations plugin.
+	 * 
+	 *     can.Observe("Task",{
+	 *       init : function(){
+	 *         this.validatePresenceOf("dueDate")
+	 *       }
+	 *     },{});
+	 * 
+	 *     var task = new Task(),
+	 *         errors = task.errors()
+	 * 
+	 *     errors.dueDate[0] //-> "can't be empty"
+	 * 
+	 * @param {Array|String} [attrs] An optional list of attributes to get errors for:
+	 * 
+	 *     task.errors(['dueDate','name']);
+	 * 
+	 * Or it can take a single attr name like:
+	 * 
+	 *     task.errors('dueDate')
+	 * 
+	 * @param {Object} [newVal] An optional new value to test setting
+	 * on the observe.  If `newVal` is provided, 
+	 * it returns the errors on the observe if `newVal` was set.
+	 * 
+	 * @return {Object} an object of attributeName : [errors] like:
+	 * 
+	 *     task.errors() // -> {dueDate: ["cant' be empty"]}
+	 * 
+	 * or `null` if there are no errors.
+	 */
+	errors: function( attrs , newVal) {
+		// convert attrs to an array
+		if ( attrs ) {
+			attrs = can.isArray(attrs) ? attrs : [attrs];
+		}
+		
+		var errors = {},
+			self = this,
+			attr,
+			// helper function that adds error messages to errors object
+			// attr - the name of the attribute
+			// funcs - the validation functions
+			addErrors = function( attr, funcs ) {
+				can.each(funcs, function( func ) {
+					var res = func.call(self, isTest ? ( self.__convert ? 
+							self.__convert(attr,newVal) : 
+							newVal ): self[attr]);
+					if ( res ) {
+						if (!errors[attr] ) {
+							errors[attr] = [];
+						}
+						errors[attr].push(res);
+					}
+
+				});
+			},
+			validations = this.constructor.validations,
+			isTest = attrs && attrs.length === 1 && arguments.length === 2;
+
+		// go through each attribute or validation and
+		// add any errors
+		can.each(attrs || validations || {}, function( funcs, attr ) {
+			// if we are iterating through an array, use funcs
+			// as the attr name
+			if ( typeof attr == 'number' ) {
+				attr = funcs;
+				funcs = validations[attr];
+			}
+			// add errors to the 
+			addErrors(attr, funcs || []);
+		});
+		
+		// return errors as long as we have one
+		return can.isEmptyObject(errors) ? null : isTest ? errors[attrs[0]] : errors;
+	}
+	
+});
+
+})(this.can, this )