New feature: basic Ajax suggestion for tags and implementation of Dojo toolkit

git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f

1 files changed, 515 insertions, 0 deletions

diff --git a/includes/js/dojox/data/OpmlStore.js b/includes/js/dojox/data/OpmlStore.js
new file mode 100644
index 0000000..94b3150
--- /dev/null
+++ b/includes/js/dojox/data/OpmlStore.js
@@ -0,0 +1,515 @@
+if(!dojo._hasResource["dojox.data.OpmlStore"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.data.OpmlStore"] = true;
+dojo.provide("dojox.data.OpmlStore");
+
+dojo.require("dojo.data.util.filter");
+dojo.require("dojo.data.util.simpleFetch");
+
+dojo.declare("dojox.data.OpmlStore", null, {
+	/* summary:
+	 *   The OpmlStore implements the dojo.data.api.Read API.  
+	 */
+	 
+	/* examples:
+	 *   var opmlStore = new dojo.data.OpmlStore({url:"geography.xml"});
+	 *   var opmlStore = new dojo.data.OpmlStore({url:"http://example.com/geography.xml"});
+	 */
+	constructor: function(/* Object */ keywordParameters){
+		// summary: constructor
+		// keywordParameters: {url: String, label: String}  Where label is optional and configures what should be used as the return from getLabel()
+		this._xmlData = null;
+		this._arrayOfTopLevelItems = [];
+		this._arrayOfAllItems = [];
+		this._metadataNodes = null;
+		this._loadFinished = false;
+		this.url = keywordParameters.url;
+		this._opmlData = keywordParameters.data;  // XML DOM Document
+		if(keywordParameters.label){
+			this.label = keywordParameters.label;
+		}
+		this._loadInProgress = false;	//Got to track the initial load to prevent duelling loads of the dataset.
+		this._queuedFetches = [];
+		this._identityMap = {};
+		this._identCount = 0;
+		this._idProp = "_I";
+	},
+
+	label: "text",
+
+	url: "",
+
+	_assertIsItem: function(/* item */ item){
+		if(!this.isItem(item)){ 
+			throw new Error("dojo.data.OpmlStore: a function was passed an item argument that was not an item");
+		}
+	},
+	
+	_assertIsAttribute: function(/* item || String */ attribute){
+		//	summary:
+		//      This function tests whether the item passed in is indeed a valid 'attribute' like type for the store.
+		//	attribute: 
+		//		The attribute to test for being contained by the store.
+		if(!dojo.isString(attribute)){
+			throw new Error("dojox.data.OpmlStore: a function was passed an attribute argument that was not an attribute object nor an attribute name string");
+		}
+	},
+	
+	_removeChildNodesThatAreNotElementNodes: function(/* node */ node, /* boolean */ recursive){
+		var childNodes = node.childNodes;
+		if(childNodes.length === 0){
+			return;
+		}
+		var nodesToRemove = [];
+		var i, childNode;
+		for(i = 0; i < childNodes.length; ++i){
+			childNode = childNodes[i];
+			if(childNode.nodeType != 1){ 
+				nodesToRemove.push(childNode); 
+			}
+		}
+		for(i = 0; i < nodesToRemove.length; ++i){
+			childNode = nodesToRemove[i];
+			node.removeChild(childNode);
+		}
+		if(recursive){
+			for(i = 0; i < childNodes.length; ++i){
+				childNode = childNodes[i];
+				this._removeChildNodesThatAreNotElementNodes(childNode, recursive);
+			}
+		}
+	},
+	
+	_processRawXmlTree: function(/* xmlDoc */ rawXmlTree){
+		this._loadFinished = true;
+		this._xmlData = rawXmlTree;
+		var headNodes = rawXmlTree.getElementsByTagName('head');
+		var headNode = headNodes[0];
+		if(headNode){
+			this._removeChildNodesThatAreNotElementNodes(headNode);
+			this._metadataNodes = headNode.childNodes;
+		}
+		var bodyNodes = rawXmlTree.getElementsByTagName('body');
+		var bodyNode = bodyNodes[0];
+		if(bodyNode){
+			this._removeChildNodesThatAreNotElementNodes(bodyNode, true);
+			
+			var bodyChildNodes = bodyNodes[0].childNodes;
+			for(var i = 0; i < bodyChildNodes.length; ++i){
+				var node = bodyChildNodes[i];
+				if(node.tagName == 'outline'){
+					this._identityMap[this._identCount] = node;
+					this._identCount++;
+					this._arrayOfTopLevelItems.push(node);
+					this._arrayOfAllItems.push(node);
+					this._checkChildNodes(node);
+				}
+			}
+		}
+	},
+
+	_checkChildNodes: function(node /*Node*/){
+		//	summary:
+		//		Internal function to recurse over all child nodes from the store and add them
+		//		As non-toplevel items
+		//	description:
+		//		Internal function to recurse over all child nodes from the store and add them
+		//		As non-toplevel items
+		//
+		//	node:
+		//		The child node to walk.
+		if(node.firstChild){
+			for(var i = 0; i < node.childNodes.length; i++){
+				var child = node.childNodes[i];
+				if(child.tagName == 'outline'){
+					this._identityMap[this._identCount] = child;
+					this._identCount++;
+					this._arrayOfAllItems.push(child);
+					this._checkChildNodes(child);
+				}
+			}
+		}
+	},
+
+	_getItemsArray: function(/*object?*/queryOptions){
+		//	summary: 
+		//		Internal function to determine which list of items to search over.
+		//	queryOptions: The query options parameter, if any.
+		if(queryOptions && queryOptions.deep) {
+			return this._arrayOfAllItems; 
+		}
+		return this._arrayOfTopLevelItems;
+	},
+
+/***************************************
+     dojo.data.api.Read API
+***************************************/
+	getValue: function( /* item */ item,
+						/* attribute || attribute-name-string */ attribute,
+						/* value? */ defaultValue){
+		//	summary: 
+		//      See dojo.data.api.Read.getValue()
+		this._assertIsItem(item);
+		this._assertIsAttribute(attribute);
+		if(attribute == 'children'){
+			return (item.firstChild || defaultValue); //Object
+		} else {
+			var value = item.getAttribute(attribute);
+			return (value !== undefined) ? value : defaultValue; //Object
+		}
+	},
+	
+	getValues: function(/* item */ item,
+						/* attribute || attribute-name-string */ attribute){
+		//	summary: 
+		//		See dojo.data.api.Read.getValues()
+		this._assertIsItem(item);
+		this._assertIsAttribute(attribute);
+		var array = [];
+		if(attribute == 'children'){
+			for(var i = 0; i < item.childNodes.length; ++i){
+				array.push(item.childNodes[i]);
+			}
+		} else if(item.getAttribute(attribute) !== null){
+				array.push(item.getAttribute(attribute));
+		}
+		return array; // Array
+	},
+	
+	getAttributes: function(/* item */ item){
+		//	summary: 
+		//		See dojo.data.api.Read.getAttributes()
+		this._assertIsItem(item);
+		var attributes = [];
+		var xmlNode = item;
+		var xmlAttributes = xmlNode.attributes;
+		for(var i = 0; i < xmlAttributes.length; ++i){
+			var xmlAttribute = xmlAttributes.item(i);
+			attributes.push(xmlAttribute.nodeName);
+		}
+		if(xmlNode.childNodes.length > 0){
+			attributes.push('children');
+		}
+		return attributes; //Array
+	},
+	
+	hasAttribute: function( /* item */ item,
+							/* attribute || attribute-name-string */ attribute){
+		//	summary: 
+		//		See dojo.data.api.Read.hasAttribute()
+		return (this.getValues(item, attribute).length > 0); //Boolean
+	},
+	
+	containsValue: function(/* item */ item, 
+							/* attribute || attribute-name-string */ attribute, 
+							/* anything */ value){
+		//	summary: 
+		//		See dojo.data.api.Read.containsValue()
+		var regexp = undefined;
+		if(typeof value === "string"){
+		   regexp = dojo.data.util.filter.patternToRegExp(value, false);
+		}
+		return this._containsValue(item, attribute, value, regexp); //boolean.
+	},
+
+	_containsValue: function(	/* item */ item, 
+								/* attribute || attribute-name-string */ attribute, 
+								/* anything */ value,
+								/* RegExp?*/ regexp){
+		//	summary: 
+		//		Internal function for looking at the values contained by the item.
+		//	description: 
+		//		Internal function for looking at the values contained by the item.  This 
+		//		function allows for denoting if the comparison should be case sensitive for
+		//		strings or not (for handling filtering cases where string case should not matter)
+		//	
+		//	item:
+		//		The data item to examine for attribute values.
+		//	attribute:
+		//		The attribute to inspect.
+		//	value:	
+		//		The value to match.
+		//	regexp:
+		//		Optional regular expression generated off value if value was of string type to handle wildcarding.
+		//		If present and attribute values are string, then it can be used for comparison instead of 'value'
+		var values = this.getValues(item, attribute);
+		for(var i = 0; i < values.length; ++i){
+			var possibleValue = values[i];
+			if(typeof possibleValue === "string" && regexp){
+				return (possibleValue.match(regexp) !== null);
+			}else{
+				//Non-string matching.
+				if(value === possibleValue){
+					return true; // Boolean
+				}
+			}
+		}
+		return false; // Boolean
+	},
+			
+	isItem: function(/* anything */ something){
+		//	summary: 
+		//		See dojo.data.api.Read.isItem()
+		//	description:
+		//		Four things are verified to ensure that "something" is an item:
+		//		something can not be null, the nodeType must be an XML Element,
+		//		the tagName must be "outline", and the node must be a member of
+		//		XML document for this datastore. 
+		return (something && 
+				something.nodeType == 1 && 
+				something.tagName == 'outline' &&
+				something.ownerDocument === this._xmlData); //Boolean
+	},
+	
+	isItemLoaded: function(/* anything */ something){
+		//	summary: 
+		//		See dojo.data.api.Read.isItemLoaded()
+		// 		OpmlStore loads every item, so if it's an item, then it's loaded.
+		return this.isItem(something); //Boolean
+	},
+	
+	loadItem: function(/* item */ item){
+		//	summary: 
+		//		See dojo.data.api.Read.loadItem()
+		//	description:
+		//		The OpmlStore always loads all items, so if it's an item, then it's loaded.
+		//		From the dojo.data.api.Read.loadItem docs:
+		//			If a call to 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.
+	},
+
+	getLabel: function(/* item */ item){
+		//	summary: 
+		//		See dojo.data.api.Read.getLabel()
+		if(this.isItem(item)){
+			return this.getValue(item,this.label); //String
+		}
+		return undefined; //undefined
+	},
+
+	getLabelAttributes: function(/* item */ item){
+		//	summary: 
+		//		See dojo.data.api.Read.getLabelAttributes()
+		return [this.label]; //array
+	},
+
+	// The dojo.data.api.Read.fetch() function is implemented as
+	// a mixin from dojo.data.util.simpleFetch.
+	// That mixin requires us to define _fetchItems().
+	_fetchItems: function(	/* Object */ keywordArgs, 
+							/* Function */ findCallback, 
+							/* Function */ errorCallback){
+		//	summary: 
+		//		See dojo.data.util.simpleFetch.fetch()
+		
+		var self = this;
+		var filter = function(requestArgs, arrayOfItems){
+			var items = null;
+			if(requestArgs.query){
+				items = [];
+				var ignoreCase = requestArgs.queryOptions ? requestArgs.queryOptions.ignoreCase : false; 
+
+				//See if there are any string values that can be regexp parsed first to avoid multiple regexp gens on the
+				//same value for each item examined.  Much more efficient.
+				var regexpList = {};
+				for(var key in requestArgs.query){
+					var value = requestArgs.query[key];
+					if(typeof value === "string"){
+						regexpList[key] = dojo.data.util.filter.patternToRegExp(value, ignoreCase);
+					}
+				}
+
+				for(var i = 0; i < arrayOfItems.length; ++i){
+					var match = true;
+					var candidateItem = arrayOfItems[i];
+					for(var key in requestArgs.query){
+						var value = requestArgs.query[key];
+						if(!self._containsValue(candidateItem, key, value, regexpList[key])){
+							match = false;
+						}
+					}
+					if(match){
+						items.push(candidateItem);
+					}
+				}
+			}else{
+				// We want a copy to pass back in case the parent wishes to sort the array.  We shouldn't allow resort 
+				// of the internal list so that multiple callers can get lists and sort without affecting each other.
+				if(arrayOfItems.length> 0){
+					items = arrayOfItems.slice(0,arrayOfItems.length); 
+				}
+			}
+			findCallback(items, requestArgs);
+		};
+
+		if(this._loadFinished){
+			filter(keywordArgs, this._getItemsArray(keywordArgs.queryOptions));
+		}else{
+
+			//If fetches come in before the loading has finished, but while
+			//a load is in progress, we have to defer the fetching to be 
+			//invoked in the callback.
+			if(this._loadInProgress){
+				this._queuedFetches.push({args: keywordArgs, filter: filter});
+			}else{
+				if(this.url !== ""){
+					this._loadInProgress = true;
+					var getArgs = {
+							url: self.url, 
+							handleAs: "xml"
+						};
+					var getHandler = dojo.xhrGet(getArgs);
+					getHandler.addCallback(function(data){
+						self._processRawXmlTree(data);
+						filter(keywordArgs, self._getItemsArray(keywordArgs.queryOptions));
+						self._handleQueuedFetches();
+					});
+					getHandler.addErrback(function(error){
+						throw error;
+					});
+				}else if(this._opmlData){
+					this._processRawXmlTree(this._opmlData);
+					this._opmlData = null;
+					filter(keywordArgs, this._getItemsArray(keywordArgs.queryOptions));
+				}else{
+					throw new Error("dojox.data.OpmlStore: No OPML source data was provided as either URL or XML data input.");
+				}
+			}
+		}
+	},
+	
+	getFeatures: function(){
+		// summary: See dojo.data.api.Read.getFeatures()
+		var features = {
+			'dojo.data.api.Read': true,
+			'dojo.data.api.Identity': true
+		};
+		return features; //Object
+	},
+
+/***************************************
+     dojo.data.api.Identity API
+***************************************/
+	getIdentity: function(/* item */ item){
+		//	summary: 
+		//		See dojo.data.api.Identity.getIdentity()
+		if(this.isItem(item)){
+			//No ther way to do this other than O(n) without
+			//complete rework of how the tree stores nodes.
+			for(var i in this._identityMap){
+				if(this._identityMap[i] === item){
+					return i;
+				}
+			}
+		}
+		return null; //null
+	},
+
+	fetchItemByIdentity: function(/* Object */ keywordArgs){
+		//	summary: 
+		//		See dojo.data.api.Identity.fetchItemByIdentity()
+
+		//Hasn't loaded yet, we have to trigger the load.
+		if(!this._loadFinished){
+			var self = this;
+			if(this.url !== ""){
+				//If fetches come in before the loading has finished, but while
+				//a load is in progress, we have to defer the fetching to be 
+				//invoked in the callback.
+				if(this._loadInProgress){
+					this._queuedFetches.push({args: keywordArgs});
+				}else{
+					this._loadInProgress = true;
+					var getArgs = {
+							url: self.url, 
+							handleAs: "xml"
+						};
+					var getHandler = dojo.xhrGet(getArgs);
+					getHandler.addCallback(function(data){
+						var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;
+						try{
+							self._processRawXmlTree(data);
+							var item = self._identityMap[keywordArgs.identity];
+							if(!self.isItem(item)){
+								item = null;
+							}
+							if(keywordArgs.onItem){
+								keywordArgs.onItem.call(scope, item);
+							}
+							self._handleQueuedFetches();
+						}catch(error){
+							if(keywordArgs.onError){
+								keywordArgs.onError.call(scope, error);
+							}
+						}
+					});
+					getHandler.addErrback(function(error){
+						this._loadInProgress = false;
+						if(keywordArgs.onError){
+							var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;
+							keywordArgs.onError.call(scope, error);
+						}
+					});
+				}
+			}else if(this._opmlData){
+				this._processRawXmlTree(this._opmlData);
+				this._opmlData = null;
+				var item = this._identityMap[keywordArgs.identity];
+				if(!self.isItem(item)){
+					item = null;
+				}
+				if(keywordArgs.onItem){
+					var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;
+					keywordArgs.onItem.call(scope, item);
+				}
+			}
+		}else{
+			//Already loaded.  We can just look it up and call back.
+			var item = this._identityMap[keywordArgs.identity];
+			if(!this.isItem(item)){
+				item = null;
+			}
+			if(keywordArgs.onItem){
+				var scope =  keywordArgs.scope?keywordArgs.scope:dojo.global;
+				keywordArgs.onItem.call(scope, item);
+			}
+		}
+	},
+
+	getIdentityAttributes: function(/* item */ item){
+		 //	summary: 
+		 //		See dojo.data.api.Identity.getIdentifierAttributes()
+		 
+		 //Identity isn't a public attribute in the item, it's the node count.
+		 //So, return null.
+		 return null;
+	},
+
+	_handleQueuedFetches: function(){
+		//	summary: 
+		//		Internal function to execute delayed request in the store.
+		//Execute any deferred fetches now.
+		if (this._queuedFetches.length > 0) {
+			for(var i = 0; i < this._queuedFetches.length; i++){
+				var fData = this._queuedFetches[i];
+				var delayedQuery = fData.args;
+				var delayedFilter = fData.filter;
+				if(delayedFilter){
+					delayedFilter(delayedQuery, this._getItemsArray(delayedQuery.queryOptions)); 
+				}else{
+					this.fetchItemByIdentity(delayedQuery);
+				}
+			}
+			this._queuedFetches = [];
+		}
+	},
+
+	close: function(/*dojo.data.api.Request || keywordArgs || null */ request){
+		 //	summary: 
+		 //		See dojo.data.api.Read.close()
+	}
+});
+//Mix in the simple fetch implementation to this class.
+dojo.extend(dojox.data.OpmlStore,dojo.data.util.simpleFetch);
+	
+
+}