Merge branch 'master' of https://github.com/bcardarella/client_side_v…

…alidations

lib/client_side_validations/action_view/form_builder.rb

@@ -97,8 +97,24 @@ def filter_validators(method, filters)
               unfiltered_validators.delete(validator.first)
             end
           else
-            if (conditional = (validator.last[:if] || validator.last[:unless])) && conditional.is_a?(Symbol) && !conditional_method_is_change_method?(conditional, method)
-              unfiltered_validators.delete(validator.first)
+            if (conditional = (validator.last[:if] || validator.last[: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.last[:if] && !result) || (validator.last[:unless] && result)
+                unfiltered_validators.delete(validator.first)
+              end
             end
           end
           unfiltered_validators[validator.first].delete(:if)     if unfiltered_validators[validator.first]

lib/client_side_validations/active_model.rb

@@ -8,6 +8,10 @@ def client_side_hash(model, attribute)
       { :message => model.errors.generate_message(attribute, message_type, options) }.merge(options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:allow_blank, :if, :unless]))
     end
 
+    def copy_conditional_attributes(to, from)
+      [:if, :unless].each { |key| to[key] = from[key] if from[key].present? }
+    end
+
     private
 
     def message_type

lib/client_side_validations/active_model/length.rb

@@ -16,6 +16,8 @@ def client_side_hash(model, attribute)
         end
       end
 
+      copy_conditional_attributes(hash, options)
+
       hash
     end
 

lib/client_side_validations/active_model/numericality.rb

@@ -23,6 +23,8 @@ def client_side_hash(model, attribute)
         end
       end
 
+      copy_conditional_attributes(hash, options)
+
       hash
     end
 

lib/client_side_validations/active_record/middleware.rb

@@ -30,7 +30,11 @@ def self.is_unique?(klass, attribute, value, params)
 
       (params[:scope] || {}).each do |attribute, value|
         value    = type_cast_value(klass, attribute, value)
-        relation = relation.and(t[attribute].eq(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?

test/action_view/cases/test_helpers.rb

@@ -355,12 +355,12 @@ def test_time_zone_select
     assert_equal expected, output_buffer
   end
 
-  def test_conditional_validators_should_be_filtered
+  def test_conditional_validators_should_be_filtered_based_on_symbol_condition_true
     hash = {
       :cost => {
         :presence => {
           :message => "can't be blank",
-          :unless => :do_not_validate?
+          :unless => :do_validate?
         }
       },
       :title => {
@@ -380,9 +380,182 @@ def test_conditional_validators_should_be_filtered
       concat f.text_field(:title)
     end
 
-    validators = {}
+    validators = {
+        'post[title]' => {:presence => {:message => "can't be blank"}}
+    }
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input id="post_cost" name="post[cost]" size="30" type="text" />} +
+      %{<input data-validate="true" id="post_title" name="post[title]" size="30" type="text" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_conditional_validators_should_be_filtered_based_on_symbol_condition_false
+    hash = {
+      :cost => {
+        :presence => {
+          :message => "can't be blank",
+          :unless => :do_not_validate?
+        }
+      },
+      :title => {
+        :presence => {
+          :message => "can't be blank",
+          :if => :do_not_validate?
+        }
+      }
+    }
+
+    @post.title = nil
+    @post.stubs(:do_not_validate?).returns(false)
+    @post.stubs(:do_validate?).returns(true)
+    @post.stubs(:client_side_validation_hash).returns(hash)
+    form_for(@post, :validate => true) do |f|
+      concat f.text_field(:cost)
+      concat f.text_field(:title)
+    end
+
+    validators = {
+        'post[cost]' => {:presence => {:message => "can't be blank"}}
+    }
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="text" />} +
+      %{<input id="post_title" name="post[title]" size="30" type="text" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_conditional_validators_should_be_filtered_based_on_string_condition_true
+    hash = {
+      :cost => {
+        :presence => {
+          :message => "can't be blank",
+          :unless => 'true'
+        }
+      },
+      :title => {
+        :presence => {
+          :message => "can't be blank",
+          :if => 'true'
+        }
+      }
+    }
+
+    @post.title = nil
+    @post.stubs(:client_side_validation_hash).returns(hash)
+    form_for(@post, :validate => true) do |f|
+      concat f.text_field(:cost)
+      concat f.text_field(:title)
+    end
+
+    validators = {
+        'post[title]' => {:presence => {:message => "can't be blank"}}
+    }
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input id="post_cost" name="post[cost]" size="30" type="text" />} +
+      %{<input data-validate="true" id="post_title" name="post[title]" size="30" type="text" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_conditional_validators_should_be_filtered_based_on_string_condition_false
+    hash = {
+      :cost => {
+        :presence => {
+          :message => "can't be blank",
+          :unless => 'false'
+        }
+      },
+      :title => {
+        :presence => {
+          :message => "can't be blank",
+          :if => 'false'
+        }
+      }
+    }
+
+    @post.title = nil
+    @post.stubs(:client_side_validation_hash).returns(hash)
+    form_for(@post, :validate => true) do |f|
+      concat f.text_field(:cost)
+      concat f.text_field(:title)
+    end
+
+    validators = {
+        'post[cost]' => {:presence => {:message => "can't be blank"}}
+    }
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="text" />} +
+      %{<input id="post_title" name="post[title]" size="30" type="text" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_conditional_validators_should_be_filtered_based_on_proc_condition_true
+    hash = {
+      :cost => {
+        :presence => {
+          :message => "can't be blank",
+          :unless => Proc.new { |o| o.do_validate? }
+        }
+      },
+      :title => {
+        :presence => {
+          :message => "can't be blank",
+          :if => Proc.new { |o| o.do_validate? }
+        }
+      }
+    }
+
+    @post.title = nil
+    @post.stubs(:do_not_validate?).returns(false)
+    @post.stubs(:do_validate?).returns(true)
+    @post.stubs(:client_side_validation_hash).returns(hash)
+    form_for(@post, :validate => true) do |f|
+      concat f.text_field(:cost)
+      concat f.text_field(:title)
+    end
+
+    validators = {
+        'post[title]' => {:presence => {:message => "can't be blank"}}
+    }
     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
       %{<input id="post_cost" name="post[cost]" size="30" type="text" />} +
+      %{<input data-validate="true" id="post_title" name="post[title]" size="30" type="text" />}
+    end
+    assert_equal expected, output_buffer
+  end
+
+  def test_conditional_validators_should_be_filtered_based_on_proc_condition_false
+    hash = {
+      :cost => {
+        :presence => {
+          :message => "can't be blank",
+          :unless => Proc.new { |o| o.do_not_validate? }
+        }
+      },
+      :title => {
+        :presence => {
+          :message => "can't be blank",
+          :if => Proc.new { |o| o.do_not_validate? }
+        }
+      }
+    }
+
+    @post.title = nil
+    @post.stubs(:do_not_validate?).returns(false)
+    @post.stubs(:do_validate?).returns(true)
+    @post.stubs(:client_side_validation_hash).returns(hash)
+    form_for(@post, :validate => true) do |f|
+      concat f.text_field(:cost)
+      concat f.text_field(:title)
+    end
+
+    validators = {
+        'post[cost]' => {:presence => {:message => "can't be blank"}}
+    }
+    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
+      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="text" />} +
       %{<input id="post_title" name="post[title]" size="30" type="text" />}
     end
     assert_equal expected, output_buffer
@@ -579,6 +752,9 @@ def test_conditional_validator_ignored_when_using_changed_helpers
     }
 
     @post.title = nil
+    # we don't have _changed? methods by default so we must stub them
+    @post.stubs(:title_changed?).returns(true)
+    @post.stubs(:cost_changed?).returns(false)
     @post.stubs(:client_side_validation_hash).returns(hash)
     form_for(@post, :validate => true) do |f|
       concat f.text_field(:cost)
@@ -613,6 +789,9 @@ def test_conditional_validator_ignored_when_using_changed_helpers_and_forcing_va
     }
 
     @post.title = nil
+    # we don't have _changed? methods by default so we must stub them
+    @post.stubs(:title_changed?).returns(true)
+    @post.stubs(:cost_changed?).returns(false)
     @post.stubs(:client_side_validation_hash).returns(hash)
     form_for(@post, :validate => true) do |f|
       concat f.text_field(:cost, :validate => true)

test/active_record/cases/test_middleware.rb

@@ -85,6 +85,24 @@ def test_mysql_adapter_uniqueness_when_id_is_given
     assert_equal 'true', last_response.body
   end
 
+  def test_mysql_adapter_uniqueness_when_id_is_given_with_scope
+    user = User.create(:email => 'user@test.com', :name => 'Brian')
+    ActiveRecord::ConnectionAdapters::SQLite3Adapter.
+                                        any_instance.expects(:instance_variable_get).
+                                        with("@config").
+                                        returns({:adapter => "mysql"})
+
+    sql_without_binary = "#{User.arel_table["email"].eq(user.email).to_sql} AND #{User.arel_table.primary_key.not_eq(user.id).to_sql} AND #{User.arel_table["name"].eq(user.name).to_sql}"
+    relation = Arel::Nodes::SqlLiteral.new("BINARY #{sql_without_binary}")
+
+    #NOTE: Stubs User#where because SQLite3 don't know BINARY
+    result = User.where(sql_without_binary)
+    User.expects(:where).with(relation).returns(result)
+
+    get '/validators/uniqueness', { 'user[email]' => user.email, 'scope' => {'name' => user.name}, 'case_sensitive' => true, 'id' => user.id}
+    assert_equal 'true', last_response.body
+  end
+
   def test_uniqueness_when_scope_is_given
     User.create(:email => 'user@test.com', :age => 25)
     get '/validators/uniqueness', { 'user[email]' => 'user@test.com', 'scope' => { 'age' => 30 }, 'case_sensitive' => true }