third-party/jquery-2.0.3/js/jquery.validate.js

   1 /**
   2  * jQuery Validation Plugin 1.11.0pre
   3  *
   4  * http://bassistance.de/jquery-plugins/jquery-plugin-validation/
   5  * http://docs.jquery.com/Plugins/Validation
   6  *
   7  * Copyright 2013 JÃ¶rn Zaefferer
   8  * Released under the MIT license:
   9  *   http://www.opensource.org/licenses/mit-license.php
  10  */
  11
  12 (function($) {
  13
  14 $.extend($.fn, {
  15     // http://docs.jquery.com/Plugins/Validation/validate
  16     validate: function( options ) {
  17
  18         // if nothing is selected, return nothing; can't chain anyway
  19         if ( !this.length ) {
  20             if ( options && options.debug && window.console ) {
  21                 console.warn( "Nothing selected, can't validate, returning nothing." );
  22             }
  23             return;
  24         }
  25
  26         // check if a validator for this form was already created
  27         var validator = $.data( this[0], "validator" );
  28         if ( validator ) {
  29             return validator;
  30         }
  31
  32         // Add novalidate tag if HTML5.
  33         this.attr( "novalidate", "novalidate" );
  34
  35         validator = new $.validator( options, this[0] );
  36         $.data( this[0], "validator", validator );
  37
  38         if ( validator.settings.onsubmit ) {
  39
  40             this.validateDelegate( ":submit", "click", function( event ) {
  41                 if ( validator.settings.submitHandler ) {
  42                     validator.submitButton = event.target;
  43                 }
  44                 // allow suppressing validation by adding a cancel class to the submit button
  45                 if ( $(event.target).hasClass("cancel") ) {
  46                     validator.cancelSubmit = true;
  47                 }
  48             });
  49
  50             // validate the form on submit
  51             this.submit( function( event ) {
  52                 if ( validator.settings.debug ) {
  53                     // prevent form submit to be able to see console output
  54                     event.preventDefault();
  55                 }
  56                 function handle() {
  57                     var hidden;
  58                     if ( validator.settings.submitHandler ) {
  59                         if ( validator.submitButton ) {
  60                             // insert a hidden input as a replacement for the missing submit button
  61                             hidden = $("<input type='hidden'/>").attr("name", validator.submitButton.name).val(validator.submitButton.value).appendTo(validator.currentForm);
  62                         }
  63                         validator.settings.submitHandler.call( validator, validator.currentForm, event );
  64                         if ( validator.submitButton ) {
  65                             // and clean up afterwards; thanks to no-block-scope, hidden can be referenced
  66                             hidden.remove();
  67                         }
  68                         return false;
  69                     }
  70                     return true;
  71                 }
  72
  73                 // prevent submit for invalid forms or custom submit handlers
  74                 if ( validator.cancelSubmit ) {
  75                     validator.cancelSubmit = false;
  76                     return handle();
  77                 }
  78                 if ( validator.form() ) {
  79                     if ( validator.pendingRequest ) {
  80                         validator.formSubmitted = true;
  81                         return false;
  82                     }
  83                     return handle();
  84                 } else {
  85                     validator.focusInvalid();
  86                     return false;
  87                 }
  88             });
  89         }
  90
  91         return validator;
  92     },
  93     // http://docs.jquery.com/Plugins/Validation/valid
  94     valid: function() {
  95         if ( $(this[0]).is("form")) {
  96             return this.validate().form();
  97         } else {
  98             var valid = true;
  99             var validator = $(this[0].form).validate();
 100             this.each(function() {
 101                 valid &= validator.element(this);
 102             });
 103             return valid;
 104         }
 105     },
 106     // attributes: space seperated list of attributes to retrieve and remove
 107     removeAttrs: function( attributes ) {
 108         var result = {},
 109             $element = this;
 110         $.each(attributes.split(/\s/), function( index, value ) {
 111             result[value] = $element.attr(value);
 112             $element.removeAttr(value);
 113         });
 114         return result;
 115     },
 116     // http://docs.jquery.com/Plugins/Validation/rules
 117     rules: function( command, argument ) {
 118         var element = this[0];
 119
 120         if ( command ) {
 121             var settings = $.data(element.form, "validator").settings;
 122             var staticRules = settings.rules;
 123             var existingRules = $.validator.staticRules(element);
 124             switch(command) {
 125             case "add":
 126                 $.extend(existingRules, $.validator.normalizeRule(argument));
 127                 staticRules[element.name] = existingRules;
 128                 if ( argument.messages ) {
 129                     settings.messages[element.name] = $.extend( settings.messages[element.name], argument.messages );
 130                 }
 131                 break;
 132             case "remove":
 133                 if ( !argument ) {
 134                     delete staticRules[element.name];
 135                     return existingRules;
 136                 }
 137                 var filtered = {};
 138                 $.each(argument.split(/\s/), function( index, method ) {
 139                     filtered[method] = existingRules[method];
 140                     delete existingRules[method];
 141                 });
 142                 return filtered;
 143             }
 144         }
 145
 146         var data = $.validator.normalizeRules(
 147         $.extend(
 148             {},
 149             $.validator.classRules(element),
 150             $.validator.attributeRules(element),
 151             $.validator.dataRules(element),
 152             $.validator.staticRules(element)
 153         ), element);
 154
 155         // make sure required is at front
 156         if ( data.required ) {
 157             var param = data.required;
 158             delete data.required;
 159             data = $.extend({required: param}, data);
 160         }
 161
 162         return data;
 163     }
 164 });
 165
 166 // Custom selectors
 167 $.extend($.expr[":"], {
 168     // http://docs.jquery.com/Plugins/Validation/blank
 169     blank: function( a ) { return !$.trim("" + a.value); },
 170     // http://docs.jquery.com/Plugins/Validation/filled
 171     filled: function( a ) { return !!$.trim("" + a.value); },
 172     // http://docs.jquery.com/Plugins/Validation/unchecked
 173     unchecked: function( a ) { return !a.checked; }
 174 });
 175
 176 // constructor for validator
 177 $.validator = function( options, form ) {
 178     this.settings = $.extend( true, {}, $.validator.defaults, options );
 179     this.currentForm = form;
 180     this.init();
 181 };
 182
 183 $.validator.format = function( source, params ) {
 184     if ( arguments.length === 1 ) {
 185         return function() {
 186             var args = $.makeArray(arguments);
 187             args.unshift(source);
 188             return $.validator.format.apply( this, args );
 189         };
 190     }
 191     if ( arguments.length > 2 && params.constructor !== Array  ) {
 192         params = $.makeArray(arguments).slice(1);
 193     }
 194     if ( params.constructor !== Array ) {
 195         params = [ params ];
 196     }
 197     $.each(params, function( i, n ) {
 198         source = source.replace( new RegExp("\\{" + i + "\\}", "g"), function() {
 199             return n;
 200         });
 201     });
 202     return source;
 203 };
 204
 205 $.extend($.validator, {
 206
 207     defaults: {
 208         messages: {},
 209         groups: {},
 210         rules: {},
 211         errorClass: "error",
 212         validClass: "valid",
 213         errorElement: "label",
 214         focusInvalid: true,
 215         errorContainer: $([]),
 216         errorLabelContainer: $([]),
 217         onsubmit: true,
 218         ignore: ":hidden",
 219         ignoreTitle: false,
 220         onfocusin: function( element, event ) {
 221             this.lastActive = element;
 222
 223             // hide error label and remove error class on focus if enabled
 224             if ( this.settings.focusCleanup && !this.blockFocusCleanup ) {
 225                 if ( this.settings.unhighlight ) {
 226                     this.settings.unhighlight.call( this, element, this.settings.errorClass, this.settings.validClass );
 227                 }
 228                 this.addWrapper(this.errorsFor(element)).hide();
 229             }
 230         },
 231         onfocusout: function( element, event ) {
 232             if ( !this.checkable(element) && (element.name in this.submitted || !this.optional(element)) ) {
 233                 this.element(element);
 234             }
 235         },
 236         onkeyup: function( element, event ) {
 237             if ( event.which === 9 && this.elementValue(element) === "" ) {
 238                 return;
 239             } else if ( element.name in this.submitted || element === this.lastElement ) {
 240                 this.element(element);
 241             }
 242         },
 243         onclick: function( element, event ) {
 244             // click on selects, radiobuttons and checkboxes
 245             if ( element.name in this.submitted ) {
 246                 this.element(element);
 247             }
 248             // or option elements, check parent select in that case
 249             else if ( element.parentNode.name in this.submitted ) {
 250                 this.element(element.parentNode);
 251             }
 252         },
 253         highlight: function( element, errorClass, validClass ) {
 254             if ( element.type === "radio" ) {
 255                 this.findByName(element.name).addClass(errorClass).removeClass(validClass);
 256             } else {
 257                 $(element).addClass(errorClass).removeClass(validClass);
 258             }
 259         },
 260         unhighlight: function( element, errorClass, validClass ) {
 261             if ( element.type === "radio" ) {
 262                 this.findByName(element.name).removeClass(errorClass).addClass(validClass);
 263             } else {
 264                 $(element).removeClass(errorClass).addClass(validClass);
 265             }
 266         }
 267     },
 268
 269     // http://docs.jquery.com/Plugins/Validation/Validator/setDefaults
 270     setDefaults: function( settings ) {
 271         $.extend( $.validator.defaults, settings );
 272     },
 273
 274     messages: {
 275         required: "This field is required.",
 276         remote: "Please fix this field.",
 277         email: "Please enter a valid email address.",
 278         url: "Please enter a valid URL.",
 279         date: "Please enter a valid date.",
 280         dateISO: "Please enter a valid date (ISO).",
 281         number: "Please enter a valid number.",
 282         digits: "Please enter only digits.",
 283         creditcard: "Please enter a valid credit card number.",
 284         equalTo: "Please enter the same value again.",
 285         maxlength: $.validator.format("Please enter no more than {0} characters."),
 286         minlength: $.validator.format("Please enter at least {0} characters."),
 287         rangelength: $.validator.format("Please enter a value between {0} and {1} characters long."),
 288         range: $.validator.format("Please enter a value between {0} and {1}."),
 289         max: $.validator.format("Please enter a value less than or equal to {0}."),
 290         min: $.validator.format("Please enter a value greater than or equal to {0}.")
 291     },
 292
 293     autoCreateRanges: false,
 294
 295     prototype: {
 296
 297         init: function() {
 298             this.labelContainer = $(this.settings.errorLabelContainer);
 299             this.errorContext = this.labelContainer.length && this.labelContainer || $(this.currentForm);
 300             this.containers = $(this.settings.errorContainer).add( this.settings.errorLabelContainer );
 301             this.submitted = {};
 302             this.valueCache = {};
 303             this.pendingRequest = 0;
 304             this.pending = {};
 305             this.invalid = {};
 306             this.reset();
 307
 308             var groups = (this.groups = {});
 309             $.each(this.settings.groups, function( key, value ) {
 310                 if ( typeof value === "string" ) {
 311                     value = value.split(/\s/);
 312                 }
 313                 $.each(value, function( index, name ) {
 314                     groups[name] = key;
 315                 });
 316             });
 317             var rules = this.settings.rules;
 318             $.each(rules, function( key, value ) {
 319                 rules[key] = $.validator.normalizeRule(value);
 320             });
 321
 322             function delegate(event) {
 323                 var validator = $.data(this[0].form, "validator"),
 324                     eventType = "on" + event.type.replace(/^validate/, "");
 325                 if ( validator.settings[eventType] ) {
 326                     validator.settings[eventType].call(validator, this[0], event);
 327                 }
 328             }
 329             $(this.currentForm)
 330                 .validateDelegate(":text, [type='password'], [type='file'], select, textarea, " +
 331                     "[type='number'], [type='search'] ,[type='tel'], [type='url'], " +
 332                     "[type='email'], [type='datetime'], [type='date'], [type='month'], " +
 333                     "[type='week'], [type='time'], [type='datetime-local'], " +
 334                     "[type='range'], [type='color'] ",
 335                     "focusin focusout keyup", delegate)
 336                 .validateDelegate("[type='radio'], [type='checkbox'], select, option", "click", delegate);
 337
 338             if ( this.settings.invalidHandler ) {
 339                 $(this.currentForm).bind("invalid-form.validate", this.settings.invalidHandler);
 340             }
 341         },
 342
 343         // http://docs.jquery.com/Plugins/Validation/Validator/form
 344         form: function() {
 345             this.checkForm();
 346             $.extend(this.submitted, this.errorMap);
 347             this.invalid = $.extend({}, this.errorMap);
 348             if ( !this.valid() ) {
 349                 $(this.currentForm).triggerHandler("invalid-form", [this]);
 350             }
 351             this.showErrors();
 352             return this.valid();
 353         },
 354
 355         checkForm: function() {
 356             this.prepareForm();
 357             for ( var i = 0, elements = (this.currentElements = this.elements()); elements[i]; i++ ) {
 358                 this.check( elements[i] );
 359             }
 360             return this.valid();
 361         },
 362
 363         // http://docs.jquery.com/Plugins/Validation/Validator/element
 364         element: function( element ) {
 365             element = this.validationTargetFor( this.clean( element ) );
 366             this.lastElement = element;
 367             this.prepareElement( element );
 368             this.currentElements = $(element);
 369             var result = this.check( element ) !== false;
 370             if ( result ) {
 371                 delete this.invalid[element.name];
 372             } else {
 373                 this.invalid[element.name] = true;
 374             }
 375             if ( !this.numberOfInvalids() ) {
 376                 // Hide error containers on last error
 377                 this.toHide = this.toHide.add( this.containers );
 378             }
 379             this.showErrors();
 380             return result;
 381         },
 382
 383         // http://docs.jquery.com/Plugins/Validation/Validator/showErrors
 384         showErrors: function( errors ) {
 385             if ( errors ) {
 386                 // add items to error list and map
 387                 $.extend( this.errorMap, errors );
 388                 this.errorList = [];
 389                 for ( var name in errors ) {
 390                     this.errorList.push({
 391                         message: errors[name],
 392                         element: this.findByName(name)[0]
 393                     });
 394                 }
 395                 // remove items from success list
 396                 this.successList = $.grep( this.successList, function( element ) {
 397                     return !(element.name in errors);
 398                 });
 399             }
 400             if ( this.settings.showErrors ) {
 401                 this.settings.showErrors.call( this, this.errorMap, this.errorList );
 402             } else {
 403                 this.defaultShowErrors();
 404             }
 405         },
 406
 407         // http://docs.jquery.com/Plugins/Validation/Validator/resetForm
 408         resetForm: function() {
 409             if ( $.fn.resetForm ) {
 410                 $(this.currentForm).resetForm();
 411             }
 412             this.submitted = {};
 413             this.lastElement = null;
 414             this.prepareForm();
 415             this.hideErrors();
 416             this.elements().removeClass( this.settings.errorClass ).removeData( "previousValue" );
 417         },
 418
 419         numberOfInvalids: function() {
 420             return this.objectLength(this.invalid);
 421         },
 422
 423         objectLength: function( obj ) {
 424             var count = 0;
 425             for ( var i in obj ) {
 426                 count++;
 427             }
 428             return count;
 429         },
 430
 431         hideErrors: function() {
 432             this.addWrapper( this.toHide ).hide();
 433         },
 434
 435         valid: function() {
 436             return this.size() === 0;
 437         },
 438
 439         size: function() {
 440             return this.errorList.length;
 441         },
 442
 443         focusInvalid: function() {
 444             if ( this.settings.focusInvalid ) {
 445                 try {
 446                     $(this.findLastActive() || this.errorList.length && this.errorList[0].element || [])
 447                     .filter(":visible")
 448                     .focus()
 449                     // manually trigger focusin event; without it, focusin handler isn't called, findLastActive won't have anything to find
 450                     .trigger("focusin");
 451                 } catch(e) {
 452                     // ignore IE throwing errors when focusing hidden elements
 453                 }
 454             }
 455         },
 456
 457         findLastActive: function() {
 458             var lastActive = this.lastActive;
 459             return lastActive && $.grep(this.errorList, function( n ) {
 460                 return n.element.name === lastActive.name;
 461             }).length === 1 && lastActive;
 462         },
 463
 464         elements: function() {
 465             var validator = this,
 466                 rulesCache = {};
 467
 468             // select all valid inputs inside the form (no submit or reset buttons)
 469             return $(this.currentForm)
 470             .find("input, select, textarea")
 471             .not(":submit, :reset, :image, [disabled]")
 472             .not( this.settings.ignore )
 473             .filter(function() {
 474                 if ( !this.name ) {
 475                     if ( window.console ) {
 476                         console.error( "%o has no name assigned", this );
 477                     }
 478                     throw new Error( "Failed to validate, found an element with no name assigned. See console for element reference." );
 479                 }
 480
 481                 // select only the first element for each name, and only those with rules specified
 482                 if ( this.name in rulesCache || !validator.objectLength($(this).rules()) ) {
 483                     return false;
 484                 }
 485
 486                 rulesCache[this.name] = true;
 487                 return true;
 488             });
 489         },
 490
 491         clean: function( selector ) {
 492             return $(selector)[0];
 493         },
 494
 495         errors: function() {
 496             var errorClass = this.settings.errorClass.replace(" ", ".");
 497             return $(this.settings.errorElement + "." + errorClass, this.errorContext);
 498         },
 499
 500         reset: function() {
 501             this.successList = [];
 502             this.errorList = [];
 503             this.errorMap = {};
 504             this.toShow = $([]);
 505             this.toHide = $([]);
 506             this.currentElements = $([]);
 507         },
 508
 509         prepareForm: function() {
 510             this.reset();
 511             this.toHide = this.errors().add( this.containers );
 512         },
 513
 514         prepareElement: function( element ) {
 515             this.reset();
 516             this.toHide = this.errorsFor(element);
 517         },
 518
 519         elementValue: function( element ) {
 520             var type = $(element).attr("type"),
 521                 val = $(element).val();
 522
 523             if ( type === "radio" || type === "checkbox" ) {
 524                 return $("input[name='" + $(element).attr("name") + "']:checked").val();
 525             }
 526
 527             if ( typeof val === "string" ) {
 528                 return val.replace(/\r/g, "");
 529             }
 530             return val;
 531         },
 532
 533         check: function( element ) {
 534             element = this.validationTargetFor( this.clean( element ) );
 535
 536             var rules = $(element).rules();
 537             var dependencyMismatch = false;
 538             var val = this.elementValue(element);
 539             var result;
 540
 541             for (var method in rules ) {
 542                 var rule = { method: method, parameters: rules[method] };
 543                 try {
 544
 545                     result = $.validator.methods[method].call( this, val, element, rule.parameters );
 546
 547                     // if a method indicates that the field is optional and therefore valid,
 548                     // don't mark it as valid when there are no other rules
 549                     if ( result === "dependency-mismatch" ) {
 550                         dependencyMismatch = true;
 551                         continue;
 552                     }
 553                     dependencyMismatch = false;
 554
 555                     if ( result === "pending" ) {
 556                         this.toHide = this.toHide.not( this.errorsFor(element) );
 557                         return;
 558                     }
 559
 560                     if ( !result ) {
 561                         this.formatAndAdd( element, rule );
 562                         return false;
 563                     }
 564                 } catch(e) {
 565                     if ( this.settings.debug && window.console ) {
 566                         console.log( "Exception occured when checking element " + element.id + ", check the '" + rule.method + "' method.", e );
 567                     }
 568                     throw e;
 569                 }
 570             }
 571             if ( dependencyMismatch ) {
 572                 return;
 573             }
 574             if ( this.objectLength(rules) ) {
 575                 this.successList.push(element);
 576             }
 577             return true;
 578         },
 579
 580         // return the custom message for the given element and validation method
 581         // specified in the element's HTML5 data attribute
 582         customDataMessage: function( element, method ) {
 583             return $(element).data("msg-" + method.toLowerCase()) || (element.attributes && $(element).attr("data-msg-" + method.toLowerCase()));
 584         },
 585
 586         // return the custom message for the given element name and validation method
 587         customMessage: function( name, method ) {
 588             var m = this.settings.messages[name];
 589             return m && (m.constructor === String ? m : m[method]);
 590         },
 591
 592         // return the first defined argument, allowing empty strings
 593         findDefined: function() {
 594             for(var i = 0; i < arguments.length; i++) {
 595                 if ( arguments[i] !== undefined ) {
 596                     return arguments[i];
 597                 }
 598             }
 599             return undefined;
 600         },
 601
 602         defaultMessage: function( element, method ) {
 603             return this.findDefined(
 604                 this.customMessage( element.name, method ),
 605                 this.customDataMessage( element, method ),
 606                 // title is never undefined, so handle empty string as undefined
 607                 !this.settings.ignoreTitle && element.title || undefined,
 608                 $.validator.messages[method],
 609                 "<strong>Warning: No message defined for " + element.name + "</strong>"
 610             );
 611         },
 612
 613         formatAndAdd: function( element, rule ) {
 614             var message = this.defaultMessage( element, rule.method ),
 615                 theregex = /\$?\{(\d+)\}/g;
 616             if ( typeof message === "function" ) {
 617                 message = message.call(this, rule.parameters, element);
 618             } else if (theregex.test(message)) {
 619                 message = $.validator.format(message.replace(theregex, "{$1}"), rule.parameters);
 620             }
 621             this.errorList.push({
 622                 message: message,
 623                 element: element
 624             });
 625
 626             this.errorMap[element.name] = message;
 627             this.submitted[element.name] = message;
 628         },
 629
 630         addWrapper: function( toToggle ) {
 631             if ( this.settings.wrapper ) {
 632                 toToggle = toToggle.add( toToggle.parent( this.settings.wrapper ) );
 633             }
 634             return toToggle;
 635         },
 636
 637         defaultShowErrors: function() {
 638             var i, elements;
 639             for ( i = 0; this.errorList[i]; i++ ) {
 640                 var error = this.errorList[i];
 641                 if ( this.settings.highlight ) {
 642                     this.settings.highlight.call( this, error.element, this.settings.errorClass, this.settings.validClass );
 643                 }
 644                 this.showLabel( error.element, error.message );
 645             }
 646             if ( this.errorList.length ) {
 647                 this.toShow = this.toShow.add( this.containers );
 648             }
 649             if ( this.settings.success ) {
 650                 for ( i = 0; this.successList[i]; i++ ) {
 651                     this.showLabel( this.successList[i] );
 652                 }
 653             }
 654             if ( this.settings.unhighlight ) {
 655                 for ( i = 0, elements = this.validElements(); elements[i]; i++ ) {
 656                     this.settings.unhighlight.call( this, elements[i], this.settings.errorClass, this.settings.validClass );
 657                 }
 658             }
 659             this.toHide = this.toHide.not( this.toShow );
 660             this.hideErrors();
 661             this.addWrapper( this.toShow ).show();
 662         },
 663
 664         validElements: function() {
 665             return this.currentElements.not(this.invalidElements());
 666         },
 667
 668         invalidElements: function() {
 669             return $(this.errorList).map(function() {
 670                 return this.element;
 671             });
 672         },
 673
 674         showLabel: function( element, message ) {
 675             var label = this.errorsFor( element );
 676             if ( label.length ) {
 677                 // refresh error/success class
 678                 label.removeClass( this.settings.validClass ).addClass( this.settings.errorClass );
 679
 680                 // check if we have a generated label, replace the message then
 681                 if ( label.attr("generated") ) {
 682                     label.html(message);
 683                 }
 684             } else {
 685                 // create label
 686                 label = $("<" + this.settings.errorElement + "/>")
 687                     .attr({"for":  this.idOrName(element), generated: true})
 688                     .addClass(this.settings.errorClass)
 689                     .html(message || "");
 690                 if ( this.settings.wrapper ) {
 691                     // make sure the element is visible, even in IE
 692                     // actually showing the wrapped element is handled elsewhere
 693                     label = label.hide().show().wrap("<" + this.settings.wrapper + "/>").parent();
 694                 }
 695                 if ( !this.labelContainer.append(label).length ) {
 696                     if ( this.settings.errorPlacement ) {
 697                         this.settings.errorPlacement(label, $(element) );
 698                     } else {
 699                         label.insertAfter(element);
 700                     }
 701                 }
 702             }
 703             if ( !message && this.settings.success ) {
 704                 label.text("");
 705                 if ( typeof this.settings.success === "string" ) {
 706                     label.addClass( this.settings.success );
 707                 } else {
 708                     this.settings.success( label, element );
 709                 }
 710             }
 711             this.toShow = this.toShow.add(label);
 712         },
 713
 714         errorsFor: function( element ) {
 715             var name = this.idOrName(element);
 716             return this.errors().filter(function() {
 717                 return $(this).attr("for") === name;
 718             });
 719         },
 720
 721         idOrName: function( element ) {
 722             return this.groups[element.name] || (this.checkable(element) ? element.name : element.id || element.name);
 723         },
 724
 725         validationTargetFor: function( element ) {
 726             // if radio/checkbox, validate first element in group instead
 727             if ( this.checkable(element) ) {
 728                 element = this.findByName( element.name ).not(this.settings.ignore)[0];
 729             }
 730             return element;
 731         },
 732
 733         checkable: function( element ) {
 734             return (/radio|checkbox/i).test(element.type);
 735         },
 736
 737         findByName: function( name ) {
 738             return $(this.currentForm).find("[name='" + name + "']");
 739         },
 740
 741         getLength: function( value, element ) {
 742             switch( element.nodeName.toLowerCase() ) {
 743             case "select":
 744                 return $("option:selected", element).length;
 745             case "input":
 746                 if ( this.checkable( element) ) {
 747                     return this.findByName(element.name).filter(":checked").length;
 748                 }
 749             }
 750             return value.length;
 751         },
 752
 753         depend: function( param, element ) {
 754             return this.dependTypes[typeof param] ? this.dependTypes[typeof param](param, element) : true;
 755         },
 756
 757         dependTypes: {
 758             "boolean": function( param, element ) {
 759                 return param;
 760             },
 761             "string": function( param, element ) {
 762                 return !!$(param, element.form).length;
 763             },
 764             "function": function( param, element ) {
 765                 return param(element);
 766             }
 767         },
 768
 769         optional: function( element ) {
 770             var val = this.elementValue(element);
 771             return !$.validator.methods.required.call(this, val, element) && "dependency-mismatch";
 772         },
 773
 774         startRequest: function( element ) {
 775             if ( !this.pending[element.name] ) {
 776                 this.pendingRequest++;
 777                 this.pending[element.name] = true;
 778             }
 779         },
 780
 781         stopRequest: function( element, valid ) {
 782             this.pendingRequest--;
 783             // sometimes synchronization fails, make sure pendingRequest is never < 0
 784             if ( this.pendingRequest < 0 ) {
 785                 this.pendingRequest = 0;
 786             }
 787             delete this.pending[element.name];
 788             if ( valid && this.pendingRequest === 0 && this.formSubmitted && this.form() ) {
 789                 $(this.currentForm).submit();
 790                 this.formSubmitted = false;
 791             } else if (!valid && this.pendingRequest === 0 && this.formSubmitted) {
 792                 $(this.currentForm).triggerHandler("invalid-form", [this]);
 793                 this.formSubmitted = false;
 794             }
 795         },
 796
 797         previousValue: function( element ) {
 798             return $.data(element, "previousValue") || $.data(element, "previousValue", {
 799                 old: null,
 800                 valid: true,
 801                 message: this.defaultMessage( element, "remote" )
 802             });
 803         }
 804
 805     },
 806
 807     classRuleSettings: {
 808         required: {required: true},
 809         email: {email: true},
 810         url: {url: true},
 811         date: {date: true},
 812         dateISO: {dateISO: true},
 813         number: {number: true},
 814         digits: {digits: true},
 815         creditcard: {creditcard: true}
 816     },
 817
 818     addClassRules: function( className, rules ) {
 819         if ( className.constructor === String ) {
 820             this.classRuleSettings[className] = rules;
 821         } else {
 822             $.extend(this.classRuleSettings, className);
 823         }
 824     },
 825
 826     classRules: function( element ) {
 827         var rules = {};
 828         var classes = $(element).attr("class");
 829         if ( classes ) {
 830             $.each(classes.split(" "), function() {
 831                 if ( this in $.validator.classRuleSettings ) {
 832                     $.extend(rules, $.validator.classRuleSettings[this]);
 833                 }
 834             });
 835         }
 836         return rules;
 837     },
 838
 839     attributeRules: function( element ) {
 840         var rules = {};
 841         var $element = $(element);
 842
 843         for (var method in $.validator.methods) {
 844             var value;
 845
 846             // support for <input required> in both html5 and older browsers
 847             if ( method === "required" ) {
 848                 value = $element.get(0).getAttribute(method);
 849                 // Some browsers return an empty string for the required attribute
 850                 // and non-HTML5 browsers might have required="" markup
 851                 if ( value === "" ) {
 852                     value = true;
 853                 }
 854                 // force non-HTML5 browsers to return bool
 855                 value = !!value;
 856             } else {
 857                 value = $element.attr(method);
 858             }
 859
 860             if ( value ) {
 861                 rules[method] = value;
 862             } else if ( $element[0].getAttribute("type") === method ) {
 863                 rules[method] = true;
 864             }
 865         }
 866
 867         // maxlength may be returned as -1, 2147483647 (IE) and 524288 (safari) for text inputs
 868         if ( rules.maxlength && /-1|2147483647|524288/.test(rules.maxlength) ) {
 869             delete rules.maxlength;
 870         }
 871
 872         return rules;
 873     },
 874
 875     dataRules: function( element ) {
 876         var method, value,
 877             rules = {}, $element = $(element);
 878         for (method in $.validator.methods) {
 879             value = $element.data("rule-" + method.toLowerCase());
 880             if ( value !== undefined ) {
 881                 rules[method] = value;
 882             }
 883         }
 884         return rules;
 885     },
 886
 887     staticRules: function( element ) {
 888         var rules = {};
 889         var validator = $.data(element.form, "validator");
 890         if ( validator.settings.rules ) {
 891             rules = $.validator.normalizeRule(validator.settings.rules[element.name]) || {};
 892         }
 893         return rules;
 894     },
 895
 896     normalizeRules: function( rules, element ) {
 897         // handle dependency check
 898         $.each(rules, function( prop, val ) {
 899             // ignore rule when param is explicitly false, eg. required:false
 900             if ( val === false ) {
 901                 delete rules[prop];
 902                 return;
 903             }
 904             if ( val.param || val.depends ) {
 905                 var keepRule = true;
 906                 switch (typeof val.depends) {
 907                 case "string":
 908                     keepRule = !!$(val.depends, element.form).length;
 909                     break;
 910                 case "function":
 911                     keepRule = val.depends.call(element, element);
 912                     break;
 913                 }
 914                 if ( keepRule ) {
 915                     rules[prop] = val.param !== undefined ? val.param : true;
 916                 } else {
 917                     delete rules[prop];
 918                 }
 919             }
 920         });
 921
 922         // evaluate parameters
 923         $.each(rules, function( rule, parameter ) {
 924             rules[rule] = $.isFunction(parameter) ? parameter(element) : parameter;
 925         });
 926
 927         // clean number parameters
 928         $.each(["minlength", "maxlength", "min", "max"], function() {
 929             if ( rules[this] ) {
 930                 rules[this] = Number(rules[this]);
 931             }
 932         });
 933         $.each(["rangelength", "range"], function() {
 934             var parts;
 935             if ( rules[this] ) {
 936                 if ( $.isArray(rules[this]) ) {
 937                     rules[this] = [Number(rules[this][0]), Number(rules[this][1])];
 938                 } else if ( typeof rules[this] === "string" ) {
 939                     parts = rules[this].split(/[\s,]+/);
 940                     rules[this] = [Number(parts[0]), Number(parts[1])];
 941                 }
 942             }
 943         });
 944
 945         if ( $.validator.autoCreateRanges ) {
 946             // auto-create ranges
 947             if ( rules.min && rules.max ) {
 948                 rules.range = [rules.min, rules.max];
 949                 delete rules.min;
 950                 delete rules.max;
 951             }
 952             if ( rules.minlength && rules.maxlength ) {
 953                 rules.rangelength = [rules.minlength, rules.maxlength];
 954                 delete rules.minlength;
 955                 delete rules.maxlength;
 956             }
 957         }
 958
 959         return rules;
 960     },
 961
 962     // Converts a simple string to a {string: true} rule, e.g., "required" to {required:true}
 963     normalizeRule: function( data ) {
 964         if ( typeof data === "string" ) {
 965             var transformed = {};
 966             $.each(data.split(/\s/), function() {
 967                 transformed[this] = true;
 968             });
 969             data = transformed;
 970         }
 971         return data;
 972     },
 973
 974     // http://docs.jquery.com/Plugins/Validation/Validator/addMethod
 975     addMethod: function( name, method, message ) {
 976         $.validator.methods[name] = method;
 977         $.validator.messages[name] = message !== undefined ? message : $.validator.messages[name];
 978         if ( method.length < 3 ) {
 979             $.validator.addClassRules(name, $.validator.normalizeRule(name));
 980         }
 981     },
 982
 983     methods: {
 984
 985         // http://docs.jquery.com/Plugins/Validation/Methods/required
 986         required: function( value, element, param ) {
 987             // check if dependency is met
 988             if ( !this.depend(param, element) ) {
 989                 return "dependency-mismatch";
 990             }
 991             if ( element.nodeName.toLowerCase() === "select" ) {
 992                 // could be an array for select-multiple or a string, both are fine this way
 993                 var val = $(element).val();
 994                 return val && val.length > 0;
 995             }
 996             if ( this.checkable(element) ) {
 997                 return this.getLength(value, element) > 0;
 998             }
 999             return $.trim(value).length > 0;
1000         },
1001
1002         // http://docs.jquery.com/Plugins/Validation/Methods/remote
1003         remote: function( value, element, param ) {
1004             if ( this.optional(element) ) {
1005                 return "dependency-mismatch";
1006             }
1007
1008             var previous = this.previousValue(element);
1009             if (!this.settings.messages[element.name] ) {
1010                 this.settings.messages[element.name] = {};
1011             }
1012             previous.originalMessage = this.settings.messages[element.name].remote;
1013             this.settings.messages[element.name].remote = previous.message;
1014
1015             param = typeof param === "string" && {url:param} || param;
1016
1017             if ( previous.old === value ) {
1018                 return previous.valid;
1019             }
1020
1021             previous.old = value;
1022             var validator = this;
1023             this.startRequest(element);
1024             var data = {};
1025             data[element.name] = value;
1026             $.ajax($.extend(true, {
1027                 url: param,
1028                 mode: "abort",
1029                 port: "validate" + element.name,
1030                 dataType: "json",
1031                 data: data,
1032                 success: function( response ) {
1033                     validator.settings.messages[element.name].remote = previous.originalMessage;
1034                     var valid = response === true || response === "true";
1035                     if ( valid ) {
1036                         var submitted = validator.formSubmitted;
1037                         validator.prepareElement(element);
1038                         validator.formSubmitted = submitted;
1039                         validator.successList.push(element);
1040                         delete validator.invalid[element.name];
1041                         validator.showErrors();
1042                     } else {
1043                         var errors = {};
1044                         var message = response || validator.defaultMessage( element, "remote" );
1045                         errors[element.name] = previous.message = $.isFunction(message) ? message(value) : message;
1046                         validator.invalid[element.name] = true;
1047                         validator.showErrors(errors);
1048                     }
1049                     previous.valid = valid;
1050                     validator.stopRequest(element, valid);
1051                 }
1052             }, param));
1053             return "pending";
1054         },
1055
1056         // http://docs.jquery.com/Plugins/Validation/Methods/minlength
1057         minlength: function( value, element, param ) {
1058             var length = $.isArray( value ) ? value.length : this.getLength($.trim(value), element);
1059             return this.optional(element) || length >= param;
1060         },
1061
1062         // http://docs.jquery.com/Plugins/Validation/Methods/maxlength
1063         maxlength: function( value, element, param ) {
1064             var length = $.isArray( value ) ? value.length : this.getLength($.trim(value), element);
1065             return this.optional(element) || length <= param;
1066         },
1067
1068         // http://docs.jquery.com/Plugins/Validation/Methods/rangelength
1069         rangelength: function( value, element, param ) {
1070             var length = $.isArray( value ) ? value.length : this.getLength($.trim(value), element);
1071             return this.optional(element) || ( length >= param[0] && length <= param[1] );
1072         },
1073
1074         // http://docs.jquery.com/Plugins/Validation/Methods/min
1075         min: function( value, element, param ) {
1076             return this.optional(element) || value >= param;
1077         },
1078
1079         // http://docs.jquery.com/Plugins/Validation/Methods/max
1080         max: function( value, element, param ) {
1081             return this.optional(element) || value <= param;
1082         },
1083
1084         // http://docs.jquery.com/Plugins/Validation/Methods/range
1085         range: function( value, element, param ) {
1086             return this.optional(element) || ( value >= param[0] && value <= param[1] );
1087         },
1088
1089         // http://docs.jquery.com/Plugins/Validation/Methods/email
1090         email: function( value, element ) {
1091             // contributed by Scott Gonzalez: http://projects.scottsplayground.com/email_address_validation/
1092             return this.optional(element) || /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i.test(value);
1093         },
1094
1095         // http://docs.jquery.com/Plugins/Validation/Methods/url
1096         url: function( value, element ) {
1097             // contributed by Scott Gonzalez: http://projects.scottsplayground.com/iri/
1098             return this.optional(element) || /^(https?|s?ftp):\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$/i.test(value);
1099         },
1100
1101         // http://docs.jquery.com/Plugins/Validation/Methods/date
1102         date: function( value, element ) {
1103             return this.optional(element) || !/Invalid|NaN/.test(new Date(value).toString());
1104         },
1105
1106         // http://docs.jquery.com/Plugins/Validation/Methods/dateISO
1107         dateISO: function( value, element ) {
1108             return this.optional(element) || /^\d{4}[\/\-]\d{1,2}[\/\-]\d{1,2}$/.test(value);
1109         },
1110
1111         // http://docs.jquery.com/Plugins/Validation/Methods/number
1112         number: function( value, element ) {
1113             return this.optional(element) || /^-?(?:\d+|\d{1,3}(?:,\d{3})+)?(?:\.\d+)?$/.test(value);
1114         },
1115
1116         // http://docs.jquery.com/Plugins/Validation/Methods/digits
1117         digits: function( value, element ) {
1118             return this.optional(element) || /^\d+$/.test(value);
1119         },
1120
1121         // http://docs.jquery.com/Plugins/Validation/Methods/creditcard
1122         // based on http://en.wikipedia.org/wiki/Luhn
1123         creditcard: function( value, element ) {
1124             if ( this.optional(element) ) {
1125                 return "dependency-mismatch";
1126             }
1127             // accept only spaces, digits and dashes
1128             if ( /[^0-9 \-]+/.test(value) ) {
1129                 return false;
1130             }
1131             var nCheck = 0,
1132                 nDigit = 0,
1133                 bEven = false;
1134
1135             value = value.replace(/\D/g, "");
1136
1137             for (var n = value.length - 1; n >= 0; n--) {
1138                 var cDigit = value.charAt(n);
1139                 nDigit = parseInt(cDigit, 10);
1140                 if ( bEven ) {
1141                     if ( (nDigit *= 2) > 9 ) {
1142                         nDigit -= 9;
1143                     }
1144                 }
1145                 nCheck += nDigit;
1146                 bEven = !bEven;
1147             }
1148
1149             return (nCheck % 10) === 0;
1150         },
1151
1152         // http://docs.jquery.com/Plugins/Validation/Methods/equalTo
1153         equalTo: function( value, element, param ) {
1154             // bind to the blur event of the target in order to revalidate whenever the target field is updated
1155             // TODO find a way to bind the event just once, avoiding the unbind-rebind overhead
1156             var target = $(param);
1157             if ( this.settings.onfocusout ) {
1158                 target.unbind(".validate-equalTo").bind("blur.validate-equalTo", function() {
1159                     $(element).valid();
1160                 });
1161             }
1162             return value === target.val();
1163         }
1164
1165     }
1166
1167 });
1168
1169 // deprecated, use $.validator.format instead
1170 $.format = $.validator.format;
1171
1172 }(jQuery));
1173
1174 // ajax mode: abort
1175 // usage: $.ajax({ mode: "abort"[, port: "uniqueport"]});
1176 // if mode:"abort" is used, the previous request on that port (port can be undefined) is aborted via XMLHttpRequest.abort()
1177 (function($) {
1178     var pendingRequests = {};
1179     // Use a prefilter if available (1.5+)
1180     if ( $.ajaxPrefilter ) {
1181         $.ajaxPrefilter(function( settings, _, xhr ) {
1182             var port = settings.port;
1183             if ( settings.mode === "abort" ) {
1184                 if ( pendingRequests[port] ) {
1185                     pendingRequests[port].abort();
1186                 }
1187                 pendingRequests[port] = xhr;
1188             }
1189         });
1190     } else {
1191         // Proxy ajax
1192         var ajax = $.ajax;
1193         $.ajax = function( settings ) {
1194             var mode = ( "mode" in settings ? settings : $.ajaxSettings ).mode,
1195                 port = ( "port" in settings ? settings : $.ajaxSettings ).port;
1196             if ( mode === "abort" ) {
1197                 if ( pendingRequests[port] ) {
1198                     pendingRequests[port].abort();
1199                 }
1200                 return (pendingRequests[port] = ajax.apply(this, arguments));
1201             }
1202             return ajax.apply(this, arguments);
1203         };
1204     }
1205 }(jQuery));
1206
1207 // provides delegate(type: String, delegate: Selector, handler: Callback) plugin for easier event delegation
1208 // handler is only called when $(event.target).is(delegate), in the scope of the jquery-object for event.target
1209 (function($) {
1210     $.extend($.fn, {
1211         validateDelegate: function( delegate, type, handler ) {
1212             return this.bind(type, function( event ) {
1213                 var target = $(event.target);
1214                 if ( target.is(delegate) ) {
1215                     return handler.apply(target, arguments);
1216                 }
1217             });
1218         }
1219     });
1220 }(jQuery));
1221
1222