client_side_validations 3.1.0 → 3.2.0

data/vendor/assets/javascripts/rails.validations.js

@@ -1,139 +1,278 @@
-/*!
- * Rails 3 Client Side Validations - v3.1.0
- * https://github.com/bcardarlela/client_side_validations
- *
- * Copyright (c) 2011 Brian Cardarella
- * Licensed under the MIT license
- * http://www.opensource.org/licenses/mit-license.php
- */
+(function() {
+  var $, validateElement, validateForm, validatorsFor,
+    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
 
-(function($) {
-  $.fn.validate = function() {
-    return this.filter('form[data-validate]').each(function() {
-      var form = $(this);
-      var settings = window[form.attr('id')];
-
-      // Set up the events for the form
-      form
-        .submit(function() { return form.isValid(settings.validators); })
-        .bind('ajax:beforeSend',      function()          { return form.isValid(settings.validators); })
-        // Callbacks
-        .bind('form:validate:after',  function(eventData) { clientSideValidations.callbacks.form.after( form, eventData); })
-        .bind('form:validate:before', function(eventData) { clientSideValidations.callbacks.form.before(form, eventData); })
-        .bind('form:validate:fail',   function(eventData) { clientSideValidations.callbacks.form.fail(  form, eventData); })
-        .bind('form:validate:pass',   function(eventData) { clientSideValidations.callbacks.form.pass(  form, eventData); })
+  $ = jQuery;
 
-        // Set up the events for each validatable form element
-        .find('[data-validate]:input:not(:radio)')
-          .live('focusout',                function()          { $(this).isValid(settings.validators); })
-          .live('change',                  function()          { $(this).data('changed', true); })
-          // Callbacks
-          .live('element:validate:after',  function(eventData) { clientSideValidations.callbacks.element.after( $(this), eventData); })
-          .live('element:validate:before', function(eventData) { clientSideValidations.callbacks.element.before($(this), eventData); })
-          .live('element:validate:fail',   function(eventData, message) {
-            var element = $(this);
-            clientSideValidations.callbacks.element.fail(element, message, function() {
-              addError(element, message);
-            }, eventData) })
-          .live('element:validate:pass',   function(eventData) {
-            var element = $(this);
-            clientSideValidations.callbacks.element.pass(element, function() {
-              removeError(element);
-            }, eventData) })
-        // Checkboxes - Live events don't support filter
-        .end().find('[data-validate]:checkbox')
-          .live('click', function() { $(this).isValid(settings.validators); })
-        // Inputs for confirmations
-        .end().find('[id*=_confirmation]').each(function() {
-          var confirmationElement = $(this),
-              element = form.find('#' + this.id.match(/(.+)_confirmation/)[1] + '[data-validate]:input');
+  $.fn.disableClientSideValidations = function() {
+    return ClientSideValidations.disable(this);
+  };
 
-          if (element[0]) {
-            $('#' + confirmationElement.attr('id'))
-              .live('focusout', function() {
-                element.data('changed', true).isValid(settings.validators);
-              })
-              .live('keyup', function() {
-                element.data('changed', true).isValid(settings.validators);
-              })
-          }
-        });
+  $.fn.enableClientSideValidations = function() {
+    this.filter('form[data-validate]').each(function() {
+      return ClientSideValidations.enablers.form(this);
+    });
+    return this.filter(':input:not(button)').each(function() {
+      return ClientSideValidations.enablers.input(this);
+    });
+  };
 
-      var addError = function(element, message) {
-        clientSideValidations.formBuilders[settings.type].add(element, settings, message);
-      }
+  $.fn.resetClientSideValidations = function() {
+    return this.filter('form[data-validate]').each(function() {
+      return ClientSideValidations.reset(this);
+    });
+  };
 
-      var removeError = function(element) {
-        clientSideValidations.formBuilders[settings.type].remove(element, settings);
-      }
+  $.fn.validate = function() {
+    return this.filter('form[data-validate]').each(function() {
+      return $(this).enableClientSideValidations();
     });
-  }
+  };
 
   $.fn.isValid = function(validators) {
-    if ($(this[0]).is('form')) {
-      return validateForm($(this[0]), validators);
+    var obj;
+    obj = $(this[0]);
+    if (obj.is('form')) {
+      return validateForm(obj, validators);
     } else {
-      return validateElement($(this[0]), validators[this[0].name]);
+      return validateElement(obj, validatorsFor(this[0].name, validators));
     }
-  }
-
-  var validateForm = function(form, validators) {
-    var valid = true;
-
-    form.trigger('form:validate:before').find('[data-validate]:input').each(function() {
-      if (!$(this).isValid(validators)) { valid = false; }
+  };
+
+  validatorsFor = function(name, validators) {
+    name = name.replace(/_attributes\]\[\d+\]/g, "_attributes][]");
+    return validators[name] || {};
+  };
+
+  validateForm = function(form, validators) {
+    var valid;
+    form.trigger('form:validate:before.ClientSideValidations');
+    valid = true;
+    form.find(':input:enabled:visible[data-validate]').each(function() {
+      if (!$(this).isValid(validators)) {
+        valid = false;
+      }
+      return true;
     });
-
     if (valid) {
-      form.trigger('form:validate:pass');
+      form.trigger('form:validate:pass.ClientSideValidations');
     } else {
-      form.trigger('form:validate:fail');
+      form.trigger('form:validate:fail.ClientSideValidations');
     }
-
-    form.trigger('form:validate:after');
+    form.trigger('form:validate:after.ClientSideValidations');
     return valid;
-  }
-
-  var validateElement = function(element, validators) {
-    element.trigger('element:validate:before');
-
-    if (element.data('changed') !== false) {
-      var valid = true;
-      element.data('changed', false);
-
-      // Because 'length' is defined on the list of validators we cannot call jQuery.each on
-      // the clientSideValidations.validators.all() object
-      for (kind in clientSideValidations.validators.all()) {
-        if (validators[kind] && (message = clientSideValidations.validators.all()[kind](element, validators[kind]))) {
-          element.trigger('element:validate:fail', message).data('valid', false);
-          valid = false;
-          break;
+  };
+
+  validateElement = function(element, validators) {
+    var afterValidate, destroyInputName, executeValidators, failElement, local, passElement, remote;
+    element.trigger('element:validate:before.ClientSideValidations');
+    passElement = function() {
+      return element.trigger('element:validate:pass.ClientSideValidations').data('valid', null);
+    };
+    failElement = function(message) {
+      element.trigger('element:validate:fail.ClientSideValidations', message).data('valid', false);
+      return false;
+    };
+    afterValidate = function() {
+      return element.trigger('element:validate:after.ClientSideValidations').data('valid') !== false;
+    };
+    executeValidators = function(context) {
+      var fn, kind, message, valid, validator, _i, _len, _ref;
+      valid = true;
+      for (kind in context) {
+        fn = context[kind];
+        if (validators[kind]) {
+          _ref = validators[kind];
+          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+            validator = _ref[_i];
+            if (message = fn.call(context, element, validator)) {
+              valid = failElement(message);
+              break;
+            }
+          }
+          if (!valid) {
+            break;
+          }
         }
       }
-
-      if (valid) { element.data('valid', null); element.trigger('element:validate:pass'); }
+      return valid;
+    };
+    destroyInputName = element.attr('name').replace(/\[([^\]]*?)\]$/, '[_destroy]');
+    if ($("input[name='" + destroyInputName + "']").val() === "1") {
+      passElement();
+      return afterValidate();
+    }
+    if (element.data('changed') === false) {
+      return afterValidate();
     }
+    element.data('changed', false);
+    local = ClientSideValidations.validators.local;
+    remote = ClientSideValidations.validators.remote;
+    if (executeValidators(local) && executeValidators(remote)) {
+      passElement();
+    }
+    return afterValidate();
+  };
+
+  $(function() {
+    return $('form[data-validate]').validate();
+  });
 
-    element.trigger('element:validate:after');
-    return element.data('valid') === false ? false : true;
+  if (window.ClientSideValidations === void 0) {
+    window.ClientSideValidations = {};
   }
 
-  // Main hook
-  // If new forms are dynamically introduced into the DOM the .validate() method
-  // must be invoked on that form
-  $(function() { $('form[data-validate]').validate(); })
-})(jQuery);
+  if (window.ClientSideValidations.forms === void 0) {
+    window.ClientSideValidations.forms = {};
+  }
 
-var clientSideValidations = {
-  validators: {
-    all: function() { return jQuery.extend({}, clientSideValidations.validators.local, clientSideValidations.validators.remote) },
+  window.ClientSideValidations.reset = function(form) {
+    var $form, key;
+    $form = $(form);
+    ClientSideValidations.disable(form);
+    ClientSideValidations.disable($form.find(':input'));
+    for (key in form.ClientSideValidations.settings.validators) {
+      form.ClientSideValidations.removeError($form.find("[name='" + key + "']"));
+    }
+    return ClientSideValidations.enablers.form(form);
+  };
+
+  window.ClientSideValidations.disable = function(target) {
+    var $target;
+    $target = $(target);
+    $target.off('.ClientSideValidations');
+    $target.removeData('valid');
+    $target.removeData('changed');
+    return $target.filter(':input').each(function() {
+      return $(this).removeAttr('data-validate');
+    });
+  };
+
+  window.ClientSideValidations.enablers = {
+    form: function(form) {
+      var $form, binding, event, _ref;
+      $form = $(form);
+      form.ClientSideValidations = {
+        settings: window.ClientSideValidations.forms[$form.attr('id')],
+        addError: function(element, message) {
+          return ClientSideValidations.formBuilders[form.ClientSideValidations.settings.type].add(element, form.ClientSideValidations.settings, message);
+        },
+        removeError: function(element) {
+          return ClientSideValidations.formBuilders[form.ClientSideValidations.settings.type].remove(element, form.ClientSideValidations.settings);
+        }
+      };
+      _ref = {
+        'submit.ClientSideValidations': function(eventData) {
+          if (!$form.isValid(form.ClientSideValidations.settings.validators)) {
+            eventData.preventDefault();
+            return eventData.stopImmediatePropagation();
+          }
+        },
+        'ajax:beforeSend.ClientSideValidations': function(eventData) {
+          if (eventData.target === this) {
+            return $form.isValid(form.ClientSideValidations.settings.validators);
+          }
+        },
+        'form:validate:after.ClientSideValidations': function(eventData) {
+          return ClientSideValidations.callbacks.form.after($form, eventData);
+        },
+        'form:validate:before.ClientSideValidations': function(eventData) {
+          return ClientSideValidations.callbacks.form.before($form, eventData);
+        },
+        'form:validate:fail.ClientSideValidations': function(eventData) {
+          return ClientSideValidations.callbacks.form.fail($form, eventData);
+        },
+        'form:validate:pass.ClientSideValidations': function(eventData) {
+          return ClientSideValidations.callbacks.form.pass($form, eventData);
+        }
+      };
+      for (event in _ref) {
+        binding = _ref[event];
+        $form.on(event, binding);
+      }
+      return $form.find(':input').each(function() {
+        return ClientSideValidations.enablers.input(this);
+      });
+    },
+    input: function(input) {
+      var $form, $input, binding, event, form, _ref;
+      $input = $(input);
+      form = input.form;
+      $form = $(form);
+      _ref = {
+        'focusout.ClientSideValidations': function() {
+          return $(this).isValid(form.ClientSideValidations.settings.validators);
+        },
+        'change.ClientSideValidations': function() {
+          return $(this).data('changed', true);
+        },
+        'element:validate:after.ClientSideValidations': function(eventData) {
+          return ClientSideValidations.callbacks.element.after($(this), eventData);
+        },
+        'element:validate:before.ClientSideValidations': function(eventData) {
+          return ClientSideValidations.callbacks.element.before($(this), eventData);
+        },
+        'element:validate:fail.ClientSideValidations': function(eventData, message) {
+          var element;
+          element = $(this);
+          return ClientSideValidations.callbacks.element.fail(element, message, function() {
+            return form.ClientSideValidations.addError(element, message);
+          }, eventData);
+        },
+        'element:validate:pass.ClientSideValidations': function(eventData) {
+          var element;
+          element = $(this);
+          return ClientSideValidations.callbacks.element.pass(element, function() {
+            return form.ClientSideValidations.removeError(element);
+          }, eventData);
+        }
+      };
+      for (event in _ref) {
+        binding = _ref[event];
+        $input.filter(':enabled:not(:radio):not([id$=_confirmation]):visible:not(button)[name]').each(function() {
+          return $(this).attr('data-validate', true);
+        }).on(event, binding);
+      }
+      $input.filter(':checkbox:visible').on('click.ClientSideValidations', function() {
+        $(this).isValid(form.ClientSideValidations.settings.validators);
+        return true;
+      });
+      return $input.filter('[id$=_confirmation]:visible').each(function() {
+        var confirmationElement, element, _ref1, _results;
+        confirmationElement = $(this);
+        element = $form.find("#" + (this.id.match(/(.+)_confirmation/)[1]) + ":input");
+        if (element[0]) {
+          _ref1 = {
+            'focusout.ClientSideValidations': function() {
+              return element.data('changed', true).isValid(form.ClientSideValidations.settings.validators);
+            },
+            'keyup.ClientSideValidations': function() {
+              return element.data('changed', true).isValid(form.ClientSideValidations.settings.validators);
+            }
+          };
+          _results = [];
+          for (event in _ref1) {
+            binding = _ref1[event];
+            _results.push($("#" + (confirmationElement.attr('id'))).on(event, binding));
+          }
+          return _results;
+        }
+      });
+    }
+  };
+
+  window.ClientSideValidations.validators = {
+    all: function() {
+      return jQuery.extend({}, ClientSideValidations.validators.local, ClientSideValidations.validators.remote);
+    },
     local: {
       presence: function(element, options) {
-        if (/^\s*$/.test(element.val() || "")) {
+        if (/^\s*$/.test(element.val() || '')) {
           return options.message;
         }
       },
       acceptance: function(element, options) {
+        var _ref;
         switch (element.attr('type')) {
           case 'checkbox':
             if (!element.attr('checked')) {
@@ -141,264 +280,317 @@ var clientSideValidations = {
             }
             break;
           case 'text':
-            if (element.val() != (options.accept || '1')) {
+            if (element.val() !== (((_ref = options.accept) != null ? _ref.toString() : void 0) || '1')) {
               return options.message;
             }
-            break;
         }
       },
       format: function(element, options) {
-        if ((message = this.presence(element, options)) && options.allow_blank == true) {
-          return;
-        } else if (message) {
-          return message;
-        } else {
-          if (options['with'] && !options['with'].test(element.val())) {
-            return options.message;
-          } else if (options['without'] && options['without'].test(element.val())) {
-            return options.message;
+        var message;
+        message = this.presence(element, options);
+        if (message) {
+          if (options.allow_blank === true) {
+            return;
           }
+          return message;
+        }
+        if (options["with"] && !options["with"].test(element.val())) {
+          return options.message;
+        }
+        if (options.without && options.without.test(element.val())) {
+          return options.message;
         }
       },
       numericality: function(element, options) {
-        if (!/^-?(?:\d+|\d{1,3}(?:,\d{3})+)(?:\.\d*)?$/.test(element.val())) {
+        var CHECKS, check, check_value, fn, form, operator, val;
+        val = jQuery.trim(element.val());
+        if (!ClientSideValidations.patterns.numericality.test(val)) {
+          if (options.allow_blank === true) {
+            return;
+          }
           return options.messages.numericality;
         }
-
-        if (options.only_integer && !/^\d+$/.test(element.val())) {
+        if (options.only_integer && !/^[+-]?\d+$/.test(val)) {
           return options.messages.only_integer;
         }
-
-        var CHECKS = { greater_than: '>', greater_than_or_equal_to: '>=',
-          equal_to: '==', less_than: '<', less_than_or_equal_to: '<=' }
-
-        for (var check in CHECKS) {
-          if (options[check] != undefined && !(new Function("return " + element.val() + CHECKS[check] + options[check])())) {
+        CHECKS = {
+          greater_than: '>',
+          greater_than_or_equal_to: '>=',
+          equal_to: '==',
+          less_than: '<',
+          less_than_or_equal_to: '<='
+        };
+        form = $(element[0].form);
+        for (check in CHECKS) {
+          operator = CHECKS[check];
+          if (!(options[check] != null)) {
+            continue;
+          }
+          if (!isNaN(parseFloat(options[check])) && isFinite(options[check])) {
+            check_value = options[check];
+          } else if (form.find("[name*=" + options[check] + "]").size() === 1) {
+            check_value = form.find("[name*=" + options[check] + "]").val();
+          } else {
+            return;
+          }
+          fn = new Function("return " + val + " " + operator + " " + check_value);
+          if (!fn()) {
             return options.messages[check];
           }
         }
-
-        if (options.odd && !(parseInt(element.val()) % 2)) {
+        if (options.odd && !(parseInt(val, 10) % 2)) {
           return options.messages.odd;
         }
-
-        if (options.even && (parseInt(element.val()) % 2)) {
+        if (options.even && (parseInt(val, 10) % 2)) {
           return options.messages.even;
         }
       },
       length: function(element, options) {
-        var blankOptions = {};
-        if (options.is) {
-          blankOptions.message = options.messages.is;
-        } else if (options.minimum) {
-          blankOptions.message = options.messages.minimum;
-        }
-        if ((message = this.presence(element, blankOptions)) && options.allow_blank == true) {
-          return;
-        } else if (message) {
+        var CHECKS, blankOptions, check, fn, message, operator, tokenized_length, tokenizer;
+        tokenizer = options.js_tokenizer || "split('')";
+        tokenized_length = new Function('element', "return (element.val()." + tokenizer + " || '').length")(element);
+        CHECKS = {
+          is: '==',
+          minimum: '>=',
+          maximum: '<='
+        };
+        blankOptions = {};
+        blankOptions.message = options.is ? options.messages.is : options.minimum ? options.messages.minimum : void 0;
+        message = this.presence(element, blankOptions);
+        if (message) {
+          if (options.allow_blank === true) {
+            return;
+          }
           return message;
-        } else {
-          var CHECKS = { is: '==', minimum: '>=', maximum: '<=' }
-          var tokenizer = options.js_tokenizer || "split('')";
-          var tokenized_length = new Function("element", "return (element.val()." + tokenizer + " || '').length;")(element);
-
-          for (var check in CHECKS) {
-            if (options[check] && !(new Function("return " + tokenized_length + CHECKS[check] + options[check])())) {
-              return options.messages[check];
-            }
+        }
+        for (check in CHECKS) {
+          operator = CHECKS[check];
+          if (!options[check]) {
+            continue;
+          }
+          fn = new Function("return " + tokenized_length + " " + operator + " " + options[check]);
+          if (!fn()) {
+            return options.messages[check];
           }
         }
       },
       exclusion: function(element, options) {
-        if ((message = this.presence(element, options)) && options.allow_blank == true) {
-          return;
-        } else if (message) {
+        var lower, message, option, upper, _ref;
+        message = this.presence(element, options);
+        if (message) {
+          if (options.allow_blank === true) {
+            return;
+          }
           return message;
-        } else {
-          if (options['in']) {
-            for (var i = 0; i < options['in'].length; i++) {
-              if (options['in'][i] == element.val()) {
-                return options.message;
-              }
-            }
-          } else if (options['range']) {
-            var lower = options['range'][0],
-                upper = options['range'][1];
-            if (element.val() >= lower && element.val() <= upper) {
-              return options.message;
+        }
+        if (options["in"]) {
+          if (_ref = element.val(), __indexOf.call((function() {
+            var _i, _len, _ref1, _results;
+            _ref1 = options["in"];
+            _results = [];
+            for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+              option = _ref1[_i];
+              _results.push(option.toString());
             }
+            return _results;
+          })(), _ref) >= 0) {
+            return options.message;
+          }
+        }
+        if (options.range) {
+          lower = options.range[0];
+          upper = options.range[1];
+          if (element.val() >= lower && element.val() <= upper) {
+            return options.message;
           }
         }
       },
       inclusion: function(element, options) {
-        if ((message = this.presence(element, options)) && options.allow_blank == true) {
-          return;
-        } else if (message) {
+        var lower, message, option, upper, _ref;
+        message = this.presence(element, options);
+        if (message) {
+          if (options.allow_blank === true) {
+            return;
+          }
           return message;
-        } else {
-          if (options['in']) {
-            for (var i = 0; i < options['in'].length; i++) {
-              if (options['in'][i] == element.val()) {
-                return;
-              }
-            }
-            return options.message;
-          } else if (options['range']) {
-            var lower = options['range'][0],
-                upper = options['range'][1];
-
-            if (element.val() >= lower && element.val() <= upper) {
-              return;
-            } else {
-              return options.message;
+        }
+        if (options["in"]) {
+          if (_ref = element.val(), __indexOf.call((function() {
+            var _i, _len, _ref1, _results;
+            _ref1 = options["in"];
+            _results = [];
+            for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+              option = _ref1[_i];
+              _results.push(option.toString());
             }
+            return _results;
+          })(), _ref) >= 0) {
+            return;
           }
+          return options.message;
+        }
+        if (options.range) {
+          lower = options.range[0];
+          upper = options.range[1];
+          if (element.val() >= lower && element.val() <= upper) {
+            return;
+          }
+          return options.message;
         }
       },
       confirmation: function(element, options) {
-        if (element.val() != jQuery('#' + element.attr('id') + '_confirmation').val()) {
+        if (element.val() !== jQuery("#" + (element.attr('id')) + "_confirmation").val()) {
           return options.message;
         }
+      },
+      uniqueness: function(element, options) {
+        var form, matches, name, name_prefix, name_suffix, valid, value;
+        name = element.attr('name');
+        if (/_attributes\]\[\d/.test(name)) {
+          matches = name.match(/^(.+_attributes\])\[\d+\](.+)$/);
+          name_prefix = matches[1];
+          name_suffix = matches[2];
+          value = element.val();
+          if (name_prefix && name_suffix) {
+            form = element.closest('form');
+            valid = true;
+            form.find(':input[name^="' + name_prefix + '"][name$="' + name_suffix + '"]').each(function() {
+              if ($(this).attr('name') !== name) {
+                if ($(this).val() === value) {
+                  valid = false;
+                  return $(this).data('notLocallyUnique', true);
+                } else {
+                  if ($(this).data('notLocallyUnique')) {
+                    return $(this).removeData('notLocallyUnique').data('changed', true);
+                  }
+                }
+              }
+            });
+            if (!valid) {
+              return options.message;
+            }
+          }
+        }
       }
     },
     remote: {
       uniqueness: function(element, options) {
-        var data = {};
-        data['case_sensitive'] = !!options.case_sensitive;
+        var data, key, message, name, scope_value, scoped_element, scoped_name, _ref;
+        message = ClientSideValidations.validators.local.presence(element, options);
+        if (message) {
+          if (options.allow_blank === true) {
+            return;
+          }
+          return message;
+        }
+        data = {};
+        data.case_sensitive = !!options.case_sensitive;
         if (options.id) {
-          data['id'] = options.id;
+          data.id = options.id;
         }
-
         if (options.scope) {
-          data.scope = {}
-          for (key in options.scope) {
-            var scoped_element = jQuery('[name="' + element.attr('name').replace(/\[\w+]$/, '[' + key + ']' + '"]'));
-            if (scoped_element[0] && scoped_element.val() != options.scope[key]) {
+          data.scope = {};
+          _ref = options.scope;
+          for (key in _ref) {
+            scope_value = _ref[key];
+            scoped_name = element.attr('name').replace(/\[\w+\]$/, "[" + key + "]");
+            scoped_element = jQuery("[name='" + scoped_name + "']");
+            jQuery("[name='" + scoped_name + "']:checkbox").each(function() {
+              if (this.checked) {
+                return scoped_element = this;
+              }
+            });
+            if (scoped_element[0] && scoped_element.val() !== scope_value) {
               data.scope[key] = scoped_element.val();
-              scoped_element.unbind('change.' + element.id).bind('change.' + element.id, function() { element.trigger('change'); element.trigger('focusout'); });
+              scoped_element.unbind("change." + element.id).bind("change." + element.id, function() {
+                element.trigger('change.ClientSideValidations');
+                return element.trigger('focusout.ClientSideValidations');
+              });
             } else {
-              data.scope[key] = options.scope[key];
+              data.scope[key] = scope_value;
             }
           }
         }
-
-        // Kind of a hack but this will isolate the resource name and attribute.
-        // e.g. user[records_attributes][0][title] => records[title]
-        // e.g. user[record_attributes][title] => record[title]
-        // Server side handles classifying the resource properly
-        if (/_attributes]/.test(element.attr('name'))) {
-          var name = element.attr('name').match(/\[\w+_attributes]/g).pop().match(/\[(\w+)_attributes]/).pop();
-          name += /(\[\w+])$/.exec(element.attr('name'))[1];
+        if (/_attributes\]/.test(element.attr('name'))) {
+          name = element.attr('name').match(/\[\w+_attributes\]/g).pop().match(/\[(\w+)_attributes\]/).pop();
+          name += /(\[\w+\])$/.exec(element.attr('name'))[1];
         } else {
-          var name = element.attr('name');
+          name = element.attr('name');
         }
-
-        // Override the name if a nested module class is passed
         if (options['class']) {
-          name = options['class'] + '[' + name.split('[')[1]
+          name = options['class'] + '[' + name.split('[')[1];
         }
         data[name] = element.val();
-
         if (jQuery.ajax({
           url: '/validators/uniqueness',
           data: data,
           async: false
-        }).status == 200) {
+        }).status === 200) {
           return options.message;
         }
       }
     }
-  },
-  formBuilders: {
+  };
+
+  window.ClientSideValidations.formBuilders = {
     'ActionView::Helpers::FormBuilder': {
       add: function(element, settings, message) {
-        if (element.data('valid') !== false && jQuery('label.message[for="' + element.attr('id') + '"]')[0] == undefined) {
-          var inputErrorField = jQuery(settings.input_tag),
-              labelErrorField = jQuery(settings.label_tag),
-              label = jQuery('label[for="' + element.attr('id') + '"]:not(.message)');
-
-          if (element.attr('autofocus')) { element.attr('autofocus', false) };
+        var form, inputErrorField, label, labelErrorField;
+        form = $(element[0].form);
+        if (element.data('valid') !== false && !(form.find("label.message[for='" + (element.attr('id')) + "']")[0] != null)) {
+          inputErrorField = jQuery(settings.input_tag);
+          labelErrorField = jQuery(settings.label_tag);
+          label = form.find("label[for='" + (element.attr('id')) + "']:not(.message)");
+          if (element.attr('autofocus')) {
+            element.attr('autofocus', false);
+          }
           element.before(inputErrorField);
           inputErrorField.find('span#input_tag').replaceWith(element);
           inputErrorField.find('label.message').attr('for', element.attr('id'));
           labelErrorField.find('label.message').attr('for', element.attr('id'));
-          label.replaceWith(labelErrorField);
+          labelErrorField.insertAfter(label);
           labelErrorField.find('label#label_tag').replaceWith(label);
         }
-        jQuery('label.message[for="' + element.attr('id') + '"]').text(message);
+        return form.find("label.message[for='" + (element.attr('id')) + "']").text(message);
       },
       remove: function(element, settings) {
-        var errorFieldClass = jQuery(settings.input_tag).attr('class'),
-            inputErrorField = element.closest('.' + errorFieldClass),
-            label = jQuery('label[for="' + element.attr('id') + '"]:not(.message)'),
-            labelErrorField = label.closest('.' + errorFieldClass);
-
+        var errorFieldClass, form, inputErrorField, label, labelErrorField;
+        form = $(element[0].form);
+        errorFieldClass = jQuery(settings.input_tag).attr('class');
+        inputErrorField = element.closest("." + (errorFieldClass.replace(" ", ".")));
+        label = form.find("label[for='" + (element.attr('id')) + "']:not(.message)");
+        labelErrorField = label.closest("." + errorFieldClass);
         if (inputErrorField[0]) {
-          inputErrorField.find('#' + element.attr('id')).detach();
+          inputErrorField.find("#" + (element.attr('id'))).detach();
           inputErrorField.replaceWith(element);
           label.detach();
-          labelErrorField.replaceWith(label);
-        }
-      }
-    },
-    'SimpleForm::FormBuilder': {
-      add: function(element, settings, message) {
-        if (element.data('valid') !== false) {
-          var wrapper = element.closest(settings.wrapper_tag);
-          wrapper.addClass(settings.wrapper_error_class);
-          var errorElement = $('<' + settings.error_tag + ' class="' + settings.error_class + '">' + message + '</' + settings.error_tag + '>');
-          wrapper.append(errorElement);
-        } else {
-          element.parent().find(settings.error_tag + '.' + settings.error_class).text(message);
+          return labelErrorField.replaceWith(label);
         }
-      },
-      remove: function(element, settings) {
-        var wrapper = element.closest(settings.wrapper_tag + '.' + settings.wrapper_error_class);
-        wrapper.removeClass(settings.wrapper_error_class);
-        var errorElement = wrapper.find(settings.error_tag + '.' + settings.error_class);
-        errorElement.remove();
       }
+    }
+  };
 
-    },
-    'Formtastic::FormBuilder': {
-      add: function(element, settings, message) {
-        if (element.data('valid') !== false) {
-          var wrapper = element.closest('li');
-          wrapper.addClass('error');
-          var errorElement = $('<p class="' + settings.inline_error_class + '">' + message + '</p>');
-          wrapper.append(errorElement);
-        } else {
-          element.parent().find('p.' + settings.inline_error_class).text(message);
-        }
-      },
-      remove: function(element, settings) {
-        var wrapper = element.closest('li.error');
-        wrapper.removeClass('error');
-        var errorElement = wrapper.find('p.' + settings.inline_error_class);
-        errorElement.remove();
-      }
-    },
-    'NestedForm::Builder': {
-      add: function(element, settings, message) {
-        clientSideValidations.formBuilders['ActionView::Helpers::FormBuilder'].add(element, settings, message);
+  window.ClientSideValidations.patterns = {
+    numericality: /^(-|\+)?(?:\d+|\d{1,3}(?:,\d{3})+)(?:\.\d*)?$/
+  };
+
+  window.ClientSideValidations.callbacks = {
+    element: {
+      after: function(element, eventData) {},
+      before: function(element, eventData) {},
+      fail: function(element, message, addError, eventData) {
+        return addError();
       },
-      remove: function(element, settings, message) {
-        clientSideValidations.formBuilders['ActionView::Helpers::FormBuilder'].remove(element, settings, message);
+      pass: function(element, removeError, eventData) {
+        return removeError();
       }
-    }
-  },
-  callbacks: {
-    element: {
-      after:  function(element, eventData)                    { },
-      before: function(element, eventData)                    { },
-      fail:   function(element, message, addError, eventData) { addError() },
-      pass:   function(element, removeError, eventData)       { removeError() }
     },
     form: {
-      after:  function(form, eventData) { },
-      before: function(form, eventData) { },
-      fail:   function(form, eventData) { },
-      pass:   function(form, eventData) { }
+      after: function(form, eventData) {},
+      before: function(form, eventData) {},
+      fail: function(form, eventData) {},
+      pass: function(form, eventData) {}
     }
-  }
-};
+  };
+
+}).call(this);