client_side_validations 15.0.0 → 16.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9aae7b42d20afe874b89eacfb409b8f7e0730b58d6d3ddd56f7f3b4fd47573db
-  data.tar.gz: 0327e5e5af1b22a18a986e51d2471aaf7dfe0407dc61f2dab632456027b7c9a4
+  metadata.gz: 43b783baa4ef85e0722508e882ae809de87bc469f480a740f81eff2d7e103e55
+  data.tar.gz: 22d4a7022f6403cfeca96a1eca204cd94454135fbf11b196193c196ba0d19344
 SHA512:
-  metadata.gz: f0be68614eb80ba98162abe631d7535380146394ff2473f59fae3669199d33deb1ecb3bc835dfdb64f56985d8c964c0d9962b69d5ac33f583625ef9ec42d92ad
-  data.tar.gz: 849c0989043371872d6626b208120a2ef8a96d31b63501545343a54e91f1c699899c14ea7dd026dd4b3f216c57923fe1d0029309d34d65151c9da8e63333dd3b
+  metadata.gz: 3a4fb820cf1b79a10295f504e0a3bf229578d4611d2e2a4aa82e2050735a436da730fb815bcd3db98aaca914c532a5d98b1d7743e671642337eab73d22cf0b3b
+  data.tar.gz: 3d2eebecc60968800d8fb9b4b013055658ea0ae100e73012ee50988bd41271a6d23999587bd0e8524c74fb8c17db733197e0b60bcf2c59301cb45acf5ede696e

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 16.0.0 / 2019-08-23
+
+* [FEATURE] Move to ES6
+* [FEATURE] Add Webpacker compatibility
+* [BUGFIX] Fix acceptance validator
+* [ENHANCEMENT] Update development dependencies
+
 ## 15.0.0 / 2019-05-14
 
 * [FEATURE] Drop Ruby 2.2 support
@@ -163,6 +170,7 @@
 ## 6.0.0 / 2017-01-20
 
 * [FEATURE] Rails 5.0 compatibility
+* [FEATURE] Drop Rails 4.x support
 
 ## 4.2.12 / 2017-01-19
 

data/README.md

@@ -1,11 +1,12 @@
 # ClientSideValidations #
 
 [![Gem Version](https://badge.fury.io/rb/client_side_validations.svg)](https://badge.fury.io/rb/client_side_validations)
+[![npm version](https://badge.fury.io/js/%40client-side-validations%2Fclient-side-validations.svg)](https://badge.fury.io/js/%40client-side-validations%2Fclient-side-validations)
 [![Build Status](https://secure.travis-ci.org/DavyJonesLocker/client_side_validations.svg?branch=master)](https://travis-ci.org/DavyJonesLocker/client_side_validations)
 [![Maintainability](https://api.codeclimate.com/v1/badges/9f9e8bb6edc92615f34e/maintainability)](https://codeclimate.com/github/DavyJonesLocker/client_side_validations/maintainability)
 [![Coverage Status](https://coveralls.io/repos/github/DavyJonesLocker/client_side_validations/badge.svg?branch=master)](https://coveralls.io/github/DavyJonesLocker/client_side_validations?branch=master)
 
-`ClientSideValidations` made easy for your Rails 5.x / Rails 6 applications!
+`ClientSideValidations` made easy for your Rails 5.x / Rails 6.0 applications!
 
 ## Project Goals ##
 
@@ -49,11 +50,53 @@ This will install the initializer:
 config/initializers/client_side_validations.rb
 ```
 
-If you need to copy the asset files from the gem into your project:
+### JavaScript file ###
+
+Instructions depend on your technology stack.
+
+Please note that CSV depends on jQuery >= 1.12.4 (jQuery slim is fine).
+
+####  When using Webpacker ####
+
+Make sure that you are requiring jQuery.
+
+Add the following package:
+
+```sh
+yarn add @client-side-validations/client-side-validations
+```
+
+Then add the following line to your `app/javascript/packs/application.js` pack:
+
+```js
+import '@client-side-validations/client-side-validations'
+```
+
+If you are using [Turbolinks](https://github.com/turbolinks/turbolinks),
+make sure that '@client-side-validations/client-side-validations' is imported
+**after** `Turbolinks.start()`, so ClientSideValidations can properly attach its
+event handlers.
+
+####  When using Sprockets ####
+
+Make sure that you are requiring jQuery.
+
+Add the following to your `app/assets/javascripts/application.js` file.
+
+```js
+//= require rails.validations
+```
+
+If you are using [Turbolinks](https://github.com/turbolinks/turbolinks),
+make sure that `rails.validations` is required **after** `turbolinks`, so
+ClientSideValidations can properly attach its event handlers.
+
+If you need to copy the asset files from the gem into your project, run:
 
 ```
 rails g client_side_validations:copy_assets
 ```
+
 Note: If you run `copy_assets`, you will need to run it again each time you update this project.
 
 ## Initializer ##
@@ -79,17 +122,6 @@ Rails `FormBuilders`. Please see the [Plugin wiki page](https://github.com/DavyJ
 
 ## Usage ##
 
-The javascript file is served up in the asset pipeline. Add the
-following to your `app/assets/javascripts/application.js` file.
-
-```js
-//= require rails.validations
-```
-
-Note: If you are using [Turbolinks](https://github.com/turbolinks/turbolinks),
-make sure that `rails.validations` is required **after** `turbolinks`, so
-ClientSideValidations can properly attach its event handler.
-
 In your `FormBuilder` you only need to enable validations:
 
 ```erb
@@ -119,9 +151,9 @@ in the form. Given the following model:
 
 ```ruby
 class Person < ActiveRecord::Base
-  validates :name, :email, presence: true, length: { maximum: 10 }, if: :can_validate?
+  validates :name, presence: true, length: { maximum: 10 }, if: :can_validate?
 
-  def can_validate
+  def can_validate?
     true
   end
 end
@@ -247,7 +279,7 @@ were overwritten by the call to `FormBuilder#validate`
 
 If you need to change the markup of how the errors are rendered you can modify that in `config/initializers/client_side_validations.rb`
 
-*Please Note* if you modify the markup, you will also need to modify `ClientSideValidations.formBuilders['ActionView::Helpers::FormBuilder']`'s `add` and `remove` functions. You can override the behavior by creating a new javascript file called `rails.validations.actionView.js` that contains the following:
+*Please Note* if you modify the markup, you will also need to modify `ClientSideValidations.formBuilders['ActionView::Helpers::FormBuilder']`'s `add` and `remove` functions. You can override the behavior by creating a new JavaScript file called `rails.validations.actionView.js` that contains the following:
 
 ```js
 window.ClientSideValidations.formBuilders['ActionView::Helpers::FormBuilder'] = {

data/lib/client_side_validations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ClientSideValidations
-  VERSION = '15.0.0'
+  VERSION = '16.0.0'
 end

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

@@ -1,286 +1,185 @@
-
 /*!
- * Client Side Validations - v15.0.0 (https://github.com/DavyJonesLocker/client_side_validations)
+ * Client Side Validations JS - v0.0.3 (https://github.com/DavyJonesLocker/client_side_validations)
  * Copyright (c) 2019 Geremia Taglialatela, Brian Cardarella
  * Licensed under MIT (https://opensource.org/licenses/mit-license.php)
  */
 
-(function() {
-  var $, ClientSideValidations, initializeOnEvent, 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; };
-
-  $ = jQuery;
-
-  $.fn.disableClientSideValidations = function() {
-    ClientSideValidations.disable(this);
-    return this;
-  };
-
-  $.fn.enableClientSideValidations = function() {
-    this.filter(ClientSideValidations.selectors.forms).each(function() {
-      return ClientSideValidations.enablers.form(this);
-    });
-    this.filter(ClientSideValidations.selectors.inputs).each(function() {
-      return ClientSideValidations.enablers.input(this);
-    });
-    return this;
-  };
-
-  $.fn.resetClientSideValidations = function() {
-    this.filter(ClientSideValidations.selectors.forms).each(function() {
-      return ClientSideValidations.reset(this);
-    });
-    return this;
-  };
-
-  $.fn.validate = function() {
-    this.filter(ClientSideValidations.selectors.forms).each(function() {
-      return $(this).enableClientSideValidations();
-    });
-    return this;
-  };
-
-  $.fn.isValid = function(validators) {
-    var obj;
-    obj = $(this[0]);
-    if (obj.is('form')) {
-      return validateForm(obj, validators);
-    } else {
-      return validateElement(obj, validatorsFor(this[0].name, validators));
-    }
-  };
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('jquery')) :
+  typeof define === 'function' && define.amd ? define(['jquery'], factory) :
+  (global = global || self, global.clientSideValidations = factory(global.$));
+}(this, function ($) { 'use strict';
 
-  validatorsFor = function(name, validators) {
-    var captures, validator, validator_name;
-    if (validators.hasOwnProperty(name)) {
-      return validators[name];
-    }
-    name = name.replace(/\[(\w+_attributes)\]\[[\da-z_]+\](?=\[(?:\w+_attributes)\])/g, '[$1][]');
-    if (captures = name.match(/\[(\w+_attributes)\].*\[(\w+)\]$/)) {
-      for (validator_name in validators) {
-        validator = validators[validator_name];
-        if (validator_name.match("\\[" + captures[1] + "\\].*\\[\\]\\[" + captures[2] + "\\]$")) {
-          name = name.replace(/\[[\da-z_]+\]\[(\w+)\]$/g, '[][$1]');
-        }
-      }
-    }
-    return validators[name] || {};
-  };
+  $ = $ && $.hasOwnProperty('default') ? $['default'] : $;
 
-  validateForm = function(form, validators) {
-    var valid;
-    form.trigger('form:validate:before.ClientSideValidations');
-    valid = true;
-    form.find(ClientSideValidations.selectors.validate_inputs).each(function() {
-      if (!$(this).isValid(validators)) {
-        valid = false;
-      }
-      return true;
-    });
-    if (valid) {
-      form.trigger('form:validate:pass.ClientSideValidations');
+  function _typeof(obj) {
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof = function (obj) {
+        return typeof obj;
+      };
     } else {
-      form.trigger('form:validate:fail.ClientSideValidations');
+      _typeof = function (obj) {
+        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+      };
     }
-    form.trigger('form:validate:after.ClientSideValidations');
-    return valid;
-  };
 
-  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, i, kind, len, message, ref, valid, validator;
-      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;
-          }
-        }
-      }
-      return valid;
-    };
-    if (element.attr('name').search(/\[([^\]]*?)\]$/) >= 0) {
-      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();
-  };
+    return _typeof(obj);
+  }
 
-  ClientSideValidations = {
+  var ClientSideValidations = {
     callbacks: {
       element: {
-        after: function(element, eventData) {},
-        before: function(element, eventData) {},
-        fail: function(element, message, addError, eventData) {
+        after: function after(element, eventData) {},
+        before: function before(element, eventData) {},
+        fail: function fail(element, message, addError, eventData) {
           return addError();
         },
-        pass: function(element, removeError, eventData) {
+        pass: function pass(element, removeError, eventData) {
           return removeError();
         }
       },
       form: {
-        after: function(form, eventData) {},
-        before: function(form, eventData) {},
-        fail: function(form, eventData) {},
-        pass: function(form, eventData) {}
+        after: function after(form, eventData) {},
+        before: function before(form, eventData) {},
+        fail: function fail(form, eventData) {},
+        pass: function pass(form, eventData) {}
       }
     },
-    enablers: {
-      form: function(form) {
-        var $form, binding, event, ref;
-        $form = $(form);
-        form.ClientSideValidations = {
-          settings: $form.data('clientSideValidations'),
-          addError: function(element, message) {
-            return ClientSideValidations.formBuilders[form.ClientSideValidations.settings.html_settings.type].add(element, form.ClientSideValidations.settings.html_settings, message);
-          },
-          removeError: function(element) {
-            return ClientSideValidations.formBuilders[form.ClientSideValidations.settings.html_settings.type].remove(element, form.ClientSideValidations.settings.html_settings);
-          }
-        };
-        ref = {
-          'submit.ClientSideValidations': function(eventData) {
-            if (!$form.isValid(form.ClientSideValidations.settings.validators)) {
+    eventsToBind: {
+      form: function form(_form, $form) {
+        return {
+          'submit.ClientSideValidations': function submitClientSideValidations(eventData) {
+            if (!$form.isValid(_form.ClientSideValidations.settings.validators)) {
               eventData.preventDefault();
               eventData.stopImmediatePropagation();
             }
           },
-          'ajax:beforeSend.ClientSideValidations': function(eventData) {
+          'ajax:beforeSend.ClientSideValidations': function ajaxBeforeSendClientSideValidations(eventData) {
             if (eventData.target === this) {
-              $form.isValid(form.ClientSideValidations.settings.validators);
+              $form.isValid(_form.ClientSideValidations.settings.validators);
             }
           },
-          'form:validate:after.ClientSideValidations': function(eventData) {
+          'form:validate:after.ClientSideValidations': function formValidateAfterClientSideValidations(eventData) {
             ClientSideValidations.callbacks.form.after($form, eventData);
           },
-          'form:validate:before.ClientSideValidations': function(eventData) {
+          'form:validate:before.ClientSideValidations': function formValidateBeforeClientSideValidations(eventData) {
             ClientSideValidations.callbacks.form.before($form, eventData);
           },
-          'form:validate:fail.ClientSideValidations': function(eventData) {
+          'form:validate:fail.ClientSideValidations': function formValidateFailClientSideValidations(eventData) {
             ClientSideValidations.callbacks.form.fail($form, eventData);
           },
-          'form:validate:pass.ClientSideValidations': function(eventData) {
+          'form:validate:pass.ClientSideValidations': function formValidatePassClientSideValidations(eventData) {
             ClientSideValidations.callbacks.form.pass($form, eventData);
           }
         };
-        for (event in ref) {
-          binding = ref[event];
-          $form.on(event, binding);
-        }
-        return $form.find(ClientSideValidations.selectors.inputs).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() {
+      input: function input(form) {
+        return {
+          'focusout.ClientSideValidations': function focusoutClientSideValidations() {
             $(this).isValid(form.ClientSideValidations.settings.validators);
           },
-          'change.ClientSideValidations': function() {
+          'change.ClientSideValidations': function changeClientSideValidations() {
             $(this).data('changed', true);
           },
-          'element:validate:after.ClientSideValidations': function(eventData) {
+          'element:validate:after.ClientSideValidations': function elementValidateAfterClientSideValidations(eventData) {
             ClientSideValidations.callbacks.element.after($(this), eventData);
           },
-          'element:validate:before.ClientSideValidations': function(eventData) {
+          'element:validate:before.ClientSideValidations': function elementValidateBeforeClientSideValidations(eventData) {
             ClientSideValidations.callbacks.element.before($(this), eventData);
           },
-          'element:validate:fail.ClientSideValidations': function(eventData, message) {
-            var element;
-            element = $(this);
-            ClientSideValidations.callbacks.element.fail(element, message, function() {
-              return form.ClientSideValidations.addError(element, message);
+          'element:validate:fail.ClientSideValidations': function elementValidateFailClientSideValidations(eventData, message) {
+            var $element = $(this);
+            ClientSideValidations.callbacks.element.fail($element, message, function () {
+              return form.ClientSideValidations.addError($element, message);
             }, eventData);
           },
-          'element:validate:pass.ClientSideValidations': function(eventData) {
-            var element;
-            element = $(this);
-            ClientSideValidations.callbacks.element.pass(element, function() {
-              return form.ClientSideValidations.removeError(element);
+          'element:validate:pass.ClientSideValidations': function elementValidatePassClientSideValidations(eventData) {
+            var $element = $(this);
+            ClientSideValidations.callbacks.element.pass($element, function () {
+              return form.ClientSideValidations.removeError($element);
             }, eventData);
           }
         };
-        for (event in ref) {
-          binding = ref[event];
-          $input.filter(':not(:radio):not([id$=_confirmation])').each(function() {
+      },
+      inputConfirmation: function inputConfirmation(element, form) {
+        return {
+          'focusout.ClientSideValidations': function focusoutClientSideValidations() {
+            element.data('changed', true).isValid(form.ClientSideValidations.settings.validators);
+          },
+          'keyup.ClientSideValidations': function keyupClientSideValidations() {
+            element.data('changed', true).isValid(form.ClientSideValidations.settings.validators);
+          }
+        };
+      }
+    },
+    enablers: {
+      form: function form(_form2) {
+        var $form = $(_form2);
+        _form2.ClientSideValidations = {
+          settings: $form.data('clientSideValidations'),
+          addError: function addError(element, message) {
+            return ClientSideValidations.formBuilders[_form2.ClientSideValidations.settings.html_settings.type].add(element, _form2.ClientSideValidations.settings.html_settings, message);
+          },
+          removeError: function removeError(element) {
+            return ClientSideValidations.formBuilders[_form2.ClientSideValidations.settings.html_settings.type].remove(element, _form2.ClientSideValidations.settings.html_settings);
+          }
+        };
+        var eventsToBind = ClientSideValidations.eventsToBind.form(_form2, $form);
+
+        for (var eventName in eventsToBind) {
+          var eventFunction = eventsToBind[eventName];
+          $form.on(eventName, eventFunction);
+        }
+
+        $form.find(ClientSideValidations.selectors.inputs).each(function () {
+          ClientSideValidations.enablers.input(this);
+        });
+      },
+      input: function input(_input) {
+        var $input = $(_input);
+        var form = _input.form;
+        var $form = $(form);
+        var eventsToBind = ClientSideValidations.eventsToBind.input(form);
+
+        for (var eventName in eventsToBind) {
+          var eventFunction = eventsToBind[eventName];
+          $input.filter(':not(:radio):not([id$=_confirmation])').each(function () {
             return $(this).attr('data-validate', true);
-          }).on(event, binding);
+          }).on(eventName, eventFunction);
         }
-        $input.filter(':checkbox').on('change.ClientSideValidations', function() {
+
+        $input.filter(':checkbox').on('change.ClientSideValidations', function () {
           $(this).isValid(form.ClientSideValidations.settings.validators);
         });
-        return $input.filter('[id$=_confirmation]').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() {
-                element.data('changed', true).isValid(form.ClientSideValidations.settings.validators);
-              },
-              'keyup.ClientSideValidations': function() {
-                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));
+        $input.filter('[id$=_confirmation]').each(function () {
+          var $element = $(this);
+          var $elementToConfirm = $form.find('#' + this.id.match(/(.+)_confirmation/)[1] + ':input');
+
+          if ($elementToConfirm.length) {
+            var _eventsToBind = ClientSideValidations.eventsToBind.inputConfirmation($elementToConfirm, form);
+
+            for (var _eventName in _eventsToBind) {
+              var _eventFunction = _eventsToBind[_eventName];
+              $('#' + $element.attr('id')).on(_eventName, _eventFunction);
             }
-            return results;
           }
         });
       }
     },
     formBuilders: {
       'ActionView::Helpers::FormBuilder': {
-        add: function(element, settings, message) {
-          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 = $(settings.input_tag);
-            labelErrorField = $(settings.label_tag);
-            label = form.find("label[for='" + (element.attr('id')) + "']:not(.message)");
+        add: function add(element, settings, message) {
+          var form = $(element[0].form);
+
+          if (element.data('valid') !== false && form.find("label.message[for='" + element.attr('id') + "']")[0] == null) {
+            var inputErrorField = $(settings.input_tag);
+            var labelErrorField = $(settings.label_tag);
+            var 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'));
@@ -288,20 +187,21 @@
             labelErrorField.insertAfter(label);
             labelErrorField.find('label#label_tag').replaceWith(label);
           }
-          return form.find("label.message[for='" + (element.attr('id')) + "']").text(message);
+
+          form.find("label.message[for='" + element.attr('id') + "']").text(message);
         },
-        remove: function(element, settings) {
-          var errorFieldClass, form, inputErrorField, label, labelErrorField;
-          form = $(element[0].form);
-          errorFieldClass = $(settings.input_tag).attr('class');
-          inputErrorField = element.closest("." + (errorFieldClass.replace(/\ /g, ".")));
-          label = form.find("label[for='" + (element.attr('id')) + "']:not(.message)");
-          labelErrorField = label.closest("." + errorFieldClass);
+        remove: function remove(element, settings) {
+          var form = $(element[0].form);
+          var errorFieldClass = $(settings.input_tag).attr('class');
+          var inputErrorField = element.closest('.' + errorFieldClass.replace(/ /g, '.'));
+          var label = form.find("label[for='" + element.attr('id') + "']:not(.message)");
+          var labelErrorField = label.closest('.' + errorFieldClass);
+
           if (inputErrorField[0]) {
-            inputErrorField.find("#" + (element.attr('id'))).detach();
+            inputErrorField.find('#' + element.attr('id')).detach();
             inputErrorField.replaceWith(element);
             label.detach();
-            return labelErrorField.replaceWith(label);
+            labelErrorField.replaceWith(label);
           }
         }
       }
@@ -318,285 +218,551 @@
       forms: 'form[data-client-side-validations]'
     },
     validators: {
-      all: function() {
-        return $.extend({}, local, remote);
-      },
-      local: {
-        absence: function(element, options) {
-          if (!/^\s*$/.test(element.val() || '')) {
-            return options.message;
-          }
-        },
-        presence: function(element, options) {
-          if (/^\s*$/.test(element.val() || '')) {
-            return options.message;
-          }
-        },
-        acceptance: function(element, options) {
-          var ref;
-          switch (element.attr('type')) {
-            case 'checkbox':
-              if (!element.prop('checked')) {
-                return options.message;
-              }
-              break;
-            case 'text':
-              if (element.val() !== (((ref = options.accept) != null ? ref.toString() : void 0) || '1')) {
-                return options.message;
-              }
-          }
-        },
-        format: function(element, options) {
-          var message;
-          message = this.presence(element, options);
-          if (message) {
-            if (options.allow_blank === true) {
-              return;
-            }
-            return message;
-          }
-          if (options["with"] && !new RegExp(options["with"].source, options["with"].options).test(element.val())) {
-            return options.message;
-          }
-          if (options.without && new RegExp(options.without.source, options.without.options).test(element.val())) {
-            return options.message;
-          }
-        },
-        numericality: function(element, options) {
-          var $form, NUMERICALITY_CHECKS, check, checkValue, check_function, number_format, val;
-          if (options.allow_blank === true && this.presence(element, {
-            message: options.messages.numericality
-          })) {
-            return;
-          }
-          $form = $(element[0].form);
-          number_format = $form[0].ClientSideValidations.settings.number_format;
-          val = $.trim(element.val()).replace(new RegExp("\\" + number_format.separator, 'g'), '.');
-          if (options.only_integer && !ClientSideValidations.patterns.numericality.only_integer.test(val)) {
-            return options.messages.only_integer;
-          }
-          if (!ClientSideValidations.patterns.numericality["default"].test(val)) {
-            return options.messages.numericality;
-          }
-          NUMERICALITY_CHECKS = {
-            greater_than: function(a, b) {
-              return a > b;
-            },
-            greater_than_or_equal_to: function(a, b) {
-              return a >= b;
-            },
-            equal_to: function(a, b) {
-              return a === b;
-            },
-            less_than: function(a, b) {
-              return a < b;
-            },
-            less_than_or_equal_to: function(a, b) {
-              return a <= b;
-            }
-          };
-          for (check in NUMERICALITY_CHECKS) {
-            check_function = NUMERICALITY_CHECKS[check];
-            if (!(options[check] != null)) {
-              continue;
-            }
-            checkValue = !isNaN(parseFloat(options[check])) && isFinite(options[check]) ? options[check] : $form.find("[name*=" + options[check] + "]").length === 1 ? $form.find("[name*=" + options[check] + "]").val() : void 0;
-            if ((checkValue == null) || checkValue === '') {
-              return;
-            }
-            if (!check_function(parseFloat(val), parseFloat(checkValue))) {
-              return options.messages[check];
-            }
-          }
-          if (options.odd && !(parseInt(val, 10) % 2)) {
-            return options.messages.odd;
-          }
-          if (options.even && (parseInt(val, 10) % 2)) {
-            return options.messages.even;
-          }
-        },
-        length: function(element, options) {
-          var LENGTH_CHECKS, blankOptions, check, check_function, length, message;
-          length = element.val().length;
-          LENGTH_CHECKS = {
-            is: function(a, b) {
-              return a === b;
-            },
-            minimum: function(a, b) {
-              return a >= b;
-            },
-            maximum: function(a, b) {
-              return a <= b;
-            }
-          };
-          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;
-          }
-          for (check in LENGTH_CHECKS) {
-            check_function = LENGTH_CHECKS[check];
-            if (options[check]) {
-              if (!check_function(length, parseInt(options[check]))) {
-                return options.messages[check];
-              }
-            }
-          }
-        },
-        exclusion: function(element, options) {
-          var lower, message, option, ref, upper;
-          message = this.presence(element, options);
-          if (message) {
-            if (options.allow_blank === true) {
-              return;
-            }
-            return 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) {
-          var lower, message, option, ref, upper;
-          message = this.presence(element, options);
-          if (message) {
-            if (options.allow_blank === true) {
-              return;
-            }
-            return 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) {
-          var confirmation_value, value;
-          value = element.val();
-          confirmation_value = $("#" + (element.attr('id')) + "_confirmation").val();
-          if (!options.case_sensitive) {
-            value = value.toLowerCase();
-            confirmation_value = confirmation_value.toLowerCase();
-          }
-          if (value !== confirmation_value) {
-            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() {
-                var other_value;
-                other_value = $(this).val();
-                if (!options.case_sensitive) {
-                  value = value.toLowerCase();
-                  other_value = other_value.toLowerCase();
-                }
-                if ($(this).attr('name') !== name) {
-                  if (other_value === 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;
-              }
-            }
-          }
-        }
+      all: function all() {
+        return $.extend({});
       },
+      local: {},
       remote: {}
     },
-    disable: function(target) {
-      var $target;
-      $target = $(target);
+    disable: function disable(target) {
+      var $target = $(target);
       $target.off('.ClientSideValidations');
+
       if ($target.is('form')) {
-        return ClientSideValidations.disable($target.find(':input'));
+        ClientSideValidations.disable($target.find(':input'));
       } else {
-        $target.removeData('valid');
-        $target.removeData('changed');
-        return $target.filter(':input').each(function() {
-          return $(this).removeAttr('data-validate');
+        $target.removeData(['changed', 'valid']);
+        $target.filter(':input').each(function () {
+          $(this).removeAttr('data-validate');
         });
       }
     },
-    reset: function(form) {
-      var $form, key;
-      $form = $(form);
+    reset: function reset(form) {
+      var $form = $(form);
       ClientSideValidations.disable(form);
-      for (key in form.ClientSideValidations.settings.validators) {
+
+      for (var key in form.ClientSideValidations.settings.validators) {
         form.ClientSideValidations.removeError($form.find("[name='" + key + "']"));
       }
-      return ClientSideValidations.enablers.form(form);
+
+      ClientSideValidations.enablers.form(form);
+    },
+    start: function start() {
+      if (window.Turbolinks != null && window.Turbolinks.supported) {
+        var initializeOnEvent = window.Turbolinks.EVENTS != null ? 'page:change' : 'turbolinks:load';
+        $(document).on(initializeOnEvent, function () {
+          return $(ClientSideValidations.selectors.forms).validate();
+        });
+      } else {
+        $(function () {
+          return $(ClientSideValidations.selectors.forms).validate();
+        });
+      }
+    }
+  };
+
+  var arrayHasValue = function arrayHasValue(value, otherValues) {
+    for (var i = 0, l = otherValues.length; i < l; i++) {
+      if (value === otherValues[i]) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+  var valueIsPresent = function valueIsPresent(value) {
+    return !/^\s*$/.test(value || '');
+  };
+
+  var absenceLocalValidator = function absenceLocalValidator(element, options) {
+    if (valueIsPresent(element.val())) {
+      return options.message;
+    }
+  };
+  var presenceLocalValidator = function presenceLocalValidator(element, options) {
+    if (!valueIsPresent(element.val())) {
+      return options.message;
+    }
+  };
+
+  var DEFAULT_ACCEPT_OPTION = ['1', true];
+  Array.isArray || (Array.isArray = function (a) {
+    var object = {};
+    return '' + a !== a && object.toString.call(a) === '[object Array]';
+  });
+
+  var isTextAccepted = function isTextAccepted(value, acceptOption) {
+    if (!acceptOption) {
+      acceptOption = DEFAULT_ACCEPT_OPTION;
+    }
+
+    if (Array.isArray(acceptOption)) {
+      return arrayHasValue(value, acceptOption);
+    }
+
+    return value === acceptOption;
+  };
+
+  var acceptanceLocalValidator = function acceptanceLocalValidator(element, options) {
+    var valid = true;
+
+    if (element.attr('type') === 'checkbox') {
+      valid = element.prop('checked');
+    }
+
+    if (element.attr('type') === 'text') {
+      valid = isTextAccepted(element.val(), options.accept);
+    }
+
+    if (!valid) {
+      return options.message;
+    }
+  };
+
+  var isMatching = function isMatching(value, regExpOptions) {
+    return new RegExp(regExpOptions.source, regExpOptions.options).test(value);
+  };
+
+  var hasValidFormat = function hasValidFormat(value, withOptions, withoutOptions) {
+    return withOptions && isMatching(value, withOptions) || withoutOptions && !isMatching(value, withoutOptions);
+  };
+
+  var formatLocalValidator = function formatLocalValidator(element, options) {
+    var value = element.val();
+
+    if (options.allow_blank && !valueIsPresent(value)) {
+      return;
+    }
+
+    if (!hasValidFormat(value, options["with"], options.without)) {
+      return options.message;
+    }
+  };
+
+  var VALIDATIONS = {
+    even: function even(a) {
+      return parseInt(a, 10) % 2 === 0;
+    },
+    greater_than: function greater_than(a, b) {
+      return parseFloat(a) > parseFloat(b);
+    },
+    greater_than_or_equal_to: function greater_than_or_equal_to(a, b) {
+      return parseFloat(a) >= parseFloat(b);
+    },
+    equal_to: function equal_to(a, b) {
+      return parseFloat(a) === parseFloat(b);
+    },
+    less_than: function less_than(a, b) {
+      return parseFloat(a) < parseFloat(b);
+    },
+    less_than_or_equal_to: function less_than_or_equal_to(a, b) {
+      return parseFloat(a) <= parseFloat(b);
+    },
+    odd: function odd(a) {
+      return parseInt(a, 10) % 2 === 1;
+    }
+  };
+
+  var getOtherValue = function getOtherValue(validationOption, $form) {
+    if (!isNaN(parseFloat(validationOption))) {
+      return validationOption;
+    }
+
+    var validationElement = $form.find('[name*=' + validationOption + ']');
+
+    if (validationElement.length === 1) {
+      var numberFormat = $form[0].ClientSideValidations.settings.number_format;
+      var otherFormattedValue = $.trim(validationElement.val()).replace(new RegExp('\\' + numberFormat.separator, 'g'), '.');
+
+      if (!isNaN(parseFloat(otherFormattedValue))) {
+        return otherFormattedValue;
+      }
+    }
+  };
+
+  var isValid = function isValid(validationFunction, validationOption, formattedValue, $form) {
+    if (validationFunction.length === 2) {
+      var otherValue = getOtherValue(validationOption, $form);
+      return otherValue == null || otherValue === '' || validationFunction(formattedValue, otherValue);
+    } else {
+      return validationFunction(formattedValue);
+    }
+  };
+
+  var runFunctionValidations = function runFunctionValidations(formattedValue, $form, options) {
+    for (var validation in VALIDATIONS) {
+      var validationOption = options[validation];
+      var validationFunction = VALIDATIONS[validation]; // Must check for null because this could be 0
+
+      if (validationOption == null) {
+        continue;
+      }
+
+      if (!isValid(validationFunction, validationOption, formattedValue, $form)) {
+        return options.messages[validation];
+      }
+    }
+  };
+
+  var runValidations = function runValidations(formattedValue, $form, options) {
+    if (options.only_integer && !ClientSideValidations.patterns.numericality.only_integer.test(formattedValue)) {
+      return options.messages.only_integer;
+    }
+
+    if (!ClientSideValidations.patterns.numericality["default"].test(formattedValue)) {
+      return options.messages.numericality;
+    }
+
+    return runFunctionValidations(formattedValue, $form, options);
+  };
+
+  var numericalityLocalValidator = function numericalityLocalValidator(element, options) {
+    var value = element.val();
+
+    if (options.allow_blank && !valueIsPresent(value)) {
+      return;
+    }
+
+    var $form = $(element[0].form);
+    var numberFormat = $form[0].ClientSideValidations.settings.number_format;
+    var formattedValue = $.trim(value).replace(new RegExp('\\' + numberFormat.separator, 'g'), '.');
+    return runValidations(formattedValue, $form, options);
+  };
+
+  var VALIDATIONS$1 = {
+    is: function is(a, b) {
+      return a === parseInt(b, 10);
+    },
+    minimum: function minimum(a, b) {
+      return a >= parseInt(b, 10);
+    },
+    maximum: function maximum(a, b) {
+      return a <= parseInt(b, 10);
+    }
+  };
+
+  var runValidations$1 = function runValidations(valueLength, options) {
+    for (var validation in VALIDATIONS$1) {
+      var validationOption = options[validation];
+      var validationFunction = VALIDATIONS$1[validation];
+
+      if (validationOption && !validationFunction(valueLength, validationOption)) {
+        return options.messages[validation];
+      }
+    }
+  };
+
+  var lengthLocalValidator = function lengthLocalValidator(element, options) {
+    var value = element.val();
+
+    if (options.allow_blank && !valueIsPresent(value)) {
+      return;
+    }
+
+    return runValidations$1(value.length, options);
+  };
+
+  var isInList = function isInList(value, otherValues) {
+    var normalizedOtherValues = [];
+
+    for (var otherValueIndex in otherValues) {
+      normalizedOtherValues.push(otherValues[otherValueIndex].toString());
+    }
+
+    return arrayHasValue(value, normalizedOtherValues);
+  };
+
+  var isInRange = function isInRange(value, range) {
+    return value >= range[0] && value <= range[1];
+  };
+
+  var isIncluded = function isIncluded(value, options, allowBlank) {
+    if ((options.allow_blank && !valueIsPresent(value)) === allowBlank) {
+      return true;
+    }
+
+    return options["in"] && isInList(value, options["in"]) || options.range && isInRange(value, options.range);
+  };
+
+  var exclusionLocalValidator = function exclusionLocalValidator(element, options) {
+    var value = element.val();
+
+    if (isIncluded(value, options, false) || !options.allow_blank && !valueIsPresent(value)) {
+      return options.message;
+    }
+  };
+  var inclusionLocalValidator = function inclusionLocalValidator(element, options) {
+    if (!isIncluded(element.val(), options, true)) {
+      return options.message;
+    }
+  };
+
+  var confirmationLocalValidator = function confirmationLocalValidator(element, options) {
+    var value = element.val();
+    var confirmationValue = $('#' + element.attr('id') + '_confirmation').val();
+
+    if (!options.case_sensitive) {
+      value = value.toLowerCase();
+      confirmationValue = confirmationValue.toLowerCase();
+    }
+
+    if (value !== confirmationValue) {
+      return options.message;
+    }
+  };
+
+  var isLocallyUnique = function isLocallyUnique(currentElement, value, otherValue, caseSensitive) {
+    if (!caseSensitive) {
+      value = value.toLowerCase();
+      otherValue = otherValue.toLowerCase();
+    }
+
+    if (otherValue === value) {
+      $(currentElement).data('notLocallyUnique', true);
+      return false;
+    }
+
+    if ($(currentElement).data('notLocallyUnique')) {
+      $(currentElement).removeData('notLocallyUnique').data('changed', true);
+    }
+
+    return true;
+  };
+
+  var uniquenessLocalValidator = function uniquenessLocalValidator(element, options) {
+    var elementName = element.attr('name');
+    var matches = elementName.match(/^(.+_attributes\])\[\d+\](.+)$/);
+
+    if (!matches) {
+      return;
+    }
+
+    var form = element.closest('form');
+    var value = element.val();
+    var valid = true;
+    form.find(':input[name^="' + matches[1] + '"][name$="' + matches[2] + '"]').not(element).each(function () {
+      var otherValue = $(this).val();
+
+      if (!isLocallyUnique(this, value, otherValue, options.case_sensitive)) {
+        valid = false;
+      }
+    });
+
+    if (!valid) {
+      return options.message;
+    }
+  };
+
+  ClientSideValidations.validators.local = {
+    absence: absenceLocalValidator,
+    presence: presenceLocalValidator,
+    acceptance: acceptanceLocalValidator,
+    format: formatLocalValidator,
+    numericality: numericalityLocalValidator,
+    length: lengthLocalValidator,
+    inclusion: inclusionLocalValidator,
+    exclusion: exclusionLocalValidator,
+    confirmation: confirmationLocalValidator,
+    uniqueness: uniquenessLocalValidator
+  };
+
+  $.fn.disableClientSideValidations = function () {
+    ClientSideValidations.disable(this);
+    return this;
+  };
+
+  $.fn.enableClientSideValidations = function () {
+    var _this = this;
+
+    var selectors = {
+      forms: 'form',
+      inputs: 'input'
+    };
+
+    var _loop = function _loop() {
+      var enablers = selectors[selector];
+
+      _this.filter(ClientSideValidations.selectors[selector]).each(function () {
+        return ClientSideValidations.enablers[enablers](this);
+      });
+    };
+
+    for (var selector in selectors) {
+      _loop();
     }
+
+    return this;
   };
 
-  if ((window.Turbolinks != null) && window.Turbolinks.supported) {
-    initializeOnEvent = window.Turbolinks.EVENTS != null ? 'page:change' : 'turbolinks:load';
-    $(document).on(initializeOnEvent, function() {
-      return $(ClientSideValidations.selectors.forms).validate();
+  $.fn.resetClientSideValidations = function () {
+    this.filter(ClientSideValidations.selectors.forms).each(function () {
+      return ClientSideValidations.reset(this);
     });
-  } else {
-    $(function() {
-      return $(ClientSideValidations.selectors.forms).validate();
+    return this;
+  };
+
+  $.fn.validate = function () {
+    this.filter(ClientSideValidations.selectors.forms).each(function () {
+      return $(this).enableClientSideValidations();
+    });
+    return this;
+  };
+
+  $.fn.isValid = function (validators) {
+    var obj = $(this[0]);
+
+    if (obj.is('form')) {
+      return validateForm(obj, validators);
+    } else {
+      return validateElement(obj, validatorsFor(this[0].name, validators));
+    }
+  };
+
+  var cleanNestedElementName = function cleanNestedElementName(elementName, nestedMatches, validators) {
+    for (var validatorName in validators) {
+      if (validatorName.match('\\[' + nestedMatches[1] + '\\].*\\[\\]\\[' + nestedMatches[2] + '\\]$')) {
+        elementName = elementName.replace(/\[[\da-z_]+\]\[(\w+)\]$/g, '[][$1]');
+      }
+    }
+
+    return elementName;
+  };
+
+  var cleanElementName = function cleanElementName(elementName, validators) {
+    elementName = elementName.replace(/\[(\w+_attributes)\]\[[\da-z_]+\](?=\[(?:\w+_attributes)\])/g, '[$1][]');
+    var nestedMatches = elementName.match(/\[(\w+_attributes)\].*\[(\w+)\]$/);
+
+    if (nestedMatches) {
+      elementName = cleanNestedElementName(elementName, nestedMatches, validators);
+    }
+
+    return elementName;
+  };
+
+  var validatorsFor = function validatorsFor(elementName, validators) {
+    if (Object.prototype.isPrototypeOf.call(validators, elementName)) {
+      return validators[elementName];
+    }
+
+    return validators[cleanElementName(elementName, validators)] || {};
+  };
+
+  var validateForm = function validateForm(form, validators) {
+    var valid = true;
+    form.trigger('form:validate:before.ClientSideValidations');
+    form.find(ClientSideValidations.selectors.validate_inputs).each(function () {
+      if (!$(this).isValid(validators)) {
+        valid = false;
+      }
+
+      return true;
     });
+
+    if (valid) {
+      form.trigger('form:validate:pass.ClientSideValidations');
+    } else {
+      form.trigger('form:validate:fail.ClientSideValidations');
+    }
+
+    form.trigger('form:validate:after.ClientSideValidations');
+    return valid;
+  };
+
+  var passElement = function passElement(element) {
+    element.trigger('element:validate:pass.ClientSideValidations').data('valid', null);
+  };
+
+  var failElement = function failElement(element, message) {
+    element.trigger('element:validate:fail.ClientSideValidations', message).data('valid', false);
+  };
+
+  var afterValidate = function afterValidate(element) {
+    return element.trigger('element:validate:after.ClientSideValidations').data('valid') !== false;
+  };
+
+  var executeValidator = function executeValidator(validatorFunctions, validatorFunction, validatorOptions, element) {
+    for (var validatorOption in validatorOptions) {
+      var message = validatorFunction.call(validatorFunctions, element, validatorOptions[validatorOption]);
+
+      if (message) {
+        failElement(element, message);
+        return false;
+      }
+    }
+
+    return true;
+  };
+
+  var executeValidators = function executeValidators(validatorFunctions, element, validators) {
+    for (var validator in validators) {
+      var validatorFunction = validatorFunctions[validator];
+
+      if (!validatorFunction) {
+        continue;
+      }
+
+      if (!executeValidator(validatorFunctions, validatorFunction, validators[validator], element)) {
+        return false;
+      }
+    }
+
+    return true;
+  };
+
+  var isMarkedForDestroy = function isMarkedForDestroy(element) {
+    if (element.attr('name').search(/\[([^\]]*?)\]$/) >= 0) {
+      var destroyInputName = element.attr('name').replace(/\[([^\]]*?)\]$/, '[_destroy]');
+
+      if ($("input[name='" + destroyInputName + "']").val() === '1') {
+        return true;
+      }
+    }
+
+    return false;
+  };
+
+  var executeAllValidators = function executeAllValidators(element, validators) {
+    if (element.data('changed') !== false) {
+      element.data('changed', false);
+
+      if (executeValidators(ClientSideValidations.validators.local, element, validators) && executeValidators(ClientSideValidations.validators.remote, element, validators)) {
+        passElement(element);
+      }
+    }
+  };
+
+  var validateElement = function validateElement(element, validators) {
+    element.trigger('element:validate:before.ClientSideValidations');
+
+    if (isMarkedForDestroy(element)) {
+      passElement(element);
+    } else {
+      executeAllValidators(element, validators);
+    }
+
+    return afterValidate(element);
+  };
+
+  if (!window.ClientSideValidations) {
+    window.ClientSideValidations = ClientSideValidations;
+
+    if (!isAMD() && !isCommonJS()) {
+      ClientSideValidations.start();
+    }
   }
 
-  window.ClientSideValidations = ClientSideValidations;
+  function isAMD() {
+    return typeof define === 'function' && define.amd; // eslint-disable-line no-undef
+  }
+
+  function isCommonJS() {
+    return (typeof exports === "undefined" ? "undefined" : _typeof(exports)) === 'object' && typeof module !== 'undefined'; // eslint-disable-line no-undef
+  }
+
+  var main = {
+    ClientSideValidations: ClientSideValidations
+  };
+
+  return main;
 
-}).call(this);
+}));