sproutcore 0.9.13 → 0.9.14

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

@@ -0,0 +1,220 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/** @constructor */
+JSDOC.SymbolSet = function() {
+  this.init();
+}
+
+JSDOC.SymbolSet.prototype.init = function() {
+  this._index = {};
+}
+
+JSDOC.SymbolSet.prototype.keys = function() {
+  var found = [];
+  for (var p in this._index) {
+    found.push(p);
+  }
+  return found;
+}
+
+JSDOC.SymbolSet.prototype.hasSymbol = function(alias) {
+  return this._index.hasOwnProperty(alias);
+}
+
+JSDOC.SymbolSet.prototype.addSymbol = function(symbol) {
+  if (this.hasSymbol(symbol.alias)) {
+    LOG.warn("Overwriting symbol documentation for: "+symbol.alias + ".");
+  }
+  this._index[symbol.alias] = symbol;
+}
+
+JSDOC.SymbolSet.prototype.getSymbol = function(alias) {
+  if (this.hasSymbol(alias)) return this._index[alias];
+}
+
+JSDOC.SymbolSet.prototype.getSymbolByName = function(name) {
+  for (var p in this._index) {
+    var symbol = this.getSymbol(p);
+    if (symbol.name == name) return symbol;
+  }
+}
+
+JSDOC.SymbolSet.prototype.toArray = function() {
+  var found = [];
+  for (var p in this._index) {
+    found.push(this._index[p]);
+  }
+  return found;
+}
+
+JSDOC.SymbolSet.prototype.deleteSymbol = function(alias) {
+  if (!this.hasSymbol(alias)) return;
+  delete this._index[alias];
+}
+
+JSDOC.SymbolSet.prototype.renameSymbol = function(oldName, newName) {
+  // todo: should check if oldname or newname already exist
+  this._index[newName] = this._index[oldName];
+  this.deleteSymbol(oldName);
+  this._index[newName].alias = newName;
+  return newName;
+}
+
+JSDOC.SymbolSet.prototype.relate = function() {
+  this.resolveBorrows();
+  this.resolveMemberOf();
+  this.resolveAugments();
+}
+
+JSDOC.SymbolSet.prototype.resolveBorrows = function() {
+  for (p in this._index) {
+    var symbol = this._index[p];
+    if (symbol.is("FILE") || symbol.is("GLOBAL")) continue;
+    
+    var borrows = symbol.inherits;
+    for (var i = 0; i < borrows.length; i++) {
+      var borrowed = this.getSymbol(borrows[i].alias);
+      if (!borrowed) {
+        LOG.warn("Can't borrow undocumented "+borrows[i].alias+".");
+        continue;
+      }
+      
+      var borrowAsName = borrows[i].as;
+      var borrowAsAlias = borrowAsName;
+      if (!borrowAsName) {
+        LOG.warn("Malformed @borrow, 'as' is required.");
+        continue;
+      }
+      
+      if (borrowAsName.length > symbol.alias.length && borrowAsName.indexOf(symbol.alias) == 0) {
+        borrowAsName = borrowAsName.replace(borrowed.alias, "")
+      }
+      else {
+        var joiner = "";
+        if (borrowAsName.charAt(0) != "#") joiner = ".";
+        borrowAsAlias = borrowed.alias + joiner + borrowAsName;
+      }
+      
+      borrowAsName = borrowAsName.replace(/^[#.]/, "");
+          
+      if (this.hasSymbol(borrowAsAlias)) continue;
+
+      var clone = borrowed.clone();
+      clone.name = borrowAsName;
+      clone.alias = borrowAsAlias;
+      this.addSymbol(clone);
+    }
+  }
+}
+
+JSDOC.SymbolSet.prototype.resolveMemberOf = function() {
+  for (var p in this._index) {
+    var symbol = this.getSymbol(p);
+    
+    if (symbol.is("FILE") || symbol.is("GLOBAL")) continue;
+    
+    // the memberOf value was provided in the @memberOf tag
+    else if (symbol.memberOf) {
+      var parts = symbol.alias.match(new RegExp("^("+symbol.memberOf+"[.#-])(.+)$"));
+      
+      // like foo.bar is a memberOf foo
+      if (parts) {
+        symbol.memberOf = parts[1];
+        symbol.name = parts[2];
+      }
+      // like bar is a memberOf foo
+      else {
+        var joiner = symbol.memberOf.charAt(symbol.memberOf.length-1);
+        if (!/[.#-]/.test(joiner)) symbol.memberOf += ".";
+        
+        this.renameSymbol(p, symbol.memberOf + symbol.name);
+      }
+    }
+    // the memberOf must be calculated
+    else {
+      var parts = symbol.alias.match(/^(.*[.#-])([^.#-]+)$/);
+      if (parts) {
+        symbol.memberOf = parts[1];
+        symbol.name = parts[2];        
+      }
+    }
+
+    // set isStatic, isInner
+    if (symbol.memberOf) {
+      switch (symbol.memberOf.charAt(symbol.memberOf.length-1)) {
+        case '#' :
+          symbol.isStatic = false;
+          symbol.isInner = false;
+        break;
+        case '.' :
+          symbol.isStatic = true;
+          symbol.isInner = false;
+        break;
+        case '-' :
+          symbol.isStatic = false;
+          symbol.isInner = true;
+        break;
+      }
+    }
+    
+    // unowned methods and fields belong to the global object
+    if (!symbol.is("CONSTRUCTOR") && !symbol.isNamespace && symbol.memberOf == "") {
+      symbol.memberOf = "_global_";
+    }
+    
+    // clean up
+    if (symbol.memberOf.match(/[.#-]$/)) {
+      symbol.memberOf = symbol.memberOf.substr(0, symbol.memberOf.length-1);
+    }
+    
+    // add to parent's methods or properties list
+    if (symbol.memberOf) {
+      var container = this.getSymbol(symbol.memberOf);
+      if (!container) {
+        if (JSDOC.Lang.isBuiltin(symbol.memberOf)) container = JSDOC.Parser.addBuiltin(symbol.memberOf);
+        else {
+          LOG.warn("Can't document "+symbol.name +" as a member of undocumented symbol "+symbol.memberOf+".");
+        }
+      }
+      
+      if (container) container.addMember(symbol);
+    }
+  }
+}
+
+JSDOC.SymbolSet.prototype.resolveAugments = function() {
+  for (var p in this._index) {
+    var symbol = this.getSymbol(p);
+    
+    if (symbol.alias == "_global_" || symbol.is("FILE")) continue;
+    JSDOC.SymbolSet.prototype.walk.apply(this, [symbol]);
+  }
+}
+
+JSDOC.SymbolSet.prototype.walk = function(symbol) {
+  var augments = symbol.augments;
+  for(var i = 0; i < augments.length; i++) {
+    var contributer = this.getSymbol(augments[i]);
+    if (contributer) {
+      if (contributer.augments.length) {
+        JSDOC.SymbolSet.prototype.walk.apply(this, [contributer]);
+      }
+      
+      symbol.inheritsFrom.push(contributer.alias);
+      if (!isUnique(symbol.inheritsFrom)) {
+        //LOG.warn("Can't resolve augments: Circular reference: "+symbol.alias+" inherits from "+contributer.alias+" more than once.");
+      }
+      else {
+        var cmethods = contributer.methods;
+        var cproperties = contributer.properties;
+        
+        for (var ci = 0, cl = cmethods.length; ci < cl; ci++)
+          symbol.inherit(cmethods[ci]);
+        for (var ci = 0, cl = cproperties.length; ci < cl; ci++)
+          symbol.inherit(cproperties[ci]);
+      }
+    }
+    else LOG.warn("Can't augment contributer: "+augments[i]+", not found.");
+  }
+}
+

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

@@ -0,0 +1,41 @@
+
+/**
+  @constructor
+*/
+JSDOC.TextStream = function(text) {
+  if (typeof(text) == "undefined") text = "";
+  text = ""+text;
+  this.text = text;
+  this.cursor = 0;
+}
+
+JSDOC.TextStream.prototype.look = function(n) {
+  if (typeof n == "undefined") n = 0;
+  
+  if (this.cursor+n < 0 || this.cursor+n >= this.text.length) {
+    var result = new String("");
+    result.eof = true;
+    return result;
+  }
+  return this.text.charAt(this.cursor+n);
+}
+
+JSDOC.TextStream.prototype.next = function(n) {
+  if (typeof n == "undefined") n = 1;
+  if (n < 1) return null;
+  
+  var pulled = "";
+  for (var i = 0; i < n; i++) {
+    if (this.cursor+i < this.text.length) {
+      pulled += this.text.charAt(this.cursor+i);
+    }
+    else {
+      var result = new String("");
+      result.eof = true;
+      return result;
+    }
+  }
+
+  this.cursor += n;
+  return pulled;
+}

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

@@ -0,0 +1,18 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+  @constructor
+*/
+JSDOC.Token = function(data, type, name) {
+  this.data = data;
+  this.type = type;
+  this.name = name;
+}
+
+JSDOC.Token.prototype.toString = function() { 
+  return "<"+this.type+" name=\""+this.name+"\">"+this.data+"</"+this.type+">";
+}
+
+JSDOC.Token.prototype.is = function(what) {
+  return this.name === what || this.type === what;
+}

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

@@ -0,0 +1,323 @@
+if (typeof JSDOC == "undefined") JSDOC = {};
+
+/**
+  @class Search a {@link JSDOC.TextStream} for language tokens.
+*/
+JSDOC.TokenReader = function() {
+  this.keepDocs = true;
+  this.keepWhite = false;
+  this.keepComments = false;
+}
+
+/**
+  @type {JSDOC.Token[]}
+ */
+JSDOC.TokenReader.prototype.tokenize = function(/**JSDOC.TextStream*/stream) {
+  var tokens = [];
+  /**@ignore*/ tokens.last = function() { return tokens[tokens.length-1]; }
+
+  while (!stream.look().eof) {
+    if (this.read_mlcomment(stream, tokens)) continue;
+    if (this.read_slcomment(stream, tokens)) continue;
+    if (this.read_dbquote(stream, tokens))   continue;
+    if (this.read_snquote(stream, tokens))   continue;
+    if (this.read_regx(stream, tokens))      continue;
+    if (this.read_numb(stream, tokens))      continue;
+    if (this.read_punc(stream, tokens))      continue;
+    if (this.read_space(stream, tokens))     continue;
+    if (this.read_newline(stream, tokens))   continue;
+    if (this.read_word(stream, tokens))      continue;
+    
+    // if execution reaches here then an error has happened
+    tokens.push(new JSDOC.Token(stream.next(), "TOKN", "UNKNOWN_TOKEN"));
+  }
+  return tokens;
+}
+
+/**
+  @returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_word = function(/**JSDOC.TokenStream*/stream, tokens) {
+  var found = "";
+  while (!stream.look().eof && JSDOC.Lang.isWordChar(stream.look())) {
+    found += stream.next();
+  }
+  
+  if (found === "") {
+    return false;
+  }
+  else {
+    var name;
+    if ((name = JSDOC.Lang.keyword(found))) tokens.push(new JSDOC.Token(found, "KEYW", name));
+    else tokens.push(new JSDOC.Token(found, "NAME", "NAME"));
+    return true;
+  }
+}
+
+/**
+  @returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_punc = function(/**JSDOC.TokenStream*/stream, tokens) {
+  var found = "";
+  var name;
+  while (!stream.look().eof && JSDOC.Lang.punc(found+stream.look())) {
+    found += stream.next();
+  }
+  
+  if (found === "") {
+    return false;
+  }
+  else {
+    tokens.push(new JSDOC.Token(found, "PUNC", JSDOC.Lang.punc(found)));
+    return true;
+  }
+}
+
+/**
+  @returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_space = function(/**JSDOC.TokenStream*/stream, tokens) {
+  var found = "";
+  
+  while (!stream.look().eof && JSDOC.Lang.isSpace(stream.look())) {
+    found += stream.next();
+  }
+  
+  if (found === "") {
+    return false;
+  }
+  else {
+    if (this.collapseWhite) found = " ";
+    if (this.keepWhite) tokens.push(new JSDOC.Token(found, "WHIT", "SPACE"));
+    return true;
+  }
+}
+
+/**
+  @returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_newline = function(/**JSDOC.TokenStream*/stream, tokens) {
+  var found = "";
+  
+  while (!stream.look().eof && JSDOC.Lang.isNewline(stream.look())) {
+    found += stream.next();
+  }
+  
+  if (found === "") {
+    return false;
+  }
+  else {
+    if (this.collapseWhite) found = "\n";
+    if (this.keepWhite) tokens.push(new JSDOC.Token(found, "WHIT", "NEWLINE"));
+    return true;
+  }
+}
+
+/**
+  @returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_mlcomment = function(/**JSDOC.TokenStream*/stream, tokens) {
+  if (stream.look() == "/" && stream.look(1) == "*") {
+    var found = stream.next(2);
+    
+    while (!stream.look().eof && !(stream.look(-1) == "/" && stream.look(-2) == "*")) {
+      found += stream.next();
+    }
+    
+    // to start doclet we allow /** or /*** but not /**/ or /****
+    if (/^\/\*\*([^\/]|\*[^*])/.test(found) && this.keepDocs) tokens.push(new JSDOC.Token(found, "COMM", "JSDOC"));
+    else if (this.keepComments) tokens.push(new JSDOC.Token(found, "COMM", "MULTI_LINE_COMM"));
+    return true;
+  }
+  return false;
+}
+
+/**
+  @returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_slcomment = function(/**JSDOC.TokenStream*/stream, tokens) {
+  var found;
+  if (
+    (stream.look() == "/" && stream.look(1) == "/" && (found=stream.next(2)))
+    || 
+    (stream.look() == "<" && stream.look(1) == "!" && stream.look(2) == "-" && stream.look(3) == "-" && (found=stream.next(4)))
+  ) {
+    
+    while (!stream.look().eof && !JSDOC.Lang.isNewline(stream.look())) {
+      found += stream.next();
+    }
+    
+    if (this.keepComments) {
+      tokens.push(new JSDOC.Token(found, "COMM", "SINGLE_LINE_COMM"));
+    }
+    return true;
+  }
+  return false;
+}
+
+/**
+  @returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_dbquote = function(/**JSDOC.TokenStream*/stream, tokens) {
+  if (stream.look() == "\"") {
+    // find terminator
+    var string = stream.next();
+    
+    while (!stream.look().eof) {
+      if (stream.look() == "\\") {
+        if (JSDOC.Lang.isNewline(stream.look(1))) {
+          do {
+            stream.next();
+          } while (!stream.look().eof && JSDOC.Lang.isNewline(stream.look()));
+          string += "\\\n";
+        }
+        else {
+          string += stream.next(2);
+        }
+      }
+      else if (stream.look() == "\"") {
+        string += stream.next();
+        tokens.push(new JSDOC.Token(string, "STRN", "DOUBLE_QUOTE"));
+        return true;
+      }
+      else {
+        string += stream.next();
+      }
+    }
+  }
+  return false; // error! unterminated string
+}
+
+/**
+  @returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_snquote = function(/**JSDOC.TokenStream*/stream, tokens) {
+  if (stream.look() == "'") {
+    // find terminator
+    var string = stream.next();
+    
+    while (!stream.look().eof) {
+      if (stream.look() == "\\") { // escape sequence
+        string += stream.next(2);
+      }
+      else if (stream.look() == "'") {
+        string += stream.next();
+        tokens.push(new JSDOC.Token(string, "STRN", "SINGLE_QUOTE"));
+        return true;
+      }
+      else {
+        string += stream.next();
+      }
+    }
+  }
+  return false; // error! unterminated string
+}
+
+/**
+  @returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_numb = function(/**JSDOC.TokenStream*/stream, tokens) {
+  if (stream.look() === "0" && stream.look(1) == "x") {
+    return this.read_hex(stream, tokens);
+  }
+  
+  var found = "";
+  
+  while (!stream.look().eof && JSDOC.Lang.isNumber(found+stream.look())){
+    found += stream.next();
+  }
+  
+  if (found === "") {
+    return false;
+  }
+  else {
+    if (/^0[0-7]/.test(found)) tokens.push(new JSDOC.Token(found, "NUMB", "OCTAL"));
+    else tokens.push(new JSDOC.Token(found, "NUMB", "DECIMAL"));
+    return true;
+  }
+}
+/*t:
+  requires("../lib/JSDOC/TextStream.js");
+  requires("../lib/JSDOC/Token.js");
+  requires("../lib/JSDOC/Lang.js");
+  
+  plan(3, "testing JSDOC.TokenReader.prototype.read_numb");
+  
+  //// setup
+  var src = "function foo(num){while (num+8.0 >= 0x20 && num < 0777){}}";
+  var tr = new JSDOC.TokenReader();
+  var tokens = tr.tokenize(new JSDOC.TextStream(src));
+  
+  var hexToken, octToken, decToken;
+  for (var i = 0; i < tokens.length; i++) {
+    if (tokens[i].name == "HEX_DEC") hexToken = tokens[i];
+    if (tokens[i].name == "OCTAL") octToken = tokens[i];
+    if (tokens[i].name == "DECIMAL") decToken = tokens[i];
+  }
+  ////
+  
+  is(decToken.data, "8.0", "decimal number is found in source.");
+  is(hexToken.data, "0x20", "hexdec number is found in source (issue #99).");
+  is(octToken.data, "0777", "octal number is found in source.");
+*/
+
+/**
+  @returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_hex = function(/**JSDOC.TokenStream*/stream, tokens) {
+  var found = stream.next(2);
+  
+  while (!stream.look().eof) {
+    if (JSDOC.Lang.isHexDec(found) && !JSDOC.Lang.isHexDec(found+stream.look())) { // done
+      tokens.push(new JSDOC.Token(found, "NUMB", "HEX_DEC"));
+      return true;
+    }
+    else {
+      found += stream.next();
+    }
+  }
+  return false;
+}
+
+/**
+  @returns {Boolean} Was the token found?
+ */
+JSDOC.TokenReader.prototype.read_regx = function(/**JSDOC.TokenStream*/stream, tokens) {
+  if (
+    stream.look() == "/"
+    && 
+    (
+      !tokens.last()
+      ||
+      (
+        !tokens.last().is("NUMB")
+        && !tokens.last().is("NAME")
+        && !tokens.last().is("RIGHT_PAREN")
+        && !tokens.last().is("RIGHT_BRACKET")
+      )
+    )
+  ) {
+    var regex = stream.next();
+    
+    while (!stream.look().eof) {
+      if (stream.look() == "\\") { // escape sequence
+        regex += stream.next(2);
+      }
+      else if (stream.look() == "/") {
+        regex += stream.next();
+        
+        while (/[gmi]/.test(stream.look())) {
+          regex += stream.next();
+        }
+        
+        tokens.push(new JSDOC.Token(regex, "REGX", "REGX"));
+        return true;
+      }
+      else {
+        regex += stream.next();
+      }
+    }
+    // error: unterminated regex
+  }
+  return false;
+}