upgrade Dojo to 1.6.1

5 files changed, 142 insertions, 137 deletions

diff --git a/lib/dojo/data/api/Identity.js b/lib/dojo/data/api/Identity.js
index 7a1caeb53..9d99f3d64 100644
--- a/lib/dojo/data/api/Identity.js
+++ b/lib/dojo/data/api/Identity.js
@@ -1,5 +1,5 @@
 /*
-	Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
 	Available via Academic Free License >= 2.1 OR the modified BSD license.
 	see: http://dojotoolkit.org/license for details
 */
@@ -10,6 +10,7 @@ dojo._hasResource["dojo.data.api.Identity"] = true;
 dojo.provide("dojo.data.api.Identity");
 dojo.require("dojo.data.api.Read");
 
+
 dojo.declare("dojo.data.api.Identity", dojo.data.api.Read, {
 	//	summary:
 	//		This is an abstract API that data provider implementations conform to.
@@ -17,7 +18,7 @@ dojo.declare("dojo.data.api.Identity", dojo.data.api.Read, {
 	//		methods unimplemented.
 
 	getFeatures: function(){
-		//	summary: 
+		//	summary:
 		//		See dojo.data.api.Read.getFeatures()
 		return {
 			 'dojo.data.api.Read': true,
@@ -45,16 +46,16 @@ dojo.declare("dojo.data.api.Identity", dojo.data.api.Read, {
 
 	getIdentityAttributes: function(/* item */ item){
 		//	summary:
-		//		Returns an array of attribute names that are used to generate the identity. 
+		//		Returns an array of attribute names that are used to generate the identity.
 		//		For most stores, this is a single attribute, but for some complex stores
 		//		such as RDB backed stores that use compound (multi-attribute) identifiers
 		//		it can be more than one.  If the identity is not composed of attributes
 		//		on the item, it will return null.  This function is intended to identify
 		//		the attributes that comprise the identity so that so that during a render
-		//		of all attributes, the UI can hide the the identity information if it 
+		//		of all attributes, the UI can hide the the identity information if it
 		//		chooses.
 		//	item:
-		//		The item from the store from which to obtain the array of public attributes that 
+		//		The item from the store from which to obtain the array of public attributes that
 		//		compose the identifier, if any.
 		//	example:
 		//	|	var itemId = store.getIdentity(kermit);
@@ -67,14 +68,14 @@ dojo.declare("dojo.data.api.Identity", dojo.data.api.Read, {
 
 	fetchItemByIdentity: function(/* object */ keywordArgs){
 		//	summary:
-		//		Given the identity of an item, this method returns the item that has 
-		//		that identity through the onItem callback.  Conforming implementations 
-		//		should return null if there is no item with the given identity.  
-		//		Implementations of fetchItemByIdentity() may sometimes return an item 
-		//		from a local cache and may sometimes fetch an item from a remote server, 
+		//		Given the identity of an item, this method returns the item that has
+		//		that identity through the onItem callback.  Conforming implementations
+		//		should return null if there is no item with the given identity.
+		//		Implementations of fetchItemByIdentity() may sometimes return an item
+		//		from a local cache and may sometimes fetch an item from a remote server,
 		//
 		// 	keywordArgs:
-		//		An anonymous object that defines the item to locate and callbacks to invoke when the 
+		//		An anonymous object that defines the item to locate and callbacks to invoke when the
 		//		item has been located and load has completed.  The format of the object is as follows:
 		//		{
 		//			identity: string|object,
@@ -84,9 +85,9 @@ dojo.declare("dojo.data.api.Identity", dojo.data.api.Read, {
 		//		}
 		//	The *identity* parameter.
 		//		The identity parameter is the identity of the item you wish to locate and load
-		//		This attribute is required.  It should be a string or an object that toString() 
+		//		This attribute is required.  It should be a string or an object that toString()
 		//		can be called on.
-		//		
+		//
 		//	The *onItem* parameter.
 		//		Function(item)
 		//		The onItem parameter is the callback to invoke when the item has been loaded.  It takes only one
@@ -98,12 +99,12 @@ dojo.declare("dojo.data.api.Identity", dojo.data.api.Read, {
 		//		parameter, the error object
 		//
 		//	The *scope* parameter.
-		//		If a scope object is provided, all of the callback functions (onItem, 
+		//		If a scope object is provided, all of the callback functions (onItem,
 		//		onError, etc) will be invoked in the context of the scope object.
 		//		In the body of the callback function, the value of the "this"
 		//		keyword will be the scope object.   If no scope object is provided,
 		//		the callback functions will be called in the context of dojo.global.
-		//		For example, onItem.call(scope, item, request) vs. 
+		//		For example, onItem.call(scope, item, request) vs.
 		//		onItem.call(dojo.global, item, request)
 		if(!this.isItemLoaded(keywordArgs.item)){
 			throw new Error('Unimplemented API: dojo.data.api.Identity.fetchItemByIdentity');
diff --git a/lib/dojo/data/api/Notification.js b/lib/dojo/data/api/Notification.js
index b1abad797..33daa3010 100644
--- a/lib/dojo/data/api/Notification.js
+++ b/lib/dojo/data/api/Notification.js
@@ -1,5 +1,5 @@
 /*
-	Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
 	Available via Academic Free License >= 2.1 OR the modified BSD license.
 	see: http://dojotoolkit.org/license for details
 */
@@ -10,6 +10,7 @@ dojo._hasResource["dojo.data.api.Notification"] = true;
 dojo.provide("dojo.data.api.Notification");
 dojo.require("dojo.data.api.Read");
 
+
 dojo.declare("dojo.data.api.Notification", dojo.data.api.Read, {
 	//	summary:
 	//		This is an abstract API that data provider implementations conform to.
@@ -18,12 +19,12 @@ dojo.declare("dojo.data.api.Notification", dojo.data.api.Read, {
 	//
 	//	description:
 	//		This API defines a set of APIs that all datastores that conform to the
-	//		Notifications API must implement.  In general, most stores will implement 
+	//		Notifications API must implement.  In general, most stores will implement
 	//		these APIs as no-op functions for users who wish to monitor them to be able
-	//		to connect to then via dojo.connect().  For non-users of dojo.connect, 
+	//		to connect to then via dojo.connect().  For non-users of dojo.connect,
 	//		they should be able to just replace the function on the store to obtain
 	//		 notifications.  Both read-only and read-write stores may implement
-	//		this feature.  In the case of a read-only store, this feature makes sense if 
+	//		this feature.  In the case of a read-only store, this feature makes sense if
 	//		the store itself does internal polling to a back-end server and periodically updates
 	//		its cache of items (deletes, adds, and updates).
 	//
@@ -36,7 +37,7 @@ dojo.declare("dojo.data.api.Notification", dojo.data.api.Read, {
 	//	|	dojo.connect(store, "onSet", onSet);
 
 	getFeatures: function(){
-		//	summary: 
+		//	summary:
 		//		See dojo.data.api.Read.getFeatures()
 		return {
 			'dojo.data.api.Read': true,
@@ -44,16 +45,16 @@ dojo.declare("dojo.data.api.Notification", dojo.data.api.Read, {
 		};
 	},
 
-	onSet: function(/* item */ item, 
-					/* attribute-name-string */ attribute, 
+	onSet: function(/* item */ item,
+					/* attribute-name-string */ attribute,
 					/* object | array */ oldValue,
 					/* object | array */ newValue){
 		//	summary:
-		//		This function is called any time an item is modified via setValue, setValues, unsetAttribute, etc.  
+		//		This function is called any time an item is modified via setValue, setValues, unsetAttribute, etc.
 		//	description:
-		//		This function is called any time an item is modified via setValue, setValues, unsetAttribute, etc.  
-		//		Its purpose is to provide a hook point for those who wish to monitor actions on items in the store 
-		//		in a simple manner.  The general expected usage is to dojo.connect() to the store's 
+		//		This function is called any time an item is modified via setValue, setValues, unsetAttribute, etc.
+		//		Its purpose is to provide a hook point for those who wish to monitor actions on items in the store
+		//		in a simple manner.  The general expected usage is to dojo.connect() to the store's
 		//		implementation and be called after the store function is called.
 		//
 		//	item:
@@ -62,11 +63,11 @@ dojo.declare("dojo.data.api.Notification", dojo.data.api.Read, {
 		//		The attribute being changed represented as a string name.
 		//	oldValue:
 		//		The old value of the attribute.  In the case of single value calls, such as setValue, unsetAttribute, etc,
-		//		this value will be generally be an atomic value of some sort (string, int, etc, object).  In the case of 
+		//		this value will be generally be an atomic value of some sort (string, int, etc, object).  In the case of
 		//		multi-valued attributes, it will be an array.
 		//	newValue:
-		//		The new value of the attribute.  In the case of single value calls, such as setValue, this value will be 
-		//		generally be an atomic value of some sort (string, int, etc, object).  In the case of multi-valued attributes, 
+		//		The new value of the attribute.  In the case of single value calls, such as setValue, this value will be
+		//		generally be an atomic value of some sort (string, int, etc, object).  In the case of multi-valued attributes,
 		//		it will be an array.  In the case of unsetAttribute, the new value will be 'undefined'.
 		//
 		//	returns:
@@ -93,12 +94,12 @@ dojo.declare("dojo.data.api.Notification", dojo.data.api.Read, {
 		//		{
 		//			item: someItem,							//The parent item
 		//			attribute:	"attribute-name-string",	//The attribute the new item was assigned to.
-		//			oldValue: something	//Whatever was the previous value for the attribute.  
+		//			oldValue: something	//Whatever was the previous value for the attribute.
 		//						//If it is a single-value attribute only, then this value will be a single value.
 		//						//If it was a multi-valued attribute, then this will be an array of all the values minues the new one.
 		//			newValue: something	//The new value of the attribute.  In the case of single value calls, such as setValue, this value will be
 		//						//generally be an atomic value of some sort (string, int, etc, object).  In the case of multi-valued attributes,
-		//						//it will be an array.  
+		//						//it will be an array.
 		//		}
 		//
 		//	returns:
diff --git a/lib/dojo/data/api/Read.js b/lib/dojo/data/api/Read.js
index 0a84aa5f9..ff8518cd4 100644
--- a/lib/dojo/data/api/Read.js
+++ b/lib/dojo/data/api/Read.js
@@ -1,5 +1,5 @@
 /*
-	Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
 	Available via Academic Free License >= 2.1 OR the modified BSD license.
 	see: http://dojotoolkit.org/license for details
 */
@@ -10,26 +10,27 @@ dojo._hasResource["dojo.data.api.Read"] = true;
 dojo.provide("dojo.data.api.Read");
 dojo.require("dojo.data.api.Request");
 
+
 dojo.declare("dojo.data.api.Read", null, {
 	//	summary:
-	//		This is an abstract API that data provider implementations conform to.  
+	//		This is an abstract API that data provider implementations conform to.
 	//		This file defines methods signatures and intentionally leaves all the
-	//		methods unimplemented.  For more information on the dojo.data APIs, 
+	//		methods unimplemented.  For more information on the dojo.data APIs,
 	//		please visit: http://www.dojotoolkit.org/node/98
 
-	getValue: function(	/* item */ item, 
-						/* attribute-name-string */ attribute, 
+	getValue: function(	/* item */ item,
+						/* attribute-name-string */ attribute,
 						/* value? */ defaultValue){
 		//	summary:
 		//		Returns a single attribute value.
 		//		Returns defaultValue if and only if *item* does not have a value for *attribute*.
 		//		Returns null if and only if null was explicitly set as the attribute value.
 		//		Returns undefined if and only if the item does not have a value for the
-		//		given attribute (which is the same as saying the item does not have the attribute). 
+		//		given attribute (which is the same as saying the item does not have the attribute).
 		// description:
 		//		Saying that an "item x does not have a value for an attribute y"
-		//		is identical to saying that an "item x does not have attribute y". 
-		//		It is an oxymoron to say "that attribute is present but has no values" 
+		//		is identical to saying that an "item x does not have attribute y".
+		//		It is an oxymoron to say "that attribute is present but has no values"
 		//		or "the item has that attribute but does not have any attribute values".
 		//		If store.hasAttribute(item, attribute) returns false, then
 		//		store.getValue(item, attribute) will return undefined.
@@ -112,7 +113,7 @@ dojo.declare("dojo.data.api.Read", null, {
 	},
 
 	containsValue: function(/* item */ item,
-							/* attribute-name-string */ attribute, 
+							/* attribute-name-string */ attribute,
 							/* anything */ value){
 		//	summary:
 		//		Returns true if the given *value* is one of the values that getValues()
@@ -135,8 +136,8 @@ dojo.declare("dojo.data.api.Read", null, {
 
 	isItem: function(/* anything */ something){
 		//	summary:
-		//		Returns true if *something* is an item and came from the store instance.  
-		//		Returns false if *something* is a literal, an item from another store instance, 
+		//		Returns true if *something* is an item and came from the store instance.
+		//		Returns false if *something* is a literal, an item from another store instance,
 		//		or is any object other than an item.
 		//
 		//	something:
@@ -173,9 +174,9 @@ dojo.declare("dojo.data.api.Read", null, {
 		//		isItemLoaded() returns true before loadItem() is even called,
 		//		then loadItem() need not do any work at all and will not even invoke
 		//		the callback handlers.  So, before invoking this method, check that
-		//		the item has not already been loaded.  
+		//		the item has not already been loaded.
 		// 	keywordArgs:
-		//		An anonymous object that defines the item to load and callbacks to invoke when the 
+		//		An anonymous object that defines the item to load and callbacks to invoke when the
 		//		load has completed.  The format of the object is as follows:
 		//		{
 		//			item: object,
@@ -198,12 +199,12 @@ dojo.declare("dojo.data.api.Read", null, {
 		//		parameter, the error object
 		//
 		//	The *scope* parameter.
-		//		If a scope object is provided, all of the callback functions (onItem, 
+		//		If a scope object is provided, all of the callback functions (onItem,
 		//		onError, etc) will be invoked in the context of the scope object.
 		//		In the body of the callback function, the value of the "this"
 		//		keyword will be the scope object.   If no scope object is provided,
 		//		the callback functions will be called in the context of dojo.global().
-		//		For example, onItem.call(scope, item, request) vs. 
+		//		For example, onItem.call(scope, item, request) vs.
 		//		onItem.call(dojo.global(), item, request)
 		if(!this.isItemLoaded(keywordArgs.item)){
 			throw new Error('Unimplemented API: dojo.data.api.Read.loadItem');
@@ -214,25 +215,25 @@ dojo.declare("dojo.data.api.Read", null, {
 		//	summary:
 		//		Given a query and set of defined options, such as a start and count of items to return,
 		//		this method executes the query and makes the results available as data items.
-		//		The format and expectations of stores is that they operate in a generally asynchronous 
+		//		The format and expectations of stores is that they operate in a generally asynchronous
 		//		manner, therefore callbacks are always used to return items located by the fetch parameters.
 		//
 		//	description:
 		//		A Request object will always be returned and is returned immediately.
-		//		The basic request is nothing more than the keyword args passed to fetch and 
-		//		an additional function attached, abort().  The returned request object may then be used 
-		//		to cancel a fetch.  All data items returns are passed through the callbacks defined in the 
+		//		The basic request is nothing more than the keyword args passed to fetch and
+		//		an additional function attached, abort().  The returned request object may then be used
+		//		to cancel a fetch.  All data items returns are passed through the callbacks defined in the
 		//		fetch parameters and are not present on the 'request' object.
 		//
 		//		This does not mean that custom stores can not add methods and properties to the request object
-		//		returned, only that the API does not require it.  For more info about the Request API, 
+		//		returned, only that the API does not require it.  For more info about the Request API,
 		//		see dojo.data.api.Request
 		//
 		//	keywordArgs:
-		//		The keywordArgs parameter may either be an instance of 
+		//		The keywordArgs parameter may either be an instance of
 		//		conforming to dojo.data.api.Request or may be a simple anonymous object
 		//		that may contain any of the following:
-		//		{ 
+		//		{
 		//			query: query-object or query-string,
 		//			queryOptions: object,
 		//			onBegin: Function,
@@ -245,10 +246,10 @@ dojo.declare("dojo.data.api.Read", null, {
 		//			sort: array
 		//		}
 		//		All implementations should accept keywordArgs objects with any of
-		//		the 9 standard properties: query, onBegin, onItem, onComplete, onError 
-		//		scope, sort, start, and count.  Some implementations may accept additional 
-		//		properties in the keywordArgs object as valid parameters, such as 
-		//		{includeOutliers:true}.         
+		//		the 9 standard properties: query, onBegin, onItem, onComplete, onError
+		//		scope, sort, start, and count.  Some implementations may accept additional
+		//		properties in the keywordArgs object as valid parameters, such as
+		//		{includeOutliers:true}.
 		//
 		//	The *query* parameter.
 		//		The query may be optional in some data store implementations.
@@ -256,28 +257,28 @@ dojo.declare("dojo.data.api.Read", null, {
 		//		of the query itself -- each different data store implementation
 		//		may have its own notion of what a query should look like.
 		//		However, as of dojo 0.9, 1.0, and 1.1, all the provided datastores in dojo.data
-		//		and dojox.data support an object structure query, where the object is a set of 
+		//		and dojox.data support an object structure query, where the object is a set of
 		//		name/value parameters such as { attrFoo: valueBar, attrFoo1: valueBar1}.  Most of the
-		//		dijit widgets, such as ComboBox assume this to be the case when working with a datastore 
-		//		when they dynamically update the query.  Therefore, for maximum compatibility with dijit 
+		//		dijit widgets, such as ComboBox assume this to be the case when working with a datastore
+		//		when they dynamically update the query.  Therefore, for maximum compatibility with dijit
 		//		widgets the recommended query parameter is a key/value object.  That does not mean that the
-		//		the datastore may not take alternative query forms, such as a simple string, a Date, a number, 
-		//		or a mix of such.  Ultimately, The dojo.data.api.Read API is agnostic about what the query 
-		//		format.  
-		//		Further note:  In general for query objects that accept strings as attribute 
-		//		value matches, the store should also support basic filtering capability, such as * 
+		//		the datastore may not take alternative query forms, such as a simple string, a Date, a number,
+		//		or a mix of such.  Ultimately, The dojo.data.api.Read API is agnostic about what the query
+		//		format.
+		//		Further note:  In general for query objects that accept strings as attribute
+		//		value matches, the store should also support basic filtering capability, such as *
 		//		(match any character) and ? (match single character).  An example query that is a query object
-		//		would be like: { attrFoo: "value*"}.  Which generally means match all items where they have 
+		//		would be like: { attrFoo: "value*"}.  Which generally means match all items where they have
 		//		an attribute named attrFoo, with a value that starts with 'value'.
 		//
 		//	The *queryOptions* parameter
 		//		The queryOptions parameter is an optional parameter used to specify optiosn that may modify
 		//		the query in some fashion, such as doing a case insensitive search, or doing a deep search
-		//		where all items in a hierarchical representation of data are scanned instead of just the root 
+		//		where all items in a hierarchical representation of data are scanned instead of just the root
 		//		items.  It currently defines two options that all datastores should attempt to honor if possible:
 		//		{
 		//			ignoreCase: boolean, //Whether or not the query should match case sensitively or not.  Default behaviour is false.
-		//			deep: boolean 	//Whether or not a fetch should do a deep search of items and all child 
+		//			deep: boolean 	//Whether or not a fetch should do a deep search of items and all child
 		//							//items instead of just root-level items in a datastore.  Default is false.
 		//		}
 		//
@@ -287,14 +288,14 @@ dojo.declare("dojo.data.api.Read", null, {
 		//		will be called just once, before the first onItem callback is called.
 		//		The onBegin callback function will be passed two arguments, the
 		//		the total number of items identified and the Request object.  If the total number is
-		//		unknown, then size will be -1.  Note that size is not necessarily the size of the 
-		//		collection of items returned from the query, as the request may have specified to return only a 
+		//		unknown, then size will be -1.  Note that size is not necessarily the size of the
+		//		collection of items returned from the query, as the request may have specified to return only a
 		//		subset of the total set of items through the use of the start and count parameters.
 		//
 		//	The *onItem* parameter.
 		//		function(item, request);
 		//		If an onItem callback function is provided, the callback function
-		//		will be called as each item in the result is received. The callback 
+		//		will be called as each item in the result is received. The callback
 		//		function will be passed two arguments: the item itself, and the
 		//		Request object.
 		//
@@ -304,12 +305,12 @@ dojo.declare("dojo.data.api.Read", null, {
 		//		If an onComplete callback function is provided, the callback function
 		//		will be called just once, after the last onItem callback is called.
 		//		Note that if the onItem callback is not present, then onComplete will be passed
-		//		an array containing all items which matched the query and the request object.  
-		//		If the onItem callback is present, then onComplete is called as: 
+		//		an array containing all items which matched the query and the request object.
+		//		If the onItem callback is present, then onComplete is called as:
 		//		onComplete(null, request).
 		//
 		//	The *onError* parameter.
-		//		function(errorData, request); 
+		//		function(errorData, request);
 		//		If an onError callback function is provided, the callback function
 		//		will be called if there is any sort of error while attempting to
 		//		execute the query.
@@ -317,29 +318,29 @@ dojo.declare("dojo.data.api.Read", null, {
 		//		an Error object and the Request object.
 		//
 		//	The *scope* parameter.
-		//		If a scope object is provided, all of the callback functions (onItem, 
+		//		If a scope object is provided, all of the callback functions (onItem,
 		//		onComplete, onError, etc) will be invoked in the context of the scope
 		//		object.  In the body of the callback function, the value of the "this"
 		//		keyword will be the scope object.   If no scope object is provided,
-		//		the callback functions will be called in the context of dojo.global().  
-		//		For example, onItem.call(scope, item, request) vs. 
+		//		the callback functions will be called in the context of dojo.global().
+		//		For example, onItem.call(scope, item, request) vs.
 		//		onItem.call(dojo.global(), item, request)
 		//
 		//	The *start* parameter.
-		//		If a start parameter is specified, this is a indication to the datastore to 
+		//		If a start parameter is specified, this is a indication to the datastore to
 		//		only start returning items once the start number of items have been located and
 		//		skipped.  When this parameter is paired withh 'count', the store should be able
-		//		to page across queries with millions of hits by only returning subsets of the 
+		//		to page across queries with millions of hits by only returning subsets of the
 		//		hits for each query
 		//
 		//	The *count* parameter.
-		//		If a count parameter is specified, this is a indication to the datastore to 
-		//		only return up to that many items.  This allows a fetch call that may have 
-		//		millions of item matches to be paired down to something reasonable.  
+		//		If a count parameter is specified, this is a indication to the datastore to
+		//		only return up to that many items.  This allows a fetch call that may have
+		//		millions of item matches to be paired down to something reasonable.
 		//
 		//	The *sort* parameter.
-		//		If a sort parameter is specified, this is a indication to the datastore to 
-		//		sort the items in some manner before returning the items.  The array is an array of 
+		//		If a sort parameter is specified, this is a indication to the datastore to
+		//		sort the items in some manner before returning the items.  The array is an array of
 		//		javascript objects that must conform to the following format to be applied to the
 		//		fetching of items:
 		//		{
@@ -347,18 +348,18 @@ dojo.declare("dojo.data.api.Read", null, {
 		//			descending: true|false;   // Optional.  Default is false.
 		//		}
 		//		Note that when comparing attributes, if an item contains no value for the attribute
-		//		(undefined), then it the default ascending sort logic should push it to the bottom 
+		//		(undefined), then it the default ascending sort logic should push it to the bottom
 		//		of the list.  In the descending order case, it such items should appear at the top of the list.
-		// 
+		//
 		//	returns:
 		//		The fetch() method will return a javascript object conforming to the API
 		//		defined in dojo.data.api.Request.  In general, it will be the keywordArgs
 		//		object returned with the required functions in Request.js attached.
 		//		Its general purpose is to provide a convenient way for a caller to abort an
-		//		ongoing fetch.  
-		// 
+		//		ongoing fetch.
+		//
 		//		The Request object may also have additional properties when it is returned
-		//		such as request.store property, which is a pointer to the datastore object that 
+		//		such as request.store property, which is a pointer to the datastore object that
 		//		fetch() is a method of.
 		//
 		//	exceptions:
@@ -373,7 +374,7 @@ dojo.declare("dojo.data.api.Read", null, {
 		//		|	var request = store.fetch(onComplete: showEverything);
 		//	example:
 		//		Fetch only 10 books that match the query 'all books', starting at the fifth book found during the search.
-		//		This demonstrates how paging can be done for specific queries.  
+		//		This demonstrates how paging can be done for specific queries.
 		//		|	var request = store.fetch({query:"all books", start: 4, count: 10, onComplete: showBooks});
 		//	example:
 		//		Fetch all items that match the query, calling 'callback' each time an item is located.
@@ -412,21 +413,21 @@ dojo.declare("dojo.data.api.Read", null, {
 		//		and then when the user presses the "Next Page" button...
 		//		|	fetchArgs.start += 20;
 		//		|	store.fetch(fetchArgs);  // get the next 20 items
-		var request = null; 
+		var request = null;
 		throw new Error('Unimplemented API: dojo.data.api.Read.fetch');
 		return request; // an object conforming to the dojo.data.api.Request API
 	},
 
 	getFeatures: function(){
 		//	summary:
-		//		The getFeatures() method returns an simple keyword values object 
-		//		that specifies what interface features the datastore implements.  
-		//		A simple CsvStore may be read-only, and the only feature it 
+		//		The getFeatures() method returns an simple keyword values object
+		//		that specifies what interface features the datastore implements.
+		//		A simple CsvStore may be read-only, and the only feature it
 		//		implements will be the 'dojo.data.api.Read' interface, so the
 		//		getFeatures() method will return an object like this one:
 		//		{'dojo.data.api.Read': true}.
 		//		A more sophisticated datastore might implement a variety of
-		//		interface features, like 'dojo.data.api.Read', 'dojo.data.api.Write', 
+		//		interface features, like 'dojo.data.api.Read', 'dojo.data.api.Write',
 		//		'dojo.data.api.Identity', and 'dojo.data.api.Attribution'.
 		return {
 			'dojo.data.api.Read': true
@@ -435,14 +436,14 @@ dojo.declare("dojo.data.api.Read", null, {
 
 	close: function(/*dojo.data.api.Request || keywordArgs || null */ request){
 		//	summary:
-		//		The close() method is intended for instructing the store to 'close' out 
+		//		The close() method is intended for instructing the store to 'close' out
 		//		any information associated with a particular request.
 		//
 		//	description:
-		//		The close() method is intended for instructing the store to 'close' out 
+		//		The close() method is intended for instructing the store to 'close' out
 		//		any information associated with a particular request.  In general, this API
-		//		expects to recieve as a parameter a request object returned from a fetch.  
-		//		It will then close out anything associated with that request, such as 
+		//		expects to recieve as a parameter a request object returned from a fetch.
+		//		It will then close out anything associated with that request, such as
 		//		clearing any internal datastore caches and closing any 'open' connections.
 		//		For some store implementations, this call may be a no-op.
 		//
@@ -450,7 +451,7 @@ dojo.declare("dojo.data.api.Read", null, {
 		//		An instance of a request for the store to use to identify what to close out.
 		//		If no request is passed, then the store should clear all internal caches (if any)
 		//		and close out all 'open' connections.  It does not render the store unusable from
-		//		there on, it merely cleans out any current data and resets the store to initial 
+		//		there on, it merely cleans out any current data and resets the store to initial
 		//		state.
 		//
 		//	example:
@@ -463,7 +464,7 @@ dojo.declare("dojo.data.api.Read", null, {
 	getLabel: function(/* item */ item){
 		//	summary:
 		//		Method to inspect the item and return a user-readable 'label' for the item
-		//		that provides a general/adequate description of what the item is. 
+		//		that provides a general/adequate description of what the item is.
 		//
 		//	description:
 		//		Method to inspect the item and return a user-readable 'label' for the item
@@ -471,17 +472,17 @@ dojo.declare("dojo.data.api.Read", null, {
 		//		most labels will be a specific attribute value or collection of the attribute
 		//		values that combine to label the item in some manner.  For example for an item
 		//		that represents a person it may return the label as:  "firstname lastlame" where
-		//		the firstname and lastname are attributes on the item.  If the store is unable 
+		//		the firstname and lastname are attributes on the item.  If the store is unable
 		//		to determine an adequate human readable label, it should return undefined.  Users that wish
-		//		to customize how a store instance labels items should replace the getLabel() function on 
-		//		their instance of the store, or extend the store and replace the function in 
+		//		to customize how a store instance labels items should replace the getLabel() function on
+		//		their instance of the store, or extend the store and replace the function in
 		//		the extension class.
 		//
 		//	item:
 		//		The item to return the label for.
 		//
-		//	returns: 
-		//		A user-readable string representing the item or undefined if no user-readable label can 
+		//	returns:
+		//		A user-readable string representing the item or undefined if no user-readable label can
 		//		be generated.
 		throw new Error('Unimplemented API: dojo.data.api.Read.getLabel');
 		return undefined;
@@ -489,21 +490,21 @@ dojo.declare("dojo.data.api.Read", null, {
 
 	getLabelAttributes: function(/* item */ item){
 		//	summary:
-		//		Method to inspect the item and return an array of what attributes of the item were used 
+		//		Method to inspect the item and return an array of what attributes of the item were used
 		//		to generate its label, if any.
 		//
 		//	description:
-		//		Method to inspect the item and return an array of what attributes of the item were used 
+		//		Method to inspect the item and return an array of what attributes of the item were used
 		//		to generate its label, if any.  This function is to assist UI developers in knowing what
 		//		attributes can be ignored out of the attributes an item has when displaying it, in cases
-		//		where the UI is using the label as an overall identifer should they wish to hide 
+		//		where the UI is using the label as an overall identifer should they wish to hide
 		//		redundant information.
 		//
 		//	item:
 		//		The item to return the list of label attributes for.
 		//
-		//	returns: 
-		//		An array of attribute names that were used to generate the label, or null if public attributes 
+		//	returns:
+		//		An array of attribute names that were used to generate the label, or null if public attributes
 		//		were not used to generate the label.
 		throw new Error('Unimplemented API: dojo.data.api.Read.getLabelAttributes');
 		return null;
diff --git a/lib/dojo/data/api/Request.js b/lib/dojo/data/api/Request.js
index d613c7b11..5c94cb5e0 100644
--- a/lib/dojo/data/api/Request.js
+++ b/lib/dojo/data/api/Request.js
@@ -1,5 +1,5 @@
 /*
-	Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
 	Available via Academic Free License >= 2.1 OR the modified BSD license.
 	see: http://dojotoolkit.org/license for details
 */
@@ -9,16 +9,17 @@ if(!dojo._hasResource["dojo.data.api.Request"]){ //_hasResource checks added by
 dojo._hasResource["dojo.data.api.Request"] = true;
 dojo.provide("dojo.data.api.Request");
 
+
 dojo.declare("dojo.data.api.Request", null, {
 	//	summary:
 	//		This class defines out the semantics of what a 'Request' object looks like
 	//		when returned from a fetch() method.  In general, a request object is
-	//		nothing more than the original keywordArgs from fetch with an abort function 
-	//		attached to it to allow users to abort a particular request if they so choose. 
+	//		nothing more than the original keywordArgs from fetch with an abort function
+	//		attached to it to allow users to abort a particular request if they so choose.
 	//		No other functions are required on a general Request object return.  That does not
 	//		inhibit other store implementations from adding extentions to it, of course.
 	//
-	//		This is an abstract API that data provider implementations conform to.  
+	//		This is an abstract API that data provider implementations conform to.
 	//		This file defines methods signatures and intentionally leaves all the
 	//		methods unimplemented.
 	//
@@ -26,10 +27,10 @@ dojo.declare("dojo.data.api.Request", null, {
 
 	abort: function(){
 		//	summary:
-		//		This function is a hook point for stores to provide as a way for 
+		//		This function is a hook point for stores to provide as a way for
 		//		a fetch to be halted mid-processing.
 		//	description:
-		//		This function is a hook point for stores to provide as a way for 
+		//		This function is a hook point for stores to provide as a way for
 		//		a fetch to be halted mid-processing.  For more details on the fetch() api,
 		//		please see dojo.data.api.Read.fetch().
 		throw new Error('Unimplemented API: dojo.data.api.Request.abort');
diff --git a/lib/dojo/data/api/Write.js b/lib/dojo/data/api/Write.js
index 3fd0b1af0..08779180b 100644
--- a/lib/dojo/data/api/Write.js
+++ b/lib/dojo/data/api/Write.js
@@ -1,5 +1,5 @@
 /*
-	Copyright (c) 2004-2010, The Dojo Foundation All Rights Reserved.
+	Copyright (c) 2004-2011, The Dojo Foundation All Rights Reserved.
 	Available via Academic Free License >= 2.1 OR the modified BSD license.
 	see: http://dojotoolkit.org/license for details
 */
@@ -10,14 +10,15 @@ dojo._hasResource["dojo.data.api.Write"] = true;
 dojo.provide("dojo.data.api.Write");
 dojo.require("dojo.data.api.Read");
 
+
 dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
 	//	summary:
-	//		This is an abstract API that data provider implementations conform to.  
+	//		This is an abstract API that data provider implementations conform to.
 	//		This file defines function signatures and intentionally leaves all the
 	//		functionss unimplemented.
 
 	getFeatures: function(){
-		//	summary: 
+		//	summary:
 		//		See dojo.data.api.Read.getFeatures()
 		return {
 			'dojo.data.api.Read': true,
@@ -31,16 +32,16 @@ dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
 		//		item based on the *keywordArgs* provided.  In general, the attribute
 		//		names in the keywords become the attributes in the new item and as for
 		//		the attribute values in keywordArgs, they become the values of the attributes
-		//		in the new item.  In addition, for stores that support hierarchical item 
+		//		in the new item.  In addition, for stores that support hierarchical item
 		//		creation, an optional second parameter is accepted that defines what item is the parent
 		//		of the new item and what attribute of that item should the new item be assigned to.
 		//		In general, this will assume that the attribute targetted is multi-valued and a new item
-		//		is appended onto the list of values for that attribute.  
+		//		is appended onto the list of values for that attribute.
 		//
 		//	keywordArgs:
 		//		A javascript object defining the initial content of the item as a set of JavaScript 'property name: value' pairs.
 		//	parentInfo:
-		//		An optional javascript object defining what item is the parent of this item (in a hierarchical store.  Not all stores do hierarchical items), 
+		//		An optional javascript object defining what item is the parent of this item (in a hierarchical store.  Not all stores do hierarchical items),
 		//		and what attribute of that parent to assign the new item to.  If this is present, and the attribute specified
 		//		is a multi-valued attribute, it will append this item into the array of values for that attribute.  The structure
 		//		of the object is as follows:
@@ -51,7 +52,7 @@ dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
 		//
 		//	exceptions:
 		//		Throws an exception if *keywordArgs* is a string or a number or
-		//		anything other than a simple anonymous object.  
+		//		anything other than a simple anonymous object.
 		//		Throws an exception if the item in parentInfo is not an item from the store
 		//		or if the attribute isn't an attribute name string.
 		//	example:
@@ -66,11 +67,11 @@ dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
 		//	summary:
 		//		Deletes an item from the store.
 		//
-		//	item: 
+		//	item:
 		//		The item to delete.
 		//
 		//	exceptions:
-		//		Throws an exception if the argument *item* is not an item 
+		//		Throws an exception if the argument *item* is not an item
 		//		(if store.isItem(item) returns false).
 		//	example:
 		//	|	var success = store.deleteItem(kermit);
@@ -78,7 +79,7 @@ dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
 		return false; // boolean
 	},
 
-	setValue: function(	/* item */ item, 
+	setValue: function(	/* item */ item,
 						/* string */ attribute,
 						/* almost anything */ value){
 		//	summary:
@@ -103,7 +104,7 @@ dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
 	},
 
 	setValues: function(/* item */ item,
-						/* string */ attribute, 
+						/* string */ attribute,
 						/* array */ values){
 		//	summary:
 		//		Adds each value in the *values* array as a value of the given
@@ -130,7 +131,7 @@ dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
 		return false; // boolean
 	},
 
-	unsetAttribute: function(	/* item */ item, 
+	unsetAttribute: function(	/* item */ item,
 								/* string */ attribute){
 		//	summary:
 		//		Deletes all the values of an attribute on an item.
@@ -154,9 +155,9 @@ dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
 		//	summary:
 		//		Saves to the server all the changes that have been made locally.
 		//		The save operation may take some time and is generally performed
-		//		in an asynchronous fashion.  The outcome of the save action is 
+		//		in an asynchronous fashion.  The outcome of the save action is
 		//		is passed into the set of supported callbacks for the save.
-		//   
+		//
 		//	keywordArgs:
 		//		{
 		//			onComplete: function
@@ -172,7 +173,7 @@ dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
 		//		are generally passed to the onComplete.
 		//
 		//	The *onError* parameter.
-		//		function(errorData); 
+		//		function(errorData);
 		//
 		//		If an onError callback function is provided, the callback function
 		//		will be called if there is any sort of error while attempting to
@@ -184,12 +185,12 @@ dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
 		//		onComplete, onError, etc) will be invoked in the context of the scope
 		//		object.  In the body of the callback function, the value of the "this"
 		//		keyword will be the scope object.   If no scope object is provided,
-		//		the callback functions will be called in the context of dojo.global.  
-		//		For example, onComplete.call(scope) vs. 
+		//		the callback functions will be called in the context of dojo.global.
+		//		For example, onComplete.call(scope) vs.
 		//		onComplete.call(dojo.global)
 		//
 		//	returns:
-		//		Nothing.  Since the saves are generally asynchronous, there is 
+		//		Nothing.  Since the saves are generally asynchronous, there is
 		//		no need to return anything.  All results are passed via callbacks.
 		//	example:
 		//	|	store.save({onComplete: onSave});
@@ -211,8 +212,8 @@ dojo.declare("dojo.data.api.Write", dojo.data.api.Read, {
 
 	isDirty: function(/* item? */ item){
 		//	summary:
-		//		Given an item, isDirty() returns true if the item has been modified 
-		//		since the last save().  If isDirty() is called with no *item* argument,  
+		//		Given an item, isDirty() returns true if the item has been modified
+		//		since the last save().  If isDirty() is called with no *item* argument,
 		//		then this function returns true if any item has been modified since
 		//		the last save().
 		//