dqs-jquery-form-validator-rails 2.2.163 → 2.2.164

data/app/assets/javascripts/src/jquery-plugins.js

@@ -0,0 +1,452 @@
+/**
+ * File declaring all methods if this plugin which is applied to $.fn.
+ */
+(function($) {
+
+  var _helpers = 0;
+
+
+  /**
+   * Assigns validateInputOnBlur function to elements blur event
+   *
+   * @param {Object} language Optional, will override $.formUtils.LANG
+   * @param {Object} conf Optional, will override the default settings
+   * @return {jQuery}
+   */
+  $.fn.validateOnBlur = function (language, conf) {
+    this.find('*[data-validation]')
+      .bind('blur.validation', function () {
+        $(this).validateInputOnBlur(language, conf, true, 'blur');
+      });
+    if (conf.validateCheckboxRadioOnClick) {
+      // bind click event to validate on click for radio & checkboxes for nice UX
+      this.find('input[type=checkbox][data-validation],input[type=radio][data-validation]')
+        .bind('click.validation', function () {
+          $(this).validateInputOnBlur(language, conf, true, 'click');
+        });
+    }
+
+    return this;
+  };
+
+  /*
+   * Assigns validateInputOnBlur function to elements custom event
+   * @param {Object} language Optional, will override $.formUtils.LANG
+   * @param {Object} settings Optional, will override the default settings
+   * * @return {jQuery}
+   */
+  $.fn.validateOnEvent = function (language, settings) {
+    this.find('*[data-validation-event]')
+      .each(function () {
+        var $el = $(this),
+          etype = $el.valAttr('event');
+        if (etype) {
+          $el
+            .unbind(etype + '.validation')
+            .bind(etype + '.validation', function (evt) {
+              if( (evt || {}).keyCode !== 9 ) {
+                $(this).validateInputOnBlur(language, settings, true, etype);
+              }
+            });
+        }
+      });
+    return this;
+  };
+
+  /**
+   * fade in help message when input gains focus
+   * fade out when input loses focus
+   * <input data-help="The info that I want to display for the user when input is focused" ... />
+   *
+   * @param {String} attrName - Optional, default is data-help
+   * @return {jQuery}
+   */
+  $.fn.showHelpOnFocus = function (attrName) {
+    if (!attrName) {
+      attrName = 'data-validation-help';
+    }
+
+    // Remove previously added event listeners
+    this.find('.has-help-txt')
+      .valAttr('has-keyup-event', false)
+      .removeClass('has-help-txt');
+
+    // Add help text listeners
+    this.find('textarea,input').each(function () {
+      var $elem = $(this),
+        className = 'jquery_form_help_' + (++_helpers),
+        help = $elem.attr(attrName);
+
+      if (help) {
+        $elem
+          .addClass('has-help-txt')
+          .unbind('focus.help')
+          .bind('focus.help', function () {
+            var $help = $elem.parent().find('.' + className);
+            if ($help.length === 0) {
+              $help = $('<span />')
+                .addClass(className)
+                .addClass('help')
+                .addClass('help-block') // twitter bs
+                .text(help)
+                .hide();
+
+              $elem.after($help);
+            }
+            $help.fadeIn();
+          })
+          .unbind('blur.help')
+          .bind('blur.help', function () {
+            $(this)
+              .parent()
+              .find('.' + className)
+              .fadeOut('slow');
+          });
+      }
+    });
+
+    return this;
+  };
+
+  /**
+   * @param {Function} cb
+   * @param {Object} [conf]
+   * @param {Object} [lang]
+   */
+  $.fn.validate = function(cb, conf, lang) {
+    var language = $.extend({}, $.formUtils.LANG, lang || {});
+    this.each(function() {
+      var $elem = $(this),
+        formDefaultConfig = $elem.closest('form').get(0).validationConfig || {};
+
+      $elem.one('validation', function(evt, isValid) {
+        if ( typeof cb === 'function' ) {
+          cb(isValid, this, evt);
+        }
+      });
+
+      $elem.validateInputOnBlur(
+        language,
+        $.extend({}, formDefaultConfig, conf || {}),
+        true
+      );
+    });
+  };
+
+  /**
+   * Tells whether or not validation of this input will have to postpone the form submit ()
+   * @returns {Boolean}
+   */
+  $.fn.willPostponeValidation = function() {
+    return (this.valAttr('suggestion-nr') ||
+      this.valAttr('postpone') ||
+      this.hasClass('hasDatepicker')) &&
+      !window.postponedValidation;
+  };
+
+  /**
+   * Validate single input when it loses focus
+   * shows error message in a span element
+   * that is appended to the parent element
+   *
+   * @param {Object} [language] Optional, will override $.formUtils.LANG
+   * @param {Object} [conf] Optional, will override the default settings
+   * @param {Boolean} attachKeyupEvent Optional
+   * @param {String} eventType
+   * @return {jQuery}
+   */
+  $.fn.validateInputOnBlur = function (language, conf, attachKeyupEvent, eventType) {
+
+    $.formUtils.eventType = eventType;
+
+    if ( this.willPostponeValidation() ) {
+      // This validation has to be postponed
+      var _self = this,
+        postponeTime = this.valAttr('postpone') || 200;
+
+      window.postponedValidation = function () {
+        _self.validateInputOnBlur(language, conf, attachKeyupEvent, eventType);
+        window.postponedValidation = false;
+      };
+
+      setTimeout(function () {
+        if (window.postponedValidation) {
+          window.postponedValidation();
+        }
+      }, postponeTime);
+
+      return this;
+    }
+
+    language = $.extend({}, $.formUtils.LANG, language || {});
+
+    $.formUtils.errorDialogs.removeErrorStyling(this, conf);
+
+    var $elem = this,
+      $form = $elem.closest('form'),
+      result = $.formUtils.validateInput(
+        $elem,
+        language,
+        conf,
+        $form,
+        eventType
+      );
+
+    if (attachKeyupEvent) {
+      $elem.unbind('keyup.validation');
+    }
+
+    if ( result.isValid ) {
+      if( result.shouldChangeDisplay ) {
+        $elem.addClass('valid');
+        $.formUtils.errorDialogs.getParentContainer($elem)
+          .addClass(conf.inputParentClassOnSuccess);
+      }
+    }
+    else if (!result.isValid) {
+
+      $.formUtils.errorDialogs.applyErrorStyling($elem, conf);
+      $.formUtils.errorDialogs.setInlineErrorMessage($elem, result.errorMsg, conf, conf.errorMessagePosition);
+
+      if (attachKeyupEvent) {
+        $elem.bind('keyup.validation', function (evt) {
+          if( evt.keyCode !== 9 ) {
+            $(this).validateInputOnBlur(language, conf, false, 'keyup');
+          }
+        });
+      }
+    }
+
+    return this;
+  };
+
+  /**
+   * Short hand for fetching/adding/removing element attributes
+   * prefixed with 'data-validation-'
+   *
+   * @param {String} name
+   * @param {String|Boolean} [val]
+   * @return string|undefined
+   * @protected
+   */
+  $.fn.valAttr = function (name, val) {
+    if (val === undefined) {
+      return this.attr('data-validation-' + name);
+    } else if (val === false || val === null) {
+      return this.removeAttr('data-validation-' + name);
+    } else {
+      name = ((name.length > 0) ? '-' + name : '');
+      return this.attr('data-validation' + name, val);
+    }
+  };
+
+  /**
+   * Function that validates all inputs in active form
+   *
+   * @param {Object} [language]
+   * @param {Object} [conf]
+   * @param {Boolean} [displayError] Defaults to true
+   */
+  $.fn.isValid = function (language, conf, displayError) {
+
+    if ($.formUtils.isLoadingModules) {
+      var $self = this;
+      setTimeout(function () {
+        $self.isValid(language, conf, displayError);
+      }, 200);
+      return null;
+    }
+
+    conf = $.extend({}, $.formUtils.defaultConfig(), conf || {});
+    language = $.extend({}, $.formUtils.LANG, language || {});
+    displayError = displayError !== false;
+
+    if ($.formUtils.errorDisplayPreventedWhenHalted) {
+      // isValid() was called programmatically with argument displayError set
+      // to false when the validation was halted by any of the validators
+      delete $.formUtils.errorDisplayPreventedWhenHalted;
+      displayError = false;
+    }
+
+    $.formUtils.isValidatingEntireForm = true;
+    $.formUtils.haltValidation = false;
+
+    /**
+     * Adds message to error message stack if not already in the message stack
+     *
+     * @param {String} mess
+     * @para {jQuery} $elem
+     */
+    var addErrorMessage = function (mess, $elem) {
+        if ($.inArray(mess, errorMessages) < 0) {
+          errorMessages.push(mess);
+        }
+        errorInputs.push($elem);
+        $elem.attr('current-error', mess);
+        if (displayError) {
+          $.formUtils.errorDialogs.applyErrorStyling($elem, conf);
+        }
+      },
+
+      /** Holds inputs (of type checkox or radio) already validated, to prevent recheck of mulitple checkboxes & radios */
+      checkedInputs = [],
+
+      /** Error messages for this validation */
+      errorMessages = [],
+
+      /** Input elements which value was not valid */
+      errorInputs = [],
+
+      /** Form instance */
+      $form = this,
+
+      /**
+       * Tells whether or not to validate element with this name and of this type
+       *
+       * @param {String} name
+       * @param {String} type
+       * @return {Boolean}
+       */
+      ignoreInput = function (name, type) {
+        if (type === 'submit' || type === 'button' || type === 'reset') {
+          return true;
+        }
+        return $.inArray(name, conf.ignore || []) > -1;
+      };
+
+    // Reset style and remove error class
+    if (displayError) {
+      $form.find('.' + conf.errorMessageClass + '.alert').remove();
+      $.formUtils.errorDialogs.removeErrorStyling($form.find('.' + conf.errorElementClass + ',.valid'), conf);
+    }
+
+    // Validate element values
+    $form.find('input,textarea,select').filter(':not([type="submit"],[type="button"])').each(function () {
+      var $elem = $(this),
+        elementType = $elem.attr('type'),
+        isCheckboxOrRadioBtn = elementType === 'radio' || elementType === 'checkbox',
+        elementName = $elem.attr('name');
+
+      if (!ignoreInput(elementName, elementType) && (!isCheckboxOrRadioBtn || $.inArray(elementName, checkedInputs) < 0)) {
+
+        if (isCheckboxOrRadioBtn) {
+          checkedInputs.push(elementName);
+        }
+
+        var result = $.formUtils.validateInput(
+          $elem,
+          language,
+          conf,
+          $form,
+          'submit'
+        );
+
+        if( result.shouldChangeDisplay ) {
+          if ( !result.isValid ) {
+            addErrorMessage(result.errorMsg, $elem);
+          } else if( result.isValid ) {
+            $elem
+              .valAttr('current-error', false)
+              .addClass('valid');
+
+            $.formUtils.errorDialogs.getParentContainer($elem)
+              .addClass(conf.inputParentClassOnSuccess);
+          }
+        }
+      }
+    });
+
+    // Run validation callback
+    if (typeof conf.onValidate === 'function') {
+      var errors = conf.onValidate($form);
+      if ($.isArray(errors)) {
+        $.each(errors, function (i, err) {
+          addErrorMessage(err.message, err.element);
+        });
+      }
+      else if (errors && errors.element && errors.message) {
+        addErrorMessage(errors.message, errors.element);
+      }
+    }
+
+    // Reset form validation flag
+    $.formUtils.isValidatingEntireForm = false;
+
+    // Validation failed
+    if (!$.formUtils.haltValidation && errorInputs.length > 0) {
+
+      if (displayError) {
+        // display all error messages in top of form
+        if (conf.errorMessagePosition === 'top') {
+          $.formUtils.errorDialogs.setTemplateMessage($form, language.errorTitle, errorMessages, conf);
+        }
+        // Customize display message
+        else if (conf.errorMessagePosition === 'custom') {
+          $.formUtils.warn('Use deprecated function errorMessageCustom');
+          if (typeof conf.errorMessageCustom === 'function') {
+            conf.errorMessageCustom($form, language.errorTitle, errorMessages, conf);
+          }
+        }
+        // Display error message below input field or in defined container
+        else {
+          $.each(errorInputs, function (i, $input) {
+            $.formUtils.errorDialogs.setInlineErrorMessage($input, $input.attr('current-error'), conf, conf.errorMessagePosition);
+          });
+        }
+
+        if (conf.scrollToTopOnError) {
+          $.formUtils.$win.scrollTop($form.offset().top - 20);
+        }
+      }
+
+      return false;
+    }
+
+    if (!displayError && $.formUtils.haltValidation) {
+      $.formUtils.errorDisplayPreventedWhenHalted = true;
+    }
+
+    return !$.formUtils.haltValidation;
+  };
+
+  /**
+   * @deprecated
+   * @param language
+   * @param conf
+   */
+  $.fn.validateForm = function (language, conf) {
+    $.formUtils.warn('Use of deprecated function $.validateForm, use $.isValid instead');
+    return this.isValid(language, conf, true);
+  };
+
+  /**
+   * Plugin for displaying input length restriction
+   */
+  $.fn.restrictLength = function (maxLengthElement) {
+    new $.formUtils.lengthRestriction(this, maxLengthElement);
+    return this;
+  };
+
+  /**
+   * Add suggestion dropdown to inputs having data-suggestions with a comma
+   * separated string with suggestions
+   * @param {Array} [settings]
+   * @returns {jQuery}
+   */
+  $.fn.addSuggestions = function (settings) {
+    var sugs = false;
+    this.find('input').each(function () {
+      var $field = $(this);
+
+      sugs = $.split($field.attr('data-suggestions'));
+
+      if (sugs.length > 0 && !$field.hasClass('has-suggestions')) {
+        $.formUtils.suggest($field, sugs, settings);
+        $field.addClass('has-suggestions');
+      }
+    });
+    return this;
+  };
+
+
+})(jQuery);

data/app/assets/javascripts/src/module-loader.js

@@ -0,0 +1,150 @@
+/**
+ * Utility methods used for handling loading of modules (attached to $.formUtils)
+ */
+(function($) {
+
+  'use strict';
+
+  $.formUtils = $.extend($.formUtils || {}, {
+
+    /**
+     * Available validators
+     */
+    validators: {},
+
+    /**
+     * @var {Boolean}
+     */
+    isLoadingModules: false,
+
+    /**
+     * @var {Object}
+     */
+    loadedModules: {},
+
+    /**
+     * @example
+     *  $.formUtils.loadModules('date, security.dev');
+     *
+     * Will load the scripts date.js and security.dev.js from the
+     * directory where this script resides. If you want to load
+     * the modules from another directory you can use the
+     * path argument.
+     *
+     * The script will be cached by the browser unless the module
+     * name ends with .dev
+     *
+     * @param {String} modules - Comma separated string with module file names (no directory nor file extension)
+     * @param {String} [path] - Optional, path where the module files is located if their not in the same directory as the core modules
+     * @param {Boolean|function} [fireEvent] - Optional, whether or not to fire event 'load' when modules finished loading
+     */
+    loadModules: function (modules, path, fireEvent) {
+
+      if (fireEvent === undefined) {
+        fireEvent = true;
+      }
+
+      if ($.formUtils.isLoadingModules) {
+        setTimeout(function () {
+          $.formUtils.loadModules(modules, path, fireEvent);
+        }, 10);
+        return;
+      }
+
+      var hasLoadedAnyModule = false,
+        loadModuleScripts = function (modules, path) {
+
+          var moduleList = $.split(modules),
+            numModules = moduleList.length,
+            moduleLoadedCallback = function () {
+              numModules--;
+              if (numModules === 0) {
+                $.formUtils.isLoadingModules = false;
+                if (fireEvent && hasLoadedAnyModule) {
+                  if( typeof fireEvent === 'function' ) {
+                    fireEvent();
+                  } else {
+                    $.formUtils.$win.trigger('validatorsLoaded');
+                  }
+                }
+              }
+            };
+
+
+          if (numModules > 0) {
+            $.formUtils.isLoadingModules = true;
+          }
+
+          var cacheSuffix = '?_=' + ( new Date().getTime() ),
+            appendToElement = document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0];
+
+          $.each(moduleList, function (i, modName) {
+            modName = $.trim(modName);
+            if (modName.length === 0) {
+              moduleLoadedCallback();
+            }
+            else {
+              var scriptUrl = path + modName + (modName.slice(-3) === '.js' ? '' : '.js'),
+                script = document.createElement('SCRIPT');
+
+              if (scriptUrl in $.formUtils.loadedModules) {
+                // already loaded
+                moduleLoadedCallback();
+              }
+              else {
+
+                // Remember that this script is loaded
+                $.formUtils.loadedModules[scriptUrl] = 1;
+                hasLoadedAnyModule = true;
+
+                // Load the script
+                script.type = 'text/javascript';
+                script.onload = moduleLoadedCallback;
+                script.src = scriptUrl + ( scriptUrl.slice(-7) === '.dev.js' ? cacheSuffix : '' );
+                script.onerror = function() {
+                  $.formUtils.warn('Unable to load form validation module '+scriptUrl);
+                };
+                script.onreadystatechange = function () {
+                  // IE 7 fix
+                  if (this.readyState === 'complete' || this.readyState === 'loaded') {
+                    moduleLoadedCallback();
+                    // Handle memory leak in IE
+                    this.onload = null;
+                    this.onreadystatechange = null;
+                  }
+                };
+                appendToElement.appendChild(script);
+              }
+            }
+          });
+        };
+
+      if (path) {
+        loadModuleScripts(modules, path);
+      } else {
+        var findScriptPathAndLoadModules = function () {
+          var foundPath = false;
+          $('script[src*="form-validator"]').each(function () {
+            foundPath = this.src.substr(0, this.src.lastIndexOf('/')) + '/';
+            if (foundPath === '/') {
+              foundPath = '';
+            }
+            return false;
+          });
+
+          if (foundPath !== false) {
+            loadModuleScripts(modules, foundPath);
+            return true;
+          }
+          return false;
+        };
+
+        if (!findScriptPathAndLoadModules()) {
+          $(findScriptPathAndLoadModules);
+        }
+      }
+    }
+
+  });
+
+})(jQuery);