path: root/includes/js/dojox/help/_base.js

if(!dojo._hasResource["dojox.help._base"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.help._base"] = true;
dojo.provide("dojox.help._base");
dojo.require("dojox.rpc.Service");
dojo.require("dojo.io.script");

dojo.experimental("dojox.help");
console.warn("Script causes side effects (on numbers, strings, and booleans). Call dojox.help.noConflict() if you plan on executing code.");

dojox.help = {
	// summary:
	//		Adds the help function to all variables.
	locate: function(/*String*/ searchFor, /*String|Object|String[]|Object[]*/ searchIn, /*Number*/ maxResults){
		// summary:
		//		Search for dojo functionality that has something to do with the given string.
		//  description:
		//		Search for locally available data; variable names and any cached
		//		documentation results for matches containing our search parameter
		// searchFor
		//		The string to search for.
		// searchIn:
		//		The namespaces to search in. Defaults to dojox.help._namespaces
		// maxResults:
		//		The maximum number of results.
		maxResults = maxResults || 20;
		var namespaces = [];
		var roots = {};
		var root;
		if(searchIn){
			if(!dojo.isArray(searchIn)){
				searchIn = [searchIn];
			}
			for(var i = 0, namespace; namespace = searchIn[i]; i++){
				root = namespace;
				if(dojo.isString(namespace)){
					namespace = dojo.getObject(namespace);
					if(!namespace){
						continue;
					}
				}else if(dojo.isObject(namespace)){
					root = namespace.__name__;
				}else{
					continue;
				}
				// Add to a list of namespace objects (in object form)
				namespaces.push(namespace);
				if(root){
					root = root.split(".")[0];
					if(!roots[root] && dojo.indexOf(dojox.help._namespaces, root) == -1){
						// Refresh anything that's not part of our global namespace list
						dojox.help.refresh(root);
					}
					roots[root] = true;
				}
			}
		}
		if(!namespaces.length){
			namespaces.push({ __name__: "window" });
			dojo.forEach(dojox.help._namespaces, function(item){ roots[item] = true; });
		}

		var found = [];
		out:
		for(var i = 0, namespace; namespace = namespaces[i]; i++){
			var name = namespace.__name__ || "";
			var shorter = dojo.some(namespaces, function(item){
				// Return true if we find a namespace below
				// the current namespace
				item = item.__name__ || "";
				return (name.indexOf(item + ".") == 0);
			});
			if(name && !shorter){
				root = name.split(".")[0];
				var names = [];
				if(name == "window"){
					for(root in dojox.help._names){
						if(dojo.isArray(dojox.help._names[root])){
							names = names.concat(dojox.help._names[root]);
						}
					}
				}else{
					names = dojox.help._names[root];
				}
				for(var j = 0, variable; variable = names[j]; j++){
					if((name == "window" || variable.indexOf(name + ".") == 0) && variable.toLowerCase().indexOf(searchFor) != -1){
						if(variable.slice(-10) == ".prototype"){ continue; }
						var obj = dojo.getObject(variable);
						if(obj){
							found.push([variable, obj]);
							if(found.length == maxResults){
								break out;
							}
						}
					}
				}
			}
		}

		dojox.help._displayLocated(found);
		if(!+dojo.isFF){
			return "";
		}
	},
	refresh: function(/*String?*/ namespace, /*Boolean?*/ recursive){
		// summary:
		//		Useful if you reset some values, and want to restore their
		//		help function
		// namespace:
		//		The string-representation of a namespace.
		// recursive:
		//		Whether to recurse through the namespace.
		if(arguments.length < 2){
			recursive = true;
		}
		dojox.help._recurse(namespace, recursive);
	},
	noConflict: function(/*Object?*/ item){
		// summary:
		//		Use this function when you want to resolve the problems
		//		created by including a dojox.help package.
		// item:
		//		If you pass an item, only that item will be cleaned
		if(arguments.length){
			return dojox.help._noConflict(item);
		}else{
			while(dojox.help._overrides.length){
				var override = dojox.help._overrides.pop();
				var parent = override[0];
				var key = override[1];
				var child = parent[key];
				parent[key] = dojox.help._noConflict(child);
			}
		}
	},
	init: function(/*String[]*/ namespaces, /*Boolen?*/ noConflict){
		// summary:
		//		Should be called by one of the implementations. Runs startup code
		// namespaces:
		//		Any namespaces to add to the default (dojox.help._namespaces)
		// noConflict:
		//		Whether to start in noConflict mode
		if(namespaces){
			dojox.help._namespaces.concat(namespaces);
		}
		dojo.addOnLoad(function(){
			dojo.require = (function(require){
				return function(){
					dojox.help.noConflict();
					require.apply(dojo, arguments);
					if(dojox.help._timer){
						clearTimeout(dojox.help._timer);
					}
					dojox.help._timer = setTimeout(function(){
						dojo.addOnLoad(function(){
							dojox.help.refresh();
							dojox.help._timer = false;
						});
					}, 500);
				}
			})(dojo.require);

			dojox.help._recurse();
		});
	},
	_noConflict: function(item){
		if(item instanceof String){
			return item.toString();
		}else if(item instanceof Number){
			return +item;
		}else if(item instanceof Boolean){
			return (item == true);
		}else if(dojo.isObject(item)){
			delete item.__name__;
			delete item.help;
		}
		return item;
	},
	_namespaces: ["dojo", "dojox", "dijit", "djConfig"],
	_rpc: new dojox.rpc.Service(dojo.moduleUrl("dojox.rpc", "documentation.smd")),
	_attributes: ["summary", "type", "returns", "parameters"],
	_clean: function(self){
		var obj = {};
		for(var i = 0, attribute; attribute = dojox.help._attributes[i]; i++){
			var value = self["__" + attribute + "__"];
			if(value){
				obj[attribute] = value;
			}
		}
		return obj;
	},
	_displayLocated: function(located){
		// summary:
		//		Stub function to be overridden in one of the dojox.help packages
		throw new Error("_displayLocated should be overridden in one of the dojox.help packages");
	},
	_displayHelp: function(loading, obj){
		// summary:
		//		Stub function to be overridden in one of the dojox.help packages
		throw new Error("_displayHelp should be overridden in one of the dojox.help packages");
	},
	_addVersion: function(obj){
		if(obj.name){
			obj.version = [dojo.version.major, dojo.version.minor, dojo.version.patch].join(".");
			var parts = obj.name.split(".");
			if(parts[0] == "dojo" || parts[0] == "dijit" || parts[0] == "dojox"){
				obj.project = parts[0];
			}
		}
		return obj;
	},
	_stripPrototype: function(original){
		var name = original.replace(/\.prototype(\.|$)/g, ".");
		var search = name;
		if(name.slice(-1) == "."){
			search = name = name.slice(0, -1);
		}else{
			name = original;
		}
		return [search, name];
	},
	_help: function(){
		var name = this.__name__;
		var search = dojox.help._stripPrototype(name)[0];
		var attributes = [];
		for(var i = 0, attribute; attribute = dojox.help._attributes[i]; i++){
			if(!this["__" + attribute + "__"]){
				attributes.push(attribute);
			}
		}

		dojox.help._displayHelp(true, { name: this.__name__ });

		if(!attributes.length || this.__searched__){
			dojox.help._displayHelp(false, dojox.help._clean(this));
		}else{
			this.__searched__ = true;
			dojox.help._rpc.get(dojox.help._addVersion({
				name: search,
				exact: true,
				attributes: attributes
			})).addCallback(this, function(data){
				if(this.toString === dojox.help._toString){
					this.toString(data);
				}
				if(data && data.length){
					data = data[0];
					for(var i = 0, attribute; attribute = dojox.help._attributes[i]; i++){
						if(data[attribute]){
							this["__" + attribute + "__"] = data[attribute];
						}
					}
					dojox.help._displayHelp(false, dojox.help._clean(this));
				}else{
					dojox.help._displayHelp(false, false);
				}
			});
		}
		if(!+dojo.isFF){
			return "";
		}
	},
	_parse: function(data){
		delete this.__searching__;
		if(data && data.length){
			var parameters = data[0].parameters;

			if(parameters){
				var signature = ["function ", this.__name__, "("];
				this.__parameters__ = parameters;
				for(var i = 0, parameter; parameter = parameters[i]; i++){
					if(i){
						signature.push(", ");
					}
					signature.push(parameter.name);
					if(parameter.types){
						var types = [];
						for(var j = 0, type; type = parameter.types[j]; j++){
							types.push(type.title);
						}
						if(types.length){
							signature.push(": ");
							signature.push(types.join("|"));
						}
					}
					if(parameter.repeating){
						signature.push("...");
					}
					if(parameter.optional){
						signature.push("?");
					}
				}
				signature.push(")");

				this.__source__ = this.__source__.replace(/function[^\(]*\([^\)]*\)/, signature.join(""));
			}

			if(this.__output__){
				delete this.__output__;
				console.log(this);
			}
		}else{
			dojox.help._displayHelp(false, false);
		}
	},
	_toStrings: {},
	_toString: function(data){
		if(!this.__source__){
			return this.__name__;
		}

		var first = (!this.__parameters__);
		this.__parameters__ = [];

		if(data){
			dojox.help._parse.call(this, data);
		}else if(first){
			this.__searching__ = true;
			dojox.help._toStrings[dojox.help._stripPrototype(this.__name__)[0]] = this;
			if(dojox.help._toStringTimer){
				clearTimeout(dojox.help._toStringTimer);
			}
			dojox.help._toStringTimer = setTimeout(function(){ dojox.help.__toString(); }, 50);
		}

		if(!first || !this.__searching__){
			return this.__source__;
		}

		var message = "function Loading info for " + this.__name__ + "... (watch console for result) {}";

		if(!+dojo.isFF){
			this.__output__ = true;
			return message;
		}

		return {
			toString: dojo.hitch(this, function(){
				// Detect if this was called by Firebug
				this.__output__ = true;
				return message;
			})
		};
	},
	__toString: function(){
		if(dojox.help._toStringTimer){
			clearTimeout(dojox.help._toStringTimer);
		}

		var names = [];
		dojox.help.noConflict(dojox.help._toStrings);
		for(var name in dojox.help._toStrings){
			names.push(name);
		}
		while(names.length){
			dojox.help._rpc.batch(dojox.help._addVersion({
				names: names.splice(-50, 50),
				exact: true,
				attributes: ["parameters"]
			})).addCallback(this, function(datas){
				for(var i = 0, data; data = datas[i]; i++){
					fn = dojox.help._toStrings[data.name];
					if(fn){
						dojox.help._parse.call(fn, [data]);
						delete dojox.help._toStrings[data.name];
					}
				}
			});
		}
	},
	_overrides: [],
	_recursions: [],
	_names: {},
	_recurse: function(/*String?*/ namespace, /*Boolean?*/ recursive){
		if(arguments.length < 2){
			recursive = true;
		}

		var items = [];

		if(namespace && dojo.isString(namespace)){
			dojox.help.__recurse(dojo.getObject(namespace), namespace, namespace, items, recursive);
		}else{
			for(var i = 0, namespace; namespace = dojox.help._namespaces[i]; i++){
				if(window[namespace]){
					dojox.help._recursions.push([window[namespace], namespace, namespace]);
					window[namespace].__name__ = namespace;
					if(!window[namespace].help){
						window[namespace].help = dojox.help._help;
					}
				}
			}
		}

		while(dojox.help._recursions.length){
			var recursion = dojox.help._recursions.shift();
			dojox.help.__recurse(recursion[0], recursion[1], recursion[2], items, recursive);
		}

		for(var i = 0, item; item = items[i]; i++){
			delete item.__seen__;
		}
	},
	__recurse: function(namespace, root, name, items, recursive){
		for(var key in namespace){
			if(key.match(/([^\w_.$]|__[\w_.$]+__)/)){
				continue;
			}

			var item = namespace[key];
			if(typeof item == "undefined"
				|| item === document
				|| item === window
				|| item === dojox.help._toString
				|| item === dojox.help._help
				|| item === null
				|| (+dojo.isIE && item.tagName)
				|| item.__seen__
			) {
				continue;
			}

			var isFunction = dojo.isFunction(item);
			var isObject = dojo.isObject(item) && !dojo.isArray(item) && !item.nodeType;

			var itemName = (name) ? (name + "." + key) : key;

			if(itemName == "dojo._blockAsync"){
				continue;
			}

			if(!item.__name__){
				var parent = null;
				if(dojo.isString(item)){
					parent = String;
				}else if(typeof item == "number"){
					parent = Number;
				}else if(typeof item == "boolean"){
					parent = Boolean;
				}
				if(parent){
					item = namespace[key] = new parent(item);
				}
			}

			item.__seen__ = true;
			item.__name__ = itemName;
			(dojox.help._names[root] = dojox.help._names[root] || []).push(itemName);
			items.push(item);
			if(!isFunction){
				dojox.help._overrides.push([namespace, key]);
			}

			if((isFunction || isObject) && recursive){
				dojox.help._recursions.push([item, root, itemName]);
			}

			if(isFunction){
				if(!item.__source__){
					item.__source__ = item.toString().replace(/^function\b ?/, "function " + itemName);
				}
				if(item.toString === Function.prototype.toString){
					item.toString = dojox.help._toString;
				}
			}

			if(!item.help){
				item.help = dojox.help._help;
			}
		}
	}
};

}