sproutcore 0.9.13 → 0.9.14

data/jsdoc/app/lib/JSDOC/TokenStream.js

@@ -0,0 +1,133 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+  @constructor
+*/
+JSDOC.TokenStream = function(tokens) {
+  this.tokens = (tokens || []);
+  this.rewind();
+}
+
+/**
+  @constructor
+  @private
+*/
+function VoidToken(/**String*/type) {
+  this.toString = function() {return "<VOID type=\""+type+"\">"};
+  this.is = function(){return false;}
+}
+
+JSDOC.TokenStream.prototype.rewind = function() {
+  this.cursor = -1;
+}
+
+/**
+  @type JSDOC.Token
+*/
+JSDOC.TokenStream.prototype.look = function(/**Number*/n, /**Boolean*/considerWhitespace) {
+  if (typeof n == "undefined") n = 0;
+
+  if (considerWhitespace == true) {
+    if (this.cursor+n < 0 || this.cursor+n > this.tokens.length) return {};
+    return this.tokens[this.cursor+n];
+  }
+  else {
+    var count = 0;
+    var i = this.cursor;
+
+    while (true) {
+      if (i < 0) return new JSDOC.Token("", "VOID", "START_OF_STREAM");
+      else if (i > this.tokens.length) return new JSDOC.Token("", "VOID", "END_OF_STREAM");
+
+      if (i != this.cursor && (this.tokens[i] === undefined || this.tokens[i].is("SPACE") || this.tokens[i].is("NEWLINE"))) {
+        if (n < 0) i--; else i++;
+        continue;
+      }
+      
+      if (count == Math.abs(n)) {
+        return this.tokens[i];
+      }
+      count++;
+      (n < 0)? i-- : i++;
+    }
+
+    return new JSDOC.Token("", "VOID", "STREAM_ERROR"); // because null isn't an object and caller always expects an object
+  }
+}
+
+/**
+  @type JSDOC.Token|JSDOC.Token[]
+*/
+JSDOC.TokenStream.prototype.next = function(/**Number*/howMany) {
+  if (typeof howMany == "undefined") howMany = 1;
+  if (howMany < 1) return null;
+  var got = [];
+
+  for (var i = 1; i <= howMany; i++) {
+    if (this.cursor+i >= this.tokens.length) {
+      return null;
+    }
+    got.push(this.tokens[this.cursor+i]);
+  }
+  this.cursor += howMany;
+
+  if (howMany == 1) {
+    return got[0];
+  }
+  else return got;
+}
+
+/**
+  @type JSDOC.Token[]
+*/
+JSDOC.TokenStream.prototype.balance = function(/**String*/start, /**String*/stop) {
+  if (!stop) stop = JSDOC.Lang.matching(start);
+  
+  var depth = 0;
+  var got = [];
+  var started = false;
+  
+  while ((token = this.look())) {
+    if (token.is(start)) {
+      depth++;
+      started = true;
+    }
+    
+    if (started) {
+      got.push(token);
+    }
+    
+    if (token.is(stop)) {
+      depth--;
+      if (depth == 0) return got;
+    }
+    if (!this.next()) break;
+  }
+}
+
+JSDOC.TokenStream.prototype.getMatchingToken = function(/**String*/start, /**String*/stop) {
+  var depth = 0;
+  var cursor = this.cursor;
+  
+  if (!start) {
+    start = JSDOC.Lang.matching(stop);
+    depth = 1;
+  }
+  if (!stop) stop = JSDOC.Lang.matching(start);
+  
+  while ((token = this.tokens[cursor])) {
+    if (token.is(start)) {
+      depth++;
+    }
+    
+    if (token.is(stop) && cursor) {
+      depth--;
+      if (depth == 0) return this.tokens[cursor];
+    }
+    cursor++;
+  }
+}
+
+JSDOC.TokenStream.prototype.insertAhead = function(/**JSDOC.Token*/token) {
+  this.tokens.splice(this.cursor+1, 0, token);
+}

data/jsdoc/app/lib/JSDOC/Util.js

@@ -0,0 +1,32 @@
+/**
+ * @namespace
+ * @deprecated Use {@link FilePath} instead.
+ */
+JSDOC.Util = {
+}
+
+/**
+ * @deprecated Use {@link FilePath.fileName} instead.
+ */
+JSDOC.Util.fileName = function(path) {
+  LOG.warn("JSDOC.Util.fileName is deprecated. Use FilePath.fileName instead.");
+  var nameStart = Math.max(path.lastIndexOf("/")+1, path.lastIndexOf("\\")+1, 0);
+  return path.substring(nameStart);
+}
+
+/**
+ * @deprecated Use {@link FilePath.fileExtension} instead.
+ */
+JSDOC.Util.fileExtension = function(filename) {
+  LOG.warn("JSDOC.Util.fileExtension is deprecated. Use FilePath.fileExtension instead.");
+  return filename.split(".").pop().toLowerCase();
+};
+
+/**
+ * @deprecated Use {@link FilePath.dir} instead.
+ */
+JSDOC.Util.dir = function(path) {
+  LOG.warn("JSDOC.Util.dir is deprecated. Use FilePath.dir instead.");
+  var nameStart = Math.max(path.lastIndexOf("/")+1, path.lastIndexOf("\\")+1, 0);
+  return path.substring(0, nameStart-1);
+}

data/jsdoc/app/lib/JSDOC/Walker.js

@@ -0,0 +1,416 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/** @constructor */
+JSDOC.Walker = function(/**JSDOC.TokenStream*/ts) {
+  this.init();
+  if (typeof ts != "undefined") {
+    this.walk(ts);
+  }
+}
+
+JSDOC.Walker.prototype.init = function() {
+  this.ts = null;
+
+  var globalSymbol = new JSDOC.Symbol("_global_", [], "GLOBAL", new JSDOC.DocComment(""));
+  globalSymbol.isNamespace = true;
+  globalSymbol.srcFile = "";
+  globalSymbol.isPrivate = false;
+  JSDOC.Parser.addSymbol(globalSymbol);
+  this.lastDoc = null;
+  this.token = null;
+  
+  /**
+    The chain of symbols under which we are currently nested.
+    @type Array
+  */
+  this.namescope = [globalSymbol];
+  this.namescope.last = function(n){ if (!n) n = 0; return this[this.length-(1+n)] || "" };
+}
+
+JSDOC.Walker.prototype.walk = function(/**JSDOC.TokenStream*/ts) {
+  this.ts = ts;
+  while (this.token = this.ts.look()) {
+    if (this.token.popNamescope) {
+      
+      var symbol = this.namescope.pop();
+      if (symbol.is("FUNCTION")) {
+        if (this.ts.look(1).is("LEFT_PAREN") && symbol.comment.getTag("function").length == 0) {
+          symbol.isa = "OBJECT";
+        }
+      }
+    }
+    this.step();
+    if (!this.ts.next()) break;
+  }
+}
+
+JSDOC.Walker.prototype.step = function() {
+  if (this.token.is("JSDOC")) { // it's a doc comment
+  
+    var doc = new JSDOC.DocComment(this.token.data);
+    
+    if (doc.getTag("lends").length > 0) { // it's a new namescope
+      var lends = doc.getTag("lends")[0];
+
+      var name = lends.desc
+      if (!name) throw "@lends tag requires a value.";
+      
+      var symbol = new JSDOC.Symbol(name, [], "OBJECT", doc);
+      
+      this.namescope.push(symbol);
+      
+      var matching = this.ts.getMatchingToken("LEFT_CURLY");
+      if (matching) matching.popNamescope = name;
+      else LOG.warn("Mismatched } character. Can't parse code.");
+      
+      this.lastDoc = null;
+      return true;
+    }
+    else if (doc.getTag("name").length > 0 && doc.getTag("overview").length == 0) { // it's a virtual symbol
+      var virtualName = doc.getTag("name")[0].desc;
+      if (!virtualName) throw "@name tag requires a value.";
+      
+      var symbol = new JSDOC.Symbol(virtualName, [], "VIRTUAL", doc);
+      
+      JSDOC.Parser.addSymbol(symbol);
+      
+      this.lastDoc = null;
+      return true;
+    }
+    else if (doc.meta) { // it's a meta doclet
+      if (doc.meta == "@+") JSDOC.DocComment.shared = doc.src;
+      else if (doc.meta == "@-") JSDOC.DocComment.shared = "";
+      else if (doc.meta == "nocode+") JSDOC.Parser.conf.ignoreCode = true;
+      else if (doc.meta == "nocode-") JSDOC.Parser.conf.ignoreCode = JSDOC.opt.n;
+      else throw "Unrecognized meta comment: "+doc.meta;
+      
+      this.lastDoc = null;
+      return true;
+    }
+    else if (doc.getTag("overview").length > 0) { // it's a file overview
+      symbol = new JSDOC.Symbol("", [], "FILE", doc);
+      
+      JSDOC.Parser.addSymbol(symbol);
+      
+      this.lastDoc = null;
+      return true;
+    }
+    else {
+      this.lastDoc = doc;
+      return false;
+    }
+  }
+  else if (!JSDOC.Parser.conf.ignoreCode) { // it's code
+    if (this.token.is("NAME")) {
+      var symbol;
+      var name = this.token.data;
+      var doc = null; if (this.lastDoc) doc = this.lastDoc;
+      var params = [];
+      
+      // it's inside an anonymous object
+      if (this.ts.look(1).is("COLON") && this.ts.look(-1).is("LEFT_CURLY") && !(this.ts.look(-2).is("JSDOC") || this.namescope.last().comment.getTag("lends").length || this.ts.look(-2).is("ASSIGN") || this.ts.look(-2).is("COLON"))) {
+        name = "$anonymous";
+        name = this.namescope.last().alias+"-"+name
+        
+        params = [];
+        
+        symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+
+        JSDOC.Parser.addSymbol(symbol);
+        
+        this.namescope.push(symbol);
+        
+        var matching = this.ts.getMatchingToken(null, "RIGHT_CURLY");
+        if (matching) matching.popNamescope = name;
+        else LOG.warn("Mismatched } character. Can't parse code.");
+      }
+      // function foo() {}
+      else if (this.ts.look(-1).is("FUNCTION") && this.ts.look(1).is("LEFT_PAREN")) {
+        var isInner;
+        
+        if (this.lastDoc) doc = this.lastDoc;
+        name = this.namescope.last().alias+"-"+name;
+        if (!this.namescope.last().is("GLOBAL")) isInner = true;
+        
+        params = JSDOC.Walker.onParamList(this.ts.balance("LEFT_PAREN"));
+        
+        symbol = new JSDOC.Symbol(name, params, "FUNCTION", doc);
+        if (isInner) symbol.isInner = true;
+        
+      
+        JSDOC.Parser.addSymbol(symbol);
+        
+        this.namescope.push(symbol);
+        
+        var matching = this.ts.getMatchingToken("LEFT_CURLY");
+        if (matching) matching.popNamescope = name;
+        else LOG.warn("Mismatched } character. Can't parse code.");
+      }
+      // foo = function() {}
+      else if (this.ts.look(1).is("ASSIGN") && this.ts.look(2).is("FUNCTION")) {
+        var isInner;
+        if (this.ts.look(-1).is("VAR") || this.isInner) {
+          name = this.namescope.last().alias+"-"+name
+          if (!this.namescope.last().is("GLOBAL")) isInner = true;
+        }
+        else if (name.indexOf("this.") == 0) {
+          name = this.resolveThis(name);
+        }
+        
+        if (this.lastDoc) doc = this.lastDoc;
+        params = JSDOC.Walker.onParamList(this.ts.balance("LEFT_PAREN"));
+        
+        symbol = new JSDOC.Symbol(name, params, "FUNCTION", doc);
+        if (isInner) symbol.isInner = true;
+        
+        JSDOC.Parser.addSymbol(symbol);
+        
+        this.namescope.push(symbol);
+        
+        var matching = this.ts.getMatchingToken("LEFT_CURLY");
+        if (matching) matching.popNamescope = name;
+        else LOG.warn("Mismatched } character. Can't parse code.");
+      }
+      // foo = new function() {}
+      else if (this.ts.look(1).is("ASSIGN") && this.ts.look(2).is("NEW") && this.ts.look(3).is("FUNCTION")) {
+        var isInner;
+        if (this.ts.look(-1).is("VAR") || this.isInner) {
+          name = this.namescope.last().alias+"-"+name
+          if (!this.namescope.last().is("GLOBAL")) isInner = true;
+        }
+        else if (name.indexOf("this.") == 0) {
+          name = this.resolveThis(name);
+        }
+        
+        if (this.lastDoc) doc = this.lastDoc;
+        params = JSDOC.Walker.onParamList(this.ts.balance("LEFT_PAREN"));
+        
+        symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+        if (isInner) symbol.isInner = true;
+        
+      
+        JSDOC.Parser.addSymbol(symbol);
+        
+        symbol.scopeType = "INSTANCE";
+        this.namescope.push(symbol);
+        
+        var matching = this.ts.getMatchingToken("LEFT_CURLY");
+        if (matching) matching.popNamescope = name;
+        else LOG.warn("Mismatched } character. Can't parse code.");
+      }
+      // foo: function() {}
+      else if (this.ts.look(1).is("COLON") && this.ts.look(2).is("FUNCTION")) {
+        name = (this.namescope.last().alias+"."+name).replace("#.", "#");
+        
+        if (this.lastDoc) doc = this.lastDoc;
+        params = JSDOC.Walker.onParamList(this.ts.balance("LEFT_PAREN"));
+        
+        if (doc && doc.getTag("constructs").length) {
+          name = name.replace(/\.prototype(\.|$)/, "#");
+          
+          if (name.indexOf("#") > -1) name = name.match(/(^[^#]+)/)[0];
+          else name = this.namescope.last().alias;
+
+          symbol = new JSDOC.Symbol(name, params, "CONSTRUCTOR", doc);
+        }
+        else {
+          symbol = new JSDOC.Symbol(name, params, "FUNCTION", doc);
+        }
+        
+        
+        JSDOC.Parser.addSymbol(symbol);
+        
+        this.namescope.push(symbol);
+        
+        var matching = this.ts.getMatchingToken("LEFT_CURLY");
+        if (matching) matching.popNamescope = name;
+        else LOG.warn("Mismatched } character. Can't parse code.");
+      }
+      // foo = {}
+      else if (this.ts.look(1).is("ASSIGN") && this.ts.look(2).is("LEFT_CURLY")) {
+        var isInner;
+        if (this.ts.look(-1).is("VAR") || this.isInner) {
+          name = this.namescope.last().alias+"-"+name
+          if (!this.namescope.last().is("GLOBAL")) isInner = true;
+        }
+        else if (name.indexOf("this.") == 0) {
+          name = this.resolveThis(name);
+        }
+        
+        if (this.lastDoc) doc = this.lastDoc;
+        
+        symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+        if (isInner) symbol.isInner = true;
+        
+      
+        if (doc) JSDOC.Parser.addSymbol(symbol);
+
+        this.namescope.push(symbol);
+        
+        var matching = this.ts.getMatchingToken("LEFT_CURLY");
+        if (matching) matching.popNamescope = name;
+        else LOG.warn("Mismatched } character. Can't parse code.");
+      }
+      // foo = x
+      else if (this.ts.look(1).is("ASSIGN")) {
+        
+        var isInner;
+        if (this.ts.look(-1).is("VAR") || this.isInner) {
+          name = this.namescope.last().alias+"-"+name
+          if (!this.namescope.last().is("GLOBAL")) isInner = true;
+        }
+        else if (name.indexOf("this.") == 0) {
+          name = this.resolveThis(name);
+        }
+        
+        if (this.lastDoc) doc = this.lastDoc;
+        
+        symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+        if (isInner) symbol.isInner = true;
+        
+      
+        if (doc) JSDOC.Parser.addSymbol(symbol);
+      }
+      // foo: {}
+      else if (this.ts.look(1).is("COLON") && this.ts.look(2).is("LEFT_CURLY")) {
+        name = (this.namescope.last().alias+"."+name).replace("#.", "#");
+        
+        if (this.lastDoc) doc = this.lastDoc;
+        
+        symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+        
+      
+        if (doc) JSDOC.Parser.addSymbol(symbol);
+        
+        this.namescope.push(symbol);
+        
+        var matching = this.ts.getMatchingToken("LEFT_CURLY");
+        if (matching) matching.popNamescope = name;
+        else LOG.warn("Mismatched } character. Can't parse code.");
+      }
+      // foo: x
+      else if (this.ts.look(1).is("COLON")) {
+        name = (this.namescope.last().alias+"."+name).replace("#.", "#");;
+        
+        if (this.lastDoc) doc = this.lastDoc;
+        
+        symbol = new JSDOC.Symbol(name, params, "OBJECT", doc);
+        
+      
+        if (doc) JSDOC.Parser.addSymbol(symbol);
+      }
+      // foo(...)
+      else if (this.ts.look(1).is("LEFT_PAREN")) {
+        var functionCall = {name: name};
+        if (!this.ts.look(2).is("RIGHT_PAREN")) functionCall.arg1 = this.ts.look(2).data;
+        
+        if (typeof JSDOC.PluginManager != "undefined") {
+          JSDOC.PluginManager.run("onFunctionCall", functionCall);
+          if (functionCall.doc) {
+            this.ts.insertAhead(new JSDOC.Token(functionCall.doc, "COMM", "JSDOC"));
+          }
+        }
+      }
+      this.lastDoc = null;
+    }
+    else if (this.token.is("FUNCTION")) { // it's an anonymous function
+      if (
+        (!this.ts.look(-1).is("COLON") || !this.ts.look(-1).is("ASSIGN"))
+        && !this.ts.look(1).is("NAME")
+      ) {
+        if (this.lastDoc) doc = this.lastDoc;
+        
+        name = "$anonymous";
+        name = this.namescope.last().alias+"-"+name
+        
+        params = JSDOC.Walker.onParamList(this.ts.balance("LEFT_PAREN"));
+        
+        symbol = new JSDOC.Symbol(name, params, "FUNCTION", doc);
+        
+      
+        JSDOC.Parser.addSymbol(symbol);
+        
+        this.namescope.push(symbol);
+        
+        var matching = this.ts.getMatchingToken("LEFT_CURLY");
+        if (matching) matching.popNamescope = name;
+        else LOG.warn("Mismatched } character. Can't parse code.");
+      }
+    }
+  }
+  return true;
+}
+
+/**
+  Resolves what "this." means when it appears in a name.
+  @param name The name that starts with "this.".
+  @returns The name with "this." resolved.
+ */
+JSDOC.Walker.prototype.resolveThis = function(name) {
+  name.match(/^this\.(.+)$/)
+  var nameFragment = RegExp.$1;
+  if (!nameFragment) return name;
+  
+  var symbol = this.namescope.last();
+  var scopeType = symbol.scopeType || symbol.isa;
+
+  // if we are in a constructor function, `this` means the instance
+  if (scopeType == "CONSTRUCTOR") {
+    name = symbol.alias+"#"+nameFragment;
+  }
+  
+  // if we are in an anonymous constructor function, `this` means the instance
+  else if (scopeType == "INSTANCE") {
+    name = symbol.alias+"."+nameFragment;
+  }
+  
+  // if we are in a function, `this` means the container (possibly the global)
+  else if (scopeType == "FUNCTION") {
+    // in a method of a prototype, so `this` means the constructor
+    if (symbol.alias.match(/(^.*)[#.-][^#.-]+/)) {
+      var parentName = RegExp.$1;
+      var parent = JSDOC.Parser.symbols.getSymbol(parentName);
+
+      if (!parent) {
+        if (JSDOC.Lang.isBuiltin(parentName)) parent = JSDOC.Parser.addBuiltin(parentName);
+        else {
+          if (symbol.alias.indexOf("$anonymous") < 0) // these will be ignored eventually
+            LOG.warn("Can't document "+symbol.alias+" without first documenting "+parentName+".");
+        }
+      }
+      if (parent) name = parentName+(parent.is("CONSTRUCTOR")?"#":".")+nameFragment;
+    }
+    else {
+      parent = this.namescope.last(1);
+      name = parent.alias+(parent.is("CONSTRUCTOR")?"#":".")+nameFragment;
+    }
+  }
+  // otherwise it means the global
+  else {
+    name = nameFragment;
+  }
+  
+  return name;
+}
+
+JSDOC.Walker.onParamList = function(/**Array*/paramTokens) {
+  if (!paramTokens) {
+    LOG.warn("Malformed parameter list. Can't parse code.");
+    return [];
+  }
+  var params = [];
+  for (var i = 0, l = paramTokens.length; i < l; i++) {
+    if (paramTokens[i].is("JSDOC")) {
+      var paramType = paramTokens[i].data.replace(/(^\/\*\* *| *\*\/$)/g, "");
+      
+      if (paramTokens[i+1] && paramTokens[i+1].is("NAME")) {
+        i++;
+        params.push({type: paramType, name: paramTokens[i].data});
+      }
+    }
+    else if (paramTokens[i].is("NAME")) {
+      params.push({name: paramTokens[i].data});
+    }
+  }
+  return params;
+}

data/jsdoc/app/lib/JSDOC.js

@@ -0,0 +1,97 @@
+/**
+  @overview
+  @date $Date: 2008-06-08 22:57:25 +0100 (Sun, 08 Jun 2008) $
+  @version $Revision: 638 $ 
+  @location $HeadURL: https://jsdoc-toolkit.googlecode.com/svn/tags/jsdoc_toolkit-2.0.1/jsdoc-toolkit/app/lib/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, 
+  {
+    d: "directory",
+    c: "conf",
+    t: "template",
+    r: "recurse",
+    x: "ext",
+    p: "private",
+    a: "allfunctions", 
+    e: "encoding",
+    n: "nocode",
+    o: "out",
+    s: "suppress",
+    T: "testmode",
+    h: "help",
+    v: "verbose",
+    "D[]": "define",
+    "H[]": "handler"
+  }
+);
+
+/** The current version string of this application. */
+JSDOC.VERSION = "2.0.1";
+
+/** 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("  -h or --help\n          Show this message and exit.\n");
+  //print("  -H=ext:handler or --handler=ext:handler\n          Multiple. Load handlers/handler.js to handle files with .ext names.\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("  -r=<DEPTH> or --recurse=<DEPTH>\n          Descend into src directories.\n");
+  print("  -s or --suppress\n          Suppress source code output.\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("  -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/");