client_side_validations 3.1.5 → 3.2.0.beta.1

data/lib/client_side_validations/mongo_mapper.rb

@@ -1,9 +0,0 @@
-require 'client_side_validations/active_model'
-require 'client_side_validations/mongo_mapper/middleware'
-
-%w{uniqueness}.each do |validator|
-  require "client_side_validations/mongo_mapper/#{validator}"
-  validator.capitalize!
-  eval "MongoMapper::Plugins::Validations::#{validator}Validator.send(:include, ClientSideValidations::MongoMapper::#{validator})"
-end
-

data/lib/client_side_validations/mongo_mapper/middleware.rb

@@ -1,20 +0,0 @@
-module ClientSideValidations::MongoMapper
-  class Middleware
-
-    # Still need to handle embedded documents
-    def self.is_unique?(klass, attribute, value, params)
-      if params[:case_sensitive] == 'false'
-        value = Regexp.new("^#{Regexp.escape(value.to_s)}$", Regexp::IGNORECASE)
-      end
-
-      criteria = klass.where(attribute => value)
-      criteria = criteria.where(:_id => {'$ne' => BSON::ObjectId(params[:id])}) if params[:id]
-
-      (params[:scope] || {}).each do |key, value|
-        criteria = criteria.where(key => value)
-      end
-
-      !criteria.exists?
-    end
-  end
-end

data/lib/client_side_validations/mongo_mapper/uniqueness.rb

@@ -1,29 +0,0 @@
-module ClientSideValidations::MongoMapper
-  module Uniqueness
-    def client_side_hash(model, attribute)
-      hash = {}
-      hash[:message] = model.errors.generate_message(attribute, message_type, options.except(:scope))
-      hash[:case_sensitive] = options[:case_sensitive] if options.key?(: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|
-          scope_hash.merge!(scope_item => model.send(scope_item))
-        end
-      end
-
-      unless model.class.name.demodulize == model.class.name
-        hash[:class] = model.class.name.underscore
-      end
-
-      hash
-    end
-
-    private
-
-    def message_type
-      :taken
-    end
-  end
-end
-

data/lib/client_side_validations/mongoid.rb

@@ -1,9 +0,0 @@
-require 'client_side_validations/active_model'
-require 'client_side_validations/mongoid/middleware'
-
-%w{format length presence uniqueness}.each do |validator|
-  require "client_side_validations/mongoid/#{validator}"
-  validator.capitalize!
-  eval "Mongoid::Validations::#{validator}Validator.send(:include, ClientSideValidations::Mongoid::#{validator})"
-end
-

data/lib/client_side_validations/mongoid/format.rb

@@ -1,10 +0,0 @@
-module ClientSideValidations::Mongoid
-  module Format
-    private
-
-    def message_type
-      :invalid
-    end
-  end
-end
-

data/lib/client_side_validations/mongoid/length.rb

@@ -1,24 +0,0 @@
-module ClientSideValidations::Mongoid
-  module Length
-
-    def client_side_hash(model, attribute)
-      options = self.options.dup
-      hash    = { :messages => {} }
-      hash[:js_tokenizer] = options[:js_tokenizer] if options[:js_tokenizer]
-      hash[:allow_blank]  = true if options[:allow_blank]
-
-      self.class::MESSAGES.each do |option, message_type|
-        if count = options[option]
-          options[:message] = options[message_type]
-          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
-
-      hash
-    end
-
-  end
-end
-

data/lib/client_side_validations/mongoid/middleware.rb

@@ -1,20 +0,0 @@
-module ClientSideValidations::Mongoid
-  class Middleware
-
-    # Still need to handle embedded documents
-    def self.is_unique?(klass, attribute, value, params)
-      if params[:case_sensitive] == 'false'
-        value = Regexp.new("^#{Regexp.escape(value.to_s)}$", Regexp::IGNORECASE)
-      end
-
-      criteria = klass.where(attribute => value)
-      criteria = criteria.where(:_id => {'$ne' => BSON::ObjectId(params[:id])}) if params[:id]
-
-      (params[:scope] || {}).each do |key, value|
-        criteria = criteria.where(key => value)
-      end
-
-      !criteria.exists?
-    end
-  end
-end

data/lib/client_side_validations/mongoid/presence.rb

@@ -1,10 +0,0 @@
-module ClientSideValidations::Mongoid
-  module Presence
-    private
-
-    def message_type
-      :blank
-    end
-  end
-end
-

data/lib/client_side_validations/mongoid/uniqueness.rb

@@ -1,29 +0,0 @@
-module ClientSideValidations::Mongoid
-  module Uniqueness
-    def client_side_hash(model, attribute)
-      hash = {}
-      hash[:message] = model.errors.generate_message(attribute, message_type, options.except(:scope))
-      hash[:case_sensitive] = options[:case_sensitive] if options.key?(: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|
-          scope_hash.merge!(scope_item => model.send(scope_item))
-        end
-      end
-
-      unless model.class.name.demodulize == model.class.name
-        hash[:class] = model.class.name.underscore
-      end
-
-      hash
-    end
-
-    private
-
-    def message_type
-      :taken
-    end
-  end
-end
-

data/lib/client_side_validations/simple_form.rb

@@ -1,24 +0,0 @@
-module ClientSideValidations
-  module SimpleForm
-    module FormBuilder
-
-      def self.included(base)
-        base.class_eval do
-          def self.client_side_form_settings(options, form_helper)
-            {
-              :type => self.to_s,
-              :error_class => ::SimpleForm.error_class,
-              :error_tag => ::SimpleForm.error_tag,
-              :wrapper_error_class => ::SimpleForm.wrapper_error_class,
-              :wrapper_tag => ::SimpleForm.wrapper_tag
-            }
-          end
-        end
-      end
-
-    end
-  end
-end
-
-SimpleForm::FormBuilder.send(:include, ClientSideValidations::SimpleForm::FormBuilder)
-

data/lib/generators/templates/client_side_validations/README.rails.3.0

@@ -1,6 +0,0 @@
-*********************
-ClientSideValidations
-*********************
-
-Client Side Validations only works with jQuery.
-You'll need to include jQuery in your layout file before you include 'rails.validations.js'

data/test/action_view/cases/helper.rb

@@ -1,176 +0,0 @@
-require 'base_helper'
-require 'action_view'
-require 'action_view/template'
-require 'action_view/models'
-require 'client_side_validations/action_view'
-
-module ActionController
-  class Base
-    include ActionDispatch::Routing::RouteSet.new.url_helpers
-  end
-end
-
-module ActionViewTestSetup
-  include ::ClientSideValidations::ActionView::Helpers::FormHelper
-  include ::ClientSideValidations::ActionView::Helpers::FormTagHelper
-
-  def form_for(*)
-    @output_buffer = super
-  end
-
-  Routes = ActionDispatch::Routing::RouteSet.new
-  Routes.draw do
-    resources :posts do
-      resources :comments
-    end
-  end
-
-  def _routes
-    Routes
-  end
-
-  include Routes.url_helpers
-
-  def setup
-    super
-
-    # Create "label" locale for testing I18n label helpers
-    I18n.backend.store_translations 'label', {
-      :activemodel => {
-        :attributes => {
-          :post => {
-            :cost => "Total cost"
-          }
-        }
-      },
-      :helpers => {
-        :label => {
-          :post => {
-            :body => "Write entire text here"
-          }
-        }
-      }
-    }
-
-    # Create "submit" locale for testing I18n submit helpers
-    I18n.backend.store_translations 'submit', {
-      :helpers => {
-        :submit => {
-          :create => 'Create %{model}',
-          :update => 'Confirm %{model} changes',
-          :submit => 'Save changes',
-          :another_post => {
-            :update => 'Update your %{model}'
-          }
-        }
-      }
-    }
-
-    @post = Post.new
-    @comment = Comment.new
-    def @post.errors()
-      Class.new{
-        def [](field); field == "author_name" ? ["can't be empty"] : [] end
-        def empty?() false end
-        def count() 1 end
-        def full_messages() [ "Author name can't be empty" ] end
-      }.new
-    end
-    def @post.id; 123; end
-    def @post.id_before_type_cast; 123; end
-    def @post.to_param; '123'; end
-
-    @post.persisted   = true
-    @post.title       = "Hello World"
-    @post.author_name = ""
-    @post.body        = "Back to the hill and over it again!"
-    @post.secret      = 1
-    @post.written_on  = Date.new(2004, 6, 15)
-
-    if defined?(ActionView::OutputFlow)
-      @view_flow        = ActionView::OutputFlow.new
-    else
-      @_content_for     = Hash.new { |h,k| h[k] = ActiveSupport::SafeBuffer.new }
-    end
-  end
-
-  def snowman(method = nil)
-    txt =  %{<div style="margin:0;padding:0;display:inline">}
-    txt << %{<input name="utf8" type="hidden" value="&#x2713;" />}
-    txt << %{<input name="_method" type="hidden" value="#{method}" />} if method
-    txt << %{</div>}
-  end
-
-  def form_text(action = "http://www.example.com", id = nil, html_class = nil, remote = nil, validators = nil, file = nil)
-    txt =  %{<form accept-charset="UTF-8" action="#{action}"}
-    txt << %{ data-remote="true"} if remote
-    txt << %{ class="#{html_class}"} if html_class
-    txt << %{ data-validate="true"} if validators
-    txt << %{ enctype="multipart/form-data"} if file
-    txt << %{ id="#{id}"} if id
-    txt << %{ method="post"}
-    txt << %{ novalidate="novalidate"} if validators
-    txt << %{>}
-  end
-
-  def whole_form(action = "http://www.example.com", id = nil, html_class = nil, options = nil)
-    contents = block_given? ? yield : ""
-
-    if options.is_a?(Hash)
-      method, remote, validators, file = options.values_at(:method, :remote, :validators, :file)
-    else
-      method = options
-    end
-
-    html = form_text(action, id, html_class, remote, validators, file) + snowman(method) + (contents || "") + "</form>"
-
-    if options.is_a?(Hash) && options[:validators]
-      build_script_tag(html, id, options[:validators])
-    else
-      html
-    end
-  end
-
-  def build_script_tag(html, id, validators)
-    (html || "") + %Q{<script>window['#{id}'] = #{client_side_form_settings_helper.merge(:validators => validators).to_json};</script>}
-  end
-
-  protected
-    def comments_path(post)
-      "/posts/#{post.id}/comments"
-    end
-    alias_method :post_comments_path, :comments_path
-
-    def comment_path(post, comment)
-      "/posts/#{post.id}/comments/#{comment.id}"
-    end
-    alias_method :post_comment_path, :comment_path
-
-    def admin_comments_path(post)
-      "/admin/posts/#{post.id}/comments"
-    end
-    alias_method :admin_post_comments_path, :admin_comments_path
-
-    def admin_comment_path(post, comment)
-      "/admin/posts/#{post.id}/comments/#{comment.id}"
-    end
-    alias_method :admin_post_comment_path, :admin_comment_path
-
-    def posts_path
-      "/posts"
-    end
-
-    def post_path(post, options = {})
-      if options[:format]
-        "/posts/#{post.id}.#{options[:format]}"
-      else
-        "/posts/#{post.id}"
-      end
-    end
-
-    def protect_against_forgery?
-      false
-    end
-
-end
-

data/test/action_view/cases/test_helpers.rb

@@ -1,635 +0,0 @@
-require 'action_view/cases/helper'
-
-class ClientSideValidations::ActionViewHelpersTest < ActionView::TestCase
-  include ActionViewTestSetup
-
-  cattr_accessor :field_error_proc
-  @@field_error_proc = Proc.new { |html_tag, instance| html_tag }
-
-  def client_side_form_settings_helper
-    {
-      :type => "ActionView::Helpers::FormBuilder",
-      :input_tag => %{<span id="input_tag" />},
-      :label_tag => %{<label id="label_tag" />}
-    }
-  end
-
-  def test_text_field
-    form_for(@post, :validate => true) do |f|
-      concat f.text_field(:cost)
-    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" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_password_field
-    form_for(@post, :validate => true) do |f|
-      concat f.password_field(:cost)
-    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="password" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_file_field
-    form_for(@post, :validate => true) do |f|
-      concat f.file_field(:cost)
-    end
-
-    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
-    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators, :file => true) do
-      %{<input data-validate="true" id="post_cost" name="post[cost]" type="file" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_text_area
-    form_for(@post, :validate => true) do |f|
-      concat f.text_area(:cost)
-    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
-      %{<textarea cols="40" data-validate="true" id="post_cost" name="post[cost]" rows="20"></textarea>}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_search_field
-    form_for(@post, :validate => true) do |f|
-      concat f.search_field(:cost)
-    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="search" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_telephone_field
-    form_for(@post, :validate => true) do |f|
-      concat f.telephone_field(:cost)
-    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="tel" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_phone_field
-    form_for(@post, :validate => true) do |f|
-      concat f.phone_field(:cost)
-    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="tel" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_url_field
-    form_for(@post, :validate => true) do |f|
-      concat f.url_field(:cost)
-    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="url" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_email_field
-    form_for(@post, :validate => true) do |f|
-      concat f.email_field(:cost)
-    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="email" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_number_field
-    form_for(@post, :validate => true) do |f|
-      concat f.number_field(:cost)
-    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="number" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_range_field
-    form_for(@post, :validate => true) do |f|
-      concat f.range_field(:cost)
-    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="range" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_check_box
-    form_for(@post, :validate => true) do |f|
-      concat f.check_box(:cost)
-    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 name="post[cost]" type="hidden" value="0" />} +
-      %{<input data-validate="true" id="post_cost" name="post[cost]" type="checkbox" value="1" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_radio_button
-    form_for(@post, :validate => true) do |f|
-      concat f.radio_button(:cost, "10")
-    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_10" name="post[cost]" type="radio" value="10" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_field_without_validations
-    form_for(@post, :validate => true) do |f|
-      concat f.text_field(:title)
-    end
-
-    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => {}) do
-      %{<input id="post_title" name="post[title]" size="30" type="text" value="Hello World" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_text_field_with_validations_turned_off
-    form_for(@post, :validate => true) do |f|
-      concat f.text_field(:cost, :validate => false)
-    end
-
-    expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => {}) do
-      %{<input id="post_cost" name="post[cost]" size="30" type="text" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_inherit_validation_settings
-    form_for(@post, :validate => true) do |f|
-      concat f.fields_for(:comment, @comment) { |c|
-        concat c.text_field(:title)
-      }
-    end
-
-    validators = {'post[comment][title]' => {: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_comment_title" name="post[comment][title]" size="30" type="text" />}
-    end
-
-    assert_equal expected, output_buffer
-  end
-
-  def test_nested_fields_for_dont_overwrite_validation_with_inheritance
-    form_for(@post, :validate => true) do |f|
-      concat f.fields_for(:comment, @comment, :validate => false) { |c|
-        concat c.text_field(:title)
-      }
-    end
-
-    expected =  whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => {}) do
-      %{<input id="post_comment_title" name="post[comment][title]" size="30" type="text" />}
-    end
-
-    assert_equal expected, output_buffer
-  end
-
-  def test_with_custom_id_for_form
-    form_for(@post, :validate => true, :html => { :id => 'some_form' }) do |f|
-      concat f.text_field(:cost)
-    end
-
-    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
-    expected = whole_form("/posts/123", "some_form", "edit_post", :method => "put", :validators => validators) do
-      %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="text" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_ignore_an_individual_validator
-    hash = {
-      :cost => {
-        :presence => {
-          :message => "can't be blank"
-        },
-        :format => {
-          :with => /.+/,
-          :message => "is invalid"
-        }
-      }
-    }
-    @post.stubs(:client_side_validation_hash).returns(hash)
-    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
-    form_for(@post, :validate => true) do |f|
-      concat f.text_field(:cost, :validate => { :format => false })
-    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" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_ignore_many_validators
-    hash = {
-      :cost => {
-        :presence => {
-          :message => "can't be blank"
-        },
-        :format => {
-          :with => /.+/,
-          :message => "is invalid"
-        }
-      }
-    }
-    @post.stubs(:client_side_validation_hash).returns(hash)
-    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
-    form_for(@post, :validate => true) do |f|
-      concat f.text_field(:cost, :validate => { :presence => false, :format => false })
-    end
-
-    validators = {}
-    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" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_select
-    form_for(@post, :validate => true) do |f|
-      concat f.select(:cost, [])
-    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
-      %{<select data-validate="true" id="post_cost" name="post[cost]"></select>}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_select_multiple
-    form_for(@post, :validate => true) do |f|
-      concat f.select(:cost, [], {}, :multiple => true)
-    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
-      %{<select data-validate="true" id="post_cost" multiple="multiple" name="post[cost][]"></select>}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_collection_select
-    form_for(@post, :validate => true) do |f|
-      concat f.collection_select(:cost, [], :id, :name)
-    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
-      %{<select data-validate="true" id="post_cost" name="post[cost]"></select>}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_grouped_collection_select
-    form_for(@post, :validate => true) do |f|
-      concat f.grouped_collection_select(:cost, [], :group_method, :group_label_method, :id, :name)
-    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
-      %{<select data-validate="true" id="post_cost" name="post[cost]"></select>}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_time_zone_select
-    zones = mock('TimeZones')
-    zones.stubs(:all).returns([])
-    form_for(@post, :validate => true) do |f|
-      concat f.time_zone_select(:cost, nil, :model => zones)
-    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
-      %{<select data-validate="true" id="post_cost" name="post[cost]"></select>}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_conditional_validators_should_be_filtered
-    hash = {
-      :cost => {
-        :presence => {
-          :message => "can't be blank",
-          :unless => :cannot_validate?
-        }
-      },
-      :title => {
-        :presence => {
-          :message => "can't be blank",
-          :if => :can_validate?
-        }
-      }
-    }
-
-    @post.title = nil
-    @post.stubs(:cannot_validate?).returns(false)
-    @post.stubs(:can_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 = {}
-    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 id="post_title" name="post[title]" size="30" type="text" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_conditional_validator_filters_being_forced
-    hash = {
-      :cost => {
-        :presence => {
-          :message => "can't be blank",
-          :unless => :cannot_validate?
-        }
-      },
-      :title => {
-        :presence => {
-          :message => "can't be blank",
-          :if => :can_validate?
-        }
-      }
-    }
-
-    @post.title = nil
-    @post.stubs(:cannot_validate?).returns(false)
-    @post.stubs(:can_validate?).returns(true)
-    @post.stubs(:client_side_validation_hash).returns(hash)
-    form_for(@post, :validate => true) do |f|
-      concat f.text_field(:cost, :validate => true)
-      concat f.text_field(:title, :validate => true)
-    end
-
-    validators = {
-      'post[cost]'  => {:presence => {:message => "can't be blank"}},
-      'post[title]' => {: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 data-validate="true" id="post_title" name="post[title]" size="30" type="text" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_conditional_validator_filters_being_forced_and_not_meeting_condition
-    hash = {
-      :cost => {
-        :presence => {
-          :message => "can't be blank",
-          :unless => :cannot_validate?
-        }
-      },
-      :title => {
-        :presence => {
-          :message => "can't be blank",
-          :if => :can_validate?
-        }
-      }
-    }
-
-    @post.title = nil
-    @post.stubs(:cannot_validate?).returns(true)
-    @post.stubs(:can_validate?).returns(false)
-    @post.stubs(:client_side_validation_hash).returns(hash)
-    form_for(@post, :validate => true) do |f|
-      concat f.text_field(:cost, :validate => true)
-      concat f.text_field(:title, :validate => true)
-    end
-
-    validators = {}
-    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 id="post_title" name="post[title]" size="30" type="text" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_conditional_validator_filters_being_forced_individually
-    hash = {
-      :cost => {
-        :presence => {
-          :message => "can't be blank",
-          :unless => :cannot_validate?
-        }
-      },
-      :title => {
-        :presence => {
-          :message => "can't be blank",
-          :if => :can_validate?
-        }
-      }
-    }
-
-    @post.title = nil
-    @post.stubs(:cannot_validate?).returns(false)
-    @post.stubs(:can_validate?).returns(true)
-    @post.stubs(:client_side_validation_hash).returns(hash)
-    form_for(@post, :validate => true) do |f|
-      concat f.text_field(:cost, :validate => { :presence => true })
-      concat f.text_field(:title, :validate => { :presence => true })
-    end
-
-    validators = {
-      'post[cost]'  => {:presence => {:message => "can't be blank"}},
-      'post[title]' => {: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 data-validate="true" id="post_title" name="post[title]" size="30" type="text" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_conditional_validator_filters_being_forced_and_not_meeting_condition_individually
-    hash = {
-      :cost => {
-        :presence => {
-          :message => "can't be blank",
-          :unless => :cannot_validate?
-        }
-      },
-      :title => {
-        :presence => {
-          :message => "can't be blank",
-          :if => :can_validate?
-        }
-      }
-    }
-
-    @post.title = nil
-    @post.stubs(:cannot_validate?).returns(true)
-    @post.stubs(:can_validate?).returns(false)
-    @post.stubs(:client_side_validation_hash).returns(hash)
-    form_for(@post, :validate => true) do |f|
-      concat f.text_field(:cost, :validate => { :presence => true })
-      concat f.text_field(:title, :validate => { :presence => true })
-    end
-
-    validators = {}
-    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 id="post_title" name="post[title]" size="30" type="text" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_conditional_validator_filters_being_forced_with_procs
-    hash = {
-      :cost => {
-        :presence => {
-          :message => "can't be blank",
-          :unless => Proc.new { |post| post.cannot_validate? }
-        }
-      },
-      :title => {
-        :presence => {
-          :message => "can't be blank",
-          :if => Proc.new { |post| post.can_validate? }
-        }
-      }
-    }
-
-    @post.title = nil
-    @post.stubs(:cannot_validate?).returns(false)
-    @post.stubs(:can_validate?).returns(true)
-    @post.stubs(:client_side_validation_hash).returns(hash)
-    form_for(@post, :validate => true) do |f|
-      concat f.text_field(:cost, :validate => true)
-      concat f.text_field(:title, :validate => true)
-    end
-
-    validators = {
-      'post[cost]'  => {:presence => {:message => "can't be blank"}},
-      'post[title]' => {: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 data-validate="true" id="post_title" name="post[title]" size="30" type="text" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_conditional_validator_ignored_when_using_changed_helpers
-    hash = {
-      :cost => {
-        :presence => {
-          :message => "can't be blank",
-          :unless => :cost_changed?
-        }
-      },
-      :title => {
-        :presence => {
-          :message => "can't be blank",
-          :if => :title_changed?
-        }
-      }
-    }
-
-    @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"}},
-      'post[title]' => {: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 data-validate="true" id="post_title" name="post[title]" size="30" type="text" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_conditional_validator_ignored_when_using_changed_helpers_and_forcing_validators
-    hash = {
-      :cost => {
-        :presence => {
-          :message => "can't be blank",
-          :unless => :cost_changed?
-        }
-      },
-      :title => {
-        :presence => {
-          :message => "can't be blank",
-          :if => :title_changed?
-        }
-      }
-    }
-
-    @post.title = nil
-    @post.stubs(:client_side_validation_hash).returns(hash)
-    form_for(@post, :validate => true) do |f|
-      concat f.text_field(:cost, :validate => true)
-      concat f.text_field(:title, :validate => true)
-    end
-
-    validators = {
-      'post[cost]'  => {:presence => {:message => "can't be blank"}},
-      'post[title]' => {: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 data-validate="true" id="post_title" name="post[title]" size="30" type="text" />}
-    end
-    assert_equal expected, output_buffer
-  end
-
-  def test_pushing_script_to_content_for
-    form_for(@post, :validate => :post) do |f|
-      concat f.text_field(:cost)
-    end
-
-    validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
-    expected = %{<form accept-charset="UTF-8" action="/posts/123" class="edit_post" data-validate="true" id="edit_post_123" method="post" novalidate="novalidate"><div style="margin:0;padding:0;display:inline"><input name="utf8" type="hidden" value="&#x2713;" /><input name="_method" type="hidden" value="put" /></div><input data-validate="true" id="post_cost" name="post[cost]" size="30" type="text" /></form>}
-    assert_equal expected, output_buffer
-    assert_equal build_script_tag(nil, "edit_post_123", validators), content_for(:post)
-  end
-end
-