webshims-rails 0.3 → 0.4

data/vendor/assets/javascripts/webshims/dev/shims/form-message.js

@@ -0,0 +1,164 @@
+jQuery.webshims.register('form-message', function($, webshims, window, document, undefined, options){
+	var validityMessages = webshims.validityMessages;
+	
+	var implementProperties = (options.overrideMessages || options.customMessages) ? ['customValidationMessage'] : [];
+	
+	validityMessages['en'] = $.extend(true, {
+		typeMismatch: {
+			email: 'Please enter an email address.',
+			url: 'Please enter a URL.',
+			number: 'Please enter a number.',
+			date: 'Please enter a date.',
+			time: 'Please enter a time.',
+			range: 'Invalid input.',
+			"datetime-local": 'Please enter a datetime.'
+		},
+		rangeUnderflow: {
+			defaultMessage: 'Value must be greater than or equal to {%min}.'
+		},
+		rangeOverflow: {
+			defaultMessage: 'Value must be less than or equal to {%max}.'
+		},
+		stepMismatch: 'Invalid input.',
+		tooLong: 'Please enter at most {%maxlength} character(s). You entered {%valueLen}.',
+		
+		patternMismatch: 'Invalid input. {%title}',
+		valueMissing: {
+			defaultMessage: 'Please fill out this field.',
+			checkbox: 'Please check this box if you want to proceed.'
+		}
+	}, (validityMessages['en'] || validityMessages['en-US'] || {}));
+	
+	
+	['select', 'radio'].forEach(function(type){
+		validityMessages['en'].valueMissing[type] = 'Please select an option.';
+	});
+	
+	['date', 'time', 'datetime-local'].forEach(function(type){
+		validityMessages.en.rangeUnderflow[type] = 'Value must be at or after {%min}.';
+	});
+	['date', 'time', 'datetime-local'].forEach(function(type){
+		validityMessages.en.rangeOverflow[type] = 'Value must be at or before {%max}.';
+	});
+	
+	validityMessages['en-US'] = validityMessages['en-US'] || validityMessages['en'];
+	validityMessages[''] = validityMessages[''] || validityMessages['en-US'];
+	
+	validityMessages['de'] = $.extend(true, {
+		typeMismatch: {
+			email: '{%value} ist keine zulässige E-Mail-Adresse',
+			url: '{%value} ist keine zulässige Webadresse',
+			number: '{%value} ist keine Nummer!',
+			date: '{%value} ist kein Datum',
+			time: '{%value} ist keine Uhrzeit',
+			range: '{%value} ist keine Nummer!',
+			"datetime-local": '{%value} ist kein Datum-Uhrzeit Format.'
+		},
+		rangeUnderflow: {
+			defaultMessage: '{%value} ist zu niedrig. {%min} ist der unterste Wert, den Sie benutzen können.'
+		},
+		rangeOverflow: {
+			defaultMessage: '{%value} ist zu hoch. {%max} ist der oberste Wert, den Sie benutzen können.'
+		},
+		stepMismatch: 'Der Wert {%value} ist in diesem Feld nicht zulässig. Hier sind nur bestimmte Werte zulässig. {%title}',
+		tooLong: 'Der eingegebene Text ist zu lang! Sie haben {%valueLen} Zeichen eingegeben, dabei sind {%maxlength} das Maximum.',
+		patternMismatch: '{%value} hat für dieses Eingabefeld ein falsches Format! {%title}',
+		valueMissing: {
+			defaultMessage: 'Bitte geben Sie einen Wert ein',
+			checkbox: 'Bitte aktivieren Sie das Kästchen'
+		}
+	}, (validityMessages['de'] || {}));
+	
+	['select', 'radio'].forEach(function(type){
+		validityMessages['de'].valueMissing[type] = 'Bitte wählen Sie eine Option aus';
+	});
+	
+	['date', 'time', 'datetime-local'].forEach(function(type){
+		validityMessages.de.rangeUnderflow[type] = '{%value} ist zu früh. {%min} ist die früheste Zeit, die Sie benutzen können.';
+	});
+	['date', 'time', 'datetime-local'].forEach(function(type){
+		validityMessages.de.rangeOverflow[type] = '{%value} ist zu spät. {%max} ist die späteste Zeit, die Sie benutzen können.';
+	});
+	
+	var currentValidationMessage =  validityMessages[''];
+	
+	
+	webshims.createValidationMessage = function(elem, name){
+		var message = currentValidationMessage[name];
+		if(message && typeof message !== 'string'){
+			message = message[ $.prop(elem, 'type') ] || message[ (elem.nodeName || '').toLowerCase() ] || message[ 'defaultMessage' ];
+		}
+		if(message){
+			['value', 'min', 'max', 'title', 'maxlength', 'label'].forEach(function(attr){
+				if(message.indexOf('{%'+attr) === -1){return;}
+				var val = ((attr == 'label') ? $.trim($('label[for="'+ elem.id +'"]', elem.form).text()).replace(/\*$|:$/, '') : $.attr(elem, attr)) || '';
+				if(name == 'patternMismatch' && attr == 'title' && !val){
+					webshims.error('no title for patternMismatch provided. Always add a title attribute.');
+				}
+				message = message.replace('{%'+ attr +'}', val);
+				if('value' == attr){
+					message = message.replace('{%valueLen}', val.length);
+				}
+			});
+		}
+		return message || '';
+	};
+	
+	
+	if(webshims.bugs.validationMessage || !Modernizr.formvalidation || webshims.bugs.bustedValidity){
+		implementProperties.push('validationMessage');
+	}
+	
+	webshims.activeLang({
+		langObj: validityMessages, 
+		module: 'form-core', 
+		callback: function(langObj){
+			currentValidationMessage = langObj;
+		}
+	});
+	
+	implementProperties.forEach(function(messageProp){
+		webshims.defineNodeNamesProperty(['fieldset', 'output', 'button'], messageProp, {
+			prop: {
+				value: '',
+				writeable: false
+			}
+		});
+		['input', 'select', 'textarea'].forEach(function(nodeName){
+			var desc = webshims.defineNodeNameProperty(nodeName, messageProp, {
+				prop: {
+					get: function(){
+						var elem = this;
+						var message = '';
+						if(!$.prop(elem, 'willValidate')){
+							return message;
+						}
+						
+						var validity = $.prop(elem, 'validity') || {valid: 1};
+						
+						if(validity.valid){return message;}
+						message = webshims.getContentValidationMessage(elem, validity);
+						
+						if(message){return message;}
+						
+						if(validity.customError && elem.nodeName){
+							message = (Modernizr.formvalidation && !webshims.bugs.bustedValidity && desc.prop._supget) ? desc.prop._supget.call(elem) : webshims.data(elem, 'customvalidationMessage');
+							if(message){return message;}
+						}
+						$.each(validity, function(name, prop){
+							if(name == 'valid' || !prop){return;}
+							
+							message = webshims.createValidationMessage(elem, name);
+							if(message){
+								return false;
+							}
+						});
+						return message || '';
+					},
+					writeable: false
+				}
+			});
+		});
+		
+	});
+});

data/vendor/assets/javascripts/webshims/dev/shims/form-native-extend.js

@@ -0,0 +1,256 @@
+jQuery.webshims.register('form-extend', function($, webshims, window, doc, undefined, options){
+	"use strict";
+	var Modernizr = window.Modernizr;
+	var modernizrInputTypes = Modernizr.inputtypes;
+	if(!Modernizr.formvalidation || webshims.bugs.bustedValidity){return;}
+	var typeModels = webshims.inputTypes;
+	var validityRules = {};
+	
+	webshims.addInputType = function(type, obj){
+		typeModels[type] = obj;
+	};
+	
+	webshims.addValidityRule = function(type, fn){
+		validityRules[type] = fn;
+	};
+	
+	webshims.addValidityRule('typeMismatch',function (input, val, cache, validityState){
+		if(val === ''){return false;}
+		var ret = validityState.typeMismatch;
+		if(!('type' in cache)){
+			cache.type = (input[0].getAttribute('type') || '').toLowerCase();
+		}
+		
+		if(typeModels[cache.type] && typeModels[cache.type].mismatch){
+			ret = typeModels[cache.type].mismatch(val, input);
+		}
+		return ret;
+	});
+	
+	var overrideNativeMessages = options.overrideMessages;	
+	
+	var overrideValidity = (!modernizrInputTypes.number || !modernizrInputTypes.time || !modernizrInputTypes.range || overrideNativeMessages);
+	var validityProps = ['customError','typeMismatch','rangeUnderflow','rangeOverflow','stepMismatch','tooLong','patternMismatch','valueMissing','valid'];
+	
+	var validityChanger = (overrideNativeMessages)? ['value', 'checked'] : ['value'];
+	var validityElements = [];
+	var testValidity = function(elem, init){
+		if(!elem){return;}
+		var type = (elem.getAttribute && elem.getAttribute('type') || elem.type || '').toLowerCase();
+		
+		if(!overrideNativeMessages && !typeModels[type]){
+			return;
+		}
+		
+		if(overrideNativeMessages && !init && type == 'radio' && elem.name){
+			$(doc.getElementsByName( elem.name )).each(function(){
+				$.prop(this, 'validity');
+			});
+		} else {
+			$.prop(elem, 'validity');
+		}
+	};
+	
+	var oldSetCustomValidity = {};
+	['input', 'textarea', 'select'].forEach(function(name){
+		var desc = webshims.defineNodeNameProperty(name, 'setCustomValidity', {
+			prop: {
+				value: function(error){
+					error = error+'';
+					var elem = (name == 'input') ? $(this).getNativeElement()[0] : this;
+					desc.prop._supvalue.call(elem, error);
+					
+					if(webshims.bugs.validationMessage){
+						webshims.data(elem, 'customvalidationMessage', error);
+					}
+					if(overrideValidity){
+						webshims.data(elem, 'hasCustomError', !!(error));
+						testValidity(elem);
+					}
+				}
+			}
+		});
+		oldSetCustomValidity[name] = desc.prop._supvalue;
+	});
+		
+	
+	if(overrideValidity || overrideNativeMessages){
+		validityChanger.push('min');
+		validityChanger.push('max');
+		validityChanger.push('step');
+		validityElements.push('input');
+	}
+	if(overrideNativeMessages){
+		validityChanger.push('required');
+		validityChanger.push('pattern');
+		validityElements.push('select');
+		validityElements.push('textarea');
+	}
+	
+	if(overrideValidity){
+		var stopValidity;
+		validityElements.forEach(function(nodeName){
+			
+			var oldDesc = webshims.defineNodeNameProperty(nodeName, 'validity', {
+				prop: {
+					get: function(){
+						if(stopValidity){return;}
+						var elem = (nodeName == 'input') ? $(this).getNativeElement()[0] : this;
+						
+						var validity = oldDesc.prop._supget.call(elem);
+						
+						if(!validity){
+							return validity;
+						}
+						var validityState = {};
+						validityProps.forEach(function(prop){
+							validityState[prop] = validity[prop];
+						});
+						
+						if( !$.prop(elem, 'willValidate') ){
+							return validityState;
+						}
+						stopValidity = true;
+						var jElm 			= $(elem),
+							cache 			= {type: (elem.getAttribute && elem.getAttribute('type') || '').toLowerCase(), nodeName: (elem.nodeName || '').toLowerCase()},
+							val				= jElm.val(),
+							customError 	= !!(webshims.data(elem, 'hasCustomError')),
+							setCustomMessage
+						;
+						stopValidity = false;
+						validityState.customError = customError;
+						
+						if( validityState.valid && validityState.customError ){
+							validityState.valid = false;
+						} else if(!validityState.valid) {
+							var allFalse = true;
+							$.each(validityState, function(name, prop){
+								if(prop){
+									allFalse = false;
+									return false;
+								}
+							});
+							
+							if(allFalse){
+								validityState.valid = true;
+							}
+							
+						}
+						
+						$.each(validityRules, function(rule, fn){
+							validityState[rule] = fn(jElm, val, cache, validityState);
+							if( validityState[rule] && (validityState.valid || !setCustomMessage) && (overrideNativeMessages || (typeModels[cache.type] && typeModels[cache.type].mismatch)) ) {
+								oldSetCustomValidity[nodeName].call(elem, webshims.createValidationMessage(elem, rule));
+								validityState.valid = false;
+								setCustomMessage = true;
+							}
+						});
+						if(validityState.valid){
+							oldSetCustomValidity[nodeName].call(elem, '');
+							webshims.data(elem, 'hasCustomError', false);
+						} else if(overrideNativeMessages && !setCustomMessage && !customError){
+							$.each(validityState, function(name, prop){
+								if(name !== 'valid' && prop){
+									oldSetCustomValidity[nodeName].call(elem, webshims.createValidationMessage(elem, name));
+									return false;
+								}
+							});
+						}
+						return validityState;
+					},
+					writeable: false
+					
+				}
+			});
+		});
+
+		validityChanger.forEach(function(prop){
+			webshims.onNodeNamesPropertyModify(validityElements, prop, function(s){
+				testValidity(this);
+			});
+		});
+		
+		if(doc.addEventListener){
+			var inputThrottle;
+			var testPassValidity = function(e){
+				if(!('form' in e.target)){return;}
+				var form = e.target.form;
+				clearTimeout(inputThrottle);
+				testValidity(e.target);
+				if(form && overrideNativeMessages){
+					$('input', form).each(function(){
+						if(this.type == 'password'){
+							testValidity(this);
+						}
+					});
+				}
+			};
+			
+			doc.addEventListener('change', testPassValidity, true);
+			
+			if(overrideNativeMessages){
+				doc.addEventListener('blur', testPassValidity, true);
+				doc.addEventListener('keydown', function(e){
+					if(e.keyCode != 13){return;}
+					testPassValidity(e);
+				}, true);
+			}
+			
+			doc.addEventListener('input', function(e){
+				clearTimeout(inputThrottle);
+				inputThrottle = setTimeout(function(){
+					testValidity(e.target);
+				}, 290);
+			}, true);
+		}
+		
+		var validityElementsSel = validityElements.join(',');	
+		
+		webshims.addReady(function(context, elem){
+			$(validityElementsSel, context).add(elem.filter(validityElementsSel)).each(function(){
+				$.prop(this, 'validity');
+			});
+		});
+		
+		
+		if(overrideNativeMessages){
+			webshims.ready('DOM form-message', function(){
+				webshims.activeLang({
+					register: 'form-core',
+					callback: function(){
+						$('input, select, textarea')
+							.getNativeElement()
+							.each(function(){
+								if(webshims.data(this, 'hasCustomError')){return;}
+								var elem = this;
+								var validity = $.prop(elem, 'validity') || {valid: true};
+								var nodeName;
+								if(validity.valid){return;}
+								nodeName = (elem.nodeName || '').toLowerCase();
+								$.each(validity, function(name, prop){
+									if(name !== 'valid' && prop){
+										oldSetCustomValidity[nodeName].call(elem, webshims.createValidationMessage(elem, name));
+										return false;
+									}
+								});
+							})
+						;
+					}
+				});
+			});
+		}
+		
+	} //end: overrideValidity
+	
+	webshims.defineNodeNameProperty('input', 'type', {
+		prop: {
+			get: function(){
+				var elem = this;
+				var type = (elem.getAttribute('type') || '').toLowerCase();
+				return (webshims.inputTypes[type]) ? type : elem.type;
+			}
+		}
+	});
+	
+	
+});

data/vendor/assets/javascripts/webshims/dev/shims/form-native-fix.js

@@ -0,0 +1,261 @@
+jQuery.webshims.register('form-native-fix', function($, webshims, window, doc, undefined){
+	
+	if(!Modernizr.formvalidation || Modernizr.bugfreeformvalidation || webshims.bugs.bustedValidity){return;}
+	
+	var badWebkit = ($.browser.webkit);
+//	var badValidity = badWebkit && webshims.browserVersion <= 534.4;
+	var invalidSelector = 'input:invalid, select:invalid, textarea:invalid';
+	var invalids = [],
+		firstInvalidEvent,
+		form
+	;
+	
+	var isChangeSubmit;
+	
+	
+	//opera/chrome fix (this will double all invalid events in opera, we have to stop them!)
+	//opera throws a submit-event and then the invalid events,
+	//chrome7/safari5.0.2 has disabled invalid events, this brings them back
+	//safari 5.0.2 reports false invalid events, if setCustomValidity was used
+	if(window.addEventListener){
+		var formnovalidate = {
+			timer: undefined,
+			prevented: false
+		};
+		window.addEventListener('submit', function(e){
+			if(!formnovalidate.prevented && e.target.checkValidity && $.attr(e.target, 'novalidate') == null){
+				isChangeSubmit = true;
+				if($(invalidSelector, e.target).length){
+					$(e.target)
+						.unbind('submit.preventInvalidSubmit')
+						.bind('submit.preventInvalidSubmit', function(submitEvent){
+							if( $.attr(e.target, 'novalidate') == null ){
+								submitEvent.stopImmediatePropagation();
+								if(badWebkit){
+									submitEvent.preventDefault();
+								}
+							}
+							if(e.target){
+								$(e.target).unbind('submit.preventInvalidSubmit');
+							}
+						})
+					;
+					webshims.moveToFirstEvent(e.target, 'submit');
+				}
+				isChangeSubmit = false;
+				if(!window.opera){
+					webshims.fromSubmit = true;
+					$(e.target).checkValidity();
+					webshims.fromSubmit = false;
+				}
+				
+			}
+		}, true);
+		
+		var preventValidityTest = function(e){
+			if($.attr(e.target, 'formnovalidate') == null){return;}
+			if(formnovalidate.timer){
+				clearTimeout(formnovalidate.timer);
+			}
+			formnovalidate.prevented = true;
+			formnovalidate.timer = setTimeout(function(){
+				formnovalidate.prevented = false;
+			}, 20);
+		};
+		window.addEventListener('click', preventValidityTest, true);
+		window.addEventListener('touchstart', preventValidityTest, true);
+		window.addEventListener('touchend', preventValidityTest, true);
+	}
+	
+	$(document)
+		.bind('firstinvalidsystem', function(e, data){
+			form = data.form;
+			if(!form){return;}
+			firstInvalidEvent = false;
+			invalids = [];
+						
+			
+			if(!webshims.fromSubmit){return;}
+			firstInvalidEvent = data;
+		})
+		.bind('invalid', function(e){
+			if(invalids.indexOf(e.target) == -1){
+				invalids.push(e.target);
+			} else {
+				e.stopImmediatePropagation();
+			}
+		})
+		.bind('lastinvalid', function(e, data){
+			var firstTarget = data.invalidlist[0];
+				
+			if( firstTarget && (badWebkit || ($.nodeName(firstTarget, 'select'))) && $(firstTarget).not(':focus') && firstInvalidEvent && !firstInvalidEvent.isInvalidUIPrevented() ){
+				webshims.validityAlert.showFor(firstTarget);
+			}
+			firstInvalidEvent = false;
+			invalids = [];
+			//remove webkit/operafix
+			if(!form){return;}
+			$(form).unbind('submit.preventInvalidSubmit');
+			
+		})
+	;
+	
+	
+	if($.browser.webkit && Modernizr.inputtypes.date){
+		(function(){
+			var noInputTriggerEvts = {updateInput: 1, input: 1},
+				fixInputTypes = {
+					date: 1,
+					time: 1,
+					"datetime-local": 1
+				},
+				noFocusEvents = {
+					focusout: 1,
+					blur: 1
+				},
+				changeEvts = {
+					updateInput: 1,
+					change: 1
+				},
+				observe = function(input){
+					var timer,
+						focusedin = true,
+						lastInputVal = input.prop('value'),
+						lastChangeVal = lastInputVal,
+						trigger = function(e){
+							//input === null
+							if(!input){return;}
+							var newVal = input.prop('value');
+							
+							if(newVal !== lastInputVal){
+								lastInputVal = newVal;
+								if(!e || !noInputTriggerEvts[e.type]){
+									input.trigger('input');
+								}
+							}
+							if(e && changeEvts[e.type]){
+								lastChangeVal = newVal;
+							}
+							if(!focusedin && newVal !== lastChangeVal){
+								input.trigger('change');
+							}
+						},
+						extraTimer,
+						extraTest = function(){
+							clearTimeout(extraTimer);
+							extraTimer = setTimeout(trigger, 9);
+						},
+						unbind = function(e){
+							clearInterval(timer);
+							setTimeout(function(){
+								if(e && noFocusEvents[e.type]){
+									focusedin = false;
+								}
+								if(input){
+									input.unbind('focusout blur', unbind).unbind('input change updateInput', trigger);
+									trigger();
+								}
+								input = null;
+							}, 1);
+							
+						}
+					;
+					
+					clearInterval(timer);
+					timer = setInterval(trigger, 160);
+					extraTest();
+					input.unbind('focusout blur', unbind).unbind('input change updateInput', trigger);
+					input.bind('focusout blur', unbind).bind('input updateInput change', trigger);
+				}
+			;
+			if($.event.customEvent){
+				$.event.customEvent.updateInput = true;
+			} 
+			
+			$(doc)
+				.bind('focusin', function(e){
+					if( e.target && fixInputTypes[e.target.type] && !e.target.readOnly && !e.target.disabled ){
+						observe($(e.target));
+					}
+				})
+			;
+		})();
+		
+		(function(){
+			
+			var correctValue = function(elem){
+				var i = 1;
+				var len = 3;
+				var abort, val;
+				if(elem.type == 'date' && (isChangeSubmit || !$(elem).is(':focus'))){
+					val = elem.value;
+					if(val && val.length < 10 && (val = val.split('-')) && val.length == len){
+						for(; i < len; i++){
+							if(val[i].length == 1){
+								val[i] = '0'+val[i];
+							} else if(val[i].length != 2){
+								abort = true;
+								break;
+							}
+						}
+						if(!abort){
+							val = val.join('-');
+							$.prop(elem, 'value', val);
+							return val;
+						}
+					}
+				}
+			};
+			var inputCheckValidityDesc, formCheckValidityDesc, inputValueDesc, inputValidityDesc;
+			
+			inputCheckValidityDesc = webshims.defineNodeNameProperty('input', 'checkValidity', {
+				prop: {
+					value: function(){
+						correctValue(this);
+						return inputCheckValidityDesc.prop._supvalue.apply(this, arguments);
+					}
+				}
+			});
+			
+			formCheckValidityDesc = webshims.defineNodeNameProperty('form', 'checkValidity', {
+				prop: {
+					value: function(){
+						$('input', this).each(function(){
+							correctValue(this);
+						});
+						return formCheckValidityDesc.prop._supvalue.apply(this, arguments);
+					}
+				}
+			});
+			
+			inputValueDesc = webshims.defineNodeNameProperty('input', 'value', {
+				prop: {
+					set: function(){
+						return inputValueDesc.prop._supset.apply(this, arguments);
+					},
+					get: function(){
+						return correctValue(this) || inputValueDesc.prop._supget.apply(this, arguments);
+					}
+				}
+			});
+			
+			inputValidityDesc = webshims.defineNodeNameProperty('input', 'validity', {
+				prop: {
+					writeable: false,
+					get: function(){
+						correctValue(this);
+						return inputValidityDesc.prop._supget.apply(this, arguments);
+					}
+				}
+			});
+			
+			$(document).bind('change', function(e){
+				isChangeSubmit = true;
+				correctValue(e.target);
+				isChangeSubmit = false;
+			});
+			
+		})();
+	}
+	
+});