Changeset 4040

Timestamp:

12/06/07 15:36:17 (9 months ago)

Author:

joern.zaefferer

Message:

* Added valid() plugin method for easy programmatic checking of forms and fields without the need to use the validator API
* Replaced regex for URL method, thanks to the contribution by Scott Gonzales, see http://www.scottsplayground.com/temp/iri/common.htm
* Fixed validate() plugin method to create only one validator instance for a given form and always return that one instance (avoids binding events multiple times)

Location:

trunk/plugins/validate

Files:

• changelog.txt (modified) (1 diff)
• demo-test/js/jquery.js (modified) (78 diffs)
• demo-test/js/test.js (modified) (4 diffs)
• demo-test/test.html (modified) (1 diff)
• jquery.validate.js (modified) (7 diffs)
• todo (modified) (2 diffs)

trunk/plugins/validate/changelog.txt

@@ -9 +9 @@
 * Added support for ajax-validation, see method "remote"
 * Added highlight and unhighlight options, by default toggles errorClass on element, allows custom highlighting
+* Added valid() plugin method for easy programmatic checking of forms and fields without the need to use the validator API
+* Replaced regex for URL method, thanks to the contribution by Scott Gonzales, see http://www.scottsplayground.com/temp/iri/common.htm
 * Fixed error container to hide when all elements are valid, not only on form submit
 * Fixed String.format to jQuery.format (moving into jQuery namespace)
-* Improved URL and email methods (now blacklisting illegal characters to make them much more versatile when dealing with unicode characters, like http://www.føtex.dk/
+* Improved email method to better handle unicode characters
 * Fixed accept method to accept both upper and lowercase extensions
-* Changed debug-mode console log to warn level
+* Changed debug-mode console log from "error" to "warn" level
+* Fixed validate() plugin method to create only one validator instance for a given form and always return that one instance (avoids binding events multiple times)
 
 1.1.1

trunk/plugins/validate/demo-test/js/jquery.js

@@ -1 +1 @@
 (function(){
 /*
- * jQuery 1.2.1 - New Wave Javascript
+ * jQuery 1.2.2-pre - New Wave Javascript
  *
  * Copyright (c) 2007 John Resig (jquery.com)
@@ -7 +7 @@
  * and GPL (GPL-LICENSE.txt) licenses.
  *
- * $Date: 2007-09-16 23:42:06 -0400 (Sun, 16 Sep 2007) $
- * $Rev: 3353 $
+ * $Date: 2007-12-05 06:01:46 +0100 (Mit, 05 Dez 2007) $
+ * $Rev: 4031 $
  */
 
 // Map over jQuery in case of overwrite
-if ( typeof jQuery != "undefined" )
-    var _jQuery = jQuery;
-
-var jQuery = window.jQuery = function(selector, context) {
+if ( window.jQuery )
+    var _jQuery = window.jQuery;
+
+var jQuery = window.jQuery = function( selector, context ) {
     // If the context is a namespace object, return a new object
     return this instanceof jQuery ?
-        this.init(selector, context) :
-        new jQuery(selector, context);
+        this.init( selector, context ) :
+        new jQuery( selector, context );
 };
 
 // Map over the $ in case of overwrite
-if ( typeof $ != "undefined" )
-    var _$ = $;
+if ( window.$ )
+    var _$ = window.$;
     
 // Map the jQuery namespace to the '$' one
 window.$ = jQuery;
 
+// A simple way to check for HTML strings or ID strings
+// (both of which we optimize for)
 var quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#(\w+)$/;
 
 jQuery.fn = jQuery.prototype = {
-    init: function(selector, context) {
+    init: function( selector, context ) {
         // Make sure that a selection was provided
         selector = selector || document;
 
+        // Handle $(DOMElement)
+        if ( selector.nodeType ) {
+            this[0] = selector;
+            this.length = 1;
+            return this;
+
         // Handle HTML strings
-        if ( typeof selector  == "string" ) {
-            var m = quickExpr.exec(selector);
-            if ( m && (m[1] || !context) ) {
+        } else if ( typeof selector == "string" ) {
+            // Are we dealing with HTML string or an ID?
+            var match = quickExpr.exec( selector );
+
+            // Verify a match, and that no context was specified for #id
+            if ( match && (match[1] || !context) ) {
+
                 // HANDLE: $(html) -> $(array)
-                if ( m[1] )
-                    selector = jQuery.clean( [ m[1] ], context );
+                if ( match[1] )
+                    selector = jQuery.clean( [ match[1] ], context );
 
                 // HANDLE: $("#id")
                 else {
-                    var tmp = document.getElementById( m[3] );
-                    if ( tmp )
+                    var elem = document.getElementById( match[3] );
+
+                    // Make sure an element was located
+                    if ( elem )
                         // Handle the case where IE and Opera return items
                         // by name instead of ID
-                        if ( tmp.id != m[3] )
+                        if ( elem.id != match[3] )
                             return jQuery().find( selector );
+
+                        // Otherwise, we inject the element directly into the jQuery object
                         else {
-                            this[0] = tmp;
+                            this[0] = elem;
                             this.length = 1;
                             return this;
                         }
+
                     else
                         selector = [];
                 }
 
-            // HANDLE: $(expr)
+            // HANDLE: $(expr, [context])
+            // (which is just equivalent to: $(content).find(expr)
             } else
                 return new jQuery( context ).find( selector );
@@ -67 +85 @@
         // HANDLE: $(function)
         // Shortcut for document ready
-        } else if ( jQuery.isFunction(selector) )
-            return new jQuery(document)[ jQuery.fn.ready ? "ready" : "load" ]( selector );
+        } else if ( jQuery.isFunction( selector ) )
+            return new jQuery( document )[ jQuery.fn.ready ? "ready" : "load" ]( selector );
 
         return this.setArray(
@@ -75 +93 @@
 
             // HANDLE: $(arraylike)
-            // Watch for when an array-like object is passed as the selector
+            // Watch for when an array-like object, contains DOM nodes, is passed in as the selector
             (selector.jquery || selector.length && selector != window && !selector.nodeType && selector[0] != undefined && selector[0].nodeType) && jQuery.makeArray( selector ) ||
 
@@ -82 +100 @@
     },
     
-    jquery: "1.2.1",
-
+    // The current version of jQuery being used
+    jquery: "@VERSION",
+
+    // The number of elements contained in the matched element set
     size: function() {
         return this.length;
     },
     
+    // The number of elements contained in the matched element set
     length: 0,
 
+    // Get the Nth element in the matched element set OR
+    // Get the whole matched element set as a clean array
     get: function( num ) {
         return num == undefined ?
@@ -97 +120 @@
 
             // Return just the object
-            this[num];
-    },
-    
-    pushStack: function( a ) {
-        var ret = jQuery(a);
+            this[ num ];
+    },
+    
+    // Take an array of elements and push it onto the stack
+    // (returning the new matched element set)
+    pushStack: function( elems ) {
+        // Build a new jQuery matched element set
+        var ret = jQuery( elems );
+
+        // Add the old object onto the stack (as a reference)
         ret.prevObject = this;
+
+        // Return the newly-formed element set
         return ret;
     },
     
-    setArray: function( a ) {
+    // Force the current matched set of elements to become
+    // the specified array of elements (destroying the stack in the process)
+    // You should use pushStack() in order to do this, but maintain the stack
+    setArray: function( elems ) {
+        // Resetting the length to 0, then using the native Array push
+        // is a super-fast way to populate an object with array-like properties
         this.length = 0;
-        Array.prototype.push.apply( this, a );
+        Array.prototype.push.apply( this, elems );
+        
         return this;
     },
 
-    each: function( fn, args ) {
-        return jQuery.each( this, fn, args );
-    },
-
-    index: function( obj ) {
-        var pos = -1;
+    // Execute a callback for every element in the matched set.
+    // (You can seed the arguments with an array of args, but this is
+    // only used internally.)
+    each: function( callback, args ) {
+        return jQuery.each( this, callback, args );
+    },
+
+    // Determine the position of an element within 
+    // the matched set of elements
+    index: function( elem ) {
+        var ret = -1;
+
+        // Locate the position of the desired element
         this.each(function(i){
-            if ( this == obj ) pos = i;
+            if ( this == elem )
+                ret = i;
         });
-        return pos;
-    },
-
-    attr: function( key, value, type ) {
-        var obj = key;
+
+        return ret;
+    },
+
+    attr: function( name, value, type ) {
+        var options = name;
         
         // Look for the case where we're accessing a style value
-        if ( key.constructor == String )
+        if ( name.constructor == String )
             if ( value == undefined )
-                return this.length && jQuery[ type || "attr" ]( this[0], key ) || undefined;
+                return this.length && jQuery[ type || "attr" ]( this[0], name ) || undefined;
+
             else {
-                obj = {};
-                obj[ key ] = value;
+                options = {};
+                options[ name ] = value;
             }
         
         // Check to see if we're setting style values
-        return this.each(function(index){
+        return this.each(function(i){
             // Set all the styles
-            for ( var prop in obj )
+            for ( name in options )
                 jQuery.attr(
-                    type ? this.style : this,
-                    prop, jQuery.prop(this, obj[prop], type, index, prop)
+                    type ?
+                        this.style :
+                        this,
+                    name, jQuery.prop( this, options[ name ], type, i, name )
                 );
         });
@@ -148 +196 @@
 
     css: function( key, value ) {
+        // ignore negative width and height values
+        if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
+            value = undefined;
         return this.attr( key, value, "curCSS" );
     },
 
-    text: function(e) {
-        if ( typeof e != "object" && e != null )
-            return this.empty().append( document.createTextNode( e ) );
-
-        var t = "";
-        jQuery.each( e || this, function(){
+    text: function( text ) {
+        if ( typeof text != "object" && text != null )
+            return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
+
+        var ret = "";
+
+        jQuery.each( text || this, function(){
             jQuery.each( this.childNodes, function(){
                 if ( this.nodeType != 8 )
-                    t += this.nodeType != 1 ?
-                        this.nodeValue : jQuery.fn.text([ this ]);
+                    ret += this.nodeType != 1 ?
+                        this.nodeValue :
+                        jQuery.fn.text( [ this ] );
             });
         });
-        return t;
-    },
-
-    wrapAll: function(html) {
+
+        return ret;
+    },
+
+    wrapAll: function( html ) {
         if ( this[0] )
             // The elements to wrap the target around
-            jQuery(html, this[0].ownerDocument)
+            jQuery( html, this[0].ownerDocument )
                 .clone()
-                .insertBefore(this[0])
+                .insertBefore( this[0] )
                 .map(function(){
                     var elem = this;
+
                     while ( elem.firstChild )
                         elem = elem.firstChild;
+
                     return elem;
                 })
@@ -183 +239 @@
     },
 
-    wrapInner: function(html) {
+    wrapInner: function( html ) {
         return this.each(function(){
-            jQuery(this).contents().wrapAll(html);
+            jQuery( this ).contents().wrapAll( html );
         });
     },
 
-    wrap: function(html) {
+    wrap: function( html ) {
         return this.each(function(){
-            jQuery(this).wrapAll(html);
+            jQuery( this ).wrapAll( html );
         });
     },
 
     append: function() {
-        return this.domManip(arguments, true, 1, function(a){
-            this.appendChild( a );
+        return this.domManip(arguments, true, false, function(elem){
+            this.appendChild( elem );
         });
     },
 
     prepend: function() {
-        return this.domManip(arguments, true, -1, function(a){
-            this.insertBefore( a, this.firstChild );
+        return this.domManip(arguments, true, true, function(elem){
+            this.insertBefore( elem, this.firstChild );
         });
     },
     
     before: function() {
-        return this.domManip(arguments, false, 1, function(a){
-            this.parentNode.insertBefore( a, this );
+        return this.domManip(arguments, false, false, function(elem){
+            this.parentNode.insertBefore( elem, this );
         });
     },
 
     after: function() {
-        return this.domManip(arguments, false, -1, function(a){
-            this.parentNode.insertBefore( a, this.nextSibling );
+        return this.domManip(arguments, false, true, function(elem){
+            this.parentNode.insertBefore( elem, this.nextSibling );
         });
     },
 
     end: function() {
-        return this.prevObject || jQuery([]);
-    },
-
-    find: function(t) {
-        var data = jQuery.map(this, function(a){ return jQuery.find(t,a); });
-        return this.pushStack( /[^+>] [^+>]/.test( t ) || t.indexOf("..") > -1 ?
-            jQuery.unique( data ) : data );
-    },
-
-    clone: function(events) {
+        return this.prevObject || jQuery( [] );
+    },
+
+    find: function( selector ) {
+        var elems = jQuery.map(this, function(elem){
+            return jQuery.find( selector, elem );
+        });
+
+        return this.pushStack( /[^+>] [^+>]/.test( selector ) || selector.indexOf("..") > -1 ?
+            jQuery.unique( elems ) :
+            elems );
+    },
+
+    clone: function( events ) {
         // Do the clone
         var ret = this.map(function(){
-            return this.outerHTML ? jQuery(this.outerHTML)[0] : this.cloneNode(true);
+            return this.outerHTML ?
+                jQuery( this.outerHTML )[0] :
+                this.cloneNode( true );
         });
 
@@ -244 +306 @@
         
         // Copy the events from the original to the clone
-        if (events === true)
-            this.find("*").andSelf().each(function(i) {
-                var events = jQuery.data(this, "events");
+        if ( events === true )
+            this.find("*").andSelf().each(function(i){
+                var events = jQuery.data( this, "events" );
+
                 for ( var type in events )
-                    for ( var handler in events[type] )
-                        jQuery.event.add(clone[i], type, events[type][handler], events[type][handler].data);
+                    for ( var handler in events[ type ] )
+                        jQuery.event.add( clone[ i ], type, events[ type ][ handler ], events[ type ][ handler ].data );
             });
 
@@ -256 +319 @@
     },
 
-    filter: function(t) {
+    filter: function( selector ) {
         return this.pushStack(
-            jQuery.isFunction( t ) &&
-            jQuery.grep(this, function(el, index){
-                return t.apply(el, [index]);
+            jQuery.isFunction( selector ) &&
+            jQuery.grep(this, function(elem, i){
+                return selector.call( elem, i );
             }) ||
 
-            jQuery.multiFilter(t,this) );
-    },
-
-    not: function(t) {
+            jQuery.multiFilter( selector, this ) );
+    },
+
+    not: function( selector ) {
         return this.pushStack(
-            t.constructor == String &&
-            jQuery.multiFilter(t, this, true) ||
-
-            jQuery.grep(this, function(a) {
-                return ( t.constructor == Array || t.jquery )
-                    ? jQuery.inArray( a, t ) < 0
-                    : a != t;
-            })
-        );
-    },
-
-    add: function(t) {
-        return this.pushStack( jQuery.merge(
+            selector.constructor == String &&
+            jQuery.multiFilter( selector, this, true ) ||
+
+            jQuery.grep(this, function(elem) {
+                return selector.constructor == Array || selector.jquery ?
+                    jQuery.inArray( elem, selector ) < 0 :
+                    elem != selector;
+            }) );
+    },
+
+    add: function( selector ) {
+        return !selector ? this : this.pushStack( jQuery.merge( 
             this.get(),
-            t.constructor == String ?
-                jQuery(t).get() :
-                t.length != undefined && (!t.nodeName || jQuery.nodeName(t, "form")) ?
-                    t : [t] )
-        );
-    },
-
-    is: function(expr) {
-        return expr ? jQuery.multiFilter(expr,this).length > 0 : false;
-    },
-
-    hasClass: function(expr) {
-        return this.is("." + expr);
-    },
-    
-    val: function( val ) {
-        if ( val == undefined ) {
+            selector.constructor == String ? 
+                jQuery( selector ).get() :
+                selector.length != undefined && (!selector.nodeName || jQuery.nodeName(selector, "form")) ?
+                    selector : [selector] ) );
+    },
+
+    is: function( selector ) {
+        return selector ?
+            jQuery.multiFilter( selector, this ).length > 0 :
+            false;
+    },
+
+    hasClass: function( selector ) {
+        return this.is( "." + selector );
+    },
+    
+    val: function( value ) {
+        if ( value == undefined ) {
+
             if ( this.length ) {
                 var elem = this[0];
-                
+
                 // We need to handle select boxes special
-                if ( jQuery.nodeName(elem, "select") ) {
+                if ( jQuery.nodeName( elem, "select" ) ) {
                     var index = elem.selectedIndex,
-                        a = [],
+                        values = [],
                         options = elem.options,
                         one = elem.type == "select-one";
@@ -315 +379 @@
                     // Loop through all the selected options
                     for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
-                        var option = options[i];
+                        var option = options[ i ];
+
                         if ( option.selected ) {
                             // Get the specifc value for the option
-                            var val = jQuery.browser.msie && !option.attributes["value"].specified ? option.text : option.value;
+                            value = jQuery.browser.msie && !option.attributes.value.specified ? option.text : option.value;
                             
                             // We don't need an array for one selects
                             if ( one )
-                                return val;
+                                return value;
                             
                             // Multi-Selects return an array
-                            a.push(val);
+                            values.push( value );
                         }
                     }
                     
-                    return a;
+                    return values;
                     
                 // Everything else, we just grab the value
                 } else
-                    return this[0].value.replace(/\r/g, "");
-            }
+                    return (this[0].value || "").replace(/\r/g, "");
+
+            }
+
         } else
             return this.each(function(){
-                if ( val.constructor == Array && /radio|checkbox/.test(this.type) )
-                    this.checked = (jQuery.inArray(this.value, val) >= 0 ||
-                        jQuery.inArray(this.name, val) >= 0);
-                else if ( jQuery.nodeName(this, "select") ) {
-                    var tmp = val.constructor == Array ? val : [val];
-
-                    jQuery("option", this).each(function(){
-                        this.selected = (jQuery.inArray(this.value, tmp) >= 0 ||
-                        jQuery.inArray(this.text, tmp) >= 0);
+                if ( value.constructor == Array && /radio|checkbox/.test( this.type ) )
+                    this.checked = (jQuery.inArray(this.value, value) >= 0 ||
+                        jQuery.inArray(this.name, value) >= 0);
+
+                else if ( jQuery.nodeName( this, "select" ) ) {
+                    var values = value.constructor == Array ?
+                        value :
+                        [ value ];
+
+                    jQuery( "option", this ).each(function(){
+                        this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
+                            jQuery.inArray( this.text, values ) >= 0);
                     });
 
-                    if ( !tmp.length )
+                    if ( !values.length )
                         this.selectedIndex = -1;
+
                 } else
-                    this.value = val;
+                    this.value = value;
             });
     },
     
-    html: function( val ) {
-        return val == undefined ?
-            ( this.length ? this[0].innerHTML : null ) :
-            this.empty().append( val );
-    },
-
-    replaceWith: function( val ) {
-        return this.after( val ).remove();
-    },