xpcomcore-rubygem 0.3.1 → 0.3.2

data/xpcomcore/etc/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]};
+}

data/xpcomcore/etc/jsdoc-toolkit/app/frame/Link.js

@@ -0,0 +1,153 @@
+/** 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 another 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
+			if (linkTo.isEvent) {
+				linkPath = 
+					(Link.filemap)? Link.filemap[linkTo.memberOf] 
+					:
+					escape(linkTo.memberOf) || "_global_";
+				linkPath += publish.conf.ext + "#event:" + Link.symbolNameToLinkName(linkTo);
+			}
+			else {
+				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>";
+}

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

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

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

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