client_side_validations 3.1.5 → 3.2.0.beta.1

data/client_side_validations.gemspec

@@ -13,19 +13,11 @@ Gem::Specification.new do |s|
   s.description = %q{Client Side Validations}
 
   s.files         = `git ls-files -- {lib/*,vendor/*,*.gemspec}`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency 'rails', '~> 3.1.0'
+  s.add_development_dependency 'rails', '~> 3.2.0'
   s.add_development_dependency 'sqlite3'
-  s.add_development_dependency 'bson_ext'
-  s.add_development_dependency 'mongoid', '~> 2.4.0'
-  s.add_development_dependency 'mongo_mapper','~> 0.9.0'
   s.add_development_dependency 'mocha'
-  s.add_development_dependency 'simple_form', '~> 1.5.0'
-  s.add_development_dependency 'formtastic', '~> 2.0.0'
-  s.add_development_dependency 'm'
 
   # For QUnit testing
   s.add_development_dependency 'sinatra', '~> 1.0'

data/lib/client_side_validations.rb

@@ -1,10 +1,14 @@
 module ClientSideValidations
+  module Config
+    class << self
+      attr_accessor :uniqueness_validator_disabled
+      @uniqueness_validator_disabled = false
+    end
+  end
 end
 
 require 'client_side_validations/active_model'  if defined?(::ActiveModel)
 require 'client_side_validations/active_record' if defined?(::ActiveRecord)
-require 'client_side_validations/mongoid'       if defined?(::Mongoid)
-require 'client_side_validations/mongo_mapper'  if defined?(::MongoMapper)
 require 'client_side_validations/action_view'   if defined?(::ActionView)
 if defined?(::Rails)
   require 'client_side_validations/middleware'

data/lib/client_side_validations/action_view/form_builder.rb

@@ -72,7 +72,7 @@ module ClientSideValidations::ActionView::Helpers
 
     def time_zone_select_with_client_side_validations(method, priority_zones = nil, options = {}, html_options = {})
       apply_client_side_validators(method, html_options)
-      time_zone_select_without_client_side_validations(method, priority_zones, options, html_options)
+      time_zone_select_without_client_side_validations(method, priority_zones = nil, options, html_options)
     end
 
   private
@@ -80,7 +80,9 @@ module ClientSideValidations::ActionView::Helpers
     def apply_client_side_validators(method, options = {})
       if @options[:validate] && options[:validate] != false && validators = filter_validators(method, options[:validate])
         options.merge!("data-validate" => true)
-        @options[:validators].merge!("#{@object_name}[#{method}]#{options[:multiple] ? "[]" : nil}" => validators)
+        name = options[:name] || "#{@object_name}[#{method}]"
+
+        @options[:validators].merge!("#{name}#{options[:multiple] ? "[]" : nil}" => validators)
       end
     end
 

data/lib/client_side_validations/action_view/form_helper.rb

@@ -6,8 +6,6 @@ module ClientSideValidations::ActionView::Helpers
       options = args.extract_options!
       if options[:validate]
 
-        content_for_name = options[:validate] unless options[:validate] == true
-
         # Always turn off HTML5 Validations
         options[:html] ||= {}
         options[:html][:novalidate] = 'novalidate'
@@ -23,17 +21,27 @@ module ClientSideValidations::ActionView::Helpers
       end
 
       @validators = {}
+
       # Order matters here. Rails mutates the options object
       script = client_side_form_settings(object, options)
       form   = super(record_or_name_or_array, *(args << options), &proc)
+
       # Because of the load order requirement above this sub is necessary
       # Would be nice to not do this
       script = insert_validators_into_script(script)
-      if content_for_name
-        content_for(content_for_name) { script.html_safe }
-        script = nil
+
+      if assign_script_to_content_for(options[:validate], script)
+        form.html_safe
+      else
+        "#{form}#{script}".html_safe
+      end
+    end
+
+    def assign_script_to_content_for(name, script)
+      if name && name != true
+        content_for(name) { script.html_safe }
+        true
       end
-      "#{form}#{script}".html_safe
     end
 
     def apply_form_for_options!(object_or_array, options)
@@ -75,7 +83,7 @@ module ClientSideValidations::ActionView::Helpers
         end
 
         content_tag(:script) do
-          "window['#{var_name}'] = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};".html_safe
+          "window.ClientSideValidations.forms['#{var_name}'] = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};".html_safe
         end
 
       end

data/lib/client_side_validations/active_model.rb

@@ -5,7 +5,6 @@ module ClientSideValidations::ActiveModel
 
     def client_side_hash(model, attribute)
       options = self.options.dup
-      # debugger
       { :message => model.errors.generate_message(attribute, message_type, options) }.merge(options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:allow_blank, :if, :unless]))
     end
 
@@ -24,7 +23,7 @@ module ClientSideValidations::ActiveModel
           validator_hash = attr[1].inject({}) do |kind_hash, validator|
             client_side_hash = validator.client_side_hash(self, attr[0])
             # Yeah yeah, #new_record? is not part of ActiveModel :p
-            if (can_use_for_client_side_validation?(client_side_hash, validator))
+            if can_use_for_client_side_validation?(client_side_hash, validator) && uniqueness_validations_allowed_or_not_applicable?(validator)
               kind_hash.merge!(validator.kind => client_side_hash.except(:on))
             else
               kind_hash.merge!({})
@@ -47,6 +46,10 @@ module ClientSideValidations::ActiveModel
     def can_use_for_client_side_validation?(client_side_hash, validator)
       ((self.respond_to?(:new_record?) && validator.options[:on] == (self.new_record? ? :create : :update)) || validator.options[:on].nil?) && validator.kind != :block
     end
+
+    def uniqueness_validations_allowed_or_not_applicable?(validator)
+      validator.kind != :uniqueness || !ClientSideValidations::Config.uniqueness_validator_disabled
+    end
   end
 end
 

data/lib/client_side_validations/active_record.rb

@@ -1,4 +1,5 @@
 require 'client_side_validations/active_model'
+require 'client_side_validations/middleware'
 require 'client_side_validations/active_record/middleware'
 
 %w{uniqueness}.each do |validator|
@@ -8,4 +9,4 @@ require 'client_side_validations/active_record/middleware'
 end
 
 ActiveRecord::Base.send(:include, ClientSideValidations::ActiveModel::Validations)
-
+ClientSideValidations::Middleware::Uniqueness.register_orm(ClientSideValidations::ActiveRecord::Middleware)

data/lib/client_side_validations/active_record/middleware.rb

@@ -1,7 +1,12 @@
 module ClientSideValidations::ActiveRecord
   class Middleware
 
+    def self.is_class?(klass)
+      klass < ::ActiveRecord::Base
+    end
+
     def self.is_unique?(klass, attribute, value, params)
+      value = type_cast_value(klass, attribute, value)
       column = klass.columns_hash[attribute.to_s]
       value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if column.text?
 
@@ -23,11 +28,19 @@ module ClientSideValidations::ActiveRecord
         relation = relation.and(t.primary_key.not_eq(params[:id])) if params[:id]
       end
 
-      (params[:scope] || {}).each do |key, value|
-        relation = relation.and(t[key].eq(value))
+      (params[:scope] || {}).each do |attribute, value|
+        value    = type_cast_value(klass, attribute, value)
+        relation = relation.and(t[attribute].eq(value))
       end
 
       !klass.where(relation).exists?
     end
+
+    private
+
+    def self.type_cast_value(klass, attribute, value)
+      klass.columns_hash[attribute].type_cast(value)
+    end
+
   end
 end

data/lib/client_side_validations/active_record/uniqueness.rb

@@ -4,7 +4,6 @@ module ClientSideValidations::ActiveRecord
       hash = {}
       hash[:message] = model.errors.generate_message(attribute, message_type, options.except(:scope))
       hash[:case_sensitive] = options[:case_sensitive]
-      hash[:allow_blank] = options[:allow_blank] if options.key?(:allow_blank)
       hash[:id] = model.id unless model.new_record?
       if options.key?(:scope) && options[:scope].present?
         hash[:scope] = Array.wrap(options[:scope]).inject({}) do |scope_hash, scope_item|

data/lib/client_side_validations/core_ext/regexp.rb

@@ -1,6 +1,6 @@
 class Regexp
   def as_json(options = nil)
-    Regexp.new inspect.sub("\\A","^").sub("\\Z","$").sub("\\z","$").sub(/^\//,"").sub(/\/[a-z]*$/,""), self.options
+    Regexp.new inspect.sub('\\A','^').sub('\\Z','$').sub('\\z','$').sub(/^\//,'').sub(/\/[a-z]*$/,'').gsub(/\(\?#.+\)/, '').gsub(/\(\?-\w+:/,'('), self.options
   end
 
   def to_json(options = nil)

data/lib/client_side_validations/middleware.rb

@@ -11,11 +11,11 @@ module ClientSideValidations
       end
 
       def call(env)
-        case env['PATH_INFO']
-        when %r{\/validators\/(\w+)}
-          "::ClientSideValidations::Middleware::#{$1.camelize}".constantize.new(env).response
-        else
+        matches = /^\/validators\/(\w+)$/.match(env['PATH_INFO'])
+        if !matches || (matches[1] == 'uniqueness' && Config.uniqueness_validator_disabled)
           @app.call(env)
+        else
+          "::ClientSideValidations::Middleware::#{matches[1].camelize}".constantize.new(env).response
         end
       end
     end
@@ -40,6 +40,7 @@ module ClientSideValidations
 
     class Uniqueness < Base
       IGNORE_PARAMS = %w{case_sensitive id scope}
+      REGISTERED_ORMS = []
 
       def response
         if is_unique?
@@ -52,23 +53,46 @@ module ClientSideValidations
         super
       end
 
+      def self.register_orm(orm)
+        registered_orms << orm
+      end
+
+      def self.registered_orms
+        REGISTERED_ORMS
+      end
+
+      def registered_orms
+        self.class.registered_orms
+      end
+
       private
 
       def is_unique?
-        resource = extract_resource
-        klass = resource.classify.constantize
-        attribute = request.params[resource].keys.first
-        value = request.params[resource][attribute]
-
-        if (defined?(::ActiveRecord::Base) && klass < ::ActiveRecord::Base)
-          middleware_klass = ClientSideValidations::ActiveRecord::Middleware
-        elsif (defined?(::Mongoid::Document) && klass.included_modules.include?(::Mongoid::Document))
-          middleware_klass = ClientSideValidations::Mongoid::Middleware
-        elsif (defined?(::MongoMapper::Document) && klass.included_modules.include?(::MongoMapper::Document))
-          middleware_klass = ClientSideValidations::MongoMapper::Middleware
+        convert_scope_value_from_null_to_nil
+        resource         = extract_resource
+        klass            = resource.classify.constantize
+        attribute        = request.params[resource].keys.first
+        value            = request.params[resource][attribute]
+        middleware_class = nil
+
+        registered_orms.each do |orm|
+          if orm.is_class?(klass)
+            middleware_class = orm
+            break
+          end
         end
 
-        middleware_klass.is_unique?(klass, attribute, value, request.params)
+        middleware_class.is_unique?(klass, attribute, value, request.params)
+      end
+
+      def convert_scope_value_from_null_to_nil
+        if request.params['scope']
+          request.params['scope'].each do |key, value|
+            if value == 'null'
+              request.params['scope'][key] = nil
+            end
+          end
+        end
       end
 
       def extract_resource

data/lib/client_side_validations/version.rb

@@ -1,3 +1,3 @@
 module ClientSideValidations
-  VERSION = '3.1.5'
+  VERSION = '3.2.0.beta.1'
 end

data/lib/generators/templates/client_side_validations/initializer.rb

@@ -1,8 +1,5 @@
 # ClientSideValidations Initializer
 
-require 'client_side_validations/simple_form' if defined?(::SimpleForm)
-require 'client_side_validations/formtastic'  if defined?(::Formtastic)
-
 # Uncomment the following block if you want each input field to have the validation messages attached.
 # ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
 #   unless html_tag =~ /^<label/

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

@@ -1,5 +1,5 @@
 /*!
- * Rails 3 Client Side Validations - v3.1.4
+ * Rails 3 Client Side Validations - v3.2.0.beta.1
  * https://github.com/bcardarella/client_side_validations
  *
  * Copyright (c) 2011 Brian Cardarella
@@ -7,80 +7,79 @@
  * http://www.opensource.org/licenses/mit-license.php
  */
 
-(function($) {
-  $.fn.validate = function() {
-    return this.filter('form[data-validate]').each(function() {
-      var form = $(this);
-      var settings = window[form.attr('id')];
+(function ($) {
+  $.fn.validate = function () {
+    return this.filter('form[data-validate]').each(function () {
+      var form = $(this),
+          settings = window['ClientSideValidations']['forms'][form.attr('id')],
+          addError = function (element, message) {
+            ClientSideValidations.formBuilders[settings.type].add(element, settings, message);
+          },
+          removeError = function (element) {
+            ClientSideValidations.formBuilders[settings.type].remove(element, settings);
+          };
 
       // Set up the events for the form
       form
-        .submit(                      function()          { return form.isValid(settings.validators); })
-        .bind('ajax:beforeSend',      function(eventData) { if(eventData.target == this) return form.isValid(settings.validators); })
+        .submit(                      function ()          { return form.isValid(settings.validators); })
+        .bind('ajax:beforeSend',      function (eventData) { if(eventData.target == this) 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); })
+        .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); } )
 
         // 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); })
+        .find('[data-validate="true"]:input:enabled: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) {
+          .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() {
+            ClientSideValidations.callbacks.element.fail(element, message, function () {
               addError(element, message);
-            }, eventData) })
-          .live('element:validate:pass',   function(eventData) {
+            }, eventData); })
+          .live('element:validate:pass',   function (eventData) {
             var element = $(this);
-            clientSideValidations.callbacks.element.pass(element, function() {
+            ClientSideValidations.callbacks.element.pass(element, function () {
               removeError(element);
-            }, eventData) })
+            }, eventData); })
         // Checkboxes - Live events don't support filter
-        .end().find('[data-validate]:checkbox')
-          .live('click', function() { $(this).isValid(settings.validators); })
+        .end().find('[data-validate="true"]:checkbox')
+          .live('click', function () { $(this).isValid(settings.validators); })
         // Inputs for confirmations
-        .end().find('[id*=_confirmation]').each(function() {
+        .end().find('[id*=_confirmation]').each(function () {
           var confirmationElement = $(this),
-              element = form.find('#' + this.id.match(/(.+)_confirmation/)[1] + '[data-validate]:input');
+              element = form.find('#' + this.id.match(/(.+)_confirmation/)[1] + '[data-validate="true"]:input');
 
           if (element[0]) {
             $('#' + confirmationElement.attr('id'))
-              .live('focusout', function() {
+              .live('focusout', function () {
                 element.data('changed', true).isValid(settings.validators);
               })
-              .live('keyup', function() {
+              .live('keyup', function () {
                 element.data('changed', true).isValid(settings.validators);
-              })
+              });
           }
         });
 
-      var addError = function(element, message) {
-        clientSideValidations.formBuilders[settings.type].add(element, settings, message);
-      }
-
-      var removeError = function(element) {
-        clientSideValidations.formBuilders[settings.type].remove(element, settings);
-      }
     });
-  }
+  };
 
-  $.fn.isValid = function(validators) {
+  $.fn.isValid = function (validators) {
     if ($(this[0]).is('form')) {
       return validateForm($(this[0]), validators);
     } else {
       return validateElement($(this[0]), validators[this[0].name]);
     }
-  }
+  };
 
-  var validateForm = function(form, validators) {
+  var validateForm = function (form, validators) {
     var valid = true;
 
-    form.trigger('form:validate:before').find('[data-validate]:input').each(function() {
+    form.trigger('form:validate:before').find('[data-validate="true"]:input:enabled').each(function() {
       if (!$(this).isValid(validators)) { valid = false; }
     });
 
@@ -92,48 +91,57 @@
 
     form.trigger('form:validate:after');
     return valid;
-  }
-
-  var validateElement = function(element, validators) {
-    element.trigger('element:validate:before');
-
-    if (element.data('changed') !== false) {
-      var valid = true;
-      element.data('changed', false);
+  },
+    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
+        for (kind in ClientSideValidations.validators.local) {
+          if (validators[kind] && (message = ClientSideValidations.validators.all()[kind](element, validators[kind]))) {
+            element.trigger('element:validate:fail', message).data('valid', false);
+            valid = false;
+            break;
+          }
+        }
 
-      // 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;
+        if (valid) {
+          for (kind in ClientSideValidations.validators.remote) {
+            if (validators[kind] && (message = ClientSideValidations.validators.all()[kind](element, validators[kind]))) {
+              element.trigger('element:validate:fail', message).data('valid', false);
+              valid = false;
+              break;
+            }
+          }
         }
-      }
 
-      if (valid) { element.data('valid', null); element.trigger('element:validate:pass'); }
-    }
+        if (valid) { element.data('valid', null); element.trigger('element:validate:pass'); }
+      }
 
-    element.trigger('element:validate:after');
-    return element.data('valid') === false ? false : true;
-  }
+      element.trigger('element:validate:after');
+      return element.data('valid') === false ? false : true;
+    };
 
   // 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(); })
+  $(function () { $('form[data-validate]').validate(); });
 })(jQuery);
 
-var clientSideValidations = {
+var ClientSideValidations = {
+  forms: {},
   validators: {
-    all: function() { return jQuery.extend({}, clientSideValidations.validators.local, clientSideValidations.validators.remote) },
+    all: function() { return jQuery.extend({}, ClientSideValidations.validators.local, ClientSideValidations.validators.remote); },
     local: {
-      presence: function(element, options) {
+      presence: function (element, options) {
         if (/^\s*$/.test(element.val() || "")) {
           return options.message;
         }
       },
-      acceptance: function(element, options) {
+      acceptance: function (element, options) {
         switch (element.attr('type')) {
           case 'checkbox':
             if (!element.attr('checked')) {
@@ -147,8 +155,8 @@ var clientSideValidations = {
             break;
         }
       },
-      format: function(element, options) {
-        if ((message = this.presence(element, options)) && options.allow_blank == true) {
+      format: function (element, options) {
+        if ((message = this.presence(element, options)) && options.allow_blank === true) {
           return;
         } else if (message) {
           return message;
@@ -160,8 +168,8 @@ var clientSideValidations = {
           }
         }
       },
-      numericality: function(element, options) {
-        if (!/^-?(?:\d+|\d{1,3}(?:,\d{3})+)(?:\.\d*)?$/.test(element.val()) && element.val() != '') {
+      numericality: function (element, options) {
+        if (!/^-?(?:\d+|\d{1,3}(?:,\d{3})+)(?:\.\d*)?$/.test(element.val())) {
           return options.messages.numericality;
         }
 
@@ -170,82 +178,83 @@ var clientSideValidations = {
         }
 
         var CHECKS = { greater_than: '>', greater_than_or_equal_to: '>=',
-          equal_to: '==', less_than: '<', less_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])())) {
+        for (check in CHECKS) {
+          if (options[check] !== undefined && !(new Function("return " + element.val() + CHECKS[check] + options[check])())) {
             return options.messages[check];
           }
         }
 
-        if (options.odd && !(parseInt(element.val()) % 2)) {
+        if (options.odd && !(parseInt(element.val(), 10) % 2)) {
           return options.messages.odd;
         }
 
-        if (options.even && (parseInt(element.val()) % 2)) {
+        if (options.even && (parseInt(element.val(), 10) % 2)) {
           return options.messages.even;
         }
       },
-      length: function(element, options) {
-        var blankOptions = {};
+      length: function (element, options) {
+        var blankOptions = {},
+            CHECKS = { is: '==', minimum: '>=', maximum: '<=' },
+            tokenizer = options.js_tokenizer || "split('')",
+            tokenized_length = new Function("element", "return (element.val()." + tokenizer + " || '').length;")(element);
         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) {
+        if ((message = this.presence(element, blankOptions)) && options.allow_blank === true) {
           return;
         } else if (message) {
           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) {
+          for (check in CHECKS) {
             if (options[check] && !(new Function("return " + tokenized_length + CHECKS[check] + options[check])())) {
               return options.messages[check];
             }
           }
         }
       },
-      exclusion: function(element, options) {
-        if ((message = this.presence(element, options)) && options.allow_blank == true) {
+      exclusion: function (element, options) {
+        var lower = null, upper = null;
+        if ((message = this.presence(element, options)) && options.allow_blank === true) {
           return;
         } else if (message) {
           return message;
         } else {
           if (options['in']) {
-            for (var i = 0; i < options['in'].length; i++) {
+            for (i = 0; i < options['in'].length; i = i + 1) {
               if (options['in'][i] == element.val()) {
                 return options.message;
               }
             }
-          } else if (options['range']) {
-            var lower = options['range'][0],
-                upper = options['range'][1];
+          } else 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) {
+      inclusion: function (element, options) {
+        var lower = null, upper = null;
+        if ((message = this.presence(element, options)) && options.allow_blank === true) {
           return;
         } else if (message) {
           return message;
         } else {
           if (options['in']) {
-            for (var i = 0; i < options['in'].length; i++) {
+            for (i = 0; i < options['in'].length; i = i + 1) {
               if (options['in'][i] == element.val()) {
                 return;
               }
             }
             return options.message;
-          } else if (options['range']) {
-            var lower = options['range'][0],
-                upper = options['range'][1];
+          } else if (options.range) {
+            lower = options.range[0];
+            upper = options.range[1];
 
             if (element.val() >= lower && element.val() <= upper) {
               return;
@@ -255,30 +264,31 @@ var clientSideValidations = {
           }
         }
       },
-      confirmation: function(element, options) {
-        if (element.val() != jQuery('#' + element.attr('id') + '_confirmation').val()) {
+      confirmation: function (element, options) {
+        if (element.val() !== jQuery('#' + element.attr('id') + '_confirmation').val()) {
           return options.message;
         }
       }
     },
     remote: {
-      uniqueness: function(element, options) {
-        if ((message = clientSideValidations.validators.local.presence(element, options)) && options.allow_blank === true) {
+      uniqueness: function (element, options) {
+        if ((message = ClientSideValidations.validators.local.presence(element, options)) && options.allow_blank === true) {
           return;
         } else if (message) {
           return message;
         } else {
-          var data = {};
-          data['case_sensitive'] = !!options.case_sensitive;
+          var data = {},
+              name = null;
+          data.case_sensitive = !!options.case_sensitive;
           if (options.id) {
-            data['id'] = options.id;
+            data.id = options.id;
           }
 
           if (options.scope) {
-            data.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]) {
+              var scoped_element = jQuery('[name="' + element.attr('name').replace(/\[\w+\]$/, '[' + key + ']' + '"]'));
+              if (scoped_element[0] && scoped_element.val() !== options.scope[key]) {
                 data.scope[key] = scoped_element.val();
                 scoped_element.unbind('change.' + element.id).bind('change.' + element.id, function() { element.trigger('change'); element.trigger('focusout'); });
               } else {
@@ -291,16 +301,16 @@ var clientSideValidations = {
           // 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();
 
@@ -308,7 +318,7 @@ var clientSideValidations = {
             url: '/validators/uniqueness',
             data: data,
             async: false
-          }).status == 200) {
+          }).status === 200) {
             return options.message;
           }
         }
@@ -317,13 +327,13 @@ var clientSideValidations = {
   },
   formBuilders: {
     'ActionView::Helpers::FormBuilder': {
-      add: function(element, settings, message) {
-        if (element.data('valid') !== false && jQuery('label.message[for="' + element.attr('id') + '"]')[0] == undefined) {
+      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) };
+          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'));
@@ -333,7 +343,7 @@ var clientSideValidations = {
         }
         jQuery('label.message[for="' + element.attr('id') + '"]').text(message);
       },
-      remove: function(element, settings) {
+      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)'),
@@ -347,64 +357,19 @@ var clientSideValidations = {
         }
       }
     },
-    '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);
-        }
-      },
-      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);
-      },
-      remove: function(element, settings, message) {
-        clientSideValidations.formBuilders['ActionView::Helpers::FormBuilder'].remove(element, settings, message);
-      }
-    }
   },
   callbacks: {
     element: {
-      after:  function(element, eventData)                    { },
-      before: function(element, eventData)                    { },
-      fail:   function(element, message, addError, eventData) { addError() },
-      pass:   function(element, removeError, eventData)       { removeError() }
+      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) { }
     }
   }
 };