riojs 0.0.0

data/public/javascripts/lib/id.js

@@ -0,0 +1,43 @@
+rio.Id = Class.create({
+	initialize: function(id) {
+		if (id) {
+			this._val = id;
+			this._temporary = false;
+		} else {
+			this._val = (Math.random() * -1000000000).round();
+			this._temporary = true;
+		}
+		this._cacheKey = this._val;
+		this._todos = [];
+	},
+	
+	temporary: function() {
+		return this._temporary;
+	},
+	
+	cacheKey: function() {
+		return this._cacheKey;
+	},
+	
+	reify: function(realId) {
+		if (!this._temporary) { return; }
+		this._val = realId;
+		this._temporary = false;
+		this._todos.each(function(todo) { todo(); });
+	},
+	
+	doAfterReification: function(todo) {
+		if(!this._temporary) {todo();}
+		this._todos.push(todo);
+	},
+
+	toString: function() {
+		return this._val.toString();
+	},
+	
+	value: function() {
+		return this._val;
+	}
+});
+
+rio.Id.toString = function() { return "Id"; };

data/public/javascripts/lib/inflector.js

@@ -0,0 +1,160 @@
+// based on the Inflector class from JavascriptMVC (http://javascriptmvc.com/index.html)
+// based on the Inflector class found on a DZone snippet contributed by Todd Sayre
+// http://snippets.dzone.com/posts/show/3205
+
+/*
+	This needs test coverage.
+	
+	I have found a few issues so far:
+	
+		"ax".singularize()
+		"mice".pluralize()
+
+		etc...
+		
+	I attempted to fix these by adding the "return word;" lines at the end of singularize and pluralize.
+*/
+
+rio.Inflector = {
+	Inflections: {
+		plural: [
+			[/(quiz)$/i,               "$1zes"  ],
+			[/^(ox)$/i,                "$1en"   ],
+			[/([m|l])ouse$/i,          "$1ice"  ],
+			[/(matr|vert|ind)ix|ex$/i, "$1ices" ],
+			[/(x|ch|ss|sh)$/i,         "$1es"   ],
+			[/([^aeiouy]|qu)y$/i,      "$1ies"  ],
+			[/(hive)$/i,               "$1s"    ],
+			[/(?:([^f])fe|([lr])f)$/i, "$1$2ves"],
+			[/sis$/i,                  "ses"    ],
+			[/([ti])um$/i,             "$1a"    ],
+			[/(buffal|tomat)o$/i,      "$1oes"  ],
+			[/(bu)s$/i,                "$1ses"  ],
+			[/(alias|status)$/i,       "$1es"   ],
+			[/(octop|vir)us$/i,        "$1i"    ],
+			[/(ax|test)is$/i,          "$1es"   ],
+			[/s$/i,                    "s"      ],
+			[/$/,                      "s"      ]
+		],
+		singular: [
+			[/(quiz)zes$/i,                                                    "$1"     ],
+			[/(matr)ices$/i,                                                   "$1ix"   ],
+			[/(vert|ind)ices$/i,                                               "$1ex"   ],
+			[/^(ox)en/i,                                                       "$1"     ],
+			[/(alias|status)es$/i,                                             "$1"     ],
+			[/(octop|vir)i$/i,                                                 "$1us"   ],
+			[/(cris|ax|test)es$/i,                                             "$1is"   ],
+			[/(shoe)s$/i,                                                      "$1"     ],
+			[/(o)es$/i,                                                        "$1"     ],
+			[/(bus)es$/i,                                                      "$1"     ],
+			[/([m|l])ice$/i,                                                   "$1ouse" ],
+			[/(x|ch|ss|sh)es$/i,                                               "$1"     ],
+			[/(m)ovies$/i,                                                     "$1ovie" ],
+			[/(s)eries$/i,                                                     "$1eries"],
+			[/([^aeiouy]|qu)ies$/i,                                            "$1y"    ],
+			[/([lr])ves$/i,                                                    "$1f"    ],
+			[/(tive)s$/i,                                                      "$1"     ],
+			[/(hive)s$/i,                                                      "$1"     ],
+			[/([^f])ves$/i,                                                    "$1fe"   ],
+			[/(^analy)ses$/i,                                                  "$1sis"  ],
+			[/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, "$1$2sis"],
+			[/([ti])a$/i,                                                      "$1um"   ],
+			[/(n)ews$/i,                                                       "$1ews"  ],
+			[/s$/i,                                                            ""       ]
+		],
+		irregular: [
+			['move',   'moves'   ],
+			['sex',    'sexes'   ],
+			['child',  'children'],
+			['man',    'men'     ],
+			['foreman', 'foremen'],
+			['person', 'people'  ]
+		],
+		uncountable: [
+			"sheep",
+			"fish",
+			"series",
+			"species",
+			"money",
+			"rice",
+			"information",
+			"equipment"
+		]
+	},
+	pluralize: function(word) {
+		var i;
+		for (i = 0; i < this.Inflections.uncountable.length; i++) {
+			var uncountable = this.Inflections.uncountable[i];
+			if (word.toLowerCase() == uncountable) {
+				return uncountable;
+			}
+		}
+		for (i = 0; i < this.Inflections.irregular.length; i++) {
+			var singular = this.Inflections.irregular[i][0];
+			var plural   = this.Inflections.irregular[i][1];
+			if ((word.toLowerCase() == singular) || (word == plural)) {
+				return word.substring(0,1)+plural.substring(1);
+			}
+		}
+		for (i = 0; i < this.Inflections.plural.length; i++) {
+			var regex          = this.Inflections.plural[i][0];
+			var replaceString = this.Inflections.plural[i][1];
+			if (regex.test(word)) {
+				return word.replace(regex, replaceString);
+			}
+		}
+		
+		return word;
+	},
+	singularize: function(word) {
+		var i;
+		for (i = 0; i < this.Inflections.uncountable.length; i++) {
+			var uncountable = this.Inflections.uncountable[i];
+			if (word.toLowerCase() == uncountable) {
+				return uncountable;
+			}
+		}
+		for (i = 0; i < this.Inflections.irregular.length; i++) {
+			var singular = this.Inflections.irregular[i][0];
+			var plural   = this.Inflections.irregular[i][1];
+			if ((word.toLowerCase() == singular) || (word.toLowerCase() == plural)) {
+				return word.substring(0,1)+singular.substring(1);
+			}
+		}
+		for (i = 0; i < this.Inflections.singular.length; i++) {
+			var regex          = this.Inflections.singular[i][0];
+			var replaceString = this.Inflections.singular[i][1];
+			if (regex.test(word)) {
+				return word.replace(regex, replaceString);
+			}
+		}
+		
+		return word;
+	}
+};
+
+
+Object.extend(String.prototype, {
+	pluralize: function(count, plural) {
+		if (typeof count == 'undefined') {
+			return rio.Inflector.pluralize(this);
+		} else {
+			return count + ' ' + (1 == parseInt(count, 10) ? this : plural || rio.Inflector.pluralize(this));
+		}
+	},
+
+	singularize: function(count) {
+		if (count == undefined) {
+			return rio.Inflector.singularize(this);
+		} else {
+			return count + " " + rio.Inflector.singularize(this);
+		}
+	},
+
+	isSingular: function(){
+		if(this.singularize() == this) {
+			return true;
+		}
+		return false;
+	}
+});

data/public/javascripts/lib/instrumenter.js

@@ -0,0 +1,106 @@
+rio.Instrumenter = {
+	instrument: function(filePath) {
+		rio.File.open(rio.boot.appRoot + filePath + ".js", {
+			asynchronous: false,
+			onSuccess: function(text) {
+				this.parseBlocks(text);
+			}.bind(this)
+		});
+	},
+
+	parseBlocks: function(text) {
+		var tokens = this.tokenize(text);
+		rio.log(tokens.map(function(t) { return t.token; }).join("\n"));
+		var CONTEXTS = {
+			NONE: 0,
+			FUNCTION: 1,
+			OBJECT: 2,
+			ARRAY: 3,
+			COMMENT: 4
+		};
+		
+		var context = CONTEXTS.NONE;
+		var out = "";
+		for (var i = 0; i < text.length; i++) {
+			
+		}
+	},
+
+	tokenize: function(text) {
+		var CONTEXTS = {
+			NONE: 0,
+			STRING: 1,
+			COMMENT: 2,
+			BLOCK_COMMENT: 3,
+			NUMBER: 4
+		};
+		var context = CONTEXTS.NONE;
+
+		var lineNumber = 1;
+		var tokens = [];
+		var soFar = "";
+		var addToken = function() {
+			tokens.push({
+				lineNumber: lineNumber,
+				token: soFar
+			});
+			soFar = "";
+		};
+		for (var i = 0; i < text.length; i++) {
+			var c = text[i];
+			switch(context) {
+			case CONTEXTS.NONE:
+				switch(c) {
+				case ' ':
+				case '\t':
+				case '\n':
+					if (soFar != "") { addToken(); }
+					break;
+				case '"':
+					
+					break;
+				default:
+					if (soFar == "/" && c == "*") {
+						context = CONTEXTS.BLOCK_COMMENT;
+						soFar = "";
+					} else if (soFar == "/" && c == "/") {
+						context = CONTEXTS.COMMENT;
+						soFar = "";
+					} else {
+						soFar += c;
+					}
+				}
+				break;
+			case CONTEXTS.STRING:
+				break;
+			case CONTEXTS.COMMENT:
+				switch(c) {
+				case "\n":
+					context = CONTEXTS.NONE;
+				}
+				break;
+			case CONTEXTS.BLOCK_COMMENT:
+				switch(c) {
+				case "*":
+					soFar = "*";
+					break;
+				case "/":
+					if (soFar == "*") { context = CONTEXTS.NONE };
+				default: 
+					soFar = "";
+				}
+				break;
+			}
+
+			if (c == "\n") { lineNumber += 1;  }
+		}
+		return tokens;
+	},
+
+	wrap: function(fcn) {
+		rio.log("WRAP");
+		return fcn();
+	},
+
+	toString: function() { return "Instrumenter"; }
+};

data/public/javascripts/lib/js_template.js

@@ -0,0 +1,275 @@
+/**
+	@class
+	
+	JsTemplates are used to parse rio templates (*.jst files).  JsTemplates are created by rio pages as a starting point
+	for a pages html state.  You should rarely have to instantiate this class directly.
+*/
+rio.JsTemplate = Class.create({
+	initialize: function(options) {
+		this._name = options.name || "template";
+		this._template = options.text.gsub(" ", "\u00a0");
+		this._path = options.path;
+	},
+	
+	mixinMethods: function() {
+		var template = this;
+		return { 
+			buildHtml: function() {
+				return template.render(this);
+			}
+		};
+	},
+	
+	xml: function() {
+		return '<div style="height: 100%;" class="' + this._name + '" xmlns:rio="http://riojs.com">' + this._template + "</div>";
+	},
+	
+	parse: function() {
+		return rio.JsTemplate.parse(this._path ? this._template : this.xml());
+	},
+	
+	render: function(context) {
+		var xml = this.parse();
+		try {
+			if (this._path) {
+				var nodes = xml.childNodes.item(0).getElementsByTagName(this._path)[0].childNodes;
+				var divNode;
+				var i = 0;
+				while (divNode == undefined) {
+					var node = nodes.item(i);
+					if (node.nodeType == 1) {
+						divNode = node;
+					}
+					i++;
+				}
+				return this.renderElement(node, context);
+			} else {
+				return this.renderElement(xml.childNodes.item(0), context);
+			}
+		} catch(e) { 
+			rio.error(e, "Rendering error.  Your xml might be malformed.\nRemember to escape these characters [<, \", &] with [&lt;, &quot;, &amp;])"); 
+			throw(e);
+		}
+	},
+	
+	renderElement: function(xmlElement, context) {
+		var nodes = xmlElement.childNodes;
+		
+		var htmlChildren = [];
+		var i, item;
+		for (i = 0; i < nodes.length; i++) {
+			item = nodes.item(i);
+			
+			switch(item.nodeType) {
+			case 1: // Element
+				if (item.nodeName.startsWith("rio:")) {
+					htmlChildren.push(this.renderComponent(item, context).html());
+				} else {
+					htmlChildren.push(this.renderElement(item, context));
+				}
+				break;
+			case 3: // Text
+				htmlChildren.push(item.nodeValue);
+				break;
+			}
+		}
+		
+		var htmlAttributes = {};
+		var attributes = xmlElement.attributes;
+		var rioId;
+		for (i = 0; i < attributes.length; i++) {
+			item = attributes.item(i);
+			if (item.nodeName == "rio:id") {
+				rioId = item.nodeValue;
+			} else {
+				htmlAttributes[item.nodeName] = item.nodeValue;
+			}
+		}
+		
+		var htmlElement = rio.Tag.build(xmlElement.nodeName, htmlChildren, htmlAttributes);
+		
+		if (rioId) {
+			context[("get-" + rioId + "Element").camelize()] = function() {
+				return htmlElement;
+			};
+		}
+		
+		return htmlElement;
+	},
+	
+	renderChildNodes: function(xmlElement, context) {
+		var nodes = xmlElement.childNodes;
+		
+		var renderedChildren = [];
+		for (var i = 0; i < nodes.length; i++) {
+			var item = nodes.item(i);
+			
+			switch(item.nodeType) {
+			case 1: // Element
+				if (item.nodeName.startsWith("rio:")) {
+					if (item.nodeName == "rio:Object") {
+						renderedChildren.push(this.renderRioObject(item, context));
+					} else {
+						renderedChildren.push(this.renderComponent(item, context));
+					}
+				} else {
+					renderedChildren.push(this.renderElement(item, context));
+				}
+				break;
+			case 3: // Text
+				if (item.nodeValue.strip() != "") {
+					renderedChildren.push(item.nodeValue);
+				}
+				break;
+			}
+		}
+		return renderedChildren.reduce();
+	},
+	
+	renderRioObject: function(xmlElement, context) {
+		var obj = {};
+		var nodes = xmlElement.childNodes;
+		for (var i = 0; i < nodes.length; i++) {
+			var item = nodes.item(i);
+			if (item.nodeType == 1) {
+				obj[item.nodeName] = this.renderChildNodes(item, context);
+			}
+		}
+		
+		return obj;
+	},
+	
+	renderComponent: function(xmlElement, context) {
+		var componentType = xmlElement.nodeName.match(/rio:(.*)/)[1];
+
+		
+		var componentAttributes = {};
+		var attributes = xmlElement.attributes;
+		var rioId, i, item;
+
+		for (i = 0; i < attributes.length; i++) {
+			item = attributes.item(i);
+			if (item.nodeName == "rio:id") {
+				rioId = item.nodeValue;
+			} else {
+				var value = item.nodeValue;
+				var executable = value.match(/\{(.*)\}/);
+				if (executable) {
+					rio.pageBinding = context;
+					try {
+						value = eval("(function() { return " + executable[1] + "; }).bind(rio.pageBinding)();");
+					} catch(e) {
+						rio.error(e, "Error evaluating " + this._name.classize() + " template attribute: " + executable[1]);
+						throw(e);
+					}
+					delete rio.pageBinding;
+				}
+				componentAttributes[item.nodeName] = value;
+			}
+		}
+
+		var nodes = xmlElement.childNodes;
+		for (i = 0; i < nodes.length; i++) {
+			item = nodes.item(i);
+		
+			if (item.nodeType == 1) {
+				if (item.nodeName == "rio:id") {
+					rioId = item.nodeValue;
+				} else {
+					componentAttributes[item.nodeName] = this.renderChildNodes(item, context);
+				}
+			}
+		}
+		try {
+			var component = new rio.components[componentType](componentAttributes);
+		} catch(e2) {
+			if (rio.components[componentType] == undefined) {
+				rio.error(e2, componentType + " not found.  Add 'components/" + componentType.underscore() + "' to the " + this._name.classize() + " require list.");
+			}
+			throw(e2);
+		}
+		
+		if (rioId) {
+			context[("get-" + rioId).camelize()] = function() {
+				return component;
+			};
+		}
+		
+		return component;
+	},
+	
+	name: function() {
+		return this._name;
+	}
+});
+Object.extend(rio.JsTemplate, {
+	build: function(path) {
+		path = rio.boot.appRoot + path;
+		if (this._templatePreloaded(path)) {
+			return new rio.JsTemplate({
+				name: this._templateNameFromPath(path),
+				text: this._allTemplatesFile,
+				path: path.gsub("/", "--")
+			});
+		} else {
+			rio.log("missed: " + path);
+			return new rio.JsTemplate({ 
+				name: this._templateNameFromPath(path),
+				text: this._templateFile(path)
+			});
+		}
+	},
+	
+	preload: function(path) {
+		this._allTemplatesFile = this._templateFile(path);
+		this._allTemplatesList = [];
+
+		var doc = this.parse(this._allTemplatesFile);
+		var templateNodes = doc.childNodes.item(0).childNodes;
+		for (var i = 0; i < templateNodes.length; i++) {
+			var item = templateNodes.item(i);
+			if (item.nodeType == 1) {
+				this._allTemplatesList.push(item.nodeName.gsub("--", "/"));
+			}
+		}
+	},
+	
+	parse: function(xml) {
+		var xmlDoc;
+		if (Prototype.Browser.IE) {
+			xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
+			xmlDoc.async="false";
+			xmlDoc.loadXML(xml);
+		} else {
+			try {
+				var parser = new DOMParser();
+				xmlDoc = parser.parseFromString(xml,"text/xml");
+			} catch(e) {
+				rio.log(e);
+			}
+		}
+		return xmlDoc;
+	},
+	
+	_templatePreloaded: function(path) {
+		return (this._allTemplatesList || []).include(path);
+	},
+	
+	_templateNameFromPath: function(path) {
+		return path.split("/").last().camelize();
+	},
+
+	_templateFile: function(path) {
+		return rio.File.open(rio.boot.root + rio.boot.appRoot + path + ".jst", {
+			asynchronous: false,
+			onFailure: function() {
+				rio.Application.fail("Failed loading template - " + path);
+			}
+		});
+	},
+
+	toString: function() { 
+		return "JsTemplate"; 
+	}
+});
+