Skip to content
Browse files

Add JSDoc to generate API documentation

  • Loading branch information...
1 parent 2ad575b commit 748582160a21257d46da440a84ef110f2ed37858 Fabien Lavignotte committed Mar 11, 2013
Showing with 6,817 additions and 0 deletions.
  1. +1 −0 .gitignore
  2. +16 −0 build/jsdoc-toolkit/GlobWeb.conf
  3. +33 −0 build/jsdoc-toolkit/app/frame.js
  4. +102 −0 build/jsdoc-toolkit/app/frame/Chain.js
  5. +144 −0 build/jsdoc-toolkit/app/frame/Dumper.js
  6. +84 −0 build/jsdoc-toolkit/app/frame/Hash.js
  7. +173 −0 build/jsdoc-toolkit/app/frame/Link.js
  8. +10 −0 build/jsdoc-toolkit/app/frame/Namespace.js
  9. +134 −0 build/jsdoc-toolkit/app/frame/Opt.js
  10. +26 −0 build/jsdoc-toolkit/app/frame/Reflection.js
  11. +93 −0 build/jsdoc-toolkit/app/frame/String.js
  12. +129 −0 build/jsdoc-toolkit/app/frame/Testrun.js
  13. +26 −0 build/jsdoc-toolkit/app/handlers/FOODOC.js
  14. +26 −0 build/jsdoc-toolkit/app/handlers/XMLDOC.js
  15. +159 −0 build/jsdoc-toolkit/app/handlers/XMLDOC/DomReader.js
  16. +16 −0 build/jsdoc-toolkit/app/handlers/XMLDOC/XMLDoc.js
  17. +292 −0 build/jsdoc-toolkit/app/handlers/XMLDOC/XMLParse.js
  18. +106 −0 build/jsdoc-toolkit/app/lib/JSDOC.js
  19. +204 −0 build/jsdoc-toolkit/app/lib/JSDOC/DocComment.js
  20. +294 −0 build/jsdoc-toolkit/app/lib/JSDOC/DocTag.js
  21. +140 −0 build/jsdoc-toolkit/app/lib/JSDOC/JsDoc.js
  22. +109 −0 build/jsdoc-toolkit/app/lib/JSDOC/JsPlate.js
  23. +144 −0 build/jsdoc-toolkit/app/lib/JSDOC/Lang.js
  24. +146 −0 build/jsdoc-toolkit/app/lib/JSDOC/Parser.js
  25. +33 −0 build/jsdoc-toolkit/app/lib/JSDOC/PluginManager.js
  26. +644 −0 build/jsdoc-toolkit/app/lib/JSDOC/Symbol.js
  27. +243 −0 build/jsdoc-toolkit/app/lib/JSDOC/SymbolSet.js
  28. +41 −0 build/jsdoc-toolkit/app/lib/JSDOC/TextStream.js
  29. +18 −0 build/jsdoc-toolkit/app/lib/JSDOC/Token.js
  30. +332 −0 build/jsdoc-toolkit/app/lib/JSDOC/TokenReader.js
  31. +133 −0 build/jsdoc-toolkit/app/lib/JSDOC/TokenStream.js
  32. +32 −0 build/jsdoc-toolkit/app/lib/JSDOC/Util.js
  33. +507 −0 build/jsdoc-toolkit/app/lib/JSDOC/Walker.js
  34. +111 −0 build/jsdoc-toolkit/app/main.js
  35. +20 −0 build/jsdoc-toolkit/app/plugins/commentSrcJson.js
  36. +16 −0 build/jsdoc-toolkit/app/plugins/frameworkPrototype.js
  37. +10 −0 build/jsdoc-toolkit/app/plugins/functionCall.js
  38. +62 −0 build/jsdoc-toolkit/app/plugins/publishSrcHilite.js
  39. +10 −0 build/jsdoc-toolkit/app/plugins/symbolLink.js
  40. +31 −0 build/jsdoc-toolkit/app/plugins/tagParamConfig.js
  41. +43 −0 build/jsdoc-toolkit/app/plugins/tagSynonyms.js
  42. +348 −0 build/jsdoc-toolkit/app/run.js
  43. +342 −0 build/jsdoc-toolkit/app/test.js
  44. +2 −0 build/jsdoc-toolkit/generate.bat
  45. BIN build/jsdoc-toolkit/java/classes/js.jar
  46. BIN build/jsdoc-toolkit/jsdebug.jar
  47. BIN build/jsdoc-toolkit/jsrun.jar
  48. +52 −0 build/jsdoc-toolkit/jsrun.sh
  49. +17 −0 build/jsdoc-toolkit/templates/jsdoc/allclasses.tmpl
  50. +56 −0 build/jsdoc-toolkit/templates/jsdoc/allfiles.tmpl
  51. +649 −0 build/jsdoc-toolkit/templates/jsdoc/class.tmpl
  52. +39 −0 build/jsdoc-toolkit/templates/jsdoc/index.tmpl
  53. +201 −0 build/jsdoc-toolkit/templates/jsdoc/publish.js
  54. +162 −0 build/jsdoc-toolkit/templates/jsdoc/static/default.css
  55. +2 −0 build/jsdoc-toolkit/templates/jsdoc/static/header.html
  56. +19 −0 build/jsdoc-toolkit/templates/jsdoc/static/index.html
  57. +35 −0 build/jsdoc-toolkit/templates/jsdoc/symbol.tmpl
View
1 .gitignore
@@ -1,4 +1,5 @@
generated/
+api_doc/
*~
############
## Windows
View
16 build/jsdoc-toolkit/GlobWeb.conf
@@ -0,0 +1,16 @@
+{
+ // source files to use
+ _: ['../../src'],
+
+ // document all functions, even uncommented ones
+ a: false,
+
+ // including those marked @private
+ p: false,
+
+ // use this directory as the output directory
+ d: "../../api_doc",
+
+ // use this template
+ t: "templates/jsdoc"
+}
View
33 build/jsdoc-toolkit/app/frame.js
@@ -0,0 +1,33 @@
+IO.include("frame/Opt.js");
+IO.include("frame/Chain.js");
+IO.include("frame/Link.js");
+IO.include("frame/String.js");
+IO.include("frame/Hash.js");
+IO.include("frame/Namespace.js");
+//IO.include("frame/Reflection.js");
+
+/** A few helper functions to make life a little easier. */
+
+function defined(o) {
+ return (o !== undefined);
+}
+
+function copy(o) { // todo check for circular refs
+ if (o == null || typeof(o) != 'object') return o;
+ var c = new o.constructor();
+ for(var p in o) c[p] = copy(o[p]);
+ return c;
+}
+
+function isUnique(arr) {
+ var l = arr.length;
+ for(var i = 0; i < l; i++ ) {
+ if (arr.lastIndexOf(arr[i]) > i) return false;
+ }
+ return true;
+}
+
+/** Returns the given string with all regex meta characters backslashed. */
+RegExp.escapeMeta = function(str) {
+ return str.replace(/([$^\\\/()|?+*\[\]{}.-])/g, "\\$1");
+}
View
102 build/jsdoc-toolkit/app/frame/Chain.js
@@ -0,0 +1,102 @@
+/**@constructor*/
+function ChainNode(object, link) {
+ this.value = object;
+ this.link = link; // describes this node's relationship to the previous node
+}
+
+/**@constructor*/
+function Chain(valueLinks) {
+ this.nodes = [];
+ this.cursor = -1;
+
+ if (valueLinks && valueLinks.length > 0) {
+ this.push(valueLinks[0], "//");
+ for (var i = 1, l = valueLinks.length; i < l; i+=2) {
+ this.push(valueLinks[i+1], valueLinks[i]);
+ }
+ }
+}
+
+Chain.prototype.push = function(o, link) {
+ if (this.nodes.length > 0 && link) this.nodes.push(new ChainNode(o, link));
+ else this.nodes.push(new ChainNode(o));
+}
+
+Chain.prototype.unshift = function(o, link) {
+ if (this.nodes.length > 0 && link) this.nodes[0].link = link;
+ this.nodes.unshift(new ChainNode(o));
+ this.cursor++;
+}
+
+Chain.prototype.get = function() {
+ if (this.cursor < 0 || this.cursor > this.nodes.length-1) return null;
+ return this.nodes[this.cursor];
+}
+
+Chain.prototype.first = function() {
+ this.cursor = 0;
+ return this.get();
+}
+
+Chain.prototype.last = function() {
+ this.cursor = this.nodes.length-1;
+ return this.get();
+}
+
+Chain.prototype.next = function() {
+ this.cursor++;
+ return this.get();
+}
+
+Chain.prototype.prev = function() {
+ this.cursor--;
+ return this.get();
+}
+
+Chain.prototype.toString = function() {
+ var string = "";
+ for (var i = 0, l = this.nodes.length; i < l; i++) {
+ if (this.nodes[i].link) string += " -("+this.nodes[i].link+")-> ";
+ string += this.nodes[i].value.toString();
+ }
+ return string;
+}
+
+Chain.prototype.joinLeft = function() {
+ var result = "";
+ for (var i = 0, l = this.cursor; i < l; i++) {
+ if (result && this.nodes[i].link) result += this.nodes[i].link;
+ result += this.nodes[i].value.toString();
+ }
+ return result;
+}
+
+
+/* USAGE:
+
+var path = "one/two/three.four/five-six";
+var pathChain = new Chain(path.split(/([\/.-])/));
+print(pathChain);
+
+var lineage = new Chain();
+lineage.push("Port");
+lineage.push("Les", "son");
+lineage.push("Dawn", "daughter");
+lineage.unshift("Purdie", "son");
+
+print(lineage);
+
+// walk left
+for (var node = lineage.last(); node !== null; node = lineage.prev()) {
+ print("< "+node.value);
+}
+
+// walk right
+var node = lineage.first()
+while (node !== null) {
+ print(node.value);
+ node = lineage.next();
+ if (node && node.link) print("had a "+node.link+" named");
+}
+
+*/
View
144 build/jsdoc-toolkit/app/frame/Dumper.js
@@ -0,0 +1,144 @@
+/**
+ * @class
+<pre>
+This is a lightly modified version of Kevin Jones' JavaScript
+library Data.Dump. To download the original visit:
+ <a href="http://openjsan.org/doc/k/ke/kevinj/Data/Dump/">http://openjsan.org/doc/k/ke/kevinj/Data/Dump/</a>
+
+AUTHORS
+
+The Data.Dump JavaScript module is written by Kevin Jones
+(kevinj@cpan.org), based on Data::Dump by Gisle Aas (gisle@aas.no),
+based on Data::Dumper by Gurusamy Sarathy (gsar@umich.edu).
+
+COPYRIGHT
+
+Copyright 2007 Kevin Jones. Copyright 1998-2000,2003-2004 Gisle Aas.
+Copyright 1996-1998 Gurusamy Sarathy.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the Perl Artistic License
+
+See http://www.perl.com/perl/misc/Artistic.html
+</pre>
+ * @static
+ */
+Dumper = {
+ /** @param [...] The objects to dump. */
+ dump: function () {
+ if (arguments.length > 1)
+ return this._dump(arguments);
+ else if (arguments.length == 1)
+ return this._dump(arguments[0]);
+ else
+ return "()";
+ },
+
+ _dump: function (obj) {
+ if (typeof obj == 'undefined') return 'undefined';
+ var out;
+ if (obj.serialize) { return obj.serialize(); }
+ var type = this._typeof(obj);
+ if (obj.circularReference) obj.circularReference++;
+ switch (type) {
+ case 'circular':
+ out = "{ //circularReference\n}";
+ break;
+ case 'object':
+ var pairs = new Array;
+
+ for (var prop in obj) {
+ if (prop != "circularReference" && obj.hasOwnProperty(prop)) { //hide inherited properties
+ pairs.push(prop + ': ' + this._dump(obj[prop]));
+ }
+ }
+
+ out = '{' + this._format_list(pairs) + '}';
+ break;
+
+ case 'string':
+ for (var prop in Dumper.ESC) {
+ if (Dumper.ESC.hasOwnProperty(prop)) {
+ obj = obj.replace(prop, Dumper.ESC[prop]);
+ }
+ }
+
+ // Escape UTF-8 Strings
+ if (obj.match(/^[\x00-\x7f]*$/)) {
+ out = '"' + obj.replace(/\"/g, "\\\"").replace(/([\n\r]+)/g, "\\$1") + '"';
+ }
+ else {
+ out = "unescape('"+escape(obj)+"')";
+ }
+ break;
+
+ case 'array':
+ var elems = new Array;
+
+ for (var i=0; i<obj.length; i++) {
+ elems.push( this._dump(obj[i]) );
+ }
+
+ out = '[' + this._format_list(elems) + ']';
+ break;
+
+ case 'date':
+ // firefox returns GMT strings from toUTCString()...
+ var utc_string = obj.toUTCString().replace(/GMT/,'UTC');
+ out = 'new Date("' + utc_string + '")';
+ break;
+
+ case 'element':
+ // DOM element
+ out = this._dump_dom(obj);
+ break;
+
+ default:
+ out = obj;
+ }
+
+ out = String(out).replace(/\n/g, '\n ');
+ out = out.replace(/\n (.*)$/,"\n$1");
+
+ return out;
+ },
+
+ _format_list: function (list) {
+ if (!list.length) return '';
+ var nl = list.toString().length > 60 ? '\n' : ' ';
+ return nl + list.join(',' + nl) + nl;
+ },
+
+ _typeof: function (obj) {
+ if (obj && obj.circularReference && obj.circularReference > 1) return 'circular';
+ if (Array.prototype.isPrototypeOf(obj)) return 'array';
+ if (Date.prototype.isPrototypeOf(obj)) return 'date';
+ if (typeof obj.nodeType != 'undefined') return 'element';
+ return typeof(obj);
+ },
+
+ _dump_dom: function (obj) {
+ return '"' + Dumper.nodeTypes[obj.nodeType] + '"';
+ }
+};
+
+Dumper.ESC = {
+ "\t": "\\t",
+ "\n": "\\n",
+ "\f": "\\f"
+};
+
+Dumper.nodeTypes = {
+ 1: "ELEMENT_NODE",
+ 2: "ATTRIBUTE_NODE",
+ 3: "TEXT_NODE",
+ 4: "CDATA_SECTION_NODE",
+ 5: "ENTITY_REFERENCE_NODE",
+ 6: "ENTITY_NODE",
+ 7: "PROCESSING_INSTRUCTION_NODE",
+ 8: "COMMENT_NODE",
+ 9: "DOCUMENT_NODE",
+ 10: "DOCUMENT_TYPE_NODE",
+ 11: "DOCUMENT_FRAGMENT_NODE",
+ 12: "NOTATION_NODE"
+};
View
84 build/jsdoc-toolkit/app/frame/Hash.js
@@ -0,0 +1,84 @@
+/**
+ @constructor
+ @example
+ var _index = new Hash();
+ _index.set("a", "apple");
+ _index.set("b", "blue");
+ _index.set("c", "coffee");
+
+ for (var p = _index.first(); p; p = _index.next()) {
+ print(p.key+" is for "+p.value);
+ }
+
+ */
+var Hash = function() {
+ this._map = {};
+ this._keys = [];
+ this._vals = [];
+ this.reset();
+}
+
+Hash.prototype.set = function(k, v) {
+ if (k != "") {
+ this._keys.push(k);
+ this._map["="+k] = this._vals.length;
+ this._vals.push(v);
+ }
+}
+
+Hash.prototype.replace = function(k, k2, v) {
+ if (k == k2) return;
+
+ var offset = this._map["="+k];
+ this._keys[offset] = k2;
+ if (typeof v != "undefined") this._vals[offset] = v;
+ this._map["="+k2] = offset;
+ delete(this._map["="+k]);
+}
+
+Hash.prototype.drop = function(k) {
+ if (k != "") {
+ var offset = this._map["="+k];
+ this._keys.splice(offset, 1);
+ this._vals.splice(offset, 1);
+ delete(this._map["="+k]);
+ for (var p in this._map) {
+ if (this._map[p] >= offset) this._map[p]--;
+ }
+ if (this._cursor >= offset && this._cursor > 0) this._cursor--;
+ }
+}
+
+Hash.prototype.get = function(k) {
+ if (k != "") {
+ return this._vals[this._map["="+k]];
+ }
+}
+
+Hash.prototype.keys = function() {
+ return this._keys;
+}
+
+Hash.prototype.hasKey = function(k) {
+ if (k != "") {
+ return (typeof this._map["="+k] != "undefined");
+ }
+}
+
+Hash.prototype.values = function() {
+ return this._vals;
+}
+
+Hash.prototype.reset = function() {
+ this._cursor = 0;
+}
+
+Hash.prototype.first = function() {
+ this.reset();
+ return this.next();
+}
+
+Hash.prototype.next = function() {
+ if (this._cursor++ < this._keys.length)
+ return {key: this._keys[this._cursor-1], value: this._vals[this._cursor-1]};
+}
View
173 build/jsdoc-toolkit/app/frame/Link.js
@@ -0,0 +1,173 @@
+/** Handle the creation of HTML links to documented symbols.
+ @constructor
+*/
+function Link() {
+ this.alias = "";
+ this.src = "";
+ this.file = "";
+ this.text = "";
+ this.innerName = "";
+ this.classLink = false;
+ this.targetName = "";
+
+ this.target = function(targetName) {
+ if (defined(targetName)) this.targetName = targetName;
+ return this;
+ }
+ this.inner = function(inner) {
+ if (defined(inner)) this.innerName = inner;
+ return this;
+ }
+ this.withText = function(text) {
+ if (defined(text)) this.text = text;
+ return this;
+ }
+ this.toSrc = function(filename) {
+ if (defined(filename)) this.src = filename;
+ return this;
+ }
+ this.toSymbol = function(alias) {
+ if (defined(alias)) this.alias = new String(alias);
+ return this;
+ }
+ this.toClass = function(alias) {
+ this.classLink = true;
+ return this.toSymbol(alias);
+ }
+ this.toFile = function(file) {
+ if (defined(file)) this.file = file;
+ return this;
+ }
+
+ this.toString = function() {
+ var linkString;
+ var thisLink = this;
+
+ if (this.alias) {
+ linkString = this.alias.replace(/(^|[^a-z$0-9_#.:^-])([|a-z$0-9_#.:^-]+)($|[^a-z$0-9_#.:^-])/i,
+ function(match, prematch, symbolName, postmatch) {
+ var symbolNames = symbolName.split("|");
+ var links = [];
+ for (var i = 0, l = symbolNames.length; i < l; i++) {
+ thisLink.alias = symbolNames[i];
+ links.push(thisLink._makeSymbolLink(symbolNames[i]));
+ }
+ return prematch+links.join("|")+postmatch;
+ }
+ );
+ }
+ else if (this.src) {
+ linkString = thisLink._makeSrcLink(this.src);
+ }
+ else if (this.file) {
+ linkString = thisLink._makeFileLink(this.file);
+ }
+
+ return linkString;
+ }
+}
+
+/** prefixed for hashes */
+Link.hashPrefix = "";
+
+/** Appended to the front of relative link paths. */
+Link.base = "";
+
+Link.symbolNameToLinkName = function(symbol) {
+ var linker = "",
+ ns = "";
+
+ if (symbol.isStatic) linker = ".";
+ else if (symbol.isInner) linker = "-";
+
+ if (symbol.isEvent && !/^event:/.test(symbol.name)) {
+ ns = "event:";
+ }
+ return Link.hashPrefix+linker+ns+symbol.name;
+}
+
+Link.getSymbol= function(alias) {
+ var symbol= Link.symbolSet.getSymbol(alias);
+
+ if (symbol)
+ return symbol;
+
+ if ('#'!==alias.charAt(0) || !Link.currentSymbol)
+ return null;
+
+ // resolve relative name
+ var container= Link.currentSymbol;
+
+ while (container)
+ {
+ symbol= Link.symbolSet.getSymbol(container.alias + alias);
+ if (symbol)
+ return symbol;
+
+ // No superclass
+ if (!container.augments.length)
+ return null;
+
+ container= Link.symbolSet.getSymbol(container.augments[0].desc);
+ }
+
+ return null;
+}
+
+/** Create a link to another symbol. */
+Link.prototype._makeSymbolLink = function(alias) {
+ var linkBase = Link.base+publish.conf.symbolsDir;
+ var linkTo = Link.getSymbol(alias);
+ var linkPath;
+ var target = (this.targetName)? " target=\""+this.targetName+"\"" : "";
+
+ // if there is no symbol by that name just return the name unaltered
+ if (!linkTo)
+ return this.text || alias;
+
+ // it's a symbol in another file
+ else {
+ if (!linkTo.is("CONSTRUCTOR") && !linkTo.isNamespace) { // it's a method or property
+ linkPath= (Link.filemap) ? Link.filemap[linkTo.memberOf] :
+ escape(linkTo.memberOf) || "_global_";
+ linkPath += publish.conf.ext + "#" + Link.symbolNameToLinkName(linkTo);
+ }
+ else {
+ linkPath = (Link.filemap)? Link.filemap[linkTo.alias] : escape(linkTo.alias);
+ linkPath += publish.conf.ext;// + (this.classLink? "":"#" + Link.hashPrefix + "constructor");
+ }
+ linkPath = linkBase + linkPath
+ }
+
+ var linkText= this.text || alias;
+
+ var link = {linkPath: linkPath, linkText: linkText, linkInner: (this.innerName? "#"+this.innerName : "")};
+
+ if (typeof JSDOC.PluginManager != "undefined") {
+ JSDOC.PluginManager.run("onSymbolLink", link);
+ }
+
+ return "<a href=\""+link.linkPath+link.linkInner+"\""+target+">"+link.linkText+"</a>";
+}
+
+/** Create a link to a source file. */
+Link.prototype._makeSrcLink = function(srcFilePath) {
+ var target = (this.targetName)? " target=\""+this.targetName+"\"" : "";
+
+ // transform filepath into a filename
+ var srcFile = srcFilePath.replace(/\.\.?[\\\/]/g, "").replace(/[:\\\/]/g, "_");
+ var outFilePath = Link.base + publish.conf.srcDir + srcFile + publish.conf.ext;
+
+ if (!this.text) this.text = FilePath.fileName(srcFilePath);
+ return "<a href=\""+outFilePath+"\""+target+">"+this.text+"</a>";
+}
+
+/** Create a link to a source file. */
+Link.prototype._makeFileLink = function(filePath) {
+ var target = (this.targetName)? " target=\""+this.targetName+"\"" : "";
+
+ var outFilePath = Link.base + filePath;
+
+ if (!this.text) this.text = filePath;
+ return "<a href=\""+outFilePath+"\""+target+">"+this.text+"</a>";
+}
View
10 build/jsdoc-toolkit/app/frame/Namespace.js
@@ -0,0 +1,10 @@
+_global_ = this;
+
+function Namespace(name, f) {
+ var n = name.split(".");
+ for (var o = _global_, i = 0, l = n.length; i < l; i++) {
+ o = o[n[i]] = o[n[i]] || {};
+ }
+
+ if (f) f();
+}
View
134 build/jsdoc-toolkit/app/frame/Opt.js
@@ -0,0 +1,134 @@
+/** @namespace */
+Opt = {
+ /**
+ * Get commandline option values.
+ * @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}
+ */
+ get: 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;
+ }
+}
+
+/*t:
+ plan(11, "Testing Opt.");
+
+ is(
+ typeof Opt,
+ "object",
+ "Opt is an object."
+ );
+
+ is(
+ typeof Opt.get,
+ "function",
+ "Opt.get is a function."
+ );
+
+ var optNames = {a:"accept", b:"backtrace", c:"class", d:"debug", "e[]":"exceptions"};
+ var t_options = Opt.get(["-a=xml", "-b", "--class=new", "--debug", "-e=one", "-e=two", "foo", "bar"], optNames);
+
+ is(
+ t_options.a,
+ "xml",
+ "an option defined with a short name can be accessed by its short name."
+ );
+
+ is(
+ t_options.b,
+ true,
+ "an option defined with a short name and no value are true."
+ );
+
+ is(
+ t_options.c,
+ "new",
+ "an option defined with a long name can be accessed by its short name."
+ );
+
+ is(
+ t_options.d,
+ true,
+ "an option defined with a long name and no value are true."
+ );
+
+ is(
+ typeof t_options.e,
+ "object",
+ "an option that can accept multiple values is defined."
+ );
+
+ is(
+ t_options.e.length,
+ 2,
+ "an option that can accept multiple values can have more than one value."
+ );
+
+ is(
+ t_options.e[1],
+ "two",
+ "an option that can accept multiple values can be accessed as an array."
+ );
+
+ is(
+ typeof t_options._,
+ "object",
+ "the property '_' is defined for unnamed options."
+ );
+
+ is(
+ t_options._[0],
+ "foo",
+ "the property '_' can be accessed as an array."
+ );
+ */
View
26 build/jsdoc-toolkit/app/frame/Reflection.js
@@ -0,0 +1,26 @@
+/**@constructor*/
+function Reflection(obj) {
+ this.obj = obj;
+}
+
+Reflection.prototype.getConstructorName = function() {
+ if (this.obj.constructor.name) return this.obj.constructor.name;
+ var src = this.obj.constructor.toSource();
+ var name = src.substring(name.indexOf("function")+8, src.indexOf('(')).replace(/ /g,'');
+ return name;
+}
+
+Reflection.prototype.getMethod = function(name) {
+ for (var p in this.obj) {
+ if (p == name && typeof(this.obj[p]) == "function") return this.obj[p];
+ }
+ return null;
+}
+
+Reflection.prototype.getParameterNames = function() {
+ var src = this.obj.toSource();
+ src = src.substring(
+ src.indexOf("(", 8)+1, src.indexOf(")")
+ );
+ return src.split(/, ?/);
+}
View
93 build/jsdoc-toolkit/app/frame/String.js
@@ -0,0 +1,93 @@
+/**
+ @name String
+ @class Additions to the core string object.
+*/
+
+/** @author Steven Levithan, released as public domain. */
+String.prototype.trim = function() {
+ var str = this.replace(/^\s+/, '');
+ for (var i = str.length - 1; i >= 0; i--) {
+ if (/\S/.test(str.charAt(i))) {
+ str = str.substring(0, i + 1);
+ break;
+ }
+ }
+ return str;
+}
+/*t:
+ plan(6, "Testing String.prototype.trim.");
+
+ var s = " a bc ".trim();
+ is(s, "a bc", "multiple spaces front and back are trimmed.");
+
+ s = "a bc\n\n".trim();
+ is(s, "a bc", "newlines only in back are trimmed.");
+
+ s = "\ta bc".trim();
+ is(s, "a bc", "tabs only in front are trimmed.");
+
+ s = "\n \t".trim();
+ is(s, "", "an all-space string is trimmed to empty.");
+
+ s = "a b\nc".trim();
+ is(s, "a b\nc", "a string with no spaces in front or back is trimmed to itself.");
+
+ s = "".trim();
+ is(s, "", "an empty string is trimmed to empty.");
+
+*/
+
+String.prototype.balance = function(open, close) {
+ var i = 0;
+ while (this.charAt(i) != open) {
+ if (i == this.length) return [-1, -1];
+ i++;
+ }
+
+ var j = i+1;
+ var balance = 1;
+ while (j < this.length) {
+ if (this.charAt(j) == open) balance++;
+ if (this.charAt(j) == close) balance--;
+ if (balance == 0) break;
+ j++;
+ if (j == this.length) return [-1, -1];
+ }
+
+ return [i, j];
+}
+/*t:
+ plan(16, "Testing String.prototype.balance.");
+
+ var s = "{abc}".balance("{","}");
+ is(s[0], 0, "opener in first is found.");
+ is(s[1], 4, "closer in last is found.");
+
+ s = "ab{c}de".balance("{","}");
+ is(s[0], 2, "opener in middle is found.");
+ is(s[1], 4, "closer in middle is found.");
+
+ s = "a{b{c}de}f".balance("{","}");
+ is(s[0], 1, "nested opener is found.");
+ is(s[1], 8, "nested closer is found.");
+
+ s = "{}".balance("{","}");
+ is(s[0], 0, "opener with no content is found.");
+ is(s[1], 1, "closer with no content is found.");
+
+ s = "".balance("{","}");
+ is(s[0], -1, "empty string opener is -1.");
+ is(s[1], -1, "empty string closer is -1.");
+
+ s = "{abc".balance("{","}");
+ is(s[0], -1, "opener with no closer returns -1.");
+ is(s[1], -1, "no closer returns -1.");
+
+ s = "abc".balance("{","}");
+ is(s[0], -1, "no opener or closer returns -1 for opener.");
+ is(s[1], -1, "no opener or closer returns -1 for closer.");
+
+ s = "a<bc}de".balance("<","}");
+ is(s[0], 1, "unmatching opener is found.");
+ is(s[1], 4, "unmatching closer is found.");
+*/
View
129 build/jsdoc-toolkit/app/frame/Testrun.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-2.4.0/jsdoc-toolkit/app/frame/Testrun.js $
+ * @revision $Id: Testrun.js 418 2008-01-15 21:40:33Z 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 : ""));
+ }
+}
View
26 build/jsdoc-toolkit/app/handlers/FOODOC.js
@@ -0,0 +1,26 @@
+/**
+ This is the main container for the FOODOC handler.
+ @namespace
+*/
+FOODOC = {
+};
+
+/** The current version string of this application. */
+FOODOC.VERSION = "1.0";
+
+FOODOC.handle = function(srcFile, src) {
+ LOG.inform("Handling file '" + srcFile + "'");
+
+ return [
+ new JSDOC.Symbol(
+ "foo",
+ [],
+ "VIRTUAL",
+ new JSDOC.DocComment("/** This is a foo. */")
+ )
+ ];
+};
+
+FOODOC.publish = function(symbolgroup) {
+ LOG.inform("Publishing symbolgroup.");
+};
View
26 build/jsdoc-toolkit/app/handlers/XMLDOC.js
@@ -0,0 +1,26 @@
+/**
+ * This is the main container for the XMLDOC handler.
+ * @namespace
+ * @author Brett Fattori (bfattori@fry.com)
+ * @version $Revision: 498 $
+ */
+XMLDOC = {
+
+};
+
+/** The current version string of this application. */
+XMLDOC.VERSION = "1.0";
+
+/** Include the library necessary to handle XML files */
+IO.includeDir("handlers/XMLDOC/");
+
+/**
+ * @type Symbol[]
+ */
+XMLDOC.handle = function(srcFile, src) {
+
+};
+
+XMLDOC.publish = function(symbolgroup) {
+
+}
View
159 build/jsdoc-toolkit/app/handlers/XMLDOC/DomReader.js
@@ -0,0 +1,159 @@
+LOG.inform("XMLDOC.DomReader loaded");
+
+XMLDOC.DomReader = function(root) {
+
+ this.dom = root;
+
+ /**
+ * The current node the reader is on
+ */
+ this.node = root;
+
+ /**
+ * Get the current node the reader is on
+ * @type XMLDOC.Parser.node
+ */
+ XMLDOC.DomReader.prototype.getNode = function() {
+ return this.node;
+ };
+
+ /**
+ * Set the node the reader should be positioned on.
+ * @param node {XMLDOC.Parser.node}
+ */
+ XMLDOC.DomReader.prototype.setNode = function(node) {
+ this.node = node;
+ };
+
+ /**
+ * A helper method to make sure the current node will
+ * never return null, unless null is passed as the root.
+ * @param step {String} An expression to evaluate - should return a node or null
+ */
+ XMLDOC.DomReader.prototype.navigate = function(step) {
+ var n;
+ if ((n = step) != null)
+ {
+ this.node = n;
+ return this.node;
+ }
+ return null;
+ };
+
+ /**
+ * Get the root node of the current node's document.
+ */
+ XMLDOC.DomReader.prototype.root = function() {
+ this.navigate(this.dom);
+ };
+
+ /**
+ * Get the parent of the current node.
+ */
+ XMLDOC.DomReader.prototype.parent = function() {
+ return this.navigate(this.node.parentNode());
+ };
+
+ /**
+ * Get the first child of the current node.
+ */
+ XMLDOC.DomReader.prototype.firstChild = function() {
+ return this.navigate(this.node.firstChild());
+ };
+
+ /**
+ * Get the last child of the current node.
+ */
+ XMLDOC.DomReader.prototype.lastChild = function() {
+ return this.navigate(this.node.lastChild());
+ };
+
+ /**
+ * Get the next sibling of the current node.
+ */
+ XMLDOC.DomReader.prototype.nextSibling = function() {
+ return this.navigate(this.node.nextSibling());
+ };
+
+ /**
+ * Get the previous sibling of the current node.
+ */
+ XMLDOC.DomReader.prototype.prevSibling = function() {
+ return this.navigate(this.node.prevSibling());
+ };
+
+ //===============================================================================================
+ // Support methods
+
+ /**
+ * Walk the tree starting with the current node, calling the plug-in for
+ * each node visited. Each time the plug-in is called, the DomReader
+ * is passed as the only parameter. Use the {@link XMLDOC.DomReader#getNode} method
+ * to access the current node. <i>This method uses a depth first traversal pattern.</i>
+ *
+ * @param srcFile {String} The source file being evaluated
+ */
+ XMLDOC.DomReader.prototype.getSymbols = function(srcFile)
+ {
+ XMLDOC.DomReader.symbols = [];
+ XMLDOC.DomReader.currentFile = srcFile;
+ JSDOC.Symbol.srcFile = (srcFile || "");
+
+ if (defined(JSDOC.PluginManager)) {
+ JSDOC.PluginManager.run("onDomGetSymbols", this);
+ }
+
+ return XMLDOC.DomReader.symbols;
+ };
+
+ /**
+ * Find the node with the given name using a depth first traversal.
+ * Does not modify the DomReader's current node.
+ *
+ * @param name {String} The name of the node to find
+ * @return the node that was found, or null if not found
+ */
+ XMLDOC.DomReader.prototype.findNode = function(name)
+ {
+ var findNode = null;
+
+ // Start at the current node and move into the subtree,
+ // looking for the node with the given name
+ function deeper(node, find)
+ {
+ var look = null;
+
+ if (node) {
+ if (node.name == find)
+ {
+ return node;
+ }
+
+ if (node.firstChild())
+ {
+ look = deeper(node.firstChild(), find);
+ }
+
+ if (!look && node.nextSibling())
+ {
+ look = deeper(node.nextSibling(), find);
+ }
+ }
+
+ return look;
+ }
+
+ return deeper(this.getNode().firstChild(), name);
+ };
+
+ /**
+ * Find the next node with the given name using a depth first traversal.
+ *
+ * @param name {String} The name of the node to find
+ */
+ XMLDOC.DomReader.prototype.findPreviousNode = function(name)
+ {
+ };
+
+};
+
View
16 build/jsdoc-toolkit/app/handlers/XMLDOC/XMLDoc.js
@@ -0,0 +1,16 @@
+LOG.inform("XMLDOC.symbolize loaded");
+
+/**
+ * Convert the source file to a set of symbols
+ */
+XMLDOC.symbolize = function(srcFile, src) {
+
+ LOG.inform("Symbolizing file '" + srcFile + "'");
+
+ // XML files already have a defined structure, so we don't need to
+ // do anything but parse them. The DOM reader can create a symbol
+ // table from the parsed XML.
+ var dr = new XMLDOC.DomReader(XMLDOC.Parser.parse(src));
+ return dr.getSymbols(srcFile);
+
+};
View
292 build/jsdoc-toolkit/app/handlers/XMLDOC/XMLParse.js
@@ -0,0 +1,292 @@
+LOG.inform("XMLDOC.Parser loaded");
+
+/**
+ * XML Parser object. Returns an {@link #XMLDOC.Parser.node} which is
+ * the root element of the parsed document.
+ * <p/>
+ * By default, this parser will only handle well formed XML. To
+ * allow the parser to handle HTML, set the <tt>XMLDOC.Parser.strictMode</tt>
+ * variable to <tt>false</tt> before calling <tt>XMLDOC.Parser.parse()</tt>.
+ * <p/>
+ * <i>Note: If you pass poorly formed XML, it will cause the parser to throw
+ * an exception.</i>
+ *
+ * @author Brett Fattori (bfattori@fry.com)
+ * @author $Author: micmath $
+ * @version $Revision: 497 $
+ */
+XMLDOC.Parser = {};
+
+/**
+ * Strict mode setting. Setting this to false allows HTML-style source to
+ * be parsed. Normally, well formed XML has defined end tags, or empty tags
+ * are properly formed. Default: <tt>true</tt>
+ * @type Boolean
+ */
+XMLDOC.Parser.strictMode = true;
+
+/**
+ * A node in an XML Document. Node types are ROOT, ELEMENT, COMMENT, PI, and TEXT.
+ * @param parent {XMLDOC.Parser.node} The parent node
+ * @param name {String} The node name
+ * @param type {String} One of the types
+ */
+XMLDOC.Parser.node = function(parent, name, type)
+{
+ this.name = name;
+ this.type = type || "ELEMENT";
+ this.parent = parent;
+ this.charData = "";
+ this.attrs = {};
+ this.nodes = [];
+ this.cPtr = 0;
+
+ XMLDOC.Parser.node.prototype.getAttributeNames = function() {
+ var a = [];
+ for (var o in this.attrs)
+ {
+ a.push(o);
+ }
+
+ return a;
+ };
+
+ XMLDOC.Parser.node.prototype.getAttribute = function(attr) {
+ return this.attrs[attr];
+ };
+
+ XMLDOC.Parser.node.prototype.setAttribute = function(attr, val) {
+ this.attrs[attr] = val;
+ };
+
+ XMLDOC.Parser.node.prototype.getChild = function(idx) {
+ return this.nodes[idx];
+ };
+
+ XMLDOC.Parser.node.prototype.parentNode = function() {
+ return this.parent;
+ };
+
+ XMLDOC.Parser.node.prototype.firstChild = function() {
+ return this.nodes[0];
+ };
+
+ XMLDOC.Parser.node.prototype.lastChild = function() {
+ return this.nodes[this.nodes.length - 1];
+ };
+
+ XMLDOC.Parser.node.prototype.nextSibling = function() {
+ var p = this.parent;
+ if (p && (p.nodes.indexOf(this) + 1 != p.nodes.length))
+ {
+ return p.getChild(p.nodes.indexOf(this) + 1);
+ }
+ return null;
+ };
+
+ XMLDOC.Parser.node.prototype.prevSibling = function() {
+ var p = this.parent;
+ if (p && (p.nodes.indexOf(this) - 1 >= 0))
+ {
+ return p.getChild(p.nodes.indexOf(this) - 1);
+ }
+ return null;
+ };
+};
+
+/**
+ * Parse an XML Document from the specified source. The XML should be
+ * well formed, unless strict mode is disabled, then the parser will
+ * handle HTML-style XML documents.
+ * @param src {String} The source to parse
+ */
+XMLDOC.Parser.parse = function(src)
+{
+ var A = [];
+
+ // Normailize whitespace
+ A = src.split("\r\n");
+ src = A.join("\n");
+ A = src.split("\r");
+ src = A.join("\n");
+
+ // Remove XML and DOCTYPE specifier
+ src.replace(/<\?XML .*\?>/i, "");
+ src.replace(/<!DOCTYPE .*\>/i, "");
+
+ // The document is the root node and cannot be modified or removed
+ var doc = new XMLDOC.Parser.node(null, "ROOT", "DOCUMENT");
+
+ // Let's break it down
+ XMLDOC.Parser.eat(doc, src);
+
+ return doc;
+};
+
+/**
+ * The XML fragment processing routine. This method is private and should not be called
+ * directly.
+ * @param parentNode {XMLDOC.Parser.node} The node which is the parent of this fragment
+ * @param src {String} The source within the fragment to process
+ * @private
+ */
+XMLDOC.Parser.eat = function(parentNode, src)
+{
+ // A simple tag def
+ var reTag = new RegExp("<(!|)(\\?|--|)((.|\\s)*?)\\2>","g");
+
+ // Special tag types
+ var reCommentTag = /<!--((.|\s)*?)-->/;
+ var rePITag = /<\?((.|\s)*?)\?>/;
+
+ // A start tag (with potential empty marker)
+ var reStartTag = /<(.*?)( +([\w_\-]*)=(\"|')(.*)\4)*(\/)?>/;
+
+ // An empty HTML style tag (not proper XML, but we'll accept it so we can process HTML)
+ var reHTMLEmptyTag = /<(.*?)( +([\w_\-]*)=(\"|')(.*)\4)*>/;
+
+ // Fully enclosing tag with nested tags
+ var reEnclosingTag = /<(.*?)( +([\w_\-]*)=(\"|')(.*?)\4)*>((.|\s)*?)<\/\1>/;
+
+ // Breaks down attributes
+ var reAttributes = new RegExp(" +([\\w_\\-]*)=(\"|')(.*?)\\2","g");
+
+ // Find us a tag
+ var tag;
+ while ((tag = reTag.exec(src)) != null)
+ {
+ if (tag.index > 0)
+ {
+ // The next tag has some text before it
+ var text = src.substring(0, tag.index).replace(/^[ \t\n]+((.|\n)*?)[ \t\n]+$/, "$1");
+
+ if (text.length > 0 && (text != "\n"))
+ {
+ var txtnode = new XMLDOC.Parser.node(parentNode, "", "TEXT");
+ txtnode.charData = text;
+
+ // Append the new text node
+ parentNode.nodes.push(txtnode);
+ }
+
+ // Reset the lastIndex of reTag
+ reTag.lastIndex -= src.substring(0, tag.index).length;
+
+ // Eat the text
+ src = src.substring(tag.index);
+ }
+
+ if (reCommentTag.test(tag[0]))
+ {
+ // Is this a comment?
+ var comment = new XMLDOC.Parser.node(parentNode, "", "COMMENT");
+ comment.charData = reCommentTag.exec(tag[0])[1];
+
+ // Append the comment
+ parentNode.nodes.push(comment);
+
+ // Move the lastIndex of reTag
+ reTag.lastIndex -= tag[0].length;
+
+ // Eat the tag
+ src = src.replace(reCommentTag, "");
+ }
+ else if (rePITag.test(tag[0]))
+ {
+ // Is this a processing instruction?
+ var pi = new XMLDOC.Parser.node(parentNode, "", "PI");
+ pi.charData = rePITag.exec(tag[0])[1];
+
+ // Append the processing instruction
+ parentNode.nodes.push(pi);
+
+ // Move the lastIndex of reTag
+ reTag.lastIndex -= tag[0].length;
+
+ // Eat the tag
+ src = src.replace(rePITag, "");
+ }
+ else if (reStartTag.test(tag[0]))
+ {
+ // Break it down
+ var e = reStartTag.exec(tag[0]);
+ var elem = new XMLDOC.Parser.node(parentNode, e[1], "ELEMENT");
+
+ // Get attributes from the tag
+ var a;
+ while ((a = reAttributes.exec(e[2])) != null )
+ {
+ elem.attrs[a[1]] = a[3];
+ }
+
+ // Is this an empty XML-style tag?
+ if (e[6] == "/")
+ {
+ // Append the empty element
+ parentNode.nodes.push(elem);
+
+ // Move the lastIndex of reTag (include the start tag length)
+ reTag.lastIndex -= e[0].length;
+
+ // Eat the tag
+ src = src.replace(reStartTag, "");
+ }
+ else
+ {
+ // Check for malformed XML tags
+ var htmlParsed = false;
+ var htmlStartTag = reHTMLEmptyTag.exec(src);
+
+ // See if there isn't an end tag within this block
+ var reHTMLEndTag = new RegExp("</" + htmlStartTag[1] + ">");
+ var htmlEndTag = reHTMLEndTag.exec(src);
+
+ if (XMLDOC.Parser.strictMode && htmlEndTag == null)
+ {
+ // Poorly formed XML fails in strict mode
+ var err = new Error("Malformed XML passed to XMLDOC.Parser... Error contains malformed 'src'");
+ err.src = src;
+ throw err;
+ }
+ else if (htmlEndTag == null)
+ {
+ // This is an HTML-style empty tag, store the element for it in non-strict mode
+ parentNode.nodes.push(elem);
+
+ // Eat the tag
+ src = src.replace(reHTMLEmptyTag, "");
+ htmlParsed = true;
+ }
+
+ // If we didn't parse HTML-style, it must be an enclosing tag
+ if (!htmlParsed)
+ {
+ var enc = reEnclosingTag.exec(src);
+
+ // Go deeper into the document
+ XMLDOC.Parser.eat(elem, enc[6]);
+
+ // Append the new element node
+ parentNode.nodes.push(elem);
+
+ // Eat the tag
+ src = src.replace(reEnclosingTag, "");
+ }
+ }
+
+ // Reset the lastIndex of reTag
+ reTag.lastIndex = 0;
+ }
+ }
+
+ // No tag was found... append the text if there is any
+ src = src.replace(/^[ \t\n]+((.|\n)*?)[ \t\n]+$/, "$1");
+ if (src.length > 0 && (src != "\n"))
+ {
+ var txtNode = new XMLDOC.Parser.node(parentNode, "", "TEXT");
+ txtNode.charData = src;
+
+ // Append the new text node
+ parentNode.nodes.push(txtNode);
+ }
+};
View
106 build/jsdoc-toolkit/app/lib/JSDOC.js
@@ -0,0 +1,106 @@
+/**
+ @overview
+ @date $Date: 2010-06-13 22:02:44 +0100 (Sun, 13 Jun 2010) $
+ @version $Revision: 837 $
+ @location $HeadURL: https://jsdoc-toolkit.googlecode.com/svn/tags/jsdoc_toolkit-2.4.0/jsdoc-toolkit/app/lib/JSDOC.js $
+ @name JSDOC.js
+ */
+
+/**
+ This is the main container for the JSDOC application.
+ @namespace
+*/
+JSDOC = {
+};
+
+/**
+ @requires Opt
+ */
+if (typeof arguments == "undefined") arguments = [];
+JSDOC.opt = Opt.get(
+ arguments,
+ {
+ a: "allfunctions",
+ c: "conf",
+ d: "directory",
+ "D[]": "define",
+ e: "encoding",
+ "E[]": "exclude",
+ h: "help",
+ m: "multiple",
+ n: "nocode",
+ o: "out",
+ p: "private",
+ q: "quiet",
+ r: "recurse",
+ S: "securemodules",
+ s: "suppress",
+ t: "template",
+ T: "testmode",
+ u: "unique",
+ v: "verbose",
+ x: "ext"
+ }
+);
+
+/** The current version string of this application. */
+JSDOC.VERSION = "2.4.0";
+
+/** Print out usage information and quit. */
+JSDOC.usage = function() {
+ print("USAGE: java -jar jsrun.jar app/run.js [OPTIONS] <SRC_DIR> <SRC_FILE> ...");
+ print("");
+ print("OPTIONS:");
+ print(" -a or --allfunctions\n Include all functions, even undocumented ones.\n");
+ print(" -c or --conf\n Load a configuration file.\n");
+ print(" -d=<PATH> or --directory=<PATH>\n Output to this directory (defaults to \"out\").\n");
+ print(" -D=\"myVar:My value\" or --define=\"myVar:My value\"\n Multiple. Define a variable, available in JsDoc as JSDOC.opt.D.myVar.\n");
+ print(" -e=<ENCODING> or --encoding=<ENCODING>\n Use this encoding to read and write files.\n");
+ print(" -E=\"REGEX\" or --exclude=\"REGEX\"\n Multiple. Exclude files based on the supplied regex.\n");
+ print(" -h or --help\n Show this message and exit.\n");
+ print(" -m or --multiples\n Don't warn about symbols being documented more than once.\n");
+ print(" -n or --nocode\n Ignore all code, only document comments with @name tags.\n");
+ print(" -o=<PATH> or --out=<PATH>\n Print log messages to a file (defaults to stdout).\n");
+ print(" -p or --private\n Include symbols tagged as private, underscored and inner symbols.\n");
+ print(" -q or --quiet\n Do not output any messages, not even warnings.\n");
+ print(" -r=<DEPTH> or --recurse=<DEPTH>\n Descend into src directories.\n");
+ print(" -s or --suppress\n Suppress source code output.\n");
+ print(" -S or --securemodules\n Use Secure Modules mode to parse source code.\n");
+ print(" -t=<PATH> or --template=<PATH>\n Required. Use this template to format the output.\n");
+ print(" -T or --test\n Run all unit tests and exit.\n");
+ print(" -u or --unique\n Force file names to be unique, but not based on symbol names.\n");
+ print(" -v or --verbose\n Provide verbose feedback about what is happening.\n");
+ print(" -x=<EXT>[,EXT]... or --ext=<EXT>[,EXT]...\n Scan source files with the given extension/s (defaults to js).\n");
+
+ quit();
+}
+
+/*t:
+ plan(4, "Testing JSDOC namespace.");
+
+ is(
+ typeof JSDOC,
+ "object",
+ "JSDOC.usage is a function."
+ );
+
+ is(
+ typeof JSDOC.VERSION,
+ "string",
+ "JSDOC.VERSION is a string."
+ );
+
+ is(
+ typeof JSDOC.usage,
+ "function",
+ "JSDOC.usage is a function."
+ );
+
+ is(
+ typeof JSDOC.opt,
+ "object",
+ "JSDOC.opt is a object."
+ );
+ */
+
+if (this.IO) IO.includeDir("lib/JSDOC/");
View
204 build/jsdoc-toolkit/app/lib/JSDOC/DocComment.js
@@ -0,0 +1,204 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+ Create a new DocComment. This takes a raw documentation comment,
+ and wraps it in useful accessors.
+ @class Represents a documentation comment object.
+ */
+JSDOC.DocComment = function(/**String*/comment) {
+ this.init();
+ if (typeof comment != "undefined") {
+ this.parse(comment);
+ }
+}
+
+JSDOC.DocComment.prototype.init = function() {
+ this.isUserComment = true;
+ this.src = "";
+ this.meta = "";
+ this.tagTexts = [];
+ this.tags = [];
+}
+
+/**
+ @requires JSDOC.DocTag
+ */
+JSDOC.DocComment.prototype.parse = function(/**String*/comment) {
+ if (comment == "") {
+ comment = "/** @desc */";
+ this.isUserComment = false;
+ }
+
+ this.src = JSDOC.DocComment.unwrapComment(comment);
+
+ this.meta = "";
+ if (this.src.indexOf("#") == 0) {
+ this.src.match(/#(.+[+-])([\s\S]*)$/);
+ if (RegExp.$1) this.meta = RegExp.$1;
+ if (RegExp.$2) this.src = RegExp.$2;
+ }
+
+ if (typeof JSDOC.PluginManager != "undefined") {
+ JSDOC.PluginManager.run("onDocCommentSrc", this);
+ }
+
+ this.fixDesc();
+
+ this.src = JSDOC.DocComment.shared+"\n"+this.src;
+
+ this.tagTexts =
+ this.src
+ .split(/(^|[\r\n])\s*@/)
+ .filter(function($){return $.match(/\S/)});
+
+ /**
+ The tags found in the comment.
+ @type JSDOC.DocTag[]
+ */
+ this.tags = this.tagTexts.map(function($){return new JSDOC.DocTag($)});
+
+ if (typeof JSDOC.PluginManager != "undefined") {
+ JSDOC.PluginManager.run("onDocCommentTags", this);
+ }
+}
+
+/*t:
+ plan(5, "testing JSDOC.DocComment");
+ requires("../frame/String.js");
+ requires("../lib/JSDOC/DocTag.js");
+
+ var com = new JSDOC.DocComment("/**@foo some\n* comment here*"+"/");
+ is(com.tagTexts[0], "foo some\ncomment here", "first tag text is found.");
+ is(com.tags[0].title, "foo", "the title is found in a comment with one tag.");
+
+ var com = new JSDOC.DocComment("/** @foo first\n* @bar second*"+"/");
+ is(com.getTag("bar").length, 1, "getTag() returns one tag by that title.");
+
+ JSDOC.DocComment.shared = "@author John Smith";
+ var com = new JSDOC.DocComment("/**@foo some\n* comment here*"+"/");
+ is(com.tags[0].title, "author", "shared comment is added.");
+ is(com.tags[1].title, "foo", "shared comment is added to existing tag.");
+*/
+
+/**
+ If no @desc tag is provided, this function will add it.
+ */
+JSDOC.DocComment.prototype.fixDesc = function() {
+ if (this.meta && this.meta != "@+") return;
+ if (/^\s*[^@\s]/.test(this.src)) {
+ this.src = "@desc "+this.src;
+ }
+}
+
+/*t:
+ plan(5, "testing JSDOC.DocComment#fixDesc");
+
+ var com = new JSDOC.DocComment();
+
+ com.src = "this is a desc\n@author foo";
+ com.fixDesc();
+ is(com.src, "@desc this is a desc\n@author foo", "if no @desc tag is provided one is added.");
+
+ com.src = "x";
+ com.fixDesc();
+ is(com.src, "@desc x", "if no @desc tag is provided one is added to a single character.");
+
+ com.src = "\nx";
+ com.fixDesc();
+ is(com.src, "@desc \nx", "if no @desc tag is provided one is added to return and character.");
+
+ com.src = " ";
+ com.fixDesc();
+ is(com.src, " ", "if no @desc tag is provided one is not added to just whitespace.");
+
+ com.src = "";
+ com.fixDesc();
+ is(com.src, "", "if no @desc tag is provided one is not added to empty.");
+*/
+
+/**
+ Remove slash-star comment wrapper from a raw comment string.
+ @type String
+ */
+JSDOC.DocComment.unwrapComment = function(/**String*/comment) {
+ if (!comment) return "";
+ var unwrapped = comment.replace(/(^\/\*\*|\*\/$)/g, "").replace(/^\s*\* ?/gm, "");
+ return unwrapped;
+}
+
+/*t:
+ plan(5, "testing JSDOC.DocComment.unwrapComment");
+
+ var com = "/**x*"+"/";
+ var unwrapped = JSDOC.DocComment.unwrapComment(com);
+ is(unwrapped, "x", "a single character jsdoc is found.");
+
+ com = "/***x*"+"/";
+ unwrapped = JSDOC.DocComment.unwrapComment(com);
+ is(unwrapped, "x", "three stars are allowed in the opener.");
+
+ com = "/****x*"+"/";
+ unwrapped = JSDOC.DocComment.unwrapComment(com);
+ is(unwrapped, "*x", "fourth star in the opener is kept.");
+
+ com = "/**x\n * y\n*"+"/";
+ unwrapped = JSDOC.DocComment.unwrapComment(com);
+ is(unwrapped, "x\ny\n", "leading stars and spaces are trimmed.");
+
+ com = "/**x\n * y\n*"+"/";
+ unwrapped = JSDOC.DocComment.unwrapComment(com);
+ is(unwrapped, "x\n y\n", "only first space after leading stars are trimmed.");
+*/
+
+/**
+ Provides a printable version of the comment.
+ @type String
+ */
+JSDOC.DocComment.prototype.toString = function() {
+ return this.src;
+}
+
+/*t:
+ plan(1, "testing JSDOC.DocComment#fixDesc");
+ var com = new JSDOC.DocComment();
+ com.src = "foo";
+ is(""+com, "foo", "stringifying a comment returns the unwrapped src.");
+*/
+
+/**
+ Given the title of a tag, returns all tags that have that title.
+ @type JSDOC.DocTag[]
+ */
+JSDOC.DocComment.prototype.getTag = function(/**String*/tagTitle) {
+ return this.tags.filter(function($){return $.title == tagTitle});
+}
+
+JSDOC.DocComment.prototype.deleteTag = function(/**String*/tagTitle) {
+ this.tags = this.tags.filter(function($){return $.title != tagTitle})
+}
+
+/*t:
+ plan(1, "testing JSDOC.DocComment#getTag");
+ requires("../frame/String.js");
+ requires("../lib/JSDOC/DocTag.js");
+
+ var com = new JSDOC.DocComment("/**@foo some\n* @bar\n* @bar*"+"/");
+ is(com.getTag("bar").length, 2, "getTag returns expected number of tags.");
+*/
+
+/**
+ Used to store the currently shared tag text.
+*/
+JSDOC.DocComment.shared = "";
+
+/*t:
+ plan(2, "testing JSDOC.DocComment.shared");
+ requires("../frame/String.js");
+ requires("../lib/JSDOC/DocTag.js");
+
+ JSDOC.DocComment.shared = "@author Michael";
+
+ var com = new JSDOC.DocComment("/**@foo\n* @foo*"+"/");
+ is(com.getTag("author").length, 1, "getTag returns shared tag.");
+ is(com.getTag("foo").length, 2, "getTag returns unshared tags too.");
+*/
View
294 build/jsdoc-toolkit/app/lib/JSDOC/DocTag.js
@@ -0,0 +1,294 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+ @constructor
+ */
+JSDOC.DocTag = function(src) {
+ this.init();
+ if (typeof src != "undefined") {
+ this.parse(src);
+ }
+}
+
+/**
+ Create and initialize the properties of this.
+ */
+JSDOC.DocTag.prototype.init = function() {
+ this.title = "";
+ this.type = "";
+ this.name = "";
+ this.isOptional = false;
+ this.defaultValue = "";
+ this.desc = "";
+
+ return this;
+}
+
+/**
+ Populate the properties of this from the given tag src.
+ @param {string} src
+ */
+JSDOC.DocTag.prototype.parse = function(src) {
+ if (typeof src != "string") throw "src must be a string not "+(typeof src);
+
+ try {
+ src = this.nibbleTitle(src);
+ if (JSDOC.PluginManager) {
+ JSDOC.PluginManager.run("onDocTagSynonym", this);
+ }
+
+ src = this.nibbleType(src);
+
+ // only some tags are allowed to have names.
+ if (this.title == "param" || this.title == "property" || this.title == "config") { // @config is deprecated
+ src = this.nibbleName(src);
+ }
+ }
+ catch(e) {
+ if (LOG) LOG.warn(e);
+ else throw e;
+ }
+ this.desc = src; // whatever is left
+
+ // example tags need to have whitespace preserved
+ if (this.title != "example") this.desc = this.desc.trim();
+
+ if (JSDOC.PluginManager) {
+ JSDOC.PluginManager.run("onDocTag", this);
+ }
+}
+
+/**
+ Automatically called when this is stringified.
+ */
+JSDOC.DocTag.prototype.toString = function() {
+ return this.desc;
+}
+
+/*t:
+ plan(1, "testing JSDOC.DocTag#toString");
+
+ var tag = new JSDOC.DocTag("param {object} date A valid date.");
+ is(""+tag, "A valid date.", "stringifying a tag returns the desc.");
+ */
+
+/**
+ Find and shift off the title of a tag.
+ @param {string} src
+ @return src
+ */
+JSDOC.DocTag.prototype.nibbleTitle = function(src) {
+ if (typeof src != "string") throw "src must be a string not "+(typeof src);
+
+ var parts = src.match(/^\s*(\S+)(?:\s([\s\S]*))?$/);
+
+ if (parts && parts[1]) this.title = parts[1];
+ if (parts && parts[2]) src = parts[2];
+ else src = "";
+
+ return src;
+}
+
+/*t:
+ plan(8, "testing JSDOC.DocTag#nibbleTitle");
+
+ var tag = new JSDOC.DocTag();
+
+ tag.init().nibbleTitle("aTitleGoesHere");
+ is(tag.title, "aTitleGoesHere", "a title can be found in a single-word string.");
+
+ var src = tag.init().nibbleTitle("aTitleGoesHere and the rest");
+ is(tag.title, "aTitleGoesHere", "a title can be found in a multi-word string.");
+ is(src, "and the rest", "the rest is returned when the title is nibbled off.");
+
+ src = tag.init().nibbleTitle("");
+ is(tag.title, "", "given an empty string the title is empty.");
+ is(src, "", "the rest is empty when the tag is empty.");
+
+ var src = tag.init().nibbleTitle(" aTitleGoesHere\n a description");
+ is(tag.title, "aTitleGoesHere", "leading and trailing spaces are not part of the title.");
+ is(src, " a description", "leading spaces (less one) are part of the description.");
+
+ tag.init().nibbleTitle("a.Title::Goes_Here foo");
+ is(tag.title, "a.Title::Goes_Here", "titles with punctuation are allowed.");
+ */
+
+/**
+ Find and shift off the type of a tag.
+ @requires frame/String.js
+ @param {string} src
+ @return src
+ */
+JSDOC.DocTag.prototype.nibbleType = function(src) {
+ if (typeof src != "string") throw "src must be a string not "+(typeof src);
+
+ if (src.match(/^\s*\{/)) {
+ var typeRange = src.balance("{", "}");
+ if (typeRange[1] == -1) {
+ throw "Malformed comment tag ignored. Tag type requires an opening { and a closing }: "+src;
+ }
+ this.type = src.substring(typeRange[0]+1, typeRange[1]).trim();
+ this.type = this.type.replace(/\s*,\s*/g, "|"); // multiples can be separated by , or |
+ src = src.substring(typeRange[1]+1);
+ }
+
+ return src;
+}
+
+/*t:
+ plan(5, "testing JSDOC.DocTag.parser.nibbleType");
+ requires("../frame/String.js");
+
+ var tag = new JSDOC.DocTag();
+
+ tag.init().nibbleType("{String[]} aliases");
+ is(tag.type, "String[]", "type can have non-alpha characters.");
+
+ tag.init().nibbleType("{ aTypeGoesHere } etc etc");
+ is(tag.type, "aTypeGoesHere", "type is trimmed.");
+
+ tag.init().nibbleType("{ oneType, twoType ,\n threeType } etc etc");
+ is(tag.type, "oneType|twoType|threeType", "multiple types can be separated by commas.");
+
+ var error;
+ try { tag.init().nibbleType("{widget foo"); }
+ catch(e) { error = e; }
+ is(typeof error, "string", "malformed tag type throws error.");
+ isnt(error.indexOf("Malformed"), -1, "error message tells tag is malformed.");
+ */
+
+/**
+ Find and shift off the name of a tag.
+ @requires frame/String.js
+ @param {string} src
+ @return src
+ */
+JSDOC.DocTag.prototype.nibbleName = function(src) {
+ if (typeof src != "string") throw "src must be a string not "+(typeof src);
+
+ src = src.trim();
+
+ // is optional?
+ if (src.charAt(0) == "[") {
+ var nameRange = src.balance("[", "]");
+ if (nameRange[1] == -1) {
+ throw "Malformed comment tag ignored. Tag optional name requires an opening [ and a closing ]: "+src;
+ }
+ this.name = src.substring(nameRange[0]+1, nameRange[1]).trim();
+ this.isOptional = true;
+
+ src = src.substring(nameRange[1]+1);
+
+ // has default value?
+ var nameAndValue = this.name.split("=");
+ if (nameAndValue.length) {
+ this.name = nameAndValue.shift().trim();
+ this.defaultValue = nameAndValue.join("=");
+ }
+ }
+ else {
+ var parts = src.match(/^(\S+)(?:\s([\s\S]*))?$/);
+ if (parts) {
+ if (parts[1]) this.name = parts[1];
+ if (parts[2]) src = parts[2].trim();
+ else src = "";
+ }
+ }
+
+ return src;
+}
+
+/*t:
+ requires("../frame/String.js");
+ plan(9, "testing JSDOC.DocTag.parser.nibbleName");
+
+ var tag = new JSDOC.DocTag();
+
+ tag.init().nibbleName("[foo] This is a description.");
+ is(tag.isOptional, true, "isOptional syntax is detected.");
+ is(tag.name, "foo", "optional param name is found.");
+
+ tag.init().nibbleName("[foo] This is a description.");
+ is(tag.isOptional, true, "isOptional syntax is detected when no type.");
+ is(tag.name, "foo", "optional param name is found when no type.");
+
+ tag.init().nibbleName("[foo=7] This is a description.");
+ is(tag.name, "foo", "optional param name is found when default value.");
+ is(tag.defaultValue, 7, "optional param default value is found when default value.");
+
+ //tag.init().nibbleName("[foo= a value] This is a description.");
+ //is(tag.defaultValue, " a value", "optional param default value is found when default value has spaces (issue #112).");
+
+ tag.init().nibbleName("[foo=[]] This is a description.");
+ is(tag.defaultValue, "[]", "optional param default value is found when default value is [] (issue #95).");
+
+ tag.init().nibbleName("[foo=a=b] This is a description.");
+ is(tag.name, "foo", "optional param name is found when default value is a=b.");
+ is(tag.defaultValue, "a=b", "optional param default value is found when default value is a=b.")
+ */
+
+/*t:
+ plan(32, "Testing JSDOC.DocTag.parser.");
+ requires("../frame/String.js");
+
+ var tag = new JSDOC.DocTag();
+
+ is(typeof tag, "object", "JSDOC.DocTag.parser with an empty string returns an object.");
+ is(typeof tag.title, "string", "returned object has a string property 'title'.");
+ is(typeof tag.type, "string", "returned object has a string property 'type'.");
+ is(typeof tag.name, "string", "returned object has a string property 'name'.");
+ is(typeof tag.defaultValue, "string", "returned object has a string property 'defaultValue'.");
+ is(typeof tag.isOptional, "boolean", "returned object has a boolean property 'isOptional'.");
+ is(typeof tag.desc, "string", "returned object has a string property 'desc'.");
+
+ tag = new JSDOC.DocTag("param {widget} foo");
+ is(tag.title, "param", "param title is found.");
+ is(tag.name, "foo", "param name is found when desc is missing.");
+ is(tag.desc, "", "param desc is empty when missing.");
+
+ tag = new JSDOC.DocTag("param {object} date A valid date.");
+ is(tag.name, "date", "param name is found with a type.");
+ is(tag.type, "object", "param type is found.");
+ is(tag.desc, "A valid date.", "param desc is found with a type.");
+
+ tag = new JSDOC.DocTag("param aName a description goes\n here.");
+ is(tag.name, "aName", "param name is found without a type.");
+ is(tag.desc, "a description goes\n here.", "param desc is found without a type.");
+
+ tag = new JSDOC.DocTag("param {widget}");
+ is(tag.name, "", "param name is empty when it is not given.");
+
+ tag = new JSDOC.DocTag("param {widget} [foo] This is a description.");
+ is(tag.name, "foo", "optional param name is found.");
+
+ tag = new JSDOC.DocTag("return {aType} This is a description.");
+ is(tag.type, "aType", "when return tag has no name, type is found.");
+ is(tag.desc, "This is a description.", "when return tag has no name, desc is found.");
+
+ tag = new JSDOC.DocTag("author Joe Coder <jcoder@example.com>");
+ is(tag.title, "author", "author tag has a title.");
+ is(tag.type, "", "the author tag has no type.");
+ is(tag.name, "", "the author tag has no name.");
+ is(tag.desc, "Joe Coder <jcoder@example.com>", "author tag has desc.");
+
+ tag = new JSDOC.DocTag("private \t\n ");
+ is(tag.title, "private", "private tag has a title.");
+ is(tag.type, "", "the private tag has no type.");
+ is(tag.name, "", "the private tag has no name.");
+ is(tag.desc, "", "private tag has no desc.");
+
+ tag = new JSDOC.DocTag("example\n example(code);\n more();");
+ is(tag.desc, " example(code);\n more();", "leading whitespace (less one) in examples code is preserved.");
+
+ tag = new JSDOC.DocTag("param theName \n");
+ is(tag.name, "theName", "name only is found.");
+
+ tag = new JSDOC.DocTag("type theDesc \n");
+ is(tag.desc, "theDesc", "desc only is found.");
+
+ tag = new JSDOC.DocTag("type {theType} \n");
+ is(tag.type, "theType", "type only is found.");
+
+ tag = new JSDOC.DocTag("");
+ is(tag.title, "", "title is empty when tag is empty.");
+ */
View
140 build/jsdoc-toolkit/app/lib/JSDOC/JsDoc.js
@@ -0,0 +1,140 @@
+/**
+ @constructor
+ @param [opt] Used to override the commandline options. Useful for testing.
+ @version $Id: JsDoc.js 831 2010-03-09 14:24:56Z micmath $
+*/
+JSDOC.JsDoc = function(/**object*/ opt) {
+ if (opt) {
+ JSDOC.opt = opt;
+ }
+
+ if (JSDOC.opt.h) {
+ JSDOC.usage();
+ quit();
+ }
+
+ // defend against options that are not sane
+ if (JSDOC.opt._.length == 0) {
+ LOG.warn("No source files to work on. Nothing to do.");
+ quit();
+ }
+ if (JSDOC.opt.t === true || JSDOC.opt.d === true) {
+ JSDOC.usage();
+ }
+
+ if (typeof JSDOC.opt.d == "string") {
+ if (!JSDOC.opt.d.charAt(JSDOC.opt.d.length-1).match(/[\\\/]/)) {
+ JSDOC.opt.d = JSDOC.opt.d+"/";
+ }
+ LOG.inform("Output directory set to '"+JSDOC.opt.d+"'.");
+ IO.mkPath(JSDOC.opt.d);
+ }
+ if (JSDOC.opt.e) IO.setEncoding(JSDOC.opt.e);
+
+ // the -r option: scan source directories recursively
+ 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;
+
+ // the -D option: define user variables
+ var D = {};
+ if (JSDOC.opt.D) {
+ for (var i = 0; i < JSDOC.opt.D.length; i++) {
+ var param = JSDOC.opt.D[i];
+ // remove first and last character if both == "
+ if (
+ param.length > 1
+ && param.charAt(0) == '"'
+ && param.charAt(param.length-1) == '"'
+ ) {
+ param = param.substr(1, param.length-2);
+ }
+ var defineParts = param.split(":");
+ if (defineParts && defineParts.length > 1) {
+ for ( var dpIdx = 2; dpIdx < defineParts.length; dpIdx++ ) {
+ defineParts[1] += ':' + defineParts[dpIdx];
+ }
+ D[defineParts[0]] = defineParts[1];
+ }
+ }
+ }
+ JSDOC.opt.D = D;
+ // combine any conf file D options with the commandline D options
+ if (defined(JSDOC.conf)) for (var c in JSDOC.conf.D) {
+ if (!defined(JSDOC.opt.D[c])) {
+ JSDOC.opt.D[c] = JSDOC.conf.D[c];
+ }
+ }
+
+ // Give plugins a chance to initialize
+ if (defined(JSDOC.PluginManager)) {
+ JSDOC.PluginManager.run("onInit", JSDOC.opt);
+ }
+
+ JSDOC.opt.srcFiles = JSDOC.JsDoc._getSrcFiles();
+ JSDOC.JsDoc._parseSrcFiles();
+ JSDOC.JsDoc.symbolSet = JSDOC.Parser.symbols;
+}
+
+/**
+ Retrieve source file list.
+ @returns {String[]} The pathnames of the files to be parsed.
+ */