sproutcore 0.9.13 → 0.9.14

data/jsdoc/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");
+}
+
+*/

data/jsdoc/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"
+};

data/jsdoc/app/frame/Hash.js

@@ -0,0 +1,47 @@
+/**@constructor*/
+function Hash() {
+  this.reset();
+}
+
+Hash.prototype.reset = function() {
+  this.elements = {};
+}
+
+Hash.prototype.put = function() {
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    this.elements[arguments[i]] = arguments[++i];
+  }
+}
+
+Hash.prototype.has = function(key) {
+  return this.elements.hasOwnProperty(key);
+}
+
+Hash.prototype.get = function(key) {
+  return (this.has(key)) ? this.elements[key] : undefined;
+}
+
+Hash.prototype.drop = function(key) {
+  if (this.has(key)) {
+    delete this.elements[key];
+  }
+}
+
+Hash.prototype.rename = function(oldKey, newKey) {
+  if (oldKey != newKey && this.has(oldKey)) {
+    this.elements[newKey] = this.elements[oldKey];
+    delete this.elements[oldKey];
+  }
+}
+
+Hash.prototype.keys = function() {
+  var keys = [];
+  for (var key in this.elements) if (this.has(key)) keys.push(key);
+  return keys;
+}
+
+Hash.prototype.values = function() {
+  var values = [];
+  for (var key in this.elements) if (this.has(key)) values.push(this.get(key));
+  return values;
+}

data/jsdoc/app/frame/Link.js

@@ -0,0 +1,142 @@
+/** 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 = "";
+  if (symbol.isStatic) linker = ".";
+  else if (symbol.isInner) linker = "-";
+  
+  return Link.hashPrefix+linker+symbol.name;
+}
+
+/** Create a link to a snother symbol. */
+Link.prototype._makeSymbolLink = function(alias) {
+  var linkBase = Link.base+publish.conf.symbolsDir;
+  var linkTo = Link.symbolSet.getSymbol(alias);
+  var linkPath;
+  var target = (this.targetName)? " target=\""+this.targetName+"\"" : "";
+
+  // is it an internal link?
+  if (alias.charAt(0) == "#") var linkPath = alias;
+  
+  // if there is no symbol by that name just return the name unaltered
+  else 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 = escape(linkTo.memberOf) || "_global_";
+      linkPath += publish.conf.ext + "#" + Link.symbolNameToLinkName(linkTo);
+    }
+    else {
+      linkPath = 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};
+  
+  if (typeof JSDOC.PluginManager != "undefined") {
+    JSDOC.PluginManager.run("onSymbolLink", link);
+  }
+  
+  return "<a href=\""+link.linkPath+"\""+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>";
+}

data/jsdoc/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();
+}

data/jsdoc/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."
+  );
+ */

data/jsdoc/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(/, ?/);
+}

data/jsdoc/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.");
+*/