sproutcore 0.9.0

data/jsdoc/app/Symbol.js

@@ -0,0 +1,298 @@
+/**
+ * @fileOverview
+ * @name Symbol
+ * @author Michael Mathews micmath@gmail.com
+ * @url $HeadURL: https://jsdoc-toolkit.googlecode.com/svn/tags/jsdoc_toolkit-1.4.0b/app/Symbol.js $
+ * @revision $Id: Symbol.js 340 2007-11-14 23:24:27Z micmath $
+ * @license <a href="http://en.wikipedia.org/wiki/MIT_License">X11/MIT License</a>
+ *          (See the accompanying README file for full details.)
+ */
+
+SYM = {
+	OBJECT:			"OBJECT",
+	FUNCTION:		"FUNCTION",
+	CONSTRUCTOR:	"CONSTRUCTOR",
+	VIRTUAL:		"VIRTUAL",
+    EVENT:          "EVENT"
+};
+
+/**
+	@class Represents an atomic unit of code.
+	@constructor
+*/
+function Symbol(name, params, isa, comment) {
+	if (isa == "META") {
+		if (comment.indexOf("/**#@+") == 0) { // start of shared doclet
+			Symbol.shared = Doclet.unwrapComment(comment.replace("/**#@+", "/**"));
+		}
+		else if (comment.indexOf("/**#@-") == 0) { // end of shared doclet
+			Symbol.shared = "";
+		}
+		return;
+	}
+	comment = Symbol.shared+"\n"+Doclet.unwrapComment(comment);
+	
+	this.name = name;
+	this.params = (params || []);
+	this.isa = (isa || SYM.OBJECT);
+	this.type = "";
+	this.alias = name;
+	this.desc = "";
+	this.classDesc = "";
+	this.memberof = "";
+	this.since = "";
+	this.version = "";
+	this.deprecated = "";
+	this.augments = [];
+	this.inherits = [];
+	this._inheritsFrom = [];
+	this.properties = [];
+	this.methods = [];
+	this.file = {};
+	this.returns = [];
+	this.exceptions = [];
+    this.events = [];
+	this.doc = new Doclet(comment);
+	this.see = [];
+	
+	// move certain data out of the tags and into the Symbol
+	var overviews;
+	if ((overviews = this.doc.getTag("overview")) && overviews.length) {
+		var libraries;
+		if ((libraries = this.doc.getTag("name")) && libraries.length) {
+			this.name = libraries[0].desc;
+			this.doc._dropTag("name");
+		}
+		else {
+			this.name = Util.fileName(this.alias)
+		}
+		
+		this.desc = overviews[0].desc;
+		this.doc._dropTag("overview");
+	}
+	else {
+		
+		var since;
+		if ((since = this.doc.getTag("since")) && since.length) {
+			this.since = since[0].desc;
+		}
+		
+		var version;
+		if ((version = this.doc.getTag("version")) && version.length) {
+			this.version = version[0].desc;
+		}
+		
+		var deprecated;
+		if ((deprecated = this.doc.getTag("deprecated")) && deprecated.length) {
+			this.deprecated = deprecated[0];
+			this.doc._dropTag("deprecated");
+		}
+		
+		var see;
+		if ((see = this.doc.getTag("see")) && version.length) {
+			this.see = see;
+			this.doc._dropTag("see");
+		}
+		
+		var descs;
+		if ((descs = this.doc.getTag("desc")) && descs.length) {
+			this.desc = descs.join("\n"); // multiple descriptions are concatenated into one
+			this.doc._dropTag("desc");
+		}
+		
+		var params;
+		if ((params = this.doc.getTag("param")) && params.length) { // user defined params override those defined by parser
+			this.params = params;
+			this.doc._dropTag("param");
+		}
+		else { // promote parser params into DocTag objects
+			for (var i = 0; i < this.params.length; i++) {
+				this.params[i] = new DocTag("param "+this.params[i]);
+			}
+		}
+		
+		var constructors;
+		if ((constructors = this.doc.getTag("constructor")) && constructors.length) {
+			this.isa = SYM.CONSTRUCTOR;
+			this.doc._dropTag("constructor");
+		}
+		
+		var functions;
+		if ((functions = this.doc.getTag("function")) && functions.length) {
+			this.isa = SYM.FUNCTION;
+			this.doc._dropTag("function");
+		}
+        
+        var events;
+		if ((events = this.doc.getTag("event")) && events.length) {
+			this.isa = SYM.EVENT;
+			this.doc._dropTag("event");
+		}
+		
+		var methods;
+		if ((functions = this.doc.getTag("method")) && functions.length) {
+			this.isa = SYM.FUNCTION;
+			this.doc._dropTag("method");
+		}
+		
+		var names;
+		if ((names = this.doc.getTag("name")) && names.length) {
+			this.name = names[0].desc;
+			this.doc._dropTag("name");
+		}
+		
+		var properties;
+		if ((properties = this.doc.getTag("property")) && properties.length) {
+			for (var i = 0; i < properties.length; i++) {
+				properties[i].alias = this.alias+"."+properties[i].name;
+				this.properties.push(properties[i]);
+			}
+			this.doc._dropTag("property");
+		}
+		
+		var returns;
+		if ((returns = this.doc.getTag("return")) && returns.length) {
+			for (var i = 0; i < returns.length; i++) {
+				this.returns.push(returns[i]);
+			}
+			this.doc._dropTag("return");
+		}
+		
+		var exceptions;
+		if ((exceptions = this.doc.getTag("throws")) && exceptions.length) {
+			for (var i = 0; i < exceptions.length; i++) {
+				this.exceptions.push(exceptions[i]);
+			}
+			this.doc._dropTag("throws");
+		}
+		
+		if (this.is("VIRTUAL")) this.isa = SYM.OBJECT;
+		
+		var types;
+		if ((types = this.doc.getTag("type")) && types.length) {
+			if (this.is("OBJECT"))
+				this.type = (types[0].desc || ""); // multiple type tags are ignored
+			this.doc._dropTag("type");
+		}
+		
+		if (this.doc.getTag("static").length > 0) {
+			this.isStatic = true;
+			this.doc._dropTag("static");
+		}
+		
+		if (this.doc.getTag("private").length > 0) {
+			this.isPrivate = true;
+			this.doc._dropTag("private");
+		}
+			
+		var classes;
+		if ((classes = this.doc.getTag("class")) && classes.length) {
+			if (this.doc.getTag("static").length > 0) this.isStatic = true;
+			this.isa = "CONSTRUCTOR"; // a class tag implies a conctuctor doclet
+			
+			this.classDesc += "\n"+classes[0].desc; // multiple class tags are concatenated
+			//this.doc._dropTag("class");
+		}
+		
+		var inherits;
+		if ((inherits = this.doc.getTag("inherits")) && inherits.length) {
+			for (var i = 0; i < inherits.length; i++) {
+				this.inherits.push(inherits[i].desc);
+			}
+			this.doc._dropTag("inherits");
+		}
+		
+		var augments;
+		if ((augments = this.doc.getTag("augments")) && augments.length) {
+			for (var i = 0; i < augments.length; i++) {
+				this.augments.push(augments[i].desc);
+			}
+			this.doc._dropTag("augments");
+		}
+		
+		Symbol.index[this.alias] = this;
+	}
+}
+Symbol.shared = ""; // holds shared doclets
+Symbol.index = {};
+
+Symbol.prototype.is = function(what) {
+    return this.isa === SYM[what];
+}
+
+/** Generate a comma separated list of the parameters. */
+Symbol.prototype.signature = function() {
+    var result = [];
+    for (var i = 0; i < this.params.length; i++) {
+    	if (this.params[i].name.indexOf(".") == -1) // config information does not appear in the signature
+    		result.push(this.params[i].name);
+    }
+    return result.join(", ");
+}
+
+Symbol.prototype.hasMethod = function(name) {
+    for (var i = 0; i < this.methods.length; i++) {
+    	if (this.methods[i].name == name) return true
+    }
+    return false;
+}
+
+Symbol.prototype.hasEvent = function(name) {
+    for (var i = 0; i < this.events.length; i++) {
+    	if (this.events[i].name == name) return true
+    }
+    return false;
+}
+
+Symbol.prototype.hasProperty = function(name) {
+    for (var i = 0; i < this.properties.length; i++) {
+    	if (this.properties[i].name == name) return true
+    }
+    return false;
+}
+
+Array.prototype.isUnique = function() {
+	var l = this.length;
+	for(var i = 0; i < l; i++ ) {
+		if (this.lastIndexOf(this[i]) > i) return false;
+	}
+	return true;
+};
+
+Symbol.prototype.getInheritedMethods = function(r) {
+	var inherited = [];
+	for(var i = 0; i < this.inherits.length; i++) {
+		inherited.push(this.file.fileGroup.getSymbol(this.inherits[i]));
+	}
+	var result = this.methods.concat(inherited);
+	for(var i = 0; i < this.augments.length; i++) {
+		var contributer = this.file.fileGroup.getSymbol(this.augments[i]);
+		if (contributer) {
+			this._inheritsFrom.push(contributer.alias);
+			
+			if (!this._inheritsFrom.isUnique()) {
+				LOG.warn("Circular reference: "+this.alias+" inherits from the same symbol more than once.");
+			}
+			else {
+				result = result.concat(contributer.getInheritedMethods(true));
+				this._inheritsFrom = [];
+			}
+		}
+	}
+	// remove overridden
+	for (var i = 0; i < result.length; i++) {
+		var j = i; 
+		while (++j < result.length) {
+			if (result[j].name == result[i].name) result.splice(j, 1);
+		}
+	}
+	
+	if (!r) { // not recursing
+		var s = this;
+		function notLocal(element, index, array) {
+			return (!s.hasMethod(element.name));
+		}
+		result = result.filter(notLocal);
+	}
+	return result;
+}

data/jsdoc/app/Transformer.js

@@ -0,0 +1,14 @@
+/** @class Use a style sheet to transform XML. Requires Rhino. */
+function Transformer(xsl) { //like: var t = new Transformer("data/teststyle.xsl");
+	var xsltFile = new Packages.java.io.File(xsl);
+	var xsltSource = new Packages.javax.xml.transform.stream.StreamSource(xsltFile);
+	this.transformer = Packages.javax.xml.transform.TransformerFactory.newInstance().newTransformer(xsltSource);
+}
+
+Transformer.prototype.transform = function(xml, out) { //like: t.transform("data/testdata.xml", "data/testout.txt");
+	var xmlFile = new Packages.java.io.File(xml);
+	var resFile = new Packages.java.io.File(out);
+	var xmlSource = new Packages.javax.xml.transform.stream.StreamSource(xmlFile);
+	var result = new Packages.javax.xml.transform.stream.StreamResult(resFile);
+	this.transformer.transform(xmlSource, result);
+}

data/jsdoc/app/Util.js

@@ -0,0 +1,97 @@
+/**
+ * @fileOverview
+ * @name Util
+ * @author Michael Mathews micmath@gmail.com
+ * @url $HeadURL: https://jsdoc-toolkit.googlecode.com/svn/tags/jsdoc_toolkit-1.4.0b/app/Util.js $
+ * @revision $Id: Util.js 244 2007-09-23 09:42:21Z micmath $
+ * @license <a href="http://en.wikipedia.org/wiki/MIT_License">X11/MIT License</a>
+ *          (See the accompanying README file for full details.)
+ */
+
+/**
+ * @class Various utility methods used by JsDoc.
+ * @static
+ */
+Util = {
+	/**
+	 * Turn a path into just the name of the file.
+	 * @static
+	 * @param {string} path
+	 * @return {string} The fileName portion of the path.
+	 */
+	fileName: function(path) {
+		var nameStart = Math.max(path.lastIndexOf("/")+1, path.lastIndexOf("\\")+1, 0);
+		return path.substring(nameStart);
+	},
+	
+	/**
+	 * Turn a path into just the directory part.
+	 * @static
+	 * @param {string} path
+	 * @return {string} The directory part of the path.
+	 */
+	dir: function(path) {
+		var nameStart = Math.max(path.lastIndexOf("/")+1, path.lastIndexOf("\\")+1, 0);
+		return path.substring(0, nameStart-1);
+	},
+	
+	/**
+	 * Get commandline option values.
+	 * @static
+	 * @param {Array} args Commandline arguments. Like ["-a=xml", "-b", "--class=new", "--debug"]
+	 * @param {object} optNames Map short names to long names. Like {a:"accept", b:"backtrace", c:"class", d:"debug"}.
+	 * @return {object} Short names and values. Like {a:"xml", b:true, c:"new", d:true}
+	 */
+	getOptions: function(args, optNames) {
+		var opt = {"_": []}; // the unnamed option allows multiple values
+		for (var i = 0; i < args.length; i++) {
+			var arg = new String(args[i]);
+			var name;
+			var value;
+			if (arg.charAt(0) == "-") {
+				if (arg.charAt(1) == "-") { // it's a longname like --foo
+					arg = arg.substring(2);
+					var m = arg.split("=");
+					name = m.shift();
+					value = m.shift();
+					if (typeof value == "undefined") value = true;
+					
+					for (var n in optNames) { // convert it to a shortname
+						if (name == optNames[n]) {
+							name = n;
+						}
+					}
+				}
+				else { // it's a shortname like -f
+					arg = arg.substring(1);
+					var m = arg.split("=");
+					name = m.shift();
+					value = m.shift();
+					if (typeof value == "undefined") value = true;
+					
+					for (var n in optNames) { // find the matching key
+						if (name == n || name+'[]' == n) {
+							name = n;
+							break;
+						}
+					}
+				}
+				if (name.match(/(.+)\[\]$/)) { // it's an array type like n[]
+					name = RegExp.$1;
+					if (!opt[name]) opt[name] = [];
+				}
+				
+				if (opt[name] && opt[name].push) {
+					opt[name].push(value);
+				}
+				else {
+					opt[name] = value;
+				}
+			}
+			else { // not associated with any optname
+				opt._.push(args[i]);
+			}
+		}
+		return opt;
+	}
+}

data/jsdoc/app/run.js

@@ -0,0 +1,144 @@
+var VERBOSE = false;
+try {
+	importClass(java.lang.System);
+}
+catch (e) {
+	throw "RuntimeException: The class java.lang.System is required to run this script.";
+}
+
+var __DIR__ = (System.getProperty("jsdoc.dir")||System.getProperty("user.dir"))+Packages.java.io.File.separator;
+
+/** Load required libraries. */
+function require(lib) {
+	var libDirs = ['', __DIR__, __DIR__+'app/', __DIR__+'../'];
+	var libErrors = [];
+	for(var i = 0; i < libDirs.length; i++) {
+		try {
+			var file = new Packages.java.io.File(libDirs[i]+lib);
+			if(!file.exists()) {
+				libErrors.push('Could not find: ['+(libDirs[i]+lib)+']');
+			}
+			else {
+				if (VERBOSE) print("Loading: ["+(libDirs[i]+lib)+"] ...");
+				load(libDirs[i]+lib);
+				return;
+			}
+		}
+		catch (e) {
+			libErrors.push('Error loading: ['+(libDirs[i]+lib)+']');
+		}
+	}
+	for(var i=0; i < libErrors.length; i++) {
+		print("ERROR: ["+libErrors[i]+"]");
+	}
+	quit();
+}
+
+require("app/JsDoc.js");
+require("app/Util.js");
+
+JsDoc.opt = Util.getOptions(arguments, {d:'directory', t:'template', r:'recurse', x:'ext', p:'private', a:'allfunctions', A:'Allfunctions', e:'encoding', o:'out', h:'help', 'D[]':'define'});
+VERBOSE = JsDoc.opt.v;
+
+require("app/JsIO.js");
+require("app/Symbol.js");
+require("app/JsToke.js");
+require("app/JsParse.js");
+require("app/DocTag.js");
+require("app/Doclet.js");
+require("app/DocFile.js");
+require("app/JsPlate.js");
+
+/** The main function. Called automatically. */
+function Main() {
+	if (JsDoc.opt.o) LOG.out = IO.open(JsDoc.opt.o, true);
+	if (!JsDoc.opt.e) JsDoc.opt.e = "utf-8";
+	IO.setEncoding(JsDoc.opt.e);
+	
+	if (JsDoc.opt.c) {
+		eval('conf = '+IO.readFile(JsDoc.opt.c));
+		
+		for (var c in conf) {
+			if (c !== "D") {
+				JsDoc.opt[c] = conf[c];
+			}
+		}
+	}
+	if (JsDoc.opt.h || JsDoc.opt._.length == 0 || JsDoc.opt.t === true) JsDoc.usage();
+	
+	var ext = ["js"];
+	if (JsDoc.opt.x) ext = JsDoc.opt.x.split(",").map(function(x) {return x.toLowerCase()});
+
+	if (typeof(JsDoc.opt.r) == "boolean") JsDoc.opt.r = 10;
+	else if (!isNaN(parseInt(JsDoc.opt.r))) JsDoc.opt.r = parseInt(JsDoc.opt.r);
+	else JsDoc.opt.r = 1;
+		
+	if (JsDoc.opt.d === true || JsDoc.opt.t === true) { // like when a user enters: -d mydir
+		LOG.warn("Option malformed.");
+		JsDoc.usage();
+	}
+	else if (!JsDoc.opt.d) {
+		JsDoc.opt.d = "js_docs_out";
+	}
+
+	JsDoc.opt.d += (JsDoc.opt.d.indexOf(IO.FileSeparator) == JsDoc.opt.d.length-1)?
+		"" : IO.FileSeparator;
+	LOG.inform("Creating output directory: "+JsDoc.opt.d);
+	IO.makeDir(JsDoc.opt.d);
+	
+	LOG.inform("Scanning for source files: recursion set to "+JsDoc.opt.r+" subdir"+((JsDoc.opt.r==1)?"":"s")+".");
+	function isJs(element, index, array) {
+		var thisExt = element.split(".").pop().toLowerCase();
+		return (ext.indexOf(thisExt) > -1); // we're only interested in files with certain extensions
+	}
+	var srcFiles = [];
+	for (var d = 0; d < JsDoc.opt._.length; d++) {
+		srcFiles = srcFiles.concat(
+			IO.ls(JsDoc.opt._[d], JsDoc.opt.r).filter(isJs)
+		);
+	}
+	
+	LOG.inform(srcFiles.length+" source file"+((srcFiles ==1)?"":"s")+" found:\n\t"+srcFiles.join("\n\t"));
+	var fileGroup = JsDoc.parse(srcFiles, JsDoc.opt);
+	
+	var D = {};
+	if (JsDoc.opt.D) {
+		for (var i = 0; i < JsDoc.opt.D.length; i++) {
+			var defineParts = JsDoc.opt.D[i].split(":", 2);
+			D[defineParts[0]] = defineParts[1];
+		}
+		JsDoc.opt.D = D;
+	}
+	else {
+		JsDoc.opt.D = {};
+	}
+
+	// combine any conf file D options with the commandline D options
+	if (typeof conf != "undefined") for (var c in conf.D) {
+		if (typeof JsDoc.opt.D[c] == "undefined") {
+			JsDoc.opt.D[c] = conf.D[c];
+		}
+	}
+	
+	if (JsDoc.opt.t && IO.exists(JsDoc.opt.t)) {
+		JsDoc.opt.t += (JsDoc.opt.t.indexOf(IO.FileSeparator)==JsDoc.opt.t.length-1)?
+			"" : IO.FileSeparator;
+		LOG.inform("Loading template: "+JsDoc.opt.t+"publish.js");
+		require(JsDoc.opt.t+"publish.js");
+		
+		LOG.inform("Publishing all files...");
+		publish(fileGroup, JsDoc.opt);
+		LOG.inform("Finished.");
+	}
+	else {
+		LOG.warn("Use the -t option to specify a template for formatting.");
+		LOG.warn("Dumping results to stdout.");
+		require("app/Dumper.js");
+		print(Dumper.dump(fileGroup));
+	}
+	
+	if (LOG.out) LOG.out.close();
+	if (LOG.warnings.length > 0) print(LOG.warnings.length+" warnings.");
+}
+
+Main();