distil 0.7.0

data/vendor/jsdoc-toolkit/app/lib/JSDOC/JsPlate.js

@@ -0,0 +1,109 @@
+/**
+	@constructor
+*/
+JSDOC.JsPlate = function(templateFile) {
+	if (templateFile) this.template = IO.readFile(templateFile);
+	
+	this.templateFile = templateFile;
+	this.code = "";
+	this.parse();
+}
+
+JSDOC.JsPlate.prototype.parse = function() {
+	this.template = this.template.replace(/\{#[\s\S]+?#\}/gi, "");
+	this.code = "var output=\u001e"+this.template;
+
+	this.code = this.code.replace(
+		/<for +each="(.+?)" +in="(.+?)" *>/gi, 
+		function (match, eachName, inName) {
+			return "\u001e;\rvar $"+eachName+"_keys = keys("+inName+");\rfor(var $"+eachName+"_i = 0; $"+eachName+"_i < $"+eachName+"_keys.length; $"+eachName+"_i++) {\rvar $"+eachName+"_last = ($"+eachName+"_i == $"+eachName+"_keys.length-1);\rvar $"+eachName+"_key = $"+eachName+"_keys[$"+eachName+"_i];\rvar "+eachName+" = "+inName+"[$"+eachName+"_key];\routput+=\u001e";
+		}
+	);	
+	this.code = this.code.replace(/<if test="(.+?)">/g, "\u001e;\rif ($1) { output+=\u001e");
+	this.code = this.code.replace(/<elseif test="(.+?)"\s*\/>/g, "\u001e;}\relse if ($1) { output+=\u001e");
+	this.code = this.code.replace(/<else\s*\/>/g, "\u001e;}\relse { output+=\u001e");
+	this.code = this.code.replace(/<\/(if|for)>/g, "\u001e;\r};\routput+=\u001e");
+	this.code = this.code.replace(
+		/\{\+\s*([\s\S]+?)\s*\+\}/gi,
+		function (match, code) {
+			code = code.replace(/"/g, "\u001e"); // prevent qoute-escaping of inline code
+			code = code.replace(/(\r?\n)/g, " ");
+			return "\u001e+ ("+code+") +\u001e";
+		}
+	);
+	this.code = this.code.replace(
+		/\{!\s*([\s\S]+?)\s*!\}/gi,
+		function (match, code) {
+			code = code.replace(/"/g, "\u001e"); // prevent qoute-escaping of inline code
+			code = code.replace(/(\n)/g, " ");
+			return "\u001e; "+code+";\routput+=\u001e";
+		}
+	);
+	this.code = this.code+"\u001e;";
+
+	this.code = this.code.replace(/(\r?\n)/g, "\\n");
+	this.code = this.code.replace(/"/g, "\\\"");
+	this.code = this.code.replace(/\u001e/g, "\"");
+}
+
+JSDOC.JsPlate.prototype.toCode = function() {
+	return this.code;
+}
+
+JSDOC.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;
+};
+
+JSDOC.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;
+};
+
+JSDOC.JsPlate.prototype.process = function(data, compact) {
+	var keys = JSDOC.JsPlate.keys;
+	var values = JSDOC.JsPlate.values;
+	
+	try {
+		eval(this.code);
+	}
+	catch (e) {
+		print(">> There was an error evaluating the compiled code from template: "+this.templateFile);
+		print("   The error was on line "+e.lineNumber+" "+e.name+": "+e.message);
+		var lines = this.code.split("\r");
+		if (e.lineNumber-2 >= 0) print("line "+(e.lineNumber-1)+": "+lines[e.lineNumber-2]);
+		print("line "+e.lineNumber+": "+lines[e.lineNumber-1]);
+		print("");
+	}
+	
+	if (compact) { // patch by mcbain.asm
+ 		// Remove lines that contain only space-characters, usually left by lines in the template
+ 		// which originally only contained JSPlate tags or code. This makes it easier to write
+ 		// non-tricky templates which still put out nice code (not bloated with extra lines).
+ 		// Lines purposely left blank (just a line ending) are left alone.
+ 		output = output.replace(/\s+?(\r?)\n/g, "$1\n");
+ 	}
+ 	
+	/*debug*///print(this.code);
+	return output;
+}

data/vendor/jsdoc-toolkit/app/lib/JSDOC/Lang.js

@@ -0,0 +1,144 @@
+/**
+	@namespace
+*/
+JSDOC.Lang = {
+}
+
+JSDOC.Lang.isBuiltin = function(name) {
+	return (JSDOC.Lang.isBuiltin.coreObjects.indexOf(name) > -1);
+}
+JSDOC.Lang.isBuiltin.coreObjects = ['_global_', 'Array', 'Boolean', 'Date', 'Error', 'Function', 'Math', 'Number', 'Object', 'RegExp', 'String'];
+
+JSDOC.Lang.whitespace = function(ch) {
+	return JSDOC.Lang.whitespace.names[ch];
+}
+JSDOC.Lang.whitespace.names = {
+	" ":      "SPACE",
+	"\f":     "FORMFEED",
+	"\t":     "TAB",
+	"\u0009": "UNICODE_TAB",
+	"\u000A": "UNICODE_NBR",
+	"\u0008": "VERTICAL_TAB"
+};
+
+JSDOC.Lang.newline = function(ch) {
+	return JSDOC.Lang.newline.names[ch];
+}
+JSDOC.Lang.newline.names = {
+	"\n":     "NEWLINE",
+	"\r":     "RETURN",
+	"\u000A": "UNICODE_LF",
+	"\u000D": "UNICODE_CR",
+	"\u2029": "UNICODE_PS",
+	"\u2028": "UNICODE_LS"
+};
+
+JSDOC.Lang.keyword = function(word) {
+	return JSDOC.Lang.keyword.names["="+word];
+}
+JSDOC.Lang.keyword.names = {
+	"=break":      "BREAK",
+	"=case":       "CASE",
+	"=catch":      "CATCH",
+	"=const":      "VAR",
+	"=continue":   "CONTINUE",
+	"=default":    "DEFAULT",
+	"=delete":     "DELETE",
+	"=do":         "DO",
+	"=else":       "ELSE",
+	"=false":      "FALSE",
+	"=finally":    "FINALLY",
+	"=for":        "FOR",
+	"=function":   "FUNCTION",
+	"=if":         "IF",
+	"=in":         "IN",
+	"=instanceof": "INSTANCEOF",
+	"=new":        "NEW",
+	"=null":       "NULL",
+	"=return":     "RETURN",
+	"=switch":     "SWITCH",
+	"=this":       "THIS",
+	"=throw":      "THROW",
+	"=true":       "TRUE",
+	"=try":        "TRY",
+	"=typeof":     "TYPEOF",
+	"=void":       "VOID",
+	"=while":      "WHILE",
+	"=with":       "WITH",
+	"=var":        "VAR"
+};
+
+JSDOC.Lang.punc = function(ch) {
+	return JSDOC.Lang.punc.names[ch];
+}
+JSDOC.Lang.punc.names = {
+	";":   "SEMICOLON",
+	",":   "COMMA",
+	"?":   "HOOK",
+	":":   "COLON",
+	"||":  "OR", 
+	"&&":  "AND",
+	"|":   "BITWISE_OR",
+	"^":   "BITWISE_XOR",
+	"&":   "BITWISE_AND",
+	"===": "STRICT_EQ", 
+	"==":  "EQ",
+	"=":   "ASSIGN",
+	"!==": "STRICT_NE",
+	"!=":  "NE",
+	"<<":  "LSH",
+	"<=":  "LE", 
+	"<":   "LT",
+	">>>": "URSH",
+	">>":  "RSH",
+	">=":  "GE",
+	">":   "GT", 
+	"++":  "INCREMENT",
+	"--":  "DECREMENT",
+	"+":   "PLUS",
+	"-":   "MINUS",
+	"*":   "MUL",
+	"/":   "DIV", 
+	"%":   "MOD",
+	"!":   "NOT",
+	"~":   "BITWISE_NOT",
+	".":   "DOT",
+	"[":   "LEFT_BRACKET",
+	"]":   "RIGHT_BRACKET",
+	"{":   "LEFT_CURLY",
+	"}":   "RIGHT_CURLY",
+	"(":   "LEFT_PAREN",
+	")":   "RIGHT_PAREN"
+};
+
+JSDOC.Lang.matching = function(name) {
+	return JSDOC.Lang.matching.names[name];
+}
+JSDOC.Lang.matching.names = {
+	"LEFT_PAREN": "RIGHT_PAREN",
+	"RIGHT_PAREN": "LEFT_PAREN",
+	"LEFT_CURLY": "RIGHT_CURLY",
+	"RIGHT_CURLY": "LEFT_CURLY",
+	"LEFT_BRACE": "RIGHT_BRACE",
+	"RIGHT_BRACE": "LEFT_BRACE"
+}
+
+JSDOC.Lang.isNumber = function(str) {
+	return /^(\.[0-9]|[0-9]+\.|[0-9])[0-9]*([eE][+-][0-9]+)?$/i.test(str);
+}
+
+JSDOC.Lang.isHexDec = function(str) {
+	return /^0x[0-9A-F]+$/i.test(str);
+}
+
+JSDOC.Lang.isWordChar = function(str) {
+	return /^[a-zA-Z0-9$_.]+$/.test(str);
+}
+
+JSDOC.Lang.isSpace = function(str) {
+	return (typeof JSDOC.Lang.whitespace(str) != "undefined");
+}
+
+JSDOC.Lang.isNewline = function(str) {
+	return (typeof JSDOC.Lang.newline(str) != "undefined");
+}

data/vendor/jsdoc-toolkit/app/lib/JSDOC/Parser.js

@@ -0,0 +1,144 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+	@namespace
+	@requires JSDOC.Walker
+	@requires JSDOC.Symbol
+	@requires JSDOC.DocComment
+*/
+JSDOC.Parser = {
+	conf: {
+		ignoreCode:               JSDOC.opt.n,
+		ignoreAnonymous:           true, // factory: true
+		treatUnderscoredAsPrivate: true, // factory: true
+		explain:                   false // factory: false
+	},
+	
+	addSymbol: function(symbol) {
+
+if (JSDOC.Parser.rename) {
+	for (var n in JSDOC.Parser.rename) {
+		if (symbol.alias.indexOf(n) == 0) {
+			if (symbol.name == symbol.alias) {
+				symbol.name = symbol.name.replace(n, JSDOC.Parser.rename[n]);
+			}
+			symbol.alias = symbol.alias.replace(n, JSDOC.Parser.rename[n]);
+		}
+	}
+}
+
+if (JSDOC.opt.S) {
+	if (typeof JSDOC.Parser.secureModules == "undefined") JSDOC.Parser.secureModules = {};
+	if (/^exports\./.test(symbol.alias)) {
+		symbol.srcFile.match(/(^|[\\\/])([^\\\/]+)\.js/i);
+		var fileNS = RegExp.$2;
+		
+		// need to create the namespace associated with this file first
+		if (!JSDOC.Parser.secureModules[fileNS]) {
+			JSDOC.Parser.secureModules[fileNS] = 1;
+				var nsSymbol = new JSDOC.Symbol(fileNS, [], "GLOBAL", new JSDOC.DocComment(""));
+				nsSymbol.isNamespace = true;
+				nsSymbol.srcFile = "";
+				nsSymbol.isPrivate = false;
+				nsSymbol.srcFile = symbol.srcFile;
+				nsSymbol.desc = (JSDOC.Parser.symbols.getSymbol(symbol.srcFile) || {desc: ""}).desc;
+				JSDOC.Parser.addSymbol(nsSymbol);
+				}
+
+				symbol.alias = symbol.alias.replace(/^exports\./, fileNS + '.');
+				symbol.name = symbol.name.replace(/^exports\./, '');
+				symbol.memberOf = fileNS;
+				symbol.isStatic = true;
+		}
+	}
+
+		// if a symbol alias is documented more than once the last one with the user docs wins
+		if (JSDOC.Parser.symbols.hasSymbol(symbol.alias)) {
+ 			var oldSymbol = JSDOC.Parser.symbols.getSymbol(symbol.alias);
+			if (oldSymbol.comment.isUserComment) {
+				if (symbol.comment.isUserComment) { // old and new are both documented
+					LOG.warn("The symbol '"+symbol.alias+"' is documented more than once.");
+				}
+				else { // old is documented but new isn't
+					return;
+				}
+			}
+		}
+		
+		// we don't document anonymous things
+		if (JSDOC.Parser.conf.ignoreAnonymous && symbol.name.match(/\$anonymous\b/)) return;
+
+		// uderscored things may be treated as if they were marked private, this cascades
+		if (JSDOC.Parser.conf.treatUnderscoredAsPrivate && symbol.name.match(/[.#-]_[^.#-]+$/)) {
+			if (!symbol.comment.getTag("public").length > 0) symbol.isPrivate = true;
+		}
+		
+		// -p flag is required to document private things
+		if (!JSDOC.opt.p && symbol.isPrivate) return; // issue #161 fixed by mcbain.asm
+		
+		// ignored things are not documented, this doesn't cascade
+		if (symbol.isIgnored) return;
+		JSDOC.Parser.symbols.addSymbol(symbol);
+	},
+	
+	addBuiltin: function(name) {
+		var builtin = new JSDOC.Symbol(name, [], "CONSTRUCTOR", new JSDOC.DocComment(""));
+		builtin.isNamespace = true;
+		builtin.srcFile = "";
+		builtin.isPrivate = false;
+		JSDOC.Parser.addSymbol(builtin);
+		return builtin;
+	},
+	
+	init: function() {
+		JSDOC.Parser.symbols = new JSDOC.SymbolSet();
+		JSDOC.Parser.walker = new JSDOC.Walker();
+	},
+	
+	finish: function() {
+		JSDOC.Parser.symbols.relate();		
+		
+		// make a litle report about what was found
+		if (JSDOC.Parser.conf.explain) {
+			var symbols = JSDOC.Parser.symbols.toArray();
+			var srcFile = "";
+			for (var i = 0, l = symbols.length; i < l; i++) {
+				var symbol = symbols[i];
+				if (srcFile != symbol.srcFile) {
+					srcFile = symbol.srcFile;
+					print("\n"+srcFile+"\n-------------------");
+				}
+				print(i+":\n  alias => "+symbol.alias + "\n  name => "+symbol.name+ "\n  isa => "+symbol.isa + "\n  memberOf => " + symbol.memberOf + "\n  isStatic => " + symbol.isStatic + ",  isInner => " + symbol.isInner+ ",  isPrivate => " + symbol.isPrivate);
+			}
+			print("-------------------\n");
+		}
+	}
+}
+
+JSDOC.Parser.parse = function(/**JSDOC.TokenStream*/ts, /**String*/srcFile) {
+	JSDOC.Symbol.srcFile = (srcFile || "");
+	JSDOC.DocComment.shared = ""; // shared comments don't cross file boundaries
+	
+	if (!JSDOC.Parser.walker) JSDOC.Parser.init();
+	JSDOC.Parser.walker.walk(ts); // adds to our symbols
+	
+	// filter symbols by option
+	for (var p = JSDOC.Parser.symbols._index.first(); p; p = JSDOC.Parser.symbols._index.next()) {
+		var symbol = p.value;
+		
+		if (!symbol) continue;
+		
+		if (symbol.is("FILE") || symbol.is("GLOBAL")) {
+			continue;
+		}
+		else if (!JSDOC.opt.a && !symbol.comment.isUserComment) {
+			JSDOC.Parser.symbols.deleteSymbol(symbol.alias);
+		}
+		
+		if (/#$/.test(symbol.alias)) { // we don't document prototypes
+			JSDOC.Parser.symbols.deleteSymbol(symbol.alias);
+		}
+	}
+	
+	return JSDOC.Parser.symbols.toArray();
+}

data/vendor/jsdoc-toolkit/app/lib/JSDOC/PluginManager.js

@@ -0,0 +1,33 @@
+/**
+	@namespace Holds functionality related to running plugins.
+*/
+JSDOC.PluginManager = {
+}
+
+/**
+	@param name A unique name that identifies that plugin.
+	@param handlers A collection of named functions. The names correspond to hooks in the core code.
+*/
+JSDOC.PluginManager.registerPlugin = function(/**String*/name, /**Object*/handlers) {
+	if (!defined(JSDOC.PluginManager.plugins))
+		/** The collection of all plugins. Requires a unique name for each.
+		*/
+		JSDOC.PluginManager.plugins = {};
+	
+	
+	JSDOC.PluginManager.plugins[name] = handlers;
+}
+
+/**
+	@param hook The name of the hook that is being caught.
+	@param target Any object. This will be passed as the only argument to the handler whose
+	name matches the hook name. Handlers cannot return a value, so must modify the target
+	object to have an effect.
+*/
+JSDOC.PluginManager.run = function(/**String*/hook, /**Mixed*/target) {
+	for (var name in JSDOC.PluginManager.plugins) {
+		if (defined(JSDOC.PluginManager.plugins[name][hook])) {
+			JSDOC.PluginManager.plugins[name][hook](target);
+		}
+	}
+}