| t |
" + html_escape(e.stack) + "\n"; + } + + } + }).call(self); + }; + + Haml = function Haml(haml, xml) { + forceXML = xml; + var js = optimize(compile(haml)); + return new Function("locals", + html_escape + "\n" + + "with(locals || {}) {\n" + + " try {\n" + + " return (" + js + ");\n" + + " } catch (e) {\n" + + " return \"\\n
\" + html_escape(e.stack) + \"\\n\";\n" + + " }\n" + + "}"); + } + + Sammy = Sammy || {}; + + // Sammy.Haml provides a quick way of using haml style templates in your app. + // The plugin itself includes the haml-js library created by Tim Caswell at + // at http://github.com/creationix/haml-js + // + // Haml is an alternative HTML syntax that is really great for describing + // the structure of HTML documents. + // + // By default using Sammy.Haml in your app adds the haml() method to the EventContext + // prototype. However, just like Sammy.Template you can change the default name of the method + // by passing a second argument (e.g. you could use the hml() as the method alias so that all the template + // files could be in the form file.hml instead of file.haml) + // + // ### Example + // + // The template (mytemplate.haml): + // + // %h1&= title + // + // Hey, #{name}! Welcome to Haml! + // + // The app: + // + // var $.app = $.sammy(function() { + // // include the plugin + // this.use(Sammy.Haml); + // + // this.get('#/hello/:name', function() { + // // set local vars + // this.title = 'Hello!' + // this.name = this.params.name; + // // render the template and pass it through haml + // this.partial('mytemplate.haml'); + // }); + // + // }); + // + // If I go to `#/hello/AQ` in the browser, Sammy will render this to the body: + // + //
Hello!
+ // + // Hey, AQ! Welcome to HAML! + // + // Note: You dont have to include the haml.js file on top of the plugin as the plugin + // includes the full source. + // + Sammy.Haml = function(app, method_alias) { + app.use(Sammy.JSON); + + var haml_cache = {}; + // *Helper* Uses haml-js to parse a template and interpolate and work with the passed data + // + // ### Arguments + // + // * `template` A String template. + // * `data` An Object containing the replacement values for the template. + // data is extended with the EventContext allowing you to call its methods within the template. + // + var haml = function(template, data, name) { + // use name for caching + if (typeof name == 'undefined') name = template; + var fn = haml_cache[name]; + if (!fn) { + fn = haml_cache[name] = Haml(template); + } + return fn($.extend({}, this, data)); + }; + + // set the default method name/extension + if (!method_alias) method_alias = 'haml'; + app.helper(method_alias, haml); + + }; + +})(jQuery); diff --git a/public/javascripts/plugins/sammy.handlebars.js b/public/javascripts/plugins/sammy.handlebars.js new file mode 100644 index 0000000..71e1404 --- /dev/null +++ b/public/javascripts/plugins/sammy.handlebars.js @@ -0,0 +1,612 @@ +(function($) { + var Handlebars = { + compilerCache: {}, + + compile: function(string) { + if (Handlebars.compilerCache[string] == null) { + var fnBody = Handlebars.compileFunctionBody(string); + var fn = new Function("context", "fallback", "Handlebars", fnBody); + Handlebars.compilerCache[string] = + function(context, fallback) { return fn(context, fallback, Handlebars); }; + } + + return Handlebars.compilerCache[string]; + }, + + compileToString: function(string) { + var fnBody = Handlebars.compileFunctionBody(string); + return "function(context, fallback) { " + fnBody + "}"; + }, + + compileFunctionBody: function(string) { + var compiler = new Handlebars.Compiler(string); + compiler.compile(); + + return "fallback = fallback || {}; var stack = [];" + compiler.fn; + }, + + isFunction: function(fn) { + return Object.prototype.toString.call(fn) == "[object Function]"; + }, + + trim: function(str) { + return str.replace(/^\s+|\s+$/g, ''); + }, + + escapeText: function(string) { + string = string.replace(/'/g, "\\'"); + string = string.replace(/\"/g, "\\\""); + return string; + }, + + escapeExpression: function(string) { + // don't escape SafeStrings, since they're already safe + if (string instanceof Handlebars.SafeString) { + return string.toString(); + } + else if (string === null) { + string = ""; + } + + return string.toString().replace(/&(?!\w+;)|["\\<>]/g, function(str) { + switch(str) { + case "&": + return "&"; + break; + case '"': + return "\""; + case "\\": + return "\\\\"; + break; + case "<": + return "<"; + break; + case ">": + return ">"; + break; + default: + return str; + } + }); + }, + + compilePartial: function(partial) { + if (Handlebars.isFunction(partial)) { + compiled = partial; + } else { + compiled = Handlebars.compile(partial); + } + + return compiled; + }, + + evalExpression: function(path, context, stack) { + var parsedPath = Handlebars.parsePath(path); + var depth = parsedPath[0]; + var parts = parsedPath[1]; + if (depth > stack.length) { + context = null; + } else if (depth > 0) { + context = stack[stack.length - depth]; + } + + for (var i = 0; i < parts.length && context !== undefined; i++) { + context = context[parts[i]]; + } + + return context; + }, + + buildContext: function(context, stack) { + var ContextWrapper = function(stack) { + this.__stack__ = stack.slice(0); + this.__get__ = function(path) { + return Handlebars.evalExpression(path, this, this.__stack__); + }; + }; + + ContextWrapper.prototype = context; + return new ContextWrapper(stack); + }, + + // spot to memoize paths to speed up loops and subsequent parses + pathPatterns: {}, + + // returns a two element array containing the numbers of contexts to back up the stack and + // the properties to dig into on the current context + // + // for example, if the path is "../../alan/name", the result will be [2, ["alan", "name"]]. + parsePath: function(path) { + if (path == null) { + return [0, []]; + } else if (Handlebars.pathPatterns[path] != null) { + return Handlebars.pathPatterns[path]; + } + + var parts = path.split("/"); + var readDepth = false; + var depth = 0; + var dig = []; + for (var i = 0, j = parts.length; i < j; i++) { + switch(parts[i]) { + case "..": + if (readDepth) { + throw new Handlebars.Exception("Cannot jump out of context after moving into a context."); + } else { + depth += 1; + } + break; + case ".": + // do nothing - using .'s is pretty dumb, but it's also basically free for us to support + case "this": + // if we do nothing you'll end up sticking in the same context + break; + default: + readDepth = true; + dig.push(parts[i]); + } + } + + var ret = [depth, dig]; + Handlebars.pathPatterns[path] = ret; + return ret; + }, + + isEmpty: function(value) { + if (typeof value === "undefined") { + return true; + } else if (!value) { + return true; + } else if(Object.prototype.toString.call(value) === "[object Array]" && value.length == 0) { + return true; + } else { + return false; + } + }, + + // Escapes output and converts empty values to empty strings + filterOutput: function(value, escape) { + + if (Handlebars.isEmpty(value)) { + return ""; + } else if (escape) { + return Handlebars.escapeExpression(value); + } else { + return value; + } + }, + + handleBlock: function(lookup, context, arg, fn, notFn) { + var out = ""; + if (Handlebars.isFunction(lookup)) { + out = out + lookup.call(context, arg, fn); + if (notFn != null && Handlebars.isFunction(lookup.not)) { + out = out + lookup.not.call(context, arg, notFn); + } + } + else { + if (!Handlebars.isEmpty(lookup)) { + out = out + Handlebars.helperMissing.call(arg, lookup, fn); + } + + if (notFn != null) { + out = out + Handlebars.helperMissing.not.call(arg, lookup, notFn); + } + } + + return out; + }, + + handleExpression: function(lookup, context, arg, isEscaped) { + var out = ""; + + if (Handlebars.isFunction(lookup)) { + out = out + Handlebars.filterOutput(lookup.call(context, arg), isEscaped); + } else if(!Handlebars.isEmpty(lookup)) { + out = out + Handlebars.filterOutput(lookup, isEscaped); + } + + return out; + }, + + handleInvertedSection: function(lookup, context, fn) { + var out = ""; + if(Handlebars.isFunction(lookup) && Handlebars.isEmpty(lookup())) { + out = out + fn(context); + } else if (Handlebars.isEmpty(lookup)) { + out = out + fn(context); + } + return out; + } + } + + Handlebars.Compiler = function(string) { + this.string = string; + this.pointer = -1; + this.mustache = false; + this.text = ""; + this.fn = "var out = ''; var lookup; "; + this.newlines = ""; + this.comment = false; + this.escaped = true; + this.partial = false; + this.inverted = false; + this.endCondition = null; + this.continueInverted = false; + }; + + Handlebars.Exception = function(message) { + this.message = message; + }; + + Handlebars.SafeString = function(string) { + this.string = string; + } + Handlebars.SafeString.prototype.toString = function() { + return this.string.toString(); + } + + Handlebars.helperMissing = function(object, fn) { + var ret = ""; + + if(object === true) { + return fn(this); + } else if(object === false) { + return ""; + } else if(Object.prototype.toString.call(object) === "[object Array]") { + for(var i=0, j=object.length; i\{\{title\}\}
+ //
+ // Hey, {{name}}! Welcome to Handlebars!
+ //
+ // The app:
+ //
+ // var $.app = $.sammy(function() {
+ // // include the plugin and alias handlebars() to hb()
+ // this.use(Sammy.Handlebars, 'hb');
+ //
+ // this.get('#/hello/:name', function() {
+ // // set local vars
+ // this.title = 'Hello!'
+ // this.name = this.params.name;
+ // // render the template and pass it through handlebars
+ // this.partial('mytemplate.hb');
+ // });
+ //
+ // });
+ //
+ // If I go to #/hello/AQ in the browser, Sammy will render this to the body:
+ //
+ // Hello!
+ //
+ // Hey, AQ! Welcome to Handlebars!
+ //
+ //
+ // ### Example #2 - Handlebars partials
+ //
+ // The template (mytemplate.hb)
+ //
+ // Hey, {{name}}! {{>hello_friend}}
+ //
+ //
+ // The partial (mypartial.hb)
+ //
+ // Say hello to your friend {{friend}}!
+ //
+ // The app:
+ //
+ // var $.app = $.sammy(function() {
+ // // include the plugin and alias handlebars() to hb()
+ // this.use(Sammy.Handlebars, 'hb');
+ //
+ // this.get('#/hello/:name/to/:friend', function() {
+ // var context = this;
+ //
+ // // fetch handlebars-partial first
+ // $.get('mypartial.hb', function(response){
+ // context.partials = response;
+ //
+ // // set local vars
+ // context.name = this.params.name;
+ // context.hello_friend = {name: this.params.friend};
+ //
+ // // render the template and pass it through handlebars
+ // context.partial('mytemplate.hb');
+ // });
+ // });
+ //
+ // });
+ //
+ // If I go to #/hello/AQ/to/dP in the browser, Sammy will render this to the body:
+ //
+ // Hey, AQ! Say hello to your friend dP!
+ //
+ // Note: You dont have to include the handlebars.js file on top of the plugin as the plugin
+ // includes the full source.
+ //
+ Sammy.Handlebars = function(app, method_alias) {
+
+ var handlebars_cache = {};
+ // *Helper* Uses handlebars.js to parse a template and interpolate and work with the passed data
+ //
+ // ### Arguments
+ //
+ // * `template` A String template.
+ // * `data` An Object containing the replacement values for the template.
+ // data is extended with the EventContext allowing you to call its methods within the template.
+ //
+ var handlebars = function(template, data, partials, name) {
+ // use name for caching
+ if (typeof name == 'undefined') name = template;
+ var fn = handlebars_cache[name];
+ if (!fn) {
+ fn = handlebars_cache[name] = Handlebars.compile(template);
+ }
+
+ data = $.extend({}, this, data);
+ partials = $.extend({}, data.partials, partials);
+
+ return fn(data, {"partials":partials});
+ };
+
+ // set the default method name/extension
+ if (!method_alias) method_alias = 'handlebars';
+ app.helper(method_alias, handlebars);
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.hoptoad.js b/public/javascripts/plugins/sammy.hoptoad.js
new file mode 100644
index 0000000..56cc155
--- /dev/null
+++ b/public/javascripts/plugins/sammy.hoptoad.js
@@ -0,0 +1,30 @@
+(function($) {
+
+ Sammy = Sammy || {};
+
+ // A plugin that posts errors to Hoptoad.
+ //
+ // ### Requirements
+ //
+ // The sole requirement is a Hoptoad object with a notify function.
+ // Thoughtbot have published an implementation (see below).
+ //
+ // ### Arguments
+ //
+ // Sammy.Hoptoad accepts an optional argument that is the
+ // Hoptoad implementation. It will default to the global `Hoptoad` object.
+ //
+ // ### See Also
+ // * http://hoptoadapp.com/
+ // * http://robots.thoughtbot.com/post/899737797
+ // * http://hoptoadapp.com/javascripts/notifier.js
+ Sammy.Hoptoad = function(app, errorReporter) {
+ errorReporter = errorReporter || window.Hoptoad;
+ app.bind('error', function(e, data) {
+ if (data && data.error) {
+ errorReporter.notify(data.error);
+ }
+ });
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.json.js b/public/javascripts/plugins/sammy.json.js
new file mode 100644
index 0000000..83b9dd0
--- /dev/null
+++ b/public/javascripts/plugins/sammy.json.js
@@ -0,0 +1,362 @@
+(function($) {
+
+ // json2.js - only included if native json does not exist
+ // http://www.json.org/js.html
+ if (!window.JSON) {
+ window.JSON = {};
+ }
+ (function () {
+
+ function f(n) {
+ // Format integers to have at least two digits.
+ return n < 10 ? '0' + n : n;
+ }
+
+ if (typeof Date.prototype.toJSON !== 'function') {
+
+ Date.prototype.toJSON = function (key) {
+
+ return this.getUTCFullYear() + '-' +
+ f(this.getUTCMonth() + 1) + '-' +
+ f(this.getUTCDate()) + 'T' +
+ f(this.getUTCHours()) + ':' +
+ f(this.getUTCMinutes()) + ':' +
+ f(this.getUTCSeconds()) + 'Z';
+ };
+
+ String.prototype.toJSON =
+ Number.prototype.toJSON =
+ Boolean.prototype.toJSON = function (key) {
+ return this.valueOf();
+ };
+ }
+
+ var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+ escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+ gap,
+ indent,
+ meta = { // table of character substitutions
+ '\b': '\\b',
+ '\t': '\\t',
+ '\n': '\\n',
+ '\f': '\\f',
+ '\r': '\\r',
+ '"' : '\\"',
+ '\\': '\\\\'
+ },
+ rep;
+
+
+ function quote(string) {
+
+ // If the string contains no control characters, no quote characters, and no
+ // backslash characters, then we can safely slap some quotes around it.
+ // Otherwise we must also replace the offending characters with safe escape
+ // sequences.
+
+ escapable.lastIndex = 0;
+ return escapable.test(string) ?
+ '"' + string.replace(escapable, function (a) {
+ var c = meta[a];
+ return typeof c === 'string' ? c :
+ '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ }) + '"' :
+ '"' + string + '"';
+ }
+
+
+ function str(key, holder) {
+
+ // Produce a string from holder[key].
+
+ var i, // The loop counter.
+ k, // The member key.
+ v, // The member value.
+ length,
+ mind = gap,
+ partial,
+ value = holder[key];
+
+ // If the value has a toJSON method, call it to obtain a replacement value.
+
+ if (value && typeof value === 'object' &&
+ typeof value.toJSON === 'function') {
+ value = value.toJSON(key);
+ }
+
+ // If we were called with a replacer function, then call the replacer to
+ // obtain a replacement value.
+
+ if (typeof rep === 'function') {
+ value = rep.call(holder, key, value);
+ }
+
+ // What happens next depends on the value's type.
+
+ switch (typeof value) {
+ case 'string':
+ return quote(value);
+
+ case 'number':
+
+ // JSON numbers must be finite. Encode non-finite numbers as null.
+
+ return isFinite(value) ? String(value) : 'null';
+
+ case 'boolean':
+ case 'null':
+
+ // If the value is a boolean or null, convert it to a string. Note:
+ // typeof null does not produce 'null'. The case is included here in
+ // the remote chance that this gets fixed someday.
+
+ return String(value);
+
+ // If the type is 'object', we might be dealing with an object or an array or
+ // null.
+
+ case 'object':
+
+ // Due to a specification blunder in ECMAScript, typeof null is 'object',
+ // so watch out for that case.
+
+ if (!value) {
+ return 'null';
+ }
+
+ // Make an array to hold the partial results of stringifying this object value.
+
+ gap += indent;
+ partial = [];
+
+ // Is the value an array?
+
+ if (Object.prototype.toString.apply(value) === '[object Array]') {
+
+ // The value is an array. Stringify every element. Use null as a placeholder
+ // for non-JSON values.
+
+ length = value.length;
+ for (i = 0; i < length; i += 1) {
+ partial[i] = str(i, value) || 'null';
+ }
+
+ // Join all of the elements together, separated with commas, and wrap them in
+ // brackets.
+
+ v = partial.length === 0 ? '[]' :
+ gap ? '[\n' + gap +
+ partial.join(',\n' + gap) + '\n' +
+ mind + ']' :
+ '[' + partial.join(',') + ']';
+ gap = mind;
+ return v;
+ }
+
+ // If the replacer is an array, use it to select the members to be stringified.
+
+ if (rep && typeof rep === 'object') {
+ length = rep.length;
+ for (i = 0; i < length; i += 1) {
+ k = rep[i];
+ if (typeof k === 'string') {
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ } else {
+
+ // Otherwise, iterate through all of the keys in the object.
+
+ for (k in value) {
+ if (Object.hasOwnProperty.call(value, k)) {
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ }
+
+ // Join all of the member texts together, separated with commas,
+ // and wrap them in braces.
+
+ v = partial.length === 0 ? '{}' :
+ gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' +
+ mind + '}' : '{' + partial.join(',') + '}';
+ gap = mind;
+ return v;
+ }
+ }
+
+ // If the JSON object does not yet have a stringify method, give it one.
+
+ if (typeof JSON.stringify !== 'function') {
+ JSON.stringify = function (value, replacer, space) {
+
+ // The stringify method takes a value and an optional replacer, and an optional
+ // space parameter, and returns a JSON text. The replacer can be a function
+ // that can replace values, or an array of strings that will select the keys.
+ // A default replacer method can be provided. Use of the space parameter can
+ // produce text that is more easily readable.
+
+ var i;
+ gap = '';
+ indent = '';
+
+ // If the space parameter is a number, make an indent string containing that
+ // many spaces.
+
+ if (typeof space === 'number') {
+ for (i = 0; i < space; i += 1) {
+ indent += ' ';
+ }
+
+ // If the space parameter is a string, it will be used as the indent string.
+
+ } else if (typeof space === 'string') {
+ indent = space;
+ }
+
+ // If there is a replacer, it must be a function or an array.
+ // Otherwise, throw an error.
+
+ rep = replacer;
+ if (replacer && typeof replacer !== 'function' &&
+ (typeof replacer !== 'object' ||
+ typeof replacer.length !== 'number')) {
+ throw new Error('JSON.stringify');
+ }
+
+ // Make a fake root object containing our value under the key of ''.
+ // Return the result of stringifying the value.
+
+ return str('', {'': value});
+ };
+ }
+
+
+ // If the JSON object does not yet have a parse method, give it one.
+
+ if (typeof JSON.parse !== 'function') {
+ JSON.parse = function (text, reviver) {
+
+ // The parse method takes a text and an optional reviver function, and returns
+ // a JavaScript value if the text is a valid JSON text.
+
+ var j;
+
+ function walk(holder, key) {
+
+ // The walk method is used to recursively walk the resulting structure so
+ // that modifications can be made.
+
+ var k, v, value = holder[key];
+ if (value && typeof value === 'object') {
+ for (k in value) {
+ if (Object.hasOwnProperty.call(value, k)) {
+ v = walk(value, k);
+ if (v !== undefined) {
+ value[k] = v;
+ } else {
+ delete value[k];
+ }
+ }
+ }
+ }
+ return reviver.call(holder, key, value);
+ }
+
+
+ // Parsing happens in four stages. In the first stage, we replace certain
+ // Unicode characters with escape sequences. JavaScript handles many characters
+ // incorrectly, either silently deleting them, or treating them as line endings.
+
+ cx.lastIndex = 0;
+ if (cx.test(text)) {
+ text = text.replace(cx, function (a) {
+ return '\\u' +
+ ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ });
+ }
+
+ // In the second stage, we run the text against regular expressions that look
+ // for non-JSON patterns. We are especially concerned with '()' and 'new'
+ // because they can cause invocation, and '=' because it can cause mutation.
+ // But just to be safe, we want to reject all unexpected forms.
+
+ // We split the second stage into 4 regexp operations in order to work around
+ // crippling inefficiencies in IE's and Safari's regexp engines. First we
+ // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
+ // replace all simple value tokens with ']' characters. Third, we delete all
+ // open brackets that follow a colon or comma or that begin the text. Finally,
+ // we look to see that the remaining characters are only whitespace or ']' or
+ // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
+
+ if (/^[\],:{}\s]*$/.
+ test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@').
+ replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
+ replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+
+ // In the third stage we use the eval function to compile the text into a
+ // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
+ // in JavaScript: it can begin a block or an object literal. We wrap the text
+ // in parens to eliminate the ambiguity.
+
+ j = eval('(' + text + ')');
+
+ // In the optional fourth stage, we recursively walk the new structure, passing
+ // each name/value pair to a reviver function for possible transformation.
+
+ return typeof reviver === 'function' ?
+ walk({'': j}, '') : j;
+ }
+
+ // If the text is not JSON parseable, then a SyntaxError is thrown.
+
+ throw new SyntaxError('JSON.parse');
+ };
+ }
+ }());
+
+ Sammy = Sammy || {};
+
+ // Sammy.JSON is a simple wrapper around Douglas Crockford's ever-useful json2.js
+ // (http://www.json.org/js.html]) Sammy.JSON includes the top level JSON object if
+ // it doesn't already exist (a.k.a. does not override the native implementation that
+ // some browsers include). It also adds a json() helper to a Sammy app when
+ // included.
+ Sammy.JSON = function(app) {
+
+ app.helpers({
+ // json is a polymorphic function that translates objects aback and forth
+ // from JSON to JS. If given a string, it will parse into JS, if given a JS
+ // object it will stringify into JSON.
+ //
+ // ### Example
+ //
+ // var app = $.sammy(function() {
+ // this.use(Sammy.JSON);
+ //
+ // this.get('#/', function() {
+ // this.json({user_id: 123}); //=> "{\"user_id\":\"123\"}"
+ // this.json("{\"user_id\":\"123\"}"); //=> [object Object]
+ // this.json("{\"user_id\":\"123\"}").user_id; //=> "123"
+ // });
+ // })
+ //
+ //
+ json: function(object) {
+ if (typeof object == 'string') {
+ return JSON.parse(object);
+ } else {
+ return JSON.stringify(object);
+ }
+ }
+ });
+
+ }
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.meld.js b/public/javascripts/plugins/sammy.meld.js
new file mode 100644
index 0000000..91a33c3
--- /dev/null
+++ b/public/javascripts/plugins/sammy.meld.js
@@ -0,0 +1,140 @@
+(function($) {
+
+ Sammy = Sammy || {};
+
+ // `Sammy.Meld` is a simple templating engine that uses the power of jQuery's
+ // DOM manipulation to easily meld JSON data and HTML templates very quickly.
+ //
+ // The template can either be a string (i.e. loaded from a remote template)
+ // or a DOM Element/jQuery object. This allows you to have templates be DOM
+ // elements as the initial document load.
+ //
+ // ### Example
+ //
+ // The simplest case is a nested `` whose class name is tied to a
+ // property of a JS object.
+ //
+ // Template:
+ //
+ //
+ //
+ //
+ //
+ //
+ //
+ // Data:
+ //
+ // {
+ // "post": {
+ // "title": "My Post",
+ // "entry": "My Entry",
+ // "author": {
+ // "name": "@aq"
+ // }
+ // }
+ // }
+ //
+ // Result:
+ //
+ //
+ // My Post
+ // My Entry
+ //
+ //
+ //
+ // Templates can be much more complex, and more deeply nested.
+ // More examples can be found in `test/fixtures/meld/`
+ //
+ // If you don't think the lookup by classes is semantic for you, you can easily
+ // switch the method of lookup by defining a selector function in the options
+ //
+ // For example:
+ //
+ // meld($('.post'), post_data, {
+ // selector: function(k) {
+ // return '[data-key=' + k + ']';
+ // }
+ // });
+ //
+ // Would look for template nodes like ``
+ //
+ Sammy.Meld = function(app, method_alias) {
+ var default_options = {
+ selector: function(k) { return '.' + k; },
+ remove_false: true
+ };
+
+ var meld = function(template, data, options) {
+ var $template = $(template);
+
+ options = $.extend(default_options, options || {});
+
+ if (typeof data === 'string') {
+ $template.html(data);
+ } else {
+ $.each(data, function(key, value) {
+ var selector = options.selector(key),
+ $sub = $template.filter(selector),
+ $container,
+ $item,
+ is_list = false,
+ subindex = $template.index($sub);
+
+ if ($sub.length === 0) { $sub = $template.find(selector); }
+ if ($sub.length > 0) {
+ if ($.isArray(value)) {
+ $container = $('');
+ if ($sub.is('ol, ul')) {
+ is_list = true;
+ $item = $sub.children('li:first');
+ if ($item.length == 0) { $item = $(''); }
+ } else if ($sub.children().length == 1) {
+ is_list = true;
+ $item = $sub.children(':first').clone();
+ } else {
+ $item = $sub.clone();
+ }
+ for (var i = 0; i < value.length; i++) {
+ $container.append(meld($item.clone(), value[i], options));
+ }
+ if (is_list) {
+ $sub.html($container.html());
+ } else if ($sub[0] == $template[0]) {
+ $template = $($container.html());
+ } else if (subindex >= 0) {
+ var args = [subindex, 1];
+ args = args.concat($container.children().get());
+ $template.splice.apply($template, args);
+ }
+ } else if (options.remove_false && value === false) {
+ $template.splice(subindex, 1);
+ } else if (typeof value === 'object') {
+ if ($sub.is(':empty')) {
+ $sub.attr(value, true);
+ } else {
+ $sub.html(meld($sub.html(), value, options));
+ }
+ } else {
+ $sub.html(value.toString());
+ }
+ } else {
+ $template.attr(key, value, true);
+ }
+ });
+ }
+ var dom = $template;
+ return dom;
+ };
+
+ // set the default method name/extension
+ if (!method_alias) method_alias = 'meld';
+ // create the helper at the method alias
+ app.helper(method_alias, meld);
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.mustache.js b/public/javascripts/plugins/sammy.mustache.js
new file mode 100644
index 0000000..169f0c7
--- /dev/null
+++ b/public/javascripts/plugins/sammy.mustache.js
@@ -0,0 +1,444 @@
+(function($) {
+
+if (!window.Mustache) {
+
+ /*
+ mustache.js — Logic-less templates in JavaScript
+
+ See http://mustache.github.com/ for more info.
+ */
+
+ var Mustache = function() {
+ var Renderer = function() {};
+
+ Renderer.prototype = {
+ otag: "{{",
+ ctag: "}}",
+ pragmas: {},
+ buffer: [],
+ pragmas_implemented: {
+ "IMPLICIT-ITERATOR": true
+ },
+ context: {},
+
+ render: function(template, context, partials, in_recursion) {
+ // reset buffer & set context
+ if(!in_recursion) {
+ this.context = context;
+ this.buffer = []; // TODO: make this non-lazy
+ }
+
+ // fail fast
+ if(!this.includes("", template)) {
+ if(in_recursion) {
+ return template;
+ } else {
+ this.send(template);
+ return;
+ }
+ }
+
+ template = this.render_pragmas(template);
+ var html = this.render_section(template, context, partials);
+ if(in_recursion) {
+ return this.render_tags(html, context, partials, in_recursion);
+ }
+
+ this.render_tags(html, context, partials, in_recursion);
+ },
+
+ /*
+ Sends parsed lines
+ */
+ send: function(line) {
+ if(line != "") {
+ this.buffer.push(line);
+ }
+ },
+
+ /*
+ Looks for %PRAGMAS
+ */
+ render_pragmas: function(template) {
+ // no pragmas
+ if(!this.includes("%", template)) {
+ return template;
+ }
+
+ var that = this;
+ var regex = new RegExp(this.otag + "%([\\w-]+) ?([\\w]+=[\\w]+)?" +
+ this.ctag);
+ return template.replace(regex, function(match, pragma, options) {
+ if(!that.pragmas_implemented[pragma]) {
+ throw({message:
+ "This implementation of mustache doesn't understand the '" +
+ pragma + "' pragma"});
+ }
+ that.pragmas[pragma] = {};
+ if(options) {
+ var opts = options.split("=");
+ that.pragmas[pragma][opts[0]] = opts[1];
+ }
+ return "";
+ // ignore unknown pragmas silently
+ });
+ },
+
+ /*
+ Tries to find a partial in the curent scope and render it
+ */
+ render_partial: function(name, context, partials) {
+ name = this.trim(name);
+ if(!partials || partials[name] === undefined) {
+ throw({message: "unknown_partial '" + name + "'"});
+ }
+ if(typeof(context[name]) != "object") {
+ return this.render(partials[name], context, partials, true);
+ }
+ return this.render(partials[name], context[name], partials, true);
+ },
+
+ /*
+ Renders inverted (^) and normal (#) sections
+ */
+ render_section: function(template, context, partials) {
+ if(!this.includes("#", template) && !this.includes("^", template)) {
+ return template;
+ }
+
+ var that = this;
+ // CSW - Added "+?" so it finds the tighest bound, not the widest
+ var regex = new RegExp(this.otag + "(\\^|\\#)\\s*(.+)\\s*" + this.ctag +
+ "\n*([\\s\\S]+?)" + this.otag + "\\/\\s*\\2\\s*" + this.ctag +
+ "\\s*", "mg");
+
+ // for each {{#foo}}{{/foo}} section do...
+ return template.replace(regex, function(match, type, name, content) {
+ var value = that.find(name, context);
+ if(type == "^") { // inverted section
+ if(!value || that.is_array(value) && value.length === 0) {
+ // false or empty list, render it
+ return that.render(content, context, partials, true);
+ } else {
+ return "";
+ }
+ } else if(type == "#") { // normal section
+ if(that.is_array(value)) { // Enumerable, Let's loop!
+ return that.map(value, function(row) {
+ return that.render(content, that.create_context(row),
+ partials, true);
+ }).join("");
+ } else if(that.is_object(value)) { // Object, Use it as subcontext!
+ return that.render(content, that.create_context(value),
+ partials, true);
+ } else if(typeof value === "function") {
+ // higher order section
+ return value.call(context, content, function(text) {
+ return that.render(text, context, partials, true);
+ });
+ } else if(value) { // boolean section
+ return that.render(content, context, partials, true);
+ } else {
+ return "";
+ }
+ }
+ });
+ },
+
+ /*
+ Replace {{foo}} and friends with values from our view
+ */
+ render_tags: function(template, context, partials, in_recursion) {
+ // tit for tat
+ var that = this;
+
+ var new_regex = function() {
+ return new RegExp(that.otag + "(=|!|>|\\{|%)?([^\\/#\\^]+?)\\1?" +
+ that.ctag + "+", "g");
+ };
+
+ var regex = new_regex();
+ var tag_replace_callback = function(match, operator, name) {
+ switch(operator) {
+ case "!": // ignore comments
+ return "";
+ case "=": // set new delimiters, rebuild the replace regexp
+ that.set_delimiters(name);
+ regex = new_regex();
+ return "";
+ case ">": // render partial
+ return that.render_partial(name, context, partials);
+ case "{": // the triple mustache is unescaped
+ return that.find(name, context);
+ default: // escape the value
+ return that.escape(that.find(name, context));
+ }
+ };
+ var lines = template.split("\n");
+ for(var i = 0; i < lines.length; i++) {
+ lines[i] = lines[i].replace(regex, tag_replace_callback, this);
+ if(!in_recursion) {
+ this.send(lines[i]);
+ }
+ }
+
+ if(in_recursion) {
+ return lines.join("\n");
+ }
+ },
+
+ set_delimiters: function(delimiters) {
+ var dels = delimiters.split(" ");
+ this.otag = this.escape_regex(dels[0]);
+ this.ctag = this.escape_regex(dels[1]);
+ },
+
+ escape_regex: function(text) {
+ // thank you Simon Willison
+ if(!arguments.callee.sRE) {
+ var specials = [
+ '/', '.', '*', '+', '?', '|',
+ '(', ')', '[', ']', '{', '}', '\\'
+ ];
+ arguments.callee.sRE = new RegExp(
+ '(\\' + specials.join('|\\') + ')', 'g'
+ );
+ }
+ return text.replace(arguments.callee.sRE, '\\$1');
+ },
+
+ /*
+ find `name` in current `context`. That is find me a value
+ from the view object
+ */
+ find: function(name, context) {
+ name = this.trim(name);
+
+ // Checks whether a value is thruthy or false or 0
+ function is_kinda_truthy(bool) {
+ return bool === false || bool === 0 || bool;
+ }
+
+ var value;
+ if(is_kinda_truthy(context[name])) {
+ value = context[name];
+ } else if(is_kinda_truthy(this.context[name])) {
+ value = this.context[name];
+ }
+
+ if(typeof value === "function") {
+ return value.apply(context);
+ }
+ if(value !== undefined) {
+ return value;
+ }
+ // silently ignore unkown variables
+ return "";
+ },
+
+ // Utility methods
+
+ /* includes tag */
+ includes: function(needle, haystack) {
+ return haystack.indexOf(this.otag + needle) != -1;
+ },
+
+ /*
+ Does away with nasty characters
+ */
+ escape: function(s) {
+ s = String(s === null ? "" : s);
+ return s.replace(/&(?!\w+;)|["<>\\]/g, function(s) {
+ switch(s) {
+ case "&": return "&";
+ case "\\": return "\\\\";
+ case '"': return '\"';
+ case "<": return "<";
+ case ">": return ">";
+ default: return s;
+ }
+ });
+ },
+
+ // by @langalex, support for arrays of strings
+ create_context: function(_context) {
+ if(this.is_object(_context)) {
+ return _context;
+ } else {
+ var iterator = ".";
+ if(this.pragmas["IMPLICIT-ITERATOR"]) {
+ iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator;
+ }
+ var ctx = {};
+ ctx[iterator] = _context;
+ return ctx;
+ }
+ },
+
+ is_object: function(a) {
+ return a && typeof a == "object";
+ },
+
+ is_array: function(a) {
+ return Object.prototype.toString.call(a) === '[object Array]';
+ },
+
+ /*
+ Gets rid of leading and trailing whitespace
+ */
+ trim: function(s) {
+ return s.replace(/^\s*|\s*$/g, "");
+ },
+
+ /*
+ Why, why, why? Because IE. Cry, cry cry.
+ */
+ map: function(array, fn) {
+ if (typeof array.map == "function") {
+ return array.map(fn);
+ } else {
+ var r = [];
+ var l = array.length;
+ for(var i = 0; i < l; i++) {
+ r.push(fn(array[i]));
+ }
+ return r;
+ }
+ }
+ };
+
+ return({
+ name: "mustache.js",
+ version: "0.3.1-dev",
+
+ /*
+ Turns a template and view into HTML
+ */
+ to_html: function(template, view, partials, send_fun) {
+ var renderer = new Renderer();
+ if(send_fun) {
+ renderer.send = send_fun;
+ }
+ renderer.render(template, view, partials);
+ if(!send_fun) {
+ return renderer.buffer.join("\n");
+ }
+ }
+ });
+ }();
+
+} // Ensure Mustache
+
+ Sammy = Sammy || {};
+
+ // Sammy.Mustache provides a quick way of using mustache style templates in your app.
+ // The plugin itself includes the awesome mustache.js lib created and maintained by Jan Lehnardt
+ // at http://github.com/janl/mustache.js
+ //
+ // Mustache is a clever templating system that relys on double brackets {{}} for interpolation.
+ // For full details on syntax check out the original Ruby implementation created by Chris Wanstrath at
+ // http://github.com/defunkt/mustache
+ //
+ // By default using Sammy.Mustache in your app adds the mustache() method to the EventContext
+ // prototype. However, just like Sammy.Template you can change the default name of the method
+ // by passing a second argument (e.g. you could use the ms() as the method alias so that all the template
+ // files could be in the form file.ms instead of file.mustache)
+ //
+ // ### Example #1
+ //
+ // The template (mytemplate.ms):
+ //
+ // \{\{title\}\}
+ //
+ // Hey, {{name}}! Welcome to Mustache!
+ //
+ // The app:
+ //
+ // var $.app = $.sammy(function() {
+ // // include the plugin and alias mustache() to ms()
+ // this.use(Sammy.Mustache, 'ms');
+ //
+ // this.get('#/hello/:name', function() {
+ // // set local vars
+ // this.title = 'Hello!'
+ // this.name = this.params.name;
+ // // render the template and pass it through mustache
+ // this.partial('mytemplate.ms');
+ // });
+ //
+ // });
+ //
+ // If I go to #/hello/AQ in the browser, Sammy will render this to the body:
+ //
+ // Hello!
+ //
+ // Hey, AQ! Welcome to Mustache!
+ //
+ //
+ // ### Example #2 - Mustache partials
+ //
+ // The template (mytemplate.ms)
+ //
+ // Hey, {{name}}! {{>hello_friend}}
+ //
+ //
+ // The partial (mypartial.ms)
+ //
+ // Say hello to your friend {{friend}}!
+ //
+ // The app:
+ //
+ // var $.app = $.sammy(function() {
+ // // include the plugin and alias mustache() to ms()
+ // this.use(Sammy.Mustache, 'ms');
+ //
+ // this.get('#/hello/:name/to/:friend', function() {
+ // var context = this;
+ //
+ // // fetch mustache-partial first
+ // $.get('mypartial.ms', function(response){
+ // context.partials = response;
+ //
+ // // set local vars
+ // context.name = this.params.name;
+ // context.hello_friend = {name: this.params.friend};
+ //
+ // // render the template and pass it through mustache
+ // context.partial('mytemplate.ms');
+ // });
+ // });
+ //
+ // });
+ //
+ // If I go to #/hello/AQ/to/dP in the browser, Sammy will render this to the body:
+ //
+ // Hey, AQ! Say hello to your friend dP!
+ //
+ // Note: You dont have to include the mustache.js file on top of the plugin as the plugin
+ // includes the full source.
+ //
+ Sammy.Mustache = function(app, method_alias) {
+
+ // *Helper* Uses Mustache.js to parse a template and interpolate and work with the passed data
+ //
+ // ### Arguments
+ //
+ // * `template` A String template. {{}} Tags are evaluated and interpolated by Mustache.js
+ // * `data` An Object containing the replacement values for the template.
+ // data is extended with the EventContext allowing you to call its methods within the template.
+ // * `partials` An Object containing one or more partials (String templates
+ // that are called from the main template).
+ //
+ var mustache = function(template, data, partials) {
+ data = $.extend({}, this, data);
+ partials = $.extend({}, data.partials, partials);
+ return Mustache.to_html(template, data, partials);
+ };
+
+ // set the default method name/extension
+ if (!method_alias) method_alias = 'mustache';
+ app.helper(method_alias, mustache);
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.nested_params.js b/public/javascripts/plugins/sammy.nested_params.js
new file mode 100644
index 0000000..645f8c9
--- /dev/null
+++ b/public/javascripts/plugins/sammy.nested_params.js
@@ -0,0 +1,118 @@
+(function($) {
+
+ Sammy = Sammy || {};
+
+ function parseValue(value) {
+ value = unescape(value);
+ if (value === "true") {
+ return true;
+ } else if (value === "false") {
+ return false;
+ } else {
+ return value;
+ }
+ };
+
+ function parseNestedParam(params, field_name, field_value) {
+ var match, name, rest;
+
+ if (field_name.match(/^[^\[]+$/)) {
+ // basic value
+ params[field_name] = parseValue(field_value);
+ } else if (match = field_name.match(/^([^\[]+)\[\](.*)$/)) {
+ // array
+ name = match[1];
+ rest = match[2];
+
+ if(params[name] && !$.isArray(params[name])) { throw('400 Bad Request'); }
+
+ if (rest) {
+ // array is not at the end of the parameter string
+ match = rest.match(/^\[([^\]]+)\](.*)$/);
+ if(!match) { throw('400 Bad Request'); }
+
+ if (params[name]) {
+ if(params[name][params[name].length - 1][match[1]]) {
+ params[name].push(parseNestedParam({}, match[1] + match[2], field_value));
+ } else {
+ $.extend(true, params[name][params[name].length - 1], parseNestedParam({}, match[1] + match[2], field_value));
+ }
+ } else {
+ params[name] = [parseNestedParam({}, match[1] + match[2], field_value)];
+ }
+ } else {
+ // array is at the end of the parameter string
+ if (params[name]) {
+ params[name].push(parseValue(field_value));
+ } else {
+ params[name] = [parseValue(field_value)];
+ }
+ }
+ } else if (match = field_name.match(/^([^\[]+)\[([^\[]+)\](.*)$/)) {
+ // hash
+ name = match[1];
+ rest = match[2] + match[3];
+
+ if (params[name] && $.isArray(params[name])) { throw('400 Bad Request'); }
+
+ if (params[name]) {
+ $.extend(true, params[name], parseNestedParam(params[name], rest, field_value));
+ } else {
+ params[name] = parseNestedParam({}, rest, field_value);
+ }
+ }
+ return params;
+ };
+
+ // Sammy.NestedParams overrides the default form parsing behavior to provide
+ // extended functionality for parsing Rack/Rails style form name/value pairs into JS
+ // Objects. In fact it passes the same suite of tests as Rack's nested query parsing.
+ // The code and tests were ported to JavaScript/Sammy by http://github.com/endor
+ //
+ // This allows you to translate a form with properly named inputs into a JSON object.
+ //
+ // ### Example
+ //
+ // Given an HTML form like so:
+ //
+ //
+ //
+ // And a Sammy app like:
+ //
+ // var app = $.sammy(function(app) {
+ // this.use(Sammy.NestedParams);
+ //
+ // this.post('#/parse_me', function(context) {
+ // $.log(this.params);
+ // });
+ // });
+ //
+ // If you filled out the form with some values and submitted it, you would see something
+ // like this in your log:
+ //
+ // {
+ // 'obj': {
+ // 'first': 'value',
+ // 'second': 'value',
+ // 'hash': {
+ // 'first': 'value',
+ // 'second': 'value'
+ // }
+ // }
+ // }
+ //
+ // It supports creating arrays with [] and other niceities. Check out the tests for
+ // full specs.
+ //
+ Sammy.NestedParams = function(app) {
+
+ app._parseParamPair = parseNestedParam;
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.oauth2.js b/public/javascripts/plugins/sammy.oauth2.js
new file mode 100644
index 0000000..6d0fab2
--- /dev/null
+++ b/public/javascripts/plugins/sammy.oauth2.js
@@ -0,0 +1,144 @@
+(function($) {
+ Sammy = Sammy || {};
+
+ // Sammy.OAuth2 is a plugin for using OAuth 2.0 to authenticate users and
+ // access your application's API. Requires Sammy.Session.
+ //
+ // Triggers the following events:
+ //
+ // * `oauth.connected` - Access token set and ready to use. Triggered when new
+ // access token acquired, of when application starts and already has access
+ // token.
+ // * `oauth.disconnected` - Access token reset. Triggered by
+ // loseAccessToken().
+ // * `oauth.denied` - Authorization attempt rejected.
+ //
+ // ### Example
+ //
+ // this.use('Storage');
+ // this.use('OAuth2');
+ // this.oauthorize = "/oauth/authorize";
+ //
+ // // The quick & easy way
+ // this.requireOAuth();
+ // // Specific path
+ // this.requireOAuth("/private");
+ // // Filter you can apply to specific URLs
+ // this.before(function(context) { return context.requireOAuth(); })
+ // // Apply to specific request
+ // this.get("/private", function(context) {
+ // this.requireOAuth(function() {
+ // // Do something
+ // });
+ // });
+ //
+ // // Sign in/sign out.
+ // this.bind("oauth.connected", function() { $("#signin").hide() });
+ // this.bind("oauth.disconnected", function() { $("#signin").show() });
+ //
+ // // Handle access denied and other errors
+ // this.bind("oauth.denied", function(evt, error) {
+ // this.partial("admin/views/no_access.tmpl", { error: error.message });
+ // });
+ //
+ // // Sign out.
+ // this.get("#/signout", function(context) {
+ // context.loseAccessToken();
+ // context.redirect("#/");
+ // });
+ //
+ Sammy.OAuth2 = function(app) {
+ app.use('JSON');
+ this.authorize = "/oauth/authorize";
+
+ // Use this on request that require OAuth token. You can use this in a
+ // filter: it will redirect and return false if the access token is missing.
+ // You can use it in a route, it will redirect to get the access token, or
+ // call the callback function if it has an access token.
+ this.helper("requireOAuth", function(cb) {
+ if (this.app.getAccessToken()) {
+ if (cb)
+ cb.apply(this);
+ } else {
+ this.redirect(this.app.authorize + "?state=" + escape(this.path));
+ return false;
+ }
+ });
+
+ // Use this to sign out.
+ this.helper("loseAccessToken", function() {
+ this.app.loseAccessToken();
+ });
+
+ // Use this in your application to require an OAuth access token on all, or
+ // the specified paths. It sets up a before filter on the specified paths.
+ this.requireOAuth = function(options) {
+ this.before(options || {}, function(context) {
+ return context.requireOAuth();
+ });
+ }
+
+ // Returns the access token. Uses Sammy.Session to store the token.
+ this.getAccessToken = function() {
+ return this.session("oauth.token");
+ }
+ // Stores the access token in the session.
+ this.setAccessToken = function(token) {
+ this.session("oauth.token", token);
+ this.trigger("oauth.connected");
+ }
+ // Lose access token: use this to sign out.
+ this.loseAccessToken = function() {
+ this.session("oauth.token", null);
+ this.trigger("oauth.disconnected");
+ }
+
+ // Add OAuth 2.0 access token to all XHR requests.
+ $(document).ajaxSend(function(evt, xhr) {
+ var token = app.getAccessToken();
+ if (token)
+ xhr.setRequestHeader("Authorization", "OAuth " + token);
+ });
+
+ // Converts query string parameters in fragment identifier to object.
+ function parseParams(hash) {
+ var pairs = hash.substring(1).split("&"), params = {};
+ for (var i in pairs) {
+ var splat = pairs[i].split("=");
+ params[splat[0]] = splat[1].replace(/\+/g, " ");
+ }
+ return params;
+ }
+
+ var start_url;
+ // Capture the application's start URL, we'll need that later on for
+ // redirection.
+ this.bind("run", function(evt, params) {
+ start_url = params.start_url || "#";
+ if (this.app.getAccessToken())
+ this.trigger("oauth.connected");
+ });
+
+ // Intercept OAuth authorization response with access token, stores it and
+ // redirects to original URL, or application root.
+ this.before(/^#(access_token=|[^\\].*\&access_token=)/, function(context) {
+ var params = parseParams(context.path);
+ this.app.setAccessToken(params.access_token);
+ // When the filter redirected the original request, it passed the original
+ // request's URL in the state parameter, which we get back after
+ // authorization.
+ context.redirect(params.state.length == 0 ? this.app.start_url : unescape(params.state));
+ return false;
+ }).get(/^#(access_token=|[^\\].*\&access_token=)/, function(context) { });
+
+ // Intercept OAuth authorization response with error (typically access
+ // denied).
+ this.before(/^#(error=|[^\\].*\&error=)/, function(context) {
+ var params = parseParams(context.path);
+ var message = params.error_description || "Access denined";
+ context.trigger("oauth.denied", { code: params.error, message: message });
+ return false;
+ }).get(/^#(error=|[^\\].*\&error=)/, function(context) { });
+
+ }
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.path_location_proxy.js b/public/javascripts/plugins/sammy.path_location_proxy.js
new file mode 100644
index 0000000..13f9014
--- /dev/null
+++ b/public/javascripts/plugins/sammy.path_location_proxy.js
@@ -0,0 +1,29 @@
+(function($) {
+
+ Sammy = Sammy || {};
+
+ // `Sammy.PathLocationProxy` is a simple Location Proxy that just
+ // gets and sets window.location. This allows you to use
+ // Sammy to route on the full URL path instead of just the hash. It
+ // will take a full refresh to get the app to change state.
+ //
+ // To read more about location proxies, check out the
+ // documentation for `Sammy.HashLocationProxy`
+ Sammy.PathLocationProxy = function(app) {
+ this.app = app;
+ };
+
+ Sammy.PathLocationProxy.prototype = {
+ bind: function() {},
+ unbind: function() {},
+
+ getLocation: function() {
+ return [window.location.pathname, window.location.search].join('');
+ },
+
+ setLocation: function(new_location) {
+ return window.location = new_location;
+ }
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.pure.js b/public/javascripts/plugins/sammy.pure.js
new file mode 100644
index 0000000..16fe3df
--- /dev/null
+++ b/public/javascripts/plugins/sammy.pure.js
@@ -0,0 +1,756 @@
+(function($) {
+
+/*!
+ PURE Unobtrusive Rendering Engine for HTML
+
+ Licensed under the MIT licenses.
+ More information at: http://www.opensource.org
+
+ Copyright (c) 2010 Michael Cvilic - BeeBole.com
+
+ Thanks to Rog Peppe for the functional JS jump
+ revision: 2.47
+*/
+
+var $p, pure = $p = function(){
+ var sel = arguments[0],
+ ctxt = false;
+
+ if(typeof sel === 'string'){
+ ctxt = arguments[1] || false;
+ }
+ return $p.core(sel, ctxt);
+};
+
+$p.core = function(sel, ctxt, plugins){
+ //get an instance of the plugins
+ var plugins = getPlugins(),
+ templates = [];
+
+ //search for the template node(s)
+ switch(typeof sel){
+ case 'string':
+ templates = plugins.find(ctxt || document, sel);
+ if(templates.length === 0) {
+ error('The template "' + sel + '" was not found');
+ }
+ break;
+ case 'undefined':
+ error('The template root is undefined, check your selector');
+ break;
+ default:
+ templates = [sel];
+ }
+
+ for(var i = 0, ii = templates.length; i < ii; i++){
+ plugins[i] = templates[i];
+ }
+ plugins.length = ii;
+
+ // set the signature string that will be replaced at render time
+ var Sig = '_s' + Math.floor( Math.random() * 1000000 ) + '_',
+ // another signature to prepend to attributes and avoid checks: style, height, on[events]...
+ attPfx = '_a' + Math.floor( Math.random() * 1000000 ) + '_',
+ // rx to parse selectors, e.g. "+tr.foo[class]"
+ selRx = /^(\+)?([^\@\+]+)?\@?([^\+]+)?(\+)?$/,
+ // set automatically attributes for some tags
+ autoAttr = {
+ IMG:'src',
+ INPUT:'value'
+ },
+ // check if the argument is an array - thanks salty-horse (Ori Avtalion)
+ isArray = Array.isArray ?
+ function(o) {
+ return Array.isArray(o);
+ } :
+ function(o) {
+ return Object.prototype.toString.call(o) === "[object Array]";
+ };
+
+ return plugins;
+
+
+ /* * * * * * * * * * * * * * * * * * * * * * * * * *
+ core functions
+ * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+
+ // error utility
+ function error(e){
+ if(typeof console !== 'undefined'){
+ console.log(e);
+ }else{ alert(e); }
+ throw('pure error: ' + e);
+ }
+
+ //return a new instance of plugins
+ function getPlugins(){
+ var plugins = $p.plugins,
+ f = function(){};
+ f.prototype = plugins;
+
+ // do not overwrite functions if external definition
+ f.prototype.compile = plugins.compile || compile;
+ f.prototype.render = plugins.render || render;
+ f.prototype.autoRender = plugins.autoRender || autoRender;
+ f.prototype.find = plugins.find || find;
+
+ // give the compiler and the error handling to the plugin context
+ f.prototype._compiler = compiler;
+ f.prototype._error = error;
+
+ return new f();
+ }
+
+ // returns the outer HTML of a node
+ function outerHTML(node){
+ // if IE take the internal method otherwise build one
+ return node.outerHTML || (
+ function(n){
+ var div = document.createElement('div'), h;
+ div.appendChild( n.cloneNode(true) );
+ h = div.innerHTML;
+ div = null;
+ return h;
+ })(node);
+ }
+
+ // returns the string generator function
+ function wrapquote(qfn, f){
+ return function(ctxt){
+ return qfn('' + f.call(ctxt.context, ctxt));
+ };
+ }
+
+ // default find using querySelector when available on the browser
+ function find(n, sel){
+ if(typeof n === 'string'){
+ sel = n;
+ n = false;
+ }
+ if(typeof document.querySelectorAll !== 'undefined'){
+ return (n||document).querySelectorAll( sel );
+ }else{
+ error('You can test PURE standalone with: iPhone, FF3.5+, Safari4+ and IE8+\n\nTo run PURE on your browser, you need a JS library/framework with a CSS selector engine');
+ }
+ }
+
+ // create a function that concatenates constant string
+ // sections (given in parts) and the results of called
+ // functions to fill in the gaps between parts (fns).
+ // fns[n] fills in the gap between parts[n-1] and parts[n];
+ // fns[0] is unused.
+ // this is the inner template evaluation loop.
+ function concatenator(parts, fns){
+ return function(ctxt){
+ var strs = [ parts[ 0 ] ],
+ n = parts.length,
+ fnVal, pVal, attLine, pos;
+
+ for(var i = 1; i < n; i++){
+ fnVal = fns[i]( ctxt );
+ pVal = parts[i];
+
+ // if the value is empty and attribute, remove it
+ if(fnVal === ''){
+ attLine = strs[ strs.length - 1 ];
+ if( ( pos = attLine.search( /[\w]+=\"?$/ ) ) > -1){
+ strs[ strs.length - 1 ] = attLine.substring( 0, pos );
+ pVal = pVal.substr( 1 );
+ }
+ }
+
+ strs[ strs.length ] = fnVal;
+ strs[ strs.length ] = pVal;
+ }
+ return strs.join('');
+ };
+ }
+
+ // parse and check the loop directive
+ function parseloopspec(p){
+ var m = p.match( /^(\w+)\s*<-\s*(\S+)?$/ );
+ if(m === null){
+ error('bad loop spec: "' + p + '"');
+ }
+ if(m[1] === 'item'){
+ error('"item<-..." is a reserved word for the current running iteration.\n\nPlease choose another name for your loop.');
+ }
+ if( !m[2] || (m[2] && (/context/i).test(m[2]))){ //undefined or space(IE)
+ m[2] = function(ctxt){return ctxt.context;};
+ }
+ return {name: m[1], sel: m[2]};
+ }
+
+ // parse a data selector and return a function that
+ // can traverse the data accordingly, given a context.
+ function dataselectfn(sel){
+ if(typeof(sel) === 'function'){
+ return sel;
+ }
+ //check for a valid js variable name with hyphen(for properties only), $, _ and :
+ var m = sel.match(/^[a-zA-Z\$_\@][\w\$:-]*(\.[\w\$:-]*[^\.])*$/);
+ if(m === null){
+ var found = false, s = sel, parts = [], pfns = [], i = 0, retStr;
+ // check if literal
+ if(/\'|\"/.test( s.charAt(0) )){
+ if(/\'|\"/.test( s.charAt(s.length-1) )){
+ retStr = s.substring(1, s.length-1);
+ return function(){ return retStr; };
+ }
+ }else{
+ // check if literal + #{var}
+ while((m = s.match(/#\{([^{}]+)\}/)) !== null){
+ found = true;
+ parts[i++] = s.slice(0, m.index);
+ pfns[i] = dataselectfn(m[1]);
+ s = s.slice(m.index + m[0].length, s.length);
+ }
+ }
+ if(!found){
+ error('bad data selector syntax: ' + sel);
+ }
+ parts[i] = s;
+ return concatenator(parts, pfns);
+ }
+ m = sel.split('.');
+ return function(ctxt){
+ var data = ctxt.context;
+ if(!data){
+ return '';
+ }
+ var v = ctxt[m[0]],
+ i = 0;
+ if(v && v.item){
+ data = v.item;
+ i += 1;
+ }
+ var n = m.length;
+ for(; i < n; i++){
+ if(!data){break;}
+ data = data[m[i]];
+ }
+ return (!data && data !== 0) ? '':data;
+ };
+ }
+
+ // wrap in an object the target node/attr and their properties
+ function gettarget(dom, sel, isloop){
+ var osel, prepend, selector, attr, append, target = [];
+ if( typeof sel === 'string' ){
+ osel = sel;
+ var m = sel.match(selRx);
+ if( !m ){
+ error( 'bad selector syntax: ' + sel );
+ }
+
+ prepend = m[1];
+ selector = m[2];
+ attr = m[3];
+ append = m[4];
+
+ if(selector === '.' || ( !selector && attr ) ){
+ target[0] = dom;
+ }else{
+ target = plugins.find(dom, selector);
+ }
+ if(!target || target.length === 0){
+ return error('The node "' + sel + '" was not found in the template');
+ }
+ }else{
+ // autoRender node
+ prepend = sel.prepend;
+ attr = sel.attr;
+ append = sel.append;
+ target = [dom];
+ }
+
+ if( prepend || append ){
+ if( prepend && append ){
+ error('append/prepend cannot take place at the same time');
+ }else if( isloop ){
+ error('no append/prepend/replace modifiers allowed for loop target');
+ }else if( append && isloop ){
+ error('cannot append with loop (sel: ' + osel + ')');
+ }
+ }
+ var setstr, getstr, quotefn, isStyle, isClass, attName, setfn;
+ if(attr){
+ isStyle = (/^style$/i).test(attr);
+ isClass = (/^class$/i).test(attr);
+ attName = isClass ? 'className' : attr;
+ setstr = function(node, s) {
+ node.setAttribute(attPfx + attr, s);
+ if (attName in node && !isStyle) {
+ node[attName] = '';
+ }
+ if (node.nodeType === 1) {
+ node.removeAttribute(attr);
+ isClass && node.removeAttribute(attName);
+ }
+ };
+ if (isStyle || isClass) {//IE no quotes special care
+ if(isStyle){
+ getstr = function(n){ return n.style.cssText; };
+ }else{
+ getstr = function(n){ return n.className; };
+ }
+ quotefn = function(s){ return s.replace(/\"/g, '"'); };
+ }else {
+ getstr = function(n){ return n.getAttribute(attr); };
+ quotefn = function(s){ return s.replace(/\"/g, '"').replace(/\s/g, ' '); };
+ }
+ if(prepend){
+ setfn = function(node, s){ setstr( node, s + getstr( node )); };
+ }else if(append){
+ setfn = function(node, s){ setstr( node, getstr( node ) + s); };
+ }else{
+ setfn = function(node, s){ setstr( node, s ); };
+ }
+ }else{
+ if (isloop) {
+ setfn = function(node, s) {
+ var pn = node.parentNode;
+ if (pn) {
+ //replace node with s
+ pn.insertBefore(document.createTextNode(s), node.nextSibling);
+ pn.removeChild(node);
+ }
+ };
+ } else {
+ if (prepend) {
+ setfn = function(node, s) { node.insertBefore(document.createTextNode(s), node.firstChild); };
+ } else if (append) {
+ setfn = function(node, s) { node.appendChild(document.createTextNode(s));};
+ } else {
+ setfn = function(node, s) {
+ while (node.firstChild) { node.removeChild(node.firstChild); }
+ node.appendChild(document.createTextNode(s));
+ };
+ }
+ }
+ quotefn = function(s) { return s; };
+ }
+ return { attr: attr, nodes: target, set: setfn, sel: osel, quotefn: quotefn };
+ }
+
+ function setsig(target, n){
+ var sig = Sig + n + ':';
+ for(var i = 0; i < target.nodes.length; i++){
+ // could check for overlapping targets here.
+ target.set( target.nodes[i], sig );
+ }
+ }
+
+ // read de loop data, and pass it to the inner rendering function
+ function loopfn(name, dselect, inner, sorter, filter){
+ return function(ctxt){
+ var a = dselect(ctxt),
+ old = ctxt[name],
+ temp = { items : a },
+ filtered = 0,
+ length,
+ strs = [],
+ buildArg = function(idx, temp, ftr, len){
+ ctxt.pos = temp.pos = idx;
+ ctxt.item = temp.item = a[ idx ];
+ ctxt.items = a;
+ //if array, set a length property - filtered items
+ typeof len !== 'undefined' && (ctxt.length = len);
+ //if filter directive
+ if(typeof ftr === 'function' && ftr(ctxt) === false){
+ filtered++;
+ return;
+ }
+ strs.push( inner.call(temp, ctxt ) );
+ };
+ ctxt[name] = temp;
+ if( isArray(a) ){
+ length = a.length || 0;
+ // if sort directive
+ if(typeof sorter === 'function'){
+ a.sort(sorter);
+ }
+ //loop on array
+ for(var i = 0, ii = length; i < ii; i++){
+ buildArg(i, temp, filter, length - filtered);
+ }
+ }else{
+ if(a && typeof sorter !== 'undefined'){
+ error('sort is only available on arrays, not objects');
+ }
+ //loop on collections
+ for(var prop in a){
+ a.hasOwnProperty( prop ) && buildArg(prop, temp, filter);
+ }
+ }
+
+ typeof old !== 'undefined' ? ctxt[name] = old : delete ctxt[name];
+ return strs.join('');
+ };
+ }
+ // generate the template for a loop node
+ function loopgen(dom, sel, loop, fns){
+ var already = false, ls, sorter, filter, prop;
+ for(prop in loop){
+ if(loop.hasOwnProperty(prop)){
+ if(prop === 'sort'){
+ sorter = loop.sort;
+ continue;
+ }else if(prop === 'filter'){
+ filter = loop.filter;
+ continue;
+ }
+ if(already){
+ error('cannot have more than one loop on a target');
+ }
+ ls = prop;
+ already = true;
+ }
+ }
+ if(!ls){
+ error('Error in the selector: ' + sel + '\nA directive action must be a string, a function or a loop(<-)');
+ }
+ var dsel = loop[ls];
+ // if it's a simple data selector then we default to contents, not replacement.
+ if(typeof(dsel) === 'string' || typeof(dsel) === 'function'){
+ loop = {};
+ loop[ls] = {root: dsel};
+ return loopgen(dom, sel, loop, fns);
+ }
+ var spec = parseloopspec(ls),
+ itersel = dataselectfn(spec.sel),
+ target = gettarget(dom, sel, true),
+ nodes = target.nodes;
+
+ for(i = 0; i < nodes.length; i++){
+ var node = nodes[i],
+ inner = compiler(node, dsel);
+ fns[fns.length] = wrapquote(target.quotefn, loopfn(spec.name, itersel, inner, sorter, filter));
+ target.nodes = [node]; // N.B. side effect on target.
+ setsig(target, fns.length - 1);
+ }
+ }
+
+ function getAutoNodes(n, data){
+ var ns = n.getElementsByTagName('*'),
+ an = [],
+ openLoops = {a:[],l:{}},
+ cspec,
+ isNodeValue,
+ i, ii, j, jj, ni, cs, cj;
+ //for each node found in the template
+ for(i = -1, ii = ns.length; i < ii; i++){
+ ni = i > -1 ?ns[i]:n;
+ if(ni.nodeType === 1 && ni.className !== ''){
+ //when a className is found
+ cs = ni.className.split(' ');
+ // for each className
+ for(j = 0, jj=cs.length;j -1 || isNodeValue){
+ ni.className = ni.className.replace('@'+cspec.attr, '');
+ if(isNodeValue){
+ cspec.attr = false;
+ }
+ }
+ an.push({n:ni, cspec:cspec});
+ }
+ }
+ }
+ }
+ return an;
+
+ function checkClass(c, tagName){
+ // read the class
+ var ca = c.match(selRx),
+ attr = ca[3] || autoAttr[tagName],
+ cspec = {prepend:!!ca[1], prop:ca[2], attr:attr, append:!!ca[4], sel:c},
+ i, ii, loopi, loopil, val;
+ // check in existing open loops
+ for(i = openLoops.a.length-1; i >= 0; i--){
+ loopi = openLoops.a[i];
+ loopil = loopi.l[0];
+ val = loopil && loopil[cspec.prop];
+ if(typeof val !== 'undefined'){
+ cspec.prop = loopi.p + '.' + cspec.prop;
+ if(openLoops.l[cspec.prop] === true){
+ val = val[0];
+ }
+ break;
+ }
+ }
+ // not found check first level of data
+ if(typeof val === 'undefined'){
+ val = isArray(data) ? data[0][cspec.prop] : data[cspec.prop];
+ // nothing found return
+ if(typeof val === 'undefined'){
+ return false;
+ }
+ }
+ // set the spec for autoNode
+ if(isArray(val)){
+ openLoops.a.push( {l:val, p:cspec.prop} );
+ openLoops.l[cspec.prop] = true;
+ cspec.t = 'loop';
+ }else{
+ cspec.t = 'str';
+ }
+ return cspec;
+ }
+ }
+
+ // returns a function that, given a context argument,
+ // will render the template defined by dom and directive.
+ function compiler(dom, directive, data, ans){
+ var fns = [];
+ // autoRendering nodes parsing -> auto-nodes
+ ans = ans || data && getAutoNodes(dom, data);
+ if(data){
+ var j, jj, cspec, n, target, nodes, itersel, node, inner;
+ // for each auto-nodes
+ while(ans.length > 0){
+ cspec = ans[0].cspec;
+ n = ans[0].n;
+ ans.splice(0, 1);
+ if(cspec.t === 'str'){
+ // if the target is a value
+ target = gettarget(n, cspec, false);
+ setsig(target, fns.length);
+ fns[fns.length] = wrapquote(target.quotefn, dataselectfn(cspec.prop));
+ }else{
+ // if the target is a loop
+ itersel = dataselectfn(cspec.sel);
+ target = gettarget(n, cspec, true);
+ nodes = target.nodes;
+ for(j = 0, jj = nodes.length; j < jj; j++){
+ node = nodes[j];
+ inner = compiler(node, false, data, ans);
+ fns[fns.length] = wrapquote(target.quotefn, loopfn(cspec.sel, itersel, inner));
+ target.nodes = [node];
+ setsig(target, fns.length - 1);
+ }
+ }
+ }
+ }
+ // read directives
+ var target, dsel;
+ for(var sel in directive){
+ if(directive.hasOwnProperty(sel)){
+ dsel = directive[sel];
+ if(typeof(dsel) === 'function' || typeof(dsel) === 'string'){
+ // set the value for the node/attr
+ target = gettarget(dom, sel, false);
+ setsig(target, fns.length);
+ fns[fns.length] = wrapquote(target.quotefn, dataselectfn(dsel));
+ }else{
+ // loop on node
+ loopgen(dom, sel, dsel, fns);
+ }
+ }
+ }
+ // convert node to a string
+ var h = outerHTML(dom), pfns = [];
+ // IE adds an unremovable "selected, value" attribute
+ // hard replace while waiting for a better solution
+ h = h.replace(/<([^>]+)\s(value\=""|selected)\s?([^>]*)>/ig, "<$1 $3>");
+
+ // remove attribute prefix
+ h = h.split(attPfx).join('');
+
+ // slice the html string at "Sig"
+ var parts = h.split( Sig ), p;
+ // for each slice add the return string of
+ for(var i = 1; i < parts.length; i++){
+ p = parts[i];
+ // part is of the form "fn-number:..." as placed there by setsig.
+ pfns[i] = fns[ parseInt(p, 10) ];
+ parts[i] = p.substring( p.indexOf(':') + 1 );
+ }
+ return concatenator(parts, pfns);
+ }
+ // compile the template with directive
+ // if a context is passed, the autoRendering is triggered automatically
+ // return a function waiting the data as argument
+ function compile(directive, ctxt, template){
+ var rfn = compiler( ( template || this[0] ).cloneNode(true), directive, ctxt);
+ return function(context){
+ return rfn({context:context});
+ };
+ }
+ //compile with the directive as argument
+ // run the template function on the context argument
+ // return an HTML string
+ // should replace the template and return this
+ function render(ctxt, directive){
+ var fn = typeof directive === 'function' ? directive : plugins.compile( directive, false, this[0] );
+ for(var i = 0, ii = this.length; i < ii; i++){
+ this[i] = replaceWith( this[i], fn( ctxt, false ));
+ }
+ context = null;
+ return this;
+ }
+
+ // compile the template with autoRender
+ // run the template function on the context argument
+ // return an HTML string
+ function autoRender(ctxt, directive){
+ var fn = plugins.compile( directive, ctxt, this[0] );
+ for(var i = 0, ii = this.length; i < ii; i++){
+ this[i] = replaceWith( this[i], fn( ctxt, false));
+ }
+ context = null;
+ return this;
+ }
+
+ function replaceWith(elm, html) {
+ var ne,
+ ep = elm.parentNode,
+ depth = 0;
+ switch (elm.tagName) {
+ case 'TBODY': case 'THEAD': case 'TFOOT':
+ html = '' + html + '
';
+ depth = 1;
+ break;
+ case 'TR':
+ html = '' + html + '
';
+ depth = 2;
+ break;
+ case 'TD': case 'TH':
+ html = '' + html + '
';
+ depth = 3;
+ break;
+ }
+ tmp = document.createElement('SPAN');
+ tmp.style.display = 'none';
+ document.body.appendChild(tmp);
+ tmp.innerHTML = html;
+ ne = tmp.firstChild;
+ while (depth--) {
+ ne = ne.firstChild;
+ }
+ ep.insertBefore(ne, elm);
+ ep.removeChild(elm);
+ document.body.removeChild(tmp);
+ elm = ne;
+
+ ne = ep = null;
+ return elm;
+ }
+};
+
+$p.plugins = {};
+
+$p.libs = {
+ dojo:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return dojo.query(sel, n);
+ };
+ }
+ },
+ domassistant:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return $(n).cssSelect(sel);
+ };
+ }
+ DOMAssistant.attach({
+ publicMethods : [ 'compile', 'render', 'autoRender'],
+ compile:function(directive, ctxt){ return $p(this).compile(directive, ctxt); },
+ render:function(ctxt, directive){ return $( $p(this).render(ctxt, directive) )[0]; },
+ autoRender:function(ctxt, directive){ return $( $p(this).autoRender(ctxt, directive) )[0]; }
+ });
+ },
+ jquery:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return jQuery(n).find(sel);
+ };
+ }
+ jQuery.fn.extend({
+ compile:function(directive, ctxt){ return $p(this[0]).compile(directive, ctxt); },
+ render:function(ctxt, directive){ return jQuery( $p( this[0] ).render( ctxt, directive ) ); },
+ autoRender:function(ctxt, directive){ return jQuery( $p( this[0] ).autoRender( ctxt, directive ) ); }
+ });
+ },
+ mootools:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return $(n).getElements(sel);
+ };
+ }
+ Element.implement({
+ compile:function(directive, ctxt){ return $p(this).compile(directive, ctxt); },
+ render:function(ctxt, directive){ return $p(this).render(ctxt, directive); },
+ autoRender:function(ctxt, directive){ return $p(this).autoRender(ctxt, directive); }
+ });
+ },
+ prototype:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ n = n === document ? n.body : n;
+ return typeof n === 'string' ? $$(n) : $(n).select(sel);
+ };
+ }
+ Element.addMethods({
+ compile:function(element, directive, ctxt){ return $p(element).compile(directive, ctxt); },
+ render:function(element, ctxt, directive){ return $p(element).render(ctxt, directive); },
+ autoRender:function(element, ctxt, directive){ return $p(element).autoRender(ctxt, directive); }
+ });
+ },
+ sizzle:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return Sizzle(sel, n);
+ };
+ }
+ },
+ sly:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return Sly(sel, n);
+ };
+ }
+ }
+};
+
+// get lib specifics if available
+(function(){
+ var libkey =
+ typeof dojo !== 'undefined' && 'dojo' ||
+ typeof DOMAssistant !== 'undefined' && 'domassistant' ||
+ typeof jQuery !== 'undefined' && 'jquery' ||
+ typeof MooTools !== 'undefined' && 'mootools' ||
+ typeof Prototype !== 'undefined' && 'prototype' ||
+ typeof Sizzle !== 'undefined' && 'sizzle' ||
+ typeof Sly !== 'undefined' && 'sly';
+
+ libkey && $p.libs[libkey]();
+})();
+
+
+ Sammy = Sammy || {};
+
+ // `Sammy.Pure` is a simple wrapper around the pure.js templating engine for
+ // use in Sammy apps.
+ //
+ // See http://beebole.com/pure/ for detailed documentation.
+ Sammy.Pure = function(app, method_alias) {
+
+ var pure = function(template, data, directives) {
+ return $(template).autoRender(data, directives);
+ };
+
+ // set the default method name/extension
+ if (!method_alias) method_alias = 'pure';
+ app.helper(method_alias, pure);
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.storage.js b/public/javascripts/plugins/sammy.storage.js
new file mode 100644
index 0000000..ad3cb86
--- /dev/null
+++ b/public/javascripts/plugins/sammy.storage.js
@@ -0,0 +1,577 @@
+(function($) {
+
+ Sammy = Sammy || {};
+
+ // Sammy.Store is an abstract adapter class that wraps the multitude of in
+ // browser data storage into a single common set of methods for storing and
+ // retreiving data. The JSON library is used (through the inclusion of the
+ // Sammy.JSON) plugin, to automatically convert objects back and forth from
+ // stored strings.
+ //
+ // Sammy.Store can be used directly, but within a Sammy.Application it is much
+ // easier to use the `Sammy.Storage` plugin and its helper methods.
+ //
+ // Sammy.Store also supports the KVO pattern, by firing DOM/jQuery Events when
+ // a key is set.
+ //
+ // ### Example
+ //
+ // // create a new store named 'mystore', tied to the #main element, using HTML5 localStorage
+ // // Note: localStorage only works on browsers that support it
+ // var store = new Sammy.Store({name: 'mystore', element: '#element', type: 'local'});
+ // store.set('foo', 'bar');
+ // store.get('foo'); //=> 'bar'
+ // store.set('json', {obj: 'this is an obj'});
+ // store.get('json'); //=> {obj: 'this is an obj'}
+ // store.keys(); //=> ['foo','json']
+ // store.clear('foo');
+ // store.keys(); //=> ['json']
+ // store.clearAll();
+ // store.keys(); //=> []
+ //
+ // ### Arguments
+ //
+ // The constructor takes a single argument which is a Object containing these possible options.
+ //
+ // * `name` The name/namespace of this store. Stores are unique by name/type. (default 'store')
+ // * `element` A selector for the element that the store is bound to. (default 'body')
+ // * `type` The type of storage/proxy to use (default 'memory')
+ //
+ // Extra options are passed to the storage constructor.
+ // Sammy.Store supports the following methods of storage:
+ //
+ // * `memory` Basic object storage
+ // * `data` jQuery.data DOM Storage
+ // * `cookie` Access to document.cookie. Limited to 2K
+ // * `local` HTML5 DOM localStorage, browswer support is currently limited.
+ // * `session` HTML5 DOM sessionStorage, browswer support is currently limited.
+ //
+ Sammy.Store = function(options) {
+ var store = this;
+ this.options = options || {};
+ this.name = this.options.name || 'store';
+ this.element = this.options.element || 'body';
+ this.$element = $(this.element);
+ if ($.isArray(this.options.type)) {
+ $.each(this.options.type, function(i, type) {
+ if (Sammy.Store.isAvailable(type)) {
+ store.type = type;
+ return false;
+ }
+ });
+ } else {
+ this.type = this.options.type || 'memory';
+ }
+ this.meta_key = this.options.meta_key || '__keys__';
+ this.storage = new Sammy.Store[Sammy.Store.stores[this.type]](this.name, this.element, this.options);
+ };
+
+ Sammy.Store.stores = {
+ 'memory': 'Memory',
+ 'data': 'Data',
+ 'local': 'LocalStorage',
+ 'session': 'SessionStorage',
+ 'cookie': 'Cookie'
+ };
+
+ $.extend(Sammy.Store.prototype, {
+ // Checks for the availability of the current storage type in the current browser/config.
+ isAvailable: function() {
+ if ($.isFunction(this.storage.isAvailable)) {
+ return this.storage.isAvailable();
+ } else {
+ true;
+ }
+ },
+ // Checks for the existance of `key` in the current store. Returns a boolean.
+ exists: function(key) {
+ return this.storage.exists(key);
+ },
+ // Sets the value of `key` with `value`. If `value` is an
+ // object, it is turned to and stored as a string with `JSON.stringify`.
+ // It also tries to conform to the KVO pattern triggering jQuery events on the
+ // element that the store is bound to.
+ //
+ // ### Example
+ //
+ // var store = new Sammy.Store({name: 'kvo'});
+ // $('body').bind('set-kvo-foo', function(e, data) {
+ // Sammy.log(data.key + ' changed to ' + data.value);
+ // });
+ // store.set('foo', 'bar'); // logged: foo changed to bar
+ //
+ set: function(key, value) {
+ var string_value = (typeof value == 'string') ? value : JSON.stringify(value);
+ key = key.toString();
+ this.storage.set(key, string_value);
+ if (key != this.meta_key) {
+ this._addKey(key);
+ this.$element.trigger('set-' + this.name, {key: key, value: value});
+ this.$element.trigger('set-' + this.name + '-' + key, {key: key, value: value});
+ };
+ // always return the original value
+ return value;
+ },
+ // Returns the set value at `key`, parsing with `JSON.parse` and
+ // turning into an object if possible
+ get: function(key) {
+ var value = this.storage.get(key);
+ if (typeof value == 'undefined' || value == null || value == '') {
+ return value;
+ }
+ try {
+ return JSON.parse(value);
+ } catch(e) {
+ return value;
+ }
+ },
+ // Removes the value at `key` from the current store
+ clear: function(key) {
+ this._removeKey(key);
+ return this.storage.clear(key);
+ },
+ // Clears all the values for the current store.
+ clearAll: function() {
+ var self = this;
+ this.each(function(key, value) {
+ self.clear(key);
+ });
+ },
+ // Returns the all the keys set for the current store as an array.
+ // Internally Sammy.Store keeps this array in a 'meta_key' for easy access.
+ keys: function() {
+ return this.get(this.meta_key) || [];
+ },
+ // Iterates over each key value pair passing them to the `callback` function
+ //
+ // ### Example
+ //
+ // store.each(function(key, value) {
+ // Sammy.log('key', key, 'value', value);
+ // });
+ //
+ each: function(callback) {
+ var i = 0,
+ keys = this.keys(),
+ returned;
+
+ for (i; i < keys.length; i++) {
+ returned = callback(keys[i], this.get(keys[i]));
+ if (returned === false) { return false; }
+ };
+ },
+ // Filters the store by a filter function that takes a key value.
+ // Returns an array of arrays where the first element of each array
+ // is the key and the second is the value of that key.
+ //
+ // ### Example
+ //
+ // var store = new Sammy.Store;
+ // store.set('one', 'two');
+ // store.set('two', 'three');
+ // store.set('1', 'two');
+ // var returned = store.filter(function(key, value) {
+ // // only return
+ // return value === 'two';
+ // });
+ // // returned => [['one', 'two'], ['1', 'two']];
+ //
+ filter: function(callback) {
+ var found = [];
+ this.each(function(key, value) {
+ if (callback(key, value)) {
+ found.push([key, value]);
+ }
+ return true;
+ });
+ return found;
+ },
+ // Works exactly like filter except only returns the first matching key
+ // value pair instead of all of them
+ first: function(callback) {
+ var found = false;
+ this.each(function(key, value) {
+ if (callback(key, value)) {
+ found = [key, value];
+ return false;
+ }
+ });
+ return found;
+ },
+ // Returns the value at `key` if set, otherwise, runs the callback
+ // and sets the value to the value returned in the callback.
+ //
+ // ### Example
+ //
+ // var store = new Sammy.Store;
+ // store.exists('foo'); //=> false
+ // store.fetch('foo', function() {
+ // return 'bar!';
+ // }); //=> 'bar!'
+ // store.get('foo') //=> 'bar!'
+ // store.fetch('foo', function() {
+ // return 'baz!';
+ // }); //=> 'bar!
+ //
+ fetch: function(key, callback) {
+ if (!this.exists(key)) {
+ return this.set(key, callback.apply(this));
+ } else {
+ return this.get(key);
+ }
+ },
+ // loads the response of a request to `path` into `key`.
+ //
+ // ### Example
+ //
+ // In /mytemplate.tpl:
+ //
+ // My Template
+ //
+ // In app.js:
+ //
+ // var store = new Sammy.Store;
+ // store.load('mytemplate', '/mytemplate.tpl', function() {
+ // s.get('mytemplate') //=> My Template
+ // });
+ //
+ load: function(key, path, callback) {
+ var s = this;
+ $.get(path, function(response) {
+ s.set(key, response);
+ if (callback) { callback.apply(this, [response]); }
+ });
+ },
+
+ _addKey: function(key) {
+ var keys = this.keys();
+ if ($.inArray(key, keys) == -1) { keys.push(key); }
+ this.set(this.meta_key, keys);
+ },
+ _removeKey: function(key) {
+ var keys = this.keys();
+ var index = $.inArray(key, keys);
+ if (index != -1) { keys.splice(index, 1); }
+ this.set(this.meta_key, keys);
+ }
+ });
+
+ // Tests if the type of storage is available/works in the current browser/config.
+ // Especially useful for testing the availability of the awesome, but not widely
+ // supported HTML5 DOM storage
+ Sammy.Store.isAvailable = function(type) {
+ try {
+ return Sammy.Store[Sammy.Store.stores[type]].prototype.isAvailable();
+ } catch(e) {
+ return false;
+ }
+ };
+
+ // Memory ('memory') is the basic/default store. It stores data in a global
+ // JS object. Data is lost on refresh.
+ Sammy.Store.Memory = function(name, element) {
+ this.name = name;
+ this.element = element;
+ this.namespace = [this.element, this.name].join('.');
+ Sammy.Store.Memory.store = Sammy.Store.Memory.store || {};
+ Sammy.Store.Memory.store[this.namespace] = Sammy.Store.Memory.store[this.namespace] || {};
+ this.store = Sammy.Store.Memory.store[this.namespace];
+ };
+ $.extend(Sammy.Store.Memory.prototype, {
+ isAvailable: function() { return true; },
+ exists: function(key) {
+ return (typeof this.store[key] != "undefined");
+ },
+ set: function(key, value) {
+ return this.store[key] = value;
+ },
+ get: function(key) {
+ return this.store[key];
+ },
+ clear: function(key) {
+ delete this.store[key];
+ }
+ });
+
+ // Data ('data') stores objects using the jQuery.data() methods. This has the advantadge
+ // of scoping the data to the specific element. Like the 'memory' store its data
+ // will only last for the length of the current request (data is lost on refresh/etc).
+ Sammy.Store.Data = function(name, element) {
+ this.name = name;
+ this.element = element;
+ this.$element = $(element);
+ };
+ $.extend(Sammy.Store.Data.prototype, {
+ isAvailable: function() { return true; },
+ exists: function(key) {
+ return !!this.$element.data(this._key(key));
+ },
+ set: function(key, value) {
+ return this.$element.data(this._key(key), value);
+ },
+ get: function(key) {
+ return this.$element.data(this._key(key));
+ },
+ clear: function(key) {
+ this.$element.removeData(this._key(key));
+ },
+ _key: function(key) {
+ return ['store', this.name, key].join('.');
+ }
+ });
+
+ // LocalStorage ('local') makes use of HTML5 DOM Storage, and the window.localStorage
+ // object. The great advantage of this method is that data will persist beyond
+ // the current request. It can be considered a pretty awesome replacement for
+ // cookies accessed via JS. The great disadvantage, though, is its only available
+ // on the latest and greatest browsers.
+ //
+ // For more info on DOM Storage:
+ // https://developer.mozilla.org/en/DOM/Storage
+ // http://www.w3.org/TR/2009/WD-webstorage-20091222/
+ //
+ Sammy.Store.LocalStorage = function(name, element) {
+ this.name = name;
+ this.element = element;
+ };
+ $.extend(Sammy.Store.LocalStorage.prototype, {
+ isAvailable: function() {
+ return ('localStorage' in window) && (window.location.protocol != 'file:');
+ },
+ exists: function(key) {
+ return (this.get(key) != null);
+ },
+ set: function(key, value) {
+ return window.localStorage.setItem(this._key(key), value);
+ },
+ get: function(key) {
+ return window.localStorage.getItem(this._key(key));
+ },
+ clear: function(key) {
+ window.localStorage.removeItem(this._key(key));;
+ },
+ _key: function(key) {
+ return ['store', this.element, this.name, key].join('.');
+ }
+ });
+
+ // .SessionStorage ('session') is similar to LocalStorage (part of the same API)
+ // and shares similar browser support/availability. The difference is that
+ // SessionStorage is only persistant through the current 'session' which is defined
+ // as the length that the current window is open. This means that data will survive
+ // refreshes but not close/open or multiple windows/tabs. For more info, check out
+ // the `LocalStorage` documentation and links.
+ Sammy.Store.SessionStorage = function(name, element) {
+ this.name = name;
+ this.element = element;
+ };
+ $.extend(Sammy.Store.SessionStorage.prototype, {
+ isAvailable: function() {
+ return ('sessionStorage' in window) &&
+ (window.location.protocol != 'file:') &&
+ ($.isFunction(window.sessionStorage.setItem));
+ },
+ exists: function(key) {
+ return (this.get(key) != null);
+ },
+ set: function(key, value) {
+ return window.sessionStorage.setItem(this._key(key), value);
+ },
+ get: function(key) {
+ var value = window.sessionStorage.getItem(this._key(key));
+ if (value && typeof value.value != "undefined") { value = value.value }
+ return value;
+ },
+ clear: function(key) {
+ window.sessionStorage.removeItem(this._key(key));;
+ },
+ _key: function(key) {
+ return ['store', this.element, this.name, key].join('.');
+ }
+ });
+
+ // .Cookie ('cookie') storage uses browser cookies to store data. JavaScript
+ // has access to a single document.cookie variable, which is limited to 2Kb in
+ // size. Cookies are also considered 'unsecure' as the data can be read easily
+ // by other sites/JS. Cookies do have the advantage, though, of being widely
+ // supported and persistent through refresh and close/open. Where available,
+ // HTML5 DOM Storage like LocalStorage and SessionStorage should be used.
+ //
+ // .Cookie can also take additional options:
+ //
+ // * `expires_in` Number of seconds to keep the cookie alive (default 2 weeks).
+ // * `path` The path to activate the current cookie for (default '/').
+ //
+ // For more information about document.cookie, check out the pre-eminint article
+ // by ppk: http://www.quirksmode.org/js/cookies.html
+ //
+ Sammy.Store.Cookie = function(name, element, options) {
+ this.name = name;
+ this.element = element;
+ this.options = options || {};
+ this.path = this.options.path || '/';
+ // set the expires in seconds or default 14 days
+ this.expires_in = this.options.expires_in || (14 * 24 * 60 * 60);
+ };
+ $.extend(Sammy.Store.Cookie.prototype, {
+ isAvailable: function() {
+ return ('cookie' in document) && (window.location.protocol != 'file:');
+ },
+ exists: function(key) {
+ return (this.get(key) != null);
+ },
+ set: function(key, value) {
+ return this._setCookie(key, value);
+ },
+ get: function(key) {
+ return this._getCookie(key);
+ },
+ clear: function(key) {
+ this._setCookie(key, "", -1);
+ },
+ _key: function(key) {
+ return ['store', this.element, this.name, key].join('.');
+ },
+ _getCookie: function(key) {
+ var escaped = this._key(key).replace(/(\.|\*|\(|\)|\[|\])/g, '\\$1');
+ var match = document.cookie.match("(^|;\\s)" + escaped + "=([^;]*)(;|$)")
+ return (match ? match[2] : null);
+ },
+ _setCookie: function(key, value, expires) {
+ if (!expires) { expires = (this.expires_in * 1000) }
+ var date = new Date();
+ date.setTime(date.getTime() + expires);
+ var set_cookie = [
+ this._key(key), "=", value,
+ "; expires=", date.toGMTString(),
+ "; path=", this.path
+ ].join('');
+ document.cookie = set_cookie;
+ }
+ });
+
+ // Sammy.Storage is a plugin that provides shortcuts for creating and using
+ // Sammy.Store objects. Once included it provides the `store()` app level
+ // and helper methods. Depends on Sammy.JSON (or json2.js).
+ Sammy.Storage = function(app) {
+ this.use(Sammy.JSON);
+
+ this.stores = this.stores || {};
+
+ // `store()` creates and looks up existing `Sammy.Store` objects
+ // for the current application. The first time used for a given `'name'`
+ // initializes a `Sammy.Store` and also creates a helper under the store's
+ // name.
+ //
+ // ### Example
+ //
+ // var app = $.sammy(function() {
+ // this.use(Sammy.Storage);
+ //
+ // // initializes the store on app creation.
+ // this.store('mystore', {type: 'cookie'});
+ //
+ // this.get('#/', function() {
+ // // returns the Sammy.Store object
+ // this.store('mystore');
+ // // sets 'foo' to 'bar' using the shortcut/helper
+ // // equivilent to this.store('mystore').set('foo', 'bar');
+ // this.mystore('foo', 'bar');
+ // // returns 'bar'
+ // // equivilent to this.store('mystore').get('foo');
+ // this.mystore('foo');
+ // // returns 'baz!'
+ // // equivilent to:
+ // // this.store('mystore').fetch('foo!', function() {
+ // // return 'baz!';
+ // // })
+ // this.mystore('foo!', function() {
+ // return 'baz!';
+ // });
+ //
+ // this.clearMystore();
+ // // equivilent to:
+ // // this.store('mystore').clearAll()
+ // });
+ //
+ // });
+ //
+ // ### Arguments
+ //
+ // * `name` The name of the store and helper. the name must be unique per application.
+ // * `options` A JS object of options that can be passed to the Store constuctor on initialization.
+ //
+ this.store = function(name, options) {
+ // if the store has not been initialized
+ if (typeof this.stores[name] == 'undefined') {
+ // create initialize the store
+ var clear_method_name = "clear" + name.substr(0,1).toUpperCase() + name.substr(1);
+ this.stores[name] = new Sammy.Store($.extend({
+ name: name,
+ element: this.element_selector
+ }, options || {}));
+ // app.name()
+ this[name] = function(key, value) {
+ if (typeof value == 'undefined') {
+ return this.stores[name].get(key);
+ } else if ($.isFunction(value)) {
+ return this.stores[name].fetch(key, value);
+ } else {
+ return this.stores[name].set(key, value)
+ }
+ };
+ // app.clearName();
+ this[clear_method_name] = function() {
+ return this.stores[name].clearAll();
+ }
+ // context.name()
+ this.helper(name, function() {
+ return this.app[name].apply(this.app, arguments);
+ });
+ // context.clearName();
+ this.helper(clear_method_name, function() {
+ return this.app[clear_method_name]();
+ });
+ }
+ return this.stores[name];
+ };
+
+ this.helpers({
+ store: function() {
+ return this.app.store.apply(this.app, arguments);
+ }
+ });
+ };
+
+ // Sammy.Session is an additional plugin for creating a common 'session' store
+ // for the given app. It is a very simple wrapper around `Sammy.Storage`
+ // that provides a simple fallback mechanism for trying to provide the best
+ // possible storage type for the session. This means, `LocalStorage`
+ // if available, otherwise `Cookie`, otherwise `Memory`.
+ // It provides the `session()` helper through `Sammy.Storage#store()`.
+ //
+ // See the `Sammy.Storage` plugin for full documentation.
+ //
+ Sammy.Session = function(app, options) {
+ this.use(Sammy.Storage);
+ // check for local storage, then cookie storage, then just use memory
+ this.store('session', $.extend({type: ['local', 'cookie', 'memory']}, options));
+ };
+
+ // Sammy.Cache provides helpers for caching data within the lifecycle of a
+ // Sammy app. The plugin provides two main methods on `Sammy.Application`,
+ // `cache` and `clearCache`. Each app has its own cache store so that
+ // you dont have to worry about collisions. As of 0.5 the original Sammy.Cache module
+ // has been deprecated in favor of this one based on Sammy.Storage. The exposed
+ // API is almost identical, but Sammy.Storage provides additional backends including
+ // HTML5 Storage. `Sammy.Cache` will try to use these backends when available
+ // (in this order) `LocalStorage`, `SessionStorage`, and `Memory`
+ Sammy.Cache = function(app, options) {
+ this.use(Sammy.Storage);
+ // set cache_partials to true
+ this.cache_partials = true;
+ // check for local storage, then session storage, then just use memory
+ this.store('cache', $.extend({type: ['local', 'session', 'memory']}, options));
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.template.js b/public/javascripts/plugins/sammy.template.js
new file mode 100644
index 0000000..2ce315f
--- /dev/null
+++ b/public/javascripts/plugins/sammy.template.js
@@ -0,0 +1,141 @@
+(function($) {
+
+ // Simple JavaScript Templating
+ // John Resig - http://ejohn.org/ - MIT Licensed
+ // adapted from: http://ejohn.org/blog/javascript-micro-templating/
+ // originally $.srender by Greg Borenstein http://ideasfordozens.com in Feb 2009
+ // modified for Sammy by Aaron Quint for caching templates by name
+ var srender_cache = {};
+ var srender = function(name, template, data, options) {
+ var fn, escaped_string;
+ // target is an optional element; if provided, the result will be inserted into it
+ // otherwise the result will simply be returned to the caller
+ if (srender_cache[name]) {
+ fn = srender_cache[name];
+ } else {
+ if (typeof template == 'undefined') {
+ // was a cache check, return false
+ return false;
+ }
+ // If options escape_html is false, dont escape the contents by default
+ if (options && options.escape_html === false) {
+ escaped_string = "\",$1,\"";
+ } else {
+ escaped_string = "\",h($1),\"";
+ }
+ // Generate a reusable function that will serve as a template
+ // generator (and which will be cached).
+ fn = srender_cache[name] = new Function("obj",
+ "var ___$$$___=[],print=function(){___$$$___.push.apply(___$$$___,arguments);};" +
+
+ // Introduce the data as local variables using with(){}
+ "with(obj){___$$$___.push(\"" +
+
+ // Convert the template into pure JavaScript
+ String(template)
+ .replace(/[\r\t\n]/g, " ")
+ .replace(/\"/g, '\\"')
+ .split("<%").join("\t")
+ .replace(/((^|%>)[^\t]*)/g, "$1\r")
+ .replace(/\t=(.*?)%>/g, escaped_string)
+ .replace(/\t!(.*?)%>/g, "\",$1,\"")
+ .split("\t").join("\");")
+ .split("%>").join("___$$$___.push(\"")
+ .split("\r").join("")
+ + "\");}return ___$$$___.join('');");
+ }
+
+ if (typeof data != 'undefined') {
+ return fn(data);
+ } else {
+ return fn;
+ }
+ };
+
+ Sammy = Sammy || {};
+
+ // `Sammy.Template` is a simple plugin that provides a way to create
+ // and render client side templates. The rendering code is based on John Resig's
+ // quick templates and Greg Borenstien's srender plugin.
+ // This is also a great template/boilerplate for Sammy plugins.
+ //
+ // Templates use `<% %>` tags to denote embedded javascript.
+ //
+ // ### Examples
+ //
+ // Here is an example template (user.template):
+ //
+ // // user.template
+ //
+ // <%= user.name %>
+ // <% if (user.photo_url) { %>
+ // 
+ // <% } %>
+ //
+ //
+ // Given that is a publicly accesible file, you would render it like:
+ //
+ // // app.js
+ // $.sammy(function() {
+ // // include the plugin
+ // this.use('Template');
+ //
+ // this.get('#/', function() {
+ // // the template is rendered in the current context.
+ // this.user = {name: 'Aaron Quint'};
+ // // partial calls template() because of the file extension
+ // this.partial('user.template');
+ // })
+ // });
+ //
+ // You can also pass a second argument to use() that will alias the template
+ // method and therefore allow you to use a different extension for template files
+ // in partial()
+ //
+ // // alias to 'tpl'
+ // this.use(Sammy.Template, 'tpl');
+ //
+ // // now .tpl files will be run through srender
+ // this.get('#/', function() {
+ // this.partial('myfile.tpl');
+ // });
+ //
+ // By default, the data passed into the tempalate is passed automatically passed through
+ // Sammy's `escapeHTML` method in order to prevent possible XSS attacks. This is
+ // a problem though if you're using something like `Sammy.Form` which renders HTML
+ // within the templates. You can get around this in two ways. One, you can use the
+ // `<%! %>` instead of `<%= %>`. Two, you can pass the `escape_html = false` option
+ // when interpolating, i.e:
+ //
+ // this.get('#/', function() {
+ // this.template('myform.tpl', {form: ""}, {escape_html: false});
+ // });
+ //
+ Sammy.Template = function(app, method_alias) {
+
+ // *Helper:* Uses simple templating to parse ERB like templates.
+ //
+ // ### Arguments
+ //
+ // * `template` A String template. '<% %>' tags are evaluated as Javascript and replaced with the elements in data.
+ // * `data` An Object containing the replacement values for the template.
+ // data is extended with the EventContext allowing you to call its methods within the template.
+ // * `name` An optional String name to cache the template.
+ //
+ var template = function(template, data, name, options) {
+ // use name for caching
+ if (typeof name == 'undefined') { name = template; }
+ if (typeof options == 'undefined' && typeof name == 'object') {
+ options = name; name = template;
+ }
+ return srender(name, template, $.extend({}, this, data), options);
+ };
+
+ // set the default method name/extension
+ if (!method_alias) { method_alias = 'template'; }
+ // create the helper at the method alias
+ app.helper(method_alias, template);
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.title.js b/public/javascripts/plugins/sammy.title.js
new file mode 100644
index 0000000..9874a1e
--- /dev/null
+++ b/public/javascripts/plugins/sammy.title.js
@@ -0,0 +1,59 @@
+(function($) {
+
+ Sammy = Sammy || {};
+
+ // Sammy.Title is a very simple plugin to easily set the document's title.
+ // It supplies a helper for setting the title (`title()`) within routes,
+ // and an app level method for setting the global title (`setTitle()`)
+ Sammy.Title = function() {
+
+ // setTitle allows setting a global title or a function that modifies the
+ // title for each route/page.
+ //
+ // ### Example
+ //
+ // // setting a title prefix
+ // $.sammy(function() {
+ //
+ // this.setTitle('My App -');
+ //
+ // this.get('#/', function() {
+ // this.title('Home'); // document's title == "My App - Home"
+ // });
+ // });
+ //
+ // // setting a title with a function
+ // $.sammy(function() {
+ //
+ // this.setTitle(function(title) {
+ // return [title, " /// My App"].join('');
+ // });
+ //
+ // this.get('#/', function() {
+ // this.title('Home'); // document's title == "Home /// My App";
+ // });
+ // });
+ //
+ this.setTitle = function(title) {
+ if (!$.isFunction(title)) {
+ this.title_function = function(additional_title) {
+ return [title, additional_title].join(' ');
+ }
+ } else {
+ this.title_function = title;
+ }
+ };
+
+ // *Helper* title() sets the document title, passing it through the function
+ // defined by setTitle() if set.
+ this.helper('title', function() {
+ var new_title = $.makeArray(arguments).join(' ');
+ if (this.app.title_function) {
+ new_title = this.app.title_function(new_title);
+ }
+ document.title = new_title;
+ });
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.tmpl.js b/public/javascripts/plugins/sammy.tmpl.js
new file mode 100644
index 0000000..0e9f0a1
--- /dev/null
+++ b/public/javascripts/plugins/sammy.tmpl.js
@@ -0,0 +1,520 @@
+(function( jQuery, undefined ){
+
+ /*
+ * a port of the...
+ * jQuery Templating Plugin
+ * Copyright 2010, John Resig
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ */
+
+ var oldManip = jQuery.fn.domManip, tmplItmAtt = "_tmplitem", htmlExpr = /^[^<]*(<[\w\W]+>)[^>]*$|\{\{\! /,
+ newTmplItems = {}, wrappedItems = {}, appendToTmplItems, topTmplItem = { key: 0, data: {} }, itemKey = 0, cloneIndex = 0, stack = [];
+
+ function newTmplItem( options, parentItem, fn, data ) {
+ // Returns a template item data structure for a new rendered instance of a template (a 'template item').
+ // The content field is a hierarchical array of strings and nested items (to be
+ // removed and replaced by nodes field of dom elements, once inserted in DOM).
+ var newItem = {
+ data: data || (parentItem ? parentItem.data : {}),
+ _wrap: parentItem ? parentItem._wrap : null,
+ tmpl: null,
+ parent: parentItem || null,
+ nodes: [],
+ calls: tiCalls,
+ nest: tiNest,
+ wrap: tiWrap,
+ html: tiHtml,
+ update: tiUpdate
+ };
+ if ( options ) {
+ jQuery.extend( newItem, options, { nodes: [], parent: parentItem } );
+ }
+ if ( fn ) {
+ // Build the hierarchical content to be used during insertion into DOM
+ newItem.tmpl = fn;
+ newItem._ctnt = newItem._ctnt || newItem.tmpl( jQuery, newItem );
+ newItem.key = ++itemKey;
+ // Keep track of new template item, until it is stored as jQuery Data on DOM element
+ (stack.length ? wrappedItems : newTmplItems)[itemKey] = newItem;
+ }
+ return newItem;
+ }
+
+ // Override appendTo etc., in order to provide support for targeting multiple elements. (This code would disappear if integrated in jquery core).
+ jQuery.each({
+ appendTo: "append",
+ prependTo: "prepend",
+ insertBefore: "before",
+ insertAfter: "after",
+ replaceAll: "replaceWith"
+ }, function( name, original ) {
+ jQuery.fn[ name ] = function( selector ) {
+ var ret = [], insert = jQuery( selector ), elems, i, l, tmplItems,
+ parent = this.length === 1 && this[0].parentNode;
+
+ appendToTmplItems = newTmplItems || {};
+ if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
+ insert[ original ]( this[0] );
+ ret = this;
+ } else {
+ for ( i = 0, l = insert.length; i < l; i++ ) {
+ cloneIndex = i;
+ elems = (i > 0 ? this.clone(true) : this).get();
+ jQuery.fn[ original ].apply( jQuery(insert[i]), elems );
+ ret = ret.concat( elems );
+ }
+ cloneIndex = 0;
+ ret = this.pushStack( ret, name, insert.selector );
+ }
+ tmplItems = appendToTmplItems;
+ appendToTmplItems = null;
+ jQuery.tmpl.complete( tmplItems );
+ return ret;
+ };
+ });
+
+ jQuery.fn.extend({
+ // Use first wrapped element as template markup.
+ // Return wrapped set of template items, obtained by rendering template against data.
+ tmpl: function( data, options, parentItem ) {
+ return jQuery.tmpl( this[0], data, options, parentItem );
+ },
+
+ // Find which rendered template item the first wrapped DOM element belongs to
+ tmplItem: function() {
+ return jQuery.tmplItem( this[0] );
+ },
+
+ // Consider the first wrapped element as a template declaration, and get the compiled template or store it as a named template.
+ template: function( name ) {
+ return jQuery.template( name, this[0] );
+ },
+
+ domManip: function( args, table, callback, options ) {
+ // This appears to be a bug in the appendTo, etc. implementation
+ // it should be doing .call() instead of .apply(). See #6227
+ if ( args[0] && args[0].nodeType ) {
+ var dmArgs = jQuery.makeArray( arguments ), argsLength = args.length, i = 0, tmplItem;
+ while ( i < argsLength && !(tmplItem = jQuery.data( args[i++], "tmplItem" ))) {}
+ if ( argsLength > 1 ) {
+ dmArgs[0] = [jQuery.makeArray( args )];
+ }
+ if ( tmplItem && cloneIndex ) {
+ dmArgs[2] = function( fragClone ) {
+ // Handler called by oldManip when rendered template has been inserted into DOM.
+ jQuery.tmpl.afterManip( this, fragClone, callback );
+ };
+ }
+ oldManip.apply( this, dmArgs );
+ } else {
+ oldManip.apply( this, arguments );
+ }
+ cloneIndex = 0;
+ if ( !appendToTmplItems ) {
+ jQuery.tmpl.complete( newTmplItems );
+ }
+ return this;
+ }
+ });
+
+ jQuery.extend({
+ // Return wrapped set of template items, obtained by rendering template against data.
+ tmpl: function( tmpl, data, options, parentItem ) {
+ var ret, topLevel = !parentItem;
+ if ( topLevel ) {
+ // This is a top-level tmpl call (not from a nested template using {{tmpl}})
+ parentItem = topTmplItem;
+ tmpl = jQuery.template[tmpl] || jQuery.template( null, tmpl );
+ wrappedItems = {}; // Any wrapped items will be rebuilt, since this is top level
+ } else if ( !tmpl ) {
+ // The template item is already associated with DOM - this is a refresh.
+ // Re-evaluate rendered template for the parentItem
+ tmpl = parentItem.tmpl;
+ newTmplItems[parentItem.key] = parentItem;
+ parentItem.nodes = [];
+ if ( parentItem.wrapped ) {
+ updateWrapped( parentItem, parentItem.wrapped );
+ }
+ // Rebuild, without creating a new template item
+ return jQuery( build( parentItem, null, parentItem.tmpl( jQuery, parentItem ) ));
+ }
+ if ( !tmpl ) {
+ return []; // Could throw...
+ }
+ if ( typeof data === "function" ) {
+ data = data.call( parentItem || {} );
+ }
+ if ( options && options.wrapped ) {
+ updateWrapped( options, options.wrapped );
+ }
+ ret = jQuery.isArray( data ) ?
+ jQuery.map( data, function( dataItem ) {
+ return dataItem ? newTmplItem( options, parentItem, tmpl, dataItem ) : null;
+ }) :
+ [ newTmplItem( options, parentItem, tmpl, data ) ];
+ return topLevel ? jQuery( build( parentItem, null, ret ) ) : ret;
+ },
+
+ // Return rendered template item for an element.
+ tmplItem: function( elem ) {
+ var tmplItem;
+ if ( elem instanceof jQuery ) {
+ elem = elem[0];
+ }
+ while ( elem && elem.nodeType === 1 && !(tmplItem = jQuery.data( elem, "tmplItem" )) && (elem = elem.parentNode) ) {}
+ return tmplItem || topTmplItem;
+ },
+
+ // Set:
+ // Use $.template( name, tmpl ) to cache a named template,
+ // where tmpl is a template string, a script element or a jQuery instance wrapping a script element, etc.
+ // Use $( "selector" ).template( name ) to provide access by name to a script block template declaration.
+
+ // Get:
+ // Use $.template( name ) to access a cached template.
+ // Also $( selectorToScriptBlock ).template(), or $.template( null, templateString )
+ // will return the compiled template, without adding a name reference.
+ // If templateString includes at least one HTML tag, $.template( templateString ) is equivalent
+ // to $.template( null, templateString )
+ template: function( name, tmpl ) {
+ if (tmpl) {
+ // Compile template and associate with name
+ if ( typeof tmpl === "string" ) {
+ // This is an HTML string being passed directly in.
+ tmpl = buildTmplFn( tmpl )
+ } else if ( tmpl instanceof jQuery ) {
+ tmpl = tmpl[0] || {};
+ }
+ if ( tmpl.nodeType ) {
+ // If this is a template block, use cached copy, or generate tmpl function and cache.
+ tmpl = jQuery.data( tmpl, "tmpl" ) || jQuery.data( tmpl, "tmpl", buildTmplFn( tmpl.innerHTML ));
+ }
+ return typeof name === "string" ? (jQuery.template[name] = tmpl) : tmpl;
+ }
+ // Return named compiled template
+ return name ? (typeof name !== "string" ? jQuery.template( null, name ):
+ (jQuery.template[name] ||
+ // If not in map, treat as a selector. (If integrated with core, use quickExpr.exec)
+ jQuery.template( null, htmlExpr.test( name ) ? name : jQuery( name )))) : null;
+ },
+
+ encode: function( text ) {
+ // Do HTML encoding replacing < > & and ' and " by corresponding entities.
+ return ("" + text).split("<").join("<").split(">").join(">").split('"').join(""").split("'").join("'");
+ }
+ });
+
+ jQuery.extend( jQuery.tmpl, {
+ tag: {
+ "tmpl": {
+ _default: { $2: "null" },
+ open: "if($notnull_1){___$$$___=___$$$___.concat($item.nest($1,$2));}"
+ // tmpl target parameter can be of type function, so use $1, not $1a (so not auto detection of functions)
+ // This means that {{tmpl foo}} treats foo as a template (which IS a function).
+ // Explicit parens can be used if foo is a function that returns a template: {{tmpl foo()}}.
+ },
+ "wrap": {
+ _default: { $2: "null" },
+ open: "$item.calls(_,$1,$2);_=[];",
+ close: "call=$item.calls();___$$$___=call.___$$$___.concat($item.wrap(call,___$$$___));"
+ },
+ "each": {
+ _default: { $2: "$index, $value" },
+ open: "if($notnull_1){$.each($1a,function($2){with(this){",
+ close: "}});}"
+ },
+ "if": {
+ open: "if(($notnull_1) && $1a){",
+ close: "}"
+ },
+ "else": {
+ _default: { $1: "true" },
+ open: "}else if(($notnull_1) && $1a){"
+ },
+ "html": {
+ // Unecoded expression evaluation.
+ open: "if($notnull_1){___$$$___.push($1a);}"
+ },
+ "=": {
+ // Encoded expression evaluation. Abbreviated form is ${}.
+ _default: { $1: "$data" },
+ open: "if($notnull_1){___$$$___.push($.encode($1a));}"
+ },
+ "!": {
+ // Comment tag. Skipped by parser
+ open: ""
+ }
+ },
+
+ // This stub can be overridden, e.g. in jquery.tmplPlus for providing rendered events
+ complete: function( items ) {
+ newTmplItems = {};
+ },
+
+ // Call this from code which overrides domManip, or equivalent
+ // Manage cloning/storing template items etc.
+ afterManip: function afterManip( elem, fragClone, callback ) {
+ // Provides cloned fragment ready for fixup prior to and after insertion into DOM
+ var content = fragClone.nodeType === 11 ?
+ jQuery.makeArray(fragClone.childNodes) :
+ fragClone.nodeType === 1 ? [fragClone] : [];
+
+ // Return fragment to original caller (e.g. append) for DOM insertion
+ callback.call( elem, fragClone );
+
+ // Fragment has been inserted:- Add inserted nodes to tmplItem data structure. Replace inserted element annotations by jQuery.data.
+ storeTmplItems( content );
+ cloneIndex++;
+ }
+ });
+
+ //========================== Private helper functions, used by code above ==========================
+
+ function build( tmplItem, nested, content ) {
+ // Convert hierarchical content into flat string array
+ // and finally return array of fragments ready for DOM insertion
+ var frag, ret = content ? jQuery.map( content, function( item ) {
+ return (typeof item === "string") ?
+ // Insert template item annotations, to be converted to jQuery.data( "tmplItem" ) when elems are inserted into DOM.
+ (tmplItem.key ? item.replace( /(<\w+)(?=[\s>])(?![^>]*_tmplitem)([^>]*)/g, "$1 " + tmplItmAtt + "=\"" + tmplItem.key + "\" $2" ) : item) :
+ // This is a child template item. Build nested template.
+ build( item, tmplItem, item._ctnt );
+ }) :
+ // If content is not defined, insert tmplItem directly. Not a template item. May be a string, or a string array, e.g. from {{html $item.html()}}.
+ tmplItem;
+ if ( nested ) {
+ return ret;
+ }
+
+ // top-level template
+ ret = ret.join("");
+
+ // Support templates which have initial or final text nodes, or consist only of text
+ // Also support HTML entities within the HTML markup.
+ ret.replace( /^\s*([^<\s][^<]*)?(<[\w\W]+>)([^>]*[^>\s])?\s*$/, function( all, before, middle, after) {
+ frag = jQuery( middle ).get();
+
+ storeTmplItems( frag );
+ if ( before ) {
+ frag = unencode( before ).concat(frag);
+ }
+ if ( after ) {
+ frag = frag.concat(unencode( after ));
+ }
+ });
+ return frag ? frag : unencode( ret );
+ }
+
+ function unencode( text ) {
+ // Use createElement, since createTextNode will not render HTML entities correctly
+ var el = document.createElement( "div" );
+ el.innerHTML = text;
+ return jQuery.makeArray(el.childNodes);
+ }
+
+ // Generate a reusable function that will serve to render a template against data
+ function buildTmplFn( markup ) {
+ return new Function("jQuery","$item",
+ "var $=jQuery,call,___$$$___=[],$data=$item.data;" +
+
+ // Introduce the data as local variables using with(){}
+ "with($data){___$$$___.push('" +
+
+ // Convert the template into pure JavaScript
+ jQuery.trim(markup)
+ .replace( /([\\'])/g, "\\$1" )
+ .replace( /[\r\t\n]/g, " " )
+ .replace( /\$\{([^\}]*)\}/g, "{{= $1}}" )
+ .replace( /\{\{(\/?)(\w+|.)(?:\(((?:[^\}]|\}(?!\}))*?)?\))?(?:\s+(.*?)?)?(\(((?:[^\}]|\}(?!\}))*?)\))?\s*\}\}/g,
+ function( all, slash, type, fnargs, target, parens, args ) {
+ var tag = jQuery.tmpl.tag[ type ], def, expr, exprAutoFnDetect;
+ if ( !tag ) {
+ throw "Template command not found: " + type;
+ }
+ def = tag._default || [];
+ if ( parens && !/\w$/.test(target)) {
+ target += parens;
+ parens = "";
+ }
+ if ( target ) {
+ target = unescape( target );
+ args = args ? ("," + unescape( args ) + ")") : (parens ? ")" : "");
+ // Support for target being things like a.toLowerCase();
+ // In that case don't call with template item as 'this' pointer. Just evaluate...
+ expr = parens ? (target.indexOf(".") > -1 ? target + parens : ("(" + target + ").call($item" + args)) : target;
+ exprAutoFnDetect = parens ? expr : "(typeof(" + target + ")==='function'?(" + target + ").call($item):(" + target + "))";
+ } else {
+ exprAutoFnDetect = expr = def.$1 || "null";
+ }
+ fnargs = unescape( fnargs );
+ return "');" +
+ tag[ slash ? "close" : "open" ]
+ .split( "$notnull_1" ).join( target ? "typeof(" + target + ")!=='undefined' && (" + target + ")!=null" : "true" )
+ .split( "$1a" ).join( exprAutoFnDetect )
+ .split( "$1" ).join( expr )
+ .split( "$2" ).join( fnargs ?
+ fnargs.replace( /\s*([^\(]+)\s*(\((.*?)\))?/g, function( all, name, parens, params ) {
+ params = params ? ("," + params + ")") : (parens ? ")" : "");
+ return params ? ("(" + name + ").call($item" + params) : all;
+ })
+ : (def.$2||"")
+ ) +
+ "___$$$___.push('";
+ }) +
+ "');}return ___$$$___;"
+ );
+ }
+ function updateWrapped( options, wrapped ) {
+ // Build the wrapped content.
+ options._wrap = build( options, true,
+ // Suport imperative scenario in which options.wrapped can be set to a selector or an HTML string.
+ jQuery.isArray( wrapped ) ? wrapped : [htmlExpr.test( wrapped ) ? wrapped : jQuery( wrapped ).html()]
+ ).join("");
+ }
+
+ function unescape( args ) {
+ return args ? args.replace( /\\'/g, "'").replace(/\\\\/g, "\\" ) : null;
+ }
+ function outerHtml( elem ) {
+ var div = document.createElement("div");
+ div.appendChild( elem.cloneNode(true) );
+ return div.innerHTML;
+ }
+
+ // Store template items in jQuery.data(), ensuring a unique tmplItem data data structure for each rendered template instance.
+ function storeTmplItems( content ) {
+ var keySuffix = "_" + cloneIndex, elem, elems, newClonedItems = {}, i, l, m;
+ for ( i = 0, l = content.length; i < l; i++ ) {
+ if ( (elem = content[i]).nodeType !== 1 ) {
+ continue;
+ }
+ elems = elem.getElementsByTagName("*");
+ for ( m = elems.length - 1; m >= 0; m-- ) {
+ processItemKey( elems[m] );
+ }
+ processItemKey( elem );
+ }
+ function processItemKey( el ) {
+ var pntKey, pntNode = el, pntItem, tmplItem, key;
+ // Ensure that each rendered template inserted into the DOM has its own template item,
+ if ( (key = el.getAttribute( tmplItmAtt ))) {
+ while ( pntNode.parentNode && (pntNode = pntNode.parentNode).nodeType === 1 && !(pntKey = pntNode.getAttribute( tmplItmAtt ))) { }
+ if ( pntKey !== key ) {
+ // The next ancestor with a _tmplitem expando is on a different key than this one.
+ // So this is a top-level element within this template item
+ // Set pntNode to the key of the parentNode, or to 0 if pntNode.parentNode is null, or pntNode is a fragment.
+ pntNode = pntNode.parentNode ? (pntNode.nodeType === 11 ? 0 : (pntNode.getAttribute( tmplItmAtt ) || 0)) : 0;
+ if ( !(tmplItem = newTmplItems[key]) ) {
+ // The item is for wrapped content, and was copied from the temporary parent wrappedItem.
+ tmplItem = wrappedItems[key];
+ tmplItem = newTmplItem( tmplItem, newTmplItems[pntNode]||wrappedItems[pntNode], null, true );
+ tmplItem.key = ++itemKey;
+ newTmplItems[itemKey] = tmplItem;
+ }
+ if ( cloneIndex ) {
+ cloneTmplItem( key );
+ }
+ }
+ el.removeAttribute( tmplItmAtt );
+ } else if ( cloneIndex && (tmplItem = jQuery.data( el, "tmplItem" )) ) {
+ // This was a rendered element, cloned during append or appendTo etc.
+ // TmplItem stored in jQuery data has already been cloned in cloneCopyEvent. We must replace it with a fresh cloned tmplItem.
+ cloneTmplItem( tmplItem.key );
+ newTmplItems[tmplItem.key] = tmplItem;
+ pntNode = jQuery.data( el.parentNode, "tmplItem" );
+ pntNode = pntNode ? pntNode.key : 0;
+ }
+ if ( tmplItem ) {
+ pntItem = tmplItem;
+ // Find the template item of the parent element.
+ // (Using !=, not !==, since pntItem.key is number, and pntNode may be a string)
+ while ( pntItem && pntItem.key != pntNode ) {
+ // Add this element as a top-level node for this rendered template item, as well as for any
+ // ancestor items between this item and the item of its parent element
+ pntItem.nodes.push( el );
+ pntItem = pntItem.parent;
+ }
+ // Delete content built during rendering - reduce API surface area and memory use, and avoid exposing of stale data after rendering...
+ delete tmplItem._ctnt;
+ delete tmplItem._wrap;
+ // Store template item as jQuery data on the element
+ jQuery.data( el, "tmplItem", tmplItem );
+ }
+ function cloneTmplItem( key ) {
+ key = key + keySuffix;
+ tmplItem = newClonedItems[key] =
+ (newClonedItems[key] || newTmplItem( tmplItem, newTmplItems[tmplItem.parent.key + keySuffix] || tmplItem.parent, null, true ));
+ }
+ }
+ }
+
+ //---- Helper functions for template item ----
+
+ function tiCalls( content, tmpl, data, options ) {
+ if ( !content ) {
+ return stack.pop();
+ }
+ stack.push({ _: content, tmpl: tmpl, item:this, data: data, options: options });
+ }
+
+ function tiNest( tmpl, data, options ) {
+ // nested template, using {{tmpl}} tag
+ return jQuery.tmpl( jQuery.template( tmpl ), data, options, this );
+ }
+
+ function tiWrap( call, wrapped ) {
+ // nested template, using {{wrap}} tag
+ var options = call.options || {};
+ options.wrapped = wrapped;
+ // Apply the template, which may incorporate wrapped content,
+ return jQuery.tmpl( jQuery.template( call.tmpl ), call.data, options, call.item );
+ }
+
+ function tiHtml( filter, textOnly ) {
+ var wrapped = this._wrap;
+ return jQuery.map(
+ jQuery( jQuery.isArray( wrapped ) ? wrapped.join("") : wrapped ).filter( filter || "*" ),
+ function(e) {
+ return textOnly ?
+ e.innerText || e.textContent :
+ e.outerHTML || outerHtml(e);
+ });
+ }
+
+ function tiUpdate() {
+ var coll = this.nodes;
+ jQuery.tmpl( null, null, null, this).insertBefore( coll[0] );
+ jQuery( coll ).remove();
+ }
+
+ Sammy = Sammy || {};
+
+ Sammy.Tmpl = function(app, method_alias) {
+
+ // *Helper:* Uses jQuery-tmpl to parse a template and interpolate and work with the passed data
+ //
+ // ### Arguments
+ //
+ // * `template` A String template. '${ }' tags are evaluated as Javascript and replaced with the elements in data.
+ // * `data` An Object containing the replacement values for the template.
+ // data is extended with the EventContext allowing you to call its methods within the template.
+ // * `name` An optional String name to cache the template.
+ //
+ var template = function(template, data, name) {
+ // use name for caching
+ if (typeof name == 'undefined') name = template;
+
+ // check the cache
+ if (!jQuery.template[name]) jQuery.template(name, template);
+
+ // we could also pass along jQuery-tmpl options as a last param?
+ return jQuery.tmpl(name, jQuery.extend({}, this, data));
+ };
+
+ // set the default method name/extension
+ if (!method_alias) method_alias = 'tmpl';
+ // create the helper at the method alias
+ app.helper(method_alias, template);
+
+ };
+})( jQuery );
diff --git a/public/javascripts/prototype.js b/public/javascripts/prototype.js
deleted file mode 100644
index 06249a6..0000000
--- a/public/javascripts/prototype.js
+++ /dev/null
@@ -1,6001 +0,0 @@
-/* Prototype JavaScript framework, version 1.7_rc2
- * (c) 2005-2010 Sam Stephenson
- *
- * Prototype is freely distributable under the terms of an MIT-style license.
- * For details, see the Prototype web site: http://www.prototypejs.org/
- *
- *--------------------------------------------------------------------------*/
-
-var Prototype = {
-
- Version: '1.7_rc2',
-
- Browser: (function(){
- var ua = navigator.userAgent;
- var isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]';
- return {
- IE: !!window.attachEvent && !isOpera,
- Opera: isOpera,
- WebKit: ua.indexOf('AppleWebKit/') > -1,
- Gecko: ua.indexOf('Gecko') > -1 && ua.indexOf('KHTML') === -1,
- MobileSafari: /Apple.*Mobile/.test(ua)
- }
- })(),
-
- BrowserFeatures: {
- XPath: !!document.evaluate,
-
- SelectorsAPI: !!document.querySelector,
-
- ElementExtensions: (function() {
- var constructor = window.Element || window.HTMLElement;
- return !!(constructor && constructor.prototype);
- })(),
- SpecificElementExtensions: (function() {
- if (typeof window.HTMLDivElement !== 'undefined')
- return true;
-
- var div = document.createElement('div'),
- form = document.createElement('form'),
- isSupported = false;
-
- if (div['__proto__'] && (div['__proto__'] !== form['__proto__'])) {
- isSupported = true;
- }
-
- div = form = null;
-
- return isSupported;
- })()
- },
-
- ScriptFragment: ']*>([\\S\\s]*?)<\/script>',
- JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,
-
- emptyFunction: function() { },
-
- K: function(x) { return x }
-};
-
-if (Prototype.Browser.MobileSafari)
- Prototype.BrowserFeatures.SpecificElementExtensions = false;
-
-
-var Abstract = { };
-
-
-var Try = {
- these: function() {
- var returnValue;
-
- for (var i = 0, length = arguments.length; i < length; i++) {
- var lambda = arguments[i];
- try {
- returnValue = lambda();
- break;
- } catch (e) { }
- }
-
- return returnValue;
- }
-};
-
-/* Based on Alex Arnell's inheritance implementation. */
-
-var Class = (function() {
-
- var IS_DONTENUM_BUGGY = (function(){
- for (var p in { toString: 1 }) {
- if (p === 'toString') return false;
- }
- return true;
- })();
-
- function subclass() {};
- function create() {
- var parent = null, properties = $A(arguments);
- if (Object.isFunction(properties[0]))
- parent = properties.shift();
-
- function klass() {
- this.initialize.apply(this, arguments);
- }
-
- Object.extend(klass, Class.Methods);
- klass.superclass = parent;
- klass.subclasses = [];
-
- if (parent) {
- subclass.prototype = parent.prototype;
- klass.prototype = new subclass;
- parent.subclasses.push(klass);
- }
-
- for (var i = 0, length = properties.length; i < length; i++)
- klass.addMethods(properties[i]);
-
- if (!klass.prototype.initialize)
- klass.prototype.initialize = Prototype.emptyFunction;
-
- klass.prototype.constructor = klass;
- return klass;
- }
-
- function addMethods(source) {
- var ancestor = this.superclass && this.superclass.prototype,
- properties = Object.keys(source);
-
- if (IS_DONTENUM_BUGGY) {
- if (source.toString != Object.prototype.toString)
- properties.push("toString");
- if (source.valueOf != Object.prototype.valueOf)
- properties.push("valueOf");
- }
-
- for (var i = 0, length = properties.length; i < length; i++) {
- var property = properties[i], value = source[property];
- if (ancestor && Object.isFunction(value) &&
- value.argumentNames()[0] == "$super") {
- var method = value;
- value = (function(m) {
- return function() { return ancestor[m].apply(this, arguments); };
- })(property).wrap(method);
-
- value.valueOf = method.valueOf.bind(method);
- value.toString = method.toString.bind(method);
- }
- this.prototype[property] = value;
- }
-
- return this;
- }
-
- return {
- create: create,
- Methods: {
- addMethods: addMethods
- }
- };
-})();
-(function() {
-
- var _toString = Object.prototype.toString,
- NULL_TYPE = 'Null',
- UNDEFINED_TYPE = 'Undefined',
- BOOLEAN_TYPE = 'Boolean',
- NUMBER_TYPE = 'Number',
- STRING_TYPE = 'String',
- OBJECT_TYPE = 'Object',
- BOOLEAN_CLASS = '[object Boolean]',
- NUMBER_CLASS = '[object Number]',
- STRING_CLASS = '[object String]',
- ARRAY_CLASS = '[object Array]',
- NATIVE_JSON_STRINGIFY_SUPPORT = window.JSON &&
- typeof JSON.stringify === 'function' &&
- JSON.stringify(0) === '0' &&
- typeof JSON.stringify(Prototype.K) === 'undefined';
-
- function Type(o) {
- switch(o) {
- case null: return NULL_TYPE;
- case (void 0): return UNDEFINED_TYPE;
- }
- var type = typeof o;
- switch(type) {
- case 'boolean': return BOOLEAN_TYPE;
- case 'number': return NUMBER_TYPE;
- case 'string': return STRING_TYPE;
- }
- return OBJECT_TYPE;
- }
-
- function extend(destination, source) {
- for (var property in source)
- destination[property] = source[property];
- return destination;
- }
-
- function inspect(object) {
- try {
- if (isUndefined(object)) return 'undefined';
- if (object === null) return 'null';
- return object.inspect ? object.inspect() : String(object);
- } catch (e) {
- if (e instanceof RangeError) return '...';
- throw e;
- }
- }
-
- function toJSON(value) {
- return Str('', { '': value }, []);
- }
-
- function Str(key, holder, stack) {
- var value = holder[key],
- type = typeof value;
-
- if (Type(value) === OBJECT_TYPE && typeof value.toJSON === 'function') {
- value = value.toJSON(key);
- }
-
- var _class = _toString.call(value);
-
- switch (_class) {
- case NUMBER_CLASS:
- case BOOLEAN_CLASS:
- case STRING_CLASS:
- value = value.valueOf();
- }
-
- switch (value) {
- case null: return 'null';
- case true: return 'true';
- case false: return 'false';
- }
-
- type = typeof value;
- switch (type) {
- case 'string':
- return value.inspect(true);
- case 'number':
- return isFinite(value) ? String(value) : 'null';
- case 'object':
-
- for (var i = 0, length = stack.length; i < length; i++) {
- if (stack[i] === value) { throw new TypeError(); }
- }
- stack.push(value);
-
- var partial = [];
- if (_class === ARRAY_CLASS) {
- for (var i = 0, length = value.length; i < length; i++) {
- var str = Str(i, value, stack);
- partial.push(typeof str === 'undefined' ? 'null' : str);
- }
- partial = '[' + partial.join(',') + ']';
- } else {
- var keys = Object.keys(value);
- for (var i = 0, length = keys.length; i < length; i++) {
- var key = keys[i], str = Str(key, value, stack);
- if (typeof str !== "undefined") {
- partial.push(key.inspect(true)+ ':' + str);
- }
- }
- partial = '{' + partial.join(',') + '}';
- }
- stack.pop();
- return partial;
- }
- }
-
- function stringify(object) {
- return JSON.stringify(object);
- }
-
- function toQueryString(object) {
- return $H(object).toQueryString();
- }
-
- function toHTML(object) {
- return object && object.toHTML ? object.toHTML() : String.interpret(object);
- }
-
- function keys(object) {
- if (Type(object) !== OBJECT_TYPE) { throw new TypeError(); }
- var results = [];
- for (var property in object) {
- if (object.hasOwnProperty(property)) {
- results.push(property);
- }
- }
- return results;
- }
-
- function values(object) {
- var results = [];
- for (var property in object)
- results.push(object[property]);
- return results;
- }
-
- function clone(object) {
- return extend({ }, object);
- }
-
- function isElement(object) {
- return !!(object && object.nodeType == 1);
- }
-
- function isArray(object) {
- return _toString.call(object) === ARRAY_CLASS;
- }
-
- var hasNativeIsArray = (typeof Array.isArray == 'function')
- && Array.isArray([]) && !Array.isArray({});
-
- if (hasNativeIsArray) {
- isArray = Array.isArray;
- }
-
- function isHash(object) {
- return object instanceof Hash;
- }
-
- function isFunction(object) {
- return typeof object === "function";
- }
-
- function isString(object) {
- return _toString.call(object) === STRING_CLASS;
- }
-
- function isNumber(object) {
- return _toString.call(object) === NUMBER_CLASS;
- }
-
- function isUndefined(object) {
- return typeof object === "undefined";
- }
-
- extend(Object, {
- extend: extend,
- inspect: inspect,
- toJSON: NATIVE_JSON_STRINGIFY_SUPPORT ? stringify : toJSON,
- toQueryString: toQueryString,
- toHTML: toHTML,
- keys: Object.keys || keys,
- values: values,
- clone: clone,
- isElement: isElement,
- isArray: isArray,
- isHash: isHash,
- isFunction: isFunction,
- isString: isString,
- isNumber: isNumber,
- isUndefined: isUndefined
- });
-})();
-Object.extend(Function.prototype, (function() {
- var slice = Array.prototype.slice;
-
- function update(array, args) {
- var arrayLength = array.length, length = args.length;
- while (length--) array[arrayLength + length] = args[length];
- return array;
- }
-
- function merge(array, args) {
- array = slice.call(array, 0);
- return update(array, args);
- }
-
- function argumentNames() {
- var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
- .replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
- .replace(/\s+/g, '').split(',');
- return names.length == 1 && !names[0] ? [] : names;
- }
-
- function bind(context) {
- if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
- var __method = this, args = slice.call(arguments, 1);
- return function() {
- var a = merge(args, arguments);
- return __method.apply(context, a);
- }
- }
-
- function bindAsEventListener(context) {
- var __method = this, args = slice.call(arguments, 1);
- return function(event) {
- var a = update([event || window.event], args);
- return __method.apply(context, a);
- }
- }
-
- function curry() {
- if (!arguments.length) return this;
- var __method = this, args = slice.call(arguments, 0);
- return function() {
- var a = merge(args, arguments);
- return __method.apply(this, a);
- }
- }
-
- function delay(timeout) {
- var __method = this, args = slice.call(arguments, 1);
- timeout = timeout * 1000;
- return window.setTimeout(function() {
- return __method.apply(__method, args);
- }, timeout);
- }
-
- function defer() {
- var args = update([0.01], arguments);
- return this.delay.apply(this, args);
- }
-
- function wrap(wrapper) {
- var __method = this;
- return function() {
- var a = update([__method.bind(this)], arguments);
- return wrapper.apply(this, a);
- }
- }
-
- function methodize() {
- if (this._methodized) return this._methodized;
- var __method = this;
- return this._methodized = function() {
- var a = update([this], arguments);
- return __method.apply(null, a);
- };
- }
-
- return {
- argumentNames: argumentNames,
- bind: bind,
- bindAsEventListener: bindAsEventListener,
- curry: curry,
- delay: delay,
- defer: defer,
- wrap: wrap,
- methodize: methodize
- }
-})());
-
-
-
-(function(proto) {
-
-
- function toISOString() {
- return this.getUTCFullYear() + '-' +
- (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
- this.getUTCDate().toPaddedString(2) + 'T' +
- this.getUTCHours().toPaddedString(2) + ':' +
- this.getUTCMinutes().toPaddedString(2) + ':' +
- this.getUTCSeconds().toPaddedString(2) + 'Z';
- }
-
-
- function toJSON() {
- return this.toISOString();
- }
-
- if (!proto.toISOString) proto.toISOString = toISOString;
- if (!proto.toJSON) proto.toJSON = toJSON;
-
-})(Date.prototype);
-
-
-RegExp.prototype.match = RegExp.prototype.test;
-
-RegExp.escape = function(str) {
- return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
-};
-var PeriodicalExecuter = Class.create({
- initialize: function(callback, frequency) {
- this.callback = callback;
- this.frequency = frequency;
- this.currentlyExecuting = false;
-
- this.registerCallback();
- },
-
- registerCallback: function() {
- this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
- },
-
- execute: function() {
- this.callback(this);
- },
-
- stop: function() {
- if (!this.timer) return;
- clearInterval(this.timer);
- this.timer = null;
- },
-
- onTimerEvent: function() {
- if (!this.currentlyExecuting) {
- try {
- this.currentlyExecuting = true;
- this.execute();
- this.currentlyExecuting = false;
- } catch(e) {
- this.currentlyExecuting = false;
- throw e;
- }
- }
- }
-});
-Object.extend(String, {
- interpret: function(value) {
- return value == null ? '' : String(value);
- },
- specialChar: {
- '\b': '\\b',
- '\t': '\\t',
- '\n': '\\n',
- '\f': '\\f',
- '\r': '\\r',
- '\\': '\\\\'
- }
-});
-
-Object.extend(String.prototype, (function() {
- var NATIVE_JSON_PARSE_SUPPORT = window.JSON &&
- typeof JSON.parse === 'function' &&
- JSON.parse('{"test": true}').test;
-
- function prepareReplacement(replacement) {
- if (Object.isFunction(replacement)) return replacement;
- var template = new Template(replacement);
- return function(match) { return template.evaluate(match) };
- }
-
- function gsub(pattern, replacement) {
- var result = '', source = this, match;
- replacement = prepareReplacement(replacement);
-
- if (Object.isString(pattern))
- pattern = RegExp.escape(pattern);
-
- if (!(pattern.length || pattern.source)) {
- replacement = replacement('');
- return replacement + source.split('').join(replacement) + replacement;
- }
-
- while (source.length > 0) {
- if (match = source.match(pattern)) {
- result += source.slice(0, match.index);
- result += String.interpret(replacement(match));
- source = source.slice(match.index + match[0].length);
- } else {
- result += source, source = '';
- }
- }
- return result;
- }
-
- function sub(pattern, replacement, count) {
- replacement = prepareReplacement(replacement);
- count = Object.isUndefined(count) ? 1 : count;
-
- return this.gsub(pattern, function(match) {
- if (--count < 0) return match[0];
- return replacement(match);
- });
- }
-
- function scan(pattern, iterator) {
- this.gsub(pattern, iterator);
- return String(this);
- }
-
- function truncate(length, truncation) {
- length = length || 30;
- truncation = Object.isUndefined(truncation) ? '...' : truncation;
- return this.length > length ?
- this.slice(0, length - truncation.length) + truncation : String(this);
- }
-
- function strip() {
- return this.replace(/^\s+/, '').replace(/\s+$/, '');
- }
-
- function stripTags() {
- return this.replace(/<\w+(\s+("[^"]*"|'[^']*'|[^>])+)?>|<\/\w+>/gi, '');
- }
-
- function stripScripts() {
- return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
- }
-
- function extractScripts() {
- var matchAll = new RegExp(Prototype.ScriptFragment, 'img'),
- matchOne = new RegExp(Prototype.ScriptFragment, 'im');
- return (this.match(matchAll) || []).map(function(scriptTag) {
- return (scriptTag.match(matchOne) || ['', ''])[1];
- });
- }
-
- function evalScripts() {
- return this.extractScripts().map(function(script) { return eval(script) });
- }
-
- function escapeHTML() {
- return this.replace(/&/g,'&').replace(//g,'>');
- }
-
- function unescapeHTML() {
- return this.stripTags().replace(/</g,'<').replace(/>/g,'>').replace(/&/g,'&');
- }
-
-
- function toQueryParams(separator) {
- var match = this.strip().match(/([^?#]*)(#.*)?$/);
- if (!match) return { };
-
- return match[1].split(separator || '&').inject({ }, function(hash, pair) {
- if ((pair = pair.split('='))[0]) {
- var key = decodeURIComponent(pair.shift()),
- value = pair.length > 1 ? pair.join('=') : pair[0];
-
- if (value != undefined) value = decodeURIComponent(value);
-
- if (key in hash) {
- if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
- hash[key].push(value);
- }
- else hash[key] = value;
- }
- return hash;
- });
- }
-
- function toArray() {
- return this.split('');
- }
-
- function succ() {
- return this.slice(0, this.length - 1) +
- String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
- }
-
- function times(count) {
- return count < 1 ? '' : new Array(count + 1).join(this);
- }
-
- function camelize() {
- return this.replace(/-+(.)?/g, function(match, chr) {
- return chr ? chr.toUpperCase() : '';
- });
- }
-
- function capitalize() {
- return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
- }
-
- function underscore() {
- return this.replace(/::/g, '/')
- .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
- .replace(/([a-z\d])([A-Z])/g, '$1_$2')
- .replace(/-/g, '_')
- .toLowerCase();
- }
-
- function dasherize() {
- return this.replace(/_/g, '-');
- }
-
- function inspect(useDoubleQuotes) {
- var escapedString = this.replace(/[\x00-\x1f\\]/g, function(character) {
- if (character in String.specialChar) {
- return String.specialChar[character];
- }
- return '\\u00' + character.charCodeAt().toPaddedString(2, 16);
- });
- if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
- return "'" + escapedString.replace(/'/g, '\\\'') + "'";
- }
-
- function unfilterJSON(filter) {
- return this.replace(filter || Prototype.JSONFilter, '$1');
- }
-
- function isJSON() {
- var str = this;
- if (str.blank()) return false;
- str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
- str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
- str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
- return (/^[\],:{}\s]*$/).test(str);
- }
-
- function evalJSON(sanitize) {
- var json = this.unfilterJSON(),
- cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
- if (cx.test(json)) {
- json = json.replace(cx, function (a) {
- return '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
- });
- }
- try {
- if (!sanitize || json.isJSON()) return eval('(' + json + ')');
- } catch (e) { }
- throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
- }
-
- function parseJSON() {
- var json = this.unfilterJSON();
- return JSON.parse(json);
- }
-
- function include(pattern) {
- return this.indexOf(pattern) > -1;
- }
-
- function startsWith(pattern) {
- return this.lastIndexOf(pattern, 0) === 0;
- }
-
- function endsWith(pattern) {
- var d = this.length - pattern.length;
- return d >= 0 && this.indexOf(pattern, d) === d;
- }
-
- function empty() {
- return this == '';
- }
-
- function blank() {
- return /^\s*$/.test(this);
- }
-
- function interpolate(object, pattern) {
- return new Template(this, pattern).evaluate(object);
- }
-
- return {
- gsub: gsub,
- sub: sub,
- scan: scan,
- truncate: truncate,
- strip: String.prototype.trim || strip,
- stripTags: stripTags,
- stripScripts: stripScripts,
- extractScripts: extractScripts,
- evalScripts: evalScripts,
- escapeHTML: escapeHTML,
- unescapeHTML: unescapeHTML,
- toQueryParams: toQueryParams,
- parseQuery: toQueryParams,
- toArray: toArray,
- succ: succ,
- times: times,
- camelize: camelize,
- capitalize: capitalize,
- underscore: underscore,
- dasherize: dasherize,
- inspect: inspect,
- unfilterJSON: unfilterJSON,
- isJSON: isJSON,
- evalJSON: NATIVE_JSON_PARSE_SUPPORT ? parseJSON : evalJSON,
- include: include,
- startsWith: startsWith,
- endsWith: endsWith,
- empty: empty,
- blank: blank,
- interpolate: interpolate
- };
-})());
-
-var Template = Class.create({
- initialize: function(template, pattern) {
- this.template = template.toString();
- this.pattern = pattern || Template.Pattern;
- },
-
- evaluate: function(object) {
- if (object && Object.isFunction(object.toTemplateReplacements))
- object = object.toTemplateReplacements();
-
- return this.template.gsub(this.pattern, function(match) {
- if (object == null) return (match[1] + '');
-
- var before = match[1] || '';
- if (before == '\\') return match[2];
-
- var ctx = object, expr = match[3],
- pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
-
- match = pattern.exec(expr);
- if (match == null) return before;
-
- while (match != null) {
- var comp = match[1].startsWith('[') ? match[2].replace(/\\\\]/g, ']') : match[1];
- ctx = ctx[comp];
- if (null == ctx || '' == match[3]) break;
- expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
- match = pattern.exec(expr);
- }
-
- return before + String.interpret(ctx);
- });
- }
-});
-Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
-
-var $break = { };
-
-var Enumerable = (function() {
- function each(iterator, context) {
- var index = 0;
- try {
- this._each(function(value) {
- iterator.call(context, value, index++);
- });
- } catch (e) {
- if (e != $break) throw e;
- }
- return this;
- }
-
- function eachSlice(number, iterator, context) {
- var index = -number, slices = [], array = this.toArray();
- if (number < 1) return array;
- while ((index += number) < array.length)
- slices.push(array.slice(index, index+number));
- return slices.collect(iterator, context);
- }
-
- function all(iterator, context) {
- iterator = iterator || Prototype.K;
- var result = true;
- this.each(function(value, index) {
- result = result && !!iterator.call(context, value, index);
- if (!result) throw $break;
- });
- return result;
- }
-
- function any(iterator, context) {
- iterator = iterator || Prototype.K;
- var result = false;
- this.each(function(value, index) {
- if (result = !!iterator.call(context, value, index))
- throw $break;
- });
- return result;
- }
-
- function collect(iterator, context) {
- iterator = iterator || Prototype.K;
- var results = [];
- this.each(function(value, index) {
- results.push(iterator.call(context, value, index));
- });
- return results;
- }
-
- function detect(iterator, context) {
- var result;
- this.each(function(value, index) {
- if (iterator.call(context, value, index)) {
- result = value;
- throw $break;
- }
- });
- return result;
- }
-
- function findAll(iterator, context) {
- var results = [];
- this.each(function(value, index) {
- if (iterator.call(context, value, index))
- results.push(value);
- });
- return results;
- }
-
- function grep(filter, iterator, context) {
- iterator = iterator || Prototype.K;
- var results = [];
-
- if (Object.isString(filter))
- filter = new RegExp(RegExp.escape(filter));
-
- this.each(function(value, index) {
- if (filter.match(value))
- results.push(iterator.call(context, value, index));
- });
- return results;
- }
-
- function include(object) {
- if (Object.isFunction(this.indexOf))
- if (this.indexOf(object) != -1) return true;
-
- var found = false;
- this.each(function(value) {
- if (value == object) {
- found = true;
- throw $break;
- }
- });
- return found;
- }
-
- function inGroupsOf(number, fillWith) {
- fillWith = Object.isUndefined(fillWith) ? null : fillWith;
- return this.eachSlice(number, function(slice) {
- while(slice.length < number) slice.push(fillWith);
- return slice;
- });
- }
-
- function inject(memo, iterator, context) {
- this.each(function(value, index) {
- memo = iterator.call(context, memo, value, index);
- });
- return memo;
- }
-
- function invoke(method) {
- var args = $A(arguments).slice(1);
- return this.map(function(value) {
- return value[method].apply(value, args);
- });
- }
-
- function max(iterator, context) {
- iterator = iterator || Prototype.K;
- var result;
- this.each(function(value, index) {
- value = iterator.call(context, value, index);
- if (result == null || value >= result)
- result = value;
- });
- return result;
- }
-
- function min(iterator, context) {
- iterator = iterator || Prototype.K;
- var result;
- this.each(function(value, index) {
- value = iterator.call(context, value, index);
- if (result == null || value < result)
- result = value;
- });
- return result;
- }
-
- function partition(iterator, context) {
- iterator = iterator || Prototype.K;
- var trues = [], falses = [];
- this.each(function(value, index) {
- (iterator.call(context, value, index) ?
- trues : falses).push(value);
- });
- return [trues, falses];
- }
-
- function pluck(property) {
- var results = [];
- this.each(function(value) {
- results.push(value[property]);
- });
- return results;
- }
-
- function reject(iterator, context) {
- var results = [];
- this.each(function(value, index) {
- if (!iterator.call(context, value, index))
- results.push(value);
- });
- return results;
- }
-
- function sortBy(iterator, context) {
- return this.map(function(value, index) {
- return {
- value: value,
- criteria: iterator.call(context, value, index)
- };
- }).sort(function(left, right) {
- var a = left.criteria, b = right.criteria;
- return a < b ? -1 : a > b ? 1 : 0;
- }).pluck('value');
- }
-
- function toArray() {
- return this.map();
- }
-
- function zip() {
- var iterator = Prototype.K, args = $A(arguments);
- if (Object.isFunction(args.last()))
- iterator = args.pop();
-
- var collections = [this].concat(args).map($A);
- return this.map(function(value, index) {
- return iterator(collections.pluck(index));
- });
- }
-
- function size() {
- return this.toArray().length;
- }
-
- function inspect() {
- return '#';
- }
-
-
-
-
-
-
-
-
-
- return {
- each: each,
- eachSlice: eachSlice,
- all: all,
- every: all,
- any: any,
- some: any,
- collect: collect,
- map: collect,
- detect: detect,
- findAll: findAll,
- select: findAll,
- filter: findAll,
- grep: grep,
- include: include,
- member: include,
- inGroupsOf: inGroupsOf,
- inject: inject,
- invoke: invoke,
- max: max,
- min: min,
- partition: partition,
- pluck: pluck,
- reject: reject,
- sortBy: sortBy,
- toArray: toArray,
- entries: toArray,
- zip: zip,
- size: size,
- inspect: inspect,
- find: detect
- };
-})();
-
-function $A(iterable) {
- if (!iterable) return [];
- if ('toArray' in Object(iterable)) return iterable.toArray();
- var length = iterable.length || 0, results = new Array(length);
- while (length--) results[length] = iterable[length];
- return results;
-}
-
-
-function $w(string) {
- if (!Object.isString(string)) return [];
- string = string.strip();
- return string ? string.split(/\s+/) : [];
-}
-
-Array.from = $A;
-
-
-(function() {
- var arrayProto = Array.prototype,
- slice = arrayProto.slice,
- _each = arrayProto.forEach; // use native browser JS 1.6 implementation if available
-
- function each(iterator) {
- for (var i = 0, length = this.length; i < length; i++)
- iterator(this[i]);
- }
- if (!_each) _each = each;
-
- function clear() {
- this.length = 0;
- return this;
- }
-
- function first() {
- return this[0];
- }
-
- function last() {
- return this[this.length - 1];
- }
-
- function compact() {
- return this.select(function(value) {
- return value != null;
- });
- }
-
- function flatten() {
- return this.inject([], function(array, value) {
- if (Object.isArray(value))
- return array.concat(value.flatten());
- array.push(value);
- return array;
- });
- }
-
- function without() {
- var values = slice.call(arguments, 0);
- return this.select(function(value) {
- return !values.include(value);
- });
- }
-
- function reverse(inline) {
- return (inline === false ? this.toArray() : this)._reverse();
- }
-
- function uniq(sorted) {
- return this.inject([], function(array, value, index) {
- if (0 == index || (sorted ? array.last() != value : !array.include(value)))
- array.push(value);
- return array;
- });
- }
-
- function intersect(array) {
- return this.uniq().findAll(function(item) {
- return array.detect(function(value) { return item === value });
- });
- }
-
-
- function clone() {
- return slice.call(this, 0);
- }
-
- function size() {
- return this.length;
- }
-
- function inspect() {
- return '[' + this.map(Object.inspect).join(', ') + ']';
- }
-
- function indexOf(item, i) {
- i || (i = 0);
- var length = this.length;
- if (i < 0) i = length + i;
- for (; i < length; i++)
- if (this[i] === item) return i;
- return -1;
- }
-
- function lastIndexOf(item, i) {
- i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
- var n = this.slice(0, i).reverse().indexOf(item);
- return (n < 0) ? n : i - n - 1;
- }
-
- function concat() {
- var array = slice.call(this, 0), item;
- for (var i = 0, length = arguments.length; i < length; i++) {
- item = arguments[i];
- if (Object.isArray(item) && !('callee' in item)) {
- for (var j = 0, arrayLength = item.length; j < arrayLength; j++)
- array.push(item[j]);
- } else {
- array.push(item);
- }
- }
- return array;
- }
-
- Object.extend(arrayProto, Enumerable);
-
- if (!arrayProto._reverse)
- arrayProto._reverse = arrayProto.reverse;
-
- Object.extend(arrayProto, {
- _each: _each,
- clear: clear,
- first: first,
- last: last,
- compact: compact,
- flatten: flatten,
- without: without,
- reverse: reverse,
- uniq: uniq,
- intersect: intersect,
- clone: clone,
- toArray: clone,
- size: size,
- inspect: inspect
- });
-
- var CONCAT_ARGUMENTS_BUGGY = (function() {
- return [].concat(arguments)[0][0] !== 1;
- })(1,2)
-
- if (CONCAT_ARGUMENTS_BUGGY) arrayProto.concat = concat;
-
- if (!arrayProto.indexOf) arrayProto.indexOf = indexOf;
- if (!arrayProto.lastIndexOf) arrayProto.lastIndexOf = lastIndexOf;
-})();
-function $H(object) {
- return new Hash(object);
-};
-
-var Hash = Class.create(Enumerable, (function() {
- function initialize(object) {
- this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
- }
-
-
- function _each(iterator) {
- for (var key in this._object) {
- var value = this._object[key], pair = [key, value];
- pair.key = key;
- pair.value = value;
- iterator(pair);
- }
- }
-
- function set(key, value) {
- return this._object[key] = value;
- }
-
- function get(key) {
- if (this._object[key] !== Object.prototype[key])
- return this._object[key];
- }
-
- function unset(key) {
- var value = this._object[key];
- delete this._object[key];
- return value;
- }
-
- function toObject() {
- return Object.clone(this._object);
- }
-
-
-
- function keys() {
- return this.pluck('key');
- }
-
- function values() {
- return this.pluck('value');
- }
-
- function index(value) {
- var match = this.detect(function(pair) {
- return pair.value === value;
- });
- return match && match.key;
- }
-
- function merge(object) {
- return this.clone().update(object);
- }
-
- function update(object) {
- return new Hash(object).inject(this, function(result, pair) {
- result.set(pair.key, pair.value);
- return result;
- });
- }
-
- function toQueryPair(key, value) {
- if (Object.isUndefined(value)) return key;
- return key + '=' + encodeURIComponent(String.interpret(value));
- }
-
- function toQueryString() {
- return this.inject([], function(results, pair) {
- var key = encodeURIComponent(pair.key), values = pair.value;
-
- if (values && typeof values == 'object') {
- if (Object.isArray(values))
- return results.concat(values.map(toQueryPair.curry(key)));
- } else results.push(toQueryPair(key, values));
- return results;
- }).join('&');
- }
-
- function inspect() {
- return '#';
- }
-
- function clone() {
- return new Hash(this);
- }
-
- return {
- initialize: initialize,
- _each: _each,
- set: set,
- get: get,
- unset: unset,
- toObject: toObject,
- toTemplateReplacements: toObject,
- keys: keys,
- values: values,
- index: index,
- merge: merge,
- update: update,
- toQueryString: toQueryString,
- inspect: inspect,
- toJSON: toObject,
- clone: clone
- };
-})());
-
-Hash.from = $H;
-Object.extend(Number.prototype, (function() {
- function toColorPart() {
- return this.toPaddedString(2, 16);
- }
-
- function succ() {
- return this + 1;
- }
-
- function times(iterator, context) {
- $R(0, this, true).each(iterator, context);
- return this;
- }
-
- function toPaddedString(length, radix) {
- var string = this.toString(radix || 10);
- return '0'.times(length - string.length) + string;
- }
-
- function abs() {
- return Math.abs(this);
- }
-
- function round() {
- return Math.round(this);
- }
-
- function ceil() {
- return Math.ceil(this);
- }
-
- function floor() {
- return Math.floor(this);
- }
-
- return {
- toColorPart: toColorPart,
- succ: succ,
- times: times,
- toPaddedString: toPaddedString,
- abs: abs,
- round: round,
- ceil: ceil,
- floor: floor
- };
-})());
-
-function $R(start, end, exclusive) {
- return new ObjectRange(start, end, exclusive);
-}
-
-var ObjectRange = Class.create(Enumerable, (function() {
- function initialize(start, end, exclusive) {
- this.start = start;
- this.end = end;
- this.exclusive = exclusive;
- }
-
- function _each(iterator) {
- var value = this.start;
- while (this.include(value)) {
- iterator(value);
- value = value.succ();
- }
- }
-
- function include(value) {
- if (value < this.start)
- return false;
- if (this.exclusive)
- return value < this.end;
- return value <= this.end;
- }
-
- return {
- initialize: initialize,
- _each: _each,
- include: include
- };
-})());
-
-
-
-var Ajax = {
- getTransport: function() {
- return Try.these(
- function() {return new XMLHttpRequest()},
- function() {return new ActiveXObject('Msxml2.XMLHTTP')},
- function() {return new ActiveXObject('Microsoft.XMLHTTP')}
- ) || false;
- },
-
- activeRequestCount: 0
-};
-
-Ajax.Responders = {
- responders: [],
-
- _each: function(iterator) {
- this.responders._each(iterator);
- },
-
- register: function(responder) {
- if (!this.include(responder))
- this.responders.push(responder);
- },
-
- unregister: function(responder) {
- this.responders = this.responders.without(responder);
- },
-
- dispatch: function(callback, request, transport, json) {
- this.each(function(responder) {
- if (Object.isFunction(responder[callback])) {
- try {
- responder[callback].apply(responder, [request, transport, json]);
- } catch (e) { }
- }
- });
- }
-};
-
-Object.extend(Ajax.Responders, Enumerable);
-
-Ajax.Responders.register({
- onCreate: function() { Ajax.activeRequestCount++ },
- onComplete: function() { Ajax.activeRequestCount-- }
-});
-Ajax.Base = Class.create({
- initialize: function(options) {
- this.options = {
- method: 'post',
- asynchronous: true,
- contentType: 'application/x-www-form-urlencoded',
- encoding: 'UTF-8',
- parameters: '',
- evalJSON: true,
- evalJS: true
- };
- Object.extend(this.options, options || { });
-
- this.options.method = this.options.method.toLowerCase();
-
- if (Object.isString(this.options.parameters))
- this.options.parameters = this.options.parameters.toQueryParams();
- else if (Object.isHash(this.options.parameters))
- this.options.parameters = this.options.parameters.toObject();
- }
-});
-Ajax.Request = Class.create(Ajax.Base, {
- _complete: false,
-
- initialize: function($super, url, options) {
- $super(options);
- this.transport = Ajax.getTransport();
- this.request(url);
- },
-
- request: function(url) {
- this.url = url;
- this.method = this.options.method;
- var params = Object.clone(this.options.parameters);
-
- if (!['get', 'post'].include(this.method)) {
- params['_method'] = this.method;
- this.method = 'post';
- }
-
- this.parameters = params;
-
- if (params = Object.toQueryString(params)) {
- if (this.method == 'get')
- this.url += (this.url.include('?') ? '&' : '?') + params;
- else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
- params += '&_=';
- }
-
- try {
- var response = new Ajax.Response(this);
- if (this.options.onCreate) this.options.onCreate(response);
- Ajax.Responders.dispatch('onCreate', this, response);
-
- this.transport.open(this.method.toUpperCase(), this.url,
- this.options.asynchronous);
-
- if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);
-
- this.transport.onreadystatechange = this.onStateChange.bind(this);
- this.setRequestHeaders();
-
- this.body = this.method == 'post' ? (this.options.postBody || params) : null;
- this.transport.send(this.body);
-
- /* Force Firefox to handle ready state 4 for synchronous requests */
- if (!this.options.asynchronous && this.transport.overrideMimeType)
- this.onStateChange();
-
- }
- catch (e) {
- this.dispatchException(e);
- }
- },
-
- onStateChange: function() {
- var readyState = this.transport.readyState;
- if (readyState > 1 && !((readyState == 4) && this._complete))
- this.respondToReadyState(this.transport.readyState);
- },
-
- setRequestHeaders: function() {
- var headers = {
- 'X-Requested-With': 'XMLHttpRequest',
- 'X-Prototype-Version': Prototype.Version,
- 'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
- };
-
- if (this.method == 'post') {
- headers['Content-type'] = this.options.contentType +
- (this.options.encoding ? '; charset=' + this.options.encoding : '');
-
- /* Force "Connection: close" for older Mozilla browsers to work
- * around a bug where XMLHttpRequest sends an incorrect
- * Content-length header. See Mozilla Bugzilla #246651.
- */
- if (this.transport.overrideMimeType &&
- (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
- headers['Connection'] = 'close';
- }
-
- if (typeof this.options.requestHeaders == 'object') {
- var extras = this.options.requestHeaders;
-
- if (Object.isFunction(extras.push))
- for (var i = 0, length = extras.length; i < length; i += 2)
- headers[extras[i]] = extras[i+1];
- else
- $H(extras).each(function(pair) { headers[pair.key] = pair.value });
- }
-
- for (var name in headers)
- this.transport.setRequestHeader(name, headers[name]);
- },
-
- success: function() {
- var status = this.getStatus();
- return !status || (status >= 200 && status < 300);
- },
-
- getStatus: function() {
- try {
- return this.transport.status || 0;
- } catch (e) { return 0 }
- },
-
- respondToReadyState: function(readyState) {
- var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this);
-
- if (state == 'Complete') {
- try {
- this._complete = true;
- (this.options['on' + response.status]
- || this.options['on' + (this.success() ? 'Success' : 'Failure')]
- || Prototype.emptyFunction)(response, response.headerJSON);
- } catch (e) {
- this.dispatchException(e);
- }
-
- var contentType = response.getHeader('Content-type');
- if (this.options.evalJS == 'force'
- || (this.options.evalJS && this.isSameOrigin() && contentType
- && contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i)))
- this.evalResponse();
- }
-
- try {
- (this.options['on' + state] || Prototype.emptyFunction)(response, response.headerJSON);
- Ajax.Responders.dispatch('on' + state, this, response, response.headerJSON);
- } catch (e) {
- this.dispatchException(e);
- }
-
- if (state == 'Complete') {
- this.transport.onreadystatechange = Prototype.emptyFunction;
- }
- },
-
- isSameOrigin: function() {
- var m = this.url.match(/^\s*https?:\/\/[^\/]*/);
- return !m || (m[0] == '#{protocol}//#{domain}#{port}'.interpolate({
- protocol: location.protocol,
- domain: document.domain,
- port: location.port ? ':' + location.port : ''
- }));
- },
-
- getHeader: function(name) {
- try {
- return this.transport.getResponseHeader(name) || null;
- } catch (e) { return null; }
- },
-
- evalResponse: function() {
- try {
- return eval((this.transport.responseText || '').unfilterJSON());
- } catch (e) {
- this.dispatchException(e);
- }
- },
-
- dispatchException: function(exception) {
- (this.options.onException || Prototype.emptyFunction)(this, exception);
- Ajax.Responders.dispatch('onException', this, exception);
- }
-});
-
-Ajax.Request.Events =
- ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
-
-
-
-
-
-
-
-
-Ajax.Response = Class.create({
- initialize: function(request){
- this.request = request;
- var transport = this.transport = request.transport,
- readyState = this.readyState = transport.readyState;
-
- if ((readyState > 2 && !Prototype.Browser.IE) || readyState == 4) {
- this.status = this.getStatus();
- this.statusText = this.getStatusText();
- this.responseText = String.interpret(transport.responseText);
- this.headerJSON = this._getHeaderJSON();
- }
-
- if (readyState == 4) {
- var xml = transport.responseXML;
- this.responseXML = Object.isUndefined(xml) ? null : xml;
- this.responseJSON = this._getResponseJSON();
- }
- },
-
- status: 0,
-
- statusText: '',
-
- getStatus: Ajax.Request.prototype.getStatus,
-
- getStatusText: function() {
- try {
- return this.transport.statusText || '';
- } catch (e) { return '' }
- },
-
- getHeader: Ajax.Request.prototype.getHeader,
-
- getAllHeaders: function() {
- try {
- return this.getAllResponseHeaders();
- } catch (e) { return null }
- },
-
- getResponseHeader: function(name) {
- return this.transport.getResponseHeader(name);
- },
-
- getAllResponseHeaders: function() {
- return this.transport.getAllResponseHeaders();
- },
-
- _getHeaderJSON: function() {
- var json = this.getHeader('X-JSON');
- if (!json) return null;
- json = decodeURIComponent(escape(json));
- try {
- return json.evalJSON(this.request.options.sanitizeJSON ||
- !this.request.isSameOrigin());
- } catch (e) {
- this.request.dispatchException(e);
- }
- },
-
- _getResponseJSON: function() {
- var options = this.request.options;
- if (!options.evalJSON || (options.evalJSON != 'force' &&
- !(this.getHeader('Content-type') || '').include('application/json')) ||
- this.responseText.blank())
- return null;
- try {
- return this.responseText.evalJSON(options.sanitizeJSON ||
- !this.request.isSameOrigin());
- } catch (e) {
- this.request.dispatchException(e);
- }
- }
-});
-
-Ajax.Updater = Class.create(Ajax.Request, {
- initialize: function($super, container, url, options) {
- this.container = {
- success: (container.success || container),
- failure: (container.failure || (container.success ? null : container))
- };
-
- options = Object.clone(options);
- var onComplete = options.onComplete;
- options.onComplete = (function(response, json) {
- this.updateContent(response.responseText);
- if (Object.isFunction(onComplete)) onComplete(response, json);
- }).bind(this);
-
- $super(url, options);
- },
-
- updateContent: function(responseText) {
- var receiver = this.container[this.success() ? 'success' : 'failure'],
- options = this.options;
-
- if (!options.evalScripts) responseText = responseText.stripScripts();
-
- if (receiver = $(receiver)) {
- if (options.insertion) {
- if (Object.isString(options.insertion)) {
- var insertion = { }; insertion[options.insertion] = responseText;
- receiver.insert(insertion);
- }
- else options.insertion(receiver, responseText);
- }
- else receiver.update(responseText);
- }
- }
-});
-
-Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
- initialize: function($super, container, url, options) {
- $super(options);
- this.onComplete = this.options.onComplete;
-
- this.frequency = (this.options.frequency || 2);
- this.decay = (this.options.decay || 1);
-
- this.updater = { };
- this.container = container;
- this.url = url;
-
- this.start();
- },
-
- start: function() {
- this.options.onComplete = this.updateComplete.bind(this);
- this.onTimerEvent();
- },
-
- stop: function() {
- this.updater.options.onComplete = undefined;
- clearTimeout(this.timer);
- (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
- },
-
- updateComplete: function(response) {
- if (this.options.decay) {
- this.decay = (response.responseText == this.lastText ?
- this.decay * this.options.decay : 1);
-
- this.lastText = response.responseText;
- }
- this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
- },
-
- onTimerEvent: function() {
- this.updater = new Ajax.Updater(this.container, this.url, this.options);
- }
-});
-
-
-function $(element) {
- if (arguments.length > 1) {
- for (var i = 0, elements = [], length = arguments.length; i < length; i++)
- elements.push($(arguments[i]));
- return elements;
- }
- if (Object.isString(element))
- element = document.getElementById(element);
- return Element.extend(element);
-}
-
-if (Prototype.BrowserFeatures.XPath) {
- document._getElementsByXPath = function(expression, parentElement) {
- var results = [];
- var query = document.evaluate(expression, $(parentElement) || document,
- null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
- for (var i = 0, length = query.snapshotLength; i < length; i++)
- results.push(Element.extend(query.snapshotItem(i)));
- return results;
- };
-}
-
-/*--------------------------------------------------------------------------*/
-
-if (!Node) var Node = { };
-
-if (!Node.ELEMENT_NODE) {
- Object.extend(Node, {
- ELEMENT_NODE: 1,
- ATTRIBUTE_NODE: 2,
- TEXT_NODE: 3,
- CDATA_SECTION_NODE: 4,
- ENTITY_REFERENCE_NODE: 5,
- ENTITY_NODE: 6,
- PROCESSING_INSTRUCTION_NODE: 7,
- COMMENT_NODE: 8,
- DOCUMENT_NODE: 9,
- DOCUMENT_TYPE_NODE: 10,
- DOCUMENT_FRAGMENT_NODE: 11,
- NOTATION_NODE: 12
- });
-}
-
-
-
-(function(global) {
-
- var HAS_EXTENDED_CREATE_ELEMENT_SYNTAX = (function(){
- try {
- var el = document.createElement('');
- return el.tagName.toLowerCase() === 'input' && el.name === 'x';
- }
- catch(err) {
- return false;
- }
- })();
-
- var element = global.Element;
-
- global.Element = function(tagName, attributes) {
- attributes = attributes || { };
- tagName = tagName.toLowerCase();
- var cache = Element.cache;
- if (HAS_EXTENDED_CREATE_ELEMENT_SYNTAX && attributes.name) {
- tagName = '<' + tagName + ' name="' + attributes.name + '">';
- delete attributes.name;
- return Element.writeAttribute(document.createElement(tagName), attributes);
- }
- if (!cache[tagName]) cache[tagName] = Element.extend(document.createElement(tagName));
- return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
- };
-
- Object.extend(global.Element, element || { });
- if (element) global.Element.prototype = element.prototype;
-
-})(this);
-
-Element.idCounter = 1;
-Element.cache = { };
-
-function purgeElement(element) {
- var uid = element._prototypeUID;
- if (uid) {
- Element.stopObserving(element);
- element._prototypeUID = void 0;
- delete Element.Storage[uid];
- }
-}
-
-Element.Methods = {
- visible: function(element) {
- return $(element).style.display != 'none';
- },
-
- toggle: function(element) {
- element = $(element);
- Element[Element.visible(element) ? 'hide' : 'show'](element);
- return element;
- },
-
- hide: function(element) {
- element = $(element);
- element.style.display = 'none';
- return element;
- },
-
- show: function(element) {
- element = $(element);
- element.style.display = '';
- return element;
- },
-
- remove: function(element) {
- element = $(element);
- element.parentNode.removeChild(element);
- return element;
- },
-
- update: (function(){
-
- var SELECT_ELEMENT_INNERHTML_BUGGY = (function(){
- var el = document.createElement("select"),
- isBuggy = true;
- el.innerHTML = "";
- if (el.options && el.options[0]) {
- isBuggy = el.options[0].nodeName.toUpperCase() !== "OPTION";
- }
- el = null;
- return isBuggy;
- })();
-
- var TABLE_ELEMENT_INNERHTML_BUGGY = (function(){
- try {
- var el = document.createElement("table");
- if (el && el.tBodies) {
- el.innerHTML = "test ', '
', 1],
- TBODY: ['', '
', 2],
- TR: ['', '
', 3],
- TD: ['', '
', 4],
- SELECT: ['', 1]
- }
-};
-
-(function() {
- var tags = Element._insertionTranslations.tags;
- Object.extend(tags, {
- THEAD: tags.TBODY,
- TFOOT: tags.TBODY,
- TH: tags.TD
- });
-})();
-
-Element.Methods.Simulated = {
- hasAttribute: function(element, attribute) {
- attribute = Element._attributeTranslations.has[attribute] || attribute;
- var node = $(element).getAttributeNode(attribute);
- return !!(node && node.specified);
- }
-};
-
-Element.Methods.ByTag = { };
-
-Object.extend(Element, Element.Methods);
-
-(function(div) {
-
- if (!Prototype.BrowserFeatures.ElementExtensions && div['__proto__']) {
- window.HTMLElement = { };
- window.HTMLElement.prototype = div['__proto__'];
- Prototype.BrowserFeatures.ElementExtensions = true;
- }
-
- div = null;
-
-})(document.createElement('div'));
-
-Element.extend = (function() {
-
- function checkDeficiency(tagName) {
- if (typeof window.Element != 'undefined') {
- var proto = window.Element.prototype;
- if (proto) {
- var id = '_' + (Math.random()+'').slice(2),
- el = document.createElement(tagName);
- proto[id] = 'x';
- var isBuggy = (el[id] !== 'x');
- delete proto[id];
- el = null;
- return isBuggy;
- }
- }
- return false;
- }
-
- function extendElementWith(element, methods) {
- for (var property in methods) {
- var value = methods[property];
- if (Object.isFunction(value) && !(property in element))
- element[property] = value.methodize();
- }
- }
-
- var HTMLOBJECTELEMENT_PROTOTYPE_BUGGY = checkDeficiency('object');
-
- if (Prototype.BrowserFeatures.SpecificElementExtensions) {
- if (HTMLOBJECTELEMENT_PROTOTYPE_BUGGY) {
- return function(element) {
- if (element && typeof element._extendedByPrototype == 'undefined') {
- var t = element.tagName;
- if (t && (/^(?:object|applet|embed)$/i.test(t))) {
- extendElementWith(element, Element.Methods);
- extendElementWith(element, Element.Methods.Simulated);
- extendElementWith(element, Element.Methods.ByTag[t.toUpperCase()]);
- }
- }
- return element;
- }
- }
- return Prototype.K;
- }
-
- var Methods = { }, ByTag = Element.Methods.ByTag;
-
- var extend = Object.extend(function(element) {
- if (!element || typeof element._extendedByPrototype != 'undefined' ||
- element.nodeType != 1 || element == window) return element;
-
- var methods = Object.clone(Methods),
- tagName = element.tagName.toUpperCase();
-
- if (ByTag[tagName]) Object.extend(methods, ByTag[tagName]);
-
- extendElementWith(element, methods);
-
- element._extendedByPrototype = Prototype.emptyFunction;
- return element;
-
- }, {
- refresh: function() {
- if (!Prototype.BrowserFeatures.ElementExtensions) {
- Object.extend(Methods, Element.Methods);
- Object.extend(Methods, Element.Methods.Simulated);
- }
- }
- });
-
- extend.refresh();
- return extend;
-})();
-
-if (document.documentElement.hasAttribute) {
- Element.hasAttribute = function(element, attribute) {
- return element.hasAttribute(attribute);
- };
-}
-else {
- Element.hasAttribute = Element.Methods.Simulated.hasAttribute;
-}
-
-Element.addMethods = function(methods) {
- var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;
-
- if (!methods) {
- Object.extend(Form, Form.Methods);
- Object.extend(Form.Element, Form.Element.Methods);
- Object.extend(Element.Methods.ByTag, {
- "FORM": Object.clone(Form.Methods),
- "INPUT": Object.clone(Form.Element.Methods),
- "SELECT": Object.clone(Form.Element.Methods),
- "TEXTAREA": Object.clone(Form.Element.Methods)
- });
- }
-
- if (arguments.length == 2) {
- var tagName = methods;
- methods = arguments[1];
- }
-
- if (!tagName) Object.extend(Element.Methods, methods || { });
- else {
- if (Object.isArray(tagName)) tagName.each(extend);
- else extend(tagName);
- }
-
- function extend(tagName) {
- tagName = tagName.toUpperCase();
- if (!Element.Methods.ByTag[tagName])
- Element.Methods.ByTag[tagName] = { };
- Object.extend(Element.Methods.ByTag[tagName], methods);
- }
-
- function copy(methods, destination, onlyIfAbsent) {
- onlyIfAbsent = onlyIfAbsent || false;
- for (var property in methods) {
- var value = methods[property];
- if (!Object.isFunction(value)) continue;
- if (!onlyIfAbsent || !(property in destination))
- destination[property] = value.methodize();
- }
- }
-
- function findDOMClass(tagName) {
- var klass;
- var trans = {
- "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
- "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
- "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
- "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
- "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
- "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
- "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
- "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
- "FrameSet", "IFRAME": "IFrame"
- };
- if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
- if (window[klass]) return window[klass];
- klass = 'HTML' + tagName + 'Element';
- if (window[klass]) return window[klass];
- klass = 'HTML' + tagName.capitalize() + 'Element';
- if (window[klass]) return window[klass];
-
- var element = document.createElement(tagName),
- proto = element['__proto__'] || element.constructor.prototype;
-
- element = null;
- return proto;
- }
-
- var elementPrototype = window.HTMLElement ? HTMLElement.prototype :
- Element.prototype;
-
- if (F.ElementExtensions) {
- copy(Element.Methods, elementPrototype);
- copy(Element.Methods.Simulated, elementPrototype, true);
- }
-
- if (F.SpecificElementExtensions) {
- for (var tag in Element.Methods.ByTag) {
- var klass = findDOMClass(tag);
- if (Object.isUndefined(klass)) continue;
- copy(T[tag], klass.prototype);
- }
- }
-
- Object.extend(Element, Element.Methods);
- delete Element.ByTag;
-
- if (Element.extend.refresh) Element.extend.refresh();
- Element.cache = { };
-};
-
-
-document.viewport = {
-
- getDimensions: function() {
- return { width: this.getWidth(), height: this.getHeight() };
- },
-
- getScrollOffsets: function() {
- return Element._returnOffset(
- window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft,
- window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop);
- }
-};
-
-(function(viewport) {
- var B = Prototype.Browser, doc = document, element, property = {};
-
- function getRootElement() {
- if (B.WebKit && !doc.evaluate)
- return document;
-
- if (B.Opera && window.parseFloat(window.opera.version()) < 9.5)
- return document.body;
-
- return document.documentElement;
- }
-
- function define(D) {
- if (!element) element = getRootElement();
-
- property[D] = 'client' + D;
-
- viewport['get' + D] = function() { return element[property[D]] };
- return viewport['get' + D]();
- }
-
- viewport.getWidth = define.curry('Width');
-
- viewport.getHeight = define.curry('Height');
-})(document.viewport);
-
-
-Element.Storage = {
- UID: 1
-};
-
-Element.addMethods({
- getStorage: function(element) {
- if (!(element = $(element))) return;
-
- var uid;
- if (element === window) {
- uid = 0;
- } else {
- if (typeof element._prototypeUID === "undefined")
- element._prototypeUID = Element.Storage.UID++;
- uid = element._prototypeUID;
- }
-
- if (!Element.Storage[uid])
- Element.Storage[uid] = $H();
-
- return Element.Storage[uid];
- },
-
- store: function(element, key, value) {
- if (!(element = $(element))) return;
-
- if (arguments.length === 2) {
- Element.getStorage(element).update(key);
- } else {
- Element.getStorage(element).set(key, value);
- }
-
- return element;
- },
-
- retrieve: function(element, key, defaultValue) {
- if (!(element = $(element))) return;
- var hash = Element.getStorage(element), value = hash.get(key);
-
- if (Object.isUndefined(value)) {
- hash.set(key, defaultValue);
- value = defaultValue;
- }
-
- return value;
- },
-
- clone: function(element, deep) {
- if (!(element = $(element))) return;
- var clone = element.cloneNode(deep);
- clone._prototypeUID = void 0;
- if (deep) {
- var descendants = Element.select(clone, '*'),
- i = descendants.length;
- while (i--) {
- descendants[i]._prototypeUID = void 0;
- }
- }
- return Element.extend(clone);
- },
-
- purge: function(element) {
- if (!(element = $(element))) return;
- purgeElement(element);
-
- var descendants = element.getElementsByTagName('*'),
- i = descendants.length;
-
- while (i--) purgeElement(descendants[i]);
-
- return null;
- }
-});
-
-(function() {
-
- function toDecimal(pctString) {
- var match = pctString.match(/^(\d+)%?$/i);
- if (!match) return null;
- return (Number(match[1]) / 100);
- }
-
- function getPixelValue(value, property) {
- if (Object.isElement(value)) {
- element = value;
- value = element.getStyle(property);
- }
- if (value === null) {
- return null;
- }
-
- if ((/^(?:-)?\d+(\.\d+)?(px)?$/i).test(value)) {
- return window.parseFloat(value);
- }
-
- if (/\d/.test(value) && element.runtimeStyle) {
- var style = element.style.left, rStyle = element.runtimeStyle.left;
- element.runtimeStyle.left = element.currentStyle.left;
- element.style.left = value || 0;
- value = element.style.pixelLeft;
- element.style.left = style;
- element.runtimeStyle.left = rStyle;
-
- return value;
- }
-
- if (value.include('%')) {
- var decimal = toDecimal(value);
- var whole;
- if (property.include('left') || property.include('right') ||
- property.include('width')) {
- whole = $(element.parentNode).measure('width');
- } else if (property.include('top') || property.include('bottom') ||
- property.include('height')) {
- whole = $(element.parentNode).measure('height');
- }
-
- return whole * decimal;
- }
-
- return 0;
- }
-
- function toCSSPixels(number) {
- if (Object.isString(number) && number.endsWith('px')) {
- return number;
- }
- return number + 'px';
- }
-
- function isDisplayed(element) {
- var originalElement = element;
- while (element && element.parentNode) {
- var display = element.getStyle('display');
- if (display === 'none') {
- return false;
- }
- element = $(element.parentNode);
- }
- return true;
- }
-
- var hasLayout = Prototype.K;
- if ('currentStyle' in document.documentElement) {
- hasLayout = function(element) {
- if (!element.currentStyle.hasLayout) {
- element.style.zoom = 1;
- }
- return element;
- };
- }
-
- function cssNameFor(key) {
- if (key.include('border')) key = key + '-width';
- return key.camelize();
- }
-
- Element.Layout = Class.create(Hash, {
- initialize: function($super, element, preCompute) {
- $super();
- this.element = $(element);
-
- Element.Layout.PROPERTIES.each( function(property) {
- this._set(property, null);
- }, this);
-
- if (preCompute) {
- this._preComputing = true;
- this._begin();
- Element.Layout.PROPERTIES.each( this._compute, this );
- this._end();
- this._preComputing = false;
- }
- },
-
- _set: function(property, value) {
- return Hash.prototype.set.call(this, property, value);
- },
-
- set: function(property, value) {
- throw "Properties of Element.Layout are read-only.";
- },
-
- get: function($super, property) {
- var value = $super(property);
- return value === null ? this._compute(property) : value;
- },
-
- _begin: function() {
- if (this._prepared) return;
-
- var element = this.element;
- if (isDisplayed(element)) {
- this._prepared = true;
- return;
- }
-
- var originalStyles = {
- position: element.style.position || '',
- width: element.style.width || '',
- visibility: element.style.visibility || '',
- display: element.style.display || ''
- };
-
- element.store('prototype_original_styles', originalStyles);
-
- var position = element.getStyle('position'),
- width = element.getStyle('width');
-
- element.setStyle({
- position: 'absolute',
- visibility: 'hidden',
- display: 'block'
- });
-
- var positionedWidth = element.getStyle('width');
-
- var newWidth;
- if (width && (positionedWidth === width)) {
- newWidth = getPixelValue(width);
- } else if (width && (position === 'absolute' || position === 'fixed')) {
- newWidth = getPixelValue(width);
- } else {
- var parent = element.parentNode, pLayout = $(parent).getLayout();
-
- newWidth = pLayout.get('width') -
- this.get('margin-left') -
- this.get('border-left') -
- this.get('padding-left') -
- this.get('padding-right') -
- this.get('border-right') -
- this.get('margin-right');
- }
-
- element.setStyle({ width: newWidth + 'px' });
-
- this._prepared = true;
- },
-
- _end: function() {
- var element = this.element;
- var originalStyles = element.retrieve('prototype_original_styles');
- element.store('prototype_original_styles', null);
- element.setStyle(originalStyles);
- this._prepared = false;
- },
-
- _compute: function(property) {
- var COMPUTATIONS = Element.Layout.COMPUTATIONS;
- if (!(property in COMPUTATIONS)) {
- throw "Property not found.";
- }
- return this._set(property, COMPUTATIONS[property].call(this, this.element));
- },
-
- toObject: function() {
- var args = $A(arguments);
- var keys = (args.length === 0) ? Element.Layout.PROPERTIES :
- args.join(' ').split(' ');
- var obj = {};
- keys.each( function(key) {
- if (!Element.Layout.PROPERTIES.include(key)) return;
- var value = this.get(key);
- if (value != null) obj[key] = value;
- }, this);
- return obj;
- },
-
- toHash: function() {
- var obj = this.toObject.apply(this, arguments);
- return new Hash(obj);
- },
-
- toCSS: function() {
- var args = $A(arguments);
- var keys = (args.length === 0) ? Element.Layout.PROPERTIES :
- args.join(' ').split(' ');
- var css = {};
-
- keys.each( function(key) {
- if (!Element.Layout.PROPERTIES.include(key)) return;
- if (Element.Layout.COMPOSITE_PROPERTIES.include(key)) return;
-
- var value = this.get(key);
- if (value != null) css[cssNameFor(key)] = value + 'px';
- }, this);
- return css;
- },
-
- inspect: function() {
- return "#";
- }
- });
-
- Object.extend(Element.Layout, {
- PROPERTIES: $w('height width top left right bottom border-left border-right border-top border-bottom padding-left padding-right padding-top padding-bottom margin-top margin-bottom margin-left margin-right padding-box-width padding-box-height border-box-width border-box-height margin-box-width margin-box-height'),
-
- COMPOSITE_PROPERTIES: $w('padding-box-width padding-box-height margin-box-width margin-box-height border-box-width border-box-height'),
-
- COMPUTATIONS: {
- 'height': function(element) {
- if (!this._preComputing) this._begin();
-
- var bHeight = this.get('border-box-height');
- if (bHeight <= 0) return 0;
-
- var bTop = this.get('border-top'),
- bBottom = this.get('border-bottom');
-
- var pTop = this.get('padding-top'),
- pBottom = this.get('padding-bottom');
-
- if (!this._preComputing) this._end();
-
- return bHeight - bTop - bBottom - pTop - pBottom;
- },
-
- 'width': function(element) {
- if (!this._preComputing) this._begin();
-
- var bWidth = this.get('border-box-width');
- if (bWidth <= 0) return 0;
-
- var bLeft = this.get('border-left'),
- bRight = this.get('border-right');
-
- var pLeft = this.get('padding-left'),
- pRight = this.get('padding-right');
-
- if (!this._preComputing) this._end();
-
- return bWidth - bLeft - bRight - pLeft - pRight;
- },
-
- 'padding-box-height': function(element) {
- var height = this.get('height'),
- pTop = this.get('padding-top'),
- pBottom = this.get('padding-bottom');
-
- return height + pTop + pBottom;
- },
-
- 'padding-box-width': function(element) {
- var width = this.get('width'),
- pLeft = this.get('padding-left'),
- pRight = this.get('padding-right');
-
- return width + pLeft + pRight;
- },
-
- 'border-box-height': function(element) {
- return element.offsetHeight;
- },
-
- 'border-box-width': function(element) {
- return element.offsetWidth;
- },
-
- 'margin-box-height': function(element) {
- var bHeight = this.get('border-box-height'),
- mTop = this.get('margin-top'),
- mBottom = this.get('margin-bottom');
-
- if (bHeight <= 0) return 0;
-
- return bHeight + mTop + mBottom;
- },
-
- 'margin-box-width': function(element) {
- var bWidth = this.get('border-box-width'),
- mLeft = this.get('margin-left'),
- mRight = this.get('margin-right');
-
- if (bWidth <= 0) return 0;
-
- return bWidth + mLeft + mRight;
- },
-
- 'top': function(element) {
- var offset = element.positionedOffset();
- return offset.top;
- },
-
- 'bottom': function(element) {
- var offset = element.positionedOffset(),
- parent = element.getOffsetParent(),
- pHeight = parent.measure('height');
-
- var mHeight = this.get('border-box-height');
-
- return pHeight - mHeight - offset.top;
- },
-
- 'left': function(element) {
- var offset = element.positionedOffset();
- return offset.left;
- },
-
- 'right': function(element) {
- var offset = element.positionedOffset(),
- parent = element.getOffsetParent(),
- pWidth = parent.measure('width');
-
- var mWidth = this.get('border-box-width');
-
- return pWidth - mWidth - offset.left;
- },
-
- 'padding-top': function(element) {
- return getPixelValue(element, 'paddingTop');
- },
-
- 'padding-bottom': function(element) {
- return getPixelValue(element, 'paddingBottom');
- },
-
- 'padding-left': function(element) {
- return getPixelValue(element, 'paddingLeft');
- },
-
- 'padding-right': function(element) {
- return getPixelValue(element, 'paddingRight');
- },
-
- 'border-top': function(element) {
- return Object.isNumber(element.clientTop) ? element.clientTop :
- getPixelValue(element, 'borderTopWidth');
- },
-
- 'border-bottom': function(element) {
- return Object.isNumber(element.clientBottom) ? element.clientBottom :
- getPixelValue(element, 'borderBottomWidth');
- },
-
- 'border-left': function(element) {
- return Object.isNumber(element.clientLeft) ? element.clientLeft :
- getPixelValue(element, 'borderLeftWidth');
- },
-
- 'border-right': function(element) {
- return Object.isNumber(element.clientRight) ? element.clientRight :
- getPixelValue(element, 'borderRightWidth');
- },
-
- 'margin-top': function(element) {
- return getPixelValue(element, 'marginTop');
- },
-
- 'margin-bottom': function(element) {
- return getPixelValue(element, 'marginBottom');
- },
-
- 'margin-left': function(element) {
- return getPixelValue(element, 'marginLeft');
- },
-
- 'margin-right': function(element) {
- return getPixelValue(element, 'marginRight');
- }
- }
- });
-
- if ('getBoundingClientRect' in document.documentElement) {
- Object.extend(Element.Layout.COMPUTATIONS, {
- 'right': function(element) {
- var parent = hasLayout(element.getOffsetParent());
- var rect = element.getBoundingClientRect(),
- pRect = parent.getBoundingClientRect();
-
- return (pRect.right - rect.right).round();
- },
-
- 'bottom': function(element) {
- var parent = hasLayout(element.getOffsetParent());
- var rect = element.getBoundingClientRect(),
- pRect = parent.getBoundingClientRect();
-
- return (pRect.bottom - rect.bottom).round();
- }
- });
- }
-
- Element.Offset = Class.create({
- initialize: function(left, top) {
- this.left = left.round();
- this.top = top.round();
-
- this[0] = this.left;
- this[1] = this.top;
- },
-
- relativeTo: function(offset) {
- return new Element.Offset(
- this.left - offset.left,
- this.top - offset.top
- );
- },
-
- inspect: function() {
- return "#".interpolate(this);
- },
-
- toString: function() {
- return "[#{left}, #{top}]".interpolate(this);
- },
-
- toArray: function() {
- return [this.left, this.top];
- }
- });
-
- function getLayout(element, preCompute) {
- return new Element.Layout(element, preCompute);
- }
-
- function measure(element, property) {
- return $(element).getLayout().get(property);
- }
-
- function getDimensions(element) {
- var layout = $(element).getLayout();
- return {
- width: layout.get('width'),
- height: layout.get('height')
- };
- }
-
- function getOffsetParent(element) {
- if (isDetached(element)) return $(document.body);
-
- var isInline = (Element.getStyle(element, 'display') === 'inline');
- if (!isInline && element.offsetParent) return $(element.offsetParent);
- if (element === document.body) return $(element);
-
- while ((element = element.parentNode) && element !== document.body) {
- if (Element.getStyle(element, 'position') !== 'static') {
- return (element.nodeName === 'HTML') ? $(document.body) : $(element);
- }
- }
-
- return $(document.body);
- }
-
-
- function cumulativeOffset(element) {
- var valueT = 0, valueL = 0;
- do {
- valueT += element.offsetTop || 0;
- valueL += element.offsetLeft || 0;
- element = element.offsetParent;
- } while (element);
- return new Element.Offset(valueL, valueT);
- }
-
- function positionedOffset(element) {
- var layout = element.getLayout();
-
- var valueT = 0, valueL = 0;
- do {
- valueT += element.offsetTop || 0;
- valueL += element.offsetLeft || 0;
- element = element.offsetParent;
- if (element) {
- if (isBody(element)) break;
- var p = Element.getStyle(element, 'position');
- if (p !== 'static') break;
- }
- } while (element);
-
- valueL -= layout.get('margin-top');
- valueT -= layout.get('margin-left');
-
- return new Element.Offset(valueL, valueT);
- }
-
- function cumulativeScrollOffset(element) {
- var valueT = 0, valueL = 0;
- do {
- valueT += element.scrollTop || 0;
- valueL += element.scrollLeft || 0;
- element = element.parentNode;
- } while (element);
- return new Element.Offset(valueL, valueT);
- }
-
- function viewportOffset(forElement) {
- var valueT = 0, valueL = 0, docBody = document.body;
-
- var element = forElement;
- do {
- valueT += element.offsetTop || 0;
- valueL += element.offsetLeft || 0;
- if (element.offsetParent == docBody &&
- Element.getStyle(element, 'position') == 'absolute') break;
- } while (element = element.offsetParent);
-
- element = forElement;
- do {
- if (element != docBody) {
- valueT -= element.scrollTop || 0;
- valueL -= element.scrollLeft || 0;
- }
- } while (element = element.parentNode);
- return new Element.Offset(valueL, valueT);
- }
-
- function absolutize(element) {
- element = $(element);
-
- if (Element.getStyle(element, 'position') === 'absolute') {
- return element;
- }
-
- var offsetParent = getOffsetParent(element);
- var eOffset = element.viewportOffset(),
- pOffset = offsetParent.viewportOffset();
-
- var offset = eOffset.relativeTo(pOffset);
- var layout = element.getLayout();
-
- element.store('prototype_absolutize_original_styles', {
- left: element.getStyle('left'),
- top: element.getStyle('top'),
- width: element.getStyle('width'),
- height: element.getStyle('height')
- });
-
- element.setStyle({
- position: 'absolute',
- top: offset.top + 'px',
- left: offset.left + 'px',
- width: layout.get('width') + 'px',
- height: layout.get('height') + 'px'
- });
-
- return element;
- }
-
- function relativize(element) {
- element = $(element);
- if (Element.getStyle(element, 'position') === 'relative') {
- return element;
- }
-
- var originalStyles =
- element.retrieve('prototype_absolutize_original_styles');
-
- if (originalStyles) element.setStyle(originalStyles);
- return element;
- }
-
- Element.addMethods({
- getLayout: getLayout,
- measure: measure,
- getDimensions: getDimensions,
- getOffsetParent: getOffsetParent,
- cumulativeOffset: cumulativeOffset,
- positionedOffset: positionedOffset,
- cumulativeScrollOffset: cumulativeScrollOffset,
- viewportOffset: viewportOffset,
- absolutize: absolutize,
- relativize: relativize
- });
-
- function isBody(element) {
- return element.nodeName.toUpperCase() === 'BODY';
- }
-
- function isDetached(element) {
- return element !== document.body &&
- !Element.descendantOf(element, document.body);
- }
-
- if ('getBoundingClientRect' in document.documentElement) {
- Element.addMethods({
- viewportOffset: function(element) {
- element = $(element);
- if (isDetached(element)) return new Element.Offset(0, 0);
-
- var rect = element.getBoundingClientRect(),
- docEl = document.documentElement;
- return new Element.Offset(rect.left - docEl.clientLeft,
- rect.top - docEl.clientTop);
- },
-
- positionedOffset: function(element) {
- element = $(element);
- var parent = element.getOffsetParent();
- if (isDetached(element)) return new Element.Offset(0, 0);
-
- if (element.offsetParent &&
- element.offsetParent.nodeName.toUpperCase() === 'HTML') {
- return positionedOffset(element);
- }
-
- var eOffset = element.viewportOffset(),
- pOffset = isBody(parent) ? viewportOffset(parent) :
- parent.viewportOffset();
- var retOffset = eOffset.relativeTo(pOffset);
-
- var layout = element.getLayout();
- var top = retOffset.top - layout.get('margin-top');
- var left = retOffset.left - layout.get('margin-left');
-
- return new Element.Offset(left, top);
- }
- });
- }
-})();
-window.$$ = function() {
- var expression = $A(arguments).join(', ');
- return Prototype.Selector.select(expression, document);
-};
-
-Prototype.Selector = (function() {
-
- function select() {
- throw new Error('Method "Prototype.Selector.select" must be defined.');
- }
-
- function match() {
- throw new Error('Method "Prototype.Selector.match" must be defined.');
- }
-
- function find(elements, expression, index) {
- index = index || 0;
- var match = Prototype.Selector.match, length = elements.length, matchIndex = 0, i;
-
- for (i = 0; i < length; i++) {
- if (match(elements[i], expression) && index == matchIndex++) {
- return Element.extend(elements[i]);
- }
- }
- }
-
- function extendElements(elements) {
- for (var i = 0, length = elements.length; i < length; i++) {
- Element.extend(elements[i]);
- }
- return elements;
- }
-
-
- var K = Prototype.K;
-
- return {
- select: select,
- match: match,
- find: find,
- extendElements: (Element.extend === K) ? K : extendElements,
- extendElement: Element.extend
- };
-})();
-Prototype._original_property = window.Sizzle;
-/*!
- * Sizzle CSS Selector Engine - v1.0
- * Copyright 2009, The Dojo Foundation
- * Released under the MIT, BSD, and GPL Licenses.
- * More information: http://sizzlejs.com/
- */
-(function(){
-
-var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
- done = 0,
- toString = Object.prototype.toString,
- hasDuplicate = false,
- baseHasDuplicate = true;
-
-[0, 0].sort(function(){
- baseHasDuplicate = false;
- return 0;
-});
-
-var Sizzle = function(selector, context, results, seed) {
- results = results || [];
- var origContext = context = context || document;
-
- if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
- return [];
- }
-
- if ( !selector || typeof selector !== "string" ) {
- return results;
- }
-
- var parts = [], m, set, checkSet, check, mode, extra, prune = true, contextXML = isXML(context),
- soFar = selector;
-
- while ( (chunker.exec(""), m = chunker.exec(soFar)) !== null ) {
- soFar = m[3];
-
- parts.push( m[1] );
-
- if ( m[2] ) {
- extra = m[3];
- break;
- }
- }
-
- if ( parts.length > 1 && origPOS.exec( selector ) ) {
- if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
- set = posProcess( parts[0] + parts[1], context );
- } else {
- set = Expr.relative[ parts[0] ] ?
- [ context ] :
- Sizzle( parts.shift(), context );
-
- while ( parts.length ) {
- selector = parts.shift();
-
- if ( Expr.relative[ selector ] )
- selector += parts.shift();
-
- set = posProcess( selector, set );
- }
- }
- } else {
- if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
- Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
- var ret = Sizzle.find( parts.shift(), context, contextXML );
- context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
- }
-
- if ( context ) {
- var ret = seed ?
- { expr: parts.pop(), set: makeArray(seed) } :
- Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
- set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;
-
- if ( parts.length > 0 ) {
- checkSet = makeArray(set);
- } else {
- prune = false;
- }
-
- while ( parts.length ) {
- var cur = parts.pop(), pop = cur;
-
- if ( !Expr.relative[ cur ] ) {
- cur = "";
- } else {
- pop = parts.pop();
- }
-
- if ( pop == null ) {
- pop = context;
- }
-
- Expr.relative[ cur ]( checkSet, pop, contextXML );
- }
- } else {
- checkSet = parts = [];
- }
- }
-
- if ( !checkSet ) {
- checkSet = set;
- }
-
- if ( !checkSet ) {
- throw "Syntax error, unrecognized expression: " + (cur || selector);
- }
-
- if ( toString.call(checkSet) === "[object Array]" ) {
- if ( !prune ) {
- results.push.apply( results, checkSet );
- } else if ( context && context.nodeType === 1 ) {
- for ( var i = 0; checkSet[i] != null; i++ ) {
- if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
- results.push( set[i] );
- }
- }
- } else {
- for ( var i = 0; checkSet[i] != null; i++ ) {
- if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
- results.push( set[i] );
- }
- }
- }
- } else {
- makeArray( checkSet, results );
- }
-
- if ( extra ) {
- Sizzle( extra, origContext, results, seed );
- Sizzle.uniqueSort( results );
- }
-
- return results;
-};
-
-Sizzle.uniqueSort = function(results){
- if ( sortOrder ) {
- hasDuplicate = baseHasDuplicate;
- results.sort(sortOrder);
-
- if ( hasDuplicate ) {
- for ( var i = 1; i < results.length; i++ ) {
- if ( results[i] === results[i-1] ) {
- results.splice(i--, 1);
- }
- }
- }
- }
-
- return results;
-};
-
-Sizzle.matches = function(expr, set){
- return Sizzle(expr, null, null, set);
-};
-
-Sizzle.find = function(expr, context, isXML){
- var set, match;
-
- if ( !expr ) {
- return [];
- }
-
- for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
- var type = Expr.order[i], match;
-
- if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
- var left = match[1];
- match.splice(1,1);
-
- if ( left.substr( left.length - 1 ) !== "\\" ) {
- match[1] = (match[1] || "").replace(/\\/g, "");
- set = Expr.find[ type ]( match, context, isXML );
- if ( set != null ) {
- expr = expr.replace( Expr.match[ type ], "" );
- break;
- }
- }
- }
- }
-
- if ( !set ) {
- set = context.getElementsByTagName("*");
- }
-
- return {set: set, expr: expr};
-};
-
-Sizzle.filter = function(expr, set, inplace, not){
- var old = expr, result = [], curLoop = set, match, anyFound,
- isXMLFilter = set && set[0] && isXML(set[0]);
-
- while ( expr && set.length ) {
- for ( var type in Expr.filter ) {
- if ( (match = Expr.match[ type ].exec( expr )) != null ) {
- var filter = Expr.filter[ type ], found, item;
- anyFound = false;
-
- if ( curLoop == result ) {
- result = [];
- }
-
- if ( Expr.preFilter[ type ] ) {
- match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
-
- if ( !match ) {
- anyFound = found = true;
- } else if ( match === true ) {
- continue;
- }
- }
-
- if ( match ) {
- for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
- if ( item ) {
- found = filter( item, match, i, curLoop );
- var pass = not ^ !!found;
-
- if ( inplace && found != null ) {
- if ( pass ) {
- anyFound = true;
- } else {
- curLoop[i] = false;
- }
- } else if ( pass ) {
- result.push( item );
- anyFound = true;
- }
- }
- }
- }
-
- if ( found !== undefined ) {
- if ( !inplace ) {
- curLoop = result;
- }
-
- expr = expr.replace( Expr.match[ type ], "" );
-
- if ( !anyFound ) {
- return [];
- }
-
- break;
- }
- }
- }
-
- if ( expr == old ) {
- if ( anyFound == null ) {
- throw "Syntax error, unrecognized expression: " + expr;
- } else {
- break;
- }
- }
-
- old = expr;
- }
-
- return curLoop;
-};
-
-var Expr = Sizzle.selectors = {
- order: [ "ID", "NAME", "TAG" ],
- match: {
- ID: /#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
- CLASS: /\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
- NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,
- ATTR: /\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
- TAG: /^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,
- CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
- POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
- PSEUDO: /:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
- },
- leftMatch: {},
- attrMap: {
- "class": "className",
- "for": "htmlFor"
- },
- attrHandle: {
- href: function(elem){
- return elem.getAttribute("href");
- }
- },
- relative: {
- "+": function(checkSet, part, isXML){
- var isPartStr = typeof part === "string",
- isTag = isPartStr && !/\W/.test(part),
- isPartStrNotTag = isPartStr && !isTag;
-
- if ( isTag && !isXML ) {
- part = part.toUpperCase();
- }
-
- for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
- if ( (elem = checkSet[i]) ) {
- while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
-
- checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ?
- elem || false :
- elem === part;
- }
- }
-
- if ( isPartStrNotTag ) {
- Sizzle.filter( part, checkSet, true );
- }
- },
- ">": function(checkSet, part, isXML){
- var isPartStr = typeof part === "string";
-
- if ( isPartStr && !/\W/.test(part) ) {
- part = isXML ? part : part.toUpperCase();
-
- for ( var i = 0, l = checkSet.length; i < l; i++ ) {
- var elem = checkSet[i];
- if ( elem ) {
- var parent = elem.parentNode;
- checkSet[i] = parent.nodeName === part ? parent : false;
- }
- }
- } else {
- for ( var i = 0, l = checkSet.length; i < l; i++ ) {
- var elem = checkSet[i];
- if ( elem ) {
- checkSet[i] = isPartStr ?
- elem.parentNode :
- elem.parentNode === part;
- }
- }
-
- if ( isPartStr ) {
- Sizzle.filter( part, checkSet, true );
- }
- }
- },
- "": function(checkSet, part, isXML){
- var doneName = done++, checkFn = dirCheck;
-
- if ( !/\W/.test(part) ) {
- var nodeCheck = part = isXML ? part : part.toUpperCase();
- checkFn = dirNodeCheck;
- }
-
- checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
- },
- "~": function(checkSet, part, isXML){
- var doneName = done++, checkFn = dirCheck;
-
- if ( typeof part === "string" && !/\W/.test(part) ) {
- var nodeCheck = part = isXML ? part : part.toUpperCase();
- checkFn = dirNodeCheck;
- }
-
- checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
- }
- },
- find: {
- ID: function(match, context, isXML){
- if ( typeof context.getElementById !== "undefined" && !isXML ) {
- var m = context.getElementById(match[1]);
- return m ? [m] : [];
- }
- },
- NAME: function(match, context, isXML){
- if ( typeof context.getElementsByName !== "undefined" ) {
- var ret = [], results = context.getElementsByName(match[1]);
-
- for ( var i = 0, l = results.length; i < l; i++ ) {
- if ( results[i].getAttribute("name") === match[1] ) {
- ret.push( results[i] );
- }
- }
-
- return ret.length === 0 ? null : ret;
- }
- },
- TAG: function(match, context){
- return context.getElementsByTagName(match[1]);
- }
- },
- preFilter: {
- CLASS: function(match, curLoop, inplace, result, not, isXML){
- match = " " + match[1].replace(/\\/g, "") + " ";
-
- if ( isXML ) {
- return match;
- }
-
- for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
- if ( elem ) {
- if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
- if ( !inplace )
- result.push( elem );
- } else if ( inplace ) {
- curLoop[i] = false;
- }
- }
- }
-
- return false;
- },
- ID: function(match){
- return match[1].replace(/\\/g, "");
- },
- TAG: function(match, curLoop){
- for ( var i = 0; curLoop[i] === false; i++ ){}
- return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
- },
- CHILD: function(match){
- if ( match[1] == "nth" ) {
- var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
- match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
- !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
-
- match[2] = (test[1] + (test[2] || 1)) - 0;
- match[3] = test[3] - 0;
- }
-
- match[0] = done++;
-
- return match;
- },
- ATTR: function(match, curLoop, inplace, result, not, isXML){
- var name = match[1].replace(/\\/g, "");
-
- if ( !isXML && Expr.attrMap[name] ) {
- match[1] = Expr.attrMap[name];
- }
-
- if ( match[2] === "~=" ) {
- match[4] = " " + match[4] + " ";
- }
-
- return match;
- },
- PSEUDO: function(match, curLoop, inplace, result, not){
- if ( match[1] === "not" ) {
- if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
- match[3] = Sizzle(match[3], null, null, curLoop);
- } else {
- var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
- if ( !inplace ) {
- result.push.apply( result, ret );
- }
- return false;
- }
- } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
- return true;
- }
-
- return match;
- },
- POS: function(match){
- match.unshift( true );
- return match;
- }
- },
- filters: {
- enabled: function(elem){
- return elem.disabled === false && elem.type !== "hidden";
- },
- disabled: function(elem){
- return elem.disabled === true;
- },
- checked: function(elem){
- return elem.checked === true;
- },
- selected: function(elem){
- elem.parentNode.selectedIndex;
- return elem.selected === true;
- },
- parent: function(elem){
- return !!elem.firstChild;
- },
- empty: function(elem){
- return !elem.firstChild;
- },
- has: function(elem, i, match){
- return !!Sizzle( match[3], elem ).length;
- },
- header: function(elem){
- return /h\d/i.test( elem.nodeName );
- },
- text: function(elem){
- return "text" === elem.type;
- },
- radio: function(elem){
- return "radio" === elem.type;
- },
- checkbox: function(elem){
- return "checkbox" === elem.type;
- },
- file: function(elem){
- return "file" === elem.type;
- },
- password: function(elem){
- return "password" === elem.type;
- },
- submit: function(elem){
- return "submit" === elem.type;
- },
- image: function(elem){
- return "image" === elem.type;
- },
- reset: function(elem){
- return "reset" === elem.type;
- },
- button: function(elem){
- return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
- },
- input: function(elem){
- return /input|select|textarea|button/i.test(elem.nodeName);
- }
- },
- setFilters: {
- first: function(elem, i){
- return i === 0;
- },
- last: function(elem, i, match, array){
- return i === array.length - 1;
- },
- even: function(elem, i){
- return i % 2 === 0;
- },
- odd: function(elem, i){
- return i % 2 === 1;
- },
- lt: function(elem, i, match){
- return i < match[3] - 0;
- },
- gt: function(elem, i, match){
- return i > match[3] - 0;
- },
- nth: function(elem, i, match){
- return match[3] - 0 == i;
- },
- eq: function(elem, i, match){
- return match[3] - 0 == i;
- }
- },
- filter: {
- PSEUDO: function(elem, match, i, array){
- var name = match[1], filter = Expr.filters[ name ];
-
- if ( filter ) {
- return filter( elem, i, match, array );
- } else if ( name === "contains" ) {
- return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
- } else if ( name === "not" ) {
- var not = match[3];
-
- for ( var i = 0, l = not.length; i < l; i++ ) {
- if ( not[i] === elem ) {
- return false;
- }
- }
-
- return true;
- }
- },
- CHILD: function(elem, match){
- var type = match[1], node = elem;
- switch (type) {
- case 'only':
- case 'first':
- while ( (node = node.previousSibling) ) {
- if ( node.nodeType === 1 ) return false;
- }
- if ( type == 'first') return true;
- node = elem;
- case 'last':
- while ( (node = node.nextSibling) ) {
- if ( node.nodeType === 1 ) return false;
- }
- return true;
- case 'nth':
- var first = match[2], last = match[3];
-
- if ( first == 1 && last == 0 ) {
- return true;
- }
-
- var doneName = match[0],
- parent = elem.parentNode;
-
- if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
- var count = 0;
- for ( node = parent.firstChild; node; node = node.nextSibling ) {
- if ( node.nodeType === 1 ) {
- node.nodeIndex = ++count;
- }
- }
- parent.sizcache = doneName;
- }
-
- var diff = elem.nodeIndex - last;
- if ( first == 0 ) {
- return diff == 0;
- } else {
- return ( diff % first == 0 && diff / first >= 0 );
- }
- }
- },
- ID: function(elem, match){
- return elem.nodeType === 1 && elem.getAttribute("id") === match;
- },
- TAG: function(elem, match){
- return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
- },
- CLASS: function(elem, match){
- return (" " + (elem.className || elem.getAttribute("class")) + " ")
- .indexOf( match ) > -1;
- },
- ATTR: function(elem, match){
- var name = match[1],
- result = Expr.attrHandle[ name ] ?
- Expr.attrHandle[ name ]( elem ) :
- elem[ name ] != null ?
- elem[ name ] :
- elem.getAttribute( name ),
- value = result + "",
- type = match[2],
- check = match[4];
-
- return result == null ?
- type === "!=" :
- type === "=" ?
- value === check :
- type === "*=" ?
- value.indexOf(check) >= 0 :
- type === "~=" ?
- (" " + value + " ").indexOf(check) >= 0 :
- !check ?
- value && result !== false :
- type === "!=" ?
- value != check :
- type === "^=" ?
- value.indexOf(check) === 0 :
- type === "$=" ?
- value.substr(value.length - check.length) === check :
- type === "|=" ?
- value === check || value.substr(0, check.length + 1) === check + "-" :
- false;
- },
- POS: function(elem, match, i, array){
- var name = match[2], filter = Expr.setFilters[ name ];
-
- if ( filter ) {
- return filter( elem, i, match, array );
- }
- }
- }
-};
-
-var origPOS = Expr.match.POS;
-
-for ( var type in Expr.match ) {
- Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
- Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source );
-}
-
-var makeArray = function(array, results) {
- array = Array.prototype.slice.call( array, 0 );
-
- if ( results ) {
- results.push.apply( results, array );
- return results;
- }
-
- return array;
-};
-
-try {
- Array.prototype.slice.call( document.documentElement.childNodes, 0 );
-
-} catch(e){
- makeArray = function(array, results) {
- var ret = results || [];
-
- if ( toString.call(array) === "[object Array]" ) {
- Array.prototype.push.apply( ret, array );
- } else {
- if ( typeof array.length === "number" ) {
- for ( var i = 0, l = array.length; i < l; i++ ) {
- ret.push( array[i] );
- }
- } else {
- for ( var i = 0; array[i]; i++ ) {
- ret.push( array[i] );
- }
- }
- }
-
- return ret;
- };
-}
-
-var sortOrder;
-
-if ( document.documentElement.compareDocumentPosition ) {
- sortOrder = function( a, b ) {
- if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
- if ( a == b ) {
- hasDuplicate = true;
- }
- return 0;
- }
-
- var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
- if ( ret === 0 ) {
- hasDuplicate = true;
- }
- return ret;
- };
-} else if ( "sourceIndex" in document.documentElement ) {
- sortOrder = function( a, b ) {
- if ( !a.sourceIndex || !b.sourceIndex ) {
- if ( a == b ) {
- hasDuplicate = true;
- }
- return 0;
- }
-
- var ret = a.sourceIndex - b.sourceIndex;
- if ( ret === 0 ) {
- hasDuplicate = true;
- }
- return ret;
- };
-} else if ( document.createRange ) {
- sortOrder = function( a, b ) {
- if ( !a.ownerDocument || !b.ownerDocument ) {
- if ( a == b ) {
- hasDuplicate = true;
- }
- return 0;
- }
-
- var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
- aRange.setStart(a, 0);
- aRange.setEnd(a, 0);
- bRange.setStart(b, 0);
- bRange.setEnd(b, 0);
- var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
- if ( ret === 0 ) {
- hasDuplicate = true;
- }
- return ret;
- };
-}
-
-(function(){
- var form = document.createElement("div"),
- id = "script" + (new Date).getTime();
- form.innerHTML = "";
-
- var root = document.documentElement;
- root.insertBefore( form, root.firstChild );
-
- if ( !!document.getElementById( id ) ) {
- Expr.find.ID = function(match, context, isXML){
- if ( typeof context.getElementById !== "undefined" && !isXML ) {
- var m = context.getElementById(match[1]);
- return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
- }
- };
-
- Expr.filter.ID = function(elem, match){
- var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
- return elem.nodeType === 1 && node && node.nodeValue === match;
- };
- }
-
- root.removeChild( form );
- root = form = null; // release memory in IE
-})();
-
-(function(){
-
- var div = document.createElement("div");
- div.appendChild( document.createComment("") );
-
- if ( div.getElementsByTagName("*").length > 0 ) {
- Expr.find.TAG = function(match, context){
- var results = context.getElementsByTagName(match[1]);
-
- if ( match[1] === "*" ) {
- var tmp = [];
-
- for ( var i = 0; results[i]; i++ ) {
- if ( results[i].nodeType === 1 ) {
- tmp.push( results[i] );
- }
- }
-
- results = tmp;
- }
-
- return results;
- };
- }
-
- div.innerHTML = "";
- if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
- div.firstChild.getAttribute("href") !== "#" ) {
- Expr.attrHandle.href = function(elem){
- return elem.getAttribute("href", 2);
- };
- }
-
- div = null; // release memory in IE
-})();
-
-if ( document.querySelectorAll ) (function(){
- var oldSizzle = Sizzle, div = document.createElement("div");
- div.innerHTML = "";
-
- if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
- return;
- }
-
- Sizzle = function(query, context, extra, seed){
- context = context || document;
-
- if ( !seed && context.nodeType === 9 && !isXML(context) ) {
- try {
- return makeArray( context.querySelectorAll(query), extra );
- } catch(e){}
- }
-
- return oldSizzle(query, context, extra, seed);
- };
-
- for ( var prop in oldSizzle ) {
- Sizzle[ prop ] = oldSizzle[ prop ];
- }
-
- div = null; // release memory in IE
-})();
-
-if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
- var div = document.createElement("div");
- div.innerHTML = "";
-
- if ( div.getElementsByClassName("e").length === 0 )
- return;
-
- div.lastChild.className = "e";
-
- if ( div.getElementsByClassName("e").length === 1 )
- return;
-
- Expr.order.splice(1, 0, "CLASS");
- Expr.find.CLASS = function(match, context, isXML) {
- if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
- return context.getElementsByClassName(match[1]);
- }
- };
-
- div = null; // release memory in IE
-})();
-
-function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
- var sibDir = dir == "previousSibling" && !isXML;
- for ( var i = 0, l = checkSet.length; i < l; i++ ) {
- var elem = checkSet[i];
- if ( elem ) {
- if ( sibDir && elem.nodeType === 1 ){
- elem.sizcache = doneName;
- elem.sizset = i;
- }
- elem = elem[dir];
- var match = false;
-
- while ( elem ) {
- if ( elem.sizcache === doneName ) {
- match = checkSet[elem.sizset];
- break;
- }
-
- if ( elem.nodeType === 1 && !isXML ){
- elem.sizcache = doneName;
- elem.sizset = i;
- }
-
- if ( elem.nodeName === cur ) {
- match = elem;
- break;
- }
-
- elem = elem[dir];
- }
-
- checkSet[i] = match;
- }
- }
-}
-
-function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
- var sibDir = dir == "previousSibling" && !isXML;
- for ( var i = 0, l = checkSet.length; i < l; i++ ) {
- var elem = checkSet[i];
- if ( elem ) {
- if ( sibDir && elem.nodeType === 1 ) {
- elem.sizcache = doneName;
- elem.sizset = i;
- }
- elem = elem[dir];
- var match = false;
-
- while ( elem ) {
- if ( elem.sizcache === doneName ) {
- match = checkSet[elem.sizset];
- break;
- }
-
- if ( elem.nodeType === 1 ) {
- if ( !isXML ) {
- elem.sizcache = doneName;
- elem.sizset = i;
- }
- if ( typeof cur !== "string" ) {
- if ( elem === cur ) {
- match = true;
- break;
- }
-
- } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
- match = elem;
- break;
- }
- }
-
- elem = elem[dir];
- }
-
- checkSet[i] = match;
- }
- }
-}
-
-var contains = document.compareDocumentPosition ? function(a, b){
- return a.compareDocumentPosition(b) & 16;
-} : function(a, b){
- return a !== b && (a.contains ? a.contains(b) : true);
-};
-
-var isXML = function(elem){
- return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
- !!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML";
-};
-
-var posProcess = function(selector, context){
- var tmpSet = [], later = "", match,
- root = context.nodeType ? [context] : context;
-
- while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
- later += match[0];
- selector = selector.replace( Expr.match.PSEUDO, "" );
- }
-
- selector = Expr.relative[selector] ? selector + "*" : selector;
-
- for ( var i = 0, l = root.length; i < l; i++ ) {
- Sizzle( selector, root[i], tmpSet );
- }
-
- return Sizzle.filter( later, tmpSet );
-};
-
-
-window.Sizzle = Sizzle;
-
-})();
-
-;(function(engine) {
- var extendElements = Prototype.Selector.extendElements;
-
- function select(selector, scope) {
- return extendElements(engine(selector, scope || document));
- }
-
- function match(element, selector) {
- return engine.matches(selector, [element]).length == 1;
- }
-
- Prototype.Selector.engine = engine;
- Prototype.Selector.select = select;
- Prototype.Selector.match = match;
-})(Sizzle);
-
-window.Sizzle = Prototype._original_property;
-delete Prototype._original_property;
-
-var Form = {
- reset: function(form) {
- form = $(form);
- form.reset();
- return form;
- },
-
- serializeElements: function(elements, options) {
- if (typeof options != 'object') options = { hash: !!options };
- else if (Object.isUndefined(options.hash)) options.hash = true;
- var key, value, submitted = false, submit = options.submit;
-
- var data = elements.inject({ }, function(result, element) {
- if (!element.disabled && element.name) {
- key = element.name; value = $(element).getValue();
- if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
- submit !== false && (!submit || key == submit) && (submitted = true)))) {
- if (key in result) {
- if (!Object.isArray(result[key])) result[key] = [result[key]];
- result[key].push(value);
- }
- else result[key] = value;
- }
- }
- return result;
- });
-
- return options.hash ? data : Object.toQueryString(data);
- }
-};
-
-Form.Methods = {
- serialize: function(form, options) {
- return Form.serializeElements(Form.getElements(form), options);
- },
-
- getElements: function(form) {
- var elements = $(form).getElementsByTagName('*'),
- element,
- arr = [ ],
- serializers = Form.Element.Serializers;
- for (var i = 0; element = elements[i]; i++) {
- arr.push(element);
- }
- return arr.inject([], function(elements, child) {
- if (serializers[child.tagName.toLowerCase()])
- elements.push(Element.extend(child));
- return elements;
- })
- },
-
- getInputs: function(form, typeName, name) {
- form = $(form);
- var inputs = form.getElementsByTagName('input');
-
- if (!typeName && !name) return $A(inputs).map(Element.extend);
-
- for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
- var input = inputs[i];
- if ((typeName && input.type != typeName) || (name && input.name != name))
- continue;
- matchingInputs.push(Element.extend(input));
- }
-
- return matchingInputs;
- },
-
- disable: function(form) {
- form = $(form);
- Form.getElements(form).invoke('disable');
- return form;
- },
-
- enable: function(form) {
- form = $(form);
- Form.getElements(form).invoke('enable');
- return form;
- },
-
- findFirstElement: function(form) {
- var elements = $(form).getElements().findAll(function(element) {
- return 'hidden' != element.type && !element.disabled;
- });
- var firstByIndex = elements.findAll(function(element) {
- return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
- }).sortBy(function(element) { return element.tabIndex }).first();
-
- return firstByIndex ? firstByIndex : elements.find(function(element) {
- return /^(?:input|select|textarea)$/i.test(element.tagName);
- });
- },
-
- focusFirstElement: function(form) {
- form = $(form);
- form.findFirstElement().activate();
- return form;
- },
-
- request: function(form, options) {
- form = $(form), options = Object.clone(options || { });
-
- var params = options.parameters, action = form.readAttribute('action') || '';
- if (action.blank()) action = window.location.href;
- options.parameters = form.serialize(true);
-
- if (params) {
- if (Object.isString(params)) params = params.toQueryParams();
- Object.extend(options.parameters, params);
- }
-
- if (form.hasAttribute('method') && !options.method)
- options.method = form.method;
-
- return new Ajax.Request(action, options);
- }
-};
-
-/*--------------------------------------------------------------------------*/
-
-
-Form.Element = {
- focus: function(element) {
- $(element).focus();
- return element;
- },
-
- select: function(element) {
- $(element).select();
- return element;
- }
-};
-
-Form.Element.Methods = {
-
- serialize: function(element) {
- element = $(element);
- if (!element.disabled && element.name) {
- var value = element.getValue();
- if (value != undefined) {
- var pair = { };
- pair[element.name] = value;
- return Object.toQueryString(pair);
- }
- }
- return '';
- },
-
- getValue: function(element) {
- element = $(element);
- var method = element.tagName.toLowerCase();
- return Form.Element.Serializers[method](element);
- },
-
- setValue: function(element, value) {
- element = $(element);
- var method = element.tagName.toLowerCase();
- Form.Element.Serializers[method](element, value);
- return element;
- },
-
- clear: function(element) {
- $(element).value = '';
- return element;
- },
-
- present: function(element) {
- return $(element).value != '';
- },
-
- activate: function(element) {
- element = $(element);
- try {
- element.focus();
- if (element.select && (element.tagName.toLowerCase() != 'input' ||
- !(/^(?:button|reset|submit)$/i.test(element.type))))
- element.select();
- } catch (e) { }
- return element;
- },
-
- disable: function(element) {
- element = $(element);
- element.disabled = true;
- return element;
- },
-
- enable: function(element) {
- element = $(element);
- element.disabled = false;
- return element;
- }
-};
-
-/*--------------------------------------------------------------------------*/
-
-var Field = Form.Element;
-
-var $F = Form.Element.Methods.getValue;
-
-/*--------------------------------------------------------------------------*/
-
-Form.Element.Serializers = {
- input: function(element, value) {
- switch (element.type.toLowerCase()) {
- case 'checkbox':
- case 'radio':
- return Form.Element.Serializers.inputSelector(element, value);
- default:
- return Form.Element.Serializers.textarea(element, value);
- }
- },
-
- inputSelector: function(element, value) {
- if (Object.isUndefined(value)) return element.checked ? element.value : null;
- else element.checked = !!value;
- },
-
- textarea: function(element, value) {
- if (Object.isUndefined(value)) return element.value;
- else element.value = value;
- },
-
- select: function(element, value) {
- if (Object.isUndefined(value))
- return this[element.type == 'select-one' ?
- 'selectOne' : 'selectMany'](element);
- else {
- var opt, currentValue, single = !Object.isArray(value);
- for (var i = 0, length = element.length; i < length; i++) {
- opt = element.options[i];
- currentValue = this.optionValue(opt);
- if (single) {
- if (currentValue == value) {
- opt.selected = true;
- return;
- }
- }
- else opt.selected = value.include(currentValue);
- }
- }
- },
-
- selectOne: function(element) {
- var index = element.selectedIndex;
- return index >= 0 ? this.optionValue(element.options[index]) : null;
- },
-
- selectMany: function(element) {
- var values, length = element.length;
- if (!length) return null;
-
- for (var i = 0, values = []; i < length; i++) {
- var opt = element.options[i];
- if (opt.selected) values.push(this.optionValue(opt));
- }
- return values;
- },
-
- optionValue: function(opt) {
- return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
- }
-};
-
-/*--------------------------------------------------------------------------*/
-
-
-Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
- initialize: function($super, element, frequency, callback) {
- $super(callback, frequency);
- this.element = $(element);
- this.lastValue = this.getValue();
- },
-
- execute: function() {
- var value = this.getValue();
- if (Object.isString(this.lastValue) && Object.isString(value) ?
- this.lastValue != value : String(this.lastValue) != String(value)) {
- this.callback(this.element, value);
- this.lastValue = value;
- }
- }
-});
-
-Form.Element.Observer = Class.create(Abstract.TimedObserver, {
- getValue: function() {
- return Form.Element.getValue(this.element);
- }
-});
-
-Form.Observer = Class.create(Abstract.TimedObserver, {
- getValue: function() {
- return Form.serialize(this.element);
- }
-});
-
-/*--------------------------------------------------------------------------*/
-
-Abstract.EventObserver = Class.create({
- initialize: function(element, callback) {
- this.element = $(element);
- this.callback = callback;
-
- this.lastValue = this.getValue();
- if (this.element.tagName.toLowerCase() == 'form')
- this.registerFormCallbacks();
- else
- this.registerCallback(this.element);
- },
-
- onElementEvent: function() {
- var value = this.getValue();
- if (this.lastValue != value) {
- this.callback(this.element, value);
- this.lastValue = value;
- }
- },
-
- registerFormCallbacks: function() {
- Form.getElements(this.element).each(this.registerCallback, this);
- },
-
- registerCallback: function(element) {
- if (element.type) {
- switch (element.type.toLowerCase()) {
- case 'checkbox':
- case 'radio':
- Event.observe(element, 'click', this.onElementEvent.bind(this));
- break;
- default:
- Event.observe(element, 'change', this.onElementEvent.bind(this));
- break;
- }
- }
- }
-});
-
-Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
- getValue: function() {
- return Form.Element.getValue(this.element);
- }
-});
-
-Form.EventObserver = Class.create(Abstract.EventObserver, {
- getValue: function() {
- return Form.serialize(this.element);
- }
-});
-(function() {
-
- var Event = {
- KEY_BACKSPACE: 8,
- KEY_TAB: 9,
- KEY_RETURN: 13,
- KEY_ESC: 27,
- KEY_LEFT: 37,
- KEY_UP: 38,
- KEY_RIGHT: 39,
- KEY_DOWN: 40,
- KEY_DELETE: 46,
- KEY_HOME: 36,
- KEY_END: 35,
- KEY_PAGEUP: 33,
- KEY_PAGEDOWN: 34,
- KEY_INSERT: 45,
-
- cache: {}
- };
-
- var docEl = document.documentElement;
- var MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED = 'onmouseenter' in docEl
- && 'onmouseleave' in docEl;
-
- var _isButton;
- if (Prototype.Browser.IE) {
- var buttonMap = { 0: 1, 1: 4, 2: 2 };
- _isButton = function(event, code) {
- return event.button === buttonMap[code];
- };
- } else if (Prototype.Browser.WebKit) {
- _isButton = function(event, code) {
- switch (code) {
- case 0: return event.which == 1 && !event.metaKey;
- case 1: return event.which == 1 && event.metaKey;
- default: return false;
- }
- };
- } else {
- _isButton = function(event, code) {
- return event.which ? (event.which === code + 1) : (event.button === code);
- };
- }
-
- function isLeftClick(event) { return _isButton(event, 0) }
-
- function isMiddleClick(event) { return _isButton(event, 1) }
-
- function isRightClick(event) { return _isButton(event, 2) }
-
- function element(event) {
- event = Event.extend(event);
-
- var node = event.target, type = event.type,
- currentTarget = event.currentTarget;
-
- if (currentTarget && currentTarget.tagName) {
- if (type === 'load' || type === 'error' ||
- (type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
- && currentTarget.type === 'radio'))
- node = currentTarget;
- }
-
- if (node.nodeType == Node.TEXT_NODE)
- node = node.parentNode;
-
- return Element.extend(node);
- }
-
- function findElement(event, expression) {
- var element = Event.element(event);
- if (!expression) return element;
- while (element) {
- if (Object.isElement(element) && Prototype.Selector.match(element, expression)) {
- return Element.extend(element);
- }
- element = element.parentNode;
- }
- }
-
- function pointer(event) {
- return { x: pointerX(event), y: pointerY(event) };
- }
-
- function pointerX(event) {
- var docElement = document.documentElement,
- body = document.body || { scrollLeft: 0 };
-
- return event.pageX || (event.clientX +
- (docElement.scrollLeft || body.scrollLeft) -
- (docElement.clientLeft || 0));
- }
-
- function pointerY(event) {
- var docElement = document.documentElement,
- body = document.body || { scrollTop: 0 };
-
- return event.pageY || (event.clientY +
- (docElement.scrollTop || body.scrollTop) -
- (docElement.clientTop || 0));
- }
-
-
- function stop(event) {
- Event.extend(event);
- event.preventDefault();
- event.stopPropagation();
-
- event.stopped = true;
- }
-
- Event.Methods = {
- isLeftClick: isLeftClick,
- isMiddleClick: isMiddleClick,
- isRightClick: isRightClick,
-
- element: element,
- findElement: findElement,
-
- pointer: pointer,
- pointerX: pointerX,
- pointerY: pointerY,
-
- stop: stop
- };
-
-
- var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
- m[name] = Event.Methods[name].methodize();
- return m;
- });
-
- if (Prototype.Browser.IE) {
- function _relatedTarget(event) {
- var element;
- switch (event.type) {
- case 'mouseover': element = event.fromElement; break;
- case 'mouseout': element = event.toElement; break;
- default: return null;
- }
- return Element.extend(element);
- }
-
- Object.extend(methods, {
- stopPropagation: function() { this.cancelBubble = true },
- preventDefault: function() { this.returnValue = false },
- inspect: function() { return '[object Event]' }
- });
-
- Event.extend = function(event, element) {
- if (!event) return false;
- if (event._extendedByPrototype) return event;
-
- event._extendedByPrototype = Prototype.emptyFunction;
- var pointer = Event.pointer(event);
-
- Object.extend(event, {
- target: event.srcElement || element,
- relatedTarget: _relatedTarget(event),
- pageX: pointer.x,
- pageY: pointer.y
- });
-
- return Object.extend(event, methods);
- };
- } else {
- Event.prototype = window.Event.prototype || document.createEvent('HTMLEvents').__proto__;
- Object.extend(Event.prototype, methods);
- Event.extend = Prototype.K;
- }
-
- function _createResponder(element, eventName, handler) {
- var registry = Element.retrieve(element, 'prototype_event_registry');
-
- if (Object.isUndefined(registry)) {
- CACHE.push(element);
- registry = Element.retrieve(element, 'prototype_event_registry', $H());
- }
-
- var respondersForEvent = registry.get(eventName);
- if (Object.isUndefined(respondersForEvent)) {
- respondersForEvent = [];
- registry.set(eventName, respondersForEvent);
- }
-
- if (respondersForEvent.pluck('handler').include(handler)) return false;
-
- var responder;
- if (eventName.include(":")) {
- responder = function(event) {
- if (Object.isUndefined(event.eventName))
- return false;
-
- if (event.eventName !== eventName)
- return false;
-
- Event.extend(event, element);
- handler.call(element, event);
- };
- } else {
- if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED &&
- (eventName === "mouseenter" || eventName === "mouseleave")) {
- if (eventName === "mouseenter" || eventName === "mouseleave") {
- responder = function(event) {
- Event.extend(event, element);
-
- var parent = event.relatedTarget;
- while (parent && parent !== element) {
- try { parent = parent.parentNode; }
- catch(e) { parent = element; }
- }
-
- if (parent === element) return;
-
- handler.call(element, event);
- };
- }
- } else {
- responder = function(event) {
- Event.extend(event, element);
- handler.call(element, event);
- };
- }
- }
-
- responder.handler = handler;
- respondersForEvent.push(responder);
- return responder;
- }
-
- function _destroyCache() {
- for (var i = 0, length = CACHE.length; i < length; i++) {
- Event.stopObserving(CACHE[i]);
- CACHE[i] = null;
- }
- }
-
- var CACHE = [];
-
- if (Prototype.Browser.IE)
- window.attachEvent('onunload', _destroyCache);
-
- if (Prototype.Browser.WebKit)
- window.addEventListener('unload', Prototype.emptyFunction, false);
-
-
- var _getDOMEventName = Prototype.K,
- translations = { mouseenter: "mouseover", mouseleave: "mouseout" };
-
- if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED) {
- _getDOMEventName = function(eventName) {
- return (translations[eventName] || eventName);
- };
- }
-
- function observe(element, eventName, handler) {
- element = $(element);
-
- var responder = _createResponder(element, eventName, handler);
-
- if (!responder) return element;
-
- if (eventName.include(':')) {
- if (element.addEventListener)
- element.addEventListener("dataavailable", responder, false);
- else {
- element.attachEvent("ondataavailable", responder);
- element.attachEvent("onfilterchange", responder);
- }
- } else {
- var actualEventName = _getDOMEventName(eventName);
-
- if (element.addEventListener)
- element.addEventListener(actualEventName, responder, false);
- else
- element.attachEvent("on" + actualEventName, responder);
- }
-
- return element;
- }
-
- function stopObserving(element, eventName, handler) {
- element = $(element);
-
- var registry = Element.retrieve(element, 'prototype_event_registry');
- if (!registry) return element;
-
- if (!eventName) {
- registry.each( function(pair) {
- var eventName = pair.key;
- stopObserving(element, eventName);
- });
- return element;
- }
-
- var responders = registry.get(eventName);
- if (!responders) return element;
-
- if (!handler) {
- responders.each(function(r) {
- stopObserving(element, eventName, r.handler);
- });
- return element;
- }
-
- var responder = responders.find( function(r) { return r.handler === handler; });
- if (!responder) return element;
-
- if (eventName.include(':')) {
- if (element.removeEventListener)
- element.removeEventListener("dataavailable", responder, false);
- else {
- element.detachEvent("ondataavailable", responder);
- element.detachEvent("onfilterchange", responder);
- }
- } else {
- var actualEventName = _getDOMEventName(eventName);
- if (element.removeEventListener)
- element.removeEventListener(actualEventName, responder, false);
- else
- element.detachEvent('on' + actualEventName, responder);
- }
-
- registry.set(eventName, responders.without(responder));
-
- return element;
- }
-
- function fire(element, eventName, memo, bubble) {
- element = $(element);
-
- if (Object.isUndefined(bubble))
- bubble = true;
-
- if (element == document && document.createEvent && !element.dispatchEvent)
- element = document.documentElement;
-
- var event;
- if (document.createEvent) {
- event = document.createEvent('HTMLEvents');
- event.initEvent('dataavailable', true, true);
- } else {
- event = document.createEventObject();
- event.eventType = bubble ? 'ondataavailable' : 'onfilterchange';
- }
-
- event.eventName = eventName;
- event.memo = memo || { };
-
- if (document.createEvent)
- element.dispatchEvent(event);
- else
- element.fireEvent(event.eventType, event);
-
- return Event.extend(event);
- }
-
- Event.Handler = Class.create({
- initialize: function(element, eventName, selector, callback) {
- this.element = $(element);
- this.eventName = eventName;
- this.selector = selector;
- this.callback = callback;
- this.handler = this.handleEvent.bind(this);
- },
-
- start: function() {
- Event.observe(this.element, this.eventName, this.handler);
- return this;
- },
-
- stop: function() {
- Event.stopObserving(this.element, this.eventName, this.handler);
- return this;
- },
-
- handleEvent: function(event) {
- var element = event.findElement(this.selector);
- if (element) this.callback.call(this.element, event, element);
- }
- });
-
- function on(element, eventName, selector, callback) {
- element = $(element);
- if (Object.isFunction(selector) && Object.isUndefined(callback)) {
- callback = selector, selector = null;
- }
-
- return new Event.Handler(element, eventName, selector, callback).start();
- }
-
- Object.extend(Event, Event.Methods);
-
- Object.extend(Event, {
- fire: fire,
- observe: observe,
- stopObserving: stopObserving,
- on: on
- });
-
- Element.addMethods({
- fire: fire,
-
- observe: observe,
-
- stopObserving: stopObserving,
-
- on: on
- });
-
- Object.extend(document, {
- fire: fire.methodize(),
-
- observe: observe.methodize(),
-
- stopObserving: stopObserving.methodize(),
-
- on: on.methodize(),
-
- loaded: false
- });
-
- if (window.Event) Object.extend(window.Event, Event);
- else window.Event = Event;
-})();
-
-(function() {
- /* Support for the DOMContentLoaded event is based on work by Dan Webb,
- Matthias Miller, Dean Edwards, John Resig, and Diego Perini. */
-
- var timer;
-
- function fireContentLoadedEvent() {
- if (document.loaded) return;
- if (timer) window.clearTimeout(timer);
- document.loaded = true;
- document.fire('dom:loaded');
- }
-
- function checkReadyState() {
- if (document.readyState === 'complete') {
- document.stopObserving('readystatechange', checkReadyState);
- fireContentLoadedEvent();
- }
- }
-
- function pollDoScroll() {
- try { document.documentElement.doScroll('left'); }
- catch(e) {
- timer = pollDoScroll.defer();
- return;
- }
- fireContentLoadedEvent();
- }
-
- if (document.addEventListener) {
- document.addEventListener('DOMContentLoaded', fireContentLoadedEvent, false);
- } else {
- document.observe('readystatechange', checkReadyState);
- if (window == top)
- timer = pollDoScroll.defer();
- }
-
- Event.observe(window, 'load', fireContentLoadedEvent);
-})();
-
-Element.addMethods();
-
-/*------------------------------- DEPRECATED -------------------------------*/
-
-Hash.toQueryString = Object.toQueryString;
-
-var Toggle = { display: Element.toggle };
-
-Element.Methods.childOf = Element.Methods.descendantOf;
-
-var Insertion = {
- Before: function(element, content) {
- return Element.insert(element, {before:content});
- },
-
- Top: function(element, content) {
- return Element.insert(element, {top:content});
- },
-
- Bottom: function(element, content) {
- return Element.insert(element, {bottom:content});
- },
-
- After: function(element, content) {
- return Element.insert(element, {after:content});
- }
-};
-
-var $continue = new Error('"throw $continue" is deprecated, use "return" instead');
-
-var Position = {
- includeScrollOffsets: false,
-
- prepare: function() {
- this.deltaX = window.pageXOffset
- || document.documentElement.scrollLeft
- || document.body.scrollLeft
- || 0;
- this.deltaY = window.pageYOffset
- || document.documentElement.scrollTop
- || document.body.scrollTop
- || 0;
- },
-
- within: function(element, x, y) {
- if (this.includeScrollOffsets)
- return this.withinIncludingScrolloffsets(element, x, y);
- this.xcomp = x;
- this.ycomp = y;
- this.offset = Element.cumulativeOffset(element);
-
- return (y >= this.offset[1] &&
- y < this.offset[1] + element.offsetHeight &&
- x >= this.offset[0] &&
- x < this.offset[0] + element.offsetWidth);
- },
-
- withinIncludingScrolloffsets: function(element, x, y) {
- var offsetcache = Element.cumulativeScrollOffset(element);
-
- this.xcomp = x + offsetcache[0] - this.deltaX;
- this.ycomp = y + offsetcache[1] - this.deltaY;
- this.offset = Element.cumulativeOffset(element);
-
- return (this.ycomp >= this.offset[1] &&
- this.ycomp < this.offset[1] + element.offsetHeight &&
- this.xcomp >= this.offset[0] &&
- this.xcomp < this.offset[0] + element.offsetWidth);
- },
-
- overlap: function(mode, element) {
- if (!mode) return 0;
- if (mode == 'vertical')
- return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
- element.offsetHeight;
- if (mode == 'horizontal')
- return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
- element.offsetWidth;
- },
-
-
- cumulativeOffset: Element.Methods.cumulativeOffset,
-
- positionedOffset: Element.Methods.positionedOffset,
-
- absolutize: function(element) {
- Position.prepare();
- return Element.absolutize(element);
- },
-
- relativize: function(element) {
- Position.prepare();
- return Element.relativize(element);
- },
-
- realOffset: Element.Methods.cumulativeScrollOffset,
-
- offsetParent: Element.Methods.getOffsetParent,
-
- page: Element.Methods.viewportOffset,
-
- clone: function(source, target, options) {
- options = options || { };
- return Element.clonePosition(target, source, options);
- }
-};
-
-/*--------------------------------------------------------------------------*/
-
-if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
- function iter(name) {
- return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
- }
-
- instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
- function(element, className) {
- className = className.toString().strip();
- var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
- return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
- } : function(element, className) {
- className = className.toString().strip();
- var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
- if (!classNames && !className) return elements;
-
- var nodes = $(element).getElementsByTagName('*');
- className = ' ' + className + ' ';
-
- for (var i = 0, child, cn; child = nodes[i]; i++) {
- if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
- (classNames && classNames.all(function(name) {
- return !name.toString().blank() && cn.include(' ' + name + ' ');
- }))))
- elements.push(Element.extend(child));
- }
- return elements;
- };
-
- return function(className, parentElement) {
- return $(parentElement || document.body).getElementsByClassName(className);
- };
-}(Element.Methods);
-
-/*--------------------------------------------------------------------------*/
-
-Element.ClassNames = Class.create();
-Element.ClassNames.prototype = {
- initialize: function(element) {
- this.element = $(element);
- },
-
- _each: function(iterator) {
- this.element.className.split(/\s+/).select(function(name) {
- return name.length > 0;
- })._each(iterator);
- },
-
- set: function(className) {
- this.element.className = className;
- },
-
- add: function(classNameToAdd) {
- if (this.include(classNameToAdd)) return;
- this.set($A(this).concat(classNameToAdd).join(' '));
- },
-
- remove: function(classNameToRemove) {
- if (!this.include(classNameToRemove)) return;
- this.set($A(this).without(classNameToRemove).join(' '));
- },
-
- toString: function() {
- return $A(this).join(' ');
- }
-};
-
-Object.extend(Element.ClassNames.prototype, Enumerable);
-
-/*--------------------------------------------------------------------------*/
-
-(function() {
- window.Selector = Class.create({
- initialize: function(expression) {
- this.expression = expression.strip();
- },
-
- findElements: function(rootElement) {
- return Prototype.Selector.select(this.expression, rootElement);
- },
-
- match: function(element) {
- return Prototype.Selector.match(element, this.expression);
- },
-
- toString: function() {
- return this.expression;
- },
-
- inspect: function() {
- return "#";
- }
- });
-
- Object.extend(Selector, {
- matchElements: function(elements, expression) {
- var match = Prototype.Selector.match,
- results = [];
-
- for (var i = 0, length = elements.length; i < length; i++) {
- var element = elements[i];
- if (match(element, expression)) {
- results.push(Element.extend(element));
- }
- }
- return results;
- },
-
- findElement: function(elements, expression, index) {
- index = index || 0;
- var matchIndex = 0, element;
- for (var i = 0, length = elements.length; i < length; i++) {
- element = elements[i];
- if (Prototype.Selector.match(element, expression) && index === matchIndex++) {
- return Element.extend(element);
- }
- }
- },
-
- findChildElements: function(element, expressions) {
- var selector = expressions.toArray().join(', ');
- return Prototype.Selector.select(selector, element || document);
- }
- });
-})();
diff --git a/public/javascripts/rails.js b/public/javascripts/rails.js
index aed6aed..e99d49e 100644
--- a/public/javascripts/rails.js
+++ b/public/javascripts/rails.js
@@ -1,191 +1,157 @@
-(function() {
- // Technique from Juriy Zaytsev
- // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
- function isEventSupported(eventName) {
- var el = document.createElement('div');
- eventName = 'on' + eventName;
- var isSupported = (eventName in el);
- if (!isSupported) {
- el.setAttribute(eventName, 'return;');
- isSupported = typeof el[eventName] == 'function';
- }
- el = null;
- return isSupported;
- }
-
- function isForm(element) {
- return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
- }
-
- function isInput(element) {
- if (Object.isElement(element)) {
- var name = element.nodeName.toUpperCase()
- return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
- }
- else return false
- }
-
- var submitBubbles = isEventSupported('submit'),
- changeBubbles = isEventSupported('change')
-
- if (!submitBubbles || !changeBubbles) {
- // augment the Event.Handler class to observe custom events when needed
- Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
- function(init, element, eventName, selector, callback) {
- init(element, eventName, selector, callback)
- // is the handler being attached to an element that doesn't support this event?
- if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
- (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
- // "submit" => "emulated:submit"
- this.eventName = 'emulated:' + this.eventName
- }
- }
- )
- }
-
- if (!submitBubbles) {
- // discover forms on the page by observing focus events which always bubble
- document.on('focusin', 'form', function(focusEvent, form) {
- // special handler for the real "submit" event (one-time operation)
- if (!form.retrieve('emulated:submit')) {
- form.on('submit', function(submitEvent) {
- var emulated = form.fire('emulated:submit', submitEvent, true)
- // if custom event received preventDefault, cancel the real one too
- if (emulated.returnValue === false) submitEvent.preventDefault()
- })
- form.store('emulated:submit', true)
- }
- })
- }
-
- if (!changeBubbles) {
- // discover form inputs on the page
- document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
- // special handler for real "change" events
- if (!input.retrieve('emulated:change')) {
- input.on('change', function(changeEvent) {
- input.fire('emulated:change', changeEvent, true)
- })
- input.store('emulated:change', true)
- }
- })
- }
-
- function handleRemote(element) {
- var method, url, params;
-
- var event = element.fire("ajax:before");
- if (event.stopped) return false;
-
- if (element.tagName.toLowerCase() === 'form') {
- method = element.readAttribute('method') || 'post';
- url = element.readAttribute('action');
- params = element.serialize();
- } else {
- method = element.readAttribute('data-method') || 'get';
- url = element.readAttribute('href');
- params = {};
- }
-
- new Ajax.Request(url, {
- method: method,
- parameters: params,
- evalScripts: true,
-
- onComplete: function(request) { element.fire("ajax:complete", request); },
- onSuccess: function(request) { element.fire("ajax:success", request); },
- onFailure: function(request) { element.fire("ajax:failure", request); }
- });
-
- element.fire("ajax:after");
- }
-
- function handleMethod(element) {
- var method = element.readAttribute('data-method'),
- url = element.readAttribute('href'),
- csrf_param = $$('meta[name=csrf-param]')[0],
- csrf_token = $$('meta[name=csrf-token]')[0];
-
- var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
- element.parentNode.insert(form);
-
- if (method !== 'post') {
- var field = new Element('input', { type: 'hidden', name: '_method', value: method });
- form.insert(field);
- }
-
- if (csrf_param) {
- var param = csrf_param.readAttribute('content'),
- token = csrf_token.readAttribute('content'),
- field = new Element('input', { type: 'hidden', name: param, value: token });
- form.insert(field);
- }
-
- form.submit();
- }
-
-
- document.on("click", "*[data-confirm]", function(event, element) {
- var message = element.readAttribute('data-confirm');
- if (!confirm(message)) event.stop();
- });
-
- document.on("click", "a[data-remote]", function(event, element) {
- if (event.stopped) return;
- handleRemote(element);
- event.stop();
- });
-
- document.on("click", "a[data-method]", function(event, element) {
- if (event.stopped) return;
- handleMethod(element);
- event.stop();
- });
-
- document.on("submit", function(event) {
- var element = event.findElement(),
- message = element.readAttribute('data-confirm');
- if (message && !confirm(message)) {
- event.stop();
- return false;
- }
-
- var inputs = element.select("input[type=submit][data-disable-with]");
- inputs.each(function(input) {
- input.disabled = true;
- input.writeAttribute('data-original-value', input.value);
- input.value = input.readAttribute('data-disable-with');
- });
-
- var element = event.findElement("form[data-remote]");
- if (element) {
- handleRemote(element);
- event.stop();
- }
- });
-
- document.on("ajax:after", "form", function(event, element) {
- var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
- inputs.each(function(input) {
- input.value = input.readAttribute('data-original-value');
- input.removeAttribute('data-original-value');
- input.disabled = false;
- });
- });
-
- Ajax.Responders.register({
- onCreate: function(request) {
- var csrf_meta_tag = $$('meta[name=csrf-token]')[0];
-
- if (csrf_meta_tag) {
- var header = 'X-CSRF-Token',
- token = csrf_meta_tag.readAttribute('content');
-
- if (!request.options.requestHeaders) {
- request.options.requestHeaders = {};
- }
- request.options.requestHeaders[header] = token;
- }
- }
- });
-})();
+/**
+ * Unobtrusive scripting adapter for jQuery
+ *
+ * Requires jQuery 1.4.3 or later.
+ * https://github.com/rails/jquery-ujs
+ */
+
+(function($) {
+ // Make sure that every Ajax request sends the CSRF token
+ function CSRFProtection(xhr) {
+ var token = $('meta[name="csrf-token"]').attr('content');
+ if (token) xhr.setRequestHeader('X-CSRF-Token', token);
+ }
+ if ('ajaxPrefilter' in $) $.ajaxPrefilter(function(options, originalOptions, xhr){ CSRFProtection(xhr) });
+ else $(document).ajaxSend(function(e, xhr){ CSRFProtection(xhr) });
+
+ // Triggers an event on an element and returns the event result
+ function fire(obj, name, data) {
+ var event = new $.Event(name);
+ obj.trigger(event, data);
+ return event.result !== false;
+ }
+
+ // Submits "remote" forms and links with ajax
+ function handleRemote(element) {
+ var method, url, data,
+ dataType = element.attr('data-type') || ($.ajaxSettings && $.ajaxSettings.dataType);
+
+ if (element.is('form')) {
+ method = element.attr('method');
+ url = element.attr('action');
+ data = element.serializeArray();
+ // memoized value from clicked submit button
+ var button = element.data('ujs:submit-button');
+ if (button) {
+ data.push(button);
+ element.data('ujs:submit-button', null);
+ }
+ } else {
+ method = element.attr('data-method');
+ url = element.attr('href');
+ data = null;
+ }
+
+ $.ajax({
+ url: url, type: method || 'GET', data: data, dataType: dataType,
+ // stopping the "ajax:beforeSend" event will cancel the ajax request
+ beforeSend: function(xhr, settings) {
+ if (settings.dataType === undefined) {
+ xhr.setRequestHeader('accept', '*/*;q=0.5, ' + settings.accepts.script);
+ }
+ return fire(element, 'ajax:beforeSend', [xhr, settings]);
+ },
+ success: function(data, status, xhr) {
+ element.trigger('ajax:success', [data, status, xhr]);
+ },
+ complete: function(xhr, status) {
+ element.trigger('ajax:complete', [xhr, status]);
+ },
+ error: function(xhr, status, error) {
+ element.trigger('ajax:error', [xhr, status, error]);
+ }
+ });
+ }
+
+ // Handles "data-method" on links such as:
+ // Delete
+ function handleMethod(link) {
+ var href = link.attr('href'),
+ method = link.attr('data-method'),
+ csrf_token = $('meta[name=csrf-token]').attr('content'),
+ csrf_param = $('meta[name=csrf-param]').attr('content'),
+ form = $(''),
+ metadata_input = '';
+
+ if (csrf_param !== undefined && csrf_token !== undefined) {
+ metadata_input += '';
+ }
+
+ form.hide().append(metadata_input).appendTo('body');
+ form.submit();
+ }
+
+ function disableFormElements(form) {
+ form.find('input[data-disable-with]').each(function() {
+ var input = $(this);
+ input.data('ujs:enable-with', input.val())
+ .val(input.attr('data-disable-with'))
+ .attr('disabled', 'disabled');
+ });
+ }
+
+ function enableFormElements(form) {
+ form.find('input[data-disable-with]').each(function() {
+ var input = $(this);
+ input.val(input.data('ujs:enable-with')).removeAttr('disabled');
+ });
+ }
+
+ function allowAction(element) {
+ var message = element.attr('data-confirm');
+ return !message || (fire(element, 'confirm') && confirm(message));
+ }
+
+ function requiredValuesMissing(form) {
+ var missing = false;
+ form.find('input[name][required]').each(function() {
+ if (!$(this).val()) missing = true;
+ });
+ return missing;
+ }
+
+ $('a[data-confirm], a[data-method], a[data-remote]').live('click.rails', function(e) {
+ var link = $(this);
+ if (!allowAction(link)) return false;
+
+ if (link.attr('data-remote') != undefined) {
+ handleRemote(link);
+ return false;
+ } else if (link.attr('data-method')) {
+ handleMethod(link);
+ return false;
+ }
+ });
+
+ $('form').live('submit.rails', function(e) {
+ var form = $(this), remote = form.attr('data-remote') != undefined;
+ if (!allowAction(form)) return false;
+
+ // skip other logic when required values are missing
+ if (requiredValuesMissing(form)) return !remote;
+
+ if (remote) {
+ handleRemote(form);
+ return false;
+ } else {
+ // slight timeout so that the submit button gets properly serialized
+ setTimeout(function(){ disableFormElements(form) }, 13);
+ }
+ });
+
+ $('form input[type=submit], form button[type=submit], form button:not([type])').live('click.rails', function() {
+ var button = $(this);
+ if (!allowAction(button)) return false;
+ // register the pressed submit button
+ var name = button.attr('name'), data = name ? {name:name, value:button.val()} : null;
+ button.closest('form').data('ujs:submit-button', data);
+ });
+
+ $('form').live('ajax:beforeSend.rails', function(event) {
+ if (this == event.target) disableFormElements($(this));
+ });
+
+ $('form').live('ajax:complete.rails', function(event) {
+ if (this == event.target) enableFormElements($(this));
+ });
+})( jQuery );
diff --git a/public/javascripts/sammy.js b/public/javascripts/sammy.js
new file mode 100644
index 0000000..d798892
--- /dev/null
+++ b/public/javascripts/sammy.js
@@ -0,0 +1,1829 @@
+// name: sammy
+// version: 0.6.3
+
+// Sammy.js / http://sammyjs.org
+
+(function($, window) {
+
+ var Sammy,
+ PATH_REPLACER = "([^\/]+)",
+ PATH_NAME_MATCHER = /:([\w\d]+)/g,
+ QUERY_STRING_MATCHER = /\?([^#]*)$/,
+ // mainly for making `arguments` an Array
+ _makeArray = function(nonarray) { return Array.prototype.slice.call(nonarray); },
+ // borrowed from jQuery
+ _isFunction = function( obj ) { return Object.prototype.toString.call(obj) === "[object Function]"; },
+ _isArray = function( obj ) { return Object.prototype.toString.call(obj) === "[object Array]"; },
+ _decode = function( str ) { return decodeURIComponent(str.replace(/\+/g, ' ')); },
+ _encode = encodeURIComponent,
+ _escapeHTML = function(s) {
+ return String(s).replace(/&(?!\w+;)/g, '&').replace(//g, '>').replace(/"/g, '"');
+ },
+ _routeWrapper = function(verb) {
+ return function(path, callback) { return this.route.apply(this, [verb, path, callback]); };
+ },
+ _template_cache = {},
+ loggers = [];
+
+
+ // `Sammy` (also aliased as $.sammy) is not only the namespace for a
+ // number of prototypes, its also a top level method that allows for easy
+ // creation/management of `Sammy.Application` instances. There are a
+ // number of different forms for `Sammy()` but each returns an instance
+ // of `Sammy.Application`. When a new instance is created using
+ // `Sammy` it is added to an Object called `Sammy.apps`. This
+ // provides for an easy way to get at existing Sammy applications. Only one
+ // instance is allowed per `element_selector` so when calling
+ // `Sammy('selector')` multiple times, the first time will create
+ // the application and the following times will extend the application
+ // already added to that selector.
+ //
+ // ### Example
+ //
+ // // returns the app at #main or a new app
+ // Sammy('#main')
+ //
+ // // equivilent to "new Sammy.Application", except appends to apps
+ // Sammy();
+ // Sammy(function() { ... });
+ //
+ // // extends the app at '#main' with function.
+ // Sammy('#main', function() { ... });
+ //
+ Sammy = function() {
+ var args = _makeArray(arguments),
+ app, selector;
+ Sammy.apps = Sammy.apps || {};
+ if (args.length === 0 || args[0] && _isFunction(args[0])) { // Sammy()
+ return Sammy.apply(Sammy, ['body'].concat(args));
+ } else if (typeof (selector = args.shift()) == 'string') { // Sammy('#main')
+ app = Sammy.apps[selector] || new Sammy.Application();
+ app.element_selector = selector;
+ if (args.length > 0) {
+ $.each(args, function(i, plugin) {
+ app.use(plugin);
+ });
+ }
+ // if the selector changes make sure the refrence in Sammy.apps changes
+ if (app.element_selector != selector) {
+ delete Sammy.apps[selector];
+ }
+ Sammy.apps[app.element_selector] = app;
+ return app;
+ }
+ };
+
+ Sammy.VERSION = '0.6.3';
+
+ // Add to the global logger pool. Takes a function that accepts an
+ // unknown number of arguments and should print them or send them somewhere
+ // The first argument is always a timestamp.
+ Sammy.addLogger = function(logger) {
+ loggers.push(logger);
+ };
+
+ // Sends a log message to each logger listed in the global
+ // loggers pool. Can take any number of arguments.
+ // Also prefixes the arguments with a timestamp.
+ Sammy.log = function() {
+ var args = _makeArray(arguments);
+ args.unshift("[" + Date() + "]");
+ $.each(loggers, function(i, logger) {
+ logger.apply(Sammy, args);
+ });
+ };
+
+ if (typeof window.console != 'undefined') {
+ if (_isFunction(window.console.log.apply)) {
+ Sammy.addLogger(function() {
+ window.console.log.apply(window.console, arguments);
+ });
+ } else {
+ Sammy.addLogger(function() {
+ window.console.log(arguments);
+ });
+ }
+ } else if (typeof console != 'undefined') {
+ Sammy.addLogger(function() {
+ console.log.apply(console, arguments);
+ });
+ }
+
+ $.extend(Sammy, {
+ makeArray: _makeArray,
+ isFunction: _isFunction,
+ isArray: _isArray
+ })
+
+ // Sammy.Object is the base for all other Sammy classes. It provides some useful
+ // functionality, including cloning, iterating, etc.
+ Sammy.Object = function(obj) { // constructor
+ return $.extend(this, obj || {});
+ };
+
+ $.extend(Sammy.Object.prototype, {
+
+ // Escape HTML in string, use in templates to prevent script injection.
+ // Also aliased as `h()`
+ escapeHTML: _escapeHTML,
+ h: _escapeHTML,
+
+ // Returns a copy of the object with Functions removed.
+ toHash: function() {
+ var json = {};
+ $.each(this, function(k,v) {
+ if (!_isFunction(v)) {
+ json[k] = v;
+ }
+ });
+ return json;
+ },
+
+ // Renders a simple HTML version of this Objects attributes.
+ // Does not render functions.
+ // For example. Given this Sammy.Object:
+ //
+ // var s = new Sammy.Object({first_name: 'Sammy', last_name: 'Davis Jr.'});
+ // s.toHTML()
+ // //=> 'first_name Sammy
last_name Davis Jr.
'
+ //
+ toHTML: function() {
+ var display = "";
+ $.each(this, function(k, v) {
+ if (!_isFunction(v)) {
+ display += "" + k + " " + v + "
";
+ }
+ });
+ return display;
+ },
+
+ // Returns an array of keys for this object. If `attributes_only`
+ // is true will not return keys that map to a `function()`
+ keys: function(attributes_only) {
+ var keys = [];
+ for (var property in this) {
+ if (!_isFunction(this[property]) || !attributes_only) {
+ keys.push(property);
+ }
+ }
+ return keys;
+ },
+
+ // Checks if the object has a value at `key` and that the value is not empty
+ has: function(key) {
+ return this[key] && $.trim(this[key].toString()) != '';
+ },
+
+ // convenience method to join as many arguments as you want
+ // by the first argument - useful for making paths
+ join: function() {
+ var args = _makeArray(arguments);
+ var delimiter = args.shift();
+ return args.join(delimiter);
+ },
+
+ // Shortcut to Sammy.log
+ log: function() {
+ Sammy.log.apply(Sammy, arguments);
+ },
+
+ // Returns a string representation of this object.
+ // if `include_functions` is true, it will also toString() the
+ // methods of this object. By default only prints the attributes.
+ toString: function(include_functions) {
+ var s = [];
+ $.each(this, function(k, v) {
+ if (!_isFunction(v) || include_functions) {
+ s.push('"' + k + '": ' + v.toString());
+ }
+ });
+ return "Sammy.Object: {" + s.join(',') + "}";
+ }
+ });
+
+ // The HashLocationProxy is the default location proxy for all Sammy applications.
+ // A location proxy is a prototype that conforms to a simple interface. The purpose
+ // of a location proxy is to notify the Sammy.Application its bound to when the location
+ // or 'external state' changes. The HashLocationProxy considers the state to be
+ // changed when the 'hash' (window.location.hash / '#') changes. It does this in two
+ // different ways depending on what browser you are using. The newest browsers
+ // (IE, Safari > 4, FF >= 3.6) support a 'onhashchange' DOM event, thats fired whenever
+ // the location.hash changes. In this situation the HashLocationProxy just binds
+ // to this event and delegates it to the application. In the case of older browsers
+ // a poller is set up to track changes to the hash. Unlike Sammy 0.3 or earlier,
+ // the HashLocationProxy allows the poller to be a global object, eliminating the
+ // need for multiple pollers even when thier are multiple apps on the page.
+ Sammy.HashLocationProxy = function(app, run_interval_every) {
+ this.app = app;
+ // set is native to false and start the poller immediately
+ this.is_native = false;
+ this._startPolling(run_interval_every);
+ };
+
+ Sammy.HashLocationProxy.prototype = {
+
+ // bind the proxy events to the current app.
+ bind: function() {
+ var proxy = this, app = this.app;
+ $(window).bind('hashchange.' + this.app.eventNamespace(), function(e, non_native) {
+ // if we receive a native hash change event, set the proxy accordingly
+ // and stop polling
+ if (proxy.is_native === false && !non_native) {
+ Sammy.log('native hash change exists, using');
+ proxy.is_native = true;
+ window.clearInterval(Sammy.HashLocationProxy._interval);
+ }
+ app.trigger('location-changed');
+ });
+ if (!Sammy.HashLocationProxy._bindings) {
+ Sammy.HashLocationProxy._bindings = 0;
+ }
+ Sammy.HashLocationProxy._bindings++;
+ },
+
+ // unbind the proxy events from the current app
+ unbind: function() {
+ $(window).unbind('hashchange.' + this.app.eventNamespace());
+ Sammy.HashLocationProxy._bindings--;
+ if (Sammy.HashLocationProxy._bindings <= 0) {
+ window.clearInterval(Sammy.HashLocationProxy._interval);
+ }
+ },
+
+ // get the current location from the hash.
+ getLocation: function() {
+ // Bypass the `window.location.hash` attribute. If a question mark
+ // appears in the hash IE6 will strip it and all of the following
+ // characters from `window.location.hash`.
+ var matches = window.location.toString().match(/^[^#]*(#.+)$/);
+ return matches ? matches[1] : '';
+ },
+
+ // set the current location to `new_location`
+ setLocation: function(new_location) {
+ return (window.location = new_location);
+ },
+
+ _startPolling: function(every) {
+ // set up interval
+ var proxy = this;
+ if (!Sammy.HashLocationProxy._interval) {
+ if (!every) { every = 10; }
+ var hashCheck = function() {
+ var current_location = proxy.getLocation();
+ if (!Sammy.HashLocationProxy._last_location ||
+ current_location != Sammy.HashLocationProxy._last_location) {
+ window.setTimeout(function() {
+ $(window).trigger('hashchange', [true]);
+ }, 13);
+ }
+ Sammy.HashLocationProxy._last_location = current_location;
+ };
+ hashCheck();
+ Sammy.HashLocationProxy._interval = window.setInterval(hashCheck, every);
+ }
+ }
+ };
+
+
+ // Sammy.Application is the Base prototype for defining 'applications'.
+ // An 'application' is a collection of 'routes' and bound events that is
+ // attached to an element when `run()` is called.
+ // The only argument an 'app_function' is evaluated within the context of the application.
+ Sammy.Application = function(app_function) {
+ var app = this;
+ this.routes = {};
+ this.listeners = new Sammy.Object({});
+ this.arounds = [];
+ this.befores = [];
+ // generate a unique namespace
+ this.namespace = (new Date()).getTime() + '-' + parseInt(Math.random() * 1000, 10);
+ this.context_prototype = function() { Sammy.EventContext.apply(this, arguments); };
+ this.context_prototype.prototype = new Sammy.EventContext();
+
+ if (_isFunction(app_function)) {
+ app_function.apply(this, [this]);
+ }
+ // set the location proxy if not defined to the default (HashLocationProxy)
+ if (!this._location_proxy) {
+ this.setLocationProxy(new Sammy.HashLocationProxy(this, this.run_interval_every));
+ }
+ if (this.debug) {
+ this.bindToAllEvents(function(e, data) {
+ app.log(app.toString(), e.cleaned_type, data || {});
+ });
+ }
+ };
+
+ Sammy.Application.prototype = $.extend({}, Sammy.Object.prototype, {
+
+ // the four route verbs
+ ROUTE_VERBS: ['get','post','put','delete'],
+
+ // An array of the default events triggered by the
+ // application during its lifecycle
+ APP_EVENTS: ['run', 'unload', 'lookup-route', 'run-route', 'route-found', 'event-context-before', 'event-context-after', 'changed', 'error', 'check-form-submission', 'redirect', 'location-changed'],
+
+ _last_route: null,
+ _location_proxy: null,
+ _running: false,
+
+ // Defines what element the application is bound to. Provide a selector
+ // (parseable by `jQuery()`) and this will be used by `$element()`
+ element_selector: 'body',
+
+ // When set to true, logs all of the default events using `log()`
+ debug: false,
+
+ // When set to true, and the error() handler is not overriden, will actually
+ // raise JS errors in routes (500) and when routes can't be found (404)
+ raise_errors: false,
+
+ // The time in milliseconds that the URL is queried for changes
+ run_interval_every: 50,
+
+ // The default template engine to use when using `partial()` in an
+ // `EventContext`. `template_engine` can either be a string that
+ // corresponds to the name of a method/helper on EventContext or it can be a function
+ // that takes two arguments, the content of the unrendered partial and an optional
+ // JS object that contains interpolation data. Template engine is only called/refered
+ // to if the extension of the partial is null or unknown. See `partial()`
+ // for more information
+ template_engine: null,
+
+ // //=> Sammy.Application: body
+ toString: function() {
+ return 'Sammy.Application:' + this.element_selector;
+ },
+
+ // returns a jQuery object of the Applications bound element.
+ $element: function(selector) {
+ return selector ? $(this.element_selector).find(selector) : $(this.element_selector);
+ },
+
+ // `use()` is the entry point for including Sammy plugins.
+ // The first argument to use should be a function() that is evaluated
+ // in the context of the current application, just like the `app_function`
+ // argument to the `Sammy.Application` constructor.
+ //
+ // Any additional arguments are passed to the app function sequentially.
+ //
+ // For much more detail about plugins, check out:
+ // [http://sammyjs.org/docs/plugins](http://sammyjs.org/docs/plugins)
+ //
+ // ### Example
+ //
+ // var MyPlugin = function(app, prepend) {
+ //
+ // this.helpers({
+ // myhelper: function(text) {
+ // alert(prepend + " " + text);
+ // }
+ // });
+ //
+ // };
+ //
+ // var app = $.sammy(function() {
+ //
+ // this.use(MyPlugin, 'This is my plugin');
+ //
+ // this.get('#/', function() {
+ // this.myhelper('and dont you forget it!');
+ // //=> Alerts: This is my plugin and dont you forget it!
+ // });
+ //
+ // });
+ //
+ // If plugin is passed as a string it assumes your are trying to load
+ // Sammy."Plugin". This is the prefered way of loading core Sammy plugins
+ // as it allows for better error-messaging.
+ //
+ // ### Example
+ //
+ // $.sammy(function() {
+ // this.use('Mustache'); //=> Sammy.Mustache
+ // this.use('Storage'); //=> Sammy.Storage
+ // });
+ //
+ use: function() {
+ // flatten the arguments
+ var args = _makeArray(arguments),
+ plugin = args.shift(),
+ plugin_name = plugin || '';
+ try {
+ args.unshift(this);
+ if (typeof plugin == 'string') {
+ plugin_name = 'Sammy.' + plugin;
+ plugin = Sammy[plugin];
+ }
+ plugin.apply(this, args);
+ } catch(e) {
+ if (typeof plugin === 'undefined') {
+ this.error("Plugin Error: called use() but plugin (" + plugin_name.toString() + ") is not defined", e);
+ } else if (!_isFunction(plugin)) {
+ this.error("Plugin Error: called use() but '" + plugin_name.toString() + "' is not a function", e);
+ } else {
+ this.error("Plugin Error", e);
+ }
+ }
+ return this;
+ },
+
+ // Sets the location proxy for the current app. By default this is set to
+ // a new `Sammy.HashLocationProxy` on initialization. However, you can set
+ // the location_proxy inside you're app function to give your app a custom
+ // location mechanism. See `Sammy.HashLocationProxy` and `Sammy.DataLocationProxy`
+ // for examples.
+ //
+ // `setLocationProxy()` takes an initialized location proxy.
+ //
+ // ### Example
+ //
+ // // to bind to data instead of the default hash;
+ // var app = $.sammy(function() {
+ // this.setLocationProxy(new Sammy.DataLocationProxy(this));
+ // });
+ //
+ setLocationProxy: function(new_proxy) {
+ var original_proxy = this._location_proxy;
+ this._location_proxy = new_proxy;
+ if (this.isRunning()) {
+ if (original_proxy) {
+ // if there is already a location proxy, unbind it.
+ original_proxy.unbind();
+ }
+ this._location_proxy.bind();
+ }
+ },
+
+ // `route()` is the main method for defining routes within an application.
+ // For great detail on routes, check out:
+ // [http://sammyjs.org/docs/routes](http://sammyjs.org/docs/routes)
+ //
+ // This method also has aliases for each of the different verbs (eg. `get()`, `post()`, etc.)
+ //
+ // ### Arguments
+ //
+ // * `verb` A String in the set of ROUTE_VERBS or 'any'. 'any' will add routes for each
+ // of the ROUTE_VERBS. If only two arguments are passed,
+ // the first argument is the path, the second is the callback and the verb
+ // is assumed to be 'any'.
+ // * `path` A Regexp or a String representing the path to match to invoke this verb.
+ // * `callback` A Function that is called/evaluated whent the route is run see: `runRoute()`.
+ // It is also possible to pass a string as the callback, which is looked up as the name
+ // of a method on the application.
+ //
+ route: function(verb, path, callback) {
+ var app = this, param_names = [], add_route, path_match;
+
+ // if the method signature is just (path, callback)
+ // assume the verb is 'any'
+ if (!callback && _isFunction(path)) {
+ path = verb;
+ callback = path;
+ verb = 'any';
+ }
+
+ verb = verb.toLowerCase(); // ensure verb is lower case
+
+ // if path is a string turn it into a regex
+ if (path.constructor == String) {
+
+ // Needs to be explicitly set because IE will maintain the index unless NULL is returned,
+ // which means that with two consecutive routes that contain params, the second set of params will not be found and end up in splat instead of params
+ // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/RegExp/lastIndex
+ PATH_NAME_MATCHER.lastIndex = 0;
+
+ // find the names
+ while ((path_match = PATH_NAME_MATCHER.exec(path)) !== null) {
+ param_names.push(path_match[1]);
+ }
+ // replace with the path replacement
+ path = new RegExp("^" + path.replace(PATH_NAME_MATCHER, PATH_REPLACER) + "$");
+ }
+ // lookup callback
+ if (typeof callback == 'string') {
+ callback = app[callback];
+ }
+
+ add_route = function(with_verb) {
+ var r = {verb: with_verb, path: path, callback: callback, param_names: param_names};
+ // add route to routes array
+ app.routes[with_verb] = app.routes[with_verb] || [];
+ // place routes in order of definition
+ app.routes[with_verb].push(r);
+ };
+
+ if (verb === 'any') {
+ $.each(this.ROUTE_VERBS, function(i, v) { add_route(v); });
+ } else {
+ add_route(verb);
+ }
+
+ // return the app
+ return this;
+ },
+
+ // Alias for route('get', ...)
+ get: _routeWrapper('get'),
+
+ // Alias for route('post', ...)
+ post: _routeWrapper('post'),
+
+ // Alias for route('put', ...)
+ put: _routeWrapper('put'),
+
+ // Alias for route('delete', ...)
+ del: _routeWrapper('delete'),
+
+ // Alias for route('any', ...)
+ any: _routeWrapper('any'),
+
+ // `mapRoutes` takes an array of arrays, each array being passed to route()
+ // as arguments, this allows for mass definition of routes. Another benefit is
+ // this makes it possible/easier to load routes via remote JSON.
+ //
+ // ### Example
+ //
+ // var app = $.sammy(function() {
+ //
+ // this.mapRoutes([
+ // ['get', '#/', function() { this.log('index'); }],
+ // // strings in callbacks are looked up as methods on the app
+ // ['post', '#/create', 'addUser'],
+ // // No verb assumes 'any' as the verb
+ // [/dowhatever/, function() { this.log(this.verb, this.path)}];
+ // ]);
+ // });
+ //
+ mapRoutes: function(route_array) {
+ var app = this;
+ $.each(route_array, function(i, route_args) {
+ app.route.apply(app, route_args);
+ });
+ return this;
+ },
+
+ // A unique event namespace defined per application.
+ // All events bound with `bind()` are automatically bound within this space.
+ eventNamespace: function() {
+ return ['sammy-app', this.namespace].join('-');
+ },
+
+ // Works just like `jQuery.fn.bind()` with a couple noteable differences.
+ //
+ // * It binds all events to the application element
+ // * All events are bound within the `eventNamespace()`
+ // * Events are not actually bound until the application is started with `run()`
+ // * callbacks are evaluated within the context of a Sammy.EventContext
+ //
+ bind: function(name, data, callback) {
+ var app = this;
+ // build the callback
+ // if the arity is 2, callback is the second argument
+ if (typeof callback == 'undefined') { callback = data; }
+ var listener_callback = function() {
+ // pull off the context from the arguments to the callback
+ var e, context, data;
+ e = arguments[0];
+ data = arguments[1];
+ if (data && data.context) {
+ context = data.context;
+ delete data.context;
+ } else {
+ context = new app.context_prototype(app, 'bind', e.type, data, e.target);
+ }
+ e.cleaned_type = e.type.replace(app.eventNamespace(), '');
+ callback.apply(context, [e, data]);
+ };
+
+ // it could be that the app element doesnt exist yet
+ // so attach to the listeners array and then run()
+ // will actually bind the event.
+ if (!this.listeners[name]) { this.listeners[name] = []; }
+ this.listeners[name].push(listener_callback);
+ if (this.isRunning()) {
+ // if the app is running
+ // *actually* bind the event to the app element
+ this._listen(name, listener_callback);
+ }
+ return this;
+ },
+
+ // Triggers custom events defined with `bind()`
+ //
+ // ### Arguments
+ //
+ // * `name` The name of the event. Automatically prefixed with the `eventNamespace()`
+ // * `data` An optional Object that can be passed to the bound callback.
+ // * `context` An optional context/Object in which to execute the bound callback.
+ // If no context is supplied a the context is a new `Sammy.EventContext`
+ //
+ trigger: function(name, data) {
+ this.$element().trigger([name, this.eventNamespace()].join('.'), [data]);
+ return this;
+ },
+
+ // Reruns the current route
+ refresh: function() {
+ this.last_location = null;
+ this.trigger('location-changed');
+ return this;
+ },
+
+ // Takes a single callback that is pushed on to a stack.
+ // Before any route is run, the callbacks are evaluated in order within
+ // the current `Sammy.EventContext`
+ //
+ // If any of the callbacks explicitly return false, execution of any
+ // further callbacks and the route itself is halted.
+ //
+ // You can also provide a set of options that will define when to run this
+ // before based on the route it proceeds.
+ //
+ // ### Example
+ //
+ // var app = $.sammy(function() {
+ //
+ // // will run at #/route but not at #/
+ // this.before('#/route', function() {
+ // //...
+ // });
+ //
+ // // will run at #/ but not at #/route
+ // this.before({except: {path: '#/route'}}, function() {
+ // this.log('not before #/route');
+ // });
+ //
+ // this.get('#/', function() {});
+ //
+ // this.get('#/route', function() {});
+ //
+ // });
+ //
+ // See `contextMatchesOptions()` for a full list of supported options
+ //
+ before: function(options, callback) {
+ if (_isFunction(options)) {
+ callback = options;
+ options = {};
+ }
+ this.befores.push([options, callback]);
+ return this;
+ },
+
+ // A shortcut for binding a callback to be run after a route is executed.
+ // After callbacks have no guarunteed order.
+ after: function(callback) {
+ return this.bind('event-context-after', callback);
+ },
+
+
+ // Adds an around filter to the application. around filters are functions
+ // that take a single argument `callback` which is the entire route
+ // execution path wrapped up in a closure. This means you can decide whether
+ // or not to proceed with execution by not invoking `callback` or,
+ // more usefuly wrapping callback inside the result of an asynchronous execution.
+ //
+ // ### Example
+ //
+ // The most common use case for around() is calling a _possibly_ async function
+ // and executing the route within the functions callback:
+ //
+ // var app = $.sammy(function() {
+ //
+ // var current_user = false;
+ //
+ // function checkLoggedIn(callback) {
+ // // /session returns a JSON representation of the logged in user
+ // // or an empty object
+ // if (!current_user) {
+ // $.getJSON('/session', function(json) {
+ // if (json.login) {
+ // // show the user as logged in
+ // current_user = json;
+ // // execute the route path
+ // callback();
+ // } else {
+ // // show the user as not logged in
+ // current_user = false;
+ // // the context of aroundFilters is an EventContext
+ // this.redirect('#/login');
+ // }
+ // });
+ // } else {
+ // // execute the route path
+ // callback();
+ // }
+ // };
+ //
+ // this.around(checkLoggedIn);
+ //
+ // });
+ //
+ around: function(callback) {
+ this.arounds.push(callback);
+ return this;
+ },
+
+ // Returns `true` if the current application is running.
+ isRunning: function() {
+ return this._running;
+ },
+
+ // Helpers extends the EventContext prototype specific to this app.
+ // This allows you to define app specific helper functions that can be used
+ // whenever you're inside of an event context (templates, routes, bind).
+ //
+ // ### Example
+ //
+ // var app = $.sammy(function() {
+ //
+ // helpers({
+ // upcase: function(text) {
+ // return text.toString().toUpperCase();
+ // }
+ // });
+ //
+ // get('#/', function() { with(this) {
+ // // inside of this context I can use the helpers
+ // $('#main').html(upcase($('#main').text());
+ // }});
+ //
+ // });
+ //
+ //
+ // ### Arguments
+ //
+ // * `extensions` An object collection of functions to extend the context.
+ //
+ helpers: function(extensions) {
+ $.extend(this.context_prototype.prototype, extensions);
+ return this;
+ },
+
+ // Helper extends the event context just like `helpers()` but does it
+ // a single method at a time. This is especially useful for dynamically named
+ // helpers
+ //
+ // ### Example
+ //
+ // // Trivial example that adds 3 helper methods to the context dynamically
+ // var app = $.sammy(function(app) {
+ //
+ // $.each([1,2,3], function(i, num) {
+ // app.helper('helper' + num, function() {
+ // this.log("I'm helper number " + num);
+ // });
+ // });
+ //
+ // this.get('#/', function() {
+ // this.helper2(); //=> I'm helper number 2
+ // });
+ // });
+ //
+ // ### Arguments
+ //
+ // * `name` The name of the method
+ // * `method` The function to be added to the prototype at `name`
+ //
+ helper: function(name, method) {
+ this.context_prototype.prototype[name] = method;
+ return this;
+ },
+
+ // Actually starts the application's lifecycle. `run()` should be invoked
+ // within a document.ready block to ensure the DOM exists before binding events, etc.
+ //
+ // ### Example
+ //
+ // var app = $.sammy(function() { ... }); // your application
+ // $(function() { // document.ready
+ // app.run();
+ // });
+ //
+ // ### Arguments
+ //
+ // * `start_url` Optionally, a String can be passed which the App will redirect to
+ // after the events/routes have been bound.
+ run: function(start_url) {
+ if (this.isRunning()) { return false; }
+ var app = this;
+
+ // actually bind all the listeners
+ $.each(this.listeners.toHash(), function(name, callbacks) {
+ $.each(callbacks, function(i, listener_callback) {
+ app._listen(name, listener_callback);
+ });
+ });
+
+ this.trigger('run', {start_url: start_url});
+ this._running = true;
+ // set last location
+ this.last_location = null;
+ if (this.getLocation() == '' && typeof start_url != 'undefined') {
+ this.setLocation(start_url);
+ }
+ // check url
+ this._checkLocation();
+ this._location_proxy.bind();
+ this.bind('location-changed', function() {
+ app._checkLocation();
+ });
+
+ // bind to submit to capture post/put/delete routes
+ this.bind('submit', function(e) {
+ var returned = app._checkFormSubmission($(e.target).closest('form'));
+ return (returned === false) ? e.preventDefault() : false;
+ });
+
+ // bind unload to body unload
+ $(window).bind('beforeunload', function() {
+ app.unload();
+ });
+
+ // trigger html changed
+ return this.trigger('changed');
+ },
+
+ // The opposite of `run()`, un-binds all event listeners and intervals
+ // `run()` Automaticaly binds a `onunload` event to run this when
+ // the document is closed.
+ unload: function() {
+ if (!this.isRunning()) { return false; }
+ var app = this;
+ this.trigger('unload');
+ // clear interval
+ this._location_proxy.unbind();
+ // unbind form submits
+ this.$element().unbind('submit').removeClass(app.eventNamespace());
+ // unbind all events
+ $.each(this.listeners.toHash() , function(name, listeners) {
+ $.each(listeners, function(i, listener_callback) {
+ app._unlisten(name, listener_callback);
+ });
+ });
+ this._running = false;
+ return this;
+ },
+
+ // Will bind a single callback function to every event that is already
+ // being listened to in the app. This includes all the `APP_EVENTS`
+ // as well as any custom events defined with `bind()`.
+ //
+ // Used internally for debug logging.
+ bindToAllEvents: function(callback) {
+ var app = this;
+ // bind to the APP_EVENTS first
+ $.each(this.APP_EVENTS, function(i, e) {
+ app.bind(e, callback);
+ });
+ // next, bind to listener names (only if they dont exist in APP_EVENTS)
+ $.each(this.listeners.keys(true), function(i, name) {
+ if (app.APP_EVENTS.indexOf(name) == -1) {
+ app.bind(name, callback);
+ }
+ });
+ return this;
+ },
+
+ // Returns a copy of the given path with any query string after the hash
+ // removed.
+ routablePath: function(path) {
+ return path.replace(QUERY_STRING_MATCHER, '');
+ },
+
+ // Given a verb and a String path, will return either a route object or false
+ // if a matching route can be found within the current defined set.
+ lookupRoute: function(verb, path) {
+ var app = this, routed = false;
+ this.trigger('lookup-route', {verb: verb, path: path});
+ if (typeof this.routes[verb] != 'undefined') {
+ $.each(this.routes[verb], function(i, route) {
+ if (app.routablePath(path).match(route.path)) {
+ routed = route;
+ return false;
+ }
+ });
+ }
+ return routed;
+ },
+
+ // First, invokes `lookupRoute()` and if a route is found, parses the
+ // possible URL params and then invokes the route's callback within a new
+ // `Sammy.EventContext`. If the route can not be found, it calls
+ // `notFound()`. If `raise_errors` is set to `true` and
+ // the `error()` has not been overriden, it will throw an actual JS
+ // error.
+ //
+ // You probably will never have to call this directly.
+ //
+ // ### Arguments
+ //
+ // * `verb` A String for the verb.
+ // * `path` A String path to lookup.
+ // * `params` An Object of Params pulled from the URI or passed directly.
+ //
+ // ### Returns
+ //
+ // Either returns the value returned by the route callback or raises a 404 Not Found error.
+ //
+ runRoute: function(verb, path, params, target) {
+ var app = this,
+ route = this.lookupRoute(verb, path),
+ context,
+ wrapped_route,
+ arounds,
+ around,
+ befores,
+ before,
+ callback_args,
+ path_params,
+ final_returned;
+
+ this.log('runRoute', [verb, path].join(' '));
+ this.trigger('run-route', {verb: verb, path: path, params: params});
+ if (typeof params == 'undefined') { params = {}; }
+
+ $.extend(params, this._parseQueryString(path));
+
+ if (route) {
+ this.trigger('route-found', {route: route});
+ // pull out the params from the path
+ if ((path_params = route.path.exec(this.routablePath(path))) !== null) {
+ // first match is the full path
+ path_params.shift();
+ // for each of the matches
+ $.each(path_params, function(i, param) {
+ // if theres a matching param name
+ if (route.param_names[i]) {
+ // set the name to the match
+ params[route.param_names[i]] = _decode(param);
+ } else {
+ // initialize 'splat'
+ if (!params.splat) { params.splat = []; }
+ params.splat.push(_decode(param));
+ }
+ });
+ }
+
+ // set event context
+ context = new this.context_prototype(this, verb, path, params, target);
+ // ensure arrays
+ arounds = this.arounds.slice(0);
+ befores = this.befores.slice(0);
+ // set the callback args to the context + contents of the splat
+ callback_args = [context].concat(params.splat);
+ // wrap the route up with the before filters
+ wrapped_route = function() {
+ var returned;
+ while (befores.length > 0) {
+ before = befores.shift();
+ // check the options
+ if (app.contextMatchesOptions(context, before[0])) {
+ returned = before[1].apply(context, [context]);
+ if (returned === false) { return false; }
+ }
+ }
+ app.last_route = route;
+ context.trigger('event-context-before', {context: context});
+ returned = route.callback.apply(context, callback_args);
+ context.trigger('event-context-after', {context: context});
+ return returned;
+ };
+ $.each(arounds.reverse(), function(i, around) {
+ var last_wrapped_route = wrapped_route;
+ wrapped_route = function() { return around.apply(context, [last_wrapped_route]); };
+ });
+ try {
+ final_returned = wrapped_route();
+ } catch(e) {
+ this.error(['500 Error', verb, path].join(' '), e);
+ }
+ return final_returned;
+ } else {
+ return this.notFound(verb, path);
+ }
+ },
+
+ // Matches an object of options against an `EventContext` like object that
+ // contains `path` and `verb` attributes. Internally Sammy uses this
+ // for matching `before()` filters against specific options. You can set the
+ // object to _only_ match certain paths or verbs, or match all paths or verbs _except_
+ // those that match the options.
+ //
+ // ### Example
+ //
+ // var app = $.sammy(),
+ // context = {verb: 'get', path: '#/mypath'};
+ //
+ // // match against a path string
+ // app.contextMatchesOptions(context, '#/mypath'); //=> true
+ // app.contextMatchesOptions(context, '#/otherpath'); //=> false
+ // // equivilent to
+ // app.contextMatchesOptions(context, {only: {path:'#/mypath'}}); //=> true
+ // app.contextMatchesOptions(context, {only: {path:'#/otherpath'}}); //=> false
+ // // match against a path regexp
+ // app.contextMatchesOptions(context, /path/); //=> true
+ // app.contextMatchesOptions(context, /^path/); //=> false
+ // // match only a verb
+ // app.contextMatchesOptions(context, {only: {verb:'get'}}); //=> true
+ // app.contextMatchesOptions(context, {only: {verb:'post'}}); //=> false
+ // // match all except a verb
+ // app.contextMatchesOptions(context, {except: {verb:'post'}}); //=> true
+ // app.contextMatchesOptions(context, {except: {verb:'get'}}); //=> false
+ // // match all except a path
+ // app.contextMatchesOptions(context, {except: {path:'#/otherpath'}}); //=> true
+ // app.contextMatchesOptions(context, {except: {path:'#/mypath'}}); //=> false
+ //
+ contextMatchesOptions: function(context, match_options, positive) {
+ // empty options always match
+ var options = match_options;
+ if (typeof options === 'undefined' || options == {}) {
+ return true;
+ }
+ if (typeof positive === 'undefined') {
+ positive = true;
+ }
+ // normalize options
+ if (typeof options === 'string' || _isFunction(options.test)) {
+ options = {path: options};
+ }
+ if (options.only) {
+ return this.contextMatchesOptions(context, options.only, true);
+ } else if (options.except) {
+ return this.contextMatchesOptions(context, options.except, false);
+ }
+ var path_matched = true, verb_matched = true;
+ if (options.path) {
+ // wierd regexp test
+ if (_isFunction(options.path.test)) {
+ path_matched = options.path.test(context.path);
+ } else {
+ path_matched = (options.path.toString() === context.path);
+ }
+ }
+ if (options.verb) {
+ verb_matched = options.verb === context.verb;
+ }
+ return positive ? (verb_matched && path_matched) : !(verb_matched && path_matched);
+ },
+
+
+ // Delegates to the `location_proxy` to get the current location.
+ // See `Sammy.HashLocationProxy` for more info on location proxies.
+ getLocation: function() {
+ return this._location_proxy.getLocation();
+ },
+
+ // Delegates to the `location_proxy` to set the current location.
+ // See `Sammy.HashLocationProxy` for more info on location proxies.
+ //
+ // ### Arguments
+ //
+ // * `new_location` A new location string (e.g. '#/')
+ //
+ setLocation: function(new_location) {
+ return this._location_proxy.setLocation(new_location);
+ },
+
+ // Swaps the content of `$element()` with `content`
+ // You can override this method to provide an alternate swap behavior
+ // for `EventContext.partial()`.
+ //
+ // ### Example
+ //
+ // var app = $.sammy(function() {
+ //
+ // // implements a 'fade out'/'fade in'
+ // this.swap = function(content) {
+ // this.$element().hide('slow').html(content).show('slow');
+ // }
+ //
+ // get('#/', function() {
+ // this.partial('index.html.erb') // will fade out and in
+ // });
+ //
+ // });
+ //
+ swap: function(content) {
+ return this.$element().html(content);
+ },
+
+ // a simple global cache for templates. Uses the same semantics as
+ // `Sammy.Cache` and `Sammy.Storage` so can easily be replaced with
+ // a persistant storage that lasts beyond the current request.
+ templateCache: function(key, value) {
+ if (typeof value != 'undefined') {
+ return _template_cache[key] = value;
+ } else {
+ return _template_cache[key];
+ }
+ },
+
+ // clear the templateCache
+ clearTemplateCache: function() {
+ return _template_cache = {};
+ },
+
+ // This thows a '404 Not Found' error by invoking `error()`.
+ // Override this method or `error()` to provide custom
+ // 404 behavior (i.e redirecting to / or showing a warning)
+ notFound: function(verb, path) {
+ var ret = this.error(['404 Not Found', verb, path].join(' '));
+ return (verb === 'get') ? ret : true;
+ },
+
+ // The base error handler takes a string `message` and an `Error`
+ // object. If `raise_errors` is set to `true` on the app level,
+ // this will re-throw the error to the browser. Otherwise it will send the error
+ // to `log()`. Override this method to provide custom error handling
+ // e.g logging to a server side component or displaying some feedback to the
+ // user.
+ error: function(message, original_error) {
+ if (!original_error) { original_error = new Error(); }
+ original_error.message = [message, original_error.message].join(' ');
+ this.trigger('error', {message: original_error.message, error: original_error});
+ if (this.raise_errors) {
+ throw(original_error);
+ } else {
+ this.log(original_error.message, original_error);
+ }
+ },
+
+ _checkLocation: function() {
+ var location, returned;
+ // get current location
+ location = this.getLocation();
+ // compare to see if hash has changed
+ if (!this.last_location || this.last_location[0] != 'get' || this.last_location[1] != location) {
+ // reset last location
+ this.last_location = ['get', location];
+ // lookup route for current hash
+ returned = this.runRoute('get', location);
+ }
+ return returned;
+ },
+
+ _getFormVerb: function(form) {
+ var $form = $(form), verb, $_method;
+ $_method = $form.find('input[name="_method"]');
+ if ($_method.length > 0) { verb = $_method.val(); }
+ if (!verb) { verb = $form[0].getAttribute('method'); }
+ if (!verb || verb == '') { verb = 'get'; }
+ return $.trim(verb.toString().toLowerCase());
+ },
+
+ _checkFormSubmission: function(form) {
+ var $form, path, verb, params, returned;
+ this.trigger('check-form-submission', {form: form});
+ $form = $(form);
+ path = $form.attr('action');
+ verb = this._getFormVerb($form);
+ this.log('_checkFormSubmission', $form, path, verb);
+ if (verb === 'get') {
+ this.setLocation(path + '?' + this._serializeFormParams($form));
+ returned = false;
+ } else {
+ params = $.extend({}, this._parseFormParams($form));
+ returned = this.runRoute(verb, path, params, form.get(0));
+ };
+ return (typeof returned == 'undefined') ? false : returned;
+ },
+
+ _serializeFormParams: function($form) {
+ var queryString = "",
+ fields = $form.serializeArray(),
+ i;
+ if (fields.length > 0) {
+ queryString = this._encodeFormPair(fields[0].name, fields[0].value);
+ for (i = 1; i < fields.length; i++) {
+ queryString = queryString + "&" + this._encodeFormPair(fields[i].name, fields[i].value);
+ }
+ }
+ return queryString;
+ },
+
+ _encodeFormPair: function(name, value){
+ return _encode(name) + "=" + _encode(value);
+ },
+
+ _parseFormParams: function($form) {
+ var params = {},
+ form_fields = $form.serializeArray(),
+ i;
+ for (i = 0; i < form_fields.length; i++) {
+ params = this._parseParamPair(params, form_fields[i].name, form_fields[i].value);
+ }
+ return params;
+ },
+
+ _parseQueryString: function(path) {
+ var params = {}, parts, pairs, pair, i;
+
+ parts = path.match(QUERY_STRING_MATCHER);
+ if (parts) {
+ pairs = parts[1].split('&');
+ for (i = 0; i < pairs.length; i++) {
+ pair = pairs[i].split('=');
+ params = this._parseParamPair(params, _decode(pair[0]), _decode(pair[1] || ""));
+ }
+ }
+ return params;
+ },
+
+ _parseParamPair: function(params, key, value) {
+ if (params[key]) {
+ if (_isArray(params[key])) {
+ params[key].push(value);
+ } else {
+ params[key] = [params[key], value];
+ }
+ } else {
+ params[key] = value;
+ }
+ return params;
+ },
+
+ _listen: function(name, callback) {
+ return this.$element().bind([name, this.eventNamespace()].join('.'), callback);
+ },
+
+ _unlisten: function(name, callback) {
+ return this.$element().unbind([name, this.eventNamespace()].join('.'), callback);
+ }
+
+ });
+
+ // `Sammy.RenderContext` is an object that makes sequential template loading,
+ // rendering and interpolation seamless even when dealing with asyncronous
+ // operations.
+ //
+ // `RenderContext` objects are not usually created directly, rather they are
+ // instatiated from an `Sammy.EventContext` by using `render()`, `load()` or
+ // `partial()` which all return `RenderContext` objects.
+ //
+ // `RenderContext` methods always returns a modified `RenderContext`
+ // for chaining (like jQuery itself).
+ //
+ // The core magic is in the `then()` method which puts the callback passed as
+ // an argument into a queue to be executed once the previous callback is complete.
+ // All the methods of `RenderContext` are wrapped in `then()` which allows you
+ // to queue up methods by chaining, but maintaing a guarunteed execution order
+ // even with remote calls to fetch templates.
+ //
+ Sammy.RenderContext = function(event_context) {
+ this.event_context = event_context;
+ this.callbacks = [];
+ this.previous_content = null;
+ this.content = null;
+ this.next_engine = false;
+ this.waiting = false;
+ };
+
+ Sammy.RenderContext.prototype = $.extend({}, Sammy.Object.prototype, {
+
+ // The "core" of the `RenderContext` object, adds the `callback` to the
+ // queue. If the context is `waiting` (meaning an async operation is happening)
+ // then the callback will be executed in order, once the other operations are
+ // complete. If there is no currently executing operation, the `callback`
+ // is executed immediately.
+ //
+ // The value returned from the callback is stored in `content` for the
+ // subsiquent operation. If you return `false`, the queue will pause, and
+ // the next callback in the queue will not be executed until `next()` is
+ // called. This allows for the guarunteed order of execution while working
+ // with async operations.
+ //
+ // If then() is passed a string instead of a function, the string is looked
+ // up as a helper method on the event context.
+ //
+ // ### Example
+ //
+ // this.get('#/', function() {
+ // // initialize the RenderContext
+ // // Even though `load()` executes async, the next `then()`
+ // // wont execute until the load finishes
+ // this.load('myfile.txt')
+ // .then(function(content) {
+ // // the first argument to then is the content of the
+ // // prev operation
+ // $('#main').html(content);
+ // });
+ // });
+ //
+ then: function(callback) {
+ if (!_isFunction(callback)) {
+ // if a string is passed to then, assume we want to call
+ // a helper on the event context in its context
+ if (typeof callback === 'string' && callback in this.event_context) {
+ var helper = this.event_context[callback];
+ callback = function(content) {
+ return helper.apply(this.event_context, [content]);
+ };
+ } else {
+ return this;
+ }
+ }
+ var context = this;
+ if (this.waiting) {
+ this.callbacks.push(callback);
+ } else {
+ this.wait();
+ window.setTimeout(function() {
+ var returned = callback.apply(context, [context.content, context.previous_content]);
+ if (returned !== false) {
+ context.next(returned);
+ }
+ }, 13);
+ }
+ return this;
+ },
+
+ // Pause the `RenderContext` queue. Combined with `next()` allows for async
+ // operations.
+ //
+ // ### Example
+ //
+ // this.get('#/', function() {
+ // this.load('mytext.json')
+ // .then(function(content) {
+ // var context = this,
+ // data = JSON.parse(content);
+ // // pause execution
+ // context.wait();
+ // // post to a url
+ // $.post(data.url, {}, function(response) {
+ // context.next(JSON.parse(response));
+ // });
+ // })
+ // .then(function(data) {
+ // // data is json from the previous post
+ // $('#message').text(data.status);
+ // });
+ // });
+ wait: function() {
+ this.waiting = true;
+ },
+
+ // Resume the queue, setting `content` to be used in the next operation.
+ // See `wait()` for an example.
+ next: function(content) {
+ this.waiting = false;
+ if (typeof content !== 'undefined') {
+ this.previous_content = this.content;
+ this.content = content;
+ }
+ if (this.callbacks.length > 0) {
+ this.then(this.callbacks.shift());
+ }
+ },
+
+ // Load a template into the context.
+ // The `location` can either be a string specifiying the remote path to the
+ // file, a jQuery object, or a DOM element.
+ //
+ // No interpolation happens by default, the content is stored in
+ // `content`.
+ //
+ // In the case of a path, unless the option `{cache: false}` is passed the
+ // data is stored in the app's `templateCache()`.
+ //
+ // If a jQuery or DOM object is passed the `innerHTML` of the node is pulled in.
+ // This is useful for nesting templates as part of the initial page load wrapped
+ // in invisible elements or `
Hello!
+ // + // Hey, AQ! Welcome to Handlebars! + // + // + // ### Example #2 - Handlebars partials + // + // The template (mytemplate.hb) + // + // Hey, {{name}}! {{>hello_friend}} + // + // + // The partial (mypartial.hb) + // + // Say hello to your friend {{friend}}! + // + // The app: + // + // var $.app = $.sammy(function() { + // // include the plugin and alias handlebars() to hb() + // this.use(Sammy.Handlebars, 'hb'); + // + // this.get('#/hello/:name/to/:friend', function() { + // var context = this; + // + // // fetch handlebars-partial first + // $.get('mypartial.hb', function(response){ + // context.partials = response; + // + // // set local vars + // context.name = this.params.name; + // context.hello_friend = {name: this.params.friend}; + // + // // render the template and pass it through handlebars + // context.partial('mytemplate.hb'); + // }); + // }); + // + // }); + // + // If I go to #/hello/AQ/to/dP in the browser, Sammy will render this to the body: + // + // Hey, AQ! Say hello to your friend dP! + // + // Note: You dont have to include the handlebars.js file on top of the plugin as the plugin + // includes the full source. + // + Sammy.Handlebars = function(app, method_alias) { + + var handlebars_cache = {}; + // *Helper* Uses handlebars.js to parse a template and interpolate and work with the passed data + // + // ### Arguments + // + // * `template` A String template. + // * `data` An Object containing the replacement values for the template. + // data is extended with the EventContext allowing you to call its methods within the template. + // + var handlebars = function(template, data, partials, name) { + // use name for caching + if (typeof name == 'undefined') name = template; + var fn = handlebars_cache[name]; + if (!fn) { + fn = handlebars_cache[name] = Handlebars.compile(template); + } + + data = $.extend({}, this, data); + partials = $.extend({}, data.partials, partials); + + return fn(data, {"partials":partials}); + }; + + // set the default method name/extension + if (!method_alias) method_alias = 'handlebars'; + app.helper(method_alias, handlebars); + + }; + +})(jQuery); diff --git a/public/javascripts/plugins/sammy.hoptoad.js b/public/javascripts/plugins/sammy.hoptoad.js new file mode 100644 index 0000000..56cc155 --- /dev/null +++ b/public/javascripts/plugins/sammy.hoptoad.js @@ -0,0 +1,30 @@ +(function($) { + + Sammy = Sammy || {}; + + // A plugin that posts errors to Hoptoad. + // + // ### Requirements + // + // The sole requirement is a Hoptoad object with a notify function. + // Thoughtbot have published an implementation (see below). + // + // ### Arguments + // + // Sammy.Hoptoad accepts an optional argument that is the + // Hoptoad implementation. It will default to the global `Hoptoad` object. + // + // ### See Also + // * http://hoptoadapp.com/ + // * http://robots.thoughtbot.com/post/899737797 + // * http://hoptoadapp.com/javascripts/notifier.js + Sammy.Hoptoad = function(app, errorReporter) { + errorReporter = errorReporter || window.Hoptoad; + app.bind('error', function(e, data) { + if (data && data.error) { + errorReporter.notify(data.error); + } + }); + }; + +})(jQuery); diff --git a/public/javascripts/plugins/sammy.json.js b/public/javascripts/plugins/sammy.json.js new file mode 100644 index 0000000..83b9dd0 --- /dev/null +++ b/public/javascripts/plugins/sammy.json.js @@ -0,0 +1,362 @@ +(function($) { + + // json2.js - only included if native json does not exist + // http://www.json.org/js.html + if (!window.JSON) { + window.JSON = {}; + } + (function () { + + function f(n) { + // Format integers to have at least two digits. + return n < 10 ? '0' + n : n; + } + + if (typeof Date.prototype.toJSON !== 'function') { + + Date.prototype.toJSON = function (key) { + + return this.getUTCFullYear() + '-' + + f(this.getUTCMonth() + 1) + '-' + + f(this.getUTCDate()) + 'T' + + f(this.getUTCHours()) + ':' + + f(this.getUTCMinutes()) + ':' + + f(this.getUTCSeconds()) + 'Z'; + }; + + String.prototype.toJSON = + Number.prototype.toJSON = + Boolean.prototype.toJSON = function (key) { + return this.valueOf(); + }; + } + + var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, + escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, + gap, + indent, + meta = { // table of character substitutions + '\b': '\\b', + '\t': '\\t', + '\n': '\\n', + '\f': '\\f', + '\r': '\\r', + '"' : '\\"', + '\\': '\\\\' + }, + rep; + + + function quote(string) { + + // If the string contains no control characters, no quote characters, and no + // backslash characters, then we can safely slap some quotes around it. + // Otherwise we must also replace the offending characters with safe escape + // sequences. + + escapable.lastIndex = 0; + return escapable.test(string) ? + '"' + string.replace(escapable, function (a) { + var c = meta[a]; + return typeof c === 'string' ? c : + '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4); + }) + '"' : + '"' + string + '"'; + } + + + function str(key, holder) { + + // Produce a string from holder[key]. + + var i, // The loop counter. + k, // The member key. + v, // The member value. + length, + mind = gap, + partial, + value = holder[key]; + + // If the value has a toJSON method, call it to obtain a replacement value. + + if (value && typeof value === 'object' && + typeof value.toJSON === 'function') { + value = value.toJSON(key); + } + + // If we were called with a replacer function, then call the replacer to + // obtain a replacement value. + + if (typeof rep === 'function') { + value = rep.call(holder, key, value); + } + + // What happens next depends on the value's type. + + switch (typeof value) { + case 'string': + return quote(value); + + case 'number': + + // JSON numbers must be finite. Encode non-finite numbers as null. + + return isFinite(value) ? String(value) : 'null'; + + case 'boolean': + case 'null': + + // If the value is a boolean or null, convert it to a string. Note: + // typeof null does not produce 'null'. The case is included here in + // the remote chance that this gets fixed someday. + + return String(value); + + // If the type is 'object', we might be dealing with an object or an array or + // null. + + case 'object': + + // Due to a specification blunder in ECMAScript, typeof null is 'object', + // so watch out for that case. + + if (!value) { + return 'null'; + } + + // Make an array to hold the partial results of stringifying this object value. + + gap += indent; + partial = []; + + // Is the value an array? + + if (Object.prototype.toString.apply(value) === '[object Array]') { + + // The value is an array. Stringify every element. Use null as a placeholder + // for non-JSON values. + + length = value.length; + for (i = 0; i < length; i += 1) { + partial[i] = str(i, value) || 'null'; + } + + // Join all of the elements together, separated with commas, and wrap them in + // brackets. + + v = partial.length === 0 ? '[]' : + gap ? '[\n' + gap + + partial.join(',\n' + gap) + '\n' + + mind + ']' : + '[' + partial.join(',') + ']'; + gap = mind; + return v; + } + + // If the replacer is an array, use it to select the members to be stringified. + + if (rep && typeof rep === 'object') { + length = rep.length; + for (i = 0; i < length; i += 1) { + k = rep[i]; + if (typeof k === 'string') { + v = str(k, value); + if (v) { + partial.push(quote(k) + (gap ? ': ' : ':') + v); + } + } + } + } else { + + // Otherwise, iterate through all of the keys in the object. + + for (k in value) { + if (Object.hasOwnProperty.call(value, k)) { + v = str(k, value); + if (v) { + partial.push(quote(k) + (gap ? ': ' : ':') + v); + } + } + } + } + + // Join all of the member texts together, separated with commas, + // and wrap them in braces. + + v = partial.length === 0 ? '{}' : + gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + + mind + '}' : '{' + partial.join(',') + '}'; + gap = mind; + return v; + } + } + + // If the JSON object does not yet have a stringify method, give it one. + + if (typeof JSON.stringify !== 'function') { + JSON.stringify = function (value, replacer, space) { + + // The stringify method takes a value and an optional replacer, and an optional + // space parameter, and returns a JSON text. The replacer can be a function + // that can replace values, or an array of strings that will select the keys. + // A default replacer method can be provided. Use of the space parameter can + // produce text that is more easily readable. + + var i; + gap = ''; + indent = ''; + + // If the space parameter is a number, make an indent string containing that + // many spaces. + + if (typeof space === 'number') { + for (i = 0; i < space; i += 1) { + indent += ' '; + } + + // If the space parameter is a string, it will be used as the indent string. + + } else if (typeof space === 'string') { + indent = space; + } + + // If there is a replacer, it must be a function or an array. + // Otherwise, throw an error. + + rep = replacer; + if (replacer && typeof replacer !== 'function' && + (typeof replacer !== 'object' || + typeof replacer.length !== 'number')) { + throw new Error('JSON.stringify'); + } + + // Make a fake root object containing our value under the key of ''. + // Return the result of stringifying the value. + + return str('', {'': value}); + }; + } + + + // If the JSON object does not yet have a parse method, give it one. + + if (typeof JSON.parse !== 'function') { + JSON.parse = function (text, reviver) { + + // The parse method takes a text and an optional reviver function, and returns + // a JavaScript value if the text is a valid JSON text. + + var j; + + function walk(holder, key) { + + // The walk method is used to recursively walk the resulting structure so + // that modifications can be made. + + var k, v, value = holder[key]; + if (value && typeof value === 'object') { + for (k in value) { + if (Object.hasOwnProperty.call(value, k)) { + v = walk(value, k); + if (v !== undefined) { + value[k] = v; + } else { + delete value[k]; + } + } + } + } + return reviver.call(holder, key, value); + } + + + // Parsing happens in four stages. In the first stage, we replace certain + // Unicode characters with escape sequences. JavaScript handles many characters + // incorrectly, either silently deleting them, or treating them as line endings. + + cx.lastIndex = 0; + if (cx.test(text)) { + text = text.replace(cx, function (a) { + return '\\u' + + ('0000' + a.charCodeAt(0).toString(16)).slice(-4); + }); + } + + // In the second stage, we run the text against regular expressions that look + // for non-JSON patterns. We are especially concerned with '()' and 'new' + // because they can cause invocation, and '=' because it can cause mutation. + // But just to be safe, we want to reject all unexpected forms. + + // We split the second stage into 4 regexp operations in order to work around + // crippling inefficiencies in IE's and Safari's regexp engines. First we + // replace the JSON backslash pairs with '@' (a non-JSON character). Second, we + // replace all simple value tokens with ']' characters. Third, we delete all + // open brackets that follow a colon or comma or that begin the text. Finally, + // we look to see that the remaining characters are only whitespace or ']' or + // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval. + + if (/^[\],:{}\s]*$/. + test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@'). + replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']'). + replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) { + + // In the third stage we use the eval function to compile the text into a + // JavaScript structure. The '{' operator is subject to a syntactic ambiguity + // in JavaScript: it can begin a block or an object literal. We wrap the text + // in parens to eliminate the ambiguity. + + j = eval('(' + text + ')'); + + // In the optional fourth stage, we recursively walk the new structure, passing + // each name/value pair to a reviver function for possible transformation. + + return typeof reviver === 'function' ? + walk({'': j}, '') : j; + } + + // If the text is not JSON parseable, then a SyntaxError is thrown. + + throw new SyntaxError('JSON.parse'); + }; + } + }()); + + Sammy = Sammy || {}; + + // Sammy.JSON is a simple wrapper around Douglas Crockford's ever-useful json2.js + // (http://www.json.org/js.html]) Sammy.JSON includes the top level JSON object if + // it doesn't already exist (a.k.a. does not override the native implementation that + // some browsers include). It also adds a json() helper to a Sammy app when + // included. + Sammy.JSON = function(app) { + + app.helpers({ + // json is a polymorphic function that translates objects aback and forth + // from JSON to JS. If given a string, it will parse into JS, if given a JS + // object it will stringify into JSON. + // + // ### Example + // + // var app = $.sammy(function() { + // this.use(Sammy.JSON); + // + // this.get('#/', function() { + // this.json({user_id: 123}); //=> "{\"user_id\":\"123\"}" + // this.json("{\"user_id\":\"123\"}"); //=> [object Object] + // this.json("{\"user_id\":\"123\"}").user_id; //=> "123" + // }); + // }) + // + // + json: function(object) { + if (typeof object == 'string') { + return JSON.parse(object); + } else { + return JSON.stringify(object); + } + } + }); + + } + +})(jQuery); diff --git a/public/javascripts/plugins/sammy.meld.js b/public/javascripts/plugins/sammy.meld.js new file mode 100644 index 0000000..91a33c3 --- /dev/null +++ b/public/javascripts/plugins/sammy.meld.js @@ -0,0 +1,140 @@ +(function($) { + + Sammy = Sammy || {}; + + // `Sammy.Meld` is a simple templating engine that uses the power of jQuery's + // DOM manipulation to easily meld JSON data and HTML templates very quickly. + // + // The template can either be a string (i.e. loaded from a remote template) + // or a DOM Element/jQuery object. This allows you to have templates be DOM + // elements as the initial document load. + // + // ### Example + // + // The simplest case is a nested `` whose class name is tied to a
+ // property of a JS object.
+ //
+ // Template:
+ //
+ //
+ //
+ //
+ //
+ //
+ //
+ // Data:
+ //
+ // {
+ // "post": {
+ // "title": "My Post",
+ // "entry": "My Entry",
+ // "author": {
+ // "name": "@aq"
+ // }
+ // }
+ // }
+ //
+ // Result:
+ //
+ //
+ //
+ //
+ // Templates can be much more complex, and more deeply nested.
+ // More examples can be found in `test/fixtures/meld/`
+ //
+ // If you don't think the lookup by classes is semantic for you, you can easily
+ // switch the method of lookup by defining a selector function in the options
+ //
+ // For example:
+ //
+ // meld($('.post'), post_data, {
+ // selector: function(k) {
+ // return '[data-key=' + k + ']';
+ // }
+ // });
+ //
+ // Would look for template nodes like `My Post
+ // My Entry
+ //
+ // `
+ //
+ Sammy.Meld = function(app, method_alias) {
+ var default_options = {
+ selector: function(k) { return '.' + k; },
+ remove_false: true
+ };
+
+ var meld = function(template, data, options) {
+ var $template = $(template);
+
+ options = $.extend(default_options, options || {});
+
+ if (typeof data === 'string') {
+ $template.html(data);
+ } else {
+ $.each(data, function(key, value) {
+ var selector = options.selector(key),
+ $sub = $template.filter(selector),
+ $container,
+ $item,
+ is_list = false,
+ subindex = $template.index($sub);
+
+ if ($sub.length === 0) { $sub = $template.find(selector); }
+ if ($sub.length > 0) {
+ if ($.isArray(value)) {
+ $container = $('');
+ if ($sub.is('ol, ul')) {
+ is_list = true;
+ $item = $sub.children('li:first');
+ if ($item.length == 0) { $item = $(''); }
+ } else if ($sub.children().length == 1) {
+ is_list = true;
+ $item = $sub.children(':first').clone();
+ } else {
+ $item = $sub.clone();
+ }
+ for (var i = 0; i < value.length; i++) {
+ $container.append(meld($item.clone(), value[i], options));
+ }
+ if (is_list) {
+ $sub.html($container.html());
+ } else if ($sub[0] == $template[0]) {
+ $template = $($container.html());
+ } else if (subindex >= 0) {
+ var args = [subindex, 1];
+ args = args.concat($container.children().get());
+ $template.splice.apply($template, args);
+ }
+ } else if (options.remove_false && value === false) {
+ $template.splice(subindex, 1);
+ } else if (typeof value === 'object') {
+ if ($sub.is(':empty')) {
+ $sub.attr(value, true);
+ } else {
+ $sub.html(meld($sub.html(), value, options));
+ }
+ } else {
+ $sub.html(value.toString());
+ }
+ } else {
+ $template.attr(key, value, true);
+ }
+ });
+ }
+ var dom = $template;
+ return dom;
+ };
+
+ // set the default method name/extension
+ if (!method_alias) method_alias = 'meld';
+ // create the helper at the method alias
+ app.helper(method_alias, meld);
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.mustache.js b/public/javascripts/plugins/sammy.mustache.js
new file mode 100644
index 0000000..169f0c7
--- /dev/null
+++ b/public/javascripts/plugins/sammy.mustache.js
@@ -0,0 +1,444 @@
+(function($) {
+
+if (!window.Mustache) {
+
+ /*
+ mustache.js — Logic-less templates in JavaScript
+
+ See http://mustache.github.com/ for more info.
+ */
+
+ var Mustache = function() {
+ var Renderer = function() {};
+
+ Renderer.prototype = {
+ otag: "{{",
+ ctag: "}}",
+ pragmas: {},
+ buffer: [],
+ pragmas_implemented: {
+ "IMPLICIT-ITERATOR": true
+ },
+ context: {},
+
+ render: function(template, context, partials, in_recursion) {
+ // reset buffer & set context
+ if(!in_recursion) {
+ this.context = context;
+ this.buffer = []; // TODO: make this non-lazy
+ }
+
+ // fail fast
+ if(!this.includes("", template)) {
+ if(in_recursion) {
+ return template;
+ } else {
+ this.send(template);
+ return;
+ }
+ }
+
+ template = this.render_pragmas(template);
+ var html = this.render_section(template, context, partials);
+ if(in_recursion) {
+ return this.render_tags(html, context, partials, in_recursion);
+ }
+
+ this.render_tags(html, context, partials, in_recursion);
+ },
+
+ /*
+ Sends parsed lines
+ */
+ send: function(line) {
+ if(line != "") {
+ this.buffer.push(line);
+ }
+ },
+
+ /*
+ Looks for %PRAGMAS
+ */
+ render_pragmas: function(template) {
+ // no pragmas
+ if(!this.includes("%", template)) {
+ return template;
+ }
+
+ var that = this;
+ var regex = new RegExp(this.otag + "%([\\w-]+) ?([\\w]+=[\\w]+)?" +
+ this.ctag);
+ return template.replace(regex, function(match, pragma, options) {
+ if(!that.pragmas_implemented[pragma]) {
+ throw({message:
+ "This implementation of mustache doesn't understand the '" +
+ pragma + "' pragma"});
+ }
+ that.pragmas[pragma] = {};
+ if(options) {
+ var opts = options.split("=");
+ that.pragmas[pragma][opts[0]] = opts[1];
+ }
+ return "";
+ // ignore unknown pragmas silently
+ });
+ },
+
+ /*
+ Tries to find a partial in the curent scope and render it
+ */
+ render_partial: function(name, context, partials) {
+ name = this.trim(name);
+ if(!partials || partials[name] === undefined) {
+ throw({message: "unknown_partial '" + name + "'"});
+ }
+ if(typeof(context[name]) != "object") {
+ return this.render(partials[name], context, partials, true);
+ }
+ return this.render(partials[name], context[name], partials, true);
+ },
+
+ /*
+ Renders inverted (^) and normal (#) sections
+ */
+ render_section: function(template, context, partials) {
+ if(!this.includes("#", template) && !this.includes("^", template)) {
+ return template;
+ }
+
+ var that = this;
+ // CSW - Added "+?" so it finds the tighest bound, not the widest
+ var regex = new RegExp(this.otag + "(\\^|\\#)\\s*(.+)\\s*" + this.ctag +
+ "\n*([\\s\\S]+?)" + this.otag + "\\/\\s*\\2\\s*" + this.ctag +
+ "\\s*", "mg");
+
+ // for each {{#foo}}{{/foo}} section do...
+ return template.replace(regex, function(match, type, name, content) {
+ var value = that.find(name, context);
+ if(type == "^") { // inverted section
+ if(!value || that.is_array(value) && value.length === 0) {
+ // false or empty list, render it
+ return that.render(content, context, partials, true);
+ } else {
+ return "";
+ }
+ } else if(type == "#") { // normal section
+ if(that.is_array(value)) { // Enumerable, Let's loop!
+ return that.map(value, function(row) {
+ return that.render(content, that.create_context(row),
+ partials, true);
+ }).join("");
+ } else if(that.is_object(value)) { // Object, Use it as subcontext!
+ return that.render(content, that.create_context(value),
+ partials, true);
+ } else if(typeof value === "function") {
+ // higher order section
+ return value.call(context, content, function(text) {
+ return that.render(text, context, partials, true);
+ });
+ } else if(value) { // boolean section
+ return that.render(content, context, partials, true);
+ } else {
+ return "";
+ }
+ }
+ });
+ },
+
+ /*
+ Replace {{foo}} and friends with values from our view
+ */
+ render_tags: function(template, context, partials, in_recursion) {
+ // tit for tat
+ var that = this;
+
+ var new_regex = function() {
+ return new RegExp(that.otag + "(=|!|>|\\{|%)?([^\\/#\\^]+?)\\1?" +
+ that.ctag + "+", "g");
+ };
+
+ var regex = new_regex();
+ var tag_replace_callback = function(match, operator, name) {
+ switch(operator) {
+ case "!": // ignore comments
+ return "";
+ case "=": // set new delimiters, rebuild the replace regexp
+ that.set_delimiters(name);
+ regex = new_regex();
+ return "";
+ case ">": // render partial
+ return that.render_partial(name, context, partials);
+ case "{": // the triple mustache is unescaped
+ return that.find(name, context);
+ default: // escape the value
+ return that.escape(that.find(name, context));
+ }
+ };
+ var lines = template.split("\n");
+ for(var i = 0; i < lines.length; i++) {
+ lines[i] = lines[i].replace(regex, tag_replace_callback, this);
+ if(!in_recursion) {
+ this.send(lines[i]);
+ }
+ }
+
+ if(in_recursion) {
+ return lines.join("\n");
+ }
+ },
+
+ set_delimiters: function(delimiters) {
+ var dels = delimiters.split(" ");
+ this.otag = this.escape_regex(dels[0]);
+ this.ctag = this.escape_regex(dels[1]);
+ },
+
+ escape_regex: function(text) {
+ // thank you Simon Willison
+ if(!arguments.callee.sRE) {
+ var specials = [
+ '/', '.', '*', '+', '?', '|',
+ '(', ')', '[', ']', '{', '}', '\\'
+ ];
+ arguments.callee.sRE = new RegExp(
+ '(\\' + specials.join('|\\') + ')', 'g'
+ );
+ }
+ return text.replace(arguments.callee.sRE, '\\$1');
+ },
+
+ /*
+ find `name` in current `context`. That is find me a value
+ from the view object
+ */
+ find: function(name, context) {
+ name = this.trim(name);
+
+ // Checks whether a value is thruthy or false or 0
+ function is_kinda_truthy(bool) {
+ return bool === false || bool === 0 || bool;
+ }
+
+ var value;
+ if(is_kinda_truthy(context[name])) {
+ value = context[name];
+ } else if(is_kinda_truthy(this.context[name])) {
+ value = this.context[name];
+ }
+
+ if(typeof value === "function") {
+ return value.apply(context);
+ }
+ if(value !== undefined) {
+ return value;
+ }
+ // silently ignore unkown variables
+ return "";
+ },
+
+ // Utility methods
+
+ /* includes tag */
+ includes: function(needle, haystack) {
+ return haystack.indexOf(this.otag + needle) != -1;
+ },
+
+ /*
+ Does away with nasty characters
+ */
+ escape: function(s) {
+ s = String(s === null ? "" : s);
+ return s.replace(/&(?!\w+;)|["<>\\]/g, function(s) {
+ switch(s) {
+ case "&": return "&";
+ case "\\": return "\\\\";
+ case '"': return '\"';
+ case "<": return "<";
+ case ">": return ">";
+ default: return s;
+ }
+ });
+ },
+
+ // by @langalex, support for arrays of strings
+ create_context: function(_context) {
+ if(this.is_object(_context)) {
+ return _context;
+ } else {
+ var iterator = ".";
+ if(this.pragmas["IMPLICIT-ITERATOR"]) {
+ iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator;
+ }
+ var ctx = {};
+ ctx[iterator] = _context;
+ return ctx;
+ }
+ },
+
+ is_object: function(a) {
+ return a && typeof a == "object";
+ },
+
+ is_array: function(a) {
+ return Object.prototype.toString.call(a) === '[object Array]';
+ },
+
+ /*
+ Gets rid of leading and trailing whitespace
+ */
+ trim: function(s) {
+ return s.replace(/^\s*|\s*$/g, "");
+ },
+
+ /*
+ Why, why, why? Because IE. Cry, cry cry.
+ */
+ map: function(array, fn) {
+ if (typeof array.map == "function") {
+ return array.map(fn);
+ } else {
+ var r = [];
+ var l = array.length;
+ for(var i = 0; i < l; i++) {
+ r.push(fn(array[i]));
+ }
+ return r;
+ }
+ }
+ };
+
+ return({
+ name: "mustache.js",
+ version: "0.3.1-dev",
+
+ /*
+ Turns a template and view into HTML
+ */
+ to_html: function(template, view, partials, send_fun) {
+ var renderer = new Renderer();
+ if(send_fun) {
+ renderer.send = send_fun;
+ }
+ renderer.render(template, view, partials);
+ if(!send_fun) {
+ return renderer.buffer.join("\n");
+ }
+ }
+ });
+ }();
+
+} // Ensure Mustache
+
+ Sammy = Sammy || {};
+
+ // Sammy.Mustache provides a quick way of using mustache style templates in your app.
+ // The plugin itself includes the awesome mustache.js lib created and maintained by Jan Lehnardt
+ // at http://github.com/janl/mustache.js
+ //
+ // Mustache is a clever templating system that relys on double brackets {{}} for interpolation.
+ // For full details on syntax check out the original Ruby implementation created by Chris Wanstrath at
+ // http://github.com/defunkt/mustache
+ //
+ // By default using Sammy.Mustache in your app adds the mustache() method to the EventContext
+ // prototype. However, just like Sammy.Template you can change the default name of the method
+ // by passing a second argument (e.g. you could use the ms() as the method alias so that all the template
+ // files could be in the form file.ms instead of file.mustache)
+ //
+ // ### Example #1
+ //
+ // The template (mytemplate.ms):
+ //
+ // \{\{title\}\}
+ //
+ // And a Sammy app like:
+ //
+ // var app = $.sammy(function(app) {
+ // this.use(Sammy.NestedParams);
+ //
+ // this.post('#/parse_me', function(context) {
+ // $.log(this.params);
+ // });
+ // });
+ //
+ // If you filled out the form with some values and submitted it, you would see something
+ // like this in your log:
+ //
+ // {
+ // 'obj': {
+ // 'first': 'value',
+ // 'second': 'value',
+ // 'hash': {
+ // 'first': 'value',
+ // 'second': 'value'
+ // }
+ // }
+ // }
+ //
+ // It supports creating arrays with [] and other niceities. Check out the tests for
+ // full specs.
+ //
+ Sammy.NestedParams = function(app) {
+
+ app._parseParamPair = parseNestedParam;
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.oauth2.js b/public/javascripts/plugins/sammy.oauth2.js
new file mode 100644
index 0000000..6d0fab2
--- /dev/null
+++ b/public/javascripts/plugins/sammy.oauth2.js
@@ -0,0 +1,144 @@
+(function($) {
+ Sammy = Sammy || {};
+
+ // Sammy.OAuth2 is a plugin for using OAuth 2.0 to authenticate users and
+ // access your application's API. Requires Sammy.Session.
+ //
+ // Triggers the following events:
+ //
+ // * `oauth.connected` - Access token set and ready to use. Triggered when new
+ // access token acquired, of when application starts and already has access
+ // token.
+ // * `oauth.disconnected` - Access token reset. Triggered by
+ // loseAccessToken().
+ // * `oauth.denied` - Authorization attempt rejected.
+ //
+ // ### Example
+ //
+ // this.use('Storage');
+ // this.use('OAuth2');
+ // this.oauthorize = "/oauth/authorize";
+ //
+ // // The quick & easy way
+ // this.requireOAuth();
+ // // Specific path
+ // this.requireOAuth("/private");
+ // // Filter you can apply to specific URLs
+ // this.before(function(context) { return context.requireOAuth(); })
+ // // Apply to specific request
+ // this.get("/private", function(context) {
+ // this.requireOAuth(function() {
+ // // Do something
+ // });
+ // });
+ //
+ // // Sign in/sign out.
+ // this.bind("oauth.connected", function() { $("#signin").hide() });
+ // this.bind("oauth.disconnected", function() { $("#signin").show() });
+ //
+ // // Handle access denied and other errors
+ // this.bind("oauth.denied", function(evt, error) {
+ // this.partial("admin/views/no_access.tmpl", { error: error.message });
+ // });
+ //
+ // // Sign out.
+ // this.get("#/signout", function(context) {
+ // context.loseAccessToken();
+ // context.redirect("#/");
+ // });
+ //
+ Sammy.OAuth2 = function(app) {
+ app.use('JSON');
+ this.authorize = "/oauth/authorize";
+
+ // Use this on request that require OAuth token. You can use this in a
+ // filter: it will redirect and return false if the access token is missing.
+ // You can use it in a route, it will redirect to get the access token, or
+ // call the callback function if it has an access token.
+ this.helper("requireOAuth", function(cb) {
+ if (this.app.getAccessToken()) {
+ if (cb)
+ cb.apply(this);
+ } else {
+ this.redirect(this.app.authorize + "?state=" + escape(this.path));
+ return false;
+ }
+ });
+
+ // Use this to sign out.
+ this.helper("loseAccessToken", function() {
+ this.app.loseAccessToken();
+ });
+
+ // Use this in your application to require an OAuth access token on all, or
+ // the specified paths. It sets up a before filter on the specified paths.
+ this.requireOAuth = function(options) {
+ this.before(options || {}, function(context) {
+ return context.requireOAuth();
+ });
+ }
+
+ // Returns the access token. Uses Sammy.Session to store the token.
+ this.getAccessToken = function() {
+ return this.session("oauth.token");
+ }
+ // Stores the access token in the session.
+ this.setAccessToken = function(token) {
+ this.session("oauth.token", token);
+ this.trigger("oauth.connected");
+ }
+ // Lose access token: use this to sign out.
+ this.loseAccessToken = function() {
+ this.session("oauth.token", null);
+ this.trigger("oauth.disconnected");
+ }
+
+ // Add OAuth 2.0 access token to all XHR requests.
+ $(document).ajaxSend(function(evt, xhr) {
+ var token = app.getAccessToken();
+ if (token)
+ xhr.setRequestHeader("Authorization", "OAuth " + token);
+ });
+
+ // Converts query string parameters in fragment identifier to object.
+ function parseParams(hash) {
+ var pairs = hash.substring(1).split("&"), params = {};
+ for (var i in pairs) {
+ var splat = pairs[i].split("=");
+ params[splat[0]] = splat[1].replace(/\+/g, " ");
+ }
+ return params;
+ }
+
+ var start_url;
+ // Capture the application's start URL, we'll need that later on for
+ // redirection.
+ this.bind("run", function(evt, params) {
+ start_url = params.start_url || "#";
+ if (this.app.getAccessToken())
+ this.trigger("oauth.connected");
+ });
+
+ // Intercept OAuth authorization response with access token, stores it and
+ // redirects to original URL, or application root.
+ this.before(/^#(access_token=|[^\\].*\&access_token=)/, function(context) {
+ var params = parseParams(context.path);
+ this.app.setAccessToken(params.access_token);
+ // When the filter redirected the original request, it passed the original
+ // request's URL in the state parameter, which we get back after
+ // authorization.
+ context.redirect(params.state.length == 0 ? this.app.start_url : unescape(params.state));
+ return false;
+ }).get(/^#(access_token=|[^\\].*\&access_token=)/, function(context) { });
+
+ // Intercept OAuth authorization response with error (typically access
+ // denied).
+ this.before(/^#(error=|[^\\].*\&error=)/, function(context) {
+ var params = parseParams(context.path);
+ var message = params.error_description || "Access denined";
+ context.trigger("oauth.denied", { code: params.error, message: message });
+ return false;
+ }).get(/^#(error=|[^\\].*\&error=)/, function(context) { });
+
+ }
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.path_location_proxy.js b/public/javascripts/plugins/sammy.path_location_proxy.js
new file mode 100644
index 0000000..13f9014
--- /dev/null
+++ b/public/javascripts/plugins/sammy.path_location_proxy.js
@@ -0,0 +1,29 @@
+(function($) {
+
+ Sammy = Sammy || {};
+
+ // `Sammy.PathLocationProxy` is a simple Location Proxy that just
+ // gets and sets window.location. This allows you to use
+ // Sammy to route on the full URL path instead of just the hash. It
+ // will take a full refresh to get the app to change state.
+ //
+ // To read more about location proxies, check out the
+ // documentation for `Sammy.HashLocationProxy`
+ Sammy.PathLocationProxy = function(app) {
+ this.app = app;
+ };
+
+ Sammy.PathLocationProxy.prototype = {
+ bind: function() {},
+ unbind: function() {},
+
+ getLocation: function() {
+ return [window.location.pathname, window.location.search].join('');
+ },
+
+ setLocation: function(new_location) {
+ return window.location = new_location;
+ }
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.pure.js b/public/javascripts/plugins/sammy.pure.js
new file mode 100644
index 0000000..16fe3df
--- /dev/null
+++ b/public/javascripts/plugins/sammy.pure.js
@@ -0,0 +1,756 @@
+(function($) {
+
+/*!
+ PURE Unobtrusive Rendering Engine for HTML
+
+ Licensed under the MIT licenses.
+ More information at: http://www.opensource.org
+
+ Copyright (c) 2010 Michael Cvilic - BeeBole.com
+
+ Thanks to Rog Peppe for the functional JS jump
+ revision: 2.47
+*/
+
+var $p, pure = $p = function(){
+ var sel = arguments[0],
+ ctxt = false;
+
+ if(typeof sel === 'string'){
+ ctxt = arguments[1] || false;
+ }
+ return $p.core(sel, ctxt);
+};
+
+$p.core = function(sel, ctxt, plugins){
+ //get an instance of the plugins
+ var plugins = getPlugins(),
+ templates = [];
+
+ //search for the template node(s)
+ switch(typeof sel){
+ case 'string':
+ templates = plugins.find(ctxt || document, sel);
+ if(templates.length === 0) {
+ error('The template "' + sel + '" was not found');
+ }
+ break;
+ case 'undefined':
+ error('The template root is undefined, check your selector');
+ break;
+ default:
+ templates = [sel];
+ }
+
+ for(var i = 0, ii = templates.length; i < ii; i++){
+ plugins[i] = templates[i];
+ }
+ plugins.length = ii;
+
+ // set the signature string that will be replaced at render time
+ var Sig = '_s' + Math.floor( Math.random() * 1000000 ) + '_',
+ // another signature to prepend to attributes and avoid checks: style, height, on[events]...
+ attPfx = '_a' + Math.floor( Math.random() * 1000000 ) + '_',
+ // rx to parse selectors, e.g. "+tr.foo[class]"
+ selRx = /^(\+)?([^\@\+]+)?\@?([^\+]+)?(\+)?$/,
+ // set automatically attributes for some tags
+ autoAttr = {
+ IMG:'src',
+ INPUT:'value'
+ },
+ // check if the argument is an array - thanks salty-horse (Ori Avtalion)
+ isArray = Array.isArray ?
+ function(o) {
+ return Array.isArray(o);
+ } :
+ function(o) {
+ return Object.prototype.toString.call(o) === "[object Array]";
+ };
+
+ return plugins;
+
+
+ /* * * * * * * * * * * * * * * * * * * * * * * * * *
+ core functions
+ * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+
+ // error utility
+ function error(e){
+ if(typeof console !== 'undefined'){
+ console.log(e);
+ }else{ alert(e); }
+ throw('pure error: ' + e);
+ }
+
+ //return a new instance of plugins
+ function getPlugins(){
+ var plugins = $p.plugins,
+ f = function(){};
+ f.prototype = plugins;
+
+ // do not overwrite functions if external definition
+ f.prototype.compile = plugins.compile || compile;
+ f.prototype.render = plugins.render || render;
+ f.prototype.autoRender = plugins.autoRender || autoRender;
+ f.prototype.find = plugins.find || find;
+
+ // give the compiler and the error handling to the plugin context
+ f.prototype._compiler = compiler;
+ f.prototype._error = error;
+
+ return new f();
+ }
+
+ // returns the outer HTML of a node
+ function outerHTML(node){
+ // if IE take the internal method otherwise build one
+ return node.outerHTML || (
+ function(n){
+ var div = document.createElement('div'), h;
+ div.appendChild( n.cloneNode(true) );
+ h = div.innerHTML;
+ div = null;
+ return h;
+ })(node);
+ }
+
+ // returns the string generator function
+ function wrapquote(qfn, f){
+ return function(ctxt){
+ return qfn('' + f.call(ctxt.context, ctxt));
+ };
+ }
+
+ // default find using querySelector when available on the browser
+ function find(n, sel){
+ if(typeof n === 'string'){
+ sel = n;
+ n = false;
+ }
+ if(typeof document.querySelectorAll !== 'undefined'){
+ return (n||document).querySelectorAll( sel );
+ }else{
+ error('You can test PURE standalone with: iPhone, FF3.5+, Safari4+ and IE8+\n\nTo run PURE on your browser, you need a JS library/framework with a CSS selector engine');
+ }
+ }
+
+ // create a function that concatenates constant string
+ // sections (given in parts) and the results of called
+ // functions to fill in the gaps between parts (fns).
+ // fns[n] fills in the gap between parts[n-1] and parts[n];
+ // fns[0] is unused.
+ // this is the inner template evaluation loop.
+ function concatenator(parts, fns){
+ return function(ctxt){
+ var strs = [ parts[ 0 ] ],
+ n = parts.length,
+ fnVal, pVal, attLine, pos;
+
+ for(var i = 1; i < n; i++){
+ fnVal = fns[i]( ctxt );
+ pVal = parts[i];
+
+ // if the value is empty and attribute, remove it
+ if(fnVal === ''){
+ attLine = strs[ strs.length - 1 ];
+ if( ( pos = attLine.search( /[\w]+=\"?$/ ) ) > -1){
+ strs[ strs.length - 1 ] = attLine.substring( 0, pos );
+ pVal = pVal.substr( 1 );
+ }
+ }
+
+ strs[ strs.length ] = fnVal;
+ strs[ strs.length ] = pVal;
+ }
+ return strs.join('');
+ };
+ }
+
+ // parse and check the loop directive
+ function parseloopspec(p){
+ var m = p.match( /^(\w+)\s*<-\s*(\S+)?$/ );
+ if(m === null){
+ error('bad loop spec: "' + p + '"');
+ }
+ if(m[1] === 'item'){
+ error('"item<-..." is a reserved word for the current running iteration.\n\nPlease choose another name for your loop.');
+ }
+ if( !m[2] || (m[2] && (/context/i).test(m[2]))){ //undefined or space(IE)
+ m[2] = function(ctxt){return ctxt.context;};
+ }
+ return {name: m[1], sel: m[2]};
+ }
+
+ // parse a data selector and return a function that
+ // can traverse the data accordingly, given a context.
+ function dataselectfn(sel){
+ if(typeof(sel) === 'function'){
+ return sel;
+ }
+ //check for a valid js variable name with hyphen(for properties only), $, _ and :
+ var m = sel.match(/^[a-zA-Z\$_\@][\w\$:-]*(\.[\w\$:-]*[^\.])*$/);
+ if(m === null){
+ var found = false, s = sel, parts = [], pfns = [], i = 0, retStr;
+ // check if literal
+ if(/\'|\"/.test( s.charAt(0) )){
+ if(/\'|\"/.test( s.charAt(s.length-1) )){
+ retStr = s.substring(1, s.length-1);
+ return function(){ return retStr; };
+ }
+ }else{
+ // check if literal + #{var}
+ while((m = s.match(/#\{([^{}]+)\}/)) !== null){
+ found = true;
+ parts[i++] = s.slice(0, m.index);
+ pfns[i] = dataselectfn(m[1]);
+ s = s.slice(m.index + m[0].length, s.length);
+ }
+ }
+ if(!found){
+ error('bad data selector syntax: ' + sel);
+ }
+ parts[i] = s;
+ return concatenator(parts, pfns);
+ }
+ m = sel.split('.');
+ return function(ctxt){
+ var data = ctxt.context;
+ if(!data){
+ return '';
+ }
+ var v = ctxt[m[0]],
+ i = 0;
+ if(v && v.item){
+ data = v.item;
+ i += 1;
+ }
+ var n = m.length;
+ for(; i < n; i++){
+ if(!data){break;}
+ data = data[m[i]];
+ }
+ return (!data && data !== 0) ? '':data;
+ };
+ }
+
+ // wrap in an object the target node/attr and their properties
+ function gettarget(dom, sel, isloop){
+ var osel, prepend, selector, attr, append, target = [];
+ if( typeof sel === 'string' ){
+ osel = sel;
+ var m = sel.match(selRx);
+ if( !m ){
+ error( 'bad selector syntax: ' + sel );
+ }
+
+ prepend = m[1];
+ selector = m[2];
+ attr = m[3];
+ append = m[4];
+
+ if(selector === '.' || ( !selector && attr ) ){
+ target[0] = dom;
+ }else{
+ target = plugins.find(dom, selector);
+ }
+ if(!target || target.length === 0){
+ return error('The node "' + sel + '" was not found in the template');
+ }
+ }else{
+ // autoRender node
+ prepend = sel.prepend;
+ attr = sel.attr;
+ append = sel.append;
+ target = [dom];
+ }
+
+ if( prepend || append ){
+ if( prepend && append ){
+ error('append/prepend cannot take place at the same time');
+ }else if( isloop ){
+ error('no append/prepend/replace modifiers allowed for loop target');
+ }else if( append && isloop ){
+ error('cannot append with loop (sel: ' + osel + ')');
+ }
+ }
+ var setstr, getstr, quotefn, isStyle, isClass, attName, setfn;
+ if(attr){
+ isStyle = (/^style$/i).test(attr);
+ isClass = (/^class$/i).test(attr);
+ attName = isClass ? 'className' : attr;
+ setstr = function(node, s) {
+ node.setAttribute(attPfx + attr, s);
+ if (attName in node && !isStyle) {
+ node[attName] = '';
+ }
+ if (node.nodeType === 1) {
+ node.removeAttribute(attr);
+ isClass && node.removeAttribute(attName);
+ }
+ };
+ if (isStyle || isClass) {//IE no quotes special care
+ if(isStyle){
+ getstr = function(n){ return n.style.cssText; };
+ }else{
+ getstr = function(n){ return n.className; };
+ }
+ quotefn = function(s){ return s.replace(/\"/g, '"'); };
+ }else {
+ getstr = function(n){ return n.getAttribute(attr); };
+ quotefn = function(s){ return s.replace(/\"/g, '"').replace(/\s/g, ' '); };
+ }
+ if(prepend){
+ setfn = function(node, s){ setstr( node, s + getstr( node )); };
+ }else if(append){
+ setfn = function(node, s){ setstr( node, getstr( node ) + s); };
+ }else{
+ setfn = function(node, s){ setstr( node, s ); };
+ }
+ }else{
+ if (isloop) {
+ setfn = function(node, s) {
+ var pn = node.parentNode;
+ if (pn) {
+ //replace node with s
+ pn.insertBefore(document.createTextNode(s), node.nextSibling);
+ pn.removeChild(node);
+ }
+ };
+ } else {
+ if (prepend) {
+ setfn = function(node, s) { node.insertBefore(document.createTextNode(s), node.firstChild); };
+ } else if (append) {
+ setfn = function(node, s) { node.appendChild(document.createTextNode(s));};
+ } else {
+ setfn = function(node, s) {
+ while (node.firstChild) { node.removeChild(node.firstChild); }
+ node.appendChild(document.createTextNode(s));
+ };
+ }
+ }
+ quotefn = function(s) { return s; };
+ }
+ return { attr: attr, nodes: target, set: setfn, sel: osel, quotefn: quotefn };
+ }
+
+ function setsig(target, n){
+ var sig = Sig + n + ':';
+ for(var i = 0; i < target.nodes.length; i++){
+ // could check for overlapping targets here.
+ target.set( target.nodes[i], sig );
+ }
+ }
+
+ // read de loop data, and pass it to the inner rendering function
+ function loopfn(name, dselect, inner, sorter, filter){
+ return function(ctxt){
+ var a = dselect(ctxt),
+ old = ctxt[name],
+ temp = { items : a },
+ filtered = 0,
+ length,
+ strs = [],
+ buildArg = function(idx, temp, ftr, len){
+ ctxt.pos = temp.pos = idx;
+ ctxt.item = temp.item = a[ idx ];
+ ctxt.items = a;
+ //if array, set a length property - filtered items
+ typeof len !== 'undefined' && (ctxt.length = len);
+ //if filter directive
+ if(typeof ftr === 'function' && ftr(ctxt) === false){
+ filtered++;
+ return;
+ }
+ strs.push( inner.call(temp, ctxt ) );
+ };
+ ctxt[name] = temp;
+ if( isArray(a) ){
+ length = a.length || 0;
+ // if sort directive
+ if(typeof sorter === 'function'){
+ a.sort(sorter);
+ }
+ //loop on array
+ for(var i = 0, ii = length; i < ii; i++){
+ buildArg(i, temp, filter, length - filtered);
+ }
+ }else{
+ if(a && typeof sorter !== 'undefined'){
+ error('sort is only available on arrays, not objects');
+ }
+ //loop on collections
+ for(var prop in a){
+ a.hasOwnProperty( prop ) && buildArg(prop, temp, filter);
+ }
+ }
+
+ typeof old !== 'undefined' ? ctxt[name] = old : delete ctxt[name];
+ return strs.join('');
+ };
+ }
+ // generate the template for a loop node
+ function loopgen(dom, sel, loop, fns){
+ var already = false, ls, sorter, filter, prop;
+ for(prop in loop){
+ if(loop.hasOwnProperty(prop)){
+ if(prop === 'sort'){
+ sorter = loop.sort;
+ continue;
+ }else if(prop === 'filter'){
+ filter = loop.filter;
+ continue;
+ }
+ if(already){
+ error('cannot have more than one loop on a target');
+ }
+ ls = prop;
+ already = true;
+ }
+ }
+ if(!ls){
+ error('Error in the selector: ' + sel + '\nA directive action must be a string, a function or a loop(<-)');
+ }
+ var dsel = loop[ls];
+ // if it's a simple data selector then we default to contents, not replacement.
+ if(typeof(dsel) === 'string' || typeof(dsel) === 'function'){
+ loop = {};
+ loop[ls] = {root: dsel};
+ return loopgen(dom, sel, loop, fns);
+ }
+ var spec = parseloopspec(ls),
+ itersel = dataselectfn(spec.sel),
+ target = gettarget(dom, sel, true),
+ nodes = target.nodes;
+
+ for(i = 0; i < nodes.length; i++){
+ var node = nodes[i],
+ inner = compiler(node, dsel);
+ fns[fns.length] = wrapquote(target.quotefn, loopfn(spec.name, itersel, inner, sorter, filter));
+ target.nodes = [node]; // N.B. side effect on target.
+ setsig(target, fns.length - 1);
+ }
+ }
+
+ function getAutoNodes(n, data){
+ var ns = n.getElementsByTagName('*'),
+ an = [],
+ openLoops = {a:[],l:{}},
+ cspec,
+ isNodeValue,
+ i, ii, j, jj, ni, cs, cj;
+ //for each node found in the template
+ for(i = -1, ii = ns.length; i < ii; i++){
+ ni = i > -1 ?ns[i]:n;
+ if(ni.nodeType === 1 && ni.className !== ''){
+ //when a className is found
+ cs = ni.className.split(' ');
+ // for each className
+ for(j = 0, jj=cs.length;j -1 || isNodeValue){
+ ni.className = ni.className.replace('@'+cspec.attr, '');
+ if(isNodeValue){
+ cspec.attr = false;
+ }
+ }
+ an.push({n:ni, cspec:cspec});
+ }
+ }
+ }
+ }
+ return an;
+
+ function checkClass(c, tagName){
+ // read the class
+ var ca = c.match(selRx),
+ attr = ca[3] || autoAttr[tagName],
+ cspec = {prepend:!!ca[1], prop:ca[2], attr:attr, append:!!ca[4], sel:c},
+ i, ii, loopi, loopil, val;
+ // check in existing open loops
+ for(i = openLoops.a.length-1; i >= 0; i--){
+ loopi = openLoops.a[i];
+ loopil = loopi.l[0];
+ val = loopil && loopil[cspec.prop];
+ if(typeof val !== 'undefined'){
+ cspec.prop = loopi.p + '.' + cspec.prop;
+ if(openLoops.l[cspec.prop] === true){
+ val = val[0];
+ }
+ break;
+ }
+ }
+ // not found check first level of data
+ if(typeof val === 'undefined'){
+ val = isArray(data) ? data[0][cspec.prop] : data[cspec.prop];
+ // nothing found return
+ if(typeof val === 'undefined'){
+ return false;
+ }
+ }
+ // set the spec for autoNode
+ if(isArray(val)){
+ openLoops.a.push( {l:val, p:cspec.prop} );
+ openLoops.l[cspec.prop] = true;
+ cspec.t = 'loop';
+ }else{
+ cspec.t = 'str';
+ }
+ return cspec;
+ }
+ }
+
+ // returns a function that, given a context argument,
+ // will render the template defined by dom and directive.
+ function compiler(dom, directive, data, ans){
+ var fns = [];
+ // autoRendering nodes parsing -> auto-nodes
+ ans = ans || data && getAutoNodes(dom, data);
+ if(data){
+ var j, jj, cspec, n, target, nodes, itersel, node, inner;
+ // for each auto-nodes
+ while(ans.length > 0){
+ cspec = ans[0].cspec;
+ n = ans[0].n;
+ ans.splice(0, 1);
+ if(cspec.t === 'str'){
+ // if the target is a value
+ target = gettarget(n, cspec, false);
+ setsig(target, fns.length);
+ fns[fns.length] = wrapquote(target.quotefn, dataselectfn(cspec.prop));
+ }else{
+ // if the target is a loop
+ itersel = dataselectfn(cspec.sel);
+ target = gettarget(n, cspec, true);
+ nodes = target.nodes;
+ for(j = 0, jj = nodes.length; j < jj; j++){
+ node = nodes[j];
+ inner = compiler(node, false, data, ans);
+ fns[fns.length] = wrapquote(target.quotefn, loopfn(cspec.sel, itersel, inner));
+ target.nodes = [node];
+ setsig(target, fns.length - 1);
+ }
+ }
+ }
+ }
+ // read directives
+ var target, dsel;
+ for(var sel in directive){
+ if(directive.hasOwnProperty(sel)){
+ dsel = directive[sel];
+ if(typeof(dsel) === 'function' || typeof(dsel) === 'string'){
+ // set the value for the node/attr
+ target = gettarget(dom, sel, false);
+ setsig(target, fns.length);
+ fns[fns.length] = wrapquote(target.quotefn, dataselectfn(dsel));
+ }else{
+ // loop on node
+ loopgen(dom, sel, dsel, fns);
+ }
+ }
+ }
+ // convert node to a string
+ var h = outerHTML(dom), pfns = [];
+ // IE adds an unremovable "selected, value" attribute
+ // hard replace while waiting for a better solution
+ h = h.replace(/<([^>]+)\s(value\=""|selected)\s?([^>]*)>/ig, "<$1 $3>");
+
+ // remove attribute prefix
+ h = h.split(attPfx).join('');
+
+ // slice the html string at "Sig"
+ var parts = h.split( Sig ), p;
+ // for each slice add the return string of
+ for(var i = 1; i < parts.length; i++){
+ p = parts[i];
+ // part is of the form "fn-number:..." as placed there by setsig.
+ pfns[i] = fns[ parseInt(p, 10) ];
+ parts[i] = p.substring( p.indexOf(':') + 1 );
+ }
+ return concatenator(parts, pfns);
+ }
+ // compile the template with directive
+ // if a context is passed, the autoRendering is triggered automatically
+ // return a function waiting the data as argument
+ function compile(directive, ctxt, template){
+ var rfn = compiler( ( template || this[0] ).cloneNode(true), directive, ctxt);
+ return function(context){
+ return rfn({context:context});
+ };
+ }
+ //compile with the directive as argument
+ // run the template function on the context argument
+ // return an HTML string
+ // should replace the template and return this
+ function render(ctxt, directive){
+ var fn = typeof directive === 'function' ? directive : plugins.compile( directive, false, this[0] );
+ for(var i = 0, ii = this.length; i < ii; i++){
+ this[i] = replaceWith( this[i], fn( ctxt, false ));
+ }
+ context = null;
+ return this;
+ }
+
+ // compile the template with autoRender
+ // run the template function on the context argument
+ // return an HTML string
+ function autoRender(ctxt, directive){
+ var fn = plugins.compile( directive, ctxt, this[0] );
+ for(var i = 0, ii = this.length; i < ii; i++){
+ this[i] = replaceWith( this[i], fn( ctxt, false));
+ }
+ context = null;
+ return this;
+ }
+
+ function replaceWith(elm, html) {
+ var ne,
+ ep = elm.parentNode,
+ depth = 0;
+ switch (elm.tagName) {
+ case 'TBODY': case 'THEAD': case 'TFOOT':
+ html = '' + html + '
';
+ depth = 1;
+ break;
+ case 'TR':
+ html = '' + html + '
';
+ depth = 2;
+ break;
+ case 'TD': case 'TH':
+ html = '
';
+ depth = 3;
+ break;
+ }
+ tmp = document.createElement('SPAN');
+ tmp.style.display = 'none';
+ document.body.appendChild(tmp);
+ tmp.innerHTML = html;
+ ne = tmp.firstChild;
+ while (depth--) {
+ ne = ne.firstChild;
+ }
+ ep.insertBefore(ne, elm);
+ ep.removeChild(elm);
+ document.body.removeChild(tmp);
+ elm = ne;
+
+ ne = ep = null;
+ return elm;
+ }
+};
+
+$p.plugins = {};
+
+$p.libs = {
+ dojo:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return dojo.query(sel, n);
+ };
+ }
+ },
+ domassistant:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return $(n).cssSelect(sel);
+ };
+ }
+ DOMAssistant.attach({
+ publicMethods : [ 'compile', 'render', 'autoRender'],
+ compile:function(directive, ctxt){ return $p(this).compile(directive, ctxt); },
+ render:function(ctxt, directive){ return $( $p(this).render(ctxt, directive) )[0]; },
+ autoRender:function(ctxt, directive){ return $( $p(this).autoRender(ctxt, directive) )[0]; }
+ });
+ },
+ jquery:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return jQuery(n).find(sel);
+ };
+ }
+ jQuery.fn.extend({
+ compile:function(directive, ctxt){ return $p(this[0]).compile(directive, ctxt); },
+ render:function(ctxt, directive){ return jQuery( $p( this[0] ).render( ctxt, directive ) ); },
+ autoRender:function(ctxt, directive){ return jQuery( $p( this[0] ).autoRender( ctxt, directive ) ); }
+ });
+ },
+ mootools:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return $(n).getElements(sel);
+ };
+ }
+ Element.implement({
+ compile:function(directive, ctxt){ return $p(this).compile(directive, ctxt); },
+ render:function(ctxt, directive){ return $p(this).render(ctxt, directive); },
+ autoRender:function(ctxt, directive){ return $p(this).autoRender(ctxt, directive); }
+ });
+ },
+ prototype:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ n = n === document ? n.body : n;
+ return typeof n === 'string' ? $$(n) : $(n).select(sel);
+ };
+ }
+ Element.addMethods({
+ compile:function(element, directive, ctxt){ return $p(element).compile(directive, ctxt); },
+ render:function(element, ctxt, directive){ return $p(element).render(ctxt, directive); },
+ autoRender:function(element, ctxt, directive){ return $p(element).autoRender(ctxt, directive); }
+ });
+ },
+ sizzle:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return Sizzle(sel, n);
+ };
+ }
+ },
+ sly:function(){
+ if(typeof document.querySelector === 'undefined'){
+ $p.plugins.find = function(n, sel){
+ return Sly(sel, n);
+ };
+ }
+ }
+};
+
+// get lib specifics if available
+(function(){
+ var libkey =
+ typeof dojo !== 'undefined' && 'dojo' ||
+ typeof DOMAssistant !== 'undefined' && 'domassistant' ||
+ typeof jQuery !== 'undefined' && 'jquery' ||
+ typeof MooTools !== 'undefined' && 'mootools' ||
+ typeof Prototype !== 'undefined' && 'prototype' ||
+ typeof Sizzle !== 'undefined' && 'sizzle' ||
+ typeof Sly !== 'undefined' && 'sly';
+
+ libkey && $p.libs[libkey]();
+})();
+
+
+ Sammy = Sammy || {};
+
+ // `Sammy.Pure` is a simple wrapper around the pure.js templating engine for
+ // use in Sammy apps.
+ //
+ // See http://beebole.com/pure/ for detailed documentation.
+ Sammy.Pure = function(app, method_alias) {
+
+ var pure = function(template, data, directives) {
+ return $(template).autoRender(data, directives);
+ };
+
+ // set the default method name/extension
+ if (!method_alias) method_alias = 'pure';
+ app.helper(method_alias, pure);
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.storage.js b/public/javascripts/plugins/sammy.storage.js
new file mode 100644
index 0000000..ad3cb86
--- /dev/null
+++ b/public/javascripts/plugins/sammy.storage.js
@@ -0,0 +1,577 @@
+(function($) {
+
+ Sammy = Sammy || {};
+
+ // Sammy.Store is an abstract adapter class that wraps the multitude of in
+ // browser data storage into a single common set of methods for storing and
+ // retreiving data. The JSON library is used (through the inclusion of the
+ // Sammy.JSON) plugin, to automatically convert objects back and forth from
+ // stored strings.
+ //
+ // Sammy.Store can be used directly, but within a Sammy.Application it is much
+ // easier to use the `Sammy.Storage` plugin and its helper methods.
+ //
+ // Sammy.Store also supports the KVO pattern, by firing DOM/jQuery Events when
+ // a key is set.
+ //
+ // ### Example
+ //
+ // // create a new store named 'mystore', tied to the #main element, using HTML5 localStorage
+ // // Note: localStorage only works on browsers that support it
+ // var store = new Sammy.Store({name: 'mystore', element: '#element', type: 'local'});
+ // store.set('foo', 'bar');
+ // store.get('foo'); //=> 'bar'
+ // store.set('json', {obj: 'this is an obj'});
+ // store.get('json'); //=> {obj: 'this is an obj'}
+ // store.keys(); //=> ['foo','json']
+ // store.clear('foo');
+ // store.keys(); //=> ['json']
+ // store.clearAll();
+ // store.keys(); //=> []
+ //
+ // ### Arguments
+ //
+ // The constructor takes a single argument which is a Object containing these possible options.
+ //
+ // * `name` The name/namespace of this store. Stores are unique by name/type. (default 'store')
+ // * `element` A selector for the element that the store is bound to. (default 'body')
+ // * `type` The type of storage/proxy to use (default 'memory')
+ //
+ // Extra options are passed to the storage constructor.
+ // Sammy.Store supports the following methods of storage:
+ //
+ // * `memory` Basic object storage
+ // * `data` jQuery.data DOM Storage
+ // * `cookie` Access to document.cookie. Limited to 2K
+ // * `local` HTML5 DOM localStorage, browswer support is currently limited.
+ // * `session` HTML5 DOM sessionStorage, browswer support is currently limited.
+ //
+ Sammy.Store = function(options) {
+ var store = this;
+ this.options = options || {};
+ this.name = this.options.name || 'store';
+ this.element = this.options.element || 'body';
+ this.$element = $(this.element);
+ if ($.isArray(this.options.type)) {
+ $.each(this.options.type, function(i, type) {
+ if (Sammy.Store.isAvailable(type)) {
+ store.type = type;
+ return false;
+ }
+ });
+ } else {
+ this.type = this.options.type || 'memory';
+ }
+ this.meta_key = this.options.meta_key || '__keys__';
+ this.storage = new Sammy.Store[Sammy.Store.stores[this.type]](this.name, this.element, this.options);
+ };
+
+ Sammy.Store.stores = {
+ 'memory': 'Memory',
+ 'data': 'Data',
+ 'local': 'LocalStorage',
+ 'session': 'SessionStorage',
+ 'cookie': 'Cookie'
+ };
+
+ $.extend(Sammy.Store.prototype, {
+ // Checks for the availability of the current storage type in the current browser/config.
+ isAvailable: function() {
+ if ($.isFunction(this.storage.isAvailable)) {
+ return this.storage.isAvailable();
+ } else {
+ true;
+ }
+ },
+ // Checks for the existance of `key` in the current store. Returns a boolean.
+ exists: function(key) {
+ return this.storage.exists(key);
+ },
+ // Sets the value of `key` with `value`. If `value` is an
+ // object, it is turned to and stored as a string with `JSON.stringify`.
+ // It also tries to conform to the KVO pattern triggering jQuery events on the
+ // element that the store is bound to.
+ //
+ // ### Example
+ //
+ // var store = new Sammy.Store({name: 'kvo'});
+ // $('body').bind('set-kvo-foo', function(e, data) {
+ // Sammy.log(data.key + ' changed to ' + data.value);
+ // });
+ // store.set('foo', 'bar'); // logged: foo changed to bar
+ //
+ set: function(key, value) {
+ var string_value = (typeof value == 'string') ? value : JSON.stringify(value);
+ key = key.toString();
+ this.storage.set(key, string_value);
+ if (key != this.meta_key) {
+ this._addKey(key);
+ this.$element.trigger('set-' + this.name, {key: key, value: value});
+ this.$element.trigger('set-' + this.name + '-' + key, {key: key, value: value});
+ };
+ // always return the original value
+ return value;
+ },
+ // Returns the set value at `key`, parsing with `JSON.parse` and
+ // turning into an object if possible
+ get: function(key) {
+ var value = this.storage.get(key);
+ if (typeof value == 'undefined' || value == null || value == '') {
+ return value;
+ }
+ try {
+ return JSON.parse(value);
+ } catch(e) {
+ return value;
+ }
+ },
+ // Removes the value at `key` from the current store
+ clear: function(key) {
+ this._removeKey(key);
+ return this.storage.clear(key);
+ },
+ // Clears all the values for the current store.
+ clearAll: function() {
+ var self = this;
+ this.each(function(key, value) {
+ self.clear(key);
+ });
+ },
+ // Returns the all the keys set for the current store as an array.
+ // Internally Sammy.Store keeps this array in a 'meta_key' for easy access.
+ keys: function() {
+ return this.get(this.meta_key) || [];
+ },
+ // Iterates over each key value pair passing them to the `callback` function
+ //
+ // ### Example
+ //
+ // store.each(function(key, value) {
+ // Sammy.log('key', key, 'value', value);
+ // });
+ //
+ each: function(callback) {
+ var i = 0,
+ keys = this.keys(),
+ returned;
+
+ for (i; i < keys.length; i++) {
+ returned = callback(keys[i], this.get(keys[i]));
+ if (returned === false) { return false; }
+ };
+ },
+ // Filters the store by a filter function that takes a key value.
+ // Returns an array of arrays where the first element of each array
+ // is the key and the second is the value of that key.
+ //
+ // ### Example
+ //
+ // var store = new Sammy.Store;
+ // store.set('one', 'two');
+ // store.set('two', 'three');
+ // store.set('1', 'two');
+ // var returned = store.filter(function(key, value) {
+ // // only return
+ // return value === 'two';
+ // });
+ // // returned => [['one', 'two'], ['1', 'two']];
+ //
+ filter: function(callback) {
+ var found = [];
+ this.each(function(key, value) {
+ if (callback(key, value)) {
+ found.push([key, value]);
+ }
+ return true;
+ });
+ return found;
+ },
+ // Works exactly like filter except only returns the first matching key
+ // value pair instead of all of them
+ first: function(callback) {
+ var found = false;
+ this.each(function(key, value) {
+ if (callback(key, value)) {
+ found = [key, value];
+ return false;
+ }
+ });
+ return found;
+ },
+ // Returns the value at `key` if set, otherwise, runs the callback
+ // and sets the value to the value returned in the callback.
+ //
+ // ### Example
+ //
+ // var store = new Sammy.Store;
+ // store.exists('foo'); //=> false
+ // store.fetch('foo', function() {
+ // return 'bar!';
+ // }); //=> 'bar!'
+ // store.get('foo') //=> 'bar!'
+ // store.fetch('foo', function() {
+ // return 'baz!';
+ // }); //=> 'bar!
+ //
+ fetch: function(key, callback) {
+ if (!this.exists(key)) {
+ return this.set(key, callback.apply(this));
+ } else {
+ return this.get(key);
+ }
+ },
+ // loads the response of a request to `path` into `key`.
+ //
+ // ### Example
+ //
+ // In /mytemplate.tpl:
+ //
+ // My Template
+ //
+ // In app.js:
+ //
+ // var store = new Sammy.Store;
+ // store.load('mytemplate', '/mytemplate.tpl', function() {
+ // s.get('mytemplate') //=> My Template
+ // });
+ //
+ load: function(key, path, callback) {
+ var s = this;
+ $.get(path, function(response) {
+ s.set(key, response);
+ if (callback) { callback.apply(this, [response]); }
+ });
+ },
+
+ _addKey: function(key) {
+ var keys = this.keys();
+ if ($.inArray(key, keys) == -1) { keys.push(key); }
+ this.set(this.meta_key, keys);
+ },
+ _removeKey: function(key) {
+ var keys = this.keys();
+ var index = $.inArray(key, keys);
+ if (index != -1) { keys.splice(index, 1); }
+ this.set(this.meta_key, keys);
+ }
+ });
+
+ // Tests if the type of storage is available/works in the current browser/config.
+ // Especially useful for testing the availability of the awesome, but not widely
+ // supported HTML5 DOM storage
+ Sammy.Store.isAvailable = function(type) {
+ try {
+ return Sammy.Store[Sammy.Store.stores[type]].prototype.isAvailable();
+ } catch(e) {
+ return false;
+ }
+ };
+
+ // Memory ('memory') is the basic/default store. It stores data in a global
+ // JS object. Data is lost on refresh.
+ Sammy.Store.Memory = function(name, element) {
+ this.name = name;
+ this.element = element;
+ this.namespace = [this.element, this.name].join('.');
+ Sammy.Store.Memory.store = Sammy.Store.Memory.store || {};
+ Sammy.Store.Memory.store[this.namespace] = Sammy.Store.Memory.store[this.namespace] || {};
+ this.store = Sammy.Store.Memory.store[this.namespace];
+ };
+ $.extend(Sammy.Store.Memory.prototype, {
+ isAvailable: function() { return true; },
+ exists: function(key) {
+ return (typeof this.store[key] != "undefined");
+ },
+ set: function(key, value) {
+ return this.store[key] = value;
+ },
+ get: function(key) {
+ return this.store[key];
+ },
+ clear: function(key) {
+ delete this.store[key];
+ }
+ });
+
+ // Data ('data') stores objects using the jQuery.data() methods. This has the advantadge
+ // of scoping the data to the specific element. Like the 'memory' store its data
+ // will only last for the length of the current request (data is lost on refresh/etc).
+ Sammy.Store.Data = function(name, element) {
+ this.name = name;
+ this.element = element;
+ this.$element = $(element);
+ };
+ $.extend(Sammy.Store.Data.prototype, {
+ isAvailable: function() { return true; },
+ exists: function(key) {
+ return !!this.$element.data(this._key(key));
+ },
+ set: function(key, value) {
+ return this.$element.data(this._key(key), value);
+ },
+ get: function(key) {
+ return this.$element.data(this._key(key));
+ },
+ clear: function(key) {
+ this.$element.removeData(this._key(key));
+ },
+ _key: function(key) {
+ return ['store', this.name, key].join('.');
+ }
+ });
+
+ // LocalStorage ('local') makes use of HTML5 DOM Storage, and the window.localStorage
+ // object. The great advantage of this method is that data will persist beyond
+ // the current request. It can be considered a pretty awesome replacement for
+ // cookies accessed via JS. The great disadvantage, though, is its only available
+ // on the latest and greatest browsers.
+ //
+ // For more info on DOM Storage:
+ // https://developer.mozilla.org/en/DOM/Storage
+ // http://www.w3.org/TR/2009/WD-webstorage-20091222/
+ //
+ Sammy.Store.LocalStorage = function(name, element) {
+ this.name = name;
+ this.element = element;
+ };
+ $.extend(Sammy.Store.LocalStorage.prototype, {
+ isAvailable: function() {
+ return ('localStorage' in window) && (window.location.protocol != 'file:');
+ },
+ exists: function(key) {
+ return (this.get(key) != null);
+ },
+ set: function(key, value) {
+ return window.localStorage.setItem(this._key(key), value);
+ },
+ get: function(key) {
+ return window.localStorage.getItem(this._key(key));
+ },
+ clear: function(key) {
+ window.localStorage.removeItem(this._key(key));;
+ },
+ _key: function(key) {
+ return ['store', this.element, this.name, key].join('.');
+ }
+ });
+
+ // .SessionStorage ('session') is similar to LocalStorage (part of the same API)
+ // and shares similar browser support/availability. The difference is that
+ // SessionStorage is only persistant through the current 'session' which is defined
+ // as the length that the current window is open. This means that data will survive
+ // refreshes but not close/open or multiple windows/tabs. For more info, check out
+ // the `LocalStorage` documentation and links.
+ Sammy.Store.SessionStorage = function(name, element) {
+ this.name = name;
+ this.element = element;
+ };
+ $.extend(Sammy.Store.SessionStorage.prototype, {
+ isAvailable: function() {
+ return ('sessionStorage' in window) &&
+ (window.location.protocol != 'file:') &&
+ ($.isFunction(window.sessionStorage.setItem));
+ },
+ exists: function(key) {
+ return (this.get(key) != null);
+ },
+ set: function(key, value) {
+ return window.sessionStorage.setItem(this._key(key), value);
+ },
+ get: function(key) {
+ var value = window.sessionStorage.getItem(this._key(key));
+ if (value && typeof value.value != "undefined") { value = value.value }
+ return value;
+ },
+ clear: function(key) {
+ window.sessionStorage.removeItem(this._key(key));;
+ },
+ _key: function(key) {
+ return ['store', this.element, this.name, key].join('.');
+ }
+ });
+
+ // .Cookie ('cookie') storage uses browser cookies to store data. JavaScript
+ // has access to a single document.cookie variable, which is limited to 2Kb in
+ // size. Cookies are also considered 'unsecure' as the data can be read easily
+ // by other sites/JS. Cookies do have the advantage, though, of being widely
+ // supported and persistent through refresh and close/open. Where available,
+ // HTML5 DOM Storage like LocalStorage and SessionStorage should be used.
+ //
+ // .Cookie can also take additional options:
+ //
+ // * `expires_in` Number of seconds to keep the cookie alive (default 2 weeks).
+ // * `path` The path to activate the current cookie for (default '/').
+ //
+ // For more information about document.cookie, check out the pre-eminint article
+ // by ppk: http://www.quirksmode.org/js/cookies.html
+ //
+ Sammy.Store.Cookie = function(name, element, options) {
+ this.name = name;
+ this.element = element;
+ this.options = options || {};
+ this.path = this.options.path || '/';
+ // set the expires in seconds or default 14 days
+ this.expires_in = this.options.expires_in || (14 * 24 * 60 * 60);
+ };
+ $.extend(Sammy.Store.Cookie.prototype, {
+ isAvailable: function() {
+ return ('cookie' in document) && (window.location.protocol != 'file:');
+ },
+ exists: function(key) {
+ return (this.get(key) != null);
+ },
+ set: function(key, value) {
+ return this._setCookie(key, value);
+ },
+ get: function(key) {
+ return this._getCookie(key);
+ },
+ clear: function(key) {
+ this._setCookie(key, "", -1);
+ },
+ _key: function(key) {
+ return ['store', this.element, this.name, key].join('.');
+ },
+ _getCookie: function(key) {
+ var escaped = this._key(key).replace(/(\.|\*|\(|\)|\[|\])/g, '\\$1');
+ var match = document.cookie.match("(^|;\\s)" + escaped + "=([^;]*)(;|$)")
+ return (match ? match[2] : null);
+ },
+ _setCookie: function(key, value, expires) {
+ if (!expires) { expires = (this.expires_in * 1000) }
+ var date = new Date();
+ date.setTime(date.getTime() + expires);
+ var set_cookie = [
+ this._key(key), "=", value,
+ "; expires=", date.toGMTString(),
+ "; path=", this.path
+ ].join('');
+ document.cookie = set_cookie;
+ }
+ });
+
+ // Sammy.Storage is a plugin that provides shortcuts for creating and using
+ // Sammy.Store objects. Once included it provides the `store()` app level
+ // and helper methods. Depends on Sammy.JSON (or json2.js).
+ Sammy.Storage = function(app) {
+ this.use(Sammy.JSON);
+
+ this.stores = this.stores || {};
+
+ // `store()` creates and looks up existing `Sammy.Store` objects
+ // for the current application. The first time used for a given `'name'`
+ // initializes a `Sammy.Store` and also creates a helper under the store's
+ // name.
+ //
+ // ### Example
+ //
+ // var app = $.sammy(function() {
+ // this.use(Sammy.Storage);
+ //
+ // // initializes the store on app creation.
+ // this.store('mystore', {type: 'cookie'});
+ //
+ // this.get('#/', function() {
+ // // returns the Sammy.Store object
+ // this.store('mystore');
+ // // sets 'foo' to 'bar' using the shortcut/helper
+ // // equivilent to this.store('mystore').set('foo', 'bar');
+ // this.mystore('foo', 'bar');
+ // // returns 'bar'
+ // // equivilent to this.store('mystore').get('foo');
+ // this.mystore('foo');
+ // // returns 'baz!'
+ // // equivilent to:
+ // // this.store('mystore').fetch('foo!', function() {
+ // // return 'baz!';
+ // // })
+ // this.mystore('foo!', function() {
+ // return 'baz!';
+ // });
+ //
+ // this.clearMystore();
+ // // equivilent to:
+ // // this.store('mystore').clearAll()
+ // });
+ //
+ // });
+ //
+ // ### Arguments
+ //
+ // * `name` The name of the store and helper. the name must be unique per application.
+ // * `options` A JS object of options that can be passed to the Store constuctor on initialization.
+ //
+ this.store = function(name, options) {
+ // if the store has not been initialized
+ if (typeof this.stores[name] == 'undefined') {
+ // create initialize the store
+ var clear_method_name = "clear" + name.substr(0,1).toUpperCase() + name.substr(1);
+ this.stores[name] = new Sammy.Store($.extend({
+ name: name,
+ element: this.element_selector
+ }, options || {}));
+ // app.name()
+ this[name] = function(key, value) {
+ if (typeof value == 'undefined') {
+ return this.stores[name].get(key);
+ } else if ($.isFunction(value)) {
+ return this.stores[name].fetch(key, value);
+ } else {
+ return this.stores[name].set(key, value)
+ }
+ };
+ // app.clearName();
+ this[clear_method_name] = function() {
+ return this.stores[name].clearAll();
+ }
+ // context.name()
+ this.helper(name, function() {
+ return this.app[name].apply(this.app, arguments);
+ });
+ // context.clearName();
+ this.helper(clear_method_name, function() {
+ return this.app[clear_method_name]();
+ });
+ }
+ return this.stores[name];
+ };
+
+ this.helpers({
+ store: function() {
+ return this.app.store.apply(this.app, arguments);
+ }
+ });
+ };
+
+ // Sammy.Session is an additional plugin for creating a common 'session' store
+ // for the given app. It is a very simple wrapper around `Sammy.Storage`
+ // that provides a simple fallback mechanism for trying to provide the best
+ // possible storage type for the session. This means, `LocalStorage`
+ // if available, otherwise `Cookie`, otherwise `Memory`.
+ // It provides the `session()` helper through `Sammy.Storage#store()`.
+ //
+ // See the `Sammy.Storage` plugin for full documentation.
+ //
+ Sammy.Session = function(app, options) {
+ this.use(Sammy.Storage);
+ // check for local storage, then cookie storage, then just use memory
+ this.store('session', $.extend({type: ['local', 'cookie', 'memory']}, options));
+ };
+
+ // Sammy.Cache provides helpers for caching data within the lifecycle of a
+ // Sammy app. The plugin provides two main methods on `Sammy.Application`,
+ // `cache` and `clearCache`. Each app has its own cache store so that
+ // you dont have to worry about collisions. As of 0.5 the original Sammy.Cache module
+ // has been deprecated in favor of this one based on Sammy.Storage. The exposed
+ // API is almost identical, but Sammy.Storage provides additional backends including
+ // HTML5 Storage. `Sammy.Cache` will try to use these backends when available
+ // (in this order) `LocalStorage`, `SessionStorage`, and `Memory`
+ Sammy.Cache = function(app, options) {
+ this.use(Sammy.Storage);
+ // set cache_partials to true
+ this.cache_partials = true;
+ // check for local storage, then session storage, then just use memory
+ this.store('cache', $.extend({type: ['local', 'session', 'memory']}, options));
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.template.js b/public/javascripts/plugins/sammy.template.js
new file mode 100644
index 0000000..2ce315f
--- /dev/null
+++ b/public/javascripts/plugins/sammy.template.js
@@ -0,0 +1,141 @@
+(function($) {
+
+ // Simple JavaScript Templating
+ // John Resig - http://ejohn.org/ - MIT Licensed
+ // adapted from: http://ejohn.org/blog/javascript-micro-templating/
+ // originally $.srender by Greg Borenstein http://ideasfordozens.com in Feb 2009
+ // modified for Sammy by Aaron Quint for caching templates by name
+ var srender_cache = {};
+ var srender = function(name, template, data, options) {
+ var fn, escaped_string;
+ // target is an optional element; if provided, the result will be inserted into it
+ // otherwise the result will simply be returned to the caller
+ if (srender_cache[name]) {
+ fn = srender_cache[name];
+ } else {
+ if (typeof template == 'undefined') {
+ // was a cache check, return false
+ return false;
+ }
+ // If options escape_html is false, dont escape the contents by default
+ if (options && options.escape_html === false) {
+ escaped_string = "\",$1,\"";
+ } else {
+ escaped_string = "\",h($1),\"";
+ }
+ // Generate a reusable function that will serve as a template
+ // generator (and which will be cached).
+ fn = srender_cache[name] = new Function("obj",
+ "var ___$$$___=[],print=function(){___$$$___.push.apply(___$$$___,arguments);};" +
+
+ // Introduce the data as local variables using with(){}
+ "with(obj){___$$$___.push(\"" +
+
+ // Convert the template into pure JavaScript
+ String(template)
+ .replace(/[\r\t\n]/g, " ")
+ .replace(/\"/g, '\\"')
+ .split("<%").join("\t")
+ .replace(/((^|%>)[^\t]*)/g, "$1\r")
+ .replace(/\t=(.*?)%>/g, escaped_string)
+ .replace(/\t!(.*?)%>/g, "\",$1,\"")
+ .split("\t").join("\");")
+ .split("%>").join("___$$$___.push(\"")
+ .split("\r").join("")
+ + "\");}return ___$$$___.join('');");
+ }
+
+ if (typeof data != 'undefined') {
+ return fn(data);
+ } else {
+ return fn;
+ }
+ };
+
+ Sammy = Sammy || {};
+
+ // `Sammy.Template` is a simple plugin that provides a way to create
+ // and render client side templates. The rendering code is based on John Resig's
+ // quick templates and Greg Borenstien's srender plugin.
+ // This is also a great template/boilerplate for Sammy plugins.
+ //
+ // Templates use `<% %>` tags to denote embedded javascript.
+ //
+ // ### Examples
+ //
+ // Here is an example template (user.template):
+ //
+ // // user.template
+ // ]*>([\\S\\s]*?)<\/script>',
- JSONFilter: /^\/\*-secure-([\s\S]*)\*\/\s*$/,
-
- emptyFunction: function() { },
-
- K: function(x) { return x }
-};
-
-if (Prototype.Browser.MobileSafari)
- Prototype.BrowserFeatures.SpecificElementExtensions = false;
-
-
-var Abstract = { };
-
-
-var Try = {
- these: function() {
- var returnValue;
-
- for (var i = 0, length = arguments.length; i < length; i++) {
- var lambda = arguments[i];
- try {
- returnValue = lambda();
- break;
- } catch (e) { }
- }
-
- return returnValue;
- }
-};
-
-/* Based on Alex Arnell's inheritance implementation. */
-
-var Class = (function() {
-
- var IS_DONTENUM_BUGGY = (function(){
- for (var p in { toString: 1 }) {
- if (p === 'toString') return false;
- }
- return true;
- })();
-
- function subclass() {};
- function create() {
- var parent = null, properties = $A(arguments);
- if (Object.isFunction(properties[0]))
- parent = properties.shift();
-
- function klass() {
- this.initialize.apply(this, arguments);
- }
-
- Object.extend(klass, Class.Methods);
- klass.superclass = parent;
- klass.subclasses = [];
-
- if (parent) {
- subclass.prototype = parent.prototype;
- klass.prototype = new subclass;
- parent.subclasses.push(klass);
- }
-
- for (var i = 0, length = properties.length; i < length; i++)
- klass.addMethods(properties[i]);
-
- if (!klass.prototype.initialize)
- klass.prototype.initialize = Prototype.emptyFunction;
-
- klass.prototype.constructor = klass;
- return klass;
- }
-
- function addMethods(source) {
- var ancestor = this.superclass && this.superclass.prototype,
- properties = Object.keys(source);
-
- if (IS_DONTENUM_BUGGY) {
- if (source.toString != Object.prototype.toString)
- properties.push("toString");
- if (source.valueOf != Object.prototype.valueOf)
- properties.push("valueOf");
- }
-
- for (var i = 0, length = properties.length; i < length; i++) {
- var property = properties[i], value = source[property];
- if (ancestor && Object.isFunction(value) &&
- value.argumentNames()[0] == "$super") {
- var method = value;
- value = (function(m) {
- return function() { return ancestor[m].apply(this, arguments); };
- })(property).wrap(method);
-
- value.valueOf = method.valueOf.bind(method);
- value.toString = method.toString.bind(method);
- }
- this.prototype[property] = value;
- }
-
- return this;
- }
-
- return {
- create: create,
- Methods: {
- addMethods: addMethods
- }
- };
-})();
-(function() {
-
- var _toString = Object.prototype.toString,
- NULL_TYPE = 'Null',
- UNDEFINED_TYPE = 'Undefined',
- BOOLEAN_TYPE = 'Boolean',
- NUMBER_TYPE = 'Number',
- STRING_TYPE = 'String',
- OBJECT_TYPE = 'Object',
- BOOLEAN_CLASS = '[object Boolean]',
- NUMBER_CLASS = '[object Number]',
- STRING_CLASS = '[object String]',
- ARRAY_CLASS = '[object Array]',
- NATIVE_JSON_STRINGIFY_SUPPORT = window.JSON &&
- typeof JSON.stringify === 'function' &&
- JSON.stringify(0) === '0' &&
- typeof JSON.stringify(Prototype.K) === 'undefined';
-
- function Type(o) {
- switch(o) {
- case null: return NULL_TYPE;
- case (void 0): return UNDEFINED_TYPE;
- }
- var type = typeof o;
- switch(type) {
- case 'boolean': return BOOLEAN_TYPE;
- case 'number': return NUMBER_TYPE;
- case 'string': return STRING_TYPE;
- }
- return OBJECT_TYPE;
- }
-
- function extend(destination, source) {
- for (var property in source)
- destination[property] = source[property];
- return destination;
- }
-
- function inspect(object) {
- try {
- if (isUndefined(object)) return 'undefined';
- if (object === null) return 'null';
- return object.inspect ? object.inspect() : String(object);
- } catch (e) {
- if (e instanceof RangeError) return '...';
- throw e;
- }
- }
-
- function toJSON(value) {
- return Str('', { '': value }, []);
- }
-
- function Str(key, holder, stack) {
- var value = holder[key],
- type = typeof value;
-
- if (Type(value) === OBJECT_TYPE && typeof value.toJSON === 'function') {
- value = value.toJSON(key);
- }
-
- var _class = _toString.call(value);
-
- switch (_class) {
- case NUMBER_CLASS:
- case BOOLEAN_CLASS:
- case STRING_CLASS:
- value = value.valueOf();
- }
-
- switch (value) {
- case null: return 'null';
- case true: return 'true';
- case false: return 'false';
- }
-
- type = typeof value;
- switch (type) {
- case 'string':
- return value.inspect(true);
- case 'number':
- return isFinite(value) ? String(value) : 'null';
- case 'object':
-
- for (var i = 0, length = stack.length; i < length; i++) {
- if (stack[i] === value) { throw new TypeError(); }
- }
- stack.push(value);
-
- var partial = [];
- if (_class === ARRAY_CLASS) {
- for (var i = 0, length = value.length; i < length; i++) {
- var str = Str(i, value, stack);
- partial.push(typeof str === 'undefined' ? 'null' : str);
- }
- partial = '[' + partial.join(',') + ']';
- } else {
- var keys = Object.keys(value);
- for (var i = 0, length = keys.length; i < length; i++) {
- var key = keys[i], str = Str(key, value, stack);
- if (typeof str !== "undefined") {
- partial.push(key.inspect(true)+ ':' + str);
- }
- }
- partial = '{' + partial.join(',') + '}';
- }
- stack.pop();
- return partial;
- }
- }
-
- function stringify(object) {
- return JSON.stringify(object);
- }
-
- function toQueryString(object) {
- return $H(object).toQueryString();
- }
-
- function toHTML(object) {
- return object && object.toHTML ? object.toHTML() : String.interpret(object);
- }
-
- function keys(object) {
- if (Type(object) !== OBJECT_TYPE) { throw new TypeError(); }
- var results = [];
- for (var property in object) {
- if (object.hasOwnProperty(property)) {
- results.push(property);
- }
- }
- return results;
- }
-
- function values(object) {
- var results = [];
- for (var property in object)
- results.push(object[property]);
- return results;
- }
-
- function clone(object) {
- return extend({ }, object);
- }
-
- function isElement(object) {
- return !!(object && object.nodeType == 1);
- }
-
- function isArray(object) {
- return _toString.call(object) === ARRAY_CLASS;
- }
-
- var hasNativeIsArray = (typeof Array.isArray == 'function')
- && Array.isArray([]) && !Array.isArray({});
-
- if (hasNativeIsArray) {
- isArray = Array.isArray;
- }
-
- function isHash(object) {
- return object instanceof Hash;
- }
-
- function isFunction(object) {
- return typeof object === "function";
- }
-
- function isString(object) {
- return _toString.call(object) === STRING_CLASS;
- }
-
- function isNumber(object) {
- return _toString.call(object) === NUMBER_CLASS;
- }
-
- function isUndefined(object) {
- return typeof object === "undefined";
- }
-
- extend(Object, {
- extend: extend,
- inspect: inspect,
- toJSON: NATIVE_JSON_STRINGIFY_SUPPORT ? stringify : toJSON,
- toQueryString: toQueryString,
- toHTML: toHTML,
- keys: Object.keys || keys,
- values: values,
- clone: clone,
- isElement: isElement,
- isArray: isArray,
- isHash: isHash,
- isFunction: isFunction,
- isString: isString,
- isNumber: isNumber,
- isUndefined: isUndefined
- });
-})();
-Object.extend(Function.prototype, (function() {
- var slice = Array.prototype.slice;
-
- function update(array, args) {
- var arrayLength = array.length, length = args.length;
- while (length--) array[arrayLength + length] = args[length];
- return array;
- }
-
- function merge(array, args) {
- array = slice.call(array, 0);
- return update(array, args);
- }
-
- function argumentNames() {
- var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
- .replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
- .replace(/\s+/g, '').split(',');
- return names.length == 1 && !names[0] ? [] : names;
- }
-
- function bind(context) {
- if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
- var __method = this, args = slice.call(arguments, 1);
- return function() {
- var a = merge(args, arguments);
- return __method.apply(context, a);
- }
- }
-
- function bindAsEventListener(context) {
- var __method = this, args = slice.call(arguments, 1);
- return function(event) {
- var a = update([event || window.event], args);
- return __method.apply(context, a);
- }
- }
-
- function curry() {
- if (!arguments.length) return this;
- var __method = this, args = slice.call(arguments, 0);
- return function() {
- var a = merge(args, arguments);
- return __method.apply(this, a);
- }
- }
-
- function delay(timeout) {
- var __method = this, args = slice.call(arguments, 1);
- timeout = timeout * 1000;
- return window.setTimeout(function() {
- return __method.apply(__method, args);
- }, timeout);
- }
-
- function defer() {
- var args = update([0.01], arguments);
- return this.delay.apply(this, args);
- }
-
- function wrap(wrapper) {
- var __method = this;
- return function() {
- var a = update([__method.bind(this)], arguments);
- return wrapper.apply(this, a);
- }
- }
-
- function methodize() {
- if (this._methodized) return this._methodized;
- var __method = this;
- return this._methodized = function() {
- var a = update([this], arguments);
- return __method.apply(null, a);
- };
- }
-
- return {
- argumentNames: argumentNames,
- bind: bind,
- bindAsEventListener: bindAsEventListener,
- curry: curry,
- delay: delay,
- defer: defer,
- wrap: wrap,
- methodize: methodize
- }
-})());
-
-
-
-(function(proto) {
-
-
- function toISOString() {
- return this.getUTCFullYear() + '-' +
- (this.getUTCMonth() + 1).toPaddedString(2) + '-' +
- this.getUTCDate().toPaddedString(2) + 'T' +
- this.getUTCHours().toPaddedString(2) + ':' +
- this.getUTCMinutes().toPaddedString(2) + ':' +
- this.getUTCSeconds().toPaddedString(2) + 'Z';
- }
-
-
- function toJSON() {
- return this.toISOString();
- }
-
- if (!proto.toISOString) proto.toISOString = toISOString;
- if (!proto.toJSON) proto.toJSON = toJSON;
-
-})(Date.prototype);
-
-
-RegExp.prototype.match = RegExp.prototype.test;
-
-RegExp.escape = function(str) {
- return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
-};
-var PeriodicalExecuter = Class.create({
- initialize: function(callback, frequency) {
- this.callback = callback;
- this.frequency = frequency;
- this.currentlyExecuting = false;
-
- this.registerCallback();
- },
-
- registerCallback: function() {
- this.timer = setInterval(this.onTimerEvent.bind(this), this.frequency * 1000);
- },
-
- execute: function() {
- this.callback(this);
- },
-
- stop: function() {
- if (!this.timer) return;
- clearInterval(this.timer);
- this.timer = null;
- },
-
- onTimerEvent: function() {
- if (!this.currentlyExecuting) {
- try {
- this.currentlyExecuting = true;
- this.execute();
- this.currentlyExecuting = false;
- } catch(e) {
- this.currentlyExecuting = false;
- throw e;
- }
- }
- }
-});
-Object.extend(String, {
- interpret: function(value) {
- return value == null ? '' : String(value);
- },
- specialChar: {
- '\b': '\\b',
- '\t': '\\t',
- '\n': '\\n',
- '\f': '\\f',
- '\r': '\\r',
- '\\': '\\\\'
- }
-});
-
-Object.extend(String.prototype, (function() {
- var NATIVE_JSON_PARSE_SUPPORT = window.JSON &&
- typeof JSON.parse === 'function' &&
- JSON.parse('{"test": true}').test;
-
- function prepareReplacement(replacement) {
- if (Object.isFunction(replacement)) return replacement;
- var template = new Template(replacement);
- return function(match) { return template.evaluate(match) };
- }
-
- function gsub(pattern, replacement) {
- var result = '', source = this, match;
- replacement = prepareReplacement(replacement);
-
- if (Object.isString(pattern))
- pattern = RegExp.escape(pattern);
-
- if (!(pattern.length || pattern.source)) {
- replacement = replacement('');
- return replacement + source.split('').join(replacement) + replacement;
- }
-
- while (source.length > 0) {
- if (match = source.match(pattern)) {
- result += source.slice(0, match.index);
- result += String.interpret(replacement(match));
- source = source.slice(match.index + match[0].length);
- } else {
- result += source, source = '';
- }
- }
- return result;
- }
-
- function sub(pattern, replacement, count) {
- replacement = prepareReplacement(replacement);
- count = Object.isUndefined(count) ? 1 : count;
-
- return this.gsub(pattern, function(match) {
- if (--count < 0) return match[0];
- return replacement(match);
- });
- }
-
- function scan(pattern, iterator) {
- this.gsub(pattern, iterator);
- return String(this);
- }
-
- function truncate(length, truncation) {
- length = length || 30;
- truncation = Object.isUndefined(truncation) ? '...' : truncation;
- return this.length > length ?
- this.slice(0, length - truncation.length) + truncation : String(this);
- }
-
- function strip() {
- return this.replace(/^\s+/, '').replace(/\s+$/, '');
- }
-
- function stripTags() {
- return this.replace(/<\w+(\s+("[^"]*"|'[^']*'|[^>])+)?>|<\/\w+>/gi, '');
- }
-
- function stripScripts() {
- return this.replace(new RegExp(Prototype.ScriptFragment, 'img'), '');
- }
-
- function extractScripts() {
- var matchAll = new RegExp(Prototype.ScriptFragment, 'img'),
- matchOne = new RegExp(Prototype.ScriptFragment, 'im');
- return (this.match(matchAll) || []).map(function(scriptTag) {
- return (scriptTag.match(matchOne) || ['', ''])[1];
- });
- }
-
- function evalScripts() {
- return this.extractScripts().map(function(script) { return eval(script) });
- }
-
- function escapeHTML() {
- return this.replace(/&/g,'&').replace(//g,'>');
- }
-
- function unescapeHTML() {
- return this.stripTags().replace(/</g,'<').replace(/>/g,'>').replace(/&/g,'&');
- }
-
-
- function toQueryParams(separator) {
- var match = this.strip().match(/([^?#]*)(#.*)?$/);
- if (!match) return { };
-
- return match[1].split(separator || '&').inject({ }, function(hash, pair) {
- if ((pair = pair.split('='))[0]) {
- var key = decodeURIComponent(pair.shift()),
- value = pair.length > 1 ? pair.join('=') : pair[0];
-
- if (value != undefined) value = decodeURIComponent(value);
-
- if (key in hash) {
- if (!Object.isArray(hash[key])) hash[key] = [hash[key]];
- hash[key].push(value);
- }
- else hash[key] = value;
- }
- return hash;
- });
- }
-
- function toArray() {
- return this.split('');
- }
-
- function succ() {
- return this.slice(0, this.length - 1) +
- String.fromCharCode(this.charCodeAt(this.length - 1) + 1);
- }
-
- function times(count) {
- return count < 1 ? '' : new Array(count + 1).join(this);
- }
-
- function camelize() {
- return this.replace(/-+(.)?/g, function(match, chr) {
- return chr ? chr.toUpperCase() : '';
- });
- }
-
- function capitalize() {
- return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();
- }
-
- function underscore() {
- return this.replace(/::/g, '/')
- .replace(/([A-Z]+)([A-Z][a-z])/g, '$1_$2')
- .replace(/([a-z\d])([A-Z])/g, '$1_$2')
- .replace(/-/g, '_')
- .toLowerCase();
- }
-
- function dasherize() {
- return this.replace(/_/g, '-');
- }
-
- function inspect(useDoubleQuotes) {
- var escapedString = this.replace(/[\x00-\x1f\\]/g, function(character) {
- if (character in String.specialChar) {
- return String.specialChar[character];
- }
- return '\\u00' + character.charCodeAt().toPaddedString(2, 16);
- });
- if (useDoubleQuotes) return '"' + escapedString.replace(/"/g, '\\"') + '"';
- return "'" + escapedString.replace(/'/g, '\\\'') + "'";
- }
-
- function unfilterJSON(filter) {
- return this.replace(filter || Prototype.JSONFilter, '$1');
- }
-
- function isJSON() {
- var str = this;
- if (str.blank()) return false;
- str = str.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@');
- str = str.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']');
- str = str.replace(/(?:^|:|,)(?:\s*\[)+/g, '');
- return (/^[\],:{}\s]*$/).test(str);
- }
-
- function evalJSON(sanitize) {
- var json = this.unfilterJSON(),
- cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
- if (cx.test(json)) {
- json = json.replace(cx, function (a) {
- return '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
- });
- }
- try {
- if (!sanitize || json.isJSON()) return eval('(' + json + ')');
- } catch (e) { }
- throw new SyntaxError('Badly formed JSON string: ' + this.inspect());
- }
-
- function parseJSON() {
- var json = this.unfilterJSON();
- return JSON.parse(json);
- }
-
- function include(pattern) {
- return this.indexOf(pattern) > -1;
- }
-
- function startsWith(pattern) {
- return this.lastIndexOf(pattern, 0) === 0;
- }
-
- function endsWith(pattern) {
- var d = this.length - pattern.length;
- return d >= 0 && this.indexOf(pattern, d) === d;
- }
-
- function empty() {
- return this == '';
- }
-
- function blank() {
- return /^\s*$/.test(this);
- }
-
- function interpolate(object, pattern) {
- return new Template(this, pattern).evaluate(object);
- }
-
- return {
- gsub: gsub,
- sub: sub,
- scan: scan,
- truncate: truncate,
- strip: String.prototype.trim || strip,
- stripTags: stripTags,
- stripScripts: stripScripts,
- extractScripts: extractScripts,
- evalScripts: evalScripts,
- escapeHTML: escapeHTML,
- unescapeHTML: unescapeHTML,
- toQueryParams: toQueryParams,
- parseQuery: toQueryParams,
- toArray: toArray,
- succ: succ,
- times: times,
- camelize: camelize,
- capitalize: capitalize,
- underscore: underscore,
- dasherize: dasherize,
- inspect: inspect,
- unfilterJSON: unfilterJSON,
- isJSON: isJSON,
- evalJSON: NATIVE_JSON_PARSE_SUPPORT ? parseJSON : evalJSON,
- include: include,
- startsWith: startsWith,
- endsWith: endsWith,
- empty: empty,
- blank: blank,
- interpolate: interpolate
- };
-})());
-
-var Template = Class.create({
- initialize: function(template, pattern) {
- this.template = template.toString();
- this.pattern = pattern || Template.Pattern;
- },
-
- evaluate: function(object) {
- if (object && Object.isFunction(object.toTemplateReplacements))
- object = object.toTemplateReplacements();
-
- return this.template.gsub(this.pattern, function(match) {
- if (object == null) return (match[1] + '');
-
- var before = match[1] || '';
- if (before == '\\') return match[2];
-
- var ctx = object, expr = match[3],
- pattern = /^([^.[]+|\[((?:.*?[^\\])?)\])(\.|\[|$)/;
-
- match = pattern.exec(expr);
- if (match == null) return before;
-
- while (match != null) {
- var comp = match[1].startsWith('[') ? match[2].replace(/\\\\]/g, ']') : match[1];
- ctx = ctx[comp];
- if (null == ctx || '' == match[3]) break;
- expr = expr.substring('[' == match[3] ? match[1].length : match[0].length);
- match = pattern.exec(expr);
- }
-
- return before + String.interpret(ctx);
- });
- }
-});
-Template.Pattern = /(^|.|\r|\n)(#\{(.*?)\})/;
-
-var $break = { };
-
-var Enumerable = (function() {
- function each(iterator, context) {
- var index = 0;
- try {
- this._each(function(value) {
- iterator.call(context, value, index++);
- });
- } catch (e) {
- if (e != $break) throw e;
- }
- return this;
- }
-
- function eachSlice(number, iterator, context) {
- var index = -number, slices = [], array = this.toArray();
- if (number < 1) return array;
- while ((index += number) < array.length)
- slices.push(array.slice(index, index+number));
- return slices.collect(iterator, context);
- }
-
- function all(iterator, context) {
- iterator = iterator || Prototype.K;
- var result = true;
- this.each(function(value, index) {
- result = result && !!iterator.call(context, value, index);
- if (!result) throw $break;
- });
- return result;
- }
-
- function any(iterator, context) {
- iterator = iterator || Prototype.K;
- var result = false;
- this.each(function(value, index) {
- if (result = !!iterator.call(context, value, index))
- throw $break;
- });
- return result;
- }
-
- function collect(iterator, context) {
- iterator = iterator || Prototype.K;
- var results = [];
- this.each(function(value, index) {
- results.push(iterator.call(context, value, index));
- });
- return results;
- }
-
- function detect(iterator, context) {
- var result;
- this.each(function(value, index) {
- if (iterator.call(context, value, index)) {
- result = value;
- throw $break;
- }
- });
- return result;
- }
-
- function findAll(iterator, context) {
- var results = [];
- this.each(function(value, index) {
- if (iterator.call(context, value, index))
- results.push(value);
- });
- return results;
- }
-
- function grep(filter, iterator, context) {
- iterator = iterator || Prototype.K;
- var results = [];
-
- if (Object.isString(filter))
- filter = new RegExp(RegExp.escape(filter));
-
- this.each(function(value, index) {
- if (filter.match(value))
- results.push(iterator.call(context, value, index));
- });
- return results;
- }
-
- function include(object) {
- if (Object.isFunction(this.indexOf))
- if (this.indexOf(object) != -1) return true;
-
- var found = false;
- this.each(function(value) {
- if (value == object) {
- found = true;
- throw $break;
- }
- });
- return found;
- }
-
- function inGroupsOf(number, fillWith) {
- fillWith = Object.isUndefined(fillWith) ? null : fillWith;
- return this.eachSlice(number, function(slice) {
- while(slice.length < number) slice.push(fillWith);
- return slice;
- });
- }
-
- function inject(memo, iterator, context) {
- this.each(function(value, index) {
- memo = iterator.call(context, memo, value, index);
- });
- return memo;
- }
-
- function invoke(method) {
- var args = $A(arguments).slice(1);
- return this.map(function(value) {
- return value[method].apply(value, args);
- });
- }
-
- function max(iterator, context) {
- iterator = iterator || Prototype.K;
- var result;
- this.each(function(value, index) {
- value = iterator.call(context, value, index);
- if (result == null || value >= result)
- result = value;
- });
- return result;
- }
-
- function min(iterator, context) {
- iterator = iterator || Prototype.K;
- var result;
- this.each(function(value, index) {
- value = iterator.call(context, value, index);
- if (result == null || value < result)
- result = value;
- });
- return result;
- }
-
- function partition(iterator, context) {
- iterator = iterator || Prototype.K;
- var trues = [], falses = [];
- this.each(function(value, index) {
- (iterator.call(context, value, index) ?
- trues : falses).push(value);
- });
- return [trues, falses];
- }
-
- function pluck(property) {
- var results = [];
- this.each(function(value) {
- results.push(value[property]);
- });
- return results;
- }
-
- function reject(iterator, context) {
- var results = [];
- this.each(function(value, index) {
- if (!iterator.call(context, value, index))
- results.push(value);
- });
- return results;
- }
-
- function sortBy(iterator, context) {
- return this.map(function(value, index) {
- return {
- value: value,
- criteria: iterator.call(context, value, index)
- };
- }).sort(function(left, right) {
- var a = left.criteria, b = right.criteria;
- return a < b ? -1 : a > b ? 1 : 0;
- }).pluck('value');
- }
-
- function toArray() {
- return this.map();
- }
-
- function zip() {
- var iterator = Prototype.K, args = $A(arguments);
- if (Object.isFunction(args.last()))
- iterator = args.pop();
-
- var collections = [this].concat(args).map($A);
- return this.map(function(value, index) {
- return iterator(collections.pluck(index));
- });
- }
-
- function size() {
- return this.toArray().length;
- }
-
- function inspect() {
- return '#';
- }
-
-
-
-
-
-
-
-
-
- return {
- each: each,
- eachSlice: eachSlice,
- all: all,
- every: all,
- any: any,
- some: any,
- collect: collect,
- map: collect,
- detect: detect,
- findAll: findAll,
- select: findAll,
- filter: findAll,
- grep: grep,
- include: include,
- member: include,
- inGroupsOf: inGroupsOf,
- inject: inject,
- invoke: invoke,
- max: max,
- min: min,
- partition: partition,
- pluck: pluck,
- reject: reject,
- sortBy: sortBy,
- toArray: toArray,
- entries: toArray,
- zip: zip,
- size: size,
- inspect: inspect,
- find: detect
- };
-})();
-
-function $A(iterable) {
- if (!iterable) return [];
- if ('toArray' in Object(iterable)) return iterable.toArray();
- var length = iterable.length || 0, results = new Array(length);
- while (length--) results[length] = iterable[length];
- return results;
-}
-
-
-function $w(string) {
- if (!Object.isString(string)) return [];
- string = string.strip();
- return string ? string.split(/\s+/) : [];
-}
-
-Array.from = $A;
-
-
-(function() {
- var arrayProto = Array.prototype,
- slice = arrayProto.slice,
- _each = arrayProto.forEach; // use native browser JS 1.6 implementation if available
-
- function each(iterator) {
- for (var i = 0, length = this.length; i < length; i++)
- iterator(this[i]);
- }
- if (!_each) _each = each;
-
- function clear() {
- this.length = 0;
- return this;
- }
-
- function first() {
- return this[0];
- }
-
- function last() {
- return this[this.length - 1];
- }
-
- function compact() {
- return this.select(function(value) {
- return value != null;
- });
- }
-
- function flatten() {
- return this.inject([], function(array, value) {
- if (Object.isArray(value))
- return array.concat(value.flatten());
- array.push(value);
- return array;
- });
- }
-
- function without() {
- var values = slice.call(arguments, 0);
- return this.select(function(value) {
- return !values.include(value);
- });
- }
-
- function reverse(inline) {
- return (inline === false ? this.toArray() : this)._reverse();
- }
-
- function uniq(sorted) {
- return this.inject([], function(array, value, index) {
- if (0 == index || (sorted ? array.last() != value : !array.include(value)))
- array.push(value);
- return array;
- });
- }
-
- function intersect(array) {
- return this.uniq().findAll(function(item) {
- return array.detect(function(value) { return item === value });
- });
- }
-
-
- function clone() {
- return slice.call(this, 0);
- }
-
- function size() {
- return this.length;
- }
-
- function inspect() {
- return '[' + this.map(Object.inspect).join(', ') + ']';
- }
-
- function indexOf(item, i) {
- i || (i = 0);
- var length = this.length;
- if (i < 0) i = length + i;
- for (; i < length; i++)
- if (this[i] === item) return i;
- return -1;
- }
-
- function lastIndexOf(item, i) {
- i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
- var n = this.slice(0, i).reverse().indexOf(item);
- return (n < 0) ? n : i - n - 1;
- }
-
- function concat() {
- var array = slice.call(this, 0), item;
- for (var i = 0, length = arguments.length; i < length; i++) {
- item = arguments[i];
- if (Object.isArray(item) && !('callee' in item)) {
- for (var j = 0, arrayLength = item.length; j < arrayLength; j++)
- array.push(item[j]);
- } else {
- array.push(item);
- }
- }
- return array;
- }
-
- Object.extend(arrayProto, Enumerable);
-
- if (!arrayProto._reverse)
- arrayProto._reverse = arrayProto.reverse;
-
- Object.extend(arrayProto, {
- _each: _each,
- clear: clear,
- first: first,
- last: last,
- compact: compact,
- flatten: flatten,
- without: without,
- reverse: reverse,
- uniq: uniq,
- intersect: intersect,
- clone: clone,
- toArray: clone,
- size: size,
- inspect: inspect
- });
-
- var CONCAT_ARGUMENTS_BUGGY = (function() {
- return [].concat(arguments)[0][0] !== 1;
- })(1,2)
-
- if (CONCAT_ARGUMENTS_BUGGY) arrayProto.concat = concat;
-
- if (!arrayProto.indexOf) arrayProto.indexOf = indexOf;
- if (!arrayProto.lastIndexOf) arrayProto.lastIndexOf = lastIndexOf;
-})();
-function $H(object) {
- return new Hash(object);
-};
-
-var Hash = Class.create(Enumerable, (function() {
- function initialize(object) {
- this._object = Object.isHash(object) ? object.toObject() : Object.clone(object);
- }
-
-
- function _each(iterator) {
- for (var key in this._object) {
- var value = this._object[key], pair = [key, value];
- pair.key = key;
- pair.value = value;
- iterator(pair);
- }
- }
-
- function set(key, value) {
- return this._object[key] = value;
- }
-
- function get(key) {
- if (this._object[key] !== Object.prototype[key])
- return this._object[key];
- }
-
- function unset(key) {
- var value = this._object[key];
- delete this._object[key];
- return value;
- }
-
- function toObject() {
- return Object.clone(this._object);
- }
-
-
-
- function keys() {
- return this.pluck('key');
- }
-
- function values() {
- return this.pluck('value');
- }
-
- function index(value) {
- var match = this.detect(function(pair) {
- return pair.value === value;
- });
- return match && match.key;
- }
-
- function merge(object) {
- return this.clone().update(object);
- }
-
- function update(object) {
- return new Hash(object).inject(this, function(result, pair) {
- result.set(pair.key, pair.value);
- return result;
- });
- }
-
- function toQueryPair(key, value) {
- if (Object.isUndefined(value)) return key;
- return key + '=' + encodeURIComponent(String.interpret(value));
- }
-
- function toQueryString() {
- return this.inject([], function(results, pair) {
- var key = encodeURIComponent(pair.key), values = pair.value;
-
- if (values && typeof values == 'object') {
- if (Object.isArray(values))
- return results.concat(values.map(toQueryPair.curry(key)));
- } else results.push(toQueryPair(key, values));
- return results;
- }).join('&');
- }
-
- function inspect() {
- return '#';
- }
-
- function clone() {
- return new Hash(this);
- }
-
- return {
- initialize: initialize,
- _each: _each,
- set: set,
- get: get,
- unset: unset,
- toObject: toObject,
- toTemplateReplacements: toObject,
- keys: keys,
- values: values,
- index: index,
- merge: merge,
- update: update,
- toQueryString: toQueryString,
- inspect: inspect,
- toJSON: toObject,
- clone: clone
- };
-})());
-
-Hash.from = $H;
-Object.extend(Number.prototype, (function() {
- function toColorPart() {
- return this.toPaddedString(2, 16);
- }
-
- function succ() {
- return this + 1;
- }
-
- function times(iterator, context) {
- $R(0, this, true).each(iterator, context);
- return this;
- }
-
- function toPaddedString(length, radix) {
- var string = this.toString(radix || 10);
- return '0'.times(length - string.length) + string;
- }
-
- function abs() {
- return Math.abs(this);
- }
-
- function round() {
- return Math.round(this);
- }
-
- function ceil() {
- return Math.ceil(this);
- }
-
- function floor() {
- return Math.floor(this);
- }
-
- return {
- toColorPart: toColorPart,
- succ: succ,
- times: times,
- toPaddedString: toPaddedString,
- abs: abs,
- round: round,
- ceil: ceil,
- floor: floor
- };
-})());
-
-function $R(start, end, exclusive) {
- return new ObjectRange(start, end, exclusive);
-}
-
-var ObjectRange = Class.create(Enumerable, (function() {
- function initialize(start, end, exclusive) {
- this.start = start;
- this.end = end;
- this.exclusive = exclusive;
- }
-
- function _each(iterator) {
- var value = this.start;
- while (this.include(value)) {
- iterator(value);
- value = value.succ();
- }
- }
-
- function include(value) {
- if (value < this.start)
- return false;
- if (this.exclusive)
- return value < this.end;
- return value <= this.end;
- }
-
- return {
- initialize: initialize,
- _each: _each,
- include: include
- };
-})());
-
-
-
-var Ajax = {
- getTransport: function() {
- return Try.these(
- function() {return new XMLHttpRequest()},
- function() {return new ActiveXObject('Msxml2.XMLHTTP')},
- function() {return new ActiveXObject('Microsoft.XMLHTTP')}
- ) || false;
- },
-
- activeRequestCount: 0
-};
-
-Ajax.Responders = {
- responders: [],
-
- _each: function(iterator) {
- this.responders._each(iterator);
- },
-
- register: function(responder) {
- if (!this.include(responder))
- this.responders.push(responder);
- },
-
- unregister: function(responder) {
- this.responders = this.responders.without(responder);
- },
-
- dispatch: function(callback, request, transport, json) {
- this.each(function(responder) {
- if (Object.isFunction(responder[callback])) {
- try {
- responder[callback].apply(responder, [request, transport, json]);
- } catch (e) { }
- }
- });
- }
-};
-
-Object.extend(Ajax.Responders, Enumerable);
-
-Ajax.Responders.register({
- onCreate: function() { Ajax.activeRequestCount++ },
- onComplete: function() { Ajax.activeRequestCount-- }
-});
-Ajax.Base = Class.create({
- initialize: function(options) {
- this.options = {
- method: 'post',
- asynchronous: true,
- contentType: 'application/x-www-form-urlencoded',
- encoding: 'UTF-8',
- parameters: '',
- evalJSON: true,
- evalJS: true
- };
- Object.extend(this.options, options || { });
-
- this.options.method = this.options.method.toLowerCase();
-
- if (Object.isString(this.options.parameters))
- this.options.parameters = this.options.parameters.toQueryParams();
- else if (Object.isHash(this.options.parameters))
- this.options.parameters = this.options.parameters.toObject();
- }
-});
-Ajax.Request = Class.create(Ajax.Base, {
- _complete: false,
-
- initialize: function($super, url, options) {
- $super(options);
- this.transport = Ajax.getTransport();
- this.request(url);
- },
-
- request: function(url) {
- this.url = url;
- this.method = this.options.method;
- var params = Object.clone(this.options.parameters);
-
- if (!['get', 'post'].include(this.method)) {
- params['_method'] = this.method;
- this.method = 'post';
- }
-
- this.parameters = params;
-
- if (params = Object.toQueryString(params)) {
- if (this.method == 'get')
- this.url += (this.url.include('?') ? '&' : '?') + params;
- else if (/Konqueror|Safari|KHTML/.test(navigator.userAgent))
- params += '&_=';
- }
-
- try {
- var response = new Ajax.Response(this);
- if (this.options.onCreate) this.options.onCreate(response);
- Ajax.Responders.dispatch('onCreate', this, response);
-
- this.transport.open(this.method.toUpperCase(), this.url,
- this.options.asynchronous);
-
- if (this.options.asynchronous) this.respondToReadyState.bind(this).defer(1);
-
- this.transport.onreadystatechange = this.onStateChange.bind(this);
- this.setRequestHeaders();
-
- this.body = this.method == 'post' ? (this.options.postBody || params) : null;
- this.transport.send(this.body);
-
- /* Force Firefox to handle ready state 4 for synchronous requests */
- if (!this.options.asynchronous && this.transport.overrideMimeType)
- this.onStateChange();
-
- }
- catch (e) {
- this.dispatchException(e);
- }
- },
-
- onStateChange: function() {
- var readyState = this.transport.readyState;
- if (readyState > 1 && !((readyState == 4) && this._complete))
- this.respondToReadyState(this.transport.readyState);
- },
-
- setRequestHeaders: function() {
- var headers = {
- 'X-Requested-With': 'XMLHttpRequest',
- 'X-Prototype-Version': Prototype.Version,
- 'Accept': 'text/javascript, text/html, application/xml, text/xml, */*'
- };
-
- if (this.method == 'post') {
- headers['Content-type'] = this.options.contentType +
- (this.options.encoding ? '; charset=' + this.options.encoding : '');
-
- /* Force "Connection: close" for older Mozilla browsers to work
- * around a bug where XMLHttpRequest sends an incorrect
- * Content-length header. See Mozilla Bugzilla #246651.
- */
- if (this.transport.overrideMimeType &&
- (navigator.userAgent.match(/Gecko\/(\d{4})/) || [0,2005])[1] < 2005)
- headers['Connection'] = 'close';
- }
-
- if (typeof this.options.requestHeaders == 'object') {
- var extras = this.options.requestHeaders;
-
- if (Object.isFunction(extras.push))
- for (var i = 0, length = extras.length; i < length; i += 2)
- headers[extras[i]] = extras[i+1];
- else
- $H(extras).each(function(pair) { headers[pair.key] = pair.value });
- }
-
- for (var name in headers)
- this.transport.setRequestHeader(name, headers[name]);
- },
-
- success: function() {
- var status = this.getStatus();
- return !status || (status >= 200 && status < 300);
- },
-
- getStatus: function() {
- try {
- return this.transport.status || 0;
- } catch (e) { return 0 }
- },
-
- respondToReadyState: function(readyState) {
- var state = Ajax.Request.Events[readyState], response = new Ajax.Response(this);
-
- if (state == 'Complete') {
- try {
- this._complete = true;
- (this.options['on' + response.status]
- || this.options['on' + (this.success() ? 'Success' : 'Failure')]
- || Prototype.emptyFunction)(response, response.headerJSON);
- } catch (e) {
- this.dispatchException(e);
- }
-
- var contentType = response.getHeader('Content-type');
- if (this.options.evalJS == 'force'
- || (this.options.evalJS && this.isSameOrigin() && contentType
- && contentType.match(/^\s*(text|application)\/(x-)?(java|ecma)script(;.*)?\s*$/i)))
- this.evalResponse();
- }
-
- try {
- (this.options['on' + state] || Prototype.emptyFunction)(response, response.headerJSON);
- Ajax.Responders.dispatch('on' + state, this, response, response.headerJSON);
- } catch (e) {
- this.dispatchException(e);
- }
-
- if (state == 'Complete') {
- this.transport.onreadystatechange = Prototype.emptyFunction;
- }
- },
-
- isSameOrigin: function() {
- var m = this.url.match(/^\s*https?:\/\/[^\/]*/);
- return !m || (m[0] == '#{protocol}//#{domain}#{port}'.interpolate({
- protocol: location.protocol,
- domain: document.domain,
- port: location.port ? ':' + location.port : ''
- }));
- },
-
- getHeader: function(name) {
- try {
- return this.transport.getResponseHeader(name) || null;
- } catch (e) { return null; }
- },
-
- evalResponse: function() {
- try {
- return eval((this.transport.responseText || '').unfilterJSON());
- } catch (e) {
- this.dispatchException(e);
- }
- },
-
- dispatchException: function(exception) {
- (this.options.onException || Prototype.emptyFunction)(this, exception);
- Ajax.Responders.dispatch('onException', this, exception);
- }
-});
-
-Ajax.Request.Events =
- ['Uninitialized', 'Loading', 'Loaded', 'Interactive', 'Complete'];
-
-
-
-
-
-
-
-
-Ajax.Response = Class.create({
- initialize: function(request){
- this.request = request;
- var transport = this.transport = request.transport,
- readyState = this.readyState = transport.readyState;
-
- if ((readyState > 2 && !Prototype.Browser.IE) || readyState == 4) {
- this.status = this.getStatus();
- this.statusText = this.getStatusText();
- this.responseText = String.interpret(transport.responseText);
- this.headerJSON = this._getHeaderJSON();
- }
-
- if (readyState == 4) {
- var xml = transport.responseXML;
- this.responseXML = Object.isUndefined(xml) ? null : xml;
- this.responseJSON = this._getResponseJSON();
- }
- },
-
- status: 0,
-
- statusText: '',
-
- getStatus: Ajax.Request.prototype.getStatus,
-
- getStatusText: function() {
- try {
- return this.transport.statusText || '';
- } catch (e) { return '' }
- },
-
- getHeader: Ajax.Request.prototype.getHeader,
-
- getAllHeaders: function() {
- try {
- return this.getAllResponseHeaders();
- } catch (e) { return null }
- },
-
- getResponseHeader: function(name) {
- return this.transport.getResponseHeader(name);
- },
-
- getAllResponseHeaders: function() {
- return this.transport.getAllResponseHeaders();
- },
-
- _getHeaderJSON: function() {
- var json = this.getHeader('X-JSON');
- if (!json) return null;
- json = decodeURIComponent(escape(json));
- try {
- return json.evalJSON(this.request.options.sanitizeJSON ||
- !this.request.isSameOrigin());
- } catch (e) {
- this.request.dispatchException(e);
- }
- },
-
- _getResponseJSON: function() {
- var options = this.request.options;
- if (!options.evalJSON || (options.evalJSON != 'force' &&
- !(this.getHeader('Content-type') || '').include('application/json')) ||
- this.responseText.blank())
- return null;
- try {
- return this.responseText.evalJSON(options.sanitizeJSON ||
- !this.request.isSameOrigin());
- } catch (e) {
- this.request.dispatchException(e);
- }
- }
-});
-
-Ajax.Updater = Class.create(Ajax.Request, {
- initialize: function($super, container, url, options) {
- this.container = {
- success: (container.success || container),
- failure: (container.failure || (container.success ? null : container))
- };
-
- options = Object.clone(options);
- var onComplete = options.onComplete;
- options.onComplete = (function(response, json) {
- this.updateContent(response.responseText);
- if (Object.isFunction(onComplete)) onComplete(response, json);
- }).bind(this);
-
- $super(url, options);
- },
-
- updateContent: function(responseText) {
- var receiver = this.container[this.success() ? 'success' : 'failure'],
- options = this.options;
-
- if (!options.evalScripts) responseText = responseText.stripScripts();
-
- if (receiver = $(receiver)) {
- if (options.insertion) {
- if (Object.isString(options.insertion)) {
- var insertion = { }; insertion[options.insertion] = responseText;
- receiver.insert(insertion);
- }
- else options.insertion(receiver, responseText);
- }
- else receiver.update(responseText);
- }
- }
-});
-
-Ajax.PeriodicalUpdater = Class.create(Ajax.Base, {
- initialize: function($super, container, url, options) {
- $super(options);
- this.onComplete = this.options.onComplete;
-
- this.frequency = (this.options.frequency || 2);
- this.decay = (this.options.decay || 1);
-
- this.updater = { };
- this.container = container;
- this.url = url;
-
- this.start();
- },
-
- start: function() {
- this.options.onComplete = this.updateComplete.bind(this);
- this.onTimerEvent();
- },
-
- stop: function() {
- this.updater.options.onComplete = undefined;
- clearTimeout(this.timer);
- (this.onComplete || Prototype.emptyFunction).apply(this, arguments);
- },
-
- updateComplete: function(response) {
- if (this.options.decay) {
- this.decay = (response.responseText == this.lastText ?
- this.decay * this.options.decay : 1);
-
- this.lastText = response.responseText;
- }
- this.timer = this.onTimerEvent.bind(this).delay(this.decay * this.frequency);
- },
-
- onTimerEvent: function() {
- this.updater = new Ajax.Updater(this.container, this.url, this.options);
- }
-});
-
-
-function $(element) {
- if (arguments.length > 1) {
- for (var i = 0, elements = [], length = arguments.length; i < length; i++)
- elements.push($(arguments[i]));
- return elements;
- }
- if (Object.isString(element))
- element = document.getElementById(element);
- return Element.extend(element);
-}
-
-if (Prototype.BrowserFeatures.XPath) {
- document._getElementsByXPath = function(expression, parentElement) {
- var results = [];
- var query = document.evaluate(expression, $(parentElement) || document,
- null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
- for (var i = 0, length = query.snapshotLength; i < length; i++)
- results.push(Element.extend(query.snapshotItem(i)));
- return results;
- };
-}
-
-/*--------------------------------------------------------------------------*/
-
-if (!Node) var Node = { };
-
-if (!Node.ELEMENT_NODE) {
- Object.extend(Node, {
- ELEMENT_NODE: 1,
- ATTRIBUTE_NODE: 2,
- TEXT_NODE: 3,
- CDATA_SECTION_NODE: 4,
- ENTITY_REFERENCE_NODE: 5,
- ENTITY_NODE: 6,
- PROCESSING_INSTRUCTION_NODE: 7,
- COMMENT_NODE: 8,
- DOCUMENT_NODE: 9,
- DOCUMENT_TYPE_NODE: 10,
- DOCUMENT_FRAGMENT_NODE: 11,
- NOTATION_NODE: 12
- });
-}
-
-
-
-(function(global) {
-
- var HAS_EXTENDED_CREATE_ELEMENT_SYNTAX = (function(){
- try {
- var el = document.createElement('');
- return el.tagName.toLowerCase() === 'input' && el.name === 'x';
- }
- catch(err) {
- return false;
- }
- })();
-
- var element = global.Element;
-
- global.Element = function(tagName, attributes) {
- attributes = attributes || { };
- tagName = tagName.toLowerCase();
- var cache = Element.cache;
- if (HAS_EXTENDED_CREATE_ELEMENT_SYNTAX && attributes.name) {
- tagName = '<' + tagName + ' name="' + attributes.name + '">';
- delete attributes.name;
- return Element.writeAttribute(document.createElement(tagName), attributes);
- }
- if (!cache[tagName]) cache[tagName] = Element.extend(document.createElement(tagName));
- return Element.writeAttribute(cache[tagName].cloneNode(false), attributes);
- };
-
- Object.extend(global.Element, element || { });
- if (element) global.Element.prototype = element.prototype;
-
-})(this);
-
-Element.idCounter = 1;
-Element.cache = { };
-
-function purgeElement(element) {
- var uid = element._prototypeUID;
- if (uid) {
- Element.stopObserving(element);
- element._prototypeUID = void 0;
- delete Element.Storage[uid];
- }
-}
-
-Element.Methods = {
- visible: function(element) {
- return $(element).style.display != 'none';
- },
-
- toggle: function(element) {
- element = $(element);
- Element[Element.visible(element) ? 'hide' : 'show'](element);
- return element;
- },
-
- hide: function(element) {
- element = $(element);
- element.style.display = 'none';
- return element;
- },
-
- show: function(element) {
- element = $(element);
- element.style.display = '';
- return element;
- },
-
- remove: function(element) {
- element = $(element);
- element.parentNode.removeChild(element);
- return element;
- },
-
- update: (function(){
-
- var SELECT_ELEMENT_INNERHTML_BUGGY = (function(){
- var el = document.createElement("select"),
- isBuggy = true;
- el.innerHTML = "";
- if (el.options && el.options[0]) {
- isBuggy = el.options[0].nodeName.toUpperCase() !== "OPTION";
- }
- el = null;
- return isBuggy;
- })();
-
- var TABLE_ELEMENT_INNERHTML_BUGGY = (function(){
- try {
- var el = document.createElement("table");
- if (el && el.tBodies) {
- el.innerHTML = "test ', '
', 1],
- TBODY: ['', '
', 2],
- TR: ['
', 3],
- TD: ['
', 4],
- SELECT: ['', 1]
- }
-};
-
-(function() {
- var tags = Element._insertionTranslations.tags;
- Object.extend(tags, {
- THEAD: tags.TBODY,
- TFOOT: tags.TBODY,
- TH: tags.TD
- });
-})();
-
-Element.Methods.Simulated = {
- hasAttribute: function(element, attribute) {
- attribute = Element._attributeTranslations.has[attribute] || attribute;
- var node = $(element).getAttributeNode(attribute);
- return !!(node && node.specified);
- }
-};
-
-Element.Methods.ByTag = { };
-
-Object.extend(Element, Element.Methods);
-
-(function(div) {
-
- if (!Prototype.BrowserFeatures.ElementExtensions && div['__proto__']) {
- window.HTMLElement = { };
- window.HTMLElement.prototype = div['__proto__'];
- Prototype.BrowserFeatures.ElementExtensions = true;
- }
-
- div = null;
-
-})(document.createElement('div'));
-
-Element.extend = (function() {
-
- function checkDeficiency(tagName) {
- if (typeof window.Element != 'undefined') {
- var proto = window.Element.prototype;
- if (proto) {
- var id = '_' + (Math.random()+'').slice(2),
- el = document.createElement(tagName);
- proto[id] = 'x';
- var isBuggy = (el[id] !== 'x');
- delete proto[id];
- el = null;
- return isBuggy;
- }
- }
- return false;
- }
-
- function extendElementWith(element, methods) {
- for (var property in methods) {
- var value = methods[property];
- if (Object.isFunction(value) && !(property in element))
- element[property] = value.methodize();
- }
- }
-
- var HTMLOBJECTELEMENT_PROTOTYPE_BUGGY = checkDeficiency('object');
-
- if (Prototype.BrowserFeatures.SpecificElementExtensions) {
- if (HTMLOBJECTELEMENT_PROTOTYPE_BUGGY) {
- return function(element) {
- if (element && typeof element._extendedByPrototype == 'undefined') {
- var t = element.tagName;
- if (t && (/^(?:object|applet|embed)$/i.test(t))) {
- extendElementWith(element, Element.Methods);
- extendElementWith(element, Element.Methods.Simulated);
- extendElementWith(element, Element.Methods.ByTag[t.toUpperCase()]);
- }
- }
- return element;
- }
- }
- return Prototype.K;
- }
-
- var Methods = { }, ByTag = Element.Methods.ByTag;
-
- var extend = Object.extend(function(element) {
- if (!element || typeof element._extendedByPrototype != 'undefined' ||
- element.nodeType != 1 || element == window) return element;
-
- var methods = Object.clone(Methods),
- tagName = element.tagName.toUpperCase();
-
- if (ByTag[tagName]) Object.extend(methods, ByTag[tagName]);
-
- extendElementWith(element, methods);
-
- element._extendedByPrototype = Prototype.emptyFunction;
- return element;
-
- }, {
- refresh: function() {
- if (!Prototype.BrowserFeatures.ElementExtensions) {
- Object.extend(Methods, Element.Methods);
- Object.extend(Methods, Element.Methods.Simulated);
- }
- }
- });
-
- extend.refresh();
- return extend;
-})();
-
-if (document.documentElement.hasAttribute) {
- Element.hasAttribute = function(element, attribute) {
- return element.hasAttribute(attribute);
- };
-}
-else {
- Element.hasAttribute = Element.Methods.Simulated.hasAttribute;
-}
-
-Element.addMethods = function(methods) {
- var F = Prototype.BrowserFeatures, T = Element.Methods.ByTag;
-
- if (!methods) {
- Object.extend(Form, Form.Methods);
- Object.extend(Form.Element, Form.Element.Methods);
- Object.extend(Element.Methods.ByTag, {
- "FORM": Object.clone(Form.Methods),
- "INPUT": Object.clone(Form.Element.Methods),
- "SELECT": Object.clone(Form.Element.Methods),
- "TEXTAREA": Object.clone(Form.Element.Methods)
- });
- }
-
- if (arguments.length == 2) {
- var tagName = methods;
- methods = arguments[1];
- }
-
- if (!tagName) Object.extend(Element.Methods, methods || { });
- else {
- if (Object.isArray(tagName)) tagName.each(extend);
- else extend(tagName);
- }
-
- function extend(tagName) {
- tagName = tagName.toUpperCase();
- if (!Element.Methods.ByTag[tagName])
- Element.Methods.ByTag[tagName] = { };
- Object.extend(Element.Methods.ByTag[tagName], methods);
- }
-
- function copy(methods, destination, onlyIfAbsent) {
- onlyIfAbsent = onlyIfAbsent || false;
- for (var property in methods) {
- var value = methods[property];
- if (!Object.isFunction(value)) continue;
- if (!onlyIfAbsent || !(property in destination))
- destination[property] = value.methodize();
- }
- }
-
- function findDOMClass(tagName) {
- var klass;
- var trans = {
- "OPTGROUP": "OptGroup", "TEXTAREA": "TextArea", "P": "Paragraph",
- "FIELDSET": "FieldSet", "UL": "UList", "OL": "OList", "DL": "DList",
- "DIR": "Directory", "H1": "Heading", "H2": "Heading", "H3": "Heading",
- "H4": "Heading", "H5": "Heading", "H6": "Heading", "Q": "Quote",
- "INS": "Mod", "DEL": "Mod", "A": "Anchor", "IMG": "Image", "CAPTION":
- "TableCaption", "COL": "TableCol", "COLGROUP": "TableCol", "THEAD":
- "TableSection", "TFOOT": "TableSection", "TBODY": "TableSection", "TR":
- "TableRow", "TH": "TableCell", "TD": "TableCell", "FRAMESET":
- "FrameSet", "IFRAME": "IFrame"
- };
- if (trans[tagName]) klass = 'HTML' + trans[tagName] + 'Element';
- if (window[klass]) return window[klass];
- klass = 'HTML' + tagName + 'Element';
- if (window[klass]) return window[klass];
- klass = 'HTML' + tagName.capitalize() + 'Element';
- if (window[klass]) return window[klass];
-
- var element = document.createElement(tagName),
- proto = element['__proto__'] || element.constructor.prototype;
-
- element = null;
- return proto;
- }
-
- var elementPrototype = window.HTMLElement ? HTMLElement.prototype :
- Element.prototype;
-
- if (F.ElementExtensions) {
- copy(Element.Methods, elementPrototype);
- copy(Element.Methods.Simulated, elementPrototype, true);
- }
-
- if (F.SpecificElementExtensions) {
- for (var tag in Element.Methods.ByTag) {
- var klass = findDOMClass(tag);
- if (Object.isUndefined(klass)) continue;
- copy(T[tag], klass.prototype);
- }
- }
-
- Object.extend(Element, Element.Methods);
- delete Element.ByTag;
-
- if (Element.extend.refresh) Element.extend.refresh();
- Element.cache = { };
-};
-
-
-document.viewport = {
-
- getDimensions: function() {
- return { width: this.getWidth(), height: this.getHeight() };
- },
-
- getScrollOffsets: function() {
- return Element._returnOffset(
- window.pageXOffset || document.documentElement.scrollLeft || document.body.scrollLeft,
- window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop);
- }
-};
-
-(function(viewport) {
- var B = Prototype.Browser, doc = document, element, property = {};
-
- function getRootElement() {
- if (B.WebKit && !doc.evaluate)
- return document;
-
- if (B.Opera && window.parseFloat(window.opera.version()) < 9.5)
- return document.body;
-
- return document.documentElement;
- }
-
- function define(D) {
- if (!element) element = getRootElement();
-
- property[D] = 'client' + D;
-
- viewport['get' + D] = function() { return element[property[D]] };
- return viewport['get' + D]();
- }
-
- viewport.getWidth = define.curry('Width');
-
- viewport.getHeight = define.curry('Height');
-})(document.viewport);
-
-
-Element.Storage = {
- UID: 1
-};
-
-Element.addMethods({
- getStorage: function(element) {
- if (!(element = $(element))) return;
-
- var uid;
- if (element === window) {
- uid = 0;
- } else {
- if (typeof element._prototypeUID === "undefined")
- element._prototypeUID = Element.Storage.UID++;
- uid = element._prototypeUID;
- }
-
- if (!Element.Storage[uid])
- Element.Storage[uid] = $H();
-
- return Element.Storage[uid];
- },
-
- store: function(element, key, value) {
- if (!(element = $(element))) return;
-
- if (arguments.length === 2) {
- Element.getStorage(element).update(key);
- } else {
- Element.getStorage(element).set(key, value);
- }
-
- return element;
- },
-
- retrieve: function(element, key, defaultValue) {
- if (!(element = $(element))) return;
- var hash = Element.getStorage(element), value = hash.get(key);
-
- if (Object.isUndefined(value)) {
- hash.set(key, defaultValue);
- value = defaultValue;
- }
-
- return value;
- },
-
- clone: function(element, deep) {
- if (!(element = $(element))) return;
- var clone = element.cloneNode(deep);
- clone._prototypeUID = void 0;
- if (deep) {
- var descendants = Element.select(clone, '*'),
- i = descendants.length;
- while (i--) {
- descendants[i]._prototypeUID = void 0;
- }
- }
- return Element.extend(clone);
- },
-
- purge: function(element) {
- if (!(element = $(element))) return;
- purgeElement(element);
-
- var descendants = element.getElementsByTagName('*'),
- i = descendants.length;
-
- while (i--) purgeElement(descendants[i]);
-
- return null;
- }
-});
-
-(function() {
-
- function toDecimal(pctString) {
- var match = pctString.match(/^(\d+)%?$/i);
- if (!match) return null;
- return (Number(match[1]) / 100);
- }
-
- function getPixelValue(value, property) {
- if (Object.isElement(value)) {
- element = value;
- value = element.getStyle(property);
- }
- if (value === null) {
- return null;
- }
-
- if ((/^(?:-)?\d+(\.\d+)?(px)?$/i).test(value)) {
- return window.parseFloat(value);
- }
-
- if (/\d/.test(value) && element.runtimeStyle) {
- var style = element.style.left, rStyle = element.runtimeStyle.left;
- element.runtimeStyle.left = element.currentStyle.left;
- element.style.left = value || 0;
- value = element.style.pixelLeft;
- element.style.left = style;
- element.runtimeStyle.left = rStyle;
-
- return value;
- }
-
- if (value.include('%')) {
- var decimal = toDecimal(value);
- var whole;
- if (property.include('left') || property.include('right') ||
- property.include('width')) {
- whole = $(element.parentNode).measure('width');
- } else if (property.include('top') || property.include('bottom') ||
- property.include('height')) {
- whole = $(element.parentNode).measure('height');
- }
-
- return whole * decimal;
- }
-
- return 0;
- }
-
- function toCSSPixels(number) {
- if (Object.isString(number) && number.endsWith('px')) {
- return number;
- }
- return number + 'px';
- }
-
- function isDisplayed(element) {
- var originalElement = element;
- while (element && element.parentNode) {
- var display = element.getStyle('display');
- if (display === 'none') {
- return false;
- }
- element = $(element.parentNode);
- }
- return true;
- }
-
- var hasLayout = Prototype.K;
- if ('currentStyle' in document.documentElement) {
- hasLayout = function(element) {
- if (!element.currentStyle.hasLayout) {
- element.style.zoom = 1;
- }
- return element;
- };
- }
-
- function cssNameFor(key) {
- if (key.include('border')) key = key + '-width';
- return key.camelize();
- }
-
- Element.Layout = Class.create(Hash, {
- initialize: function($super, element, preCompute) {
- $super();
- this.element = $(element);
-
- Element.Layout.PROPERTIES.each( function(property) {
- this._set(property, null);
- }, this);
-
- if (preCompute) {
- this._preComputing = true;
- this._begin();
- Element.Layout.PROPERTIES.each( this._compute, this );
- this._end();
- this._preComputing = false;
- }
- },
-
- _set: function(property, value) {
- return Hash.prototype.set.call(this, property, value);
- },
-
- set: function(property, value) {
- throw "Properties of Element.Layout are read-only.";
- },
-
- get: function($super, property) {
- var value = $super(property);
- return value === null ? this._compute(property) : value;
- },
-
- _begin: function() {
- if (this._prepared) return;
-
- var element = this.element;
- if (isDisplayed(element)) {
- this._prepared = true;
- return;
- }
-
- var originalStyles = {
- position: element.style.position || '',
- width: element.style.width || '',
- visibility: element.style.visibility || '',
- display: element.style.display || ''
- };
-
- element.store('prototype_original_styles', originalStyles);
-
- var position = element.getStyle('position'),
- width = element.getStyle('width');
-
- element.setStyle({
- position: 'absolute',
- visibility: 'hidden',
- display: 'block'
- });
-
- var positionedWidth = element.getStyle('width');
-
- var newWidth;
- if (width && (positionedWidth === width)) {
- newWidth = getPixelValue(width);
- } else if (width && (position === 'absolute' || position === 'fixed')) {
- newWidth = getPixelValue(width);
- } else {
- var parent = element.parentNode, pLayout = $(parent).getLayout();
-
- newWidth = pLayout.get('width') -
- this.get('margin-left') -
- this.get('border-left') -
- this.get('padding-left') -
- this.get('padding-right') -
- this.get('border-right') -
- this.get('margin-right');
- }
-
- element.setStyle({ width: newWidth + 'px' });
-
- this._prepared = true;
- },
-
- _end: function() {
- var element = this.element;
- var originalStyles = element.retrieve('prototype_original_styles');
- element.store('prototype_original_styles', null);
- element.setStyle(originalStyles);
- this._prepared = false;
- },
-
- _compute: function(property) {
- var COMPUTATIONS = Element.Layout.COMPUTATIONS;
- if (!(property in COMPUTATIONS)) {
- throw "Property not found.";
- }
- return this._set(property, COMPUTATIONS[property].call(this, this.element));
- },
-
- toObject: function() {
- var args = $A(arguments);
- var keys = (args.length === 0) ? Element.Layout.PROPERTIES :
- args.join(' ').split(' ');
- var obj = {};
- keys.each( function(key) {
- if (!Element.Layout.PROPERTIES.include(key)) return;
- var value = this.get(key);
- if (value != null) obj[key] = value;
- }, this);
- return obj;
- },
-
- toHash: function() {
- var obj = this.toObject.apply(this, arguments);
- return new Hash(obj);
- },
-
- toCSS: function() {
- var args = $A(arguments);
- var keys = (args.length === 0) ? Element.Layout.PROPERTIES :
- args.join(' ').split(' ');
- var css = {};
-
- keys.each( function(key) {
- if (!Element.Layout.PROPERTIES.include(key)) return;
- if (Element.Layout.COMPOSITE_PROPERTIES.include(key)) return;
-
- var value = this.get(key);
- if (value != null) css[cssNameFor(key)] = value + 'px';
- }, this);
- return css;
- },
-
- inspect: function() {
- return "#";
- }
- });
-
- Object.extend(Element.Layout, {
- PROPERTIES: $w('height width top left right bottom border-left border-right border-top border-bottom padding-left padding-right padding-top padding-bottom margin-top margin-bottom margin-left margin-right padding-box-width padding-box-height border-box-width border-box-height margin-box-width margin-box-height'),
-
- COMPOSITE_PROPERTIES: $w('padding-box-width padding-box-height margin-box-width margin-box-height border-box-width border-box-height'),
-
- COMPUTATIONS: {
- 'height': function(element) {
- if (!this._preComputing) this._begin();
-
- var bHeight = this.get('border-box-height');
- if (bHeight <= 0) return 0;
-
- var bTop = this.get('border-top'),
- bBottom = this.get('border-bottom');
-
- var pTop = this.get('padding-top'),
- pBottom = this.get('padding-bottom');
-
- if (!this._preComputing) this._end();
-
- return bHeight - bTop - bBottom - pTop - pBottom;
- },
-
- 'width': function(element) {
- if (!this._preComputing) this._begin();
-
- var bWidth = this.get('border-box-width');
- if (bWidth <= 0) return 0;
-
- var bLeft = this.get('border-left'),
- bRight = this.get('border-right');
-
- var pLeft = this.get('padding-left'),
- pRight = this.get('padding-right');
-
- if (!this._preComputing) this._end();
-
- return bWidth - bLeft - bRight - pLeft - pRight;
- },
-
- 'padding-box-height': function(element) {
- var height = this.get('height'),
- pTop = this.get('padding-top'),
- pBottom = this.get('padding-bottom');
-
- return height + pTop + pBottom;
- },
-
- 'padding-box-width': function(element) {
- var width = this.get('width'),
- pLeft = this.get('padding-left'),
- pRight = this.get('padding-right');
-
- return width + pLeft + pRight;
- },
-
- 'border-box-height': function(element) {
- return element.offsetHeight;
- },
-
- 'border-box-width': function(element) {
- return element.offsetWidth;
- },
-
- 'margin-box-height': function(element) {
- var bHeight = this.get('border-box-height'),
- mTop = this.get('margin-top'),
- mBottom = this.get('margin-bottom');
-
- if (bHeight <= 0) return 0;
-
- return bHeight + mTop + mBottom;
- },
-
- 'margin-box-width': function(element) {
- var bWidth = this.get('border-box-width'),
- mLeft = this.get('margin-left'),
- mRight = this.get('margin-right');
-
- if (bWidth <= 0) return 0;
-
- return bWidth + mLeft + mRight;
- },
-
- 'top': function(element) {
- var offset = element.positionedOffset();
- return offset.top;
- },
-
- 'bottom': function(element) {
- var offset = element.positionedOffset(),
- parent = element.getOffsetParent(),
- pHeight = parent.measure('height');
-
- var mHeight = this.get('border-box-height');
-
- return pHeight - mHeight - offset.top;
- },
-
- 'left': function(element) {
- var offset = element.positionedOffset();
- return offset.left;
- },
-
- 'right': function(element) {
- var offset = element.positionedOffset(),
- parent = element.getOffsetParent(),
- pWidth = parent.measure('width');
-
- var mWidth = this.get('border-box-width');
-
- return pWidth - mWidth - offset.left;
- },
-
- 'padding-top': function(element) {
- return getPixelValue(element, 'paddingTop');
- },
-
- 'padding-bottom': function(element) {
- return getPixelValue(element, 'paddingBottom');
- },
-
- 'padding-left': function(element) {
- return getPixelValue(element, 'paddingLeft');
- },
-
- 'padding-right': function(element) {
- return getPixelValue(element, 'paddingRight');
- },
-
- 'border-top': function(element) {
- return Object.isNumber(element.clientTop) ? element.clientTop :
- getPixelValue(element, 'borderTopWidth');
- },
-
- 'border-bottom': function(element) {
- return Object.isNumber(element.clientBottom) ? element.clientBottom :
- getPixelValue(element, 'borderBottomWidth');
- },
-
- 'border-left': function(element) {
- return Object.isNumber(element.clientLeft) ? element.clientLeft :
- getPixelValue(element, 'borderLeftWidth');
- },
-
- 'border-right': function(element) {
- return Object.isNumber(element.clientRight) ? element.clientRight :
- getPixelValue(element, 'borderRightWidth');
- },
-
- 'margin-top': function(element) {
- return getPixelValue(element, 'marginTop');
- },
-
- 'margin-bottom': function(element) {
- return getPixelValue(element, 'marginBottom');
- },
-
- 'margin-left': function(element) {
- return getPixelValue(element, 'marginLeft');
- },
-
- 'margin-right': function(element) {
- return getPixelValue(element, 'marginRight');
- }
- }
- });
-
- if ('getBoundingClientRect' in document.documentElement) {
- Object.extend(Element.Layout.COMPUTATIONS, {
- 'right': function(element) {
- var parent = hasLayout(element.getOffsetParent());
- var rect = element.getBoundingClientRect(),
- pRect = parent.getBoundingClientRect();
-
- return (pRect.right - rect.right).round();
- },
-
- 'bottom': function(element) {
- var parent = hasLayout(element.getOffsetParent());
- var rect = element.getBoundingClientRect(),
- pRect = parent.getBoundingClientRect();
-
- return (pRect.bottom - rect.bottom).round();
- }
- });
- }
-
- Element.Offset = Class.create({
- initialize: function(left, top) {
- this.left = left.round();
- this.top = top.round();
-
- this[0] = this.left;
- this[1] = this.top;
- },
-
- relativeTo: function(offset) {
- return new Element.Offset(
- this.left - offset.left,
- this.top - offset.top
- );
- },
-
- inspect: function() {
- return "#".interpolate(this);
- },
-
- toString: function() {
- return "[#{left}, #{top}]".interpolate(this);
- },
-
- toArray: function() {
- return [this.left, this.top];
- }
- });
-
- function getLayout(element, preCompute) {
- return new Element.Layout(element, preCompute);
- }
-
- function measure(element, property) {
- return $(element).getLayout().get(property);
- }
-
- function getDimensions(element) {
- var layout = $(element).getLayout();
- return {
- width: layout.get('width'),
- height: layout.get('height')
- };
- }
-
- function getOffsetParent(element) {
- if (isDetached(element)) return $(document.body);
-
- var isInline = (Element.getStyle(element, 'display') === 'inline');
- if (!isInline && element.offsetParent) return $(element.offsetParent);
- if (element === document.body) return $(element);
-
- while ((element = element.parentNode) && element !== document.body) {
- if (Element.getStyle(element, 'position') !== 'static') {
- return (element.nodeName === 'HTML') ? $(document.body) : $(element);
- }
- }
-
- return $(document.body);
- }
-
-
- function cumulativeOffset(element) {
- var valueT = 0, valueL = 0;
- do {
- valueT += element.offsetTop || 0;
- valueL += element.offsetLeft || 0;
- element = element.offsetParent;
- } while (element);
- return new Element.Offset(valueL, valueT);
- }
-
- function positionedOffset(element) {
- var layout = element.getLayout();
-
- var valueT = 0, valueL = 0;
- do {
- valueT += element.offsetTop || 0;
- valueL += element.offsetLeft || 0;
- element = element.offsetParent;
- if (element) {
- if (isBody(element)) break;
- var p = Element.getStyle(element, 'position');
- if (p !== 'static') break;
- }
- } while (element);
-
- valueL -= layout.get('margin-top');
- valueT -= layout.get('margin-left');
-
- return new Element.Offset(valueL, valueT);
- }
-
- function cumulativeScrollOffset(element) {
- var valueT = 0, valueL = 0;
- do {
- valueT += element.scrollTop || 0;
- valueL += element.scrollLeft || 0;
- element = element.parentNode;
- } while (element);
- return new Element.Offset(valueL, valueT);
- }
-
- function viewportOffset(forElement) {
- var valueT = 0, valueL = 0, docBody = document.body;
-
- var element = forElement;
- do {
- valueT += element.offsetTop || 0;
- valueL += element.offsetLeft || 0;
- if (element.offsetParent == docBody &&
- Element.getStyle(element, 'position') == 'absolute') break;
- } while (element = element.offsetParent);
-
- element = forElement;
- do {
- if (element != docBody) {
- valueT -= element.scrollTop || 0;
- valueL -= element.scrollLeft || 0;
- }
- } while (element = element.parentNode);
- return new Element.Offset(valueL, valueT);
- }
-
- function absolutize(element) {
- element = $(element);
-
- if (Element.getStyle(element, 'position') === 'absolute') {
- return element;
- }
-
- var offsetParent = getOffsetParent(element);
- var eOffset = element.viewportOffset(),
- pOffset = offsetParent.viewportOffset();
-
- var offset = eOffset.relativeTo(pOffset);
- var layout = element.getLayout();
-
- element.store('prototype_absolutize_original_styles', {
- left: element.getStyle('left'),
- top: element.getStyle('top'),
- width: element.getStyle('width'),
- height: element.getStyle('height')
- });
-
- element.setStyle({
- position: 'absolute',
- top: offset.top + 'px',
- left: offset.left + 'px',
- width: layout.get('width') + 'px',
- height: layout.get('height') + 'px'
- });
-
- return element;
- }
-
- function relativize(element) {
- element = $(element);
- if (Element.getStyle(element, 'position') === 'relative') {
- return element;
- }
-
- var originalStyles =
- element.retrieve('prototype_absolutize_original_styles');
-
- if (originalStyles) element.setStyle(originalStyles);
- return element;
- }
-
- Element.addMethods({
- getLayout: getLayout,
- measure: measure,
- getDimensions: getDimensions,
- getOffsetParent: getOffsetParent,
- cumulativeOffset: cumulativeOffset,
- positionedOffset: positionedOffset,
- cumulativeScrollOffset: cumulativeScrollOffset,
- viewportOffset: viewportOffset,
- absolutize: absolutize,
- relativize: relativize
- });
-
- function isBody(element) {
- return element.nodeName.toUpperCase() === 'BODY';
- }
-
- function isDetached(element) {
- return element !== document.body &&
- !Element.descendantOf(element, document.body);
- }
-
- if ('getBoundingClientRect' in document.documentElement) {
- Element.addMethods({
- viewportOffset: function(element) {
- element = $(element);
- if (isDetached(element)) return new Element.Offset(0, 0);
-
- var rect = element.getBoundingClientRect(),
- docEl = document.documentElement;
- return new Element.Offset(rect.left - docEl.clientLeft,
- rect.top - docEl.clientTop);
- },
-
- positionedOffset: function(element) {
- element = $(element);
- var parent = element.getOffsetParent();
- if (isDetached(element)) return new Element.Offset(0, 0);
-
- if (element.offsetParent &&
- element.offsetParent.nodeName.toUpperCase() === 'HTML') {
- return positionedOffset(element);
- }
-
- var eOffset = element.viewportOffset(),
- pOffset = isBody(parent) ? viewportOffset(parent) :
- parent.viewportOffset();
- var retOffset = eOffset.relativeTo(pOffset);
-
- var layout = element.getLayout();
- var top = retOffset.top - layout.get('margin-top');
- var left = retOffset.left - layout.get('margin-left');
-
- return new Element.Offset(left, top);
- }
- });
- }
-})();
-window.$$ = function() {
- var expression = $A(arguments).join(', ');
- return Prototype.Selector.select(expression, document);
-};
-
-Prototype.Selector = (function() {
-
- function select() {
- throw new Error('Method "Prototype.Selector.select" must be defined.');
- }
-
- function match() {
- throw new Error('Method "Prototype.Selector.match" must be defined.');
- }
-
- function find(elements, expression, index) {
- index = index || 0;
- var match = Prototype.Selector.match, length = elements.length, matchIndex = 0, i;
-
- for (i = 0; i < length; i++) {
- if (match(elements[i], expression) && index == matchIndex++) {
- return Element.extend(elements[i]);
- }
- }
- }
-
- function extendElements(elements) {
- for (var i = 0, length = elements.length; i < length; i++) {
- Element.extend(elements[i]);
- }
- return elements;
- }
-
-
- var K = Prototype.K;
-
- return {
- select: select,
- match: match,
- find: find,
- extendElements: (Element.extend === K) ? K : extendElements,
- extendElement: Element.extend
- };
-})();
-Prototype._original_property = window.Sizzle;
-/*!
- * Sizzle CSS Selector Engine - v1.0
- * Copyright 2009, The Dojo Foundation
- * Released under the MIT, BSD, and GPL Licenses.
- * More information: http://sizzlejs.com/
- */
-(function(){
-
-var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
- done = 0,
- toString = Object.prototype.toString,
- hasDuplicate = false,
- baseHasDuplicate = true;
-
-[0, 0].sort(function(){
- baseHasDuplicate = false;
- return 0;
-});
-
-var Sizzle = function(selector, context, results, seed) {
- results = results || [];
- var origContext = context = context || document;
-
- if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
- return [];
- }
-
- if ( !selector || typeof selector !== "string" ) {
- return results;
- }
-
- var parts = [], m, set, checkSet, check, mode, extra, prune = true, contextXML = isXML(context),
- soFar = selector;
-
- while ( (chunker.exec(""), m = chunker.exec(soFar)) !== null ) {
- soFar = m[3];
-
- parts.push( m[1] );
-
- if ( m[2] ) {
- extra = m[3];
- break;
- }
- }
-
- if ( parts.length > 1 && origPOS.exec( selector ) ) {
- if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
- set = posProcess( parts[0] + parts[1], context );
- } else {
- set = Expr.relative[ parts[0] ] ?
- [ context ] :
- Sizzle( parts.shift(), context );
-
- while ( parts.length ) {
- selector = parts.shift();
-
- if ( Expr.relative[ selector ] )
- selector += parts.shift();
-
- set = posProcess( selector, set );
- }
- }
- } else {
- if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
- Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
- var ret = Sizzle.find( parts.shift(), context, contextXML );
- context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
- }
-
- if ( context ) {
- var ret = seed ?
- { expr: parts.pop(), set: makeArray(seed) } :
- Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
- set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;
-
- if ( parts.length > 0 ) {
- checkSet = makeArray(set);
- } else {
- prune = false;
- }
-
- while ( parts.length ) {
- var cur = parts.pop(), pop = cur;
-
- if ( !Expr.relative[ cur ] ) {
- cur = "";
- } else {
- pop = parts.pop();
- }
-
- if ( pop == null ) {
- pop = context;
- }
-
- Expr.relative[ cur ]( checkSet, pop, contextXML );
- }
- } else {
- checkSet = parts = [];
- }
- }
-
- if ( !checkSet ) {
- checkSet = set;
- }
-
- if ( !checkSet ) {
- throw "Syntax error, unrecognized expression: " + (cur || selector);
- }
-
- if ( toString.call(checkSet) === "[object Array]" ) {
- if ( !prune ) {
- results.push.apply( results, checkSet );
- } else if ( context && context.nodeType === 1 ) {
- for ( var i = 0; checkSet[i] != null; i++ ) {
- if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
- results.push( set[i] );
- }
- }
- } else {
- for ( var i = 0; checkSet[i] != null; i++ ) {
- if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
- results.push( set[i] );
- }
- }
- }
- } else {
- makeArray( checkSet, results );
- }
-
- if ( extra ) {
- Sizzle( extra, origContext, results, seed );
- Sizzle.uniqueSort( results );
- }
-
- return results;
-};
-
-Sizzle.uniqueSort = function(results){
- if ( sortOrder ) {
- hasDuplicate = baseHasDuplicate;
- results.sort(sortOrder);
-
- if ( hasDuplicate ) {
- for ( var i = 1; i < results.length; i++ ) {
- if ( results[i] === results[i-1] ) {
- results.splice(i--, 1);
- }
- }
- }
- }
-
- return results;
-};
-
-Sizzle.matches = function(expr, set){
- return Sizzle(expr, null, null, set);
-};
-
-Sizzle.find = function(expr, context, isXML){
- var set, match;
-
- if ( !expr ) {
- return [];
- }
-
- for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
- var type = Expr.order[i], match;
-
- if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
- var left = match[1];
- match.splice(1,1);
-
- if ( left.substr( left.length - 1 ) !== "\\" ) {
- match[1] = (match[1] || "").replace(/\\/g, "");
- set = Expr.find[ type ]( match, context, isXML );
- if ( set != null ) {
- expr = expr.replace( Expr.match[ type ], "" );
- break;
- }
- }
- }
- }
-
- if ( !set ) {
- set = context.getElementsByTagName("*");
- }
-
- return {set: set, expr: expr};
-};
-
-Sizzle.filter = function(expr, set, inplace, not){
- var old = expr, result = [], curLoop = set, match, anyFound,
- isXMLFilter = set && set[0] && isXML(set[0]);
-
- while ( expr && set.length ) {
- for ( var type in Expr.filter ) {
- if ( (match = Expr.match[ type ].exec( expr )) != null ) {
- var filter = Expr.filter[ type ], found, item;
- anyFound = false;
-
- if ( curLoop == result ) {
- result = [];
- }
-
- if ( Expr.preFilter[ type ] ) {
- match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
-
- if ( !match ) {
- anyFound = found = true;
- } else if ( match === true ) {
- continue;
- }
- }
-
- if ( match ) {
- for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
- if ( item ) {
- found = filter( item, match, i, curLoop );
- var pass = not ^ !!found;
-
- if ( inplace && found != null ) {
- if ( pass ) {
- anyFound = true;
- } else {
- curLoop[i] = false;
- }
- } else if ( pass ) {
- result.push( item );
- anyFound = true;
- }
- }
- }
- }
-
- if ( found !== undefined ) {
- if ( !inplace ) {
- curLoop = result;
- }
-
- expr = expr.replace( Expr.match[ type ], "" );
-
- if ( !anyFound ) {
- return [];
- }
-
- break;
- }
- }
- }
-
- if ( expr == old ) {
- if ( anyFound == null ) {
- throw "Syntax error, unrecognized expression: " + expr;
- } else {
- break;
- }
- }
-
- old = expr;
- }
-
- return curLoop;
-};
-
-var Expr = Sizzle.selectors = {
- order: [ "ID", "NAME", "TAG" ],
- match: {
- ID: /#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
- CLASS: /\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
- NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,
- ATTR: /\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
- TAG: /^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,
- CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
- POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
- PSEUDO: /:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
- },
- leftMatch: {},
- attrMap: {
- "class": "className",
- "for": "htmlFor"
- },
- attrHandle: {
- href: function(elem){
- return elem.getAttribute("href");
- }
- },
- relative: {
- "+": function(checkSet, part, isXML){
- var isPartStr = typeof part === "string",
- isTag = isPartStr && !/\W/.test(part),
- isPartStrNotTag = isPartStr && !isTag;
-
- if ( isTag && !isXML ) {
- part = part.toUpperCase();
- }
-
- for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
- if ( (elem = checkSet[i]) ) {
- while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
-
- checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ?
- elem || false :
- elem === part;
- }
- }
-
- if ( isPartStrNotTag ) {
- Sizzle.filter( part, checkSet, true );
- }
- },
- ">": function(checkSet, part, isXML){
- var isPartStr = typeof part === "string";
-
- if ( isPartStr && !/\W/.test(part) ) {
- part = isXML ? part : part.toUpperCase();
-
- for ( var i = 0, l = checkSet.length; i < l; i++ ) {
- var elem = checkSet[i];
- if ( elem ) {
- var parent = elem.parentNode;
- checkSet[i] = parent.nodeName === part ? parent : false;
- }
- }
- } else {
- for ( var i = 0, l = checkSet.length; i < l; i++ ) {
- var elem = checkSet[i];
- if ( elem ) {
- checkSet[i] = isPartStr ?
- elem.parentNode :
- elem.parentNode === part;
- }
- }
-
- if ( isPartStr ) {
- Sizzle.filter( part, checkSet, true );
- }
- }
- },
- "": function(checkSet, part, isXML){
- var doneName = done++, checkFn = dirCheck;
-
- if ( !/\W/.test(part) ) {
- var nodeCheck = part = isXML ? part : part.toUpperCase();
- checkFn = dirNodeCheck;
- }
-
- checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
- },
- "~": function(checkSet, part, isXML){
- var doneName = done++, checkFn = dirCheck;
-
- if ( typeof part === "string" && !/\W/.test(part) ) {
- var nodeCheck = part = isXML ? part : part.toUpperCase();
- checkFn = dirNodeCheck;
- }
-
- checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
- }
- },
- find: {
- ID: function(match, context, isXML){
- if ( typeof context.getElementById !== "undefined" && !isXML ) {
- var m = context.getElementById(match[1]);
- return m ? [m] : [];
- }
- },
- NAME: function(match, context, isXML){
- if ( typeof context.getElementsByName !== "undefined" ) {
- var ret = [], results = context.getElementsByName(match[1]);
-
- for ( var i = 0, l = results.length; i < l; i++ ) {
- if ( results[i].getAttribute("name") === match[1] ) {
- ret.push( results[i] );
- }
- }
-
- return ret.length === 0 ? null : ret;
- }
- },
- TAG: function(match, context){
- return context.getElementsByTagName(match[1]);
- }
- },
- preFilter: {
- CLASS: function(match, curLoop, inplace, result, not, isXML){
- match = " " + match[1].replace(/\\/g, "") + " ";
-
- if ( isXML ) {
- return match;
- }
-
- for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
- if ( elem ) {
- if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
- if ( !inplace )
- result.push( elem );
- } else if ( inplace ) {
- curLoop[i] = false;
- }
- }
- }
-
- return false;
- },
- ID: function(match){
- return match[1].replace(/\\/g, "");
- },
- TAG: function(match, curLoop){
- for ( var i = 0; curLoop[i] === false; i++ ){}
- return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
- },
- CHILD: function(match){
- if ( match[1] == "nth" ) {
- var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
- match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
- !/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
-
- match[2] = (test[1] + (test[2] || 1)) - 0;
- match[3] = test[3] - 0;
- }
-
- match[0] = done++;
-
- return match;
- },
- ATTR: function(match, curLoop, inplace, result, not, isXML){
- var name = match[1].replace(/\\/g, "");
-
- if ( !isXML && Expr.attrMap[name] ) {
- match[1] = Expr.attrMap[name];
- }
-
- if ( match[2] === "~=" ) {
- match[4] = " " + match[4] + " ";
- }
-
- return match;
- },
- PSEUDO: function(match, curLoop, inplace, result, not){
- if ( match[1] === "not" ) {
- if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
- match[3] = Sizzle(match[3], null, null, curLoop);
- } else {
- var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
- if ( !inplace ) {
- result.push.apply( result, ret );
- }
- return false;
- }
- } else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
- return true;
- }
-
- return match;
- },
- POS: function(match){
- match.unshift( true );
- return match;
- }
- },
- filters: {
- enabled: function(elem){
- return elem.disabled === false && elem.type !== "hidden";
- },
- disabled: function(elem){
- return elem.disabled === true;
- },
- checked: function(elem){
- return elem.checked === true;
- },
- selected: function(elem){
- elem.parentNode.selectedIndex;
- return elem.selected === true;
- },
- parent: function(elem){
- return !!elem.firstChild;
- },
- empty: function(elem){
- return !elem.firstChild;
- },
- has: function(elem, i, match){
- return !!Sizzle( match[3], elem ).length;
- },
- header: function(elem){
- return /h\d/i.test( elem.nodeName );
- },
- text: function(elem){
- return "text" === elem.type;
- },
- radio: function(elem){
- return "radio" === elem.type;
- },
- checkbox: function(elem){
- return "checkbox" === elem.type;
- },
- file: function(elem){
- return "file" === elem.type;
- },
- password: function(elem){
- return "password" === elem.type;
- },
- submit: function(elem){
- return "submit" === elem.type;
- },
- image: function(elem){
- return "image" === elem.type;
- },
- reset: function(elem){
- return "reset" === elem.type;
- },
- button: function(elem){
- return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
- },
- input: function(elem){
- return /input|select|textarea|button/i.test(elem.nodeName);
- }
- },
- setFilters: {
- first: function(elem, i){
- return i === 0;
- },
- last: function(elem, i, match, array){
- return i === array.length - 1;
- },
- even: function(elem, i){
- return i % 2 === 0;
- },
- odd: function(elem, i){
- return i % 2 === 1;
- },
- lt: function(elem, i, match){
- return i < match[3] - 0;
- },
- gt: function(elem, i, match){
- return i > match[3] - 0;
- },
- nth: function(elem, i, match){
- return match[3] - 0 == i;
- },
- eq: function(elem, i, match){
- return match[3] - 0 == i;
- }
- },
- filter: {
- PSEUDO: function(elem, match, i, array){
- var name = match[1], filter = Expr.filters[ name ];
-
- if ( filter ) {
- return filter( elem, i, match, array );
- } else if ( name === "contains" ) {
- return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
- } else if ( name === "not" ) {
- var not = match[3];
-
- for ( var i = 0, l = not.length; i < l; i++ ) {
- if ( not[i] === elem ) {
- return false;
- }
- }
-
- return true;
- }
- },
- CHILD: function(elem, match){
- var type = match[1], node = elem;
- switch (type) {
- case 'only':
- case 'first':
- while ( (node = node.previousSibling) ) {
- if ( node.nodeType === 1 ) return false;
- }
- if ( type == 'first') return true;
- node = elem;
- case 'last':
- while ( (node = node.nextSibling) ) {
- if ( node.nodeType === 1 ) return false;
- }
- return true;
- case 'nth':
- var first = match[2], last = match[3];
-
- if ( first == 1 && last == 0 ) {
- return true;
- }
-
- var doneName = match[0],
- parent = elem.parentNode;
-
- if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
- var count = 0;
- for ( node = parent.firstChild; node; node = node.nextSibling ) {
- if ( node.nodeType === 1 ) {
- node.nodeIndex = ++count;
- }
- }
- parent.sizcache = doneName;
- }
-
- var diff = elem.nodeIndex - last;
- if ( first == 0 ) {
- return diff == 0;
- } else {
- return ( diff % first == 0 && diff / first >= 0 );
- }
- }
- },
- ID: function(elem, match){
- return elem.nodeType === 1 && elem.getAttribute("id") === match;
- },
- TAG: function(elem, match){
- return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
- },
- CLASS: function(elem, match){
- return (" " + (elem.className || elem.getAttribute("class")) + " ")
- .indexOf( match ) > -1;
- },
- ATTR: function(elem, match){
- var name = match[1],
- result = Expr.attrHandle[ name ] ?
- Expr.attrHandle[ name ]( elem ) :
- elem[ name ] != null ?
- elem[ name ] :
- elem.getAttribute( name ),
- value = result + "",
- type = match[2],
- check = match[4];
-
- return result == null ?
- type === "!=" :
- type === "=" ?
- value === check :
- type === "*=" ?
- value.indexOf(check) >= 0 :
- type === "~=" ?
- (" " + value + " ").indexOf(check) >= 0 :
- !check ?
- value && result !== false :
- type === "!=" ?
- value != check :
- type === "^=" ?
- value.indexOf(check) === 0 :
- type === "$=" ?
- value.substr(value.length - check.length) === check :
- type === "|=" ?
- value === check || value.substr(0, check.length + 1) === check + "-" :
- false;
- },
- POS: function(elem, match, i, array){
- var name = match[2], filter = Expr.setFilters[ name ];
-
- if ( filter ) {
- return filter( elem, i, match, array );
- }
- }
- }
-};
-
-var origPOS = Expr.match.POS;
-
-for ( var type in Expr.match ) {
- Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
- Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source );
-}
-
-var makeArray = function(array, results) {
- array = Array.prototype.slice.call( array, 0 );
-
- if ( results ) {
- results.push.apply( results, array );
- return results;
- }
-
- return array;
-};
-
-try {
- Array.prototype.slice.call( document.documentElement.childNodes, 0 );
-
-} catch(e){
- makeArray = function(array, results) {
- var ret = results || [];
-
- if ( toString.call(array) === "[object Array]" ) {
- Array.prototype.push.apply( ret, array );
- } else {
- if ( typeof array.length === "number" ) {
- for ( var i = 0, l = array.length; i < l; i++ ) {
- ret.push( array[i] );
- }
- } else {
- for ( var i = 0; array[i]; i++ ) {
- ret.push( array[i] );
- }
- }
- }
-
- return ret;
- };
-}
-
-var sortOrder;
-
-if ( document.documentElement.compareDocumentPosition ) {
- sortOrder = function( a, b ) {
- if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
- if ( a == b ) {
- hasDuplicate = true;
- }
- return 0;
- }
-
- var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
- if ( ret === 0 ) {
- hasDuplicate = true;
- }
- return ret;
- };
-} else if ( "sourceIndex" in document.documentElement ) {
- sortOrder = function( a, b ) {
- if ( !a.sourceIndex || !b.sourceIndex ) {
- if ( a == b ) {
- hasDuplicate = true;
- }
- return 0;
- }
-
- var ret = a.sourceIndex - b.sourceIndex;
- if ( ret === 0 ) {
- hasDuplicate = true;
- }
- return ret;
- };
-} else if ( document.createRange ) {
- sortOrder = function( a, b ) {
- if ( !a.ownerDocument || !b.ownerDocument ) {
- if ( a == b ) {
- hasDuplicate = true;
- }
- return 0;
- }
-
- var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
- aRange.setStart(a, 0);
- aRange.setEnd(a, 0);
- bRange.setStart(b, 0);
- bRange.setEnd(b, 0);
- var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
- if ( ret === 0 ) {
- hasDuplicate = true;
- }
- return ret;
- };
-}
-
-(function(){
- var form = document.createElement("div"),
- id = "script" + (new Date).getTime();
- form.innerHTML = "";
-
- var root = document.documentElement;
- root.insertBefore( form, root.firstChild );
-
- if ( !!document.getElementById( id ) ) {
- Expr.find.ID = function(match, context, isXML){
- if ( typeof context.getElementById !== "undefined" && !isXML ) {
- var m = context.getElementById(match[1]);
- return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
- }
- };
-
- Expr.filter.ID = function(elem, match){
- var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
- return elem.nodeType === 1 && node && node.nodeValue === match;
- };
- }
-
- root.removeChild( form );
- root = form = null; // release memory in IE
-})();
-
-(function(){
-
- var div = document.createElement("div");
- div.appendChild( document.createComment("") );
-
- if ( div.getElementsByTagName("*").length > 0 ) {
- Expr.find.TAG = function(match, context){
- var results = context.getElementsByTagName(match[1]);
-
- if ( match[1] === "*" ) {
- var tmp = [];
-
- for ( var i = 0; results[i]; i++ ) {
- if ( results[i].nodeType === 1 ) {
- tmp.push( results[i] );
- }
- }
-
- results = tmp;
- }
-
- return results;
- };
- }
-
- div.innerHTML = "";
- if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
- div.firstChild.getAttribute("href") !== "#" ) {
- Expr.attrHandle.href = function(elem){
- return elem.getAttribute("href", 2);
- };
- }
-
- div = null; // release memory in IE
-})();
-
-if ( document.querySelectorAll ) (function(){
- var oldSizzle = Sizzle, div = document.createElement("div");
- div.innerHTML = "";
-
- if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
- return;
- }
-
- Sizzle = function(query, context, extra, seed){
- context = context || document;
-
- if ( !seed && context.nodeType === 9 && !isXML(context) ) {
- try {
- return makeArray( context.querySelectorAll(query), extra );
- } catch(e){}
- }
-
- return oldSizzle(query, context, extra, seed);
- };
-
- for ( var prop in oldSizzle ) {
- Sizzle[ prop ] = oldSizzle[ prop ];
- }
-
- div = null; // release memory in IE
-})();
-
-if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
- var div = document.createElement("div");
- div.innerHTML = "";
-
- if ( div.getElementsByClassName("e").length === 0 )
- return;
-
- div.lastChild.className = "e";
-
- if ( div.getElementsByClassName("e").length === 1 )
- return;
-
- Expr.order.splice(1, 0, "CLASS");
- Expr.find.CLASS = function(match, context, isXML) {
- if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
- return context.getElementsByClassName(match[1]);
- }
- };
-
- div = null; // release memory in IE
-})();
-
-function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
- var sibDir = dir == "previousSibling" && !isXML;
- for ( var i = 0, l = checkSet.length; i < l; i++ ) {
- var elem = checkSet[i];
- if ( elem ) {
- if ( sibDir && elem.nodeType === 1 ){
- elem.sizcache = doneName;
- elem.sizset = i;
- }
- elem = elem[dir];
- var match = false;
-
- while ( elem ) {
- if ( elem.sizcache === doneName ) {
- match = checkSet[elem.sizset];
- break;
- }
-
- if ( elem.nodeType === 1 && !isXML ){
- elem.sizcache = doneName;
- elem.sizset = i;
- }
-
- if ( elem.nodeName === cur ) {
- match = elem;
- break;
- }
-
- elem = elem[dir];
- }
-
- checkSet[i] = match;
- }
- }
-}
-
-function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
- var sibDir = dir == "previousSibling" && !isXML;
- for ( var i = 0, l = checkSet.length; i < l; i++ ) {
- var elem = checkSet[i];
- if ( elem ) {
- if ( sibDir && elem.nodeType === 1 ) {
- elem.sizcache = doneName;
- elem.sizset = i;
- }
- elem = elem[dir];
- var match = false;
-
- while ( elem ) {
- if ( elem.sizcache === doneName ) {
- match = checkSet[elem.sizset];
- break;
- }
-
- if ( elem.nodeType === 1 ) {
- if ( !isXML ) {
- elem.sizcache = doneName;
- elem.sizset = i;
- }
- if ( typeof cur !== "string" ) {
- if ( elem === cur ) {
- match = true;
- break;
- }
-
- } else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
- match = elem;
- break;
- }
- }
-
- elem = elem[dir];
- }
-
- checkSet[i] = match;
- }
- }
-}
-
-var contains = document.compareDocumentPosition ? function(a, b){
- return a.compareDocumentPosition(b) & 16;
-} : function(a, b){
- return a !== b && (a.contains ? a.contains(b) : true);
-};
-
-var isXML = function(elem){
- return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
- !!elem.ownerDocument && elem.ownerDocument.documentElement.nodeName !== "HTML";
-};
-
-var posProcess = function(selector, context){
- var tmpSet = [], later = "", match,
- root = context.nodeType ? [context] : context;
-
- while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
- later += match[0];
- selector = selector.replace( Expr.match.PSEUDO, "" );
- }
-
- selector = Expr.relative[selector] ? selector + "*" : selector;
-
- for ( var i = 0, l = root.length; i < l; i++ ) {
- Sizzle( selector, root[i], tmpSet );
- }
-
- return Sizzle.filter( later, tmpSet );
-};
-
-
-window.Sizzle = Sizzle;
-
-})();
-
-;(function(engine) {
- var extendElements = Prototype.Selector.extendElements;
-
- function select(selector, scope) {
- return extendElements(engine(selector, scope || document));
- }
-
- function match(element, selector) {
- return engine.matches(selector, [element]).length == 1;
- }
-
- Prototype.Selector.engine = engine;
- Prototype.Selector.select = select;
- Prototype.Selector.match = match;
-})(Sizzle);
-
-window.Sizzle = Prototype._original_property;
-delete Prototype._original_property;
-
-var Form = {
- reset: function(form) {
- form = $(form);
- form.reset();
- return form;
- },
-
- serializeElements: function(elements, options) {
- if (typeof options != 'object') options = { hash: !!options };
- else if (Object.isUndefined(options.hash)) options.hash = true;
- var key, value, submitted = false, submit = options.submit;
-
- var data = elements.inject({ }, function(result, element) {
- if (!element.disabled && element.name) {
- key = element.name; value = $(element).getValue();
- if (value != null && element.type != 'file' && (element.type != 'submit' || (!submitted &&
- submit !== false && (!submit || key == submit) && (submitted = true)))) {
- if (key in result) {
- if (!Object.isArray(result[key])) result[key] = [result[key]];
- result[key].push(value);
- }
- else result[key] = value;
- }
- }
- return result;
- });
-
- return options.hash ? data : Object.toQueryString(data);
- }
-};
-
-Form.Methods = {
- serialize: function(form, options) {
- return Form.serializeElements(Form.getElements(form), options);
- },
-
- getElements: function(form) {
- var elements = $(form).getElementsByTagName('*'),
- element,
- arr = [ ],
- serializers = Form.Element.Serializers;
- for (var i = 0; element = elements[i]; i++) {
- arr.push(element);
- }
- return arr.inject([], function(elements, child) {
- if (serializers[child.tagName.toLowerCase()])
- elements.push(Element.extend(child));
- return elements;
- })
- },
-
- getInputs: function(form, typeName, name) {
- form = $(form);
- var inputs = form.getElementsByTagName('input');
-
- if (!typeName && !name) return $A(inputs).map(Element.extend);
-
- for (var i = 0, matchingInputs = [], length = inputs.length; i < length; i++) {
- var input = inputs[i];
- if ((typeName && input.type != typeName) || (name && input.name != name))
- continue;
- matchingInputs.push(Element.extend(input));
- }
-
- return matchingInputs;
- },
-
- disable: function(form) {
- form = $(form);
- Form.getElements(form).invoke('disable');
- return form;
- },
-
- enable: function(form) {
- form = $(form);
- Form.getElements(form).invoke('enable');
- return form;
- },
-
- findFirstElement: function(form) {
- var elements = $(form).getElements().findAll(function(element) {
- return 'hidden' != element.type && !element.disabled;
- });
- var firstByIndex = elements.findAll(function(element) {
- return element.hasAttribute('tabIndex') && element.tabIndex >= 0;
- }).sortBy(function(element) { return element.tabIndex }).first();
-
- return firstByIndex ? firstByIndex : elements.find(function(element) {
- return /^(?:input|select|textarea)$/i.test(element.tagName);
- });
- },
-
- focusFirstElement: function(form) {
- form = $(form);
- form.findFirstElement().activate();
- return form;
- },
-
- request: function(form, options) {
- form = $(form), options = Object.clone(options || { });
-
- var params = options.parameters, action = form.readAttribute('action') || '';
- if (action.blank()) action = window.location.href;
- options.parameters = form.serialize(true);
-
- if (params) {
- if (Object.isString(params)) params = params.toQueryParams();
- Object.extend(options.parameters, params);
- }
-
- if (form.hasAttribute('method') && !options.method)
- options.method = form.method;
-
- return new Ajax.Request(action, options);
- }
-};
-
-/*--------------------------------------------------------------------------*/
-
-
-Form.Element = {
- focus: function(element) {
- $(element).focus();
- return element;
- },
-
- select: function(element) {
- $(element).select();
- return element;
- }
-};
-
-Form.Element.Methods = {
-
- serialize: function(element) {
- element = $(element);
- if (!element.disabled && element.name) {
- var value = element.getValue();
- if (value != undefined) {
- var pair = { };
- pair[element.name] = value;
- return Object.toQueryString(pair);
- }
- }
- return '';
- },
-
- getValue: function(element) {
- element = $(element);
- var method = element.tagName.toLowerCase();
- return Form.Element.Serializers[method](element);
- },
-
- setValue: function(element, value) {
- element = $(element);
- var method = element.tagName.toLowerCase();
- Form.Element.Serializers[method](element, value);
- return element;
- },
-
- clear: function(element) {
- $(element).value = '';
- return element;
- },
-
- present: function(element) {
- return $(element).value != '';
- },
-
- activate: function(element) {
- element = $(element);
- try {
- element.focus();
- if (element.select && (element.tagName.toLowerCase() != 'input' ||
- !(/^(?:button|reset|submit)$/i.test(element.type))))
- element.select();
- } catch (e) { }
- return element;
- },
-
- disable: function(element) {
- element = $(element);
- element.disabled = true;
- return element;
- },
-
- enable: function(element) {
- element = $(element);
- element.disabled = false;
- return element;
- }
-};
-
-/*--------------------------------------------------------------------------*/
-
-var Field = Form.Element;
-
-var $F = Form.Element.Methods.getValue;
-
-/*--------------------------------------------------------------------------*/
-
-Form.Element.Serializers = {
- input: function(element, value) {
- switch (element.type.toLowerCase()) {
- case 'checkbox':
- case 'radio':
- return Form.Element.Serializers.inputSelector(element, value);
- default:
- return Form.Element.Serializers.textarea(element, value);
- }
- },
-
- inputSelector: function(element, value) {
- if (Object.isUndefined(value)) return element.checked ? element.value : null;
- else element.checked = !!value;
- },
-
- textarea: function(element, value) {
- if (Object.isUndefined(value)) return element.value;
- else element.value = value;
- },
-
- select: function(element, value) {
- if (Object.isUndefined(value))
- return this[element.type == 'select-one' ?
- 'selectOne' : 'selectMany'](element);
- else {
- var opt, currentValue, single = !Object.isArray(value);
- for (var i = 0, length = element.length; i < length; i++) {
- opt = element.options[i];
- currentValue = this.optionValue(opt);
- if (single) {
- if (currentValue == value) {
- opt.selected = true;
- return;
- }
- }
- else opt.selected = value.include(currentValue);
- }
- }
- },
-
- selectOne: function(element) {
- var index = element.selectedIndex;
- return index >= 0 ? this.optionValue(element.options[index]) : null;
- },
-
- selectMany: function(element) {
- var values, length = element.length;
- if (!length) return null;
-
- for (var i = 0, values = []; i < length; i++) {
- var opt = element.options[i];
- if (opt.selected) values.push(this.optionValue(opt));
- }
- return values;
- },
-
- optionValue: function(opt) {
- return Element.extend(opt).hasAttribute('value') ? opt.value : opt.text;
- }
-};
-
-/*--------------------------------------------------------------------------*/
-
-
-Abstract.TimedObserver = Class.create(PeriodicalExecuter, {
- initialize: function($super, element, frequency, callback) {
- $super(callback, frequency);
- this.element = $(element);
- this.lastValue = this.getValue();
- },
-
- execute: function() {
- var value = this.getValue();
- if (Object.isString(this.lastValue) && Object.isString(value) ?
- this.lastValue != value : String(this.lastValue) != String(value)) {
- this.callback(this.element, value);
- this.lastValue = value;
- }
- }
-});
-
-Form.Element.Observer = Class.create(Abstract.TimedObserver, {
- getValue: function() {
- return Form.Element.getValue(this.element);
- }
-});
-
-Form.Observer = Class.create(Abstract.TimedObserver, {
- getValue: function() {
- return Form.serialize(this.element);
- }
-});
-
-/*--------------------------------------------------------------------------*/
-
-Abstract.EventObserver = Class.create({
- initialize: function(element, callback) {
- this.element = $(element);
- this.callback = callback;
-
- this.lastValue = this.getValue();
- if (this.element.tagName.toLowerCase() == 'form')
- this.registerFormCallbacks();
- else
- this.registerCallback(this.element);
- },
-
- onElementEvent: function() {
- var value = this.getValue();
- if (this.lastValue != value) {
- this.callback(this.element, value);
- this.lastValue = value;
- }
- },
-
- registerFormCallbacks: function() {
- Form.getElements(this.element).each(this.registerCallback, this);
- },
-
- registerCallback: function(element) {
- if (element.type) {
- switch (element.type.toLowerCase()) {
- case 'checkbox':
- case 'radio':
- Event.observe(element, 'click', this.onElementEvent.bind(this));
- break;
- default:
- Event.observe(element, 'change', this.onElementEvent.bind(this));
- break;
- }
- }
- }
-});
-
-Form.Element.EventObserver = Class.create(Abstract.EventObserver, {
- getValue: function() {
- return Form.Element.getValue(this.element);
- }
-});
-
-Form.EventObserver = Class.create(Abstract.EventObserver, {
- getValue: function() {
- return Form.serialize(this.element);
- }
-});
-(function() {
-
- var Event = {
- KEY_BACKSPACE: 8,
- KEY_TAB: 9,
- KEY_RETURN: 13,
- KEY_ESC: 27,
- KEY_LEFT: 37,
- KEY_UP: 38,
- KEY_RIGHT: 39,
- KEY_DOWN: 40,
- KEY_DELETE: 46,
- KEY_HOME: 36,
- KEY_END: 35,
- KEY_PAGEUP: 33,
- KEY_PAGEDOWN: 34,
- KEY_INSERT: 45,
-
- cache: {}
- };
-
- var docEl = document.documentElement;
- var MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED = 'onmouseenter' in docEl
- && 'onmouseleave' in docEl;
-
- var _isButton;
- if (Prototype.Browser.IE) {
- var buttonMap = { 0: 1, 1: 4, 2: 2 };
- _isButton = function(event, code) {
- return event.button === buttonMap[code];
- };
- } else if (Prototype.Browser.WebKit) {
- _isButton = function(event, code) {
- switch (code) {
- case 0: return event.which == 1 && !event.metaKey;
- case 1: return event.which == 1 && event.metaKey;
- default: return false;
- }
- };
- } else {
- _isButton = function(event, code) {
- return event.which ? (event.which === code + 1) : (event.button === code);
- };
- }
-
- function isLeftClick(event) { return _isButton(event, 0) }
-
- function isMiddleClick(event) { return _isButton(event, 1) }
-
- function isRightClick(event) { return _isButton(event, 2) }
-
- function element(event) {
- event = Event.extend(event);
-
- var node = event.target, type = event.type,
- currentTarget = event.currentTarget;
-
- if (currentTarget && currentTarget.tagName) {
- if (type === 'load' || type === 'error' ||
- (type === 'click' && currentTarget.tagName.toLowerCase() === 'input'
- && currentTarget.type === 'radio'))
- node = currentTarget;
- }
-
- if (node.nodeType == Node.TEXT_NODE)
- node = node.parentNode;
-
- return Element.extend(node);
- }
-
- function findElement(event, expression) {
- var element = Event.element(event);
- if (!expression) return element;
- while (element) {
- if (Object.isElement(element) && Prototype.Selector.match(element, expression)) {
- return Element.extend(element);
- }
- element = element.parentNode;
- }
- }
-
- function pointer(event) {
- return { x: pointerX(event), y: pointerY(event) };
- }
-
- function pointerX(event) {
- var docElement = document.documentElement,
- body = document.body || { scrollLeft: 0 };
-
- return event.pageX || (event.clientX +
- (docElement.scrollLeft || body.scrollLeft) -
- (docElement.clientLeft || 0));
- }
-
- function pointerY(event) {
- var docElement = document.documentElement,
- body = document.body || { scrollTop: 0 };
-
- return event.pageY || (event.clientY +
- (docElement.scrollTop || body.scrollTop) -
- (docElement.clientTop || 0));
- }
-
-
- function stop(event) {
- Event.extend(event);
- event.preventDefault();
- event.stopPropagation();
-
- event.stopped = true;
- }
-
- Event.Methods = {
- isLeftClick: isLeftClick,
- isMiddleClick: isMiddleClick,
- isRightClick: isRightClick,
-
- element: element,
- findElement: findElement,
-
- pointer: pointer,
- pointerX: pointerX,
- pointerY: pointerY,
-
- stop: stop
- };
-
-
- var methods = Object.keys(Event.Methods).inject({ }, function(m, name) {
- m[name] = Event.Methods[name].methodize();
- return m;
- });
-
- if (Prototype.Browser.IE) {
- function _relatedTarget(event) {
- var element;
- switch (event.type) {
- case 'mouseover': element = event.fromElement; break;
- case 'mouseout': element = event.toElement; break;
- default: return null;
- }
- return Element.extend(element);
- }
-
- Object.extend(methods, {
- stopPropagation: function() { this.cancelBubble = true },
- preventDefault: function() { this.returnValue = false },
- inspect: function() { return '[object Event]' }
- });
-
- Event.extend = function(event, element) {
- if (!event) return false;
- if (event._extendedByPrototype) return event;
-
- event._extendedByPrototype = Prototype.emptyFunction;
- var pointer = Event.pointer(event);
-
- Object.extend(event, {
- target: event.srcElement || element,
- relatedTarget: _relatedTarget(event),
- pageX: pointer.x,
- pageY: pointer.y
- });
-
- return Object.extend(event, methods);
- };
- } else {
- Event.prototype = window.Event.prototype || document.createEvent('HTMLEvents').__proto__;
- Object.extend(Event.prototype, methods);
- Event.extend = Prototype.K;
- }
-
- function _createResponder(element, eventName, handler) {
- var registry = Element.retrieve(element, 'prototype_event_registry');
-
- if (Object.isUndefined(registry)) {
- CACHE.push(element);
- registry = Element.retrieve(element, 'prototype_event_registry', $H());
- }
-
- var respondersForEvent = registry.get(eventName);
- if (Object.isUndefined(respondersForEvent)) {
- respondersForEvent = [];
- registry.set(eventName, respondersForEvent);
- }
-
- if (respondersForEvent.pluck('handler').include(handler)) return false;
-
- var responder;
- if (eventName.include(":")) {
- responder = function(event) {
- if (Object.isUndefined(event.eventName))
- return false;
-
- if (event.eventName !== eventName)
- return false;
-
- Event.extend(event, element);
- handler.call(element, event);
- };
- } else {
- if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED &&
- (eventName === "mouseenter" || eventName === "mouseleave")) {
- if (eventName === "mouseenter" || eventName === "mouseleave") {
- responder = function(event) {
- Event.extend(event, element);
-
- var parent = event.relatedTarget;
- while (parent && parent !== element) {
- try { parent = parent.parentNode; }
- catch(e) { parent = element; }
- }
-
- if (parent === element) return;
-
- handler.call(element, event);
- };
- }
- } else {
- responder = function(event) {
- Event.extend(event, element);
- handler.call(element, event);
- };
- }
- }
-
- responder.handler = handler;
- respondersForEvent.push(responder);
- return responder;
- }
-
- function _destroyCache() {
- for (var i = 0, length = CACHE.length; i < length; i++) {
- Event.stopObserving(CACHE[i]);
- CACHE[i] = null;
- }
- }
-
- var CACHE = [];
-
- if (Prototype.Browser.IE)
- window.attachEvent('onunload', _destroyCache);
-
- if (Prototype.Browser.WebKit)
- window.addEventListener('unload', Prototype.emptyFunction, false);
-
-
- var _getDOMEventName = Prototype.K,
- translations = { mouseenter: "mouseover", mouseleave: "mouseout" };
-
- if (!MOUSEENTER_MOUSELEAVE_EVENTS_SUPPORTED) {
- _getDOMEventName = function(eventName) {
- return (translations[eventName] || eventName);
- };
- }
-
- function observe(element, eventName, handler) {
- element = $(element);
-
- var responder = _createResponder(element, eventName, handler);
-
- if (!responder) return element;
-
- if (eventName.include(':')) {
- if (element.addEventListener)
- element.addEventListener("dataavailable", responder, false);
- else {
- element.attachEvent("ondataavailable", responder);
- element.attachEvent("onfilterchange", responder);
- }
- } else {
- var actualEventName = _getDOMEventName(eventName);
-
- if (element.addEventListener)
- element.addEventListener(actualEventName, responder, false);
- else
- element.attachEvent("on" + actualEventName, responder);
- }
-
- return element;
- }
-
- function stopObserving(element, eventName, handler) {
- element = $(element);
-
- var registry = Element.retrieve(element, 'prototype_event_registry');
- if (!registry) return element;
-
- if (!eventName) {
- registry.each( function(pair) {
- var eventName = pair.key;
- stopObserving(element, eventName);
- });
- return element;
- }
-
- var responders = registry.get(eventName);
- if (!responders) return element;
-
- if (!handler) {
- responders.each(function(r) {
- stopObserving(element, eventName, r.handler);
- });
- return element;
- }
-
- var responder = responders.find( function(r) { return r.handler === handler; });
- if (!responder) return element;
-
- if (eventName.include(':')) {
- if (element.removeEventListener)
- element.removeEventListener("dataavailable", responder, false);
- else {
- element.detachEvent("ondataavailable", responder);
- element.detachEvent("onfilterchange", responder);
- }
- } else {
- var actualEventName = _getDOMEventName(eventName);
- if (element.removeEventListener)
- element.removeEventListener(actualEventName, responder, false);
- else
- element.detachEvent('on' + actualEventName, responder);
- }
-
- registry.set(eventName, responders.without(responder));
-
- return element;
- }
-
- function fire(element, eventName, memo, bubble) {
- element = $(element);
-
- if (Object.isUndefined(bubble))
- bubble = true;
-
- if (element == document && document.createEvent && !element.dispatchEvent)
- element = document.documentElement;
-
- var event;
- if (document.createEvent) {
- event = document.createEvent('HTMLEvents');
- event.initEvent('dataavailable', true, true);
- } else {
- event = document.createEventObject();
- event.eventType = bubble ? 'ondataavailable' : 'onfilterchange';
- }
-
- event.eventName = eventName;
- event.memo = memo || { };
-
- if (document.createEvent)
- element.dispatchEvent(event);
- else
- element.fireEvent(event.eventType, event);
-
- return Event.extend(event);
- }
-
- Event.Handler = Class.create({
- initialize: function(element, eventName, selector, callback) {
- this.element = $(element);
- this.eventName = eventName;
- this.selector = selector;
- this.callback = callback;
- this.handler = this.handleEvent.bind(this);
- },
-
- start: function() {
- Event.observe(this.element, this.eventName, this.handler);
- return this;
- },
-
- stop: function() {
- Event.stopObserving(this.element, this.eventName, this.handler);
- return this;
- },
-
- handleEvent: function(event) {
- var element = event.findElement(this.selector);
- if (element) this.callback.call(this.element, event, element);
- }
- });
-
- function on(element, eventName, selector, callback) {
- element = $(element);
- if (Object.isFunction(selector) && Object.isUndefined(callback)) {
- callback = selector, selector = null;
- }
-
- return new Event.Handler(element, eventName, selector, callback).start();
- }
-
- Object.extend(Event, Event.Methods);
-
- Object.extend(Event, {
- fire: fire,
- observe: observe,
- stopObserving: stopObserving,
- on: on
- });
-
- Element.addMethods({
- fire: fire,
-
- observe: observe,
-
- stopObserving: stopObserving,
-
- on: on
- });
-
- Object.extend(document, {
- fire: fire.methodize(),
-
- observe: observe.methodize(),
-
- stopObserving: stopObserving.methodize(),
-
- on: on.methodize(),
-
- loaded: false
- });
-
- if (window.Event) Object.extend(window.Event, Event);
- else window.Event = Event;
-})();
-
-(function() {
- /* Support for the DOMContentLoaded event is based on work by Dan Webb,
- Matthias Miller, Dean Edwards, John Resig, and Diego Perini. */
-
- var timer;
-
- function fireContentLoadedEvent() {
- if (document.loaded) return;
- if (timer) window.clearTimeout(timer);
- document.loaded = true;
- document.fire('dom:loaded');
- }
-
- function checkReadyState() {
- if (document.readyState === 'complete') {
- document.stopObserving('readystatechange', checkReadyState);
- fireContentLoadedEvent();
- }
- }
-
- function pollDoScroll() {
- try { document.documentElement.doScroll('left'); }
- catch(e) {
- timer = pollDoScroll.defer();
- return;
- }
- fireContentLoadedEvent();
- }
-
- if (document.addEventListener) {
- document.addEventListener('DOMContentLoaded', fireContentLoadedEvent, false);
- } else {
- document.observe('readystatechange', checkReadyState);
- if (window == top)
- timer = pollDoScroll.defer();
- }
-
- Event.observe(window, 'load', fireContentLoadedEvent);
-})();
-
-Element.addMethods();
-
-/*------------------------------- DEPRECATED -------------------------------*/
-
-Hash.toQueryString = Object.toQueryString;
-
-var Toggle = { display: Element.toggle };
-
-Element.Methods.childOf = Element.Methods.descendantOf;
-
-var Insertion = {
- Before: function(element, content) {
- return Element.insert(element, {before:content});
- },
-
- Top: function(element, content) {
- return Element.insert(element, {top:content});
- },
-
- Bottom: function(element, content) {
- return Element.insert(element, {bottom:content});
- },
-
- After: function(element, content) {
- return Element.insert(element, {after:content});
- }
-};
-
-var $continue = new Error('"throw $continue" is deprecated, use "return" instead');
-
-var Position = {
- includeScrollOffsets: false,
-
- prepare: function() {
- this.deltaX = window.pageXOffset
- || document.documentElement.scrollLeft
- || document.body.scrollLeft
- || 0;
- this.deltaY = window.pageYOffset
- || document.documentElement.scrollTop
- || document.body.scrollTop
- || 0;
- },
-
- within: function(element, x, y) {
- if (this.includeScrollOffsets)
- return this.withinIncludingScrolloffsets(element, x, y);
- this.xcomp = x;
- this.ycomp = y;
- this.offset = Element.cumulativeOffset(element);
-
- return (y >= this.offset[1] &&
- y < this.offset[1] + element.offsetHeight &&
- x >= this.offset[0] &&
- x < this.offset[0] + element.offsetWidth);
- },
-
- withinIncludingScrolloffsets: function(element, x, y) {
- var offsetcache = Element.cumulativeScrollOffset(element);
-
- this.xcomp = x + offsetcache[0] - this.deltaX;
- this.ycomp = y + offsetcache[1] - this.deltaY;
- this.offset = Element.cumulativeOffset(element);
-
- return (this.ycomp >= this.offset[1] &&
- this.ycomp < this.offset[1] + element.offsetHeight &&
- this.xcomp >= this.offset[0] &&
- this.xcomp < this.offset[0] + element.offsetWidth);
- },
-
- overlap: function(mode, element) {
- if (!mode) return 0;
- if (mode == 'vertical')
- return ((this.offset[1] + element.offsetHeight) - this.ycomp) /
- element.offsetHeight;
- if (mode == 'horizontal')
- return ((this.offset[0] + element.offsetWidth) - this.xcomp) /
- element.offsetWidth;
- },
-
-
- cumulativeOffset: Element.Methods.cumulativeOffset,
-
- positionedOffset: Element.Methods.positionedOffset,
-
- absolutize: function(element) {
- Position.prepare();
- return Element.absolutize(element);
- },
-
- relativize: function(element) {
- Position.prepare();
- return Element.relativize(element);
- },
-
- realOffset: Element.Methods.cumulativeScrollOffset,
-
- offsetParent: Element.Methods.getOffsetParent,
-
- page: Element.Methods.viewportOffset,
-
- clone: function(source, target, options) {
- options = options || { };
- return Element.clonePosition(target, source, options);
- }
-};
-
-/*--------------------------------------------------------------------------*/
-
-if (!document.getElementsByClassName) document.getElementsByClassName = function(instanceMethods){
- function iter(name) {
- return name.blank() ? null : "[contains(concat(' ', @class, ' '), ' " + name + " ')]";
- }
-
- instanceMethods.getElementsByClassName = Prototype.BrowserFeatures.XPath ?
- function(element, className) {
- className = className.toString().strip();
- var cond = /\s/.test(className) ? $w(className).map(iter).join('') : iter(className);
- return cond ? document._getElementsByXPath('.//*' + cond, element) : [];
- } : function(element, className) {
- className = className.toString().strip();
- var elements = [], classNames = (/\s/.test(className) ? $w(className) : null);
- if (!classNames && !className) return elements;
-
- var nodes = $(element).getElementsByTagName('*');
- className = ' ' + className + ' ';
-
- for (var i = 0, child, cn; child = nodes[i]; i++) {
- if (child.className && (cn = ' ' + child.className + ' ') && (cn.include(className) ||
- (classNames && classNames.all(function(name) {
- return !name.toString().blank() && cn.include(' ' + name + ' ');
- }))))
- elements.push(Element.extend(child));
- }
- return elements;
- };
-
- return function(className, parentElement) {
- return $(parentElement || document.body).getElementsByClassName(className);
- };
-}(Element.Methods);
-
-/*--------------------------------------------------------------------------*/
-
-Element.ClassNames = Class.create();
-Element.ClassNames.prototype = {
- initialize: function(element) {
- this.element = $(element);
- },
-
- _each: function(iterator) {
- this.element.className.split(/\s+/).select(function(name) {
- return name.length > 0;
- })._each(iterator);
- },
-
- set: function(className) {
- this.element.className = className;
- },
-
- add: function(classNameToAdd) {
- if (this.include(classNameToAdd)) return;
- this.set($A(this).concat(classNameToAdd).join(' '));
- },
-
- remove: function(classNameToRemove) {
- if (!this.include(classNameToRemove)) return;
- this.set($A(this).without(classNameToRemove).join(' '));
- },
-
- toString: function() {
- return $A(this).join(' ');
- }
-};
-
-Object.extend(Element.ClassNames.prototype, Enumerable);
-
-/*--------------------------------------------------------------------------*/
-
-(function() {
- window.Selector = Class.create({
- initialize: function(expression) {
- this.expression = expression.strip();
- },
-
- findElements: function(rootElement) {
- return Prototype.Selector.select(this.expression, rootElement);
- },
-
- match: function(element) {
- return Prototype.Selector.match(element, this.expression);
- },
-
- toString: function() {
- return this.expression;
- },
-
- inspect: function() {
- return "#";
- }
- });
-
- Object.extend(Selector, {
- matchElements: function(elements, expression) {
- var match = Prototype.Selector.match,
- results = [];
-
- for (var i = 0, length = elements.length; i < length; i++) {
- var element = elements[i];
- if (match(element, expression)) {
- results.push(Element.extend(element));
- }
- }
- return results;
- },
-
- findElement: function(elements, expression, index) {
- index = index || 0;
- var matchIndex = 0, element;
- for (var i = 0, length = elements.length; i < length; i++) {
- element = elements[i];
- if (Prototype.Selector.match(element, expression) && index === matchIndex++) {
- return Element.extend(element);
- }
- }
- },
-
- findChildElements: function(element, expressions) {
- var selector = expressions.toArray().join(', ');
- return Prototype.Selector.select(selector, element || document);
- }
- });
-})();
diff --git a/public/javascripts/rails.js b/public/javascripts/rails.js
index aed6aed..e99d49e 100644
--- a/public/javascripts/rails.js
+++ b/public/javascripts/rails.js
@@ -1,191 +1,157 @@
-(function() {
- // Technique from Juriy Zaytsev
- // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
- function isEventSupported(eventName) {
- var el = document.createElement('div');
- eventName = 'on' + eventName;
- var isSupported = (eventName in el);
- if (!isSupported) {
- el.setAttribute(eventName, 'return;');
- isSupported = typeof el[eventName] == 'function';
- }
- el = null;
- return isSupported;
- }
-
- function isForm(element) {
- return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
- }
-
- function isInput(element) {
- if (Object.isElement(element)) {
- var name = element.nodeName.toUpperCase()
- return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
- }
- else return false
- }
-
- var submitBubbles = isEventSupported('submit'),
- changeBubbles = isEventSupported('change')
-
- if (!submitBubbles || !changeBubbles) {
- // augment the Event.Handler class to observe custom events when needed
- Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
- function(init, element, eventName, selector, callback) {
- init(element, eventName, selector, callback)
- // is the handler being attached to an element that doesn't support this event?
- if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
- (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
- // "submit" => "emulated:submit"
- this.eventName = 'emulated:' + this.eventName
- }
- }
- )
- }
-
- if (!submitBubbles) {
- // discover forms on the page by observing focus events which always bubble
- document.on('focusin', 'form', function(focusEvent, form) {
- // special handler for the real "submit" event (one-time operation)
- if (!form.retrieve('emulated:submit')) {
- form.on('submit', function(submitEvent) {
- var emulated = form.fire('emulated:submit', submitEvent, true)
- // if custom event received preventDefault, cancel the real one too
- if (emulated.returnValue === false) submitEvent.preventDefault()
- })
- form.store('emulated:submit', true)
- }
- })
- }
-
- if (!changeBubbles) {
- // discover form inputs on the page
- document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
- // special handler for real "change" events
- if (!input.retrieve('emulated:change')) {
- input.on('change', function(changeEvent) {
- input.fire('emulated:change', changeEvent, true)
- })
- input.store('emulated:change', true)
- }
- })
- }
-
- function handleRemote(element) {
- var method, url, params;
-
- var event = element.fire("ajax:before");
- if (event.stopped) return false;
-
- if (element.tagName.toLowerCase() === 'form') {
- method = element.readAttribute('method') || 'post';
- url = element.readAttribute('action');
- params = element.serialize();
- } else {
- method = element.readAttribute('data-method') || 'get';
- url = element.readAttribute('href');
- params = {};
- }
-
- new Ajax.Request(url, {
- method: method,
- parameters: params,
- evalScripts: true,
-
- onComplete: function(request) { element.fire("ajax:complete", request); },
- onSuccess: function(request) { element.fire("ajax:success", request); },
- onFailure: function(request) { element.fire("ajax:failure", request); }
- });
-
- element.fire("ajax:after");
- }
-
- function handleMethod(element) {
- var method = element.readAttribute('data-method'),
- url = element.readAttribute('href'),
- csrf_param = $$('meta[name=csrf-param]')[0],
- csrf_token = $$('meta[name=csrf-token]')[0];
-
- var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
- element.parentNode.insert(form);
-
- if (method !== 'post') {
- var field = new Element('input', { type: 'hidden', name: '_method', value: method });
- form.insert(field);
- }
-
- if (csrf_param) {
- var param = csrf_param.readAttribute('content'),
- token = csrf_token.readAttribute('content'),
- field = new Element('input', { type: 'hidden', name: param, value: token });
- form.insert(field);
- }
-
- form.submit();
- }
-
-
- document.on("click", "*[data-confirm]", function(event, element) {
- var message = element.readAttribute('data-confirm');
- if (!confirm(message)) event.stop();
- });
-
- document.on("click", "a[data-remote]", function(event, element) {
- if (event.stopped) return;
- handleRemote(element);
- event.stop();
- });
-
- document.on("click", "a[data-method]", function(event, element) {
- if (event.stopped) return;
- handleMethod(element);
- event.stop();
- });
-
- document.on("submit", function(event) {
- var element = event.findElement(),
- message = element.readAttribute('data-confirm');
- if (message && !confirm(message)) {
- event.stop();
- return false;
- }
-
- var inputs = element.select("input[type=submit][data-disable-with]");
- inputs.each(function(input) {
- input.disabled = true;
- input.writeAttribute('data-original-value', input.value);
- input.value = input.readAttribute('data-disable-with');
- });
-
- var element = event.findElement("form[data-remote]");
- if (element) {
- handleRemote(element);
- event.stop();
- }
- });
-
- document.on("ajax:after", "form", function(event, element) {
- var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
- inputs.each(function(input) {
- input.value = input.readAttribute('data-original-value');
- input.removeAttribute('data-original-value');
- input.disabled = false;
- });
- });
-
- Ajax.Responders.register({
- onCreate: function(request) {
- var csrf_meta_tag = $$('meta[name=csrf-token]')[0];
-
- if (csrf_meta_tag) {
- var header = 'X-CSRF-Token',
- token = csrf_meta_tag.readAttribute('content');
-
- if (!request.options.requestHeaders) {
- request.options.requestHeaders = {};
- }
- request.options.requestHeaders[header] = token;
- }
- }
- });
-})();
+/**
+ * Unobtrusive scripting adapter for jQuery
+ *
+ * Requires jQuery 1.4.3 or later.
+ * https://github.com/rails/jquery-ujs
+ */
+
+(function($) {
+ // Make sure that every Ajax request sends the CSRF token
+ function CSRFProtection(xhr) {
+ var token = $('meta[name="csrf-token"]').attr('content');
+ if (token) xhr.setRequestHeader('X-CSRF-Token', token);
+ }
+ if ('ajaxPrefilter' in $) $.ajaxPrefilter(function(options, originalOptions, xhr){ CSRFProtection(xhr) });
+ else $(document).ajaxSend(function(e, xhr){ CSRFProtection(xhr) });
+
+ // Triggers an event on an element and returns the event result
+ function fire(obj, name, data) {
+ var event = new $.Event(name);
+ obj.trigger(event, data);
+ return event.result !== false;
+ }
+
+ // Submits "remote" forms and links with ajax
+ function handleRemote(element) {
+ var method, url, data,
+ dataType = element.attr('data-type') || ($.ajaxSettings && $.ajaxSettings.dataType);
+
+ if (element.is('form')) {
+ method = element.attr('method');
+ url = element.attr('action');
+ data = element.serializeArray();
+ // memoized value from clicked submit button
+ var button = element.data('ujs:submit-button');
+ if (button) {
+ data.push(button);
+ element.data('ujs:submit-button', null);
+ }
+ } else {
+ method = element.attr('data-method');
+ url = element.attr('href');
+ data = null;
+ }
+
+ $.ajax({
+ url: url, type: method || 'GET', data: data, dataType: dataType,
+ // stopping the "ajax:beforeSend" event will cancel the ajax request
+ beforeSend: function(xhr, settings) {
+ if (settings.dataType === undefined) {
+ xhr.setRequestHeader('accept', '*/*;q=0.5, ' + settings.accepts.script);
+ }
+ return fire(element, 'ajax:beforeSend', [xhr, settings]);
+ },
+ success: function(data, status, xhr) {
+ element.trigger('ajax:success', [data, status, xhr]);
+ },
+ complete: function(xhr, status) {
+ element.trigger('ajax:complete', [xhr, status]);
+ },
+ error: function(xhr, status, error) {
+ element.trigger('ajax:error', [xhr, status, error]);
+ }
+ });
+ }
+
+ // Handles "data-method" on links such as:
+ // Delete
+ function handleMethod(link) {
+ var href = link.attr('href'),
+ method = link.attr('data-method'),
+ csrf_token = $('meta[name=csrf-token]').attr('content'),
+ csrf_param = $('meta[name=csrf-param]').attr('content'),
+ form = $(''),
+ metadata_input = '';
+
+ if (csrf_param !== undefined && csrf_token !== undefined) {
+ metadata_input += '';
+ }
+
+ form.hide().append(metadata_input).appendTo('body');
+ form.submit();
+ }
+
+ function disableFormElements(form) {
+ form.find('input[data-disable-with]').each(function() {
+ var input = $(this);
+ input.data('ujs:enable-with', input.val())
+ .val(input.attr('data-disable-with'))
+ .attr('disabled', 'disabled');
+ });
+ }
+
+ function enableFormElements(form) {
+ form.find('input[data-disable-with]').each(function() {
+ var input = $(this);
+ input.val(input.data('ujs:enable-with')).removeAttr('disabled');
+ });
+ }
+
+ function allowAction(element) {
+ var message = element.attr('data-confirm');
+ return !message || (fire(element, 'confirm') && confirm(message));
+ }
+
+ function requiredValuesMissing(form) {
+ var missing = false;
+ form.find('input[name][required]').each(function() {
+ if (!$(this).val()) missing = true;
+ });
+ return missing;
+ }
+
+ $('a[data-confirm], a[data-method], a[data-remote]').live('click.rails', function(e) {
+ var link = $(this);
+ if (!allowAction(link)) return false;
+
+ if (link.attr('data-remote') != undefined) {
+ handleRemote(link);
+ return false;
+ } else if (link.attr('data-method')) {
+ handleMethod(link);
+ return false;
+ }
+ });
+
+ $('form').live('submit.rails', function(e) {
+ var form = $(this), remote = form.attr('data-remote') != undefined;
+ if (!allowAction(form)) return false;
+
+ // skip other logic when required values are missing
+ if (requiredValuesMissing(form)) return !remote;
+
+ if (remote) {
+ handleRemote(form);
+ return false;
+ } else {
+ // slight timeout so that the submit button gets properly serialized
+ setTimeout(function(){ disableFormElements(form) }, 13);
+ }
+ });
+
+ $('form input[type=submit], form button[type=submit], form button:not([type])').live('click.rails', function() {
+ var button = $(this);
+ if (!allowAction(button)) return false;
+ // register the pressed submit button
+ var name = button.attr('name'), data = name ? {name:name, value:button.val()} : null;
+ button.closest('form').data('ujs:submit-button', data);
+ });
+
+ $('form').live('ajax:beforeSend.rails', function(event) {
+ if (this == event.target) disableFormElements($(this));
+ });
+
+ $('form').live('ajax:complete.rails', function(event) {
+ if (this == event.target) enableFormElements($(this));
+ });
+})( jQuery );
diff --git a/public/javascripts/sammy.js b/public/javascripts/sammy.js
new file mode 100644
index 0000000..d798892
--- /dev/null
+++ b/public/javascripts/sammy.js
@@ -0,0 +1,1829 @@
+// name: sammy
+// version: 0.6.3
+
+// Sammy.js / http://sammyjs.org
+
+(function($, window) {
+
+ var Sammy,
+ PATH_REPLACER = "([^\/]+)",
+ PATH_NAME_MATCHER = /:([\w\d]+)/g,
+ QUERY_STRING_MATCHER = /\?([^#]*)$/,
+ // mainly for making `arguments` an Array
+ _makeArray = function(nonarray) { return Array.prototype.slice.call(nonarray); },
+ // borrowed from jQuery
+ _isFunction = function( obj ) { return Object.prototype.toString.call(obj) === "[object Function]"; },
+ _isArray = function( obj ) { return Object.prototype.toString.call(obj) === "[object Array]"; },
+ _decode = function( str ) { return decodeURIComponent(str.replace(/\+/g, ' ')); },
+ _encode = encodeURIComponent,
+ _escapeHTML = function(s) {
+ return String(s).replace(/&(?!\w+;)/g, '&').replace(//g, '>').replace(/"/g, '"');
+ },
+ _routeWrapper = function(verb) {
+ return function(path, callback) { return this.route.apply(this, [verb, path, callback]); };
+ },
+ _template_cache = {},
+ loggers = [];
+
+
+ // `Sammy` (also aliased as $.sammy) is not only the namespace for a
+ // number of prototypes, its also a top level method that allows for easy
+ // creation/management of `Sammy.Application` instances. There are a
+ // number of different forms for `Sammy()` but each returns an instance
+ // of `Sammy.Application`. When a new instance is created using
+ // `Sammy` it is added to an Object called `Sammy.apps`. This
+ // provides for an easy way to get at existing Sammy applications. Only one
+ // instance is allowed per `element_selector` so when calling
+ // `Sammy('selector')` multiple times, the first time will create
+ // the application and the following times will extend the application
+ // already added to that selector.
+ //
+ // ### Example
+ //
+ // // returns the app at #main or a new app
+ // Sammy('#main')
+ //
+ // // equivilent to "new Sammy.Application", except appends to apps
+ // Sammy();
+ // Sammy(function() { ... });
+ //
+ // // extends the app at '#main' with function.
+ // Sammy('#main', function() { ... });
+ //
+ Sammy = function() {
+ var args = _makeArray(arguments),
+ app, selector;
+ Sammy.apps = Sammy.apps || {};
+ if (args.length === 0 || args[0] && _isFunction(args[0])) { // Sammy()
+ return Sammy.apply(Sammy, ['body'].concat(args));
+ } else if (typeof (selector = args.shift()) == 'string') { // Sammy('#main')
+ app = Sammy.apps[selector] || new Sammy.Application();
+ app.element_selector = selector;
+ if (args.length > 0) {
+ $.each(args, function(i, plugin) {
+ app.use(plugin);
+ });
+ }
+ // if the selector changes make sure the refrence in Sammy.apps changes
+ if (app.element_selector != selector) {
+ delete Sammy.apps[selector];
+ }
+ Sammy.apps[app.element_selector] = app;
+ return app;
+ }
+ };
+
+ Sammy.VERSION = '0.6.3';
+
+ // Add to the global logger pool. Takes a function that accepts an
+ // unknown number of arguments and should print them or send them somewhere
+ // The first argument is always a timestamp.
+ Sammy.addLogger = function(logger) {
+ loggers.push(logger);
+ };
+
+ // Sends a log message to each logger listed in the global
+ // loggers pool. Can take any number of arguments.
+ // Also prefixes the arguments with a timestamp.
+ Sammy.log = function() {
+ var args = _makeArray(arguments);
+ args.unshift("[" + Date() + "]");
+ $.each(loggers, function(i, logger) {
+ logger.apply(Sammy, args);
+ });
+ };
+
+ if (typeof window.console != 'undefined') {
+ if (_isFunction(window.console.log.apply)) {
+ Sammy.addLogger(function() {
+ window.console.log.apply(window.console, arguments);
+ });
+ } else {
+ Sammy.addLogger(function() {
+ window.console.log(arguments);
+ });
+ }
+ } else if (typeof console != 'undefined') {
+ Sammy.addLogger(function() {
+ console.log.apply(console, arguments);
+ });
+ }
+
+ $.extend(Sammy, {
+ makeArray: _makeArray,
+ isFunction: _isFunction,
+ isArray: _isArray
+ })
+
+ // Sammy.Object is the base for all other Sammy classes. It provides some useful
+ // functionality, including cloning, iterating, etc.
+ Sammy.Object = function(obj) { // constructor
+ return $.extend(this, obj || {});
+ };
+
+ $.extend(Sammy.Object.prototype, {
+
+ // Escape HTML in string, use in templates to prevent script injection.
+ // Also aliased as `h()`
+ escapeHTML: _escapeHTML,
+ h: _escapeHTML,
+
+ // Returns a copy of the object with Functions removed.
+ toHash: function() {
+ var json = {};
+ $.each(this, function(k,v) {
+ if (!_isFunction(v)) {
+ json[k] = v;
+ }
+ });
+ return json;
+ },
+
+ // Renders a simple HTML version of this Objects attributes.
+ // Does not render functions.
+ // For example. Given this Sammy.Object:
+ //
+ // var s = new Sammy.Object({first_name: 'Sammy', last_name: 'Davis Jr.'});
+ // s.toHTML()
+ // //=> 'first_name Sammy
last_name Davis Jr.
' + // + toHTML: function() { + var display = ""; + $.each(this, function(k, v) { + if (!_isFunction(v)) { + display += "" + k + " " + v + "
"; + } + }); + return display; + }, + + // Returns an array of keys for this object. If `attributes_only` + // is true will not return keys that map to a `function()` + keys: function(attributes_only) { + var keys = []; + for (var property in this) { + if (!_isFunction(this[property]) || !attributes_only) { + keys.push(property); + } + } + return keys; + }, + + // Checks if the object has a value at `key` and that the value is not empty + has: function(key) { + return this[key] && $.trim(this[key].toString()) != ''; + }, + + // convenience method to join as many arguments as you want + // by the first argument - useful for making paths + join: function() { + var args = _makeArray(arguments); + var delimiter = args.shift(); + return args.join(delimiter); + }, + + // Shortcut to Sammy.log + log: function() { + Sammy.log.apply(Sammy, arguments); + }, + + // Returns a string representation of this object. + // if `include_functions` is true, it will also toString() the + // methods of this object. By default only prints the attributes. + toString: function(include_functions) { + var s = []; + $.each(this, function(k, v) { + if (!_isFunction(v) || include_functions) { + s.push('"' + k + '": ' + v.toString()); + } + }); + return "Sammy.Object: {" + s.join(',') + "}"; + } + }); + + // The HashLocationProxy is the default location proxy for all Sammy applications. + // A location proxy is a prototype that conforms to a simple interface. The purpose + // of a location proxy is to notify the Sammy.Application its bound to when the location + // or 'external state' changes. The HashLocationProxy considers the state to be + // changed when the 'hash' (window.location.hash / '#') changes. It does this in two + // different ways depending on what browser you are using. The newest browsers + // (IE, Safari > 4, FF >= 3.6) support a 'onhashchange' DOM event, thats fired whenever + // the location.hash changes. In this situation the HashLocationProxy just binds + // to this event and delegates it to the application. In the case of older browsers + // a poller is set up to track changes to the hash. Unlike Sammy 0.3 or earlier, + // the HashLocationProxy allows the poller to be a global object, eliminating the + // need for multiple pollers even when thier are multiple apps on the page. + Sammy.HashLocationProxy = function(app, run_interval_every) { + this.app = app; + // set is native to false and start the poller immediately + this.is_native = false; + this._startPolling(run_interval_every); + }; + + Sammy.HashLocationProxy.prototype = { + + // bind the proxy events to the current app. + bind: function() { + var proxy = this, app = this.app; + $(window).bind('hashchange.' + this.app.eventNamespace(), function(e, non_native) { + // if we receive a native hash change event, set the proxy accordingly + // and stop polling + if (proxy.is_native === false && !non_native) { + Sammy.log('native hash change exists, using'); + proxy.is_native = true; + window.clearInterval(Sammy.HashLocationProxy._interval); + } + app.trigger('location-changed'); + }); + if (!Sammy.HashLocationProxy._bindings) { + Sammy.HashLocationProxy._bindings = 0; + } + Sammy.HashLocationProxy._bindings++; + }, + + // unbind the proxy events from the current app + unbind: function() { + $(window).unbind('hashchange.' + this.app.eventNamespace()); + Sammy.HashLocationProxy._bindings--; + if (Sammy.HashLocationProxy._bindings <= 0) { + window.clearInterval(Sammy.HashLocationProxy._interval); + } + }, + + // get the current location from the hash. + getLocation: function() { + // Bypass the `window.location.hash` attribute. If a question mark + // appears in the hash IE6 will strip it and all of the following + // characters from `window.location.hash`. + var matches = window.location.toString().match(/^[^#]*(#.+)$/); + return matches ? matches[1] : ''; + }, + + // set the current location to `new_location` + setLocation: function(new_location) { + return (window.location = new_location); + }, + + _startPolling: function(every) { + // set up interval + var proxy = this; + if (!Sammy.HashLocationProxy._interval) { + if (!every) { every = 10; } + var hashCheck = function() { + var current_location = proxy.getLocation(); + if (!Sammy.HashLocationProxy._last_location || + current_location != Sammy.HashLocationProxy._last_location) { + window.setTimeout(function() { + $(window).trigger('hashchange', [true]); + }, 13); + } + Sammy.HashLocationProxy._last_location = current_location; + }; + hashCheck(); + Sammy.HashLocationProxy._interval = window.setInterval(hashCheck, every); + } + } + }; + + + // Sammy.Application is the Base prototype for defining 'applications'. + // An 'application' is a collection of 'routes' and bound events that is + // attached to an element when `run()` is called. + // The only argument an 'app_function' is evaluated within the context of the application. + Sammy.Application = function(app_function) { + var app = this; + this.routes = {}; + this.listeners = new Sammy.Object({}); + this.arounds = []; + this.befores = []; + // generate a unique namespace + this.namespace = (new Date()).getTime() + '-' + parseInt(Math.random() * 1000, 10); + this.context_prototype = function() { Sammy.EventContext.apply(this, arguments); }; + this.context_prototype.prototype = new Sammy.EventContext(); + + if (_isFunction(app_function)) { + app_function.apply(this, [this]); + } + // set the location proxy if not defined to the default (HashLocationProxy) + if (!this._location_proxy) { + this.setLocationProxy(new Sammy.HashLocationProxy(this, this.run_interval_every)); + } + if (this.debug) { + this.bindToAllEvents(function(e, data) { + app.log(app.toString(), e.cleaned_type, data || {}); + }); + } + }; + + Sammy.Application.prototype = $.extend({}, Sammy.Object.prototype, { + + // the four route verbs + ROUTE_VERBS: ['get','post','put','delete'], + + // An array of the default events triggered by the + // application during its lifecycle + APP_EVENTS: ['run', 'unload', 'lookup-route', 'run-route', 'route-found', 'event-context-before', 'event-context-after', 'changed', 'error', 'check-form-submission', 'redirect', 'location-changed'], + + _last_route: null, + _location_proxy: null, + _running: false, + + // Defines what element the application is bound to. Provide a selector + // (parseable by `jQuery()`) and this will be used by `$element()` + element_selector: 'body', + + // When set to true, logs all of the default events using `log()` + debug: false, + + // When set to true, and the error() handler is not overriden, will actually + // raise JS errors in routes (500) and when routes can't be found (404) + raise_errors: false, + + // The time in milliseconds that the URL is queried for changes + run_interval_every: 50, + + // The default template engine to use when using `partial()` in an + // `EventContext`. `template_engine` can either be a string that + // corresponds to the name of a method/helper on EventContext or it can be a function + // that takes two arguments, the content of the unrendered partial and an optional + // JS object that contains interpolation data. Template engine is only called/refered + // to if the extension of the partial is null or unknown. See `partial()` + // for more information + template_engine: null, + + // //=> Sammy.Application: body + toString: function() { + return 'Sammy.Application:' + this.element_selector; + }, + + // returns a jQuery object of the Applications bound element. + $element: function(selector) { + return selector ? $(this.element_selector).find(selector) : $(this.element_selector); + }, + + // `use()` is the entry point for including Sammy plugins. + // The first argument to use should be a function() that is evaluated + // in the context of the current application, just like the `app_function` + // argument to the `Sammy.Application` constructor. + // + // Any additional arguments are passed to the app function sequentially. + // + // For much more detail about plugins, check out: + // [http://sammyjs.org/docs/plugins](http://sammyjs.org/docs/plugins) + // + // ### Example + // + // var MyPlugin = function(app, prepend) { + // + // this.helpers({ + // myhelper: function(text) { + // alert(prepend + " " + text); + // } + // }); + // + // }; + // + // var app = $.sammy(function() { + // + // this.use(MyPlugin, 'This is my plugin'); + // + // this.get('#/', function() { + // this.myhelper('and dont you forget it!'); + // //=> Alerts: This is my plugin and dont you forget it! + // }); + // + // }); + // + // If plugin is passed as a string it assumes your are trying to load + // Sammy."Plugin". This is the prefered way of loading core Sammy plugins + // as it allows for better error-messaging. + // + // ### Example + // + // $.sammy(function() { + // this.use('Mustache'); //=> Sammy.Mustache + // this.use('Storage'); //=> Sammy.Storage + // }); + // + use: function() { + // flatten the arguments + var args = _makeArray(arguments), + plugin = args.shift(), + plugin_name = plugin || ''; + try { + args.unshift(this); + if (typeof plugin == 'string') { + plugin_name = 'Sammy.' + plugin; + plugin = Sammy[plugin]; + } + plugin.apply(this, args); + } catch(e) { + if (typeof plugin === 'undefined') { + this.error("Plugin Error: called use() but plugin (" + plugin_name.toString() + ") is not defined", e); + } else if (!_isFunction(plugin)) { + this.error("Plugin Error: called use() but '" + plugin_name.toString() + "' is not a function", e); + } else { + this.error("Plugin Error", e); + } + } + return this; + }, + + // Sets the location proxy for the current app. By default this is set to + // a new `Sammy.HashLocationProxy` on initialization. However, you can set + // the location_proxy inside you're app function to give your app a custom + // location mechanism. See `Sammy.HashLocationProxy` and `Sammy.DataLocationProxy` + // for examples. + // + // `setLocationProxy()` takes an initialized location proxy. + // + // ### Example + // + // // to bind to data instead of the default hash; + // var app = $.sammy(function() { + // this.setLocationProxy(new Sammy.DataLocationProxy(this)); + // }); + // + setLocationProxy: function(new_proxy) { + var original_proxy = this._location_proxy; + this._location_proxy = new_proxy; + if (this.isRunning()) { + if (original_proxy) { + // if there is already a location proxy, unbind it. + original_proxy.unbind(); + } + this._location_proxy.bind(); + } + }, + + // `route()` is the main method for defining routes within an application. + // For great detail on routes, check out: + // [http://sammyjs.org/docs/routes](http://sammyjs.org/docs/routes) + // + // This method also has aliases for each of the different verbs (eg. `get()`, `post()`, etc.) + // + // ### Arguments + // + // * `verb` A String in the set of ROUTE_VERBS or 'any'. 'any' will add routes for each + // of the ROUTE_VERBS. If only two arguments are passed, + // the first argument is the path, the second is the callback and the verb + // is assumed to be 'any'. + // * `path` A Regexp or a String representing the path to match to invoke this verb. + // * `callback` A Function that is called/evaluated whent the route is run see: `runRoute()`. + // It is also possible to pass a string as the callback, which is looked up as the name + // of a method on the application. + // + route: function(verb, path, callback) { + var app = this, param_names = [], add_route, path_match; + + // if the method signature is just (path, callback) + // assume the verb is 'any' + if (!callback && _isFunction(path)) { + path = verb; + callback = path; + verb = 'any'; + } + + verb = verb.toLowerCase(); // ensure verb is lower case + + // if path is a string turn it into a regex + if (path.constructor == String) { + + // Needs to be explicitly set because IE will maintain the index unless NULL is returned, + // which means that with two consecutive routes that contain params, the second set of params will not be found and end up in splat instead of params + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/RegExp/lastIndex + PATH_NAME_MATCHER.lastIndex = 0; + + // find the names + while ((path_match = PATH_NAME_MATCHER.exec(path)) !== null) { + param_names.push(path_match[1]); + } + // replace with the path replacement + path = new RegExp("^" + path.replace(PATH_NAME_MATCHER, PATH_REPLACER) + "$"); + } + // lookup callback + if (typeof callback == 'string') { + callback = app[callback]; + } + + add_route = function(with_verb) { + var r = {verb: with_verb, path: path, callback: callback, param_names: param_names}; + // add route to routes array + app.routes[with_verb] = app.routes[with_verb] || []; + // place routes in order of definition + app.routes[with_verb].push(r); + }; + + if (verb === 'any') { + $.each(this.ROUTE_VERBS, function(i, v) { add_route(v); }); + } else { + add_route(verb); + } + + // return the app + return this; + }, + + // Alias for route('get', ...) + get: _routeWrapper('get'), + + // Alias for route('post', ...) + post: _routeWrapper('post'), + + // Alias for route('put', ...) + put: _routeWrapper('put'), + + // Alias for route('delete', ...) + del: _routeWrapper('delete'), + + // Alias for route('any', ...) + any: _routeWrapper('any'), + + // `mapRoutes` takes an array of arrays, each array being passed to route() + // as arguments, this allows for mass definition of routes. Another benefit is + // this makes it possible/easier to load routes via remote JSON. + // + // ### Example + // + // var app = $.sammy(function() { + // + // this.mapRoutes([ + // ['get', '#/', function() { this.log('index'); }], + // // strings in callbacks are looked up as methods on the app + // ['post', '#/create', 'addUser'], + // // No verb assumes 'any' as the verb + // [/dowhatever/, function() { this.log(this.verb, this.path)}]; + // ]); + // }); + // + mapRoutes: function(route_array) { + var app = this; + $.each(route_array, function(i, route_args) { + app.route.apply(app, route_args); + }); + return this; + }, + + // A unique event namespace defined per application. + // All events bound with `bind()` are automatically bound within this space. + eventNamespace: function() { + return ['sammy-app', this.namespace].join('-'); + }, + + // Works just like `jQuery.fn.bind()` with a couple noteable differences. + // + // * It binds all events to the application element + // * All events are bound within the `eventNamespace()` + // * Events are not actually bound until the application is started with `run()` + // * callbacks are evaluated within the context of a Sammy.EventContext + // + bind: function(name, data, callback) { + var app = this; + // build the callback + // if the arity is 2, callback is the second argument + if (typeof callback == 'undefined') { callback = data; } + var listener_callback = function() { + // pull off the context from the arguments to the callback + var e, context, data; + e = arguments[0]; + data = arguments[1]; + if (data && data.context) { + context = data.context; + delete data.context; + } else { + context = new app.context_prototype(app, 'bind', e.type, data, e.target); + } + e.cleaned_type = e.type.replace(app.eventNamespace(), ''); + callback.apply(context, [e, data]); + }; + + // it could be that the app element doesnt exist yet + // so attach to the listeners array and then run() + // will actually bind the event. + if (!this.listeners[name]) { this.listeners[name] = []; } + this.listeners[name].push(listener_callback); + if (this.isRunning()) { + // if the app is running + // *actually* bind the event to the app element + this._listen(name, listener_callback); + } + return this; + }, + + // Triggers custom events defined with `bind()` + // + // ### Arguments + // + // * `name` The name of the event. Automatically prefixed with the `eventNamespace()` + // * `data` An optional Object that can be passed to the bound callback. + // * `context` An optional context/Object in which to execute the bound callback. + // If no context is supplied a the context is a new `Sammy.EventContext` + // + trigger: function(name, data) { + this.$element().trigger([name, this.eventNamespace()].join('.'), [data]); + return this; + }, + + // Reruns the current route + refresh: function() { + this.last_location = null; + this.trigger('location-changed'); + return this; + }, + + // Takes a single callback that is pushed on to a stack. + // Before any route is run, the callbacks are evaluated in order within + // the current `Sammy.EventContext` + // + // If any of the callbacks explicitly return false, execution of any + // further callbacks and the route itself is halted. + // + // You can also provide a set of options that will define when to run this + // before based on the route it proceeds. + // + // ### Example + // + // var app = $.sammy(function() { + // + // // will run at #/route but not at #/ + // this.before('#/route', function() { + // //... + // }); + // + // // will run at #/ but not at #/route + // this.before({except: {path: '#/route'}}, function() { + // this.log('not before #/route'); + // }); + // + // this.get('#/', function() {}); + // + // this.get('#/route', function() {}); + // + // }); + // + // See `contextMatchesOptions()` for a full list of supported options + // + before: function(options, callback) { + if (_isFunction(options)) { + callback = options; + options = {}; + } + this.befores.push([options, callback]); + return this; + }, + + // A shortcut for binding a callback to be run after a route is executed. + // After callbacks have no guarunteed order. + after: function(callback) { + return this.bind('event-context-after', callback); + }, + + + // Adds an around filter to the application. around filters are functions + // that take a single argument `callback` which is the entire route + // execution path wrapped up in a closure. This means you can decide whether + // or not to proceed with execution by not invoking `callback` or, + // more usefuly wrapping callback inside the result of an asynchronous execution. + // + // ### Example + // + // The most common use case for around() is calling a _possibly_ async function + // and executing the route within the functions callback: + // + // var app = $.sammy(function() { + // + // var current_user = false; + // + // function checkLoggedIn(callback) { + // // /session returns a JSON representation of the logged in user + // // or an empty object + // if (!current_user) { + // $.getJSON('/session', function(json) { + // if (json.login) { + // // show the user as logged in + // current_user = json; + // // execute the route path + // callback(); + // } else { + // // show the user as not logged in + // current_user = false; + // // the context of aroundFilters is an EventContext + // this.redirect('#/login'); + // } + // }); + // } else { + // // execute the route path + // callback(); + // } + // }; + // + // this.around(checkLoggedIn); + // + // }); + // + around: function(callback) { + this.arounds.push(callback); + return this; + }, + + // Returns `true` if the current application is running. + isRunning: function() { + return this._running; + }, + + // Helpers extends the EventContext prototype specific to this app. + // This allows you to define app specific helper functions that can be used + // whenever you're inside of an event context (templates, routes, bind). + // + // ### Example + // + // var app = $.sammy(function() { + // + // helpers({ + // upcase: function(text) { + // return text.toString().toUpperCase(); + // } + // }); + // + // get('#/', function() { with(this) { + // // inside of this context I can use the helpers + // $('#main').html(upcase($('#main').text()); + // }}); + // + // }); + // + // + // ### Arguments + // + // * `extensions` An object collection of functions to extend the context. + // + helpers: function(extensions) { + $.extend(this.context_prototype.prototype, extensions); + return this; + }, + + // Helper extends the event context just like `helpers()` but does it + // a single method at a time. This is especially useful for dynamically named + // helpers + // + // ### Example + // + // // Trivial example that adds 3 helper methods to the context dynamically + // var app = $.sammy(function(app) { + // + // $.each([1,2,3], function(i, num) { + // app.helper('helper' + num, function() { + // this.log("I'm helper number " + num); + // }); + // }); + // + // this.get('#/', function() { + // this.helper2(); //=> I'm helper number 2 + // }); + // }); + // + // ### Arguments + // + // * `name` The name of the method + // * `method` The function to be added to the prototype at `name` + // + helper: function(name, method) { + this.context_prototype.prototype[name] = method; + return this; + }, + + // Actually starts the application's lifecycle. `run()` should be invoked + // within a document.ready block to ensure the DOM exists before binding events, etc. + // + // ### Example + // + // var app = $.sammy(function() { ... }); // your application + // $(function() { // document.ready + // app.run(); + // }); + // + // ### Arguments + // + // * `start_url` Optionally, a String can be passed which the App will redirect to + // after the events/routes have been bound. + run: function(start_url) { + if (this.isRunning()) { return false; } + var app = this; + + // actually bind all the listeners + $.each(this.listeners.toHash(), function(name, callbacks) { + $.each(callbacks, function(i, listener_callback) { + app._listen(name, listener_callback); + }); + }); + + this.trigger('run', {start_url: start_url}); + this._running = true; + // set last location + this.last_location = null; + if (this.getLocation() == '' && typeof start_url != 'undefined') { + this.setLocation(start_url); + } + // check url + this._checkLocation(); + this._location_proxy.bind(); + this.bind('location-changed', function() { + app._checkLocation(); + }); + + // bind to submit to capture post/put/delete routes + this.bind('submit', function(e) { + var returned = app._checkFormSubmission($(e.target).closest('form')); + return (returned === false) ? e.preventDefault() : false; + }); + + // bind unload to body unload + $(window).bind('beforeunload', function() { + app.unload(); + }); + + // trigger html changed + return this.trigger('changed'); + }, + + // The opposite of `run()`, un-binds all event listeners and intervals + // `run()` Automaticaly binds a `onunload` event to run this when + // the document is closed. + unload: function() { + if (!this.isRunning()) { return false; } + var app = this; + this.trigger('unload'); + // clear interval + this._location_proxy.unbind(); + // unbind form submits + this.$element().unbind('submit').removeClass(app.eventNamespace()); + // unbind all events + $.each(this.listeners.toHash() , function(name, listeners) { + $.each(listeners, function(i, listener_callback) { + app._unlisten(name, listener_callback); + }); + }); + this._running = false; + return this; + }, + + // Will bind a single callback function to every event that is already + // being listened to in the app. This includes all the `APP_EVENTS` + // as well as any custom events defined with `bind()`. + // + // Used internally for debug logging. + bindToAllEvents: function(callback) { + var app = this; + // bind to the APP_EVENTS first + $.each(this.APP_EVENTS, function(i, e) { + app.bind(e, callback); + }); + // next, bind to listener names (only if they dont exist in APP_EVENTS) + $.each(this.listeners.keys(true), function(i, name) { + if (app.APP_EVENTS.indexOf(name) == -1) { + app.bind(name, callback); + } + }); + return this; + }, + + // Returns a copy of the given path with any query string after the hash + // removed. + routablePath: function(path) { + return path.replace(QUERY_STRING_MATCHER, ''); + }, + + // Given a verb and a String path, will return either a route object or false + // if a matching route can be found within the current defined set. + lookupRoute: function(verb, path) { + var app = this, routed = false; + this.trigger('lookup-route', {verb: verb, path: path}); + if (typeof this.routes[verb] != 'undefined') { + $.each(this.routes[verb], function(i, route) { + if (app.routablePath(path).match(route.path)) { + routed = route; + return false; + } + }); + } + return routed; + }, + + // First, invokes `lookupRoute()` and if a route is found, parses the + // possible URL params and then invokes the route's callback within a new + // `Sammy.EventContext`. If the route can not be found, it calls + // `notFound()`. If `raise_errors` is set to `true` and + // the `error()` has not been overriden, it will throw an actual JS + // error. + // + // You probably will never have to call this directly. + // + // ### Arguments + // + // * `verb` A String for the verb. + // * `path` A String path to lookup. + // * `params` An Object of Params pulled from the URI or passed directly. + // + // ### Returns + // + // Either returns the value returned by the route callback or raises a 404 Not Found error. + // + runRoute: function(verb, path, params, target) { + var app = this, + route = this.lookupRoute(verb, path), + context, + wrapped_route, + arounds, + around, + befores, + before, + callback_args, + path_params, + final_returned; + + this.log('runRoute', [verb, path].join(' ')); + this.trigger('run-route', {verb: verb, path: path, params: params}); + if (typeof params == 'undefined') { params = {}; } + + $.extend(params, this._parseQueryString(path)); + + if (route) { + this.trigger('route-found', {route: route}); + // pull out the params from the path + if ((path_params = route.path.exec(this.routablePath(path))) !== null) { + // first match is the full path + path_params.shift(); + // for each of the matches + $.each(path_params, function(i, param) { + // if theres a matching param name + if (route.param_names[i]) { + // set the name to the match + params[route.param_names[i]] = _decode(param); + } else { + // initialize 'splat' + if (!params.splat) { params.splat = []; } + params.splat.push(_decode(param)); + } + }); + } + + // set event context + context = new this.context_prototype(this, verb, path, params, target); + // ensure arrays + arounds = this.arounds.slice(0); + befores = this.befores.slice(0); + // set the callback args to the context + contents of the splat + callback_args = [context].concat(params.splat); + // wrap the route up with the before filters + wrapped_route = function() { + var returned; + while (befores.length > 0) { + before = befores.shift(); + // check the options + if (app.contextMatchesOptions(context, before[0])) { + returned = before[1].apply(context, [context]); + if (returned === false) { return false; } + } + } + app.last_route = route; + context.trigger('event-context-before', {context: context}); + returned = route.callback.apply(context, callback_args); + context.trigger('event-context-after', {context: context}); + return returned; + }; + $.each(arounds.reverse(), function(i, around) { + var last_wrapped_route = wrapped_route; + wrapped_route = function() { return around.apply(context, [last_wrapped_route]); }; + }); + try { + final_returned = wrapped_route(); + } catch(e) { + this.error(['500 Error', verb, path].join(' '), e); + } + return final_returned; + } else { + return this.notFound(verb, path); + } + }, + + // Matches an object of options against an `EventContext` like object that + // contains `path` and `verb` attributes. Internally Sammy uses this + // for matching `before()` filters against specific options. You can set the + // object to _only_ match certain paths or verbs, or match all paths or verbs _except_ + // those that match the options. + // + // ### Example + // + // var app = $.sammy(), + // context = {verb: 'get', path: '#/mypath'}; + // + // // match against a path string + // app.contextMatchesOptions(context, '#/mypath'); //=> true + // app.contextMatchesOptions(context, '#/otherpath'); //=> false + // // equivilent to + // app.contextMatchesOptions(context, {only: {path:'#/mypath'}}); //=> true + // app.contextMatchesOptions(context, {only: {path:'#/otherpath'}}); //=> false + // // match against a path regexp + // app.contextMatchesOptions(context, /path/); //=> true + // app.contextMatchesOptions(context, /^path/); //=> false + // // match only a verb + // app.contextMatchesOptions(context, {only: {verb:'get'}}); //=> true + // app.contextMatchesOptions(context, {only: {verb:'post'}}); //=> false + // // match all except a verb + // app.contextMatchesOptions(context, {except: {verb:'post'}}); //=> true + // app.contextMatchesOptions(context, {except: {verb:'get'}}); //=> false + // // match all except a path + // app.contextMatchesOptions(context, {except: {path:'#/otherpath'}}); //=> true + // app.contextMatchesOptions(context, {except: {path:'#/mypath'}}); //=> false + // + contextMatchesOptions: function(context, match_options, positive) { + // empty options always match + var options = match_options; + if (typeof options === 'undefined' || options == {}) { + return true; + } + if (typeof positive === 'undefined') { + positive = true; + } + // normalize options + if (typeof options === 'string' || _isFunction(options.test)) { + options = {path: options}; + } + if (options.only) { + return this.contextMatchesOptions(context, options.only, true); + } else if (options.except) { + return this.contextMatchesOptions(context, options.except, false); + } + var path_matched = true, verb_matched = true; + if (options.path) { + // wierd regexp test + if (_isFunction(options.path.test)) { + path_matched = options.path.test(context.path); + } else { + path_matched = (options.path.toString() === context.path); + } + } + if (options.verb) { + verb_matched = options.verb === context.verb; + } + return positive ? (verb_matched && path_matched) : !(verb_matched && path_matched); + }, + + + // Delegates to the `location_proxy` to get the current location. + // See `Sammy.HashLocationProxy` for more info on location proxies. + getLocation: function() { + return this._location_proxy.getLocation(); + }, + + // Delegates to the `location_proxy` to set the current location. + // See `Sammy.HashLocationProxy` for more info on location proxies. + // + // ### Arguments + // + // * `new_location` A new location string (e.g. '#/') + // + setLocation: function(new_location) { + return this._location_proxy.setLocation(new_location); + }, + + // Swaps the content of `$element()` with `content` + // You can override this method to provide an alternate swap behavior + // for `EventContext.partial()`. + // + // ### Example + // + // var app = $.sammy(function() { + // + // // implements a 'fade out'/'fade in' + // this.swap = function(content) { + // this.$element().hide('slow').html(content).show('slow'); + // } + // + // get('#/', function() { + // this.partial('index.html.erb') // will fade out and in + // }); + // + // }); + // + swap: function(content) { + return this.$element().html(content); + }, + + // a simple global cache for templates. Uses the same semantics as + // `Sammy.Cache` and `Sammy.Storage` so can easily be replaced with + // a persistant storage that lasts beyond the current request. + templateCache: function(key, value) { + if (typeof value != 'undefined') { + return _template_cache[key] = value; + } else { + return _template_cache[key]; + } + }, + + // clear the templateCache + clearTemplateCache: function() { + return _template_cache = {}; + }, + + // This thows a '404 Not Found' error by invoking `error()`. + // Override this method or `error()` to provide custom + // 404 behavior (i.e redirecting to / or showing a warning) + notFound: function(verb, path) { + var ret = this.error(['404 Not Found', verb, path].join(' ')); + return (verb === 'get') ? ret : true; + }, + + // The base error handler takes a string `message` and an `Error` + // object. If `raise_errors` is set to `true` on the app level, + // this will re-throw the error to the browser. Otherwise it will send the error + // to `log()`. Override this method to provide custom error handling + // e.g logging to a server side component or displaying some feedback to the + // user. + error: function(message, original_error) { + if (!original_error) { original_error = new Error(); } + original_error.message = [message, original_error.message].join(' '); + this.trigger('error', {message: original_error.message, error: original_error}); + if (this.raise_errors) { + throw(original_error); + } else { + this.log(original_error.message, original_error); + } + }, + + _checkLocation: function() { + var location, returned; + // get current location + location = this.getLocation(); + // compare to see if hash has changed + if (!this.last_location || this.last_location[0] != 'get' || this.last_location[1] != location) { + // reset last location + this.last_location = ['get', location]; + // lookup route for current hash + returned = this.runRoute('get', location); + } + return returned; + }, + + _getFormVerb: function(form) { + var $form = $(form), verb, $_method; + $_method = $form.find('input[name="_method"]'); + if ($_method.length > 0) { verb = $_method.val(); } + if (!verb) { verb = $form[0].getAttribute('method'); } + if (!verb || verb == '') { verb = 'get'; } + return $.trim(verb.toString().toLowerCase()); + }, + + _checkFormSubmission: function(form) { + var $form, path, verb, params, returned; + this.trigger('check-form-submission', {form: form}); + $form = $(form); + path = $form.attr('action'); + verb = this._getFormVerb($form); + this.log('_checkFormSubmission', $form, path, verb); + if (verb === 'get') { + this.setLocation(path + '?' + this._serializeFormParams($form)); + returned = false; + } else { + params = $.extend({}, this._parseFormParams($form)); + returned = this.runRoute(verb, path, params, form.get(0)); + }; + return (typeof returned == 'undefined') ? false : returned; + }, + + _serializeFormParams: function($form) { + var queryString = "", + fields = $form.serializeArray(), + i; + if (fields.length > 0) { + queryString = this._encodeFormPair(fields[0].name, fields[0].value); + for (i = 1; i < fields.length; i++) { + queryString = queryString + "&" + this._encodeFormPair(fields[i].name, fields[i].value); + } + } + return queryString; + }, + + _encodeFormPair: function(name, value){ + return _encode(name) + "=" + _encode(value); + }, + + _parseFormParams: function($form) { + var params = {}, + form_fields = $form.serializeArray(), + i; + for (i = 0; i < form_fields.length; i++) { + params = this._parseParamPair(params, form_fields[i].name, form_fields[i].value); + } + return params; + }, + + _parseQueryString: function(path) { + var params = {}, parts, pairs, pair, i; + + parts = path.match(QUERY_STRING_MATCHER); + if (parts) { + pairs = parts[1].split('&'); + for (i = 0; i < pairs.length; i++) { + pair = pairs[i].split('='); + params = this._parseParamPair(params, _decode(pair[0]), _decode(pair[1] || "")); + } + } + return params; + }, + + _parseParamPair: function(params, key, value) { + if (params[key]) { + if (_isArray(params[key])) { + params[key].push(value); + } else { + params[key] = [params[key], value]; + } + } else { + params[key] = value; + } + return params; + }, + + _listen: function(name, callback) { + return this.$element().bind([name, this.eventNamespace()].join('.'), callback); + }, + + _unlisten: function(name, callback) { + return this.$element().unbind([name, this.eventNamespace()].join('.'), callback); + } + + }); + + // `Sammy.RenderContext` is an object that makes sequential template loading, + // rendering and interpolation seamless even when dealing with asyncronous + // operations. + // + // `RenderContext` objects are not usually created directly, rather they are + // instatiated from an `Sammy.EventContext` by using `render()`, `load()` or + // `partial()` which all return `RenderContext` objects. + // + // `RenderContext` methods always returns a modified `RenderContext` + // for chaining (like jQuery itself). + // + // The core magic is in the `then()` method which puts the callback passed as + // an argument into a queue to be executed once the previous callback is complete. + // All the methods of `RenderContext` are wrapped in `then()` which allows you + // to queue up methods by chaining, but maintaing a guarunteed execution order + // even with remote calls to fetch templates. + // + Sammy.RenderContext = function(event_context) { + this.event_context = event_context; + this.callbacks = []; + this.previous_content = null; + this.content = null; + this.next_engine = false; + this.waiting = false; + }; + + Sammy.RenderContext.prototype = $.extend({}, Sammy.Object.prototype, { + + // The "core" of the `RenderContext` object, adds the `callback` to the + // queue. If the context is `waiting` (meaning an async operation is happening) + // then the callback will be executed in order, once the other operations are + // complete. If there is no currently executing operation, the `callback` + // is executed immediately. + // + // The value returned from the callback is stored in `content` for the + // subsiquent operation. If you return `false`, the queue will pause, and + // the next callback in the queue will not be executed until `next()` is + // called. This allows for the guarunteed order of execution while working + // with async operations. + // + // If then() is passed a string instead of a function, the string is looked + // up as a helper method on the event context. + // + // ### Example + // + // this.get('#/', function() { + // // initialize the RenderContext + // // Even though `load()` executes async, the next `then()` + // // wont execute until the load finishes + // this.load('myfile.txt') + // .then(function(content) { + // // the first argument to then is the content of the + // // prev operation + // $('#main').html(content); + // }); + // }); + // + then: function(callback) { + if (!_isFunction(callback)) { + // if a string is passed to then, assume we want to call + // a helper on the event context in its context + if (typeof callback === 'string' && callback in this.event_context) { + var helper = this.event_context[callback]; + callback = function(content) { + return helper.apply(this.event_context, [content]); + }; + } else { + return this; + } + } + var context = this; + if (this.waiting) { + this.callbacks.push(callback); + } else { + this.wait(); + window.setTimeout(function() { + var returned = callback.apply(context, [context.content, context.previous_content]); + if (returned !== false) { + context.next(returned); + } + }, 13); + } + return this; + }, + + // Pause the `RenderContext` queue. Combined with `next()` allows for async + // operations. + // + // ### Example + // + // this.get('#/', function() { + // this.load('mytext.json') + // .then(function(content) { + // var context = this, + // data = JSON.parse(content); + // // pause execution + // context.wait(); + // // post to a url + // $.post(data.url, {}, function(response) { + // context.next(JSON.parse(response)); + // }); + // }) + // .then(function(data) { + // // data is json from the previous post + // $('#message').text(data.status); + // }); + // }); + wait: function() { + this.waiting = true; + }, + + // Resume the queue, setting `content` to be used in the next operation. + // See `wait()` for an example. + next: function(content) { + this.waiting = false; + if (typeof content !== 'undefined') { + this.previous_content = this.content; + this.content = content; + } + if (this.callbacks.length > 0) { + this.then(this.callbacks.shift()); + } + }, + + // Load a template into the context. + // The `location` can either be a string specifiying the remote path to the + // file, a jQuery object, or a DOM element. + // + // No interpolation happens by default, the content is stored in + // `content`. + // + // In the case of a path, unless the option `{cache: false}` is passed the + // data is stored in the app's `templateCache()`. + // + // If a jQuery or DOM object is passed the `innerHTML` of the node is pulled in. + // This is useful for nesting templates as part of the initial page load wrapped + // in invisible elements or `
\{\{title\}\}
+ //
+ // Hey, {{name}}! Welcome to Mustache!
+ //
+ // The app:
+ //
+ // var $.app = $.sammy(function() {
+ // // include the plugin and alias mustache() to ms()
+ // this.use(Sammy.Mustache, 'ms');
+ //
+ // this.get('#/hello/:name', function() {
+ // // set local vars
+ // this.title = 'Hello!'
+ // this.name = this.params.name;
+ // // render the template and pass it through mustache
+ // this.partial('mytemplate.ms');
+ // });
+ //
+ // });
+ //
+ // If I go to #/hello/AQ in the browser, Sammy will render this to the body:
+ //
+ // Hello!
+ //
+ // Hey, AQ! Welcome to Mustache!
+ //
+ //
+ // ### Example #2 - Mustache partials
+ //
+ // The template (mytemplate.ms)
+ //
+ // Hey, {{name}}! {{>hello_friend}}
+ //
+ //
+ // The partial (mypartial.ms)
+ //
+ // Say hello to your friend {{friend}}!
+ //
+ // The app:
+ //
+ // var $.app = $.sammy(function() {
+ // // include the plugin and alias mustache() to ms()
+ // this.use(Sammy.Mustache, 'ms');
+ //
+ // this.get('#/hello/:name/to/:friend', function() {
+ // var context = this;
+ //
+ // // fetch mustache-partial first
+ // $.get('mypartial.ms', function(response){
+ // context.partials = response;
+ //
+ // // set local vars
+ // context.name = this.params.name;
+ // context.hello_friend = {name: this.params.friend};
+ //
+ // // render the template and pass it through mustache
+ // context.partial('mytemplate.ms');
+ // });
+ // });
+ //
+ // });
+ //
+ // If I go to #/hello/AQ/to/dP in the browser, Sammy will render this to the body:
+ //
+ // Hey, AQ! Say hello to your friend dP!
+ //
+ // Note: You dont have to include the mustache.js file on top of the plugin as the plugin
+ // includes the full source.
+ //
+ Sammy.Mustache = function(app, method_alias) {
+
+ // *Helper* Uses Mustache.js to parse a template and interpolate and work with the passed data
+ //
+ // ### Arguments
+ //
+ // * `template` A String template. {{}} Tags are evaluated and interpolated by Mustache.js
+ // * `data` An Object containing the replacement values for the template.
+ // data is extended with the EventContext allowing you to call its methods within the template.
+ // * `partials` An Object containing one or more partials (String templates
+ // that are called from the main template).
+ //
+ var mustache = function(template, data, partials) {
+ data = $.extend({}, this, data);
+ partials = $.extend({}, data.partials, partials);
+ return Mustache.to_html(template, data, partials);
+ };
+
+ // set the default method name/extension
+ if (!method_alias) method_alias = 'mustache';
+ app.helper(method_alias, mustache);
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.nested_params.js b/public/javascripts/plugins/sammy.nested_params.js
new file mode 100644
index 0000000..645f8c9
--- /dev/null
+++ b/public/javascripts/plugins/sammy.nested_params.js
@@ -0,0 +1,118 @@
+(function($) {
+
+ Sammy = Sammy || {};
+
+ function parseValue(value) {
+ value = unescape(value);
+ if (value === "true") {
+ return true;
+ } else if (value === "false") {
+ return false;
+ } else {
+ return value;
+ }
+ };
+
+ function parseNestedParam(params, field_name, field_value) {
+ var match, name, rest;
+
+ if (field_name.match(/^[^\[]+$/)) {
+ // basic value
+ params[field_name] = parseValue(field_value);
+ } else if (match = field_name.match(/^([^\[]+)\[\](.*)$/)) {
+ // array
+ name = match[1];
+ rest = match[2];
+
+ if(params[name] && !$.isArray(params[name])) { throw('400 Bad Request'); }
+
+ if (rest) {
+ // array is not at the end of the parameter string
+ match = rest.match(/^\[([^\]]+)\](.*)$/);
+ if(!match) { throw('400 Bad Request'); }
+
+ if (params[name]) {
+ if(params[name][params[name].length - 1][match[1]]) {
+ params[name].push(parseNestedParam({}, match[1] + match[2], field_value));
+ } else {
+ $.extend(true, params[name][params[name].length - 1], parseNestedParam({}, match[1] + match[2], field_value));
+ }
+ } else {
+ params[name] = [parseNestedParam({}, match[1] + match[2], field_value)];
+ }
+ } else {
+ // array is at the end of the parameter string
+ if (params[name]) {
+ params[name].push(parseValue(field_value));
+ } else {
+ params[name] = [parseValue(field_value)];
+ }
+ }
+ } else if (match = field_name.match(/^([^\[]+)\[([^\[]+)\](.*)$/)) {
+ // hash
+ name = match[1];
+ rest = match[2] + match[3];
+
+ if (params[name] && $.isArray(params[name])) { throw('400 Bad Request'); }
+
+ if (params[name]) {
+ $.extend(true, params[name], parseNestedParam(params[name], rest, field_value));
+ } else {
+ params[name] = parseNestedParam({}, rest, field_value);
+ }
+ }
+ return params;
+ };
+
+ // Sammy.NestedParams overrides the default form parsing behavior to provide
+ // extended functionality for parsing Rack/Rails style form name/value pairs into JS
+ // Objects. In fact it passes the same suite of tests as Rack's nested query parsing.
+ // The code and tests were ported to JavaScript/Sammy by http://github.com/endor
+ //
+ // This allows you to translate a form with properly named inputs into a JSON object.
+ //
+ // ### Example
+ //
+ // Given an HTML form like so:
+ //
+ //
+ //
+ // And a Sammy app like:
+ //
+ // var app = $.sammy(function(app) {
+ // this.use(Sammy.NestedParams);
+ //
+ // this.post('#/parse_me', function(context) {
+ // $.log(this.params);
+ // });
+ // });
+ //
+ // If you filled out the form with some values and submitted it, you would see something
+ // like this in your log:
+ //
+ // {
+ // 'obj': {
+ // 'first': 'value',
+ // 'second': 'value',
+ // 'hash': {
+ // 'first': 'value',
+ // 'second': 'value'
+ // }
+ // }
+ // }
+ //
+ // It supports creating arrays with [] and other niceities. Check out the tests for
+ // full specs.
+ //
+ Sammy.NestedParams = function(app) {
+
+ app._parseParamPair = parseNestedParam;
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.oauth2.js b/public/javascripts/plugins/sammy.oauth2.js
new file mode 100644
index 0000000..6d0fab2
--- /dev/null
+++ b/public/javascripts/plugins/sammy.oauth2.js
@@ -0,0 +1,144 @@
+(function($) {
+ Sammy = Sammy || {};
+
+ // Sammy.OAuth2 is a plugin for using OAuth 2.0 to authenticate users and
+ // access your application's API. Requires Sammy.Session.
+ //
+ // Triggers the following events:
+ //
+ // * `oauth.connected` - Access token set and ready to use. Triggered when new
+ // access token acquired, of when application starts and already has access
+ // token.
+ // * `oauth.disconnected` - Access token reset. Triggered by
+ // loseAccessToken().
+ // * `oauth.denied` - Authorization attempt rejected.
+ //
+ // ### Example
+ //
+ // this.use('Storage');
+ // this.use('OAuth2');
+ // this.oauthorize = "/oauth/authorize";
+ //
+ // // The quick & easy way
+ // this.requireOAuth();
+ // // Specific path
+ // this.requireOAuth("/private");
+ // // Filter you can apply to specific URLs
+ // this.before(function(context) { return context.requireOAuth(); })
+ // // Apply to specific request
+ // this.get("/private", function(context) {
+ // this.requireOAuth(function() {
+ // // Do something
+ // });
+ // });
+ //
+ // // Sign in/sign out.
+ // this.bind("oauth.connected", function() { $("#signin").hide() });
+ // this.bind("oauth.disconnected", function() { $("#signin").show() });
+ //
+ // // Handle access denied and other errors
+ // this.bind("oauth.denied", function(evt, error) {
+ // this.partial("admin/views/no_access.tmpl", { error: error.message });
+ // });
+ //
+ // // Sign out.
+ // this.get("#/signout", function(context) {
+ // context.loseAccessToken();
+ // context.redirect("#/");
+ // });
+ //
+ Sammy.OAuth2 = function(app) {
+ app.use('JSON');
+ this.authorize = "/oauth/authorize";
+
+ // Use this on request that require OAuth token. You can use this in a
+ // filter: it will redirect and return false if the access token is missing.
+ // You can use it in a route, it will redirect to get the access token, or
+ // call the callback function if it has an access token.
+ this.helper("requireOAuth", function(cb) {
+ if (this.app.getAccessToken()) {
+ if (cb)
+ cb.apply(this);
+ } else {
+ this.redirect(this.app.authorize + "?state=" + escape(this.path));
+ return false;
+ }
+ });
+
+ // Use this to sign out.
+ this.helper("loseAccessToken", function() {
+ this.app.loseAccessToken();
+ });
+
+ // Use this in your application to require an OAuth access token on all, or
+ // the specified paths. It sets up a before filter on the specified paths.
+ this.requireOAuth = function(options) {
+ this.before(options || {}, function(context) {
+ return context.requireOAuth();
+ });
+ }
+
+ // Returns the access token. Uses Sammy.Session to store the token.
+ this.getAccessToken = function() {
+ return this.session("oauth.token");
+ }
+ // Stores the access token in the session.
+ this.setAccessToken = function(token) {
+ this.session("oauth.token", token);
+ this.trigger("oauth.connected");
+ }
+ // Lose access token: use this to sign out.
+ this.loseAccessToken = function() {
+ this.session("oauth.token", null);
+ this.trigger("oauth.disconnected");
+ }
+
+ // Add OAuth 2.0 access token to all XHR requests.
+ $(document).ajaxSend(function(evt, xhr) {
+ var token = app.getAccessToken();
+ if (token)
+ xhr.setRequestHeader("Authorization", "OAuth " + token);
+ });
+
+ // Converts query string parameters in fragment identifier to object.
+ function parseParams(hash) {
+ var pairs = hash.substring(1).split("&"), params = {};
+ for (var i in pairs) {
+ var splat = pairs[i].split("=");
+ params[splat[0]] = splat[1].replace(/\+/g, " ");
+ }
+ return params;
+ }
+
+ var start_url;
+ // Capture the application's start URL, we'll need that later on for
+ // redirection.
+ this.bind("run", function(evt, params) {
+ start_url = params.start_url || "#";
+ if (this.app.getAccessToken())
+ this.trigger("oauth.connected");
+ });
+
+ // Intercept OAuth authorization response with access token, stores it and
+ // redirects to original URL, or application root.
+ this.before(/^#(access_token=|[^\\].*\&access_token=)/, function(context) {
+ var params = parseParams(context.path);
+ this.app.setAccessToken(params.access_token);
+ // When the filter redirected the original request, it passed the original
+ // request's URL in the state parameter, which we get back after
+ // authorization.
+ context.redirect(params.state.length == 0 ? this.app.start_url : unescape(params.state));
+ return false;
+ }).get(/^#(access_token=|[^\\].*\&access_token=)/, function(context) { });
+
+ // Intercept OAuth authorization response with error (typically access
+ // denied).
+ this.before(/^#(error=|[^\\].*\&error=)/, function(context) {
+ var params = parseParams(context.path);
+ var message = params.error_description || "Access denined";
+ context.trigger("oauth.denied", { code: params.error, message: message });
+ return false;
+ }).get(/^#(error=|[^\\].*\&error=)/, function(context) { });
+
+ }
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.path_location_proxy.js b/public/javascripts/plugins/sammy.path_location_proxy.js
new file mode 100644
index 0000000..13f9014
--- /dev/null
+++ b/public/javascripts/plugins/sammy.path_location_proxy.js
@@ -0,0 +1,29 @@
+(function($) {
+
+ Sammy = Sammy || {};
+
+ // `Sammy.PathLocationProxy` is a simple Location Proxy that just
+ // gets and sets window.location. This allows you to use
+ // Sammy to route on the full URL path instead of just the hash. It
+ // will take a full refresh to get the app to change state.
+ //
+ // To read more about location proxies, check out the
+ // documentation for `Sammy.HashLocationProxy`
+ Sammy.PathLocationProxy = function(app) {
+ this.app = app;
+ };
+
+ Sammy.PathLocationProxy.prototype = {
+ bind: function() {},
+ unbind: function() {},
+
+ getLocation: function() {
+ return [window.location.pathname, window.location.search].join('');
+ },
+
+ setLocation: function(new_location) {
+ return window.location = new_location;
+ }
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.pure.js b/public/javascripts/plugins/sammy.pure.js
new file mode 100644
index 0000000..16fe3df
--- /dev/null
+++ b/public/javascripts/plugins/sammy.pure.js
@@ -0,0 +1,756 @@
+(function($) {
+
+/*!
+ PURE Unobtrusive Rendering Engine for HTML
+
+ Licensed under the MIT licenses.
+ More information at: http://www.opensource.org
+
+ Copyright (c) 2010 Michael Cvilic - BeeBole.com
+
+ Thanks to Rog Peppe for the functional JS jump
+ revision: 2.47
+*/
+
+var $p, pure = $p = function(){
+ var sel = arguments[0],
+ ctxt = false;
+
+ if(typeof sel === 'string'){
+ ctxt = arguments[1] || false;
+ }
+ return $p.core(sel, ctxt);
+};
+
+$p.core = function(sel, ctxt, plugins){
+ //get an instance of the plugins
+ var plugins = getPlugins(),
+ templates = [];
+
+ //search for the template node(s)
+ switch(typeof sel){
+ case 'string':
+ templates = plugins.find(ctxt || document, sel);
+ if(templates.length === 0) {
+ error('The template "' + sel + '" was not found');
+ }
+ break;
+ case 'undefined':
+ error('The template root is undefined, check your selector');
+ break;
+ default:
+ templates = [sel];
+ }
+
+ for(var i = 0, ii = templates.length; i < ii; i++){
+ plugins[i] = templates[i];
+ }
+ plugins.length = ii;
+
+ // set the signature string that will be replaced at render time
+ var Sig = '_s' + Math.floor( Math.random() * 1000000 ) + '_',
+ // another signature to prepend to attributes and avoid checks: style, height, on[events]...
+ attPfx = '_a' + Math.floor( Math.random() * 1000000 ) + '_',
+ // rx to parse selectors, e.g. "+tr.foo[class]"
+ selRx = /^(\+)?([^\@\+]+)?\@?([^\+]+)?(\+)?$/,
+ // set automatically attributes for some tags
+ autoAttr = {
+ IMG:'src',
+ INPUT:'value'
+ },
+ // check if the argument is an array - thanks salty-horse (Ori Avtalion)
+ isArray = Array.isArray ?
+ function(o) {
+ return Array.isArray(o);
+ } :
+ function(o) {
+ return Object.prototype.toString.call(o) === "[object Array]";
+ };
+
+ return plugins;
+
+
+ /* * * * * * * * * * * * * * * * * * * * * * * * * *
+ core functions
+ * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+
+ // error utility
+ function error(e){
+ if(typeof console !== 'undefined'){
+ console.log(e);
+ }else{ alert(e); }
+ throw('pure error: ' + e);
+ }
+
+ //return a new instance of plugins
+ function getPlugins(){
+ var plugins = $p.plugins,
+ f = function(){};
+ f.prototype = plugins;
+
+ // do not overwrite functions if external definition
+ f.prototype.compile = plugins.compile || compile;
+ f.prototype.render = plugins.render || render;
+ f.prototype.autoRender = plugins.autoRender || autoRender;
+ f.prototype.find = plugins.find || find;
+
+ // give the compiler and the error handling to the plugin context
+ f.prototype._compiler = compiler;
+ f.prototype._error = error;
+
+ return new f();
+ }
+
+ // returns the outer HTML of a node
+ function outerHTML(node){
+ // if IE take the internal method otherwise build one
+ return node.outerHTML || (
+ function(n){
+ var div = document.createElement('div'), h;
+ div.appendChild( n.cloneNode(true) );
+ h = div.innerHTML;
+ div = null;
+ return h;
+ })(node);
+ }
+
+ // returns the string generator function
+ function wrapquote(qfn, f){
+ return function(ctxt){
+ return qfn('' + f.call(ctxt.context, ctxt));
+ };
+ }
+
+ // default find using querySelector when available on the browser
+ function find(n, sel){
+ if(typeof n === 'string'){
+ sel = n;
+ n = false;
+ }
+ if(typeof document.querySelectorAll !== 'undefined'){
+ return (n||document).querySelectorAll( sel );
+ }else{
+ error('You can test PURE standalone with: iPhone, FF3.5+, Safari4+ and IE8+\n\nTo run PURE on your browser, you need a JS library/framework with a CSS selector engine');
+ }
+ }
+
+ // create a function that concatenates constant string
+ // sections (given in parts) and the results of called
+ // functions to fill in the gaps between parts (fns).
+ // fns[n] fills in the gap between parts[n-1] and parts[n];
+ // fns[0] is unused.
+ // this is the inner template evaluation loop.
+ function concatenator(parts, fns){
+ return function(ctxt){
+ var strs = [ parts[ 0 ] ],
+ n = parts.length,
+ fnVal, pVal, attLine, pos;
+
+ for(var i = 1; i < n; i++){
+ fnVal = fns[i]( ctxt );
+ pVal = parts[i];
+
+ // if the value is empty and attribute, remove it
+ if(fnVal === ''){
+ attLine = strs[ strs.length - 1 ];
+ if( ( pos = attLine.search( /[\w]+=\"?$/ ) ) > -1){
+ strs[ strs.length - 1 ] = attLine.substring( 0, pos );
+ pVal = pVal.substr( 1 );
+ }
+ }
+
+ strs[ strs.length ] = fnVal;
+ strs[ strs.length ] = pVal;
+ }
+ return strs.join('');
+ };
+ }
+
+ // parse and check the loop directive
+ function parseloopspec(p){
+ var m = p.match( /^(\w+)\s*<-\s*(\S+)?$/ );
+ if(m === null){
+ error('bad loop spec: "' + p + '"');
+ }
+ if(m[1] === 'item'){
+ error('"item<-..." is a reserved word for the current running iteration.\n\nPlease choose another name for your loop.');
+ }
+ if( !m[2] || (m[2] && (/context/i).test(m[2]))){ //undefined or space(IE)
+ m[2] = function(ctxt){return ctxt.context;};
+ }
+ return {name: m[1], sel: m[2]};
+ }
+
+ // parse a data selector and return a function that
+ // can traverse the data accordingly, given a context.
+ function dataselectfn(sel){
+ if(typeof(sel) === 'function'){
+ return sel;
+ }
+ //check for a valid js variable name with hyphen(for properties only), $, _ and :
+ var m = sel.match(/^[a-zA-Z\$_\@][\w\$:-]*(\.[\w\$:-]*[^\.])*$/);
+ if(m === null){
+ var found = false, s = sel, parts = [], pfns = [], i = 0, retStr;
+ // check if literal
+ if(/\'|\"/.test( s.charAt(0) )){
+ if(/\'|\"/.test( s.charAt(s.length-1) )){
+ retStr = s.substring(1, s.length-1);
+ return function(){ return retStr; };
+ }
+ }else{
+ // check if literal + #{var}
+ while((m = s.match(/#\{([^{}]+)\}/)) !== null){
+ found = true;
+ parts[i++] = s.slice(0, m.index);
+ pfns[i] = dataselectfn(m[1]);
+ s = s.slice(m.index + m[0].length, s.length);
+ }
+ }
+ if(!found){
+ error('bad data selector syntax: ' + sel);
+ }
+ parts[i] = s;
+ return concatenator(parts, pfns);
+ }
+ m = sel.split('.');
+ return function(ctxt){
+ var data = ctxt.context;
+ if(!data){
+ return '';
+ }
+ var v = ctxt[m[0]],
+ i = 0;
+ if(v && v.item){
+ data = v.item;
+ i += 1;
+ }
+ var n = m.length;
+ for(; i < n; i++){
+ if(!data){break;}
+ data = data[m[i]];
+ }
+ return (!data && data !== 0) ? '':data;
+ };
+ }
+
+ // wrap in an object the target node/attr and their properties
+ function gettarget(dom, sel, isloop){
+ var osel, prepend, selector, attr, append, target = [];
+ if( typeof sel === 'string' ){
+ osel = sel;
+ var m = sel.match(selRx);
+ if( !m ){
+ error( 'bad selector syntax: ' + sel );
+ }
+
+ prepend = m[1];
+ selector = m[2];
+ attr = m[3];
+ append = m[4];
+
+ if(selector === '.' || ( !selector && attr ) ){
+ target[0] = dom;
+ }else{
+ target = plugins.find(dom, selector);
+ }
+ if(!target || target.length === 0){
+ return error('The node "' + sel + '" was not found in the template');
+ }
+ }else{
+ // autoRender node
+ prepend = sel.prepend;
+ attr = sel.attr;
+ append = sel.append;
+ target = [dom];
+ }
+
+ if( prepend || append ){
+ if( prepend && append ){
+ error('append/prepend cannot take place at the same time');
+ }else if( isloop ){
+ error('no append/prepend/replace modifiers allowed for loop target');
+ }else if( append && isloop ){
+ error('cannot append with loop (sel: ' + osel + ')');
+ }
+ }
+ var setstr, getstr, quotefn, isStyle, isClass, attName, setfn;
+ if(attr){
+ isStyle = (/^style$/i).test(attr);
+ isClass = (/^class$/i).test(attr);
+ attName = isClass ? 'className' : attr;
+ setstr = function(node, s) {
+ node.setAttribute(attPfx + attr, s);
+ if (attName in node && !isStyle) {
+ node[attName] = '';
+ }
+ if (node.nodeType === 1) {
+ node.removeAttribute(attr);
+ isClass && node.removeAttribute(attName);
+ }
+ };
+ if (isStyle || isClass) {//IE no quotes special care
+ if(isStyle){
+ getstr = function(n){ return n.style.cssText; };
+ }else{
+ getstr = function(n){ return n.className; };
+ }
+ quotefn = function(s){ return s.replace(/\"/g, '"'); };
+ }else {
+ getstr = function(n){ return n.getAttribute(attr); };
+ quotefn = function(s){ return s.replace(/\"/g, '"').replace(/\s/g, ' '); };
+ }
+ if(prepend){
+ setfn = function(node, s){ setstr( node, s + getstr( node )); };
+ }else if(append){
+ setfn = function(node, s){ setstr( node, getstr( node ) + s); };
+ }else{
+ setfn = function(node, s){ setstr( node, s ); };
+ }
+ }else{
+ if (isloop) {
+ setfn = function(node, s) {
+ var pn = node.parentNode;
+ if (pn) {
+ //replace node with s
+ pn.insertBefore(document.createTextNode(s), node.nextSibling);
+ pn.removeChild(node);
+ }
+ };
+ } else {
+ if (prepend) {
+ setfn = function(node, s) { node.insertBefore(document.createTextNode(s), node.firstChild); };
+ } else if (append) {
+ setfn = function(node, s) { node.appendChild(document.createTextNode(s));};
+ } else {
+ setfn = function(node, s) {
+ while (node.firstChild) { node.removeChild(node.firstChild); }
+ node.appendChild(document.createTextNode(s));
+ };
+ }
+ }
+ quotefn = function(s) { return s; };
+ }
+ return { attr: attr, nodes: target, set: setfn, sel: osel, quotefn: quotefn };
+ }
+
+ function setsig(target, n){
+ var sig = Sig + n + ':';
+ for(var i = 0; i < target.nodes.length; i++){
+ // could check for overlapping targets here.
+ target.set( target.nodes[i], sig );
+ }
+ }
+
+ // read de loop data, and pass it to the inner rendering function
+ function loopfn(name, dselect, inner, sorter, filter){
+ return function(ctxt){
+ var a = dselect(ctxt),
+ old = ctxt[name],
+ temp = { items : a },
+ filtered = 0,
+ length,
+ strs = [],
+ buildArg = function(idx, temp, ftr, len){
+ ctxt.pos = temp.pos = idx;
+ ctxt.item = temp.item = a[ idx ];
+ ctxt.items = a;
+ //if array, set a length property - filtered items
+ typeof len !== 'undefined' && (ctxt.length = len);
+ //if filter directive
+ if(typeof ftr === 'function' && ftr(ctxt) === false){
+ filtered++;
+ return;
+ }
+ strs.push( inner.call(temp, ctxt ) );
+ };
+ ctxt[name] = temp;
+ if( isArray(a) ){
+ length = a.length || 0;
+ // if sort directive
+ if(typeof sorter === 'function'){
+ a.sort(sorter);
+ }
+ //loop on array
+ for(var i = 0, ii = length; i < ii; i++){
+ buildArg(i, temp, filter, length - filtered);
+ }
+ }else{
+ if(a && typeof sorter !== 'undefined'){
+ error('sort is only available on arrays, not objects');
+ }
+ //loop on collections
+ for(var prop in a){
+ a.hasOwnProperty( prop ) && buildArg(prop, temp, filter);
+ }
+ }
+
+ typeof old !== 'undefined' ? ctxt[name] = old : delete ctxt[name];
+ return strs.join('');
+ };
+ }
+ // generate the template for a loop node
+ function loopgen(dom, sel, loop, fns){
+ var already = false, ls, sorter, filter, prop;
+ for(prop in loop){
+ if(loop.hasOwnProperty(prop)){
+ if(prop === 'sort'){
+ sorter = loop.sort;
+ continue;
+ }else if(prop === 'filter'){
+ filter = loop.filter;
+ continue;
+ }
+ if(already){
+ error('cannot have more than one loop on a target');
+ }
+ ls = prop;
+ already = true;
+ }
+ }
+ if(!ls){
+ error('Error in the selector: ' + sel + '\nA directive action must be a string, a function or a loop(<-)');
+ }
+ var dsel = loop[ls];
+ // if it's a simple data selector then we default to contents, not replacement.
+ if(typeof(dsel) === 'string' || typeof(dsel) === 'function'){
+ loop = {};
+ loop[ls] = {root: dsel};
+ return loopgen(dom, sel, loop, fns);
+ }
+ var spec = parseloopspec(ls),
+ itersel = dataselectfn(spec.sel),
+ target = gettarget(dom, sel, true),
+ nodes = target.nodes;
+
+ for(i = 0; i < nodes.length; i++){
+ var node = nodes[i],
+ inner = compiler(node, dsel);
+ fns[fns.length] = wrapquote(target.quotefn, loopfn(spec.name, itersel, inner, sorter, filter));
+ target.nodes = [node]; // N.B. side effect on target.
+ setsig(target, fns.length - 1);
+ }
+ }
+
+ function getAutoNodes(n, data){
+ var ns = n.getElementsByTagName('*'),
+ an = [],
+ openLoops = {a:[],l:{}},
+ cspec,
+ isNodeValue,
+ i, ii, j, jj, ni, cs, cj;
+ //for each node found in the template
+ for(i = -1, ii = ns.length; i < ii; i++){
+ ni = i > -1 ?ns[i]:n;
+ if(ni.nodeType === 1 && ni.className !== ''){
+ //when a className is found
+ cs = ni.className.split(' ');
+ // for each className
+ for(j = 0, jj=cs.length;jHello!
+ // + // Hey, AQ! Welcome to Mustache! + // + // + // ### Example #2 - Mustache partials + // + // The template (mytemplate.ms) + // + // Hey, {{name}}! {{>hello_friend}} + // + // + // The partial (mypartial.ms) + // + // Say hello to your friend {{friend}}! + // + // The app: + // + // var $.app = $.sammy(function() { + // // include the plugin and alias mustache() to ms() + // this.use(Sammy.Mustache, 'ms'); + // + // this.get('#/hello/:name/to/:friend', function() { + // var context = this; + // + // // fetch mustache-partial first + // $.get('mypartial.ms', function(response){ + // context.partials = response; + // + // // set local vars + // context.name = this.params.name; + // context.hello_friend = {name: this.params.friend}; + // + // // render the template and pass it through mustache + // context.partial('mytemplate.ms'); + // }); + // }); + // + // }); + // + // If I go to #/hello/AQ/to/dP in the browser, Sammy will render this to the body: + // + // Hey, AQ! Say hello to your friend dP! + // + // Note: You dont have to include the mustache.js file on top of the plugin as the plugin + // includes the full source. + // + Sammy.Mustache = function(app, method_alias) { + + // *Helper* Uses Mustache.js to parse a template and interpolate and work with the passed data + // + // ### Arguments + // + // * `template` A String template. {{}} Tags are evaluated and interpolated by Mustache.js + // * `data` An Object containing the replacement values for the template. + // data is extended with the EventContext allowing you to call its methods within the template. + // * `partials` An Object containing one or more partials (String templates + // that are called from the main template). + // + var mustache = function(template, data, partials) { + data = $.extend({}, this, data); + partials = $.extend({}, data.partials, partials); + return Mustache.to_html(template, data, partials); + }; + + // set the default method name/extension + if (!method_alias) method_alias = 'mustache'; + app.helper(method_alias, mustache); + + }; + +})(jQuery); diff --git a/public/javascripts/plugins/sammy.nested_params.js b/public/javascripts/plugins/sammy.nested_params.js new file mode 100644 index 0000000..645f8c9 --- /dev/null +++ b/public/javascripts/plugins/sammy.nested_params.js @@ -0,0 +1,118 @@ +(function($) { + + Sammy = Sammy || {}; + + function parseValue(value) { + value = unescape(value); + if (value === "true") { + return true; + } else if (value === "false") { + return false; + } else { + return value; + } + }; + + function parseNestedParam(params, field_name, field_value) { + var match, name, rest; + + if (field_name.match(/^[^\[]+$/)) { + // basic value + params[field_name] = parseValue(field_value); + } else if (match = field_name.match(/^([^\[]+)\[\](.*)$/)) { + // array + name = match[1]; + rest = match[2]; + + if(params[name] && !$.isArray(params[name])) { throw('400 Bad Request'); } + + if (rest) { + // array is not at the end of the parameter string + match = rest.match(/^\[([^\]]+)\](.*)$/); + if(!match) { throw('400 Bad Request'); } + + if (params[name]) { + if(params[name][params[name].length - 1][match[1]]) { + params[name].push(parseNestedParam({}, match[1] + match[2], field_value)); + } else { + $.extend(true, params[name][params[name].length - 1], parseNestedParam({}, match[1] + match[2], field_value)); + } + } else { + params[name] = [parseNestedParam({}, match[1] + match[2], field_value)]; + } + } else { + // array is at the end of the parameter string + if (params[name]) { + params[name].push(parseValue(field_value)); + } else { + params[name] = [parseValue(field_value)]; + } + } + } else if (match = field_name.match(/^([^\[]+)\[([^\[]+)\](.*)$/)) { + // hash + name = match[1]; + rest = match[2] + match[3]; + + if (params[name] && $.isArray(params[name])) { throw('400 Bad Request'); } + + if (params[name]) { + $.extend(true, params[name], parseNestedParam(params[name], rest, field_value)); + } else { + params[name] = parseNestedParam({}, rest, field_value); + } + } + return params; + }; + + // Sammy.NestedParams overrides the default form parsing behavior to provide + // extended functionality for parsing Rack/Rails style form name/value pairs into JS + // Objects. In fact it passes the same suite of tests as Rack's nested query parsing. + // The code and tests were ported to JavaScript/Sammy by http://github.com/endor + // + // This allows you to translate a form with properly named inputs into a JSON object. + // + // ### Example + // + // Given an HTML form like so: + // + //
+ //
+ // <% } %>
+ //
+ //
+ // Given that is a publicly accesible file, you would render it like:
+ //
+ // // app.js
+ // $.sammy(function() {
+ // // include the plugin
+ // this.use('Template');
+ //
+ // this.get('#/', function() {
+ // // the template is rendered in the current context.
+ // this.user = {name: 'Aaron Quint'};
+ // // partial calls template() because of the file extension
+ // this.partial('user.template');
+ // })
+ // });
+ //
+ // You can also pass a second argument to use() that will alias the template
+ // method and therefore allow you to use a different extension for template files
+ // in partial()
+ //
+ // // alias to 'tpl'
+ // this.use(Sammy.Template, 'tpl');
+ //
+ // // now .tpl files will be run through srender
+ // this.get('#/', function() {
+ // this.partial('myfile.tpl');
+ // });
+ //
+ // By default, the data passed into the tempalate is passed automatically passed through
+ // Sammy's `escapeHTML` method in order to prevent possible XSS attacks. This is
+ // a problem though if you're using something like `Sammy.Form` which renders HTML
+ // within the templates. You can get around this in two ways. One, you can use the
+ // `<%! %>` instead of `<%= %>`. Two, you can pass the `escape_html = false` option
+ // when interpolating, i.e:
+ //
+ // this.get('#/', function() {
+ // this.template('myform.tpl', {form: ""}, {escape_html: false});
+ // });
+ //
+ Sammy.Template = function(app, method_alias) {
+
+ // *Helper:* Uses simple templating to parse ERB like templates.
+ //
+ // ### Arguments
+ //
+ // * `template` A String template. '<% %>' tags are evaluated as Javascript and replaced with the elements in data.
+ // * `data` An Object containing the replacement values for the template.
+ // data is extended with the EventContext allowing you to call its methods within the template.
+ // * `name` An optional String name to cache the template.
+ //
+ var template = function(template, data, name, options) {
+ // use name for caching
+ if (typeof name == 'undefined') { name = template; }
+ if (typeof options == 'undefined' && typeof name == 'object') {
+ options = name; name = template;
+ }
+ return srender(name, template, $.extend({}, this, data), options);
+ };
+
+ // set the default method name/extension
+ if (!method_alias) { method_alias = 'template'; }
+ // create the helper at the method alias
+ app.helper(method_alias, template);
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.title.js b/public/javascripts/plugins/sammy.title.js
new file mode 100644
index 0000000..9874a1e
--- /dev/null
+++ b/public/javascripts/plugins/sammy.title.js
@@ -0,0 +1,59 @@
+(function($) {
+
+ Sammy = Sammy || {};
+
+ // Sammy.Title is a very simple plugin to easily set the document's title.
+ // It supplies a helper for setting the title (`title()`) within routes,
+ // and an app level method for setting the global title (`setTitle()`)
+ Sammy.Title = function() {
+
+ // setTitle allows setting a global title or a function that modifies the
+ // title for each route/page.
+ //
+ // ### Example
+ //
+ // // setting a title prefix
+ // $.sammy(function() {
+ //
+ // this.setTitle('My App -');
+ //
+ // this.get('#/', function() {
+ // this.title('Home'); // document's title == "My App - Home"
+ // });
+ // });
+ //
+ // // setting a title with a function
+ // $.sammy(function() {
+ //
+ // this.setTitle(function(title) {
+ // return [title, " /// My App"].join('');
+ // });
+ //
+ // this.get('#/', function() {
+ // this.title('Home'); // document's title == "Home /// My App";
+ // });
+ // });
+ //
+ this.setTitle = function(title) {
+ if (!$.isFunction(title)) {
+ this.title_function = function(additional_title) {
+ return [title, additional_title].join(' ');
+ }
+ } else {
+ this.title_function = title;
+ }
+ };
+
+ // *Helper* title() sets the document title, passing it through the function
+ // defined by setTitle() if set.
+ this.helper('title', function() {
+ var new_title = $.makeArray(arguments).join(' ');
+ if (this.app.title_function) {
+ new_title = this.app.title_function(new_title);
+ }
+ document.title = new_title;
+ });
+
+ };
+
+})(jQuery);
diff --git a/public/javascripts/plugins/sammy.tmpl.js b/public/javascripts/plugins/sammy.tmpl.js
new file mode 100644
index 0000000..0e9f0a1
--- /dev/null
+++ b/public/javascripts/plugins/sammy.tmpl.js
@@ -0,0 +1,520 @@
+(function( jQuery, undefined ){
+
+ /*
+ * a port of the...
+ * jQuery Templating Plugin
+ * Copyright 2010, John Resig
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ */
+
+ var oldManip = jQuery.fn.domManip, tmplItmAtt = "_tmplitem", htmlExpr = /^[^<]*(<[\w\W]+>)[^>]*$|\{\{\! /,
+ newTmplItems = {}, wrappedItems = {}, appendToTmplItems, topTmplItem = { key: 0, data: {} }, itemKey = 0, cloneIndex = 0, stack = [];
+
+ function newTmplItem( options, parentItem, fn, data ) {
+ // Returns a template item data structure for a new rendered instance of a template (a 'template item').
+ // The content field is a hierarchical array of strings and nested items (to be
+ // removed and replaced by nodes field of dom elements, once inserted in DOM).
+ var newItem = {
+ data: data || (parentItem ? parentItem.data : {}),
+ _wrap: parentItem ? parentItem._wrap : null,
+ tmpl: null,
+ parent: parentItem || null,
+ nodes: [],
+ calls: tiCalls,
+ nest: tiNest,
+ wrap: tiWrap,
+ html: tiHtml,
+ update: tiUpdate
+ };
+ if ( options ) {
+ jQuery.extend( newItem, options, { nodes: [], parent: parentItem } );
+ }
+ if ( fn ) {
+ // Build the hierarchical content to be used during insertion into DOM
+ newItem.tmpl = fn;
+ newItem._ctnt = newItem._ctnt || newItem.tmpl( jQuery, newItem );
+ newItem.key = ++itemKey;
+ // Keep track of new template item, until it is stored as jQuery Data on DOM element
+ (stack.length ? wrappedItems : newTmplItems)[itemKey] = newItem;
+ }
+ return newItem;
+ }
+
+ // Override appendTo etc., in order to provide support for targeting multiple elements. (This code would disappear if integrated in jquery core).
+ jQuery.each({
+ appendTo: "append",
+ prependTo: "prepend",
+ insertBefore: "before",
+ insertAfter: "after",
+ replaceAll: "replaceWith"
+ }, function( name, original ) {
+ jQuery.fn[ name ] = function( selector ) {
+ var ret = [], insert = jQuery( selector ), elems, i, l, tmplItems,
+ parent = this.length === 1 && this[0].parentNode;
+
+ appendToTmplItems = newTmplItems || {};
+ if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
+ insert[ original ]( this[0] );
+ ret = this;
+ } else {
+ for ( i = 0, l = insert.length; i < l; i++ ) {
+ cloneIndex = i;
+ elems = (i > 0 ? this.clone(true) : this).get();
+ jQuery.fn[ original ].apply( jQuery(insert[i]), elems );
+ ret = ret.concat( elems );
+ }
+ cloneIndex = 0;
+ ret = this.pushStack( ret, name, insert.selector );
+ }
+ tmplItems = appendToTmplItems;
+ appendToTmplItems = null;
+ jQuery.tmpl.complete( tmplItems );
+ return ret;
+ };
+ });
+
+ jQuery.fn.extend({
+ // Use first wrapped element as template markup.
+ // Return wrapped set of template items, obtained by rendering template against data.
+ tmpl: function( data, options, parentItem ) {
+ return jQuery.tmpl( this[0], data, options, parentItem );
+ },
+
+ // Find which rendered template item the first wrapped DOM element belongs to
+ tmplItem: function() {
+ return jQuery.tmplItem( this[0] );
+ },
+
+ // Consider the first wrapped element as a template declaration, and get the compiled template or store it as a named template.
+ template: function( name ) {
+ return jQuery.template( name, this[0] );
+ },
+
+ domManip: function( args, table, callback, options ) {
+ // This appears to be a bug in the appendTo, etc. implementation
+ // it should be doing .call() instead of .apply(). See #6227
+ if ( args[0] && args[0].nodeType ) {
+ var dmArgs = jQuery.makeArray( arguments ), argsLength = args.length, i = 0, tmplItem;
+ while ( i < argsLength && !(tmplItem = jQuery.data( args[i++], "tmplItem" ))) {}
+ if ( argsLength > 1 ) {
+ dmArgs[0] = [jQuery.makeArray( args )];
+ }
+ if ( tmplItem && cloneIndex ) {
+ dmArgs[2] = function( fragClone ) {
+ // Handler called by oldManip when rendered template has been inserted into DOM.
+ jQuery.tmpl.afterManip( this, fragClone, callback );
+ };
+ }
+ oldManip.apply( this, dmArgs );
+ } else {
+ oldManip.apply( this, arguments );
+ }
+ cloneIndex = 0;
+ if ( !appendToTmplItems ) {
+ jQuery.tmpl.complete( newTmplItems );
+ }
+ return this;
+ }
+ });
+
+ jQuery.extend({
+ // Return wrapped set of template items, obtained by rendering template against data.
+ tmpl: function( tmpl, data, options, parentItem ) {
+ var ret, topLevel = !parentItem;
+ if ( topLevel ) {
+ // This is a top-level tmpl call (not from a nested template using {{tmpl}})
+ parentItem = topTmplItem;
+ tmpl = jQuery.template[tmpl] || jQuery.template( null, tmpl );
+ wrappedItems = {}; // Any wrapped items will be rebuilt, since this is top level
+ } else if ( !tmpl ) {
+ // The template item is already associated with DOM - this is a refresh.
+ // Re-evaluate rendered template for the parentItem
+ tmpl = parentItem.tmpl;
+ newTmplItems[parentItem.key] = parentItem;
+ parentItem.nodes = [];
+ if ( parentItem.wrapped ) {
+ updateWrapped( parentItem, parentItem.wrapped );
+ }
+ // Rebuild, without creating a new template item
+ return jQuery( build( parentItem, null, parentItem.tmpl( jQuery, parentItem ) ));
+ }
+ if ( !tmpl ) {
+ return []; // Could throw...
+ }
+ if ( typeof data === "function" ) {
+ data = data.call( parentItem || {} );
+ }
+ if ( options && options.wrapped ) {
+ updateWrapped( options, options.wrapped );
+ }
+ ret = jQuery.isArray( data ) ?
+ jQuery.map( data, function( dataItem ) {
+ return dataItem ? newTmplItem( options, parentItem, tmpl, dataItem ) : null;
+ }) :
+ [ newTmplItem( options, parentItem, tmpl, data ) ];
+ return topLevel ? jQuery( build( parentItem, null, ret ) ) : ret;
+ },
+
+ // Return rendered template item for an element.
+ tmplItem: function( elem ) {
+ var tmplItem;
+ if ( elem instanceof jQuery ) {
+ elem = elem[0];
+ }
+ while ( elem && elem.nodeType === 1 && !(tmplItem = jQuery.data( elem, "tmplItem" )) && (elem = elem.parentNode) ) {}
+ return tmplItem || topTmplItem;
+ },
+
+ // Set:
+ // Use $.template( name, tmpl ) to cache a named template,
+ // where tmpl is a template string, a script element or a jQuery instance wrapping a script element, etc.
+ // Use $( "selector" ).template( name ) to provide access by name to a script block template declaration.
+
+ // Get:
+ // Use $.template( name ) to access a cached template.
+ // Also $( selectorToScriptBlock ).template(), or $.template( null, templateString )
+ // will return the compiled template, without adding a name reference.
+ // If templateString includes at least one HTML tag, $.template( templateString ) is equivalent
+ // to $.template( null, templateString )
+ template: function( name, tmpl ) {
+ if (tmpl) {
+ // Compile template and associate with name
+ if ( typeof tmpl === "string" ) {
+ // This is an HTML string being passed directly in.
+ tmpl = buildTmplFn( tmpl )
+ } else if ( tmpl instanceof jQuery ) {
+ tmpl = tmpl[0] || {};
+ }
+ if ( tmpl.nodeType ) {
+ // If this is a template block, use cached copy, or generate tmpl function and cache.
+ tmpl = jQuery.data( tmpl, "tmpl" ) || jQuery.data( tmpl, "tmpl", buildTmplFn( tmpl.innerHTML ));
+ }
+ return typeof name === "string" ? (jQuery.template[name] = tmpl) : tmpl;
+ }
+ // Return named compiled template
+ return name ? (typeof name !== "string" ? jQuery.template( null, name ):
+ (jQuery.template[name] ||
+ // If not in map, treat as a selector. (If integrated with core, use quickExpr.exec)
+ jQuery.template( null, htmlExpr.test( name ) ? name : jQuery( name )))) : null;
+ },
+
+ encode: function( text ) {
+ // Do HTML encoding replacing < > & and ' and " by corresponding entities.
+ return ("" + text).split("<").join("<").split(">").join(">").split('"').join(""").split("'").join("'");
+ }
+ });
+
+ jQuery.extend( jQuery.tmpl, {
+ tag: {
+ "tmpl": {
+ _default: { $2: "null" },
+ open: "if($notnull_1){___$$$___=___$$$___.concat($item.nest($1,$2));}"
+ // tmpl target parameter can be of type function, so use $1, not $1a (so not auto detection of functions)
+ // This means that {{tmpl foo}} treats foo as a template (which IS a function).
+ // Explicit parens can be used if foo is a function that returns a template: {{tmpl foo()}}.
+ },
+ "wrap": {
+ _default: { $2: "null" },
+ open: "$item.calls(_,$1,$2);_=[];",
+ close: "call=$item.calls();___$$$___=call.___$$$___.concat($item.wrap(call,___$$$___));"
+ },
+ "each": {
+ _default: { $2: "$index, $value" },
+ open: "if($notnull_1){$.each($1a,function($2){with(this){",
+ close: "}});}"
+ },
+ "if": {
+ open: "if(($notnull_1) && $1a){",
+ close: "}"
+ },
+ "else": {
+ _default: { $1: "true" },
+ open: "}else if(($notnull_1) && $1a){"
+ },
+ "html": {
+ // Unecoded expression evaluation.
+ open: "if($notnull_1){___$$$___.push($1a);}"
+ },
+ "=": {
+ // Encoded expression evaluation. Abbreviated form is ${}.
+ _default: { $1: "$data" },
+ open: "if($notnull_1){___$$$___.push($.encode($1a));}"
+ },
+ "!": {
+ // Comment tag. Skipped by parser
+ open: ""
+ }
+ },
+
+ // This stub can be overridden, e.g. in jquery.tmplPlus for providing rendered events
+ complete: function( items ) {
+ newTmplItems = {};
+ },
+
+ // Call this from code which overrides domManip, or equivalent
+ // Manage cloning/storing template items etc.
+ afterManip: function afterManip( elem, fragClone, callback ) {
+ // Provides cloned fragment ready for fixup prior to and after insertion into DOM
+ var content = fragClone.nodeType === 11 ?
+ jQuery.makeArray(fragClone.childNodes) :
+ fragClone.nodeType === 1 ? [fragClone] : [];
+
+ // Return fragment to original caller (e.g. append) for DOM insertion
+ callback.call( elem, fragClone );
+
+ // Fragment has been inserted:- Add inserted nodes to tmplItem data structure. Replace inserted element annotations by jQuery.data.
+ storeTmplItems( content );
+ cloneIndex++;
+ }
+ });
+
+ //========================== Private helper functions, used by code above ==========================
+
+ function build( tmplItem, nested, content ) {
+ // Convert hierarchical content into flat string array
+ // and finally return array of fragments ready for DOM insertion
+ var frag, ret = content ? jQuery.map( content, function( item ) {
+ return (typeof item === "string") ?
+ // Insert template item annotations, to be converted to jQuery.data( "tmplItem" ) when elems are inserted into DOM.
+ (tmplItem.key ? item.replace( /(<\w+)(?=[\s>])(?![^>]*_tmplitem)([^>]*)/g, "$1 " + tmplItmAtt + "=\"" + tmplItem.key + "\" $2" ) : item) :
+ // This is a child template item. Build nested template.
+ build( item, tmplItem, item._ctnt );
+ }) :
+ // If content is not defined, insert tmplItem directly. Not a template item. May be a string, or a string array, e.g. from {{html $item.html()}}.
+ tmplItem;
+ if ( nested ) {
+ return ret;
+ }
+
+ // top-level template
+ ret = ret.join("");
+
+ // Support templates which have initial or final text nodes, or consist only of text
+ // Also support HTML entities within the HTML markup.
+ ret.replace( /^\s*([^<\s][^<]*)?(<[\w\W]+>)([^>]*[^>\s])?\s*$/, function( all, before, middle, after) {
+ frag = jQuery( middle ).get();
+
+ storeTmplItems( frag );
+ if ( before ) {
+ frag = unencode( before ).concat(frag);
+ }
+ if ( after ) {
+ frag = frag.concat(unencode( after ));
+ }
+ });
+ return frag ? frag : unencode( ret );
+ }
+
+ function unencode( text ) {
+ // Use createElement, since createTextNode will not render HTML entities correctly
+ var el = document.createElement( "div" );
+ el.innerHTML = text;
+ return jQuery.makeArray(el.childNodes);
+ }
+
+ // Generate a reusable function that will serve to render a template against data
+ function buildTmplFn( markup ) {
+ return new Function("jQuery","$item",
+ "var $=jQuery,call,___$$$___=[],$data=$item.data;" +
+
+ // Introduce the data as local variables using with(){}
+ "with($data){___$$$___.push('" +
+
+ // Convert the template into pure JavaScript
+ jQuery.trim(markup)
+ .replace( /([\\'])/g, "\\$1" )
+ .replace( /[\r\t\n]/g, " " )
+ .replace( /\$\{([^\}]*)\}/g, "{{= $1}}" )
+ .replace( /\{\{(\/?)(\w+|.)(?:\(((?:[^\}]|\}(?!\}))*?)?\))?(?:\s+(.*?)?)?(\(((?:[^\}]|\}(?!\}))*?)\))?\s*\}\}/g,
+ function( all, slash, type, fnargs, target, parens, args ) {
+ var tag = jQuery.tmpl.tag[ type ], def, expr, exprAutoFnDetect;
+ if ( !tag ) {
+ throw "Template command not found: " + type;
+ }
+ def = tag._default || [];
+ if ( parens && !/\w$/.test(target)) {
+ target += parens;
+ parens = "";
+ }
+ if ( target ) {
+ target = unescape( target );
+ args = args ? ("," + unescape( args ) + ")") : (parens ? ")" : "");
+ // Support for target being things like a.toLowerCase();
+ // In that case don't call with template item as 'this' pointer. Just evaluate...
+ expr = parens ? (target.indexOf(".") > -1 ? target + parens : ("(" + target + ").call($item" + args)) : target;
+ exprAutoFnDetect = parens ? expr : "(typeof(" + target + ")==='function'?(" + target + ").call($item):(" + target + "))";
+ } else {
+ exprAutoFnDetect = expr = def.$1 || "null";
+ }
+ fnargs = unescape( fnargs );
+ return "');" +
+ tag[ slash ? "close" : "open" ]
+ .split( "$notnull_1" ).join( target ? "typeof(" + target + ")!=='undefined' && (" + target + ")!=null" : "true" )
+ .split( "$1a" ).join( exprAutoFnDetect )
+ .split( "$1" ).join( expr )
+ .split( "$2" ).join( fnargs ?
+ fnargs.replace( /\s*([^\(]+)\s*(\((.*?)\))?/g, function( all, name, parens, params ) {
+ params = params ? ("," + params + ")") : (parens ? ")" : "");
+ return params ? ("(" + name + ").call($item" + params) : all;
+ })
+ : (def.$2||"")
+ ) +
+ "___$$$___.push('";
+ }) +
+ "');}return ___$$$___;"
+ );
+ }
+ function updateWrapped( options, wrapped ) {
+ // Build the wrapped content.
+ options._wrap = build( options, true,
+ // Suport imperative scenario in which options.wrapped can be set to a selector or an HTML string.
+ jQuery.isArray( wrapped ) ? wrapped : [htmlExpr.test( wrapped ) ? wrapped : jQuery( wrapped ).html()]
+ ).join("");
+ }
+
+ function unescape( args ) {
+ return args ? args.replace( /\\'/g, "'").replace(/\\\\/g, "\\" ) : null;
+ }
+ function outerHtml( elem ) {
+ var div = document.createElement("div");
+ div.appendChild( elem.cloneNode(true) );
+ return div.innerHTML;
+ }
+
+ // Store template items in jQuery.data(), ensuring a unique tmplItem data data structure for each rendered template instance.
+ function storeTmplItems( content ) {
+ var keySuffix = "_" + cloneIndex, elem, elems, newClonedItems = {}, i, l, m;
+ for ( i = 0, l = content.length; i < l; i++ ) {
+ if ( (elem = content[i]).nodeType !== 1 ) {
+ continue;
+ }
+ elems = elem.getElementsByTagName("*");
+ for ( m = elems.length - 1; m >= 0; m-- ) {
+ processItemKey( elems[m] );
+ }
+ processItemKey( elem );
+ }
+ function processItemKey( el ) {
+ var pntKey, pntNode = el, pntItem, tmplItem, key;
+ // Ensure that each rendered template inserted into the DOM has its own template item,
+ if ( (key = el.getAttribute( tmplItmAtt ))) {
+ while ( pntNode.parentNode && (pntNode = pntNode.parentNode).nodeType === 1 && !(pntKey = pntNode.getAttribute( tmplItmAtt ))) { }
+ if ( pntKey !== key ) {
+ // The next ancestor with a _tmplitem expando is on a different key than this one.
+ // So this is a top-level element within this template item
+ // Set pntNode to the key of the parentNode, or to 0 if pntNode.parentNode is null, or pntNode is a fragment.
+ pntNode = pntNode.parentNode ? (pntNode.nodeType === 11 ? 0 : (pntNode.getAttribute( tmplItmAtt ) || 0)) : 0;
+ if ( !(tmplItem = newTmplItems[key]) ) {
+ // The item is for wrapped content, and was copied from the temporary parent wrappedItem.
+ tmplItem = wrappedItems[key];
+ tmplItem = newTmplItem( tmplItem, newTmplItems[pntNode]||wrappedItems[pntNode], null, true );
+ tmplItem.key = ++itemKey;
+ newTmplItems[itemKey] = tmplItem;
+ }
+ if ( cloneIndex ) {
+ cloneTmplItem( key );
+ }
+ }
+ el.removeAttribute( tmplItmAtt );
+ } else if ( cloneIndex && (tmplItem = jQuery.data( el, "tmplItem" )) ) {
+ // This was a rendered element, cloned during append or appendTo etc.
+ // TmplItem stored in jQuery data has already been cloned in cloneCopyEvent. We must replace it with a fresh cloned tmplItem.
+ cloneTmplItem( tmplItem.key );
+ newTmplItems[tmplItem.key] = tmplItem;
+ pntNode = jQuery.data( el.parentNode, "tmplItem" );
+ pntNode = pntNode ? pntNode.key : 0;
+ }
+ if ( tmplItem ) {
+ pntItem = tmplItem;
+ // Find the template item of the parent element.
+ // (Using !=, not !==, since pntItem.key is number, and pntNode may be a string)
+ while ( pntItem && pntItem.key != pntNode ) {
+ // Add this element as a top-level node for this rendered template item, as well as for any
+ // ancestor items between this item and the item of its parent element
+ pntItem.nodes.push( el );
+ pntItem = pntItem.parent;
+ }
+ // Delete content built during rendering - reduce API surface area and memory use, and avoid exposing of stale data after rendering...
+ delete tmplItem._ctnt;
+ delete tmplItem._wrap;
+ // Store template item as jQuery data on the element
+ jQuery.data( el, "tmplItem", tmplItem );
+ }
+ function cloneTmplItem( key ) {
+ key = key + keySuffix;
+ tmplItem = newClonedItems[key] =
+ (newClonedItems[key] || newTmplItem( tmplItem, newTmplItems[tmplItem.parent.key + keySuffix] || tmplItem.parent, null, true ));
+ }
+ }
+ }
+
+ //---- Helper functions for template item ----
+
+ function tiCalls( content, tmpl, data, options ) {
+ if ( !content ) {
+ return stack.pop();
+ }
+ stack.push({ _: content, tmpl: tmpl, item:this, data: data, options: options });
+ }
+
+ function tiNest( tmpl, data, options ) {
+ // nested template, using {{tmpl}} tag
+ return jQuery.tmpl( jQuery.template( tmpl ), data, options, this );
+ }
+
+ function tiWrap( call, wrapped ) {
+ // nested template, using {{wrap}} tag
+ var options = call.options || {};
+ options.wrapped = wrapped;
+ // Apply the template, which may incorporate wrapped content,
+ return jQuery.tmpl( jQuery.template( call.tmpl ), call.data, options, call.item );
+ }
+
+ function tiHtml( filter, textOnly ) {
+ var wrapped = this._wrap;
+ return jQuery.map(
+ jQuery( jQuery.isArray( wrapped ) ? wrapped.join("") : wrapped ).filter( filter || "*" ),
+ function(e) {
+ return textOnly ?
+ e.innerText || e.textContent :
+ e.outerHTML || outerHtml(e);
+ });
+ }
+
+ function tiUpdate() {
+ var coll = this.nodes;
+ jQuery.tmpl( null, null, null, this).insertBefore( coll[0] );
+ jQuery( coll ).remove();
+ }
+
+ Sammy = Sammy || {};
+
+ Sammy.Tmpl = function(app, method_alias) {
+
+ // *Helper:* Uses jQuery-tmpl to parse a template and interpolate and work with the passed data
+ //
+ // ### Arguments
+ //
+ // * `template` A String template. '${ }' tags are evaluated as Javascript and replaced with the elements in data.
+ // * `data` An Object containing the replacement values for the template.
+ // data is extended with the EventContext allowing you to call its methods within the template.
+ // * `name` An optional String name to cache the template.
+ //
+ var template = function(template, data, name) {
+ // use name for caching
+ if (typeof name == 'undefined') name = template;
+
+ // check the cache
+ if (!jQuery.template[name]) jQuery.template(name, template);
+
+ // we could also pass along jQuery-tmpl options as a last param?
+ return jQuery.tmpl(name, jQuery.extend({}, this, data));
+ };
+
+ // set the default method name/extension
+ if (!method_alias) method_alias = 'tmpl';
+ // create the helper at the method alias
+ app.helper(method_alias, template);
+
+ };
+})( jQuery );
diff --git a/public/javascripts/prototype.js b/public/javascripts/prototype.js
deleted file mode 100644
index 06249a6..0000000
--- a/public/javascripts/prototype.js
+++ /dev/null
@@ -1,6001 +0,0 @@
-/* Prototype JavaScript framework, version 1.7_rc2
- * (c) 2005-2010 Sam Stephenson
- *
- * Prototype is freely distributable under the terms of an MIT-style license.
- * For details, see the Prototype web site: http://www.prototypejs.org/
- *
- *--------------------------------------------------------------------------*/
-
-var Prototype = {
-
- Version: '1.7_rc2',
-
- Browser: (function(){
- var ua = navigator.userAgent;
- var isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]';
- return {
- IE: !!window.attachEvent && !isOpera,
- Opera: isOpera,
- WebKit: ua.indexOf('AppleWebKit/') > -1,
- Gecko: ua.indexOf('Gecko') > -1 && ua.indexOf('KHTML') === -1,
- MobileSafari: /Apple.*Mobile/.test(ua)
- }
- })(),
-
- BrowserFeatures: {
- XPath: !!document.evaluate,
-
- SelectorsAPI: !!document.querySelector,
-
- ElementExtensions: (function() {
- var constructor = window.Element || window.HTMLElement;
- return !!(constructor && constructor.prototype);
- })(),
- SpecificElementExtensions: (function() {
- if (typeof window.HTMLDivElement !== 'undefined')
- return true;
-
- var div = document.createElement('div'),
- form = document.createElement('form'),
- isSupported = false;
-
- if (div['__proto__'] && (div['__proto__'] !== form['__proto__'])) {
- isSupported = true;
- }
-
- div = form = null;
-
- return isSupported;
- })()
- },
-
- ScriptFragment: '<%= user.name %>
+ // <% if (user.photo_url) { %>
+ // | ', ' |
last_name Davis Jr.
' + // + toHTML: function() { + var display = ""; + $.each(this, function(k, v) { + if (!_isFunction(v)) { + display += "" + k + " " + v + "
"; + } + }); + return display; + }, + + // Returns an array of keys for this object. If `attributes_only` + // is true will not return keys that map to a `function()` + keys: function(attributes_only) { + var keys = []; + for (var property in this) { + if (!_isFunction(this[property]) || !attributes_only) { + keys.push(property); + } + } + return keys; + }, + + // Checks if the object has a value at `key` and that the value is not empty + has: function(key) { + return this[key] && $.trim(this[key].toString()) != ''; + }, + + // convenience method to join as many arguments as you want + // by the first argument - useful for making paths + join: function() { + var args = _makeArray(arguments); + var delimiter = args.shift(); + return args.join(delimiter); + }, + + // Shortcut to Sammy.log + log: function() { + Sammy.log.apply(Sammy, arguments); + }, + + // Returns a string representation of this object. + // if `include_functions` is true, it will also toString() the + // methods of this object. By default only prints the attributes. + toString: function(include_functions) { + var s = []; + $.each(this, function(k, v) { + if (!_isFunction(v) || include_functions) { + s.push('"' + k + '": ' + v.toString()); + } + }); + return "Sammy.Object: {" + s.join(',') + "}"; + } + }); + + // The HashLocationProxy is the default location proxy for all Sammy applications. + // A location proxy is a prototype that conforms to a simple interface. The purpose + // of a location proxy is to notify the Sammy.Application its bound to when the location + // or 'external state' changes. The HashLocationProxy considers the state to be + // changed when the 'hash' (window.location.hash / '#') changes. It does this in two + // different ways depending on what browser you are using. The newest browsers + // (IE, Safari > 4, FF >= 3.6) support a 'onhashchange' DOM event, thats fired whenever + // the location.hash changes. In this situation the HashLocationProxy just binds + // to this event and delegates it to the application. In the case of older browsers + // a poller is set up to track changes to the hash. Unlike Sammy 0.3 or earlier, + // the HashLocationProxy allows the poller to be a global object, eliminating the + // need for multiple pollers even when thier are multiple apps on the page. + Sammy.HashLocationProxy = function(app, run_interval_every) { + this.app = app; + // set is native to false and start the poller immediately + this.is_native = false; + this._startPolling(run_interval_every); + }; + + Sammy.HashLocationProxy.prototype = { + + // bind the proxy events to the current app. + bind: function() { + var proxy = this, app = this.app; + $(window).bind('hashchange.' + this.app.eventNamespace(), function(e, non_native) { + // if we receive a native hash change event, set the proxy accordingly + // and stop polling + if (proxy.is_native === false && !non_native) { + Sammy.log('native hash change exists, using'); + proxy.is_native = true; + window.clearInterval(Sammy.HashLocationProxy._interval); + } + app.trigger('location-changed'); + }); + if (!Sammy.HashLocationProxy._bindings) { + Sammy.HashLocationProxy._bindings = 0; + } + Sammy.HashLocationProxy._bindings++; + }, + + // unbind the proxy events from the current app + unbind: function() { + $(window).unbind('hashchange.' + this.app.eventNamespace()); + Sammy.HashLocationProxy._bindings--; + if (Sammy.HashLocationProxy._bindings <= 0) { + window.clearInterval(Sammy.HashLocationProxy._interval); + } + }, + + // get the current location from the hash. + getLocation: function() { + // Bypass the `window.location.hash` attribute. If a question mark + // appears in the hash IE6 will strip it and all of the following + // characters from `window.location.hash`. + var matches = window.location.toString().match(/^[^#]*(#.+)$/); + return matches ? matches[1] : ''; + }, + + // set the current location to `new_location` + setLocation: function(new_location) { + return (window.location = new_location); + }, + + _startPolling: function(every) { + // set up interval + var proxy = this; + if (!Sammy.HashLocationProxy._interval) { + if (!every) { every = 10; } + var hashCheck = function() { + var current_location = proxy.getLocation(); + if (!Sammy.HashLocationProxy._last_location || + current_location != Sammy.HashLocationProxy._last_location) { + window.setTimeout(function() { + $(window).trigger('hashchange', [true]); + }, 13); + } + Sammy.HashLocationProxy._last_location = current_location; + }; + hashCheck(); + Sammy.HashLocationProxy._interval = window.setInterval(hashCheck, every); + } + } + }; + + + // Sammy.Application is the Base prototype for defining 'applications'. + // An 'application' is a collection of 'routes' and bound events that is + // attached to an element when `run()` is called. + // The only argument an 'app_function' is evaluated within the context of the application. + Sammy.Application = function(app_function) { + var app = this; + this.routes = {}; + this.listeners = new Sammy.Object({}); + this.arounds = []; + this.befores = []; + // generate a unique namespace + this.namespace = (new Date()).getTime() + '-' + parseInt(Math.random() * 1000, 10); + this.context_prototype = function() { Sammy.EventContext.apply(this, arguments); }; + this.context_prototype.prototype = new Sammy.EventContext(); + + if (_isFunction(app_function)) { + app_function.apply(this, [this]); + } + // set the location proxy if not defined to the default (HashLocationProxy) + if (!this._location_proxy) { + this.setLocationProxy(new Sammy.HashLocationProxy(this, this.run_interval_every)); + } + if (this.debug) { + this.bindToAllEvents(function(e, data) { + app.log(app.toString(), e.cleaned_type, data || {}); + }); + } + }; + + Sammy.Application.prototype = $.extend({}, Sammy.Object.prototype, { + + // the four route verbs + ROUTE_VERBS: ['get','post','put','delete'], + + // An array of the default events triggered by the + // application during its lifecycle + APP_EVENTS: ['run', 'unload', 'lookup-route', 'run-route', 'route-found', 'event-context-before', 'event-context-after', 'changed', 'error', 'check-form-submission', 'redirect', 'location-changed'], + + _last_route: null, + _location_proxy: null, + _running: false, + + // Defines what element the application is bound to. Provide a selector + // (parseable by `jQuery()`) and this will be used by `$element()` + element_selector: 'body', + + // When set to true, logs all of the default events using `log()` + debug: false, + + // When set to true, and the error() handler is not overriden, will actually + // raise JS errors in routes (500) and when routes can't be found (404) + raise_errors: false, + + // The time in milliseconds that the URL is queried for changes + run_interval_every: 50, + + // The default template engine to use when using `partial()` in an + // `EventContext`. `template_engine` can either be a string that + // corresponds to the name of a method/helper on EventContext or it can be a function + // that takes two arguments, the content of the unrendered partial and an optional + // JS object that contains interpolation data. Template engine is only called/refered + // to if the extension of the partial is null or unknown. See `partial()` + // for more information + template_engine: null, + + // //=> Sammy.Application: body + toString: function() { + return 'Sammy.Application:' + this.element_selector; + }, + + // returns a jQuery object of the Applications bound element. + $element: function(selector) { + return selector ? $(this.element_selector).find(selector) : $(this.element_selector); + }, + + // `use()` is the entry point for including Sammy plugins. + // The first argument to use should be a function() that is evaluated + // in the context of the current application, just like the `app_function` + // argument to the `Sammy.Application` constructor. + // + // Any additional arguments are passed to the app function sequentially. + // + // For much more detail about plugins, check out: + // [http://sammyjs.org/docs/plugins](http://sammyjs.org/docs/plugins) + // + // ### Example + // + // var MyPlugin = function(app, prepend) { + // + // this.helpers({ + // myhelper: function(text) { + // alert(prepend + " " + text); + // } + // }); + // + // }; + // + // var app = $.sammy(function() { + // + // this.use(MyPlugin, 'This is my plugin'); + // + // this.get('#/', function() { + // this.myhelper('and dont you forget it!'); + // //=> Alerts: This is my plugin and dont you forget it! + // }); + // + // }); + // + // If plugin is passed as a string it assumes your are trying to load + // Sammy."Plugin". This is the prefered way of loading core Sammy plugins + // as it allows for better error-messaging. + // + // ### Example + // + // $.sammy(function() { + // this.use('Mustache'); //=> Sammy.Mustache + // this.use('Storage'); //=> Sammy.Storage + // }); + // + use: function() { + // flatten the arguments + var args = _makeArray(arguments), + plugin = args.shift(), + plugin_name = plugin || ''; + try { + args.unshift(this); + if (typeof plugin == 'string') { + plugin_name = 'Sammy.' + plugin; + plugin = Sammy[plugin]; + } + plugin.apply(this, args); + } catch(e) { + if (typeof plugin === 'undefined') { + this.error("Plugin Error: called use() but plugin (" + plugin_name.toString() + ") is not defined", e); + } else if (!_isFunction(plugin)) { + this.error("Plugin Error: called use() but '" + plugin_name.toString() + "' is not a function", e); + } else { + this.error("Plugin Error", e); + } + } + return this; + }, + + // Sets the location proxy for the current app. By default this is set to + // a new `Sammy.HashLocationProxy` on initialization. However, you can set + // the location_proxy inside you're app function to give your app a custom + // location mechanism. See `Sammy.HashLocationProxy` and `Sammy.DataLocationProxy` + // for examples. + // + // `setLocationProxy()` takes an initialized location proxy. + // + // ### Example + // + // // to bind to data instead of the default hash; + // var app = $.sammy(function() { + // this.setLocationProxy(new Sammy.DataLocationProxy(this)); + // }); + // + setLocationProxy: function(new_proxy) { + var original_proxy = this._location_proxy; + this._location_proxy = new_proxy; + if (this.isRunning()) { + if (original_proxy) { + // if there is already a location proxy, unbind it. + original_proxy.unbind(); + } + this._location_proxy.bind(); + } + }, + + // `route()` is the main method for defining routes within an application. + // For great detail on routes, check out: + // [http://sammyjs.org/docs/routes](http://sammyjs.org/docs/routes) + // + // This method also has aliases for each of the different verbs (eg. `get()`, `post()`, etc.) + // + // ### Arguments + // + // * `verb` A String in the set of ROUTE_VERBS or 'any'. 'any' will add routes for each + // of the ROUTE_VERBS. If only two arguments are passed, + // the first argument is the path, the second is the callback and the verb + // is assumed to be 'any'. + // * `path` A Regexp or a String representing the path to match to invoke this verb. + // * `callback` A Function that is called/evaluated whent the route is run see: `runRoute()`. + // It is also possible to pass a string as the callback, which is looked up as the name + // of a method on the application. + // + route: function(verb, path, callback) { + var app = this, param_names = [], add_route, path_match; + + // if the method signature is just (path, callback) + // assume the verb is 'any' + if (!callback && _isFunction(path)) { + path = verb; + callback = path; + verb = 'any'; + } + + verb = verb.toLowerCase(); // ensure verb is lower case + + // if path is a string turn it into a regex + if (path.constructor == String) { + + // Needs to be explicitly set because IE will maintain the index unless NULL is returned, + // which means that with two consecutive routes that contain params, the second set of params will not be found and end up in splat instead of params + // https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/RegExp/lastIndex + PATH_NAME_MATCHER.lastIndex = 0; + + // find the names + while ((path_match = PATH_NAME_MATCHER.exec(path)) !== null) { + param_names.push(path_match[1]); + } + // replace with the path replacement + path = new RegExp("^" + path.replace(PATH_NAME_MATCHER, PATH_REPLACER) + "$"); + } + // lookup callback + if (typeof callback == 'string') { + callback = app[callback]; + } + + add_route = function(with_verb) { + var r = {verb: with_verb, path: path, callback: callback, param_names: param_names}; + // add route to routes array + app.routes[with_verb] = app.routes[with_verb] || []; + // place routes in order of definition + app.routes[with_verb].push(r); + }; + + if (verb === 'any') { + $.each(this.ROUTE_VERBS, function(i, v) { add_route(v); }); + } else { + add_route(verb); + } + + // return the app + return this; + }, + + // Alias for route('get', ...) + get: _routeWrapper('get'), + + // Alias for route('post', ...) + post: _routeWrapper('post'), + + // Alias for route('put', ...) + put: _routeWrapper('put'), + + // Alias for route('delete', ...) + del: _routeWrapper('delete'), + + // Alias for route('any', ...) + any: _routeWrapper('any'), + + // `mapRoutes` takes an array of arrays, each array being passed to route() + // as arguments, this allows for mass definition of routes. Another benefit is + // this makes it possible/easier to load routes via remote JSON. + // + // ### Example + // + // var app = $.sammy(function() { + // + // this.mapRoutes([ + // ['get', '#/', function() { this.log('index'); }], + // // strings in callbacks are looked up as methods on the app + // ['post', '#/create', 'addUser'], + // // No verb assumes 'any' as the verb + // [/dowhatever/, function() { this.log(this.verb, this.path)}]; + // ]); + // }); + // + mapRoutes: function(route_array) { + var app = this; + $.each(route_array, function(i, route_args) { + app.route.apply(app, route_args); + }); + return this; + }, + + // A unique event namespace defined per application. + // All events bound with `bind()` are automatically bound within this space. + eventNamespace: function() { + return ['sammy-app', this.namespace].join('-'); + }, + + // Works just like `jQuery.fn.bind()` with a couple noteable differences. + // + // * It binds all events to the application element + // * All events are bound within the `eventNamespace()` + // * Events are not actually bound until the application is started with `run()` + // * callbacks are evaluated within the context of a Sammy.EventContext + // + bind: function(name, data, callback) { + var app = this; + // build the callback + // if the arity is 2, callback is the second argument + if (typeof callback == 'undefined') { callback = data; } + var listener_callback = function() { + // pull off the context from the arguments to the callback + var e, context, data; + e = arguments[0]; + data = arguments[1]; + if (data && data.context) { + context = data.context; + delete data.context; + } else { + context = new app.context_prototype(app, 'bind', e.type, data, e.target); + } + e.cleaned_type = e.type.replace(app.eventNamespace(), ''); + callback.apply(context, [e, data]); + }; + + // it could be that the app element doesnt exist yet + // so attach to the listeners array and then run() + // will actually bind the event. + if (!this.listeners[name]) { this.listeners[name] = []; } + this.listeners[name].push(listener_callback); + if (this.isRunning()) { + // if the app is running + // *actually* bind the event to the app element + this._listen(name, listener_callback); + } + return this; + }, + + // Triggers custom events defined with `bind()` + // + // ### Arguments + // + // * `name` The name of the event. Automatically prefixed with the `eventNamespace()` + // * `data` An optional Object that can be passed to the bound callback. + // * `context` An optional context/Object in which to execute the bound callback. + // If no context is supplied a the context is a new `Sammy.EventContext` + // + trigger: function(name, data) { + this.$element().trigger([name, this.eventNamespace()].join('.'), [data]); + return this; + }, + + // Reruns the current route + refresh: function() { + this.last_location = null; + this.trigger('location-changed'); + return this; + }, + + // Takes a single callback that is pushed on to a stack. + // Before any route is run, the callbacks are evaluated in order within + // the current `Sammy.EventContext` + // + // If any of the callbacks explicitly return false, execution of any + // further callbacks and the route itself is halted. + // + // You can also provide a set of options that will define when to run this + // before based on the route it proceeds. + // + // ### Example + // + // var app = $.sammy(function() { + // + // // will run at #/route but not at #/ + // this.before('#/route', function() { + // //... + // }); + // + // // will run at #/ but not at #/route + // this.before({except: {path: '#/route'}}, function() { + // this.log('not before #/route'); + // }); + // + // this.get('#/', function() {}); + // + // this.get('#/route', function() {}); + // + // }); + // + // See `contextMatchesOptions()` for a full list of supported options + // + before: function(options, callback) { + if (_isFunction(options)) { + callback = options; + options = {}; + } + this.befores.push([options, callback]); + return this; + }, + + // A shortcut for binding a callback to be run after a route is executed. + // After callbacks have no guarunteed order. + after: function(callback) { + return this.bind('event-context-after', callback); + }, + + + // Adds an around filter to the application. around filters are functions + // that take a single argument `callback` which is the entire route + // execution path wrapped up in a closure. This means you can decide whether + // or not to proceed with execution by not invoking `callback` or, + // more usefuly wrapping callback inside the result of an asynchronous execution. + // + // ### Example + // + // The most common use case for around() is calling a _possibly_ async function + // and executing the route within the functions callback: + // + // var app = $.sammy(function() { + // + // var current_user = false; + // + // function checkLoggedIn(callback) { + // // /session returns a JSON representation of the logged in user + // // or an empty object + // if (!current_user) { + // $.getJSON('/session', function(json) { + // if (json.login) { + // // show the user as logged in + // current_user = json; + // // execute the route path + // callback(); + // } else { + // // show the user as not logged in + // current_user = false; + // // the context of aroundFilters is an EventContext + // this.redirect('#/login'); + // } + // }); + // } else { + // // execute the route path + // callback(); + // } + // }; + // + // this.around(checkLoggedIn); + // + // }); + // + around: function(callback) { + this.arounds.push(callback); + return this; + }, + + // Returns `true` if the current application is running. + isRunning: function() { + return this._running; + }, + + // Helpers extends the EventContext prototype specific to this app. + // This allows you to define app specific helper functions that can be used + // whenever you're inside of an event context (templates, routes, bind). + // + // ### Example + // + // var app = $.sammy(function() { + // + // helpers({ + // upcase: function(text) { + // return text.toString().toUpperCase(); + // } + // }); + // + // get('#/', function() { with(this) { + // // inside of this context I can use the helpers + // $('#main').html(upcase($('#main').text()); + // }}); + // + // }); + // + // + // ### Arguments + // + // * `extensions` An object collection of functions to extend the context. + // + helpers: function(extensions) { + $.extend(this.context_prototype.prototype, extensions); + return this; + }, + + // Helper extends the event context just like `helpers()` but does it + // a single method at a time. This is especially useful for dynamically named + // helpers + // + // ### Example + // + // // Trivial example that adds 3 helper methods to the context dynamically + // var app = $.sammy(function(app) { + // + // $.each([1,2,3], function(i, num) { + // app.helper('helper' + num, function() { + // this.log("I'm helper number " + num); + // }); + // }); + // + // this.get('#/', function() { + // this.helper2(); //=> I'm helper number 2 + // }); + // }); + // + // ### Arguments + // + // * `name` The name of the method + // * `method` The function to be added to the prototype at `name` + // + helper: function(name, method) { + this.context_prototype.prototype[name] = method; + return this; + }, + + // Actually starts the application's lifecycle. `run()` should be invoked + // within a document.ready block to ensure the DOM exists before binding events, etc. + // + // ### Example + // + // var app = $.sammy(function() { ... }); // your application + // $(function() { // document.ready + // app.run(); + // }); + // + // ### Arguments + // + // * `start_url` Optionally, a String can be passed which the App will redirect to + // after the events/routes have been bound. + run: function(start_url) { + if (this.isRunning()) { return false; } + var app = this; + + // actually bind all the listeners + $.each(this.listeners.toHash(), function(name, callbacks) { + $.each(callbacks, function(i, listener_callback) { + app._listen(name, listener_callback); + }); + }); + + this.trigger('run', {start_url: start_url}); + this._running = true; + // set last location + this.last_location = null; + if (this.getLocation() == '' && typeof start_url != 'undefined') { + this.setLocation(start_url); + } + // check url + this._checkLocation(); + this._location_proxy.bind(); + this.bind('location-changed', function() { + app._checkLocation(); + }); + + // bind to submit to capture post/put/delete routes + this.bind('submit', function(e) { + var returned = app._checkFormSubmission($(e.target).closest('form')); + return (returned === false) ? e.preventDefault() : false; + }); + + // bind unload to body unload + $(window).bind('beforeunload', function() { + app.unload(); + }); + + // trigger html changed + return this.trigger('changed'); + }, + + // The opposite of `run()`, un-binds all event listeners and intervals + // `run()` Automaticaly binds a `onunload` event to run this when + // the document is closed. + unload: function() { + if (!this.isRunning()) { return false; } + var app = this; + this.trigger('unload'); + // clear interval + this._location_proxy.unbind(); + // unbind form submits + this.$element().unbind('submit').removeClass(app.eventNamespace()); + // unbind all events + $.each(this.listeners.toHash() , function(name, listeners) { + $.each(listeners, function(i, listener_callback) { + app._unlisten(name, listener_callback); + }); + }); + this._running = false; + return this; + }, + + // Will bind a single callback function to every event that is already + // being listened to in the app. This includes all the `APP_EVENTS` + // as well as any custom events defined with `bind()`. + // + // Used internally for debug logging. + bindToAllEvents: function(callback) { + var app = this; + // bind to the APP_EVENTS first + $.each(this.APP_EVENTS, function(i, e) { + app.bind(e, callback); + }); + // next, bind to listener names (only if they dont exist in APP_EVENTS) + $.each(this.listeners.keys(true), function(i, name) { + if (app.APP_EVENTS.indexOf(name) == -1) { + app.bind(name, callback); + } + }); + return this; + }, + + // Returns a copy of the given path with any query string after the hash + // removed. + routablePath: function(path) { + return path.replace(QUERY_STRING_MATCHER, ''); + }, + + // Given a verb and a String path, will return either a route object or false + // if a matching route can be found within the current defined set. + lookupRoute: function(verb, path) { + var app = this, routed = false; + this.trigger('lookup-route', {verb: verb, path: path}); + if (typeof this.routes[verb] != 'undefined') { + $.each(this.routes[verb], function(i, route) { + if (app.routablePath(path).match(route.path)) { + routed = route; + return false; + } + }); + } + return routed; + }, + + // First, invokes `lookupRoute()` and if a route is found, parses the + // possible URL params and then invokes the route's callback within a new + // `Sammy.EventContext`. If the route can not be found, it calls + // `notFound()`. If `raise_errors` is set to `true` and + // the `error()` has not been overriden, it will throw an actual JS + // error. + // + // You probably will never have to call this directly. + // + // ### Arguments + // + // * `verb` A String for the verb. + // * `path` A String path to lookup. + // * `params` An Object of Params pulled from the URI or passed directly. + // + // ### Returns + // + // Either returns the value returned by the route callback or raises a 404 Not Found error. + // + runRoute: function(verb, path, params, target) { + var app = this, + route = this.lookupRoute(verb, path), + context, + wrapped_route, + arounds, + around, + befores, + before, + callback_args, + path_params, + final_returned; + + this.log('runRoute', [verb, path].join(' ')); + this.trigger('run-route', {verb: verb, path: path, params: params}); + if (typeof params == 'undefined') { params = {}; } + + $.extend(params, this._parseQueryString(path)); + + if (route) { + this.trigger('route-found', {route: route}); + // pull out the params from the path + if ((path_params = route.path.exec(this.routablePath(path))) !== null) { + // first match is the full path + path_params.shift(); + // for each of the matches + $.each(path_params, function(i, param) { + // if theres a matching param name + if (route.param_names[i]) { + // set the name to the match + params[route.param_names[i]] = _decode(param); + } else { + // initialize 'splat' + if (!params.splat) { params.splat = []; } + params.splat.push(_decode(param)); + } + }); + } + + // set event context + context = new this.context_prototype(this, verb, path, params, target); + // ensure arrays + arounds = this.arounds.slice(0); + befores = this.befores.slice(0); + // set the callback args to the context + contents of the splat + callback_args = [context].concat(params.splat); + // wrap the route up with the before filters + wrapped_route = function() { + var returned; + while (befores.length > 0) { + before = befores.shift(); + // check the options + if (app.contextMatchesOptions(context, before[0])) { + returned = before[1].apply(context, [context]); + if (returned === false) { return false; } + } + } + app.last_route = route; + context.trigger('event-context-before', {context: context}); + returned = route.callback.apply(context, callback_args); + context.trigger('event-context-after', {context: context}); + return returned; + }; + $.each(arounds.reverse(), function(i, around) { + var last_wrapped_route = wrapped_route; + wrapped_route = function() { return around.apply(context, [last_wrapped_route]); }; + }); + try { + final_returned = wrapped_route(); + } catch(e) { + this.error(['500 Error', verb, path].join(' '), e); + } + return final_returned; + } else { + return this.notFound(verb, path); + } + }, + + // Matches an object of options against an `EventContext` like object that + // contains `path` and `verb` attributes. Internally Sammy uses this + // for matching `before()` filters against specific options. You can set the + // object to _only_ match certain paths or verbs, or match all paths or verbs _except_ + // those that match the options. + // + // ### Example + // + // var app = $.sammy(), + // context = {verb: 'get', path: '#/mypath'}; + // + // // match against a path string + // app.contextMatchesOptions(context, '#/mypath'); //=> true + // app.contextMatchesOptions(context, '#/otherpath'); //=> false + // // equivilent to + // app.contextMatchesOptions(context, {only: {path:'#/mypath'}}); //=> true + // app.contextMatchesOptions(context, {only: {path:'#/otherpath'}}); //=> false + // // match against a path regexp + // app.contextMatchesOptions(context, /path/); //=> true + // app.contextMatchesOptions(context, /^path/); //=> false + // // match only a verb + // app.contextMatchesOptions(context, {only: {verb:'get'}}); //=> true + // app.contextMatchesOptions(context, {only: {verb:'post'}}); //=> false + // // match all except a verb + // app.contextMatchesOptions(context, {except: {verb:'post'}}); //=> true + // app.contextMatchesOptions(context, {except: {verb:'get'}}); //=> false + // // match all except a path + // app.contextMatchesOptions(context, {except: {path:'#/otherpath'}}); //=> true + // app.contextMatchesOptions(context, {except: {path:'#/mypath'}}); //=> false + // + contextMatchesOptions: function(context, match_options, positive) { + // empty options always match + var options = match_options; + if (typeof options === 'undefined' || options == {}) { + return true; + } + if (typeof positive === 'undefined') { + positive = true; + } + // normalize options + if (typeof options === 'string' || _isFunction(options.test)) { + options = {path: options}; + } + if (options.only) { + return this.contextMatchesOptions(context, options.only, true); + } else if (options.except) { + return this.contextMatchesOptions(context, options.except, false); + } + var path_matched = true, verb_matched = true; + if (options.path) { + // wierd regexp test + if (_isFunction(options.path.test)) { + path_matched = options.path.test(context.path); + } else { + path_matched = (options.path.toString() === context.path); + } + } + if (options.verb) { + verb_matched = options.verb === context.verb; + } + return positive ? (verb_matched && path_matched) : !(verb_matched && path_matched); + }, + + + // Delegates to the `location_proxy` to get the current location. + // See `Sammy.HashLocationProxy` for more info on location proxies. + getLocation: function() { + return this._location_proxy.getLocation(); + }, + + // Delegates to the `location_proxy` to set the current location. + // See `Sammy.HashLocationProxy` for more info on location proxies. + // + // ### Arguments + // + // * `new_location` A new location string (e.g. '#/') + // + setLocation: function(new_location) { + return this._location_proxy.setLocation(new_location); + }, + + // Swaps the content of `$element()` with `content` + // You can override this method to provide an alternate swap behavior + // for `EventContext.partial()`. + // + // ### Example + // + // var app = $.sammy(function() { + // + // // implements a 'fade out'/'fade in' + // this.swap = function(content) { + // this.$element().hide('slow').html(content).show('slow'); + // } + // + // get('#/', function() { + // this.partial('index.html.erb') // will fade out and in + // }); + // + // }); + // + swap: function(content) { + return this.$element().html(content); + }, + + // a simple global cache for templates. Uses the same semantics as + // `Sammy.Cache` and `Sammy.Storage` so can easily be replaced with + // a persistant storage that lasts beyond the current request. + templateCache: function(key, value) { + if (typeof value != 'undefined') { + return _template_cache[key] = value; + } else { + return _template_cache[key]; + } + }, + + // clear the templateCache + clearTemplateCache: function() { + return _template_cache = {}; + }, + + // This thows a '404 Not Found' error by invoking `error()`. + // Override this method or `error()` to provide custom + // 404 behavior (i.e redirecting to / or showing a warning) + notFound: function(verb, path) { + var ret = this.error(['404 Not Found', verb, path].join(' ')); + return (verb === 'get') ? ret : true; + }, + + // The base error handler takes a string `message` and an `Error` + // object. If `raise_errors` is set to `true` on the app level, + // this will re-throw the error to the browser. Otherwise it will send the error + // to `log()`. Override this method to provide custom error handling + // e.g logging to a server side component or displaying some feedback to the + // user. + error: function(message, original_error) { + if (!original_error) { original_error = new Error(); } + original_error.message = [message, original_error.message].join(' '); + this.trigger('error', {message: original_error.message, error: original_error}); + if (this.raise_errors) { + throw(original_error); + } else { + this.log(original_error.message, original_error); + } + }, + + _checkLocation: function() { + var location, returned; + // get current location + location = this.getLocation(); + // compare to see if hash has changed + if (!this.last_location || this.last_location[0] != 'get' || this.last_location[1] != location) { + // reset last location + this.last_location = ['get', location]; + // lookup route for current hash + returned = this.runRoute('get', location); + } + return returned; + }, + + _getFormVerb: function(form) { + var $form = $(form), verb, $_method; + $_method = $form.find('input[name="_method"]'); + if ($_method.length > 0) { verb = $_method.val(); } + if (!verb) { verb = $form[0].getAttribute('method'); } + if (!verb || verb == '') { verb = 'get'; } + return $.trim(verb.toString().toLowerCase()); + }, + + _checkFormSubmission: function(form) { + var $form, path, verb, params, returned; + this.trigger('check-form-submission', {form: form}); + $form = $(form); + path = $form.attr('action'); + verb = this._getFormVerb($form); + this.log('_checkFormSubmission', $form, path, verb); + if (verb === 'get') { + this.setLocation(path + '?' + this._serializeFormParams($form)); + returned = false; + } else { + params = $.extend({}, this._parseFormParams($form)); + returned = this.runRoute(verb, path, params, form.get(0)); + }; + return (typeof returned == 'undefined') ? false : returned; + }, + + _serializeFormParams: function($form) { + var queryString = "", + fields = $form.serializeArray(), + i; + if (fields.length > 0) { + queryString = this._encodeFormPair(fields[0].name, fields[0].value); + for (i = 1; i < fields.length; i++) { + queryString = queryString + "&" + this._encodeFormPair(fields[i].name, fields[i].value); + } + } + return queryString; + }, + + _encodeFormPair: function(name, value){ + return _encode(name) + "=" + _encode(value); + }, + + _parseFormParams: function($form) { + var params = {}, + form_fields = $form.serializeArray(), + i; + for (i = 0; i < form_fields.length; i++) { + params = this._parseParamPair(params, form_fields[i].name, form_fields[i].value); + } + return params; + }, + + _parseQueryString: function(path) { + var params = {}, parts, pairs, pair, i; + + parts = path.match(QUERY_STRING_MATCHER); + if (parts) { + pairs = parts[1].split('&'); + for (i = 0; i < pairs.length; i++) { + pair = pairs[i].split('='); + params = this._parseParamPair(params, _decode(pair[0]), _decode(pair[1] || "")); + } + } + return params; + }, + + _parseParamPair: function(params, key, value) { + if (params[key]) { + if (_isArray(params[key])) { + params[key].push(value); + } else { + params[key] = [params[key], value]; + } + } else { + params[key] = value; + } + return params; + }, + + _listen: function(name, callback) { + return this.$element().bind([name, this.eventNamespace()].join('.'), callback); + }, + + _unlisten: function(name, callback) { + return this.$element().unbind([name, this.eventNamespace()].join('.'), callback); + } + + }); + + // `Sammy.RenderContext` is an object that makes sequential template loading, + // rendering and interpolation seamless even when dealing with asyncronous + // operations. + // + // `RenderContext` objects are not usually created directly, rather they are + // instatiated from an `Sammy.EventContext` by using `render()`, `load()` or + // `partial()` which all return `RenderContext` objects. + // + // `RenderContext` methods always returns a modified `RenderContext` + // for chaining (like jQuery itself). + // + // The core magic is in the `then()` method which puts the callback passed as + // an argument into a queue to be executed once the previous callback is complete. + // All the methods of `RenderContext` are wrapped in `then()` which allows you + // to queue up methods by chaining, but maintaing a guarunteed execution order + // even with remote calls to fetch templates. + // + Sammy.RenderContext = function(event_context) { + this.event_context = event_context; + this.callbacks = []; + this.previous_content = null; + this.content = null; + this.next_engine = false; + this.waiting = false; + }; + + Sammy.RenderContext.prototype = $.extend({}, Sammy.Object.prototype, { + + // The "core" of the `RenderContext` object, adds the `callback` to the + // queue. If the context is `waiting` (meaning an async operation is happening) + // then the callback will be executed in order, once the other operations are + // complete. If there is no currently executing operation, the `callback` + // is executed immediately. + // + // The value returned from the callback is stored in `content` for the + // subsiquent operation. If you return `false`, the queue will pause, and + // the next callback in the queue will not be executed until `next()` is + // called. This allows for the guarunteed order of execution while working + // with async operations. + // + // If then() is passed a string instead of a function, the string is looked + // up as a helper method on the event context. + // + // ### Example + // + // this.get('#/', function() { + // // initialize the RenderContext + // // Even though `load()` executes async, the next `then()` + // // wont execute until the load finishes + // this.load('myfile.txt') + // .then(function(content) { + // // the first argument to then is the content of the + // // prev operation + // $('#main').html(content); + // }); + // }); + // + then: function(callback) { + if (!_isFunction(callback)) { + // if a string is passed to then, assume we want to call + // a helper on the event context in its context + if (typeof callback === 'string' && callback in this.event_context) { + var helper = this.event_context[callback]; + callback = function(content) { + return helper.apply(this.event_context, [content]); + }; + } else { + return this; + } + } + var context = this; + if (this.waiting) { + this.callbacks.push(callback); + } else { + this.wait(); + window.setTimeout(function() { + var returned = callback.apply(context, [context.content, context.previous_content]); + if (returned !== false) { + context.next(returned); + } + }, 13); + } + return this; + }, + + // Pause the `RenderContext` queue. Combined with `next()` allows for async + // operations. + // + // ### Example + // + // this.get('#/', function() { + // this.load('mytext.json') + // .then(function(content) { + // var context = this, + // data = JSON.parse(content); + // // pause execution + // context.wait(); + // // post to a url + // $.post(data.url, {}, function(response) { + // context.next(JSON.parse(response)); + // }); + // }) + // .then(function(data) { + // // data is json from the previous post + // $('#message').text(data.status); + // }); + // }); + wait: function() { + this.waiting = true; + }, + + // Resume the queue, setting `content` to be used in the next operation. + // See `wait()` for an example. + next: function(content) { + this.waiting = false; + if (typeof content !== 'undefined') { + this.previous_content = this.content; + this.content = content; + } + if (this.callbacks.length > 0) { + this.then(this.callbacks.shift()); + } + }, + + // Load a template into the context. + // The `location` can either be a string specifiying the remote path to the + // file, a jQuery object, or a DOM element. + // + // No interpolation happens by default, the content is stored in + // `content`. + // + // In the case of a path, unless the option `{cache: false}` is passed the + // data is stored in the app's `templateCache()`. + // + // If a jQuery or DOM object is passed the `innerHTML` of the node is pulled in. + // This is useful for nesting templates as part of the initial page load wrapped + // in invisible elements or `