client_side_validations 3.1.0 → 3.2.0

data/client_side_validations.gemspec

@@ -13,30 +13,18 @@ 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.rc4'
+  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.0.0'
-  s.add_development_dependency 'mongo_mapper','~>0.9.0'
   s.add_development_dependency 'mocha'
-  s.add_development_dependency 'simple_form'
-  s.add_development_dependency 'formtastic', '~> 2.0.0.rc3'
+  s.add_development_dependency 'm'
 
   # For QUnit testing
   s.add_development_dependency 'sinatra', '~> 1.0'
   s.add_development_dependency 'shotgun'
   s.add_development_dependency 'thin'
   s.add_development_dependency 'json'
-
-  ruby_minor_version = RUBY_VERSION.split('.')[1].to_i
-  if ruby_minor_version == 8
-    s.add_development_dependency 'minitest'
-    s.add_development_dependency 'ruby-debug'
-  elsif ruby_minor_version == 9
-    s.add_development_dependency 'ruby-debug19'
-  end
+  s.add_development_dependency 'coffee-script'
+  s.add_development_dependency 'jquery-rails'
 end

data/lib/client_side_validations/action_view/form_builder.rb

@@ -5,7 +5,7 @@ module ClientSideValidations::ActionView::Helpers
       (base.field_helpers.map(&:to_s) - %w(apply_form_for_options! label check_box radio_button fields_for hidden_field)).each do |selector|
         base.class_eval <<-RUBY_EVAL
           def #{selector}_with_client_side_validations(method, options = {})
-            apply_client_side_validators(method, options)
+            build_validation_options(method, options)
             options.delete(:validate)
             #{selector}_without_client_side_validations(method, options)
           end
@@ -24,9 +24,9 @@ module ClientSideValidations::ActionView::Helpers
         alias_method_chain :grouped_collection_select, :client_side_validations
         alias_method_chain :time_zone_select,          :client_side_validations
 
-        def self.client_side_form_settings(options, form_helper)
+        def client_side_form_settings(options, form_helper)
           {
-            :type => self.to_s,
+            :type => self.class.to_s,
             :input_tag => form_helper.class.field_error_proc.call(%{<span id="input_tag" />},  Struct.new(:error_message, :tag_id).new([], "")),
             :label_tag => form_helper.class.field_error_proc.call(%{<label id="label_tag" />}, Struct.new(:error_message, :tag_id).new([], ""))
           }
@@ -34,9 +34,17 @@ module ClientSideValidations::ActionView::Helpers
       end
     end
 
+    def validate(*attrs)
+      options = attrs.pop if attrs.last.is_a?(Hash)
+      (attrs.present? ? attrs : @object._validators.keys).each do |attr|
+        build_validation_options(attr, :validate => options)
+      end
+      nil
+    end
+
     def initialize_with_client_side_validations(object_name, object, template, options, proc)
       initialize_without_client_side_validations(object_name, object, template, options, proc)
-      @options[:validators] = {}
+      @options[:validators] = { object => {} }
     end
 
     def fields_for_with_client_side_validations(record_or_name_or_array, *args, &block)
@@ -46,106 +54,50 @@ module ClientSideValidations::ActionView::Helpers
     end
 
     def check_box_with_client_side_validations(method, options = {}, checked_value = "1", unchecked_value = "0")
-      apply_client_side_validators(method, options)
+      build_validation_options(method, options)
+      options.delete(:validate)
       check_box_without_client_side_validations(method, options, checked_value, unchecked_value)
     end
 
     def radio_button_with_client_side_validations(method, tag_value, options = {})
-      apply_client_side_validators(method, options)
+      build_validation_options(method, options)
+      options.delete(:validate)
       radio_button_without_client_side_validations(method, tag_value, options)
     end
 
     def select_with_client_side_validations(method, choices, options = {}, html_options = {})
-      apply_client_side_validators(method, html_options)
+      build_validation_options(method, html_options.merge(:name => options[:name]))
+      html_options.delete(:validate)
       select_without_client_side_validations(method, choices, options, html_options)
     end
 
     def collection_select_with_client_side_validations(method, collection, value_method, text_method, options = {}, html_options = {})
-      apply_client_side_validators(method, html_options)
+      build_validation_options(method, html_options.merge(:name => options[:name]))
+      html_options.delete(:validate)
       collection_select_without_client_side_validations(method, collection, value_method, text_method, options, html_options)
     end
 
     def grouped_collection_select_with_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
-      apply_client_side_validators(method, html_options)
+      build_validation_options(method, html_options.merge(:name => options[:name]))
+      html_options.delete(:validate)
       grouped_collection_select_without_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
     end
 
     def time_zone_select_with_client_side_validations(method, priority_zones = nil, options = {}, html_options = {})
-      apply_client_side_validators(method, html_options)
+      build_validation_options(method, html_options.merge(:name => options[:name]))
+      html_options.delete(:validate)
       time_zone_select_without_client_side_validations(method, priority_zones = nil, options, html_options)
     end
 
   private
 
-    def apply_client_side_validators(method, options = {})
-      if @options[:validate] && options[:validate] != false && validators = filter_validators(@object.client_side_validation_hash[method], options[:validate])
-        options.merge!("data-validate" => true)
-        @options[:validators].merge!("#{@object_name}[#{method}]#{options[:multiple] ? "[]" : nil}" => validators)
-      end
-    end
-
-    def filter_validators(validators, filters)
-      if validators
-        filtered_validators = validators.inject({}) do |filtered_validators, validator|
-          filtered_validators[validator.first] = validator.last
-          if has_filter_for_validator?(validator, filters)
-            if filter_validator?(validator, filters)
-              filtered_validators.delete(validator.first)
-            elsif force_validator_despite_conditional?(validator, filters) && !can_run_validator?(validator)
-              filtered_validators.delete(validator.first)
-            end
-          else
-            if validator.last.key?(:if) || validator.last.key?(:unless)
-              filtered_validators.delete(validator.first)
-            end
-          end
-          filtered_validators[validator.first].delete(:if) if filtered_validators[validator.first]
-          filtered_validators[validator.first].delete(:unless) if filtered_validators[validator.first]
-          filtered_validators
-        end
-
-        filtered_validators.empty? ? nil : filtered_validators
-      end
-    end
-
-    def has_filter_for_validator?(validator, filters)
-      filters && (filters == true || filters.key?(validator.first))
-    end
-
-    def filter_validator?(validator, filters)
-      filters != true && filters[validator.first] == false
-    end
-
-    def force_validator_despite_conditional?(validator, filters)
-      filters == true || filters[validator.first] == true
-    end
-
-    def can_run_validator?(validator)
-      result        = true
-      if_result     = can_run_if_validator?(validator.last[:if])
-      unless_result = can_run_unless_validator?(validator.last[:unless])
-      result        = result && if_result unless if_result.nil?
-      result        = result && unless_result unless unless_result.nil?
-      result
-    end
-
-    def can_run_if_validator?(conditional)
-      if conditional
-        if conditional.is_a?(Symbol)
-          !!@object.send(conditional)
-        else
-          !!conditional.call(@object)
-        end
-      end
-    end
-
-    def can_run_unless_validator?(conditional)
-      if conditional
-        if conditional.is_a?(Symbol)
-          !@object.send(conditional)
-        else
-          !conditional.call(@object)
-        end
+    def build_validation_options(method, options = {})
+      if @options[:validate]
+        name = options[:name] || "#{@object_name}[#{method}]"
+        child_index = @options[:child_index] ? "(\\d+|#{Regexp.escape(@options[:child_index])})" : "\\d+"
+        name = name.to_s.gsub(/_attributes\]\[#{child_index}\]/, '_attributes][]')
+        name = "#{name}#{options[:multiple] ? "[]" : nil}"
+        @options[:validators][@object][method] = { :name => name, :options => options[:validate] }
       end
     end
   end

data/lib/client_side_validations/action_view/form_helper.rb

@@ -2,38 +2,46 @@ module ClientSideValidations::ActionView::Helpers
   module FormHelper
     class Error < StandardError; end
 
-    def form_for(record_or_name_or_array, *args, &proc)
+    def form_for(record, *args, &proc)
       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'
 
-        case record_or_name_or_array
+        case record
         when String, Symbol
-          raise ClientSideValidations::ActionView::Helpers::FormHelper::Error, 'Using form_for(:name, @resource) is deprecated in Rails and is not supported with ClientSideValidations. Please use form_for(@resource, :as => :name) instead.'
-        when Array
-          object = record_or_name_or_array.last
+          raise ClientSideValidations::ActionView::Helpers::FormHelper::Error, 'Using form_for(:name, @resource) is not supported with ClientSideValidations. Please use form_for(@resource, :as => :name) instead.'
         else
-          object = record_or_name_or_array
+          object = record.is_a?(Array) ? record.last : record
         end
       end
 
       @validators = {}
+
       # Order matters here. Rails mutates the options object
+      html_id = options[:html][:id] if options[:html]
+      form   = super(record, *(args << options), &proc)
+      options[:id] = html_id if html_id
       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)
@@ -41,9 +49,9 @@ module ClientSideValidations::ActionView::Helpers
       options[:html][:validate] = true if options[:validate]
     end
 
-    def fields_for(record_or_name_or_array, *args, &block)
+    def fields_for(record_or_name_or_array, record_object = nil, options = {}, &block)
       output = super
-      @validators.merge!(args.last[:validators]) if @validators
+      @validators.merge!(options[:validators]) if @validators
       output
     end
 
@@ -54,30 +62,57 @@ module ClientSideValidations::ActionView::Helpers
       # But using String#sub has some issues. Undocumented "features"
       if script
         script = script.split(/"validator_hash"/)
-        script = "#{script[0]}#{@validators.to_json}#{script[1]}"
+        script = "#{script[0]}#{construct_validators.to_json}#{script[1]}"
       end
 
       script
     end
 
+    def construct_validators
+      @validators.inject({}) do |validator_hash, object_opts|
+        option_hash = object_opts[1].inject({}) do |option_hash, attr|
+          option_hash.merge!(attr[0] => attr[1][:options])
+        end
+
+        validation_hash = object_opts[0].client_side_validation_hash(option_hash)
+
+        option_hash.each_key do |attr|
+          if validation_hash[attr]
+            validator_hash.merge!(object_opts[1][attr][:name] => validation_hash[attr])
+          end
+        end
+
+        validator_hash
+      end
+    end
+
     def client_side_form_settings(object, options)
       if options[:validate]
-        builder = options[:builder] || ActionView::Base.default_form_builder
+        builder = options[:parent_builder]
 
-        if options[:html] && options[:html][:id]
-          var_name = options[:html][:id]
+        if options[:id]
+          var_name = options[:id]
         else
-          var_name = if object.respond_to?(:persisted?) && object.persisted?
-            options[:as] ? "#{options[:as]}_edit" : dom_id(object, :edit)
+          if Rails.version >= '3.2.0'
+            var_name = if object.respond_to?(:persisted?) && object.persisted?
+              options[:as] ? "edit_#{options[:as]}" : [options[:namespace], dom_id(object, :edit)].compact.join("_")
+            else
+              options[:as] ? "new_#{options[:as]}" : [options[:namespace], dom_id(object)].compact.join("_")
+            end
           else
-            options[:as] ? "#{options[:as]}_new" : dom_id(object)
+            # This is to maintain backward compatibility with Rails 3.1
+            # see: https://github.com/rails/rails/commit/e29773f885fd500189ffd964550ae20061d745ba#commitcomment-948052
+            var_name = if object.respond_to?(:persisted?) && object.persisted?
+              options[:as] ? "#{options[:as]}_edit" : dom_id(object, :edit)
+            else
+              options[:as] ? "#{options[:as]}_new" : dom_id(object)
+            end
           end
         end
 
         content_tag(:script) do
-          "window['#{var_name}'] = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};".html_safe
+          "//<![CDATA[\nif(window.ClientSideValidations==undefined)window.ClientSideValidations={};if(window.ClientSideValidations.forms==undefined)window.ClientSideValidations.forms={};window.ClientSideValidations.forms['#{var_name}'] = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};\n//]]>".html_safe
         end
-
       end
     end
 

data/lib/client_side_validations/active_model/exclusion.rb

@@ -1,12 +1,24 @@
 module ClientSideValidations::ActiveModel
   module Exclusion
 
-    def client_side_hash(model, attribute)
-      hash = super
+    def client_side_hash(model, attribute, force = nil)
+      if options[:in].respond_to?(:call)
+        if force
+          options = self.options.dup
+          options[:in] = options[:in].call(model)
+          hash = build_client_side_hash(model, attribute, options)
+        else
+          return
+        end
+      else
+        hash = build_client_side_hash(model, attribute, self.options.dup)
+      end
+
       if hash[:in].is_a?(Range)
         hash[:range] = hash[:in]
         hash.delete(:in)
       end
+
       hash
     end
 

data/lib/client_side_validations/active_model/format.rb

@@ -1,5 +1,26 @@
 module ClientSideValidations::ActiveModel
   module Format
+    def client_side_hash(model, attribute, force = nil)
+      options = self.options.dup
+      if options[:with].respond_to?(:call)
+        if force
+          options[:with] = options[:with].call(model)
+          build_client_side_hash(model, attribute, options)
+        else
+          return
+        end
+      elsif options[:without].respond_to?(:call)
+        if force
+          options[:without] = options[:without].call(model)
+          build_client_side_hash(model, attribute, options)
+        else
+          return
+        end
+      else
+        super
+      end
+    end
+
     private
 
     def message_type

data/lib/client_side_validations/active_model/inclusion.rb

@@ -1,8 +1,19 @@
 module ClientSideValidations::ActiveModel
   module Inclusion
 
-    def client_side_hash(model, attribute)
-      hash = super
+    def client_side_hash(model, attribute, force = nil)
+      if options[:in].respond_to?(:call)
+        if force
+          options = self.options.dup
+          options[:in] = options[:in].call(model)
+          hash = build_client_side_hash(model, attribute, options)
+        else
+          return
+        end
+      else
+        hash = build_client_side_hash(model, attribute, self.options.dup)
+      end
+
       if hash[:in].is_a?(Range)
         hash[:range] = hash[:in]
         hash.delete(:in)

data/lib/client_side_validations/active_model/length.rb

@@ -1,7 +1,7 @@
 module ClientSideValidations::ActiveModel
   module Length
 
-    def client_side_hash(model, attribute)
+    def client_side_hash(model, attribute, force = nil)
       options = self.options.dup
       hash    = { :messages => {} }
       hash[:js_tokenizer] = options[:js_tokenizer] if options[:js_tokenizer]
@@ -9,13 +9,15 @@ module ClientSideValidations::ActiveModel
 
       self.class::MESSAGES.each do |option, message_type|
         if count = options[option]
-          options[:message] = options[message_type]
+          options[:message] = options[message_type] if options[message_type].present?
           options.delete(:message) if options[:message].nil?
           hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(:count => count))
           hash[option] = count
         end
       end
 
+      copy_conditional_attributes(hash, options)
+
       hash
     end
 

data/lib/client_side_validations/active_model/numericality.rb

@@ -7,7 +7,7 @@ module ClientSideValidations::ActiveModel
       OPTION_MAP.merge!(base::CHECKS.keys.inject({}) { |hash, key| hash.merge!(key => key) })
     end
 
-    def client_side_hash(model, attribute)
+    def client_side_hash(model, attribute, force = nil)
       options = self.options.dup
       hash    = { :messages => { :numericality => model.errors.generate_message(attribute, :not_a_number, options) } }
 
@@ -16,13 +16,24 @@ module ClientSideValidations::ActiveModel
         hash[:only_integer] = true
       end
 
+      hash[:allow_blank] = true if options[:allow_nil]
+
       OPTION_MAP.each do |option, message_type|
         if count = options[option]
+          if count.respond_to?(:call)
+            if force
+              count = count.call(model)
+            else
+              next
+            end
+          end
           hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(:count => count))
           hash[option] = count
         end
       end
 
+      copy_conditional_attributes(hash, options)
+
       hash
     end
 

data/lib/client_side_validations/active_model.rb

@@ -3,31 +3,38 @@ require 'client_side_validations/core_ext'
 module ClientSideValidations::ActiveModel
   module Validator
 
-    def client_side_hash(model, attribute)
-      options = self.options.dup
-      { :message => model.errors.generate_message(attribute, message_type, options) }.merge(options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:allow_blank, :if, :unless]))
+    def client_side_hash(model, attribute, force = nil)
+      build_client_side_hash(model, attribute, self.options.dup)
+    end
+
+    def copy_conditional_attributes(to, from)
+      [:if, :unless].each { |key| to[key] = from[key] if from[key].present? }
     end
 
     private
 
+    def build_client_side_hash(model, attribute, options)
+      { :message => model.errors.generate_message(attribute, message_type, options) }.merge(options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:allow_blank, :if, :unless]))
+    end
+
     def message_type
       kind
     end
   end
 
   module Validations
-    def client_side_validation_hash
-      @client_side_validation_hash ||= _validators.inject({}) do |attr_hash, attr|
+    def client_side_validation_hash(force = nil)
+      _validators.inject({}) do |attr_hash, attr|
         unless [nil, :block].include?(attr[0])
 
-          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))
-              kind_hash.merge!(validator.kind => client_side_hash.except(:on))
-            else
-              kind_hash.merge!({})
+          validator_hash = attr[1].inject(Hash.new { |h,k| h[k] = []}) do |kind_hash, validator|
+            if can_use_for_client_side_validation?(attr[0], validator, force)
+              if client_side_hash = validator.client_side_hash(self, attr[0], extract_force_option(attr[0], force))
+                kind_hash[validator.kind] << client_side_hash.except(:on, :if, :unless)
+              end
             end
+
+            kind_hash
           end
 
           if validator_hash.present?
@@ -43,8 +50,87 @@ module ClientSideValidations::ActiveModel
 
     private
 
-    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
+    def extract_force_option(attr, force)
+      case force
+      when FalseClass, TrueClass, NilClass
+        force
+      when Hash
+        extract_force_option(nil, force[attr])
+      else
+        nil
+      end
+    end
+
+    def can_use_for_client_side_validation?(attr, validator, force)
+      if validator_turned_off?(attr, validator, force)
+        result = false
+      else
+        # Yeah yeah, #new_record? is not part of ActiveModel :p
+        result = ((self.respond_to?(:new_record?) && validator.options[:on] == (self.new_record? ? :create : :update)) || validator.options[:on].nil?)
+        result = result && validator.kind != :block
+
+        if validator.options[:if] || validator.options[:unless]
+          if result = can_force_validator?(attr, validator, force)
+            if validator.options[:if]
+              result = result && run_conditional(validator.options[:if])
+            end
+            if validator.options[:unless]
+              result = result && !run_conditional(validator.options[:unless])
+            end
+          end
+        end
+      end
+
+      result
+    end
+
+    def run_conditional(method_name_or_proc)
+      case method_name_or_proc
+      when Proc
+        method_name_or_proc.call(self)
+      else
+        self.send(method_name_or_proc)
+      end
+    end
+
+    def validator_turned_off?(attr, validator, force)
+      case force
+      when FalseClass
+        true
+      when Hash
+        case force[attr]
+        when FalseClass
+          true
+        when Hash
+          force[attr][validator.kind] == false
+        else
+          false
+        end
+      else
+        ::ClientSideValidations::Config.disabled_validators.include?(validator.kind)
+      end
+    end
+
+    def can_force_validator?(attr, validator, force)
+      case force
+      when TrueClass
+        true
+      when Hash
+        case force[attr]
+        when TrueClass
+          true
+        when Hash
+          force[attr][validator.kind]
+        else
+          false
+        end
+      else
+        if (validator.options[:if] || validator.options[:unless]) =~ /changed\?/
+          true
+        else
+          false
+        end
+      end
     end
   end
 end

data/lib/client_side_validations/active_record/middleware.rb

@@ -1,14 +1,20 @@
 module ClientSideValidations::ActiveRecord
   class Middleware
 
+    def self.is_class?(klass)
+      klass < ::ActiveRecord::Base
+    end
+
     def self.is_unique?(klass, attribute, value, params)
+      klass = find_topmost_superclass(klass)
+      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?
 
       t = klass.arel_table
 
       if params[:case_sensitive] == 'true'
-        if t.engine.connection.instance_variable_get("@config")[:adapter] == 'mysql'
+        if t.engine.connection.instance_variable_get("@config")[:adapter] =~ /^mysql/
           relation = Arel::Nodes::SqlLiteral.new("BINARY #{t[attribute].eq(value).to_sql}")
         else
           relation = t[attribute].eq(value)
@@ -23,11 +29,31 @@ 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)
+        if relation.is_a?(Arel::Nodes::SqlLiteral)
+          relation =  Arel::Nodes::SqlLiteral.new("#{relation} AND #{t[attribute].eq(value).to_sql}")
+        else
+          relation = relation.and(t[attribute].eq(value))
+        end
       end
 
       !klass.where(relation).exists?
     end
+
+    private
+
+    def self.type_cast_value(klass, attribute, value)
+      klass.columns_hash[attribute].type_cast(value)
+    end
+
+    def self.find_topmost_superclass(klass)
+      if is_class?(klass.superclass)
+        find_topmost_superclass(klass.superclass)
+      else
+        klass
+      end
+    end
+
   end
 end