client_side_validations 3.2.0.beta.6 → 3.2.0.rc.1

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
@@ -36,7 +36,7 @@ module ClientSideValidations::ActionView::Helpers
 
     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,137 +46,47 @@ 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(:validate => options[: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(:validate => options[: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(:validate => options[: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(:validate => options[: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(method, options[:validate])
-        options.merge!("data-validate" => true)
+    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.gsub(/_attributes\]\[#{child_index}\]/, '_attributes][]')
-        @options[:validators].merge!("#{name}#{options[:multiple] ? "[]" : nil}" => validators)
+        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
-
-    def filter_validators(method, filters)
-      if validators = @object.client_side_validation_hash[method]
-        unfiltered_validators = validators.inject({}) do |unfiltered_validators, validator|
-          kind = validator.first
-          unfiltered_validators[kind] = validator.last.inject([]) do |validators_array, validator_hash|
-            if has_filter_for_validator?(kind, filters)
-              if filter_validator?(kind, filters)
-                next
-              elsif force_validator_despite_conditional?(kind, filters) && !can_run_validator?(validator_hash, method)
-                next
-              end
-            else
-              if (conditional = (validator_hash[:if] || validator_hash[:unless]))
-                result = case conditional
-                  when Symbol
-                    if @object.respond_to?(conditional)
-                      @object.send(conditional)
-                    else
-                      raise(ArgumentError, "unknown method called '#{conditional}'")
-                    end
-                  when String
-                    eval(conditional)
-                  when Proc
-                    conditional.call(@object)
-                  end
-
-                # :if was specified and result is false OR :unless was specified and result was true
-                if (validator_hash[:if] && !result) || (validator_hash[:unless] && result)
-                  next
-                end
-              end
-
-            end
-
-            validators_array << validator_hash.clone
-            validators_array.last.delete_if { |key, value| key == :if || key == :unless }
-            validators_array
-          end
-
-          unfiltered_validators
-        end
-
-        unfiltered_validators.delete_if { |k, v| v.nil? }
-        unfiltered_validators.empty? ? nil : unfiltered_validators
-      end
-    end
-
-    def has_filter_for_validator?(kind, filters)
-      filters && (filters == true || filters.key?(kind))
-    end
-
-    def filter_validator?(kind, filters)
-      filters != true && filters[kind] == false
-    end
-
-    def force_validator_despite_conditional?(kind, filters)
-      filters == true || filters[kind] == true
-    end
-
-    def can_run_validator?(validator_hash, method)
-      result        = true
-      if_result     = run_if_validator(validator_hash[:if], method)
-      unless_result = run_unless_validator(validator_hash[:unless], method)
-      result        = result && if_result unless if_result.nil?
-      result        = result && unless_result unless unless_result.nil?
-      result
-    end
-
-    def run_if_validator(conditional, method)
-      if conditional
-        if conditional.is_a?(Symbol)
-          conditional_method_is_change_method?(conditional, method) ? true : !!@object.send(conditional)
-        else
-          !!conditional.call(@object)
-        end
-      end
-    end
-
-    def run_unless_validator(conditional, method)
-      if conditional
-        if conditional.is_a?(Symbol)
-          conditional_method_is_change_method?(conditional, method) ? true : !@object.send(conditional)
-        else
-          !conditional.call(@object)
-        end
-      end
-    end
-
-    def conditional_method_is_change_method?(conditional, method)
-      conditional.to_sym == "#{method}_changed?".to_sym
-    end
   end
 end

data/lib/client_side_validations/action_view/form_helper.rb

@@ -2,7 +2,7 @@ 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]
 
@@ -10,13 +10,11 @@ module ClientSideValidations::ActionView::Helpers
         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
 
@@ -24,7 +22,7 @@ module ClientSideValidations::ActionView::Helpers
 
       # Order matters here. Rails mutates the options object
       html_id = options[:html][:id] if options[:html]
-      form   = super(record_or_name_or_array, *(args << options), &proc)
+      form   = super(record, *(args << options), &proc)
       options[:id] = html_id if html_id
       script = client_side_form_settings(object, options)
 
@@ -64,12 +62,30 @@ 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[:parent_builder]

data/lib/client_side_validations/active_model.rb

@@ -3,9 +3,8 @@ 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)
@@ -14,21 +13,25 @@ module ClientSideValidations::ActiveModel
 
     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(Hash.new { |h,k| h[k] = []}) 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) && uniqueness_validations_allowed_or_not_applicable?(validator)
-              kind_hash[validator.kind] << client_side_hash.except(:on)
+            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
@@ -47,8 +50,88 @@ 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
+        result = result && uniqueness_validations_allowed_or_not_applicable?(validator)
+
+        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
+        false
+      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
 
     def uniqueness_validations_allowed_or_not_applicable?(validator)

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]