sproutcore 0.9.0

data/jsdoc/app/JsParse.js

@@ -0,0 +1,385 @@
+/**
+ * @fileOverview
+ * @name JsParse
+ * @author Michael Mathews micmath@gmail.com
+ * @url $HeadURL: https://jsdoc-toolkit.googlecode.com/svn/tags/jsdoc_toolkit-1.4.0b/app/JsParse.js $
+ * @revision $Id: JsParse.js 329 2007-11-13 00:48:15Z micmath $
+ * @license <a href="http://en.wikipedia.org/wiki/MIT_License">X11/MIT License</a>
+ *          (See the accompanying README file for full details.)
+ */
+
+/**
+ * @class Find objects in tokenized JavaScript source code.
+ * @constructor
+ * @author Michael Mathews <a href="mailto:micmath@gmail.com">micmath@gmail.com</a>
+ */
+function JsParse() {};
+
+/**
+ * Populate the symbols array with symbols found in the
+ * given token stream.
+ * @param {TokenStream} tokenStream
+ */
+JsParse.prototype.parse = function(tokenStream) {
+	/** 
+	 * All symbols found in the tokenStream.
+	 * @type Symbol[]
+	 */
+	this.symbols = [];
+	
+	/** 
+	 * Overview found in the tokenStream.
+	 * @type Symbol
+	 */
+	this.overview = null;
+	
+	while(tokenStream.next()) {
+		if (this._findDocComment(tokenStream)) continue;
+		if (this._findFunction(tokenStream)) continue;
+		if (this._findVariable(tokenStream)) continue;
+	}
+}
+
+/**
+ * Try to find a JsDoc comment in the tokenStream.
+ * @param {TokenStream} ts
+ * @return {boolean} Was a JsDoc comment found?
+ */
+JsParse.prototype._findDocComment = function(ts) {
+	if (ts.look().is("JSDOC")) {
+		
+		ts.look().data = ts.look().data.replace(/@namespace\b/, "@static\n@class");
+
+		var doc = ts.look().data;
+		
+		
+		if (doc.indexOf("/**#") == 0) {
+			new Symbol("", [], "META", doc);
+			delete ts.tokens[ts.cursor];
+			return true;
+		}
+		else if (/@(projectdescription|(file)?overview)\b/i.test(doc)) {
+			this.overview = new Symbol("", [], "FILE", doc);
+			delete ts.tokens[ts.cursor];
+			return true;
+		}
+		else if (/@name\s+([a-z0-9_$.]+)\s*/i.test(doc)) {
+			this.symbols.push(new Symbol(RegExp.$1, [], SYM.VIRTUAL, doc));
+			delete ts.tokens[ts.cursor];
+			return true;
+		}
+		else if (/@scope\s+([a-z0-9_$.]+)\s*/i.test(doc)) {
+			var scope = RegExp.$1;
+			if (scope) {
+				scope = scope.replace(/\.prototype\b/, "/");
+				this._onObLiteral(scope, new TokenStream(ts.balance("LEFT_CURLY")));
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
+/**
+ * Try to find a function definition in the tokenStream
+ * @param {TokenStream} ts
+ * @return {boolean} Was a function definition found?
+ */
+JsParse.prototype._findFunction = function(ts) {
+	if (ts.look().is("NAME")) {
+		var name = ts.look().data;
+		var doc = "";
+		var isa = null;
+		var body = "";
+		var paramTokens = [];
+		var params = [];
+		
+		// like function foo()
+		if (ts.look(-1).is("FUNCTION")) {
+			isa = SYM.FUNCTION;
+			
+			if (ts.look(-2).is("JSDOC")) {
+				doc = ts.look(-2).data;
+			}
+			paramTokens = ts.balance("LEFT_PAREN");
+			body = ts.balance("LEFT_CURLY");
+		}
+		
+		// like var foo = function()
+		else if (ts.look(1).is("ASSIGN") && ts.look(2).is("FUNCTION")) {
+			isa = SYM.FUNCTION;
+			
+			if (ts.look(-1).is("VAR") && ts.look(-2).is("JSDOC")) {
+				doc = ts.look(-2).data;
+			}
+			else if (ts.look(-1).is("JSDOC")) {
+				doc = ts.look(-1).data;
+			}
+			paramTokens = ts.balance("LEFT_PAREN");
+			body = ts.balance("LEFT_CURLY");
+			
+			// like foo = function(n) {return n}(42)
+			if (ts.look(1).is("LEFT_PAREN")) {
+				isa = SYM.OBJECT;
+				
+				ts.balance("LEFT_PAREN");
+				if (doc) { // we only keep these if they're documented
+					name = name.replace(/\.prototype\.?/, "/");
+						
+					if (!/\/$/.test(name)) { // assigning to prototype of already existing symbol
+						this.symbols.push(new Symbol(name, [], isa, doc));
+					}
+				}
+				this._onFnBody(name, new TokenStream(body));
+				return true;
+			}
+		}
+		
+		// like var foo = new function()
+		else if (ts.look(1).is("ASSIGN") && ts.look(2).is("NEW") && ts.look(3).is("FUNCTION")) {
+			isa = SYM.OBJECT;
+		
+			if (ts.look(-1).is("VAR") && ts.look(-2).is("JSDOC")) {
+				doc = ts.look(-2).data;
+			}
+			else if (ts.look(-1).is("JSDOC")) {
+				doc = ts.look(-1).data;
+			}
+			
+			paramTokens = ts.balance("LEFT_PAREN");
+			body = ts.balance("LEFT_CURLY");
+			if (doc) { // we only keep these if they're documented
+				name = name.replace(/\.prototype\.?/, "/");
+						
+				if (!/\/$/.test(name)) { // assigning to prototype of already existing symbol
+					this.symbols.push(new Symbol(name, [], isa, doc));
+				}
+			}
+			this._onFnBody(name, new TokenStream(body));
+			return true;
+		}
+		
+		if (isa && name) {
+			if (isa == SYM.FUNCTION) {
+				for (var i = 0; i < paramTokens.length; i++) {
+					if (paramTokens[i].is("NAME"))
+						params.push(paramTokens[i].data);
+				}
+			}
+			
+			// like Foo.bar.prototype.baz = function() {}
+			var ns = name;
+			if (name.indexOf(".prototype") > 0) {
+				isa = SYM.FUNCTION;
+				name = name.replace(/\.prototype\.?/, "/");
+			}
+			
+			this.symbols.push(new Symbol(name, params, isa, doc));
+			
+			if (body) {
+				if (ns.indexOf(".prototype") > 0) {
+					if (/@constructor\b/.test(doc)) {
+						ns = ns.replace(/\.prototype\.?/, "/");
+					}
+					else {
+						ns = ns.replace(/\.prototype\.[^.]+$/, "/");
+					}
+				}
+				this._onFnBody(ns, new TokenStream(body));
+			}
+			return true;
+		}
+	}
+	return false;
+}
+
+/**
+ * Try to find a variable definition in the tokenStream
+ * @param {TokenStream} ts
+ * @return {boolean} Was a variable definition found?
+ */
+JsParse.prototype._findVariable = function(ts) {
+	if (ts.look().is("NAME") && ts.look(1).is("ASSIGN")) {
+		// like var foo = 1
+		var name = ts.look().data;
+		isa = SYM.OBJECT;
+		
+		var doc;
+		if (ts.look(-1).is("JSDOC")) doc = ts.look(-1).data;
+		else if (ts.look(-1).is("VAR") && ts.look(-2).is("JSDOC")) doc = ts.look(-2).data;
+		name = name.replace(/\.prototype\.?/, "/");
+		
+		if (doc) { // we only keep these if they're documented
+			if (!/\/$/.test(name)) { // assigning to prototype of already existing symbol
+				this.symbols.push(new Symbol(name, [], isa, doc));
+			}
+			if (/@class\b/i.test(doc)) {
+				name = name +"/";
+			}
+		}
+		
+		// like foo = {
+		if (ts.look(2).is("LEFT_CURLY")) {
+			this._onObLiteral(name, new TokenStream(ts.balance("LEFT_CURLY")));
+		}
+		return true;
+	}
+	return false;
+}
+
+/**
+ * Handle sub-parsing of the content within an object literal.
+ * @private
+ * @param {String} nspace The name attached to this object.
+ * @param {TokenStream} ts The content of the object literal.
+ */
+JsParse.prototype._onObLiteral = function(nspace, ts) {
+	while (ts.next()) {
+		if (this._findDocComment(ts)) {
+		
+		}
+		else if (ts.look().is("NAME") && ts.look(1).is("COLON")) {
+			var name = nspace+((nspace.charAt(nspace.length-1)=="/")?"":".")+ts.look().data;
+			
+			// like foo: function
+			if (ts.look(2).is("FUNCTION")) {
+				var isa = SYM.FUNCTION;
+				var doc = "";
+				
+				if (ts.look(-1).is("JSDOC")) doc = ts.look(-1).data;
+				
+				var paramTokens = ts.balance("LEFT_PAREN");
+				var params = [];
+				for (var i = 0; i < paramTokens.length; i++) {
+					if (paramTokens[i].is("NAME"))
+						params.push(paramTokens[i].data);
+				}
+				
+				var body = ts.balance("LEFT_CURLY");
+				
+				// like foo: function(n) {return n}(42)
+				if (ts.look(1).is("LEFT_PAREN")) {
+					isa = SYM.OBJECT;
+					
+					ts.balance("LEFT_PAREN");
+					//if (doc) { // we only keep these if they're documented
+						//name = name.replace(/\.prototype\.?/, "/");
+							
+						//if (!/\/$/.test(name)) { // assigning to prototype of already existing symbol
+						//	this.symbols.push(new Symbol(name, [], isa, doc));
+						//}
+					//}
+					//this._onFnBody(name, new TokenStream(body));
+					//return true;
+				}
+			
+				this.symbols.push(new Symbol(name, params, isa, doc));
+				
+				// find methods in the body of this function
+				this._onFnBody(name, new TokenStream(body));
+			}
+			// like foo: {...}
+			else if (ts.look(2).is("LEFT_CURLY")) { // another nested object literal
+				if (ts.look(-1).is("JSDOC")) {
+					var isa = SYM.OBJECT;
+					var doc = ts.look(-1).data;
+
+					this.symbols.push(new Symbol(name, [], isa, doc));
+				}
+				
+				this._onObLiteral(name, new TokenStream(ts.balance("LEFT_CURLY"))); // recursive
+			}
+			else { // like foo: 1, or foo: "one"
+				if (ts.look(-1).is("JSDOC")) { // we only grab these if they are documented
+					var isa = SYM.OBJECT;
+					var doc = ts.look(-1).data;
+					
+					this.symbols.push(new Symbol(name, [], isa, doc));
+				}
+				
+				while (!ts.look().is("COMMA")) { // skip to end of RH value ignoring things like bar({blah, blah})
+					if (ts.look().is("LEFT_PAREN")) ts.balance("LEFT_PAREN");
+					else if (ts.look().is("LEFT_CURLY")) ts.balance("LEFT_CURLY");
+					else if (!ts.next()) break;
+				}
+			}
+		}
+	}
+}
+
+/**
+ * Handle sub-parsing of the content within a function body.
+ * @private
+ * @param {String} nspace The name attached to this function.
+ * @param {TokenStream} fs The content of the function body.
+ */
+JsParse.prototype._onFnBody = function(nspace, fs) {
+	while (fs.look()) {
+		if (this._findDocComment(fs)) {
+		
+		}
+		else if (fs.look().is("NAME") && fs.look(1).is("ASSIGN")) {
+			var name = fs.look().data;
+			
+			// like this.foo =
+			if (name.indexOf("this.") == 0) {
+				// like this.foo = function
+				if (fs.look(2).is("FUNCTION")) {
+					var isa = SYM.FUNCTION;
+					var doc = (fs.look(-1).is("JSDOC"))? fs.look(-1).data : "";
+					name = name.replace(/^this\./, (nspace+"/").replace("//", "/"))
+					
+					var paramTokens = fs.balance("LEFT_PAREN");
+					var params = [];
+					for (var i = 0; i < paramTokens.length; i++) {
+						if (paramTokens[i].is("NAME")) params.push(paramTokens[i].data);
+					}
+					
+					body = fs.balance("LEFT_CURLY");
+
+					// like this.foo = function(n) {return n}(42)
+					if (fs.look(1).is("LEFT_PAREN")) { // false alarm, it's not really a named function definition
+						isa = SYM.OBJECT;
+						fs.balance("LEFT_PAREN");
+						if (doc) { // we only grab these if they are documented
+							this.symbols.push(
+								new Symbol(name, [], isa, doc)
+							);
+						}
+						break;
+					}
+
+					this.symbols.push(
+						new Symbol(name, params, isa, doc)
+					);
+					
+					if (body) {
+						this._onFnBody(name, new TokenStream(body)); // recursive
+					}
+				}
+				else {
+					var isa = SYM.OBJECT;
+					var doc = (fs.look(-1).is("JSDOC"))? fs.look(-1).data : "";
+					name = name.replace(/^this\./, (nspace+"/").replace("//", "/"))
+						
+					if (doc) {
+						this.symbols.push(
+							new Symbol(name, [], isa, doc)
+						);
+					}
+						
+					// like this.foo = { ... }
+					if (fs.look(2).is("LEFT_CURLY")) {
+						var literal = fs.balance("LEFT_CURLY");
+						this._onObLiteral(name, new TokenStream(literal));
+					}
+				}
+			}
+			// like <thisfunction>.prototype.foo =
+			else if (name.indexOf(nspace+".prototype.") == 0) {
+				this._findFunction(fs);
+			}
+		}
+		if (!fs.next()) break;
+	}
+}

data/jsdoc/app/JsPlate.js

@@ -0,0 +1,130 @@
+/**
+ * @fileOverview
+ * @name JsPlate
+ * @author Michael Mathews micmath@gmail.com
+ * @url $HeadURL: https://jsdoc-toolkit.googlecode.com/svn/tags/jsdoc_toolkit-1.4.0b/app/JsPlate.js $
+ * @revision $Id: JsPlate.js 213 2007-08-22 10:21:50Z micmath $
+ * @license <a href="http://en.wikipedia.org/wiki/MIT_License">X11/MIT License</a>
+ *          (See the accompanying README file for full details.)
+
+ */
+
+ /**
+  * @class A lightweight template engine for JavaScript.
+  * @constructor
+  * @author Michael Mathews <a href="mailto:micmath@gmail.com">micmath@gmail.com</a>
+  * @param {string} template
+  */
+JsPlate = function(template) {
+	this.template = IO.readFile(template);
+
+	this.code = "";
+	this.parse();
+}
+
+/** Converts a template into evalable code. */
+JsPlate.prototype.parse = function() {
+	this.template = this.template.replace(/\{#[\s\S]+?#\}/gi, "");
+	this.code = "var output=``"+this.template;
+
+	this.code = this.code.replace(
+		/<for each="(.+?)" in="(.+?)"(?: sortby="(.+?)")?>/g, 
+		function (match, eachName, inName, sortby) {
+			if (!sortby) sortby = "asis";
+			
+			return "``; var $"+eachName+"_keys = "+sortby+"("+inName+"); for(var $"+eachName+"_i = 0; $"+eachName+"_i < $"+eachName+"_keys.length; $"+eachName+"_i++) { var $"+eachName+"_last = ($"+eachName+"_i == $"+eachName+"_keys.length-1); var $"+eachName+"_key = $"+eachName+"_keys[$"+eachName+"_i]; var "+eachName+" = "+inName+"[$"+eachName+"_key]; output+=``";
+		}
+	);	
+	this.code = this.code.replace(/<if test="(.+?)">/g, "``; if ($1) { output+=``");
+	this.code = this.code.replace(/<\/(if|for)>/g, "``; }; output+=``");
+	this.code = this.code.replace(
+		/\{\+\s*([\s\S]+?)\s*\+\}/gi,
+		function (match, code) {
+			code = code.replace(/"/g, "``"); // prevent qoute-escaping of inline code
+			code = code.replace(/(\r?\n)/g, " ");
+			return "``+"+code+"+``";
+		}
+	);
+	this.code = this.code.replace(
+		/\{!\s*([\s\S]+?)\s*!\}/gi,
+		function (match, code) {
+			code = code.replace(/"/g, "``"); // prevent qoute-escaping of inline code
+			code = code.replace(/(\r?\n)/g, " ");
+			return "``; "+code+"; output+=``";
+		}
+	);
+	this.code = this.code+"``;";
+
+	this.code = this.code.replace(/(\r?\n)/g, "\\n");
+	this.code = this.code.replace(/"/g, "\\\"");
+	this.code = this.code.replace(/``/g, "\"");
+}
+
+/**
+ * @private
+ */
+JsPlate.prototype.toCode = function() {
+	return this.code;
+}
+
+/**
+ * @private
+ * @static
+ * @memberOf JsPlate
+ */
+JsPlate.keys = function(obj) {
+	var keys = [];
+	if (obj.constructor.toString().indexOf("Array") > -1) {
+		for (var i = 0; i < obj.length; i++) keys.push(i);
+	}
+	else {
+		for (var i in obj) { keys.push(i); }
+	}
+	return keys.sort();
+};
+
+/**
+ * @private
+ * @static
+ * @memberOf JsPlate
+ */
+JsPlate.values = function(obj) {
+	var values = [];
+	if (obj.constructor.toString().indexOf("Array") > -1) {
+		for (var i = 0; i < obj.length; i++) values.push(obj[i]);
+	}
+	else {
+		for (var i in obj) { values.push(obj[i]); }
+	}
+	return values.sort();
+};
+
+/**
+ * @private
+ * @static
+ * @memberOf JsPlate
+ */
+JsPlate.asis = function(obj) {
+	var keys = [];
+	if (obj.constructor.toString().indexOf("Array") > -1) {
+		for (var i = 0; i < obj.length; i++) keys.push(i);
+	}
+	else {
+		for (var i in obj) { keys.push(i); }
+	}
+	return keys;
+};
+
+/**
+ * Return the output. This must be called after parse()
+ * @param {object} data What shall represent the "data" in your template.
+ * @return {string}
+ */
+JsPlate.prototype.process = function(data) {
+	var keys = JsPlate.keys;
+	var values = JsPlate.values;
+	var asis = JsPlate.asis;
+	eval(this.code);
+	return output;
+	//print(this.code)
+}

data/jsdoc/app/JsTestrun.js

@@ -0,0 +1,129 @@
+/**
+ * @fileOverview
+ * @name JsTestrun
+ * @author Michael Mathews micmath@gmail.com
+ * @url $HeadURL: https://jsdoc-toolkit.googlecode.com/svn/tags/jsdoc_toolkit-1.4.0b/app/JsTestrun.js $
+ * @revision $Id: JsTestrun.js 292 2007-10-25 22:17:25Z micmath $
+ * @license <a href="http://en.wikipedia.org/wiki/MIT_License">X11/MIT License</a>
+ *          (See the accompanying README file for full details.)
+ */
+ 
+/**
+	Yet another unit testing tool for JavaScript.
+	@author Michael Mathews <a href="mailto:micmath@gmail.com">micmath@gmail.com</a>
+	@param {object} testCases Properties are testcase names, values are functions to execute as tests.
+*/
+function testrun(testCases) {
+	var ran = 0;
+	for (t in testCases) {
+		var result = testCases[t]();
+		ran++;
+	}
+	
+	return testrun.reportOut+"-------------------------------\n"+((testrun.fails>0)? ":( Failed "+testrun.fails+"/" : ":) Passed all ")+testrun.count+" test"+((testrun.count == 1)? "":"s")+".\n";
+}
+
+
+testrun.count = 0;
+testrun.current = null;
+testrun.passes = 0;
+testrun.fails = 0;
+testrun.reportOut = "";
+
+/** @private */
+testrun.report = function(text) {
+	testrun.reportOut += text+"\n";
+}
+
+/**
+	Check if test evaluates to true.
+	@param {string} test To be evaluated.
+	@param {string} message Optional. To be displayed in the report.
+	@return {boolean} True if the string test evaluates to true.
+*/
+ok = function(test, message) {
+	testrun.count++;
+	
+	var result;
+	try {
+		result = eval(test);
+		
+		if (result) {
+			testrun.passes++;
+			testrun.report("    OK "+testrun.count+" - "+((message != null)? message : ""));
+		}
+		else {
+			testrun.fails++;
+			testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+		}
+	}
+	catch(e) {
+		testrun.fails++
+		testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+
+	}
+}
+
+/**
+	Check if test is same as expected.
+	@param {string} test To be evaluated.
+	@param {string} expected
+	@param {string} message Optional. To be displayed in the report. 
+	@return {boolean} True if (test == expected). Note that the comparison is not a strict equality check.
+*/
+is = function(test, expected, message) {
+	testrun.count++;
+	
+	var result;
+	try {
+		result = eval(test);
+		
+		if (result == expected) {
+			testrun.passes++
+			testrun.report("    OK "+testrun.count+" - "+((message != null)? message : ""));
+		}
+		else {
+			testrun.fails++
+			testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+			testrun.report("expected: "+expected);
+			testrun.report("     got: "+result);
+		}
+	}
+	catch(e) {
+		testrun.fails++
+		testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+		testrun.report("expected: "+expected);
+		testrun.report("     got: "+result);}
+}
+
+/**
+	Check if test matches pattern.
+	@param {string} test To be evaluated.
+	@param {string} pattern Used to create a RegExp.
+	@param {string} message Optional. To be displayed in the report.
+	@return {boolean} True if test matches pattern.
+*/
+like = function(test, pattern, message) {
+	testrun.count++;
+
+	var result;
+	try {
+		result = eval(test);
+		var rgx = new RegExp(pattern);
+		
+		if (rgx.test(result)) {
+			testrun.passes++
+			testrun.report("    OK "+testrun.count+" - "+((message != null)? message : ""));
+		}
+		else {
+			testrun.fails++
+			testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+			testrun.report("       this: "+result);
+			testrun.report("is not like: "+pattern);
+		}
+	}
+	catch(e) {
+		testrun.fails++
+		testrun.report("NOT OK "+testrun.count+" - "+((message != null)? message : ""));
+	}
+}