Initial commit of intern.ccwn.org contentsHEADmaster

1 files changed, 219 insertions, 0 deletions

diff --git a/js/dojo/dojox/lang/docs.js b/js/dojo/dojox/lang/docs.js
new file mode 100644
index 0000000..0174630
--- /dev/null
+++ b/js/dojo/dojox/lang/docs.js
@@ -0,0 +1,219 @@
+//>>built
+// wrapped by build app
+define("dojox/lang/docs", ["dijit","dojo","dojox"], function(dijit,dojo,dojox){
+dojo.provide("dojox.lang.docs");
+
+// Extracts information from the API docs to apply a schema representation to dojo classes.
+// This can be utilized for runtime metadata retrieval and type checking
+(function(){
+	function error(error){
+		console.log("Warning, the API docs must be available at ../util/docscripts/api.json "+
+		"or ../util/docscripts/api/*.json "+
+		"in order for dojox.lang.docs to supply schema information, but it could not be loaded: " + error);
+	}
+
+	var declaredClasses = {};
+	var requiredModules = [];
+	var _docs = dojox.lang.docs._loadedDocs = {};
+
+	var schemifyClass = function(clazz, name){
+		// initial implementation records classes until they are ready
+		declaredClasses[name] = clazz;
+	};
+	var getType = function(typeDef){
+		var type = typeDef.type || '';
+		var typeObj, optional = false, array = false, dontModify;
+		type = type.replace(/\?/, function(){
+			optional = true;
+			return '';
+		});
+		type = type.replace(/\[\]/, function(){
+			array = true;
+			return '';
+		});
+		if(type.match(/HTML/)){
+			// HTML String and other "types" of strings are really just strings
+			type = "string";
+		}else if(type == 'String' || type == 'Number' ||
+				type == 'Boolean' || type == 'Object' ||
+				type == 'Array' || type == 'Integer' || type == "Function"){
+			type = type.toLowerCase();
+		}else if(type == "bool"){
+			type = "boolean";
+		}else if(type){
+			typeObj = dojo.getObject(type) || {};
+			dontModify = true;
+		}else{
+			typeObj = {};
+		}
+		typeObj = typeObj || {type:type};
+		if(array){
+			typeObj = {items:typeObj, type:"array"};
+			dontModify = false;
+		}
+		if(!dontModify){
+			if(optional){
+				typeObj.optional = true;
+			}
+			if(/const/.test(typeDef.tags)){
+				typeObj.readonly = true;
+			}
+		}
+		return typeObj;
+	};
+	var actualSchemifyClass = function(clazz, name){
+		var docForClass = _docs[name];
+		if(docForClass){
+			clazz.description = docForClass.description;
+			clazz.properties = {};
+			clazz.methods = {};
+
+			if(docForClass.properties){
+				var props = docForClass.properties;
+				for(var i=0, l=props.length; i<l; i++){
+					if(props[i].scope == "prototype"){
+						var propDef = clazz.properties[props[i].name] = getType(props[i]);
+						propDef.description = props[i].summary;
+					}
+				}
+			}
+
+			// translate the methods to JSON Schema
+			if(docForClass.methods){
+				var methods = docForClass.methods;
+				for(i=0, l=methods.length; i<l; i++){
+					name = methods[i].name;
+					if(name && methods[i].scope == "prototype"){
+						var methodDef = clazz.methods[name] = {};
+						methodDef.description = methods[i].summary;
+						var parameters = methods[i].parameters;
+						if(parameters){
+							methodDef.parameters = [];
+							for(var j=0, k=parameters.length; j<k; j++){
+								var param = parameters[j];
+								var paramDef = methodDef.parameters[j] = getType(param);
+								paramDef.name = param.name;
+								paramDef.optional = "optional" == param.usage;
+							}
+						}
+						var ret = methods[i]['return-types'];
+						if(ret && ret[0]){
+							var returns = getType(ret[0]);
+							if(returns.type){
+								methodDef.returns = returns;
+							}
+						}
+					}
+				}
+			}
+
+			var superclass = docForClass.superclass;
+			if(superclass){
+				clazz["extends"] = dojo.getObject(superclass);
+			}
+		}
+	};
+	var requireDocs = function(moduleName){
+		requiredModules.push(moduleName);
+	};
+
+	// hook into all declared classes
+	var defaultDeclare = dojo.declare;
+	dojo.declare = function(name){
+		var clazz = defaultDeclare.apply(this, arguments);
+		schemifyClass(clazz, name);
+		return clazz;
+	};
+	dojo.mixin(dojo.declare, defaultDeclare);
+	var initialized;
+
+	// hook into dojo.require
+	var defaultRequire = dojo.require;
+	dojo.require = function(moduleName){
+		requireDocs(moduleName);
+		var module = defaultRequire.apply(this, arguments);
+		return module;
+	};
+
+	dojox.lang.docs.init = function(/*Boolean*/async){
+		// summary:
+		//		Loads the documentation and applies it to the previously defined classes
+		// 		and any future defined classes
+		//
+		// async:
+		// 		 If true, the documentation will be loaded asynchronously
+		function loadFullDocs(){
+			dojo.require = defaultRequire;
+			requiredModules = null;
+			try{
+				dojo.xhrGet({
+					sync:!async,
+					url: dojo.baseUrl + '../util/docscripts/api.json',
+					handleAs: 'text'
+				}).addCallbacks(function(obj){
+					_docs = (new Function("return " + obj))();
+					obj = null;
+					schemifyClass = actualSchemifyClass;
+
+					for(var i in declaredClasses){
+						schemifyClass(declaredClasses[i], i);
+					}
+					declaredClasses = null;
+				}, error);
+			}catch(e){
+				error(e);
+			}
+		}
+		
+		if(initialized){
+			return null;
+		}
+		initialized = true;
+
+		var getSplitDocs = function(moduleName, sync){
+			return dojo.xhrGet({
+				sync: sync||!async,
+				url: dojo.baseUrl + '../util/docscripts/api/' + moduleName + '.json',
+				handleAs: 'text'
+			}).addCallback(function(obj){
+				obj = (new Function("return " + obj))();
+				for(var clazz in obj){
+					if(!_docs[clazz]){
+						_docs[clazz] = obj[clazz];
+					}
+				}
+			});
+		};
+		try{
+			var firstMod = requiredModules.shift();
+			getSplitDocs(firstMod, true).addCallbacks(function(){
+				requireDocs = function(moduleName){
+					if(!_docs[moduleName]){
+						try{
+							getSplitDocs(moduleName);
+						}catch(e){
+							_docs[moduleName] = {};
+						}
+					}
+				};
+				//console.log(requiredModules);
+				dojo.forEach(requiredModules, function(mod){
+					requireDocs(mod);
+				});
+				requiredModules = null;
+
+				schemifyClass = actualSchemifyClass;
+
+				for(i in declaredClasses){
+					schemifyClass(declaredClasses[i], i);
+				}
+				declaredClasses = null;
+			},loadFullDocs);
+		}catch(e){
+			loadFullDocs();
+		}
+		return null;
+	}
+})();
+
+});