transit 0.0.1 → 0.0.2

data/app/assets/javascripts/jqtools/scrollable/navigator.js

@@ -0,0 +1,139 @@
+/**
+ * @license 
+ * jQuery Tools @VERSION / Scrollable Navigator
+ * 
+ * NO COPYRIGHTS OR LICENSES. DO WHAT YOU LIKE.
+ *
+ * http://flowplayer.org/tools/scrollable/navigator.html
+ *
+ * Since: September 2009
+ * Date: @DATE 
+ */
+(function($) {
+		
+	var t = $.tools.scrollable; 
+	
+	t.navigator = {
+		
+		conf: {
+			navi: '.navi',
+			naviItem: null,		
+			activeClass: 'active',
+			indexed: false,
+			idPrefix: null,
+			
+			// 1.2
+			history: false
+		}
+	};		
+	
+	function find(root, query) {
+		var el = $(query);
+		return el.length < 2 ? el : root.parent().find(query);
+	}
+	
+	// jQuery plugin implementation
+	$.fn.navigator = function(conf) {
+
+		// configuration
+		if (typeof conf == 'string') { conf = {navi: conf}; } 
+		conf = $.extend({}, t.navigator.conf, conf);
+		
+		var ret;
+		
+		this.each(function() {
+				
+			var api = $(this).data("scrollable"),
+				 navi = conf.navi.jquery ? conf.navi : find(api.getRoot(), conf.navi), 
+				 buttons = api.getNaviButtons(),
+				 cls = conf.activeClass,
+				 history = conf.history && $.fn.history;
+
+			// @deprecated stuff
+			if (api) { ret = api; }
+			
+			api.getNaviButtons = function() {
+				return buttons.add(navi);	
+			}; 
+			
+			
+			function doClick(el, i, e) {
+				api.seekTo(i);				
+				if (history) {
+					if (location.hash) {
+						location.hash = el.attr("href").replace("#", "");	
+					}
+				} else  {
+					return e.preventDefault();			
+				}
+			}
+			
+			function els() {
+				return navi.find(conf.naviItem || '> *');	
+			}
+			
+			function addItem(i) {  
+				
+				var item = $("<" + (conf.naviItem || 'a') + "/>").click(function(e)  {
+					doClick($(this), i, e);
+					
+				}).attr("href", "#" + i);
+				
+				// index number / id attribute
+				if (i === 0) {  item.addClass(cls); }
+				if (conf.indexed)  { item.text(i + 1); }
+				if (conf.idPrefix) { item.attr("id", conf.idPrefix + i); } 
+				
+				return item.appendTo(navi);
+			}
+
+			
+			// generate navigator
+			if (els().length) {
+				els().each(function(i) { 
+					$(this).click(function(e)  {
+						doClick($(this), i, e);		
+					});
+				});
+				
+			} else {
+				$.each(api.getItems(), function(i) {
+					addItem(i); 
+				});
+			}   
+			
+			// activate correct entry
+			api.onBeforeSeek(function(e, index) {
+				setTimeout(function() {
+					if (!e.isDefaultPrevented()) {	
+						var el = els().eq(index);
+						if (!e.isDefaultPrevented() && el.length) {			
+							els().removeClass(cls).eq(index).addClass(cls);
+						}
+					}
+				}, 1);
+			}); 
+			
+			function doHistory(evt, hash) {
+				var el = els().eq(hash.replace("#", ""));
+				if (!el.length) {
+					el = els().filter("[href=" + hash + "]");	
+				}
+				el.click();		
+			}
+			
+			// new item being added
+			api.onAddItem(function(e, item) {
+				item = addItem(api.getItems().index(item)); 
+				if (history)  { item.history(doHistory); }
+			});
+			
+			if (history) { els().history(doHistory); }
+			
+		});		
+		
+		return conf.api ? ret : this;
+		
+	};
+	
+})(jQuery);

data/app/assets/javascripts/jqtools/validator.js

@@ -0,0 +1,590 @@
+/**
+ * @license 
+ * jQuery Tools Validator @VERSION - HTML5 is here. Now use it.
+ * 
+ * NO COPYRIGHTS OR LICENSES. DO WHAT YOU LIKE.
+ * 
+ * http://flowplayer.org/tools/form/validator/
+ * 
+ * Since: Mar 2010
+ * Date: @DATE 
+ */
+/*jslint evil: true */ 
+(function($) {	
+
+	$.tools = $.tools || {version: '@VERSION'};
+		
+	// globals
+	var typeRe = /\[type=([a-z]+)\]/, 
+		numRe = /^-?[0-9]*(\.[0-9]+)?$/,
+		dateInput = $.tools.dateinput,
+		
+		// http://net.tutsplus.com/tutorials/other/8-regular-expressions-you-should-know/
+		emailRe = /^([a-z0-9_\.\-\+]+)@([\da-z\.\-]+)\.([a-z\.]{2,6})$/i,
+		urlRe = /^(https?:\/\/)?[\da-z\.\-]+\.[a-z\.]{2,6}[#&+_\?\/\w \.\-=]*$/i,
+		v;
+		 
+	v = $.tools.validator = {
+		
+		conf: {   
+			grouped: false, 				// show all error messages at once inside the container 
+			effect: 'default',			// show/hide effect for error message. only 'default' is built-in
+			errorClass: 'invalid',		// input field class name in case of validation error		
+			
+			// when to check for validity?
+			inputEvent: null,				// change, blur, keyup, null 
+			errorInputEvent: 'keyup',  // change, blur, keyup, null
+			formEvent: 'submit',       // submit, null
+
+			lang: 'en',						// default language for error messages 
+			message: '<div/>',
+			messageAttr: 'data-message', // name of the attribute for overridden error message
+			messageClass: 'error',		// error message element's class name
+			offset: [0, 0], 
+			position: 'center right',
+			singleError: false, 			// validate all inputs at once
+			speed: 'normal'				// message's fade-in speed			
+		},
+
+
+		/* The Error Messages */
+		messages: {
+			"*": { en: "Please correct this value" }		
+		},
+		
+		localize: function(lang, messages) { 
+			$.each(messages, function(key, msg)  {
+				v.messages[key] = v.messages[key] || {};
+				v.messages[key][lang] = msg;		
+			});
+		},
+		
+		localizeFn: function(key, messages) {
+			v.messages[key] = v.messages[key] || {};
+			$.extend(v.messages[key], messages);
+		},
+		
+		/** 
+		 * Adds a new validator 
+		 */
+		fn: function(matcher, msg, fn) {
+			
+			// no message supplied
+			if ($.isFunction(msg)) { 
+				fn = msg; 
+				
+			// message(s) on second argument
+			} else {
+				if (typeof msg == 'string') { msg = {en: msg}; }
+				this.messages[matcher.key || matcher] = msg;
+			}
+
+			// check for "[type=xxx]" (not supported by jQuery)
+			var test = typeRe.exec(matcher);                                    
+			if (test) { matcher = isType(test[1]); }				
+			
+			// add validator to the arsenal
+			fns.push([matcher, fn]);		 
+		},
+
+		/* Add new show/hide effect */
+		addEffect: function(name, showFn, closeFn) {
+			effects[name] = [showFn, closeFn];
+		}
+		
+	};
+	
+	/* calculate error message position relative to the input */  	
+	function getPosition(trigger, el, conf) {	
+		
+		// get origin top/left position 
+		var top = trigger.offset().top, 
+			 left = trigger.offset().left,	 
+			 pos = conf.position.split(/,?\s+/),
+			 y = pos[0],
+			 x = pos[1];
+		
+		top  -= el.outerHeight() - conf.offset[0];
+		left += trigger.outerWidth() + conf.offset[1];
+		
+		
+		// iPad position fix
+		if (/iPad/i.test(navigator.userAgent)) {
+			top -= $(window).scrollTop();
+		}
+		
+		// adjust Y		
+		var height = el.outerHeight() + trigger.outerHeight();
+		if (y == 'center') 	{ top += height / 2; }
+		if (y == 'bottom') 	{ top += height; }
+		
+		// adjust X
+		var width = trigger.outerWidth();
+		if (x == 'center') 	{ left -= (width  + el.outerWidth()) / 2; }
+		if (x == 'left')  	{ left -= width; }	 
+		
+		return {top: top, left: left};
+	}	
+	
+
+	
+	// $.is("[type=xxx]") or $.filter("[type=xxx]") not working in jQuery 1.3.2 or 1.4.2
+	function isType(type) { 
+		function fn() {
+			return this.getAttribute("type") == type;  	
+		} 
+		fn.key = "[type=" + type + "]";
+		return fn;
+	}	
+
+	
+	var fns = [], effects = {
+		
+		'default' : [
+			
+			// show errors function
+			function(errs) {
+				
+				var conf = this.getConf();
+				
+				// loop errors
+				$.each(errs, function(i, err) {
+						
+					// add error class	
+					var input = err.input;					
+					input.addClass(conf.errorClass);
+					
+					// get handle to the error container
+					var msg = input.data("msg.el"); 
+					
+					// create it if not present
+					if (!msg) { 
+						msg = $(conf.message).addClass(conf.messageClass).appendTo(document.body);
+						input.data("msg.el", msg);
+					}  
+					
+					// clear the container 
+					msg.css({visibility: 'hidden'}).find("p").remove();
+					
+					// populate messages
+					$.each(err.messages, function(i, m) { 
+						$("<p/>").html(m).appendTo(msg);			
+					});
+					
+					// make sure the width is not full body width so it can be positioned correctly
+					if (msg.outerWidth() == msg.parent().width()) {
+						msg.add(msg.find("p")).css({display: 'inline'});		
+					} 
+					
+					// insert into correct position (relative to the field)
+					var pos = getPosition(input, msg, conf); 
+					 
+					msg.css({ visibility: 'visible', position: 'absolute', top: pos.top, left: pos.left })
+						.fadeIn(conf.speed);     
+				});
+						
+				
+			// hide errors function
+			}, function(inputs) {
+
+				var conf = this.getConf();				
+				inputs.removeClass(conf.errorClass).each(function() {
+					var msg = $(this).data("msg.el");
+					if (msg) { msg.css({visibility: 'hidden'}); }
+				});
+			}
+		]  
+	};
+
+	
+	/* sperial selectors */
+	$.each("email,url,number".split(","), function(i, key) {
+		$.expr[':'][key] = function(el) {
+			return el.getAttribute("type") === key;
+		};
+	});
+	
+
+	/* 
+		oninvalid() jQuery plugin. 
+		Usage: $("input:eq(2)").oninvalid(function() { ... });
+	*/
+	$.fn.oninvalid = function( fn ){
+		return this[fn ? "bind" : "trigger"]("OI", fn);
+	};
+	
+	
+	/******* built-in HTML5 standard validators *********/
+	
+	v.fn(":email", "Please enter a valid email address", function(el, v) {
+		return !v || emailRe.test(v);
+	});
+	
+	v.fn(":url", "Please enter a valid URL", function(el, v) {
+		return !v || urlRe.test(v);
+	});
+	
+	v.fn(":number", "Please enter a numeric value.", function(el, v) {
+		return numRe.test(v);			
+	});
+	
+	v.fn("[max]", "Please enter a value smaller than $1", function(el, v) {
+			
+		// skip empty values and dateinputs
+		if (v === '' || dateInput && el.is(":date")) { return true; }	
+		
+		var max = el.attr("max");
+		return parseFloat(v) <= parseFloat(max) ? true : [max];
+	});
+	
+	v.fn("[min]", "Please enter a value larger than $1", function(el, v) {
+
+		// skip empty values and dateinputs
+		if (v === '' || dateInput && el.is(":date")) { return true; }
+
+		var min = el.attr("min");
+		return parseFloat(v) >= parseFloat(min) ? true : [min];
+	});
+	
+	v.fn("[required]", "Please complete this mandatory field.", function(el, v) {
+		if (el.is(":checkbox")) { return el.is(":checked"); }
+		return !!v; 			
+	});
+	
+	v.fn("[pattern]", function(el) {
+		var p = new RegExp("^" + el.attr("pattern") + "$");  
+		return p.test(el.val()); 			
+	});
+
+	
+	function Validator(inputs, form, conf) {		
+		
+		// private variables
+		var self = this, 
+			 fire = form.add(self);
+
+		// make sure there are input fields available
+		inputs = inputs.not(":button, :image, :reset, :submit");			 
+
+		// utility function
+		function pushMessage(to, matcher, returnValue) {
+			
+			// only one message allowed
+			if (!conf.grouped && to.length) { return; }
+			
+			// the error message
+			var msg;
+			
+			// substitutions are returned
+			if (returnValue === false || $.isArray(returnValue)) {
+				msg = v.messages[matcher.key || matcher] || v.messages["*"];
+				msg = msg[conf.lang] || v.messages["*"].en;
+
+				// substitution
+				var matches = msg.match(/\$\d/g);
+				
+				if (matches && $.isArray(returnValue)) {
+					$.each(matches, function(i) {
+						msg = msg.replace(this, returnValue[i]);
+					});
+				} 					 
+				
+			// error message is returned directly
+			} else {
+				msg = returnValue[conf.lang] || returnValue;
+			}
+			
+			to.push(msg);
+		}
+		
+		
+		// API methods  
+		$.extend(self, {
+
+			getConf: function() {
+				return conf;	
+			},
+			
+			getForm: function() {
+				return form;		
+			},
+			
+			getInputs: function() {
+				return inputs;	
+			},		
+			
+			reflow: function() {
+				inputs.each(function()  {
+					var input = $(this),
+						 msg = input.data("msg.el");
+						 
+					if (msg) {						
+						var pos = getPosition(input, msg, conf);
+						msg.css({ top: pos.top, left: pos.left });
+					}
+				});
+				return self;
+			},
+			
+			/* @param e - for internal use only */
+			invalidate: function(errs, e) {
+				
+				// errors are given manually: { fieldName1: 'message1', fieldName2: 'message2' }
+				if (!e) {
+					var errors = [];
+					$.each(errs, function(key, val) {
+						var input = inputs.filter("[name='" + key + "']");
+						if (input.length) {
+							
+							// trigger HTML5 ininvalid event
+							input.trigger("OI", [val]);
+							
+							errors.push({ input: input, messages: [val]});				
+						}
+					});
+
+				  	errs = errors; 
+					e = $.Event();
+				}
+				
+				// onFail callback
+				e.type = "onFail";					
+				fire.trigger(e, [errs]); 
+				
+				// call the effect
+				if (!e.isDefaultPrevented()) {						
+					effects[conf.effect][0].call(self, errs, e);													
+				}
+				
+				return self;
+			},
+			
+			reset: function(els) {
+				els = els || inputs;
+				els.removeClass(conf.errorClass).each(function()  {
+					var msg = $(this).data("msg.el");
+					if (msg) {
+						msg.remove();
+						$(this).data("msg.el", null);
+					}
+				}).unbind(conf.errorInputEvent || '');
+				return self;
+			},
+			
+			destroy: function() { 
+				form.unbind(conf.formEvent + ".V").unbind("reset.V"); 
+				inputs.unbind(conf.inputEvent + ".V").unbind("change.V");
+				return self.reset();	
+			}, 
+			
+			
+//{{{  checkValidity() - flesh and bone of this tool
+						
+			/* @returns boolean */
+			checkValidity: function(els, e) {
+				
+				els = els || inputs;    
+				els = els.not(":disabled");
+				if (!els.length) { return true; }
+
+				e = e || $.Event();
+
+				// onBeforeValidate
+				e.type = "onBeforeValidate";
+				fire.trigger(e, [els]);				
+				if (e.isDefaultPrevented()) { return e.result; }				
+					
+				// container for errors
+				var errs = [];
+ 
+				// loop trough the inputs
+				els.not(":radio:not(:checked)").each(function() {
+						
+					// field and it's error message container						
+					var msgs = [], 
+						 el = $(this).data("messages", msgs),
+						 event = dateInput && el.is(":date") ? "onHide.v" : conf.errorInputEvent + ".v";					
+					
+					// cleanup previous validation event
+					el.unbind(event);
+					
+					
+					// loop all validator functions
+					$.each(fns, function() {
+						var fn = this, match = fn[0]; 
+					
+						// match found
+						if (el.filter(match).length)  {  
+							
+							// execute a validator function
+							var returnValue = fn[1].call(self, el, el.val());
+							
+							
+							// validation failed. multiple substitutions can be returned with an array
+							if (returnValue !== true) {								
+								
+								// onBeforeFail
+								e.type = "onBeforeFail";
+								fire.trigger(e, [el, match]);
+								if (e.isDefaultPrevented()) { return false; }
+								
+								// overridden custom message
+								var msg = el.attr(conf.messageAttr);
+								if (msg) { 
+									msgs = [msg];
+									return false;
+								} else {
+									pushMessage(msgs, match, returnValue);
+								}
+							}							
+						}
+					});
+					
+					if (msgs.length) { 
+						
+						errs.push({input: el, messages: msgs});  
+						
+						// trigger HTML5 ininvalid event
+						el.trigger("OI", [msgs]);
+						
+						// begin validating upon error event type (such as keyup) 
+						if (conf.errorInputEvent) {							
+							el.bind(event, function(e) {
+								self.checkValidity(el, e);		
+							});							
+						} 					
+					}
+					
+					if (conf.singleError && errs.length) { return false; }
+					
+				});
+				
+				
+				// validation done. now check that we have a proper effect at hand
+				var eff = effects[conf.effect];
+				if (!eff) { throw "Validator: cannot find effect \"" + conf.effect + "\""; }
+				
+				// errors found
+				if (errs.length) {					 
+					self.invalidate(errs, e); 
+					return false;
+					
+				// no errors
+				} else {
+					
+					// call the effect
+					eff[1].call(self, els, e);
+					
+					// onSuccess callback
+					e.type = "onSuccess";					
+					fire.trigger(e, [els]);
+					
+					els.unbind(conf.errorInputEvent + ".v");
+				}
+				
+				return true;				
+			}
+//}}} 
+			
+		});
+		
+		// callbacks	
+		$.each("onBeforeValidate,onBeforeFail,onFail,onSuccess".split(","), function(i, name) {
+				
+			// configuration
+			if ($.isFunction(conf[name]))  {
+				$(self).bind(name, conf[name]);	
+			}
+			
+			// API methods				
+			self[name] = function(fn) {
+				if (fn) { $(self).bind(name, fn); }
+				return self;
+			};
+		});	
+		
+		
+		// form validation
+		if (conf.formEvent) {
+			form.bind(conf.formEvent + ".V", function(e) {
+				if (!self.checkValidity(null, e)) { 
+					return e.preventDefault(); 
+				}
+			});
+		}
+		
+		// form reset
+		form.bind("reset.V", function()  {
+			self.reset();			
+		});
+		
+		// disable browser's default validation mechanism
+		if (inputs[0] && inputs[0].validity) {
+			inputs.each(function()  {
+				this.oninvalid = function() { 
+					return false; 
+				};		
+			});
+		}
+		
+		// Web Forms 2.0 compatibility
+		if (form[0]) {
+			form[0].checkValidity = self.checkValidity;
+		}
+		
+		// input validation               
+		if (conf.inputEvent) {
+			inputs.bind(conf.inputEvent + ".V", function(e) {
+				self.checkValidity($(this), e);
+			});	
+		} 
+	
+		// checkboxes, selects and radios are checked separately
+		inputs.filter(":checkbox, select").filter("[required]").bind("change.V", function(e) {
+			var el = $(this);
+			if (this.checked || (el.is("select") && $(this).val())) {
+				effects[conf.effect][1].call(self, el, e); 
+			}
+		});		
+		
+		var radios = inputs.filter(":radio").change(function(e) {
+			self.checkValidity(radios, e);
+		});
+		
+		// reposition tooltips when window is resized
+		$(window).resize(function() {
+			self.reflow();		
+		});
+	}
+
+	
+	// jQuery plugin initialization
+	$.fn.validator = function(conf) { 
+		
+		var instance = this.data("validator");
+		
+		// destroy existing instance
+		if (instance) { 
+			instance.destroy();
+			this.removeData("validator");
+		} 
+		
+		// configuration
+		conf = $.extend(true, {}, v.conf, conf);		
+		
+		// selector is a form		
+		if (this.is("form")) {
+			return this.each(function() {			
+				var form = $(this); 
+				instance = new Validator(form.find(":input"), form, conf);	 
+				form.data("validator", instance);
+			});
+			
+		} else {
+			instance = new Validator(this, this.eq(0).closest("form"), conf);
+			return this.data("validator", instance);
+		}     
+		
+	};   
+		
+})(jQuery);