├── .rvmrc
├── .gitignore
├── lib
    ├── client_side_validations
    │   ├── version.rb
    │   ├── core_ext.rb
    │   ├── active_model
    │   │   ├── format.rb
    │   │   ├── presence.rb
    │   │   ├── acceptance.rb
    │   │   ├── exclusion.rb
    │   │   ├── inclusion.rb
    │   │   ├── length.rb
    │   │   └── numericality.rb
    │   ├── core_ext
    │   │   ├── range.rb
    │   │   └── regexp.rb
    │   ├── mongoid.rb
    │   ├── action_view
    │   │   ├── form_tag_helper.rb
    │   │   ├── form_helper.rb
    │   │   └── form_builder.rb
    │   ├── active_record.rb
    │   ├── action_view.rb
    │   ├── formtastic.rb
    │   ├── mongoid
    │   │   ├── middleware.rb
    │   │   └── uniqueness.rb
    │   ├── simple_form.rb
    │   ├── active_record
    │   │   ├── uniqueness.rb
    │   │   └── middleware.rb
    │   ├── middleware.rb
    │   └── active_model.rb
    ├── generators
    │   ├── templates
    │   │   ├── README
    │   │   └── client_side_validations.rb
    │   └── client_side_validations
    │   │   └── install_generator.rb
    └── client_side_validations.rb
├── test
    ├── formtastic
    │   └── cases
    │   │   ├── helper.rb
    │   │   ├── test_form_builder.rb
    │   │   └── test_form_helper.rb
    ├── simple_form
    │   └── cases
    │   │   ├── helper.rb
    │   │   ├── test_form_builder.rb
    │   │   └── test_form_helper.rb
    ├── action_view
    │   ├── models.rb
    │   ├── models
    │   │   ├── post.rb
    │   │   └── comment.rb
    │   └── cases
    │   │   ├── helper.rb
    │   │   ├── test_legacy_helpers.rb
    │   │   └── test_helpers.rb
    ├── javascript
    │   ├── config.ru
    │   ├── public
    │   │   ├── test
    │   │   │   ├── validators
    │   │   │   │   ├── presence.js
    │   │   │   │   ├── confirmation.js
    │   │   │   │   ├── format.js
    │   │   │   │   ├── acceptance.js
    │   │   │   │   ├── exclusion.js
    │   │   │   │   ├── inclusion.js
    │   │   │   │   ├── length.js
    │   │   │   │   ├── uniqueness.js
    │   │   │   │   └── numericality.js
    │   │   │   ├── settings.js
    │   │   │   ├── callbacks
    │   │   │   │   ├── formAfter.js
    │   │   │   │   ├── formBefore.js
    │   │   │   │   ├── formPass.js
    │   │   │   │   ├── formFail.js
    │   │   │   │   ├── elementAfter.js
    │   │   │   │   ├── elementBefore.js
    │   │   │   │   ├── elementPass.js
    │   │   │   │   └── elementFail.js
    │   │   │   ├── form_builders
    │   │   │   │   ├── validateFormtastic.js
    │   │   │   │   ├── validateSimpleForm.js
    │   │   │   │   └── validateForm.js
    │   │   │   └── validateElement.js
    │   │   └── vendor
    │   │   │   ├── jquery.metadata.js
    │   │   │   └── qunit.css
    │   ├── views
    │   │   ├── index.erb
    │   │   └── layout.erb
    │   └── server.rb
    ├── base_helper.rb
    ├── active_model
    │   ├── cases
    │   │   ├── helper.rb
    │   │   ├── test_base.rb
    │   │   ├── test_presence_validator.rb
    │   │   ├── test_confirmation_validator.rb
    │   │   ├── test_acceptance_validator.rb
    │   │   ├── test_format_validator.rb
    │   │   ├── test_exclusion_validator.rb
    │   │   ├── test_inclusion_validator.rb
    │   │   ├── test_numericality_validator.rb
    │   │   ├── test_length_validator.rb
    │   │   └── test_validations.rb
    │   └── models
    │   │   └── person.rb
    ├── mongoid
    │   ├── models
    │   │   └── book.rb
    │   └── cases
    │   │   ├── helper.rb
    │   │   ├── test_base.rb
    │   │   ├── test_uniqueness_validator.rb
    │   │   └── test_middleware.rb
    ├── active_record
    │   ├── models
    │   │   ├── guid.rb
    │   │   └── user.rb
    │   └── cases
    │   │   ├── test_base.rb
    │   │   ├── helper.rb
    │   │   ├── test_uniqueness_validator.rb
    │   │   └── test_middleware.rb
    ├── middleware
    │   └── cases
    │   │   ├── test_middleware.rb
    │   │   └── helper.rb
    ├── generators
    │   └── cases
    │   │   └── test_install_generator.rb
    └── core_ext
    │   └── cases
    │       └── test_core_ext.rb
├── Gemfile
├── client_side_validations.gemspec
├── Rakefile
├── HISTORY
├── README.markdown
└── javascript
    └── rails.validations.js


/.rvmrc:
--------------------------------------------------------------------------------
1 | rvm --create use default@client_side_validations > /dev/null
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.gem
2 | .bundle
3 | Gemfile.lock
4 | pkg/*
5 | tags
6 | test/generators/tmp/*
7 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/version.rb:
--------------------------------------------------------------------------------
1 | module ClientSideValidations
2 |   VERSION = "3.0.4"
3 | end
4 | 


--------------------------------------------------------------------------------
/test/formtastic/cases/helper.rb:
--------------------------------------------------------------------------------
1 | require 'formtastic'
2 | require 'client_side_validations/formtastic'
3 | 


--------------------------------------------------------------------------------
/test/simple_form/cases/helper.rb:
--------------------------------------------------------------------------------
1 | require 'simple_form'
2 | require 'client_side_validations/simple_form'
3 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source "http://rubygems.org"
2 | 
3 | # Specify your gem's dependencies in client_side_validations.gemspec
4 | gemspec
5 | 


--------------------------------------------------------------------------------
/test/action_view/models.rb:
--------------------------------------------------------------------------------
1 | require 'active_model'
2 | require 'action_view/models/comment'
3 | require 'action_view/models/post'
4 | 


--------------------------------------------------------------------------------
/test/javascript/config.ru:
--------------------------------------------------------------------------------
1 | $LOAD_PATH.unshift File.expand_path('..', __FILE__)
2 | require 'server'
3 | run Sinatra::Application
4 | 


--------------------------------------------------------------------------------
/test/base_helper.rb:
--------------------------------------------------------------------------------
1 | require 'rubygems'
2 | require 'ruby-debug'
3 | require 'test/unit'
4 | require 'mocha'
5 | 
6 | module ClientSideValidations; end
7 | 


--------------------------------------------------------------------------------
/test/active_model/cases/helper.rb:
--------------------------------------------------------------------------------
1 | require 'base_helper'
2 | require 'active_model'
3 | require 'client_side_validations/active_model'
4 | require 'active_model/models/person'
5 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/core_ext.rb:
--------------------------------------------------------------------------------
1 | require 'active_support/json'
2 | require 'client_side_validations/core_ext/range'
3 | require 'client_side_validations/core_ext/regexp'
4 | 


--------------------------------------------------------------------------------
/test/mongoid/models/book.rb:
--------------------------------------------------------------------------------
1 | class Book
2 |   include Mongoid::Document
3 | 
4 |   field :age, :type => Integer
5 |   field :author_name, :type => String
6 |   field :author_email, :type => String
7 | end
8 | 
9 | 


--------------------------------------------------------------------------------
/test/active_record/models/guid.rb:
--------------------------------------------------------------------------------
1 | guids_table = %{CREATE TABLE guids (id INTEGER PRIMARY KEY, key text);}
2 | ActiveRecord::Base.connection.execute(guids_table)
3 | 
4 | class Guid < ActiveRecord::Base
5 | 
6 | end
7 | 
8 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/format.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveModel
 2 |   module Format
 3 |     private
 4 | 
 5 |     def message_type
 6 |       :invalid
 7 |     end
 8 |   end
 9 | end
10 | 
11 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/presence.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveModel
 2 |   module Presence
 3 |     private
 4 | 
 5 |     def message_type
 6 |       :blank
 7 |     end
 8 |   end
 9 | end
10 | 
11 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/core_ext/range.rb:
--------------------------------------------------------------------------------
 1 | class Range
 2 |   def as_json(options = nil)
 3 |     [first, last]
 4 |   end
 5 | 
 6 |   def to_json(options = nil)
 7 |     as_json(options).inspect
 8 |   end
 9 | end
10 | 
11 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/acceptance.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveModel
 2 |   module Acceptance
 3 |     private
 4 | 
 5 |     def message_type
 6 |       :accepted
 7 |     end
 8 |   end
 9 | end
10 | 
11 | 


--------------------------------------------------------------------------------
/lib/generators/templates/README:
--------------------------------------------------------------------------------
1 | **************************************
2 | Client Side Validations
3 | 
4 | Currently Client Side Validations only
5 | works with jQuery. You'll need to require
6 | jQuery in your layout file before you 
7 | require 'rails.validations.js'
8 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_base.rb:
--------------------------------------------------------------------------------
 1 | require 'active_model/cases/helper'
 2 | 
 3 | class ClientSideValidations::ActiveModelTestBase < ActiveModel::TestCase
 4 |   include ActiveModel::Validations
 5 | 
 6 |   def setup
 7 |     @person = Person.new
 8 |   end
 9 | 
10 | end
11 | 
12 | 


--------------------------------------------------------------------------------
/test/active_record/cases/test_base.rb:
--------------------------------------------------------------------------------
 1 | require 'active_record/cases/helper'
 2 | 
 3 | class ClientSideValidations::ActiveRecordTestBase < ActiveRecord::TestCase
 4 |   include ActiveRecord::Validations
 5 | 
 6 |   def setup
 7 |     @user = User.new
 8 |   end
 9 | 
10 | end
11 | 
12 | 


--------------------------------------------------------------------------------
/test/middleware/cases/test_middleware.rb:
--------------------------------------------------------------------------------
1 | require 'middleware/cases/helper'
2 | 
3 | class ClientSideValidationsMiddleWareTest < Test::Unit::TestCase
4 |   def test_if_middleware_is_auto_included
5 |     assert Rails.configuration.middleware.include?(ClientSideValidations::Middleware::Validators)
6 |   end
7 | end
8 | 
9 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/exclusion.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveModel
 2 |   module Exclusion
 3 | 
 4 |     def client_side_hash(model, attribute)
 5 |       hash = super
 6 |       if hash[:in].is_a?(Range)
 7 |         hash[:range] = hash[:in]
 8 |         hash.delete(:in)
 9 |       end
10 |       hash
11 |     end
12 | 
13 |   end
14 | end
15 | 
16 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/inclusion.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveModel
 2 |   module Inclusion
 3 | 
 4 |     def client_side_hash(model, attribute)
 5 |       hash = super
 6 |       if hash[:in].is_a?(Range)
 7 |         hash[:range] = hash[:in]
 8 |         hash.delete(:in)
 9 |       end
10 |       hash
11 |     end
12 | 
13 |   end
14 | end
15 | 
16 | 


--------------------------------------------------------------------------------
/test/active_record/models/user.rb:
--------------------------------------------------------------------------------
 1 | users_table = %{CREATE TABLE users (id INTEGER PRIMARY KEY, age INTEGER, name TEXT, email TEXT, title VARCHAR(5));}
 2 | ActiveRecord::Base.connection.execute(users_table)
 3 | 
 4 | class User < ActiveRecord::Base
 5 | 
 6 | end
 7 | 
 8 | class IneptWizard < User; end
 9 | class Conjurer < IneptWizard; end
10 | class Thaumaturgist < Conjurer; end
11 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/core_ext/regexp.rb:
--------------------------------------------------------------------------------
 1 | class Regexp
 2 |   def as_json(options = nil)
 3 |     Regexp.new inspect.sub("\\A","^").sub("\\Z","$").sub("\\z","$").sub(/^\//,"").sub(/\/[a-z]*$/,""), self.options
 4 |   end
 5 | 
 6 |   def to_json(options = nil)
 7 |     as_json(options).inspect
 8 |   end
 9 | 
10 |   def encode_json(encoder)
11 |     inspect
12 |   end
13 | end
14 | 
15 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/mongoid.rb:
--------------------------------------------------------------------------------
 1 | require 'client_side_validations/active_model'
 2 | require 'client_side_validations/mongoid/middleware'
 3 | 
 4 | %w{uniqueness}.each do |validator|
 5 |   require "client_side_validations/mongoid/#{validator}"
 6 |   validator.capitalize!
 7 |   eval "Mongoid::Validations::#{validator}Validator.send(:include, ClientSideValidations::Mongoid::#{validator})"
 8 | end
 9 | 
10 | 


--------------------------------------------------------------------------------
/lib/client_side_validations.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations
 2 | end
 3 | 
 4 | require 'client_side_validations/active_model' if defined?(::ActiveModel)
 5 | require 'client_side_validations/active_record' if defined?(::ActiveRecord)
 6 | require 'client_side_validations/mongoid' if defined?(::Mongoid)
 7 | require 'client_side_validations/action_view'
 8 | require 'client_side_validations/middleware' if defined?(::Rails)
 9 | 
10 | 


--------------------------------------------------------------------------------
/test/active_record/cases/helper.rb:
--------------------------------------------------------------------------------
 1 | require 'base_helper'
 2 | require 'active_record'
 3 | require 'client_side_validations/active_record'
 4 | 
 5 | # Connection must be establised before anything else
 6 | ActiveRecord::Base.establish_connection(
 7 |   :adapter => defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3',
 8 |   :database => ':memory:'
 9 | )
10 | 
11 | require 'active_record/models/user'
12 | require 'active_record/models/guid'
13 | 


--------------------------------------------------------------------------------
/test/active_model/models/person.rb:
--------------------------------------------------------------------------------
 1 | class PersonValidator < ActiveModel::Validator
 2 |   def validate(record)
 3 |   end
 4 | end
 5 | 
 6 | class Person
 7 |   include ActiveModel::Validations
 8 | 
 9 |   attr_accessor :first_name, :last_name, :email, :age
10 | 
11 |   validates_presence_of :first_name
12 |   validates_format_of :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
13 | 
14 |   def new_record?
15 |     true
16 |   end
17 | end
18 | 


--------------------------------------------------------------------------------
/test/middleware/cases/helper.rb:
--------------------------------------------------------------------------------
 1 | require 'base_helper'
 2 | require 'rails'
 3 | 
 4 | # Pulled from railties/test/abstract_unit in Rails 3.1
 5 | module TestApp
 6 |   class Application < Rails::Application
 7 |     config.root = File.dirname(__FILE__)
 8 |     config.active_support.deprecation = :log
 9 |     config.logger = Logger.new(STDOUT)
10 |   end
11 | end
12 | 
13 | require 'client_side_validations/middleware'
14 | 
15 | TestApp::Application.initialize!
16 | 


--------------------------------------------------------------------------------
/test/mongoid/cases/helper.rb:
--------------------------------------------------------------------------------
 1 | require 'base_helper'
 2 | require 'mongoid'
 3 | require 'client_side_validations/mongoid'
 4 | 
 5 | Mongoid.configure do |config|
 6 |   name = "client_side_validations_development"
 7 |   host = "localhost"
 8 |   config.master = Mongo::Connection.new.db(name)
 9 |   config.slaves = [
10 |     Mongo::Connection.new(host).db(name)
11 |   ]
12 |   config.persist_in_safe_mode = false
13 | end
14 | 
15 | require 'mongoid/models/book'
16 | 
17 | 


--------------------------------------------------------------------------------
/test/formtastic/cases/test_form_builder.rb:
--------------------------------------------------------------------------------
 1 | require 'formtastic/cases/helper'
 2 | 
 3 | class ClientSideValidations::Formtastic::SemanticFormBuilderTest < Test::Unit::TestCase
 4 |   def test_client_side_form_js_hash
 5 |     expected = {
 6 |       :type => 'Formtastic::SemanticFormBuilder',
 7 |       :inline_error_class => 'inline-errors'
 8 |     }
 9 |     assert_equal expected, Formtastic::SemanticFormBuilder.client_side_form_settings(nil, nil)
10 |   end
11 | end
12 | 


--------------------------------------------------------------------------------
/test/mongoid/cases/test_base.rb:
--------------------------------------------------------------------------------
 1 | require 'mongoid/cases/helper'
 2 | 
 3 | class ClientSideValidations::MongoidTestBase < Test::Unit::TestCase
 4 |   include Mongoid::Validations
 5 | 
 6 |   def setup
 7 |     @book = Book.new
 8 |   end
 9 | 
10 |   def test_uniqueness_client_side_hash
11 |     expected_hash = { :message => "is already taken" }
12 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name]).client_side_hash(@book, :age)
13 |   end
14 | end
15 | 
16 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/action_view/form_tag_helper.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActionView::Helpers
 2 |   module FormTagHelper
 3 |     private
 4 |       def html_options_for_form(url_for_options, options, *parameters_for_url)
 5 |         options.stringify_keys!
 6 |         html_options = {}
 7 |         html_options['data-validate'] = options.delete('validate') if options['validate']
 8 |         html_options.merge!(super(url_for_options, options, *parameters_for_url))
 9 |       end
10 |   end
11 | end
12 | 
13 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_record.rb:
--------------------------------------------------------------------------------
 1 | require 'client_side_validations/active_model'
 2 | require 'client_side_validations/active_record/middleware'
 3 | 
 4 | %w{uniqueness}.each do |validator|
 5 |   require "client_side_validations/active_record/#{validator}"
 6 |   validator.capitalize!
 7 |   eval "ActiveRecord::Validations::#{validator}Validator.send(:include, ClientSideValidations::ActiveRecord::#{validator})"
 8 | end
 9 | 
10 | ActiveRecord::Base.send(:include, ClientSideValidations::ActiveModel::Validations)
11 | 
12 | 


--------------------------------------------------------------------------------
/test/simple_form/cases/test_form_builder.rb:
--------------------------------------------------------------------------------
 1 | require 'simple_form/cases/helper'
 2 | 
 3 | class ClientSideValidations::SimpleForm::FormBuilderTest < Test::Unit::TestCase
 4 |   def test_client_side_form_js_hash
 5 |     expected = {
 6 |       :type => 'SimpleForm::FormBuilder',
 7 |       :error_class => :error,
 8 |       :error_tag => :span,
 9 |       :wrapper_error_class => :field_with_errors,
10 |       :wrapper_tag => :div
11 |     }
12 |     assert_equal expected, SimpleForm::FormBuilder.client_side_form_settings(nil, nil)
13 |   end
14 | end
15 | 


--------------------------------------------------------------------------------
/test/generators/cases/test_install_generator.rb:
--------------------------------------------------------------------------------
 1 | require 'rails/generators/test_case'
 2 | require 'generators/client_side_validations/install_generator'
 3 | 
 4 | class InstallGeneratorTest < Rails::Generators::TestCase
 5 |   tests ClientSideValidations::Generators::InstallGenerator
 6 |   destination File.expand_path('../../tmp', __FILE__)
 7 |   setup :prepare_destination
 8 | 
 9 |   test 'Assert all files are properly created' do
10 |     run_generator
11 |     assert_file 'config/initializers/client_side_validations.rb'
12 |     assert_file 'public/javascripts/rails.validations.js'
13 |   end
14 | end
15 | 
16 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/action_view.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActionView
 2 |   module Helpers
 3 |   end
 4 | end
 5 | 
 6 | require "client_side_validations/action_view/form_helper"
 7 | require "client_side_validations/action_view/form_tag_helper"
 8 | require "client_side_validations/action_view/form_builder"
 9 | 
10 | ActionView::Base.send(:include, ClientSideValidations::ActionView::Helpers::FormHelper)
11 | ActionView::Base.send(:include, ClientSideValidations::ActionView::Helpers::FormTagHelper)
12 | ActionView::Helpers::FormBuilder.send(:include, ClientSideValidations::ActionView::Helpers::FormBuilder)
13 | 
14 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/presence.js:
--------------------------------------------------------------------------------
 1 | module('Presence options');
 2 | 
 3 | test('when value is not empty', function() {
 4 |   var element = $('<input type="text" />');
 5 |   var options = { message: "failed validation" };
 6 |   element.val('not empty');
 7 |   equal(clientSideValidations.validators.local.presence(element, options), undefined);
 8 | });
 9 | 
10 | test('when value is empty', function() {
11 |   var element = $('<input type="text" />');
12 |   var options = { message: "failed validation" };
13 |   equal(clientSideValidations.validators.local.presence(element, options), "failed validation");
14 | });
15 | 
16 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/settings.js:
--------------------------------------------------------------------------------
 1 | // hijacks normal form submit; lets it submit to an iframe to prevent
 2 | // navigating away from the test suite
 3 | $(document).bind('submit', function(e) {
 4 |   if (!e.isDefaultPrevented()) {
 5 |     var form = $(e.target), action = form.attr('action'),
 6 |         name = 'form-frame' + jQuery.guid++,
 7 |         iframe = $('<iframe name="' + name + '" />');
 8 | 
 9 |     if (action.indexOf('iframe') < 0) form.attr('action', action + '?iframe=true')
10 |     form.attr('target', name);
11 |     $('#qunit-fixture').append(iframe);
12 |     form.trigger('iframe:loading');
13 |   }
14 | });
15 | 
16 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/formtastic.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations
 2 |   module Formtastic
 3 |     module SemanticFormBuilder
 4 | 
 5 |       def self.included(base)
 6 |         base.class_eval do
 7 |           def self.client_side_form_settings(options, form_helper)
 8 |             {
 9 |               :type => self.to_s,
10 |               :inline_error_class => ::Formtastic::SemanticFormBuilder.default_inline_error_class
11 |             }
12 |           end
13 |         end
14 |       end
15 | 
16 |     end
17 |   end
18 | end
19 | 
20 | Formtastic::SemanticFormBuilder.send(:include, ClientSideValidations::Formtastic::SemanticFormBuilder)
21 | 
22 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_presence_validator.rb:
--------------------------------------------------------------------------------
 1 | require 'active_model/cases/test_base'
 2 | 
 3 | class ActiveModel::InclusionValidatorTest < ClientSideValidations::ActiveModelTestBase
 4 | 
 5 |   def test_presence_client_side_hash
 6 |     expected_hash = { :message => "can't be blank" }
 7 |     assert_equal expected_hash, PresenceValidator.new(:attributes => [:name]).client_side_hash(@person, :age)
 8 |   end
 9 | 
10 |   def test_presence_client_side_hash_with_custom_message
11 |     expected_hash = { :message => "is required" }
12 |     assert_equal expected_hash, PresenceValidator.new(:attributes => [:name], :message => "is required").client_side_hash(@person, :age)
13 |   end
14 | 
15 | end
16 | 
17 | 


--------------------------------------------------------------------------------
/test/javascript/views/index.erb:
--------------------------------------------------------------------------------
 1 | <% @title = "client-side-validations test" %>
 2 | 
 3 | <%= test_base %>
 4 | <%= script_tag 'validateElement' %>
 5 | <%= test :validators, :form_builders, :callbacks %>
 6 | 
 7 | <h1 id="qunit-header"><%= @title %></h1>
 8 | <div id="jquery-version">
 9 |   jQuery version:
10 |   <% %w{1.4.1 1.4.2 1.4.3 1.4.4 1.5 1.5.1 1.6}.each do |version| %>
11 |     <%= jquery_link version %> •
12 |   <% end %>
13 |   <%= jquery_link 'edge' if File.exist?(settings.root + '/public/vendor/jquery.js') %>
14 | </div>
15 | <h2 id="qunit-banner"></h2>
16 | <div id="qunit-testrunner-toolbar"></div>
17 | <h2 id="qunit-userAgent"></h2>
18 | <ol id="qunit-tests"></ol>
19 | 
20 | <div id="qunit-fixture"></div>
21 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/mongoid/middleware.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::Mongoid
 2 |   class Middleware
 3 | 
 4 |     # Still need to handle embedded documents
 5 |     def self.is_unique?(klass, attribute, value, params)
 6 |       if params[:case_sensitive] == 'false'
 7 |         value = Regexp.new("^#{Regexp.escape(value.to_s)}$", Regexp::IGNORECASE)
 8 |       end
 9 | 
10 |       criteria = klass.where(attribute => value)
11 |       criteria = criteria.where(:_id => {'$ne' => BSON::ObjectId(params[:id])}) if params[:id]
12 | 
13 |       (params[:scope] || {}).each do |key, value|
14 |         criteria = criteria.where(key => value)
15 |       end
16 | 
17 |       !criteria.exists?
18 |     end
19 |   end
20 | end
21 | 


--------------------------------------------------------------------------------
/test/javascript/views/layout.erb:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html id="html">
 3 |   <head>
 4 |     <title><%= @title %></title>
 5 |     <link href="/vendor/qunit.css" media="screen" rel="stylesheet" type="text/css" media="screen, projection" />
 6 |     <style>
 7 |       #jquery-version {
 8 |         color: #8699A4; text-align: right; font-family: sans-serif; line-height: 1;
 9 |         margin-top: -1.8em; padding: 0 2em .8em 0;
10 |       }
11 |       #jquery-version a { color: white; text-decoration: underline; }
12 |     </style>
13 | 
14 |     <%= script_tag jquery_src %>
15 |     <%= script_tag "/javascript/rails.validations.js" %>
16 |   </head>
17 | 
18 |   <body id="body">
19 |     <%= yield %>
20 |   </body>
21 | </html>
22 | 


--------------------------------------------------------------------------------
/lib/generators/templates/client_side_validations.rb:
--------------------------------------------------------------------------------
 1 | # ClientSideValidations Initializer
 2 | 
 3 | require 'client_side_validations/simple_form' if defined?(::SimpleForm)
 4 | require 'client_side_validations/formtastic' if defined?(::Formtastic)
 5 | 
 6 | # Uncomment the following block if you want each input field to have the validation messages attached.
 7 | # ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
 8 | #   unless html_tag =~ /^<label/
 9 | #     %{<div class="field_with_errors">#{html_tag}<label for="#{instance.send(:tag_id)}" class="message">#{instance.error_message.first}</label></div>}.html_safe
10 | #   else
11 | #     %{<div class="field_with_errors">#{html_tag}</div>}.html_safe
12 | #   end
13 | # end
14 | 
15 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_confirmation_validator.rb:
--------------------------------------------------------------------------------
 1 | require 'active_model/cases/test_base'
 2 | 
 3 | class ActiveModel::ConfirmationValidatorTest < ClientSideValidations::ActiveModelTestBase
 4 | 
 5 |   def test_confirmation_client_side_hash
 6 |     expected_hash = { :message => "doesn't match confirmation" }
 7 |     assert_equal expected_hash, ConfirmationValidator.new(:attributes => [:name]).client_side_hash(@person, :age)
 8 |   end
 9 | 
10 |   def test_confirmation_client_side_hash_with_custom_message
11 |     expected_hash = { :message => "you must confirm" }
12 |     assert_equal expected_hash, ConfirmationValidator.new(:attributes => [:name], :message => "you must confirm").client_side_hash(@person, :age)
13 |   end
14 | 
15 | end
16 | 
17 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_acceptance_validator.rb:
--------------------------------------------------------------------------------
 1 | require 'active_model/cases/test_base'
 2 | 
 3 | class ActiveModel::AcceptanceValidatorTest < ClientSideValidations::ActiveModelTestBase
 4 | 
 5 |   def test_acceptance_client_side_hash
 6 |     expected_hash = { :message => "must be accepted", :accept => "1" }
 7 |     assert_equal expected_hash, AcceptanceValidator.new(:attributes => [:name]).client_side_hash(@person, :age)
 8 |   end
 9 | 
10 |   def test_acceptance_client_side_hash_with_custom_message
11 |     expected_hash = { :message => "you must accept", :accept => "1" }
12 |     assert_equal expected_hash, AcceptanceValidator.new(:attributes => [:name], :message => "you must accept").client_side_hash(@person, :age)
13 |   end
14 | 
15 | end
16 | 
17 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/simple_form.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations
 2 |   module SimpleForm
 3 |     module FormBuilder
 4 | 
 5 |       def self.included(base)
 6 |         base.class_eval do
 7 |           def self.client_side_form_settings(options, form_helper)
 8 |             {
 9 |               :type => self.to_s,
10 |               :error_class => ::SimpleForm.error_class,
11 |               :error_tag => ::SimpleForm.error_tag,
12 |               :wrapper_error_class => ::SimpleForm.wrapper_error_class,
13 |               :wrapper_tag => ::SimpleForm.wrapper_tag
14 |             }
15 |           end
16 |         end
17 |       end
18 | 
19 |     end
20 |   end
21 | end
22 | 
23 | SimpleForm::FormBuilder.send(:include, ClientSideValidations::SimpleForm::FormBuilder)
24 | 
25 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_record/uniqueness.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveRecord
 2 |   module Uniqueness
 3 |     def client_side_hash(model, attribute)
 4 |       hash = {}
 5 |       hash[:message] = model.errors.generate_message(attribute, message_type, options.except(:scope))
 6 |       hash[:case_sensitive] = options[:case_sensitive]
 7 |       hash[:id] = model.id unless model.new_record?
 8 |       if options.key?(:scope) && options[:scope].present?
 9 |         hash[:scope] = Array.wrap(options[:scope]).inject({}) do |scope_hash, scope_item|
10 |           scope_hash.merge!(scope_item => model.send(scope_item))
11 |         end
12 |       end
13 |       hash
14 |     end
15 | 
16 |     private
17 | 
18 |     def message_type
19 |       :taken
20 |     end
21 |   end
22 | end
23 | 
24 | 


--------------------------------------------------------------------------------
/lib/generators/client_side_validations/install_generator.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations
 2 |   module Generators
 3 |     class InstallGenerator < Rails::Generators::Base
 4 |       source_root File.expand_path('../../templates', __FILE__)
 5 | 
 6 |       desc 'Creates a ClientSideValidations initializer and copies client-side-validations.js to public/javascripts.'
 7 | 
 8 |       def copy_initializer
 9 |         copy_file 'client_side_validations.rb', 'config/initializers/client_side_validations.rb'
10 |       end
11 | 
12 |       def copy_locale
13 |         copy_file '../../../javascript/rails.validations.js', 'public/javascripts/rails.validations.js'
14 |       end
15 | 
16 |       def show_readme
17 |         readme 'README' if behavior == :invoke
18 |       end
19 |     end
20 |   end
21 | end
22 | 
23 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/mongoid/uniqueness.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::Mongoid
 2 |   module Uniqueness
 3 |     def client_side_hash(model, attribute)
 4 |       hash = {}
 5 |       hash[:message] = model.errors.generate_message(attribute, message_type, options.except(:scope))
 6 |       hash[:case_sensitive] = options[:case_sensitive] if options.key?(:case_sensitive)
 7 |       hash[:id] = model.id unless model.new_record?
 8 |       if options.key?(:scope) && options[:scope].present?
 9 |         hash[:scope] = Array.wrap(options[:scope]).inject({}) do |scope_hash, scope_item|
10 |           scope_hash.merge!(scope_item => model.send(scope_item))
11 |         end
12 |       end
13 |       hash
14 |     end
15 | 
16 |     private
17 | 
18 |     def message_type
19 |       :taken
20 |     end
21 |   end
22 | end
23 | 
24 | 


--------------------------------------------------------------------------------
/test/action_view/models/post.rb:
--------------------------------------------------------------------------------
 1 | class Post < Struct.new(:title, :author_name, :body, :secret, :written_on, :cost)
 2 |   extend ActiveModel::Naming
 3 |   include ActiveModel::Conversion
 4 |   extend ActiveModel::Translation
 5 | 
 6 |   alias_method :secret?, :secret
 7 | 
 8 |   def persisted=(boolean)
 9 |     @persisted = boolean
10 |   end
11 | 
12 |   def persisted?
13 |     @persisted
14 |   end
15 | 
16 |   def client_side_validation_hash
17 |     {
18 |       :cost => {
19 |         :presence => {
20 |           :message => "can't be blank"
21 |         }
22 |       }
23 |     }
24 |   end
25 | 
26 |   attr_accessor :author
27 |   def author_attributes=(attributes); end
28 | 
29 |   attr_accessor :comments, :comment_ids
30 |   def comments_attributes=(attributes); end
31 | 
32 |   attr_accessor :tags
33 |   def tags_attributes=(attributes); end
34 | end
35 | 
36 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/length.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveModel
 2 |   module Length
 3 | 
 4 |     def client_side_hash(model, attribute)
 5 |       options = self.options.dup
 6 |       hash    = { :messages => {} }
 7 |       hash[:js_tokenizer] = options[:js_tokenizer] if options[:js_tokenizer]
 8 |       hash[:allow_blank]  = true if options[:allow_blank]
 9 | 
10 |       self.class::MESSAGES.each do |option, message_type|
11 |         if count = options[option]
12 |           options[:message] = options[message_type]
13 |           options.delete(:message) if options[:message].nil?
14 |           hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(:count => count))
15 |           hash[option] = count
16 |         end
17 |       end
18 | 
19 |       hash
20 |     end
21 | 
22 |   end
23 | end
24 | 
25 | 


--------------------------------------------------------------------------------
/test/action_view/models/comment.rb:
--------------------------------------------------------------------------------
 1 | class Comment
 2 |   extend ActiveModel::Naming
 3 |   include ActiveModel::Conversion
 4 |   include ActiveModel::Validations
 5 | 
 6 |   attr_reader :id
 7 |   attr_reader :post_id
 8 |   attr_reader :title
 9 | 
10 |   validates_presence_of :title
11 | 
12 |   def initialize(id = nil, post_id = nil); @id, @post_id = id, post_id end
13 |   def to_key; id ? [id] : nil end
14 |   def save; @id = 1; @post_id = 1 end
15 |   def persisted?; @id.present? end
16 |   def to_param; @id; end
17 |   def name
18 |     @id.nil? ? "new #{self.class.name.downcase}" : "#{self.class.name.downcase} ##{@id}"
19 |   end
20 | 
21 |   attr_accessor :relevances
22 |   def relevances_attributes=(attributes); end
23 | 
24 |   def client_side_validation_hash
25 |     {
26 |       :title => {
27 |         :presence => {
28 |           :message => "can't be blank"
29 |         }
30 |       }
31 |     }
32 |   end
33 | 
34 | end
35 | 
36 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_format_validator.rb:
--------------------------------------------------------------------------------
 1 | require 'active_model/cases/test_base'
 2 | 
 3 | class ActiveModel::FormatValidatorTest < ClientSideValidations::ActiveModelTestBase
 4 | 
 5 |   def test_format_client_side_hash
 6 |     expected_hash = { :message => "is invalid", :with => /.+/ }
 7 |     assert_equal expected_hash, FormatValidator.new(:attributes => [:name], :with => /.+/).client_side_hash(@person, :age)
 8 |   end
 9 | 
10 |   def test_format_client_side_hash_without
11 |     expected_hash = { :message => "is invalid", :without => /.+/ }
12 |     assert_equal expected_hash, FormatValidator.new(:attributes => [:name], :without => /.+/).client_side_hash(@person, :age)
13 |   end
14 | 
15 |   def test_format_client_side_hash_with_custom_message
16 |     expected_hash = { :message => "is wrong format", :with => /.+/ }
17 |     assert_equal expected_hash, FormatValidator.new(:attributes => [:name], :with => /.+/, :message => "is wrong format").client_side_hash(@person, :age)
18 |   end
19 | 
20 | end
21 | 
22 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_exclusion_validator.rb:
--------------------------------------------------------------------------------
 1 | require 'active_model/cases/test_base'
 2 | 
 3 | class ActiveModel::ExclusionValidatorTest < ClientSideValidations::ActiveModelTestBase
 4 | 
 5 |   def test_exclusion_client_side_hash
 6 |     expected_hash = { :message => "is reserved", :in => [1, 2] }
 7 |     assert_equal expected_hash, ExclusionValidator.new(:attributes => [:name], :in => [1, 2]).client_side_hash(@person, :age)
 8 |   end
 9 | 
10 |   def test_exclusion_client_side_hash_with_custom_message
11 |     expected_hash = { :message => "is exclusive", :in => [1, 2] }
12 |     assert_equal expected_hash, ExclusionValidator.new(:attributes => [:name], :in => [1, 2], :message => "is exclusive").client_side_hash(@person, :age)
13 |   end
14 | 
15 |   def test_exclusion_client_side_hash_with_ranges
16 |     expected_hash = { :message => "is reserved", :range => 1..2 }
17 |     assert_equal expected_hash, ExclusionValidator.new(:attributes => [:name], :in => 1..2).client_side_hash(@person, :age)
18 |   end
19 | end
20 | 
21 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_inclusion_validator.rb:
--------------------------------------------------------------------------------
 1 | require 'active_model/cases/test_base'
 2 | 
 3 | class ActiveModel::InclusionValidatorTest < ClientSideValidations::ActiveModelTestBase
 4 | 
 5 |   def test_inclusion_client_side_hash
 6 |     expected_hash = { :message => "is not included in the list", :in => [1, 2] }
 7 |     assert_equal expected_hash, InclusionValidator.new(:attributes => [:name], :in => [1, 2]).client_side_hash(@person, :age)
 8 |   end
 9 | 
10 |   def test_inclusion_client_side_hash_with_custom_message
11 |     expected_hash = { :message => "is not a choice", :in => [1, 2] }
12 |     assert_equal expected_hash, InclusionValidator.new(:attributes => [:name], :in => [1, 2], :message => "is not a choice").client_side_hash(@person, :age)
13 |   end
14 | 
15 |   def test_inclusion_client_side_hash_with_range
16 |     expected_hash = { :message => "is not included in the list", :range => 1..2 }
17 |     assert_equal expected_hash, InclusionValidator.new(:attributes => [:name], :in => 1..2).client_side_hash(@person, :age)
18 |   end
19 | 
20 | end
21 | 
22 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/numericality.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveModel
 2 |   module Numericality
 3 | 
 4 |     OPTION_MAP = {}
 5 | 
 6 |     def self.included(base)
 7 |       OPTION_MAP.merge!(base::CHECKS.keys.inject({}) { |hash, key| hash.merge!(key => key) })
 8 |     end
 9 | 
10 |     def client_side_hash(model, attribute)
11 |       options = self.options.dup
12 |       hash    = { :messages => { :numericality => model.errors.generate_message(attribute, :not_a_number, options) } }
13 | 
14 |       if options[:only_integer]
15 |         hash[:messages][:only_integer] = model.errors.generate_message(attribute, :not_an_integer, options)
16 |         hash[:only_integer] = true
17 |       end
18 | 
19 |       OPTION_MAP.each do |option, message_type|
20 |         if count = options[option]
21 |           hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(:count => count))
22 |           hash[option] = count
23 |         end
24 |       end
25 | 
26 |       hash
27 |     end
28 | 
29 |   end
30 | end
31 | 
32 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/confirmation.js:
--------------------------------------------------------------------------------
 1 | module('Confirmation options', {
 2 |   setup: function() {
 3 |     $('#qunit-fixture')
 4 |       .append('<input id="password" type="password" />')
 5 |       .append('<input id="password_confirmation" type="password" />')
 6 |   }
 7 | });
 8 | 
 9 | test('when values match', function() {
10 |   var password_element = $('#password');
11 |   var password_confirmation_element = $('#password_confirmation');
12 |   var options = { message: "failed validation" };
13 |   password_element.val('test');
14 |   password_confirmation_element.val('test');
15 |   equal(clientSideValidations.validators.local.confirmation(password_element, options), undefined);
16 | });
17 | 
18 | test('when values match', function() {
19 |   var password_element = $('#password');
20 |   var password_confirmation_element = $('#password_confirmation');
21 |   var options = { message: "failed validation" };
22 |   password_element.val('test');
23 |   password_confirmation_element.val('bad test');
24 |   equal(clientSideValidations.validators.local.confirmation(password_element, options), "failed validation");
25 | });
26 | 


--------------------------------------------------------------------------------
/test/core_ext/cases/test_core_ext.rb:
--------------------------------------------------------------------------------
 1 | require 'client_side_validations/core_ext'
 2 | 
 3 | class CoreExtTest < Test::Unit::TestCase
 4 |   def test_regexp_as_json
 5 |     regexp = //
 6 |     assert_equal regexp, regexp.as_json
 7 |   end
 8 | 
 9 |   def test_regexp_replace_A_and_Z
10 |     test_regexp = /\A\Z/
11 |     expected_regexp = /^$/
12 |     assert_equal expected_regexp, test_regexp.as_json
13 |   end
14 | 
15 |   def test_regexp_replace_a_and_z
16 |     test_regexp = /\A\z/
17 |     expected_regexp = /^$/
18 |     assert_equal expected_regexp, test_regexp.as_json
19 |   end
20 | 
21 |   def test_regexp_to_json
22 |     assert_equal "/^$/", /\A\Z/.to_json(nil)
23 |   end
24 | 
25 |   def test_regexp_encode_json
26 |     assert_equal "//", //.encode_json(nil)
27 |   end
28 | 
29 |   def test_regexp_as_jason_with_options
30 |     assert_equal //i, //i.as_json
31 |   end
32 | 
33 |   def test_range_as_json
34 |     assert_equal [1,3], (1..3).as_json
35 |   end
36 | 
37 |   def test_range_to_json
38 |     assert_equal '[1, 3]', (1..3).to_json(nil)
39 |   end
40 | 
41 |   def test_range_as_json_with_floats
42 |     assert_equal [0.5,5.5], (0.5..5.5).as_json
43 |   end
44 | end
45 | 
46 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/format.js:
--------------------------------------------------------------------------------
 1 | module('Format options');
 2 | 
 3 | test('when matching format', function() {
 4 |   var element = $('<input type="text" />');
 5 |   var options = { 'message': "failed validation", 'with': /\d+/ };
 6 |   element.val('123');
 7 |   equal(clientSideValidations.validators.local.format(element, options), undefined);
 8 | });
 9 | 
10 | test('when not matching format', function() {
11 |   var element = $('<input type="text" />');
12 |   var options = { 'message': "failed validation", 'with': /\d+/ };
13 |   element.val('abc');
14 |   equal(clientSideValidations.validators.local.format(element, options), "failed validation");
15 | });
16 | 
17 | test('when allowing blank', function() {
18 |   var element = $('<input type="text" />');
19 |   var options = { 'message': "failed validation", 'with': /\d+/, 'allow_blank': true };
20 |   equal(clientSideValidations.validators.local.format(element, options), undefined);
21 | });
22 | 
23 | test('when not allowing blank', function() {
24 |   var element = $('<input type="text" />');
25 |   var options = { 'message': "failed validation", 'with': /\d+/ };
26 |   equal(clientSideValidations.validators.local.format(element, options), "failed validation");
27 | });
28 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_record/middleware.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveRecord
 2 |   class Middleware
 3 | 
 4 |     def self.is_unique?(klass, attribute, value, params)
 5 |       column = klass.columns_hash[attribute.to_s]
 6 |       value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if column.text?
 7 | 
 8 |       t = klass.arel_table
 9 | 
10 |       if params[:case_sensitive] == 'true'
11 |         if t.engine.connection.instance_variable_get("@config")[:adapter] == 'mysql'
12 |           relation = Arel::Nodes::SqlLiteral.new("BINARY #{t[attribute].eq(value).to_sql}")
13 |         else
14 |           relation = t[attribute].eq(value)
15 |         end
16 |       else
17 |         relation = t[attribute].matches(value)
18 |       end
19 | 
20 |       if relation.is_a?(Arel::Nodes::SqlLiteral)
21 |         relation = Arel::Nodes::SqlLiteral.new("BINARY #{t[attribute].eq(value).to_sql} AND #{t.primary_key.not_eq(params[:id]).to_sql}")
22 |       else
23 |         relation = relation.and(t.primary_key.not_eq(params[:id])) if params[:id]
24 |       end
25 | 
26 |       (params[:scope] || {}).each do |key, value|
27 |         relation = relation.and(t[key].eq(value))
28 |       end
29 | 
30 |       !klass.where(relation).exists?
31 |     end
32 |   end
33 | end
34 | 


--------------------------------------------------------------------------------
/test/formtastic/cases/test_form_helper.rb:
--------------------------------------------------------------------------------
 1 | require 'action_view/cases/helper'
 2 | require 'formtastic/cases/helper'
 3 | 
 4 | class ClientSideValidations::Formtastic::FormHelperTest < ActionView::TestCase
 5 |   include ActionViewTestSetup
 6 |   include Formtastic::SemanticFormHelper
 7 | 
 8 |   def client_side_form_settings_helper
 9 |     ""
10 |   end
11 | 
12 |   def test_semantic_form_for
13 |     semantic_form_for(@post, :validate => true) do |f|
14 |       concat f.input(:cost)
15 |     end
16 | 
17 |     expected = %{<form accept-charset="UTF-8" action="/posts/123" class="formtastic 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><li class="string required" id="post_cost_input"><label for="post_cost">Cost<abbr title="required">*</abbr></label><input data-validate="true" id="post_cost" name="post[cost]" type="text" /></li></form><script>var edit_post_123 = {"type":"Formtastic::SemanticFormBuilder","inline_error_class":"inline-errors","validators":{"post[cost]":{"presence":{"message":"can't be blank"}}}};</script>}
18 |     assert_equal expected, output_buffer, "\n\n *** If you're running Ruby 1.8 and this test fails is is most likely due to 1.8's lack of insertion order persistence with Hashes ***\n"
19 |   end
20 | 
21 | end
22 | 
23 | 


--------------------------------------------------------------------------------
/test/simple_form/cases/test_form_helper.rb:
--------------------------------------------------------------------------------
 1 | require 'action_view/cases/helper'
 2 | require 'simple_form/cases/helper'
 3 | 
 4 | class ClientSideValidations::SimpleForm::FormHelperTest < ActionView::TestCase
 5 |   include ActionViewTestSetup
 6 |   include SimpleForm::ActionViewExtensions::FormHelper
 7 | 
 8 |   def client_side_form_settings_helper
 9 |     ""
10 |   end
11 | 
12 |   def test_simple_form_for
13 |     simple_form_for(@post, :validate => true) do |f|
14 |       concat f.input(:cost)
15 |     end
16 | 
17 |     expected = %{<form accept-charset="UTF-8" action="/posts/123" class="simple_form 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><div class="input string required"><label class="string required" for="post_cost"><abbr title="required">*</abbr> Cost</label><input class="string required" data-validate="true" id="post_cost" name="post[cost]" required="required" size="50" type="text" /></div></form><script>var edit_post_123 = {"type":"SimpleForm::FormBuilder","error_class":"error","error_tag":"span","wrapper_error_class":"field_with_errors","wrapper_tag":"div","validators":{"post[cost]":{"presence":{"message":"can't be blank"}}}};</script>}
18 |     assert_equal expected, output_buffer, "\n\n *** If you're running Ruby 1.8 and this test fails is is most likely due to 1.8's lack of insertion order persistence with Hashes ***\n"
19 |   end
20 | 
21 | end
22 | 
23 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/formAfter.js:
--------------------------------------------------------------------------------
 1 | module('Form Validate After Callback', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'ActionView::Helpers::FormBuilder',
 5 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
 6 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
 7 |       validators: {"user[name]":{"presence":{"message": "must be present"}}}
 8 |     }
 9 | 
10 |     $('#qunit-fixture')
11 |       .append($('<span id="result" />'))
12 |       .append($('<form />', {
13 |         action: '/users',
14 |         'data-validate': true,
15 |         method: 'post',
16 |         id: 'new_user'
17 |       }))
18 |       .find('form')
19 |         .append($('<input />', {
20 |           name: 'user[name]',
21 |           id: 'user_name',
22 |           'data-validate': 'true',
23 |           type: 'text'
24 |         }))
25 |         .append($('<label for="user_name">Name</label>'));
26 | 
27 |     clientSideValidations.callbacks.form.after = function(form, message) {
28 |       $('#result').text('Form Validate After ' + form.attr('id'));
29 |     }
30 |     $('form#new_user').validate();
31 |   },
32 |   teardown: function() {
33 |     clientSideValidations.callbacks.form.after = function(form, eventData) {}
34 |   }
35 | });
36 | 
37 | test('runs callback', function() {
38 |   var form = $('form'), input = form.find('input');
39 | 
40 |   equal($('#result').text(), '');
41 | 
42 |   form.submit();
43 |   equal($('#result').text(), 'Form Validate After new_user');
44 | });
45 | 
46 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/formBefore.js:
--------------------------------------------------------------------------------
 1 | module('Form Validate Before Callback', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'ActionView::Helpers::FormBuilder',
 5 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
 6 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
 7 |       validators: {"user[name]":{"presence":{"message": "must be present"}}}
 8 |     }
 9 | 
10 |     $('#qunit-fixture')
11 |       .append($('<span id="result" />'))
12 |       .append($('<form />', {
13 |         action: '/users',
14 |         'data-validate': true,
15 |         method: 'post',
16 |         id: 'new_user'
17 |       }))
18 |       .find('form')
19 |         .append($('<input />', {
20 |           name: 'user[name]',
21 |           id: 'user_name',
22 |           'data-validate': 'true',
23 |           type: 'text'
24 |         }))
25 |         .append($('<label for="user_name">Name</label>'));
26 | 
27 |     clientSideValidations.callbacks.form.before = function(form, message) {
28 |       $('#result').text('Form Validate Before ' + form.attr('id'));
29 |     }
30 |     $('form#new_user').validate();
31 |   },
32 |   teardown: function() {
33 |     clientSideValidations.callbacks.form.before = function(form, eventData) {}
34 |   }
35 | });
36 | 
37 | test('runs callback', function() {
38 |   var form = $('form'), input = form.find('input');
39 | 
40 |   equal($('#result').text(), '');
41 | 
42 |   form.submit();
43 |   equal($('#result').text(), 'Form Validate Before new_user');
44 | });
45 | 
46 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/formPass.js:
--------------------------------------------------------------------------------
 1 | module('Form Validate Pass Callback', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'ActionView::Helpers::FormBuilder',
 5 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
 6 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
 7 |       validators: {"user[name]":{"presence":{"message": "must be present"}}}
 8 |     }
 9 | 
10 |     $('#qunit-fixture')
11 |       .append($('<span id="result" />'))
12 |       .append($('<form />', {
13 |         action: '/users',
14 |         'data-validate': true,
15 |         method: 'post',
16 |         id: 'new_user'
17 |       }))
18 |       .find('form')
19 |         .append($('<input />', {
20 |           name: 'user[name]',
21 |           id: 'user_name',
22 |           'data-validate': 'true',
23 |           type: 'text'
24 |         }))
25 |         .append($('<label for="user_name">Name</label>'));
26 | 
27 |     clientSideValidations.callbacks.form.pass = function(form, message) {
28 |       $('#result').text('Form Validate Pass ' + form.attr('id'));
29 |     }
30 |     $('form#new_user').validate();
31 |   },
32 |   teardown: function() {
33 |     clientSideValidations.callbacks.form.pass = function(form, eventData) {}
34 |   }
35 | });
36 | 
37 | test('runs callback', function() {
38 |   var form = $('form'), input = form.find('input');
39 | 
40 |   equal($('#result').text(), '');
41 | 
42 |   form.submit();
43 |   equal($('#result').text(), '');
44 | 
45 |   input.val('test');
46 |   input.trigger('change');
47 |   form.submit();
48 |   equal($('#result').text(), 'Form Validate Pass new_user');
49 | });
50 | 
51 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/formFail.js:
--------------------------------------------------------------------------------
 1 | module('Form Validate Fail Callback', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'ActionView::Helpers::FormBuilder',
 5 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
 6 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
 7 |       validators: {"user[name]":{"presence":{"message": "must be present"}}}
 8 |     }
 9 | 
10 |     $('#qunit-fixture')
11 |       .append($('<span id="result" />'))
12 |       .append($('<form />', {
13 |         action: '/users',
14 |         'data-validate': true,
15 |         method: 'post',
16 |         id: 'new_user'
17 |       }))
18 |       .find('form')
19 |         .append($('<input />', {
20 |           name: 'user[name]',
21 |           id: 'user_name',
22 |           'data-validate': 'true',
23 |           type: 'text'
24 |         }))
25 |         .append($('<label for="user_name">Name</label>'));
26 | 
27 |     clientSideValidations.callbacks.form.fail = function(form, message) {
28 |       $('#result').text('Form Validate Fail ' + form.attr('id'));
29 |     }
30 |     $('form#new_user').validate();
31 |   },
32 |   teardown: function() {
33 |     clientSideValidations.callbacks.form.fail = function(form, eventData) {}
34 |   }
35 | });
36 | 
37 | test('runs callback', function() {
38 |   var form = $('form'), input = form.find('input');
39 | 
40 |   equal($('#result').text(), '');
41 | 
42 |   form.submit();
43 |   equal($('#result').text(), 'Form Validate Fail new_user');
44 | 
45 |   $('#result').text('');
46 |   input.val('test');
47 |   input.trigger('change');
48 |   form.submit();
49 |   equal($('#result').text(), '');
50 | });
51 | 
52 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/acceptance.js:
--------------------------------------------------------------------------------
 1 | module('Acceptance options');
 2 | 
 3 | test('when checkbox and checked', function() {
 4 |   var element = $('<input type="checkbox" />');
 5 |   var options = { message: "failed validation" };
 6 |   element.attr('checked', true)
 7 |   equal(clientSideValidations.validators.local.acceptance(element, options), undefined);
 8 | });
 9 | 
10 | test('when checkbox and not checked', function() {
11 |   var element = $('<input type="checkbox" />');
12 |   var options = { message: "failed validation" };
13 |   equal(clientSideValidations.validators.local.acceptance(element, options), "failed validation");
14 | });
15 | 
16 | test('when text and value default of 1', function() {
17 |   var element = $('<input type="text" />');
18 |   var options = { message: "failed validation" };
19 |   element.val("1");
20 |   equal(clientSideValidations.validators.local.acceptance(element, options), undefined);
21 | });
22 | 
23 | test('when text and value 2 and accept value is 2', function() {
24 |   var element = $('<input type="text" />');
25 |   var options = { message: "failed validation", accept: 1 };
26 |   element.val("1");
27 |   equal(clientSideValidations.validators.local.acceptance(element, options), undefined);
28 | });
29 | 
30 | test('when text and value empty', function() {
31 |   var element = $('<input type="text" />');
32 |   var options = { message: "failed validation" };
33 |   equal(clientSideValidations.validators.local.acceptance(element, options), "failed validation");
34 | });
35 | 
36 | test('when text and value 1 and accept value is 2', function() {
37 |   var element = $('<input type="text" />');
38 |   var options = { message: "failed validation", accept: 2 };
39 |   element.val("1");
40 |   equal(clientSideValidations.validators.local.acceptance(element, options), "failed validation");
41 | });
42 | 
43 | 


--------------------------------------------------------------------------------
/client_side_validations.gemspec:
--------------------------------------------------------------------------------
 1 | # -*- encoding: utf-8 -*-
 2 | $:.push File.expand_path("../lib", __FILE__)
 3 | require "client_side_validations/version"
 4 | 
 5 | Gem::Specification.new do |s|
 6 |   s.name        = "client_side_validations"
 7 |   s.version     = ClientSideValidations::VERSION
 8 |   s.platform    = Gem::Platform::RUBY
 9 |   s.authors     = ["Brian Cardarella"]
10 |   s.email       = ["bcardarella@gmail.com"]
11 |   s.homepage    = "https://github.com/bcardarella/client_side_validations"
12 |   s.summary     = %q{Client Side Validations}
13 |   s.description = %q{Client Side Validations}
14 | 
15 |   s.rubyforge_project = "client_side_validations"
16 | 
17 |   s.files         = `git ls-files -- {lib/*,javascript/*,*.gemspec}`.split("\n")
18 |   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
19 |   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
20 |   s.require_paths = ["lib"]
21 | 
22 |   s.add_dependency 'activesupport', '~> 3.0.0'
23 | 
24 |   s.add_development_dependency 'rails', '~> 3.0.0'
25 |   s.add_development_dependency 'sqlite3'
26 |   s.add_development_dependency 'bson_ext'
27 |   s.add_development_dependency 'mongoid', '~> 2.0.0'
28 |   s.add_development_dependency 'mocha'
29 |   s.add_development_dependency 'simple_form'
30 |   s.add_development_dependency 'formtastic'
31 | 
32 |   # For QUnit testing
33 |   s.add_development_dependency 'sinatra', '~> 1.0'
34 |   s.add_development_dependency 'shotgun'
35 |   s.add_development_dependency 'thin'
36 |   s.add_development_dependency 'json'
37 | 
38 |   ruby_minor_version = RUBY_VERSION.split('.')[1].to_i
39 |   if ruby_minor_version == 8
40 |     s.add_development_dependency 'minitest'
41 |     s.add_development_dependency 'ruby-debug'
42 |   elsif ruby_minor_version == 9
43 |     s.add_development_dependency 'ruby-debug19'
44 |   end
45 | end
46 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/exclusion.js:
--------------------------------------------------------------------------------
 1 | module('Exclusion options');
 2 | 
 3 | test('when value is not in the list', function() {
 4 |   var element = $('<input type="text" />');
 5 |   var options = { 'message': "failed validation", 'in': [1, 2, 3] };
 6 |   element.val('4');
 7 |   equal(clientSideValidations.validators.local.exclusion(element, options), undefined);
 8 | });
 9 | 
10 | test('when value is not in the range', function() {
11 |   var element = $('<input type="text" />');
12 |   var options = { 'message': "failed validation", 'range': [1, 3] };
13 |   element.val('4');
14 |   equal(clientSideValidations.validators.local.exclusion(element, options), undefined);
15 | });
16 | 
17 | test('when value is in the list', function() {
18 |   var element = $('<input type="text" />');
19 |   var options = { 'message': "failed validation", 'in': [1, 2, 3] };
20 |   element.val('1');
21 |   equal(clientSideValidations.validators.local.exclusion(element, options), "failed validation");
22 | });
23 | 
24 | test('when value is in the range', function() {
25 |   var element = $('<input type="text" />');
26 |   var options = { 'message': "failed validation", 'range': [1, 3] };
27 |   element.val('1');
28 |   equal(clientSideValidations.validators.local.exclusion(element, options), "failed validation");
29 | });
30 | 
31 | test('when allowing blank', function() {
32 |   var element = $('<input type="text" />');
33 |   var options = { 'message': "failed validation", 'in': [1, 2, 3], allow_blank: true };
34 |   equal(clientSideValidations.validators.local.exclusion(element, options), undefined);
35 | });
36 | 
37 | test('when not allowing blank', function() {
38 |   var element = $('<input type="text" />');
39 |   var options = { 'message': "failed validation", 'in': [1, 2, 3] };
40 |   equal(clientSideValidations.validators.local.exclusion(element, options), "failed validation");
41 | });
42 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/form_builders/validateFormtastic.js:
--------------------------------------------------------------------------------
 1 | module('Validate Formtastic', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'Formtastic::SemanticFormBuilder',
 5 |       inline_error_class: 'inline-errors',
 6 |       validators: {
 7 |         "user[name]":{"presence":{"message": "must be present"}, "format":{"message":"is invalid","with":/\d+/}}
 8 |       }
 9 |     }
10 | 
11 |     $('#qunit-fixture')
12 |       .append($('<form />', {
13 |         action: '/users',
14 |         'data-validate': true,
15 |         method: 'post',
16 |         id: 'new_user'
17 |       }))
18 |       .find('form')
19 |         .append('<li />').find('li')
20 |           .append($('<input />', {
21 |             name: 'user[name]',
22 |             id: 'user_name',
23 |             'data-validate': 'true',
24 |             type: 'text'
25 |           }))
26 |           .append($('<label for="user_name">Name</label>'));
27 |     $('form#new_user').validate();
28 |   }
29 | });
30 | 
31 | test('Validate error attaching and detaching', function() {
32 |   var form = $('form#new_user'), input = form.find('input#user_name');
33 |   var label = $('label[for="user_name"]');
34 | 
35 |   input.trigger('focusout')
36 |   ok(input.parent().hasClass('error'));
37 |   ok(label.parent().hasClass('error'));
38 |   ok(input.parent().find('p.inline-errors:contains("must be present")')[0]);
39 | 
40 |   input.val('abc')
41 |   input.trigger('change')
42 |   input.trigger('focusout')
43 |   ok(input.parent().hasClass('error'));
44 |   ok(label.parent().hasClass('error'));
45 |   ok(input.parent().find('p.inline-errors:contains("is invalid")')[0]);
46 | 
47 |   input.val('123')
48 |   input.trigger('change')
49 |   input.trigger('focusout')
50 |   ok(!input.parent().hasClass('error'));
51 |   ok(!label.parent().hasClass('error'));
52 |   ok(!input.parent().find('p.inline-errors')[0]);
53 | });
54 | 
55 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/inclusion.js:
--------------------------------------------------------------------------------
 1 | module('Inclusion options');
 2 | 
 3 | test('when value is in the list', function() {
 4 |   var element = $('<input type="text" />');
 5 |   var options = { 'message': "failed validation", 'in': [1, 2, 3] };
 6 |   element.val('1');
 7 |   equal(clientSideValidations.validators.local.inclusion(element, options), undefined);
 8 | });
 9 | 
10 | test('when value is in the range', function() {
11 |   var element = $('<input type="text" />');
12 |   var options = { 'message': "failed validation", 'range': [1, 3] };
13 |   element.val('1');
14 |   equal(clientSideValidations.validators.local.inclusion(element, options), undefined);
15 | });
16 | 
17 | test('when value is not in the list', function() {
18 |   var element = $('<input type="text" />');
19 |   var options = { 'message': "failed validation", 'in': [1, 2, 3] };
20 |   element.val('4');
21 |   equal(clientSideValidations.validators.local.inclusion(element, options), "failed validation");
22 | });
23 | 
24 | test('when value is not in the range', function() {
25 |   var element = $('<input type="text" />');
26 |   var options = { 'message': "failed validation", 'range': [1, 3] };
27 |   element.val('4');
28 |   equal(clientSideValidations.validators.local.inclusion(element, options), "failed validation");
29 | });
30 | 
31 | test('when allowing blank', function() {
32 |   var element = $('<input type="text" />');
33 |   var options = { 'message': "failed validation", 'in': [1, 2, 3], allow_blank: true };
34 |   equal(clientSideValidations.validators.local.inclusion(element, options), undefined);
35 | });
36 | 
37 | test('when not allowing blank', function() {
38 |   var element = $('<input type="text" />');
39 |   var options = { 'message': "failed validation", 'in': [1, 2, 3] };
40 |   equal(clientSideValidations.validators.local.inclusion(element, options), "failed validation");
41 | });
42 | 
43 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/elementAfter.js:
--------------------------------------------------------------------------------
 1 | module('Element Validate After Callback', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'ActionView::Helpers::FormBuilder',
 5 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
 6 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
 7 |       validators: {"user[name]":{"presence":{"message": "must be present"}}}
 8 |     }
 9 | 
10 |     $('#qunit-fixture')
11 |       .append($('<span id="result" />'))
12 |       .append($('<form />', {
13 |         action: '/users',
14 |         'data-validate': true,
15 |         method: 'post',
16 |         id: 'new_user'
17 |       }))
18 |       .find('form')
19 |         .append($('<input />', {
20 |           name: 'user[name]',
21 |           id: 'user_name',
22 |           'data-validate': 'true',
23 |           type: 'text'
24 |         }))
25 |         .append($('<label for="user_name">Name</label>'));
26 | 
27 |     clientSideValidations.callbacks.element.after = function(element, message) {
28 |       $('#result').text('Element Validate After ' + element.attr('id'));
29 |     }
30 |     $('form#new_user').validate();
31 |   },
32 |   teardown: function() {
33 |     clientSideValidations.callbacks.element.after = function(element, eventData) {}
34 |   }
35 | });
36 | 
37 | test('runs callback when form element validate', function() {
38 |   var input = $('input');
39 | 
40 |   equal($('#result').text(), '');
41 | 
42 |   input.trigger('focusout');
43 |   equal($('#result').text(), 'Element Validate After user_name');
44 | });
45 | 
46 | test('runs callback when form validates', function() {
47 |   var form = $('form'), input = form.find('input');
48 | 
49 |   equal($('#result').text(), '');
50 | 
51 |   form.submit();
52 |   equal($('#result').text(), 'Element Validate After user_name');
53 | });
54 | 
55 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/elementBefore.js:
--------------------------------------------------------------------------------
 1 | module('Element Validate Before Callback', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'ActionView::Helpers::FormBuilder',
 5 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
 6 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
 7 |       validators: {"user[name]":{"{presence":{"message": "must be present"}}}
 8 |     }
 9 | 
10 |     $('#qunit-fixture')
11 |       .append($('<span id="result" />'))
12 |       .append($('<form />', {
13 |         action: '/users',
14 |         'data-validate': true,
15 |         method: 'post',
16 |         id: 'new_user'
17 |       }))
18 |       .find('form')
19 |         .append($('<input />', {
20 |           name: 'user[name]',
21 |           id: 'user_name',
22 |           'data-validate': 'true',
23 |           type: 'text'
24 |         }))
25 |         .append($('<label for="user_name">Name</label>'));
26 | 
27 |     clientSideValidations.callbacks.element.before = function(element) {
28 |       $('#result').text('Element Validate Before ' + element.attr('id'));
29 |     }
30 |     $('form#new_user').validate();
31 |   },
32 |   teardown: function() {
33 |     clientSideValidations.callbacks.element.before = function(element, eventData) {}
34 |   }
35 | });
36 | 
37 | test('runs callback when form element validate', function() {
38 |   var input = $('input');
39 | 
40 |   equal($('#result').text(), '');
41 | 
42 |   input.trigger('focusout');
43 |   equal($('#result').text(), 'Element Validate Before user_name');
44 | });
45 | 
46 | test('runs callback when form validates', function() {
47 |   var form = $('form'), input = form.find('input');
48 | 
49 |   equal($('#result').text(), '');
50 | 
51 |   form.submit();
52 |   equal($('#result').text(), 'Element Validate Before user_name');
53 | });
54 | 
55 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_numericality_validator.rb:
--------------------------------------------------------------------------------
 1 | require 'active_model/cases/test_base'
 2 | 
 3 | class ActiveModel::NumericalityValidatorTest < ClientSideValidations::ActiveModelTestBase
 4 | 
 5 |   def test_numericality_client_side_hash
 6 |     expected_hash = { :messages => { :numericality => "is not a number" } }
 7 |     assert_equal expected_hash, NumericalityValidator.new(:attributes => [:age]).client_side_hash(@person, :age)
 8 |   end
 9 | 
10 |   def test_numericality_client_side_hash_with_custom_message
11 |     expected_hash = { :messages => { :numericality => "bad number" } }
12 |     assert_equal expected_hash, NumericalityValidator.new(:attributes => [:age], :message => "bad number").client_side_hash(@person, :age)
13 |   end
14 | 
15 |   def test_numericality_client_side_hash_with_options
16 |     expected_hash = {
17 |       :messages => {
18 |         :numericality => "is not a number",
19 |         :only_integer => "must be an integer",
20 |         :greater_than => "must be greater than 10",
21 |         :greater_than_or_equal_to => "must be greater than or equal to 10",
22 |         :equal_to => "must be equal to 10",
23 |         :less_than => "must be less than 10",
24 |         :less_than_or_equal_to => "must be less than or equal to 10",
25 |         :odd => "must be odd",
26 |         :even => "must be even"
27 |       },
28 |       :only_integer => true,
29 |       :greater_than => 10,
30 |       :greater_than_or_equal_to => 10,
31 |       :equal_to => 10,
32 |       :less_than => 10,
33 |       :less_than_or_equal_to => 10,
34 |       :odd => true,
35 |       :even => true
36 |     }
37 |     test_hash = NumericalityValidator.new(:attributes => [:age],
38 |       :only_integer => true, :greater_than => 10, :greater_than_or_equal_to => 10,
39 |       :equal_to => 10, :less_than => 10, :less_than_or_equal_to => 10,
40 |       :odd => true, :even => true).client_side_hash(@person, :age)
41 | 
42 |     assert_equal expected_hash, test_hash
43 |   end
44 | 
45 | end
46 | 
47 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/form_builders/validateSimpleForm.js:
--------------------------------------------------------------------------------
 1 | module('Validate SimpleForm', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'SimpleForm::FormBuilder',
 5 |       error_class: 'error',
 6 |       error_tag: 'span',
 7 |       wrapper_error_class: 'field_with_errors',
 8 |       wrapper_tag: 'div',
 9 |       validators: {
10 |         "user[name]":{"presence":{"message": "must be present"}, "format":{"message":"is invalid","with":/\d+/}}
11 |       }
12 |     }
13 | 
14 |     $('#qunit-fixture')
15 |       .append($('<form />', {
16 |         action: '/users',
17 |         'data-validate': true,
18 |         method: 'post',
19 |         id: 'new_user'
20 |       }))
21 |       .find('form')
22 |         .append('<div />').find('div')
23 |           .append($('<input />', {
24 |             name: 'user[name]',
25 |             id: 'user_name',
26 |             'data-validate': 'true',
27 |             type: 'text'
28 |           }))
29 |           .append($('<label for="user_name">Name</label>'));
30 |     $('form#new_user').validate();
31 |   }
32 | });
33 | 
34 | test('Validate error attaching and detaching', function() {
35 |   var form = $('form#new_user'), input = form.find('input#user_name');
36 |   var label = $('label[for="user_name"]');
37 | 
38 |   input.trigger('focusout');
39 |   ok(input.parent().hasClass('field_with_errors'));
40 |   ok(label.parent().hasClass('field_with_errors'));
41 |   ok(input.parent().find('span.error:contains("must be present")')[0]);
42 | 
43 |   input.val('abc')
44 |   input.trigger('change')
45 |   input.trigger('focusout')
46 |   ok(input.parent().hasClass('field_with_errors'));
47 |   ok(label.parent().hasClass('field_with_errors'));
48 |   ok(input.parent().find('span.error:contains("is invalid")')[0]);
49 | 
50 |   input.val('123')
51 |   input.trigger('change')
52 |   input.trigger('focusout')
53 |   ok(!input.parent().hasClass('field_with_errors'));
54 |   ok(!label.parent().hasClass('field_with_errors'));
55 |   ok(!input.parent().find('span.error')[0]);
56 | });
57 | 
58 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
 1 | require 'bundler'
 2 | Bundler::GemHelper.install_tasks
 3 | 
 4 | multitask :default => 'test:ruby'
 5 | 
 6 | require 'rake/testtask'
 7 | namespace :test do
 8 |   desc %(Run all tests)
 9 |   multitask :all => ['test:all_rubies', 'test:js']
10 | 
11 |   desc %(Test Ruby code)
12 |   Rake::TestTask.new(:ruby) do |test|
13 |     test.libs << 'lib' << 'test'
14 |     test.pattern = 'test/*/cases/**/test_*.rb'
15 |     test.verbose = true
16 |   end
17 | 
18 |   task :all_rubies do
19 |     system "rvm ruby-1.8.7@client_side_validations,ruby-1.9.2@client_side_validations rake test:ruby"
20 |   end
21 | 
22 |   desc %(Test Javascript code)
23 |   multitask :js => ['test:server', 'test:open']
24 | 
25 |   desc %(Starts the test server)
26 |   task :server do
27 |     system 'bundle exec ruby test/javascript/server.rb'
28 |   end
29 | 
30 |   desc %(Starts the test server which reloads everything on each refresh)
31 |   task :reloadable do
32 |     exec "bundle exec shotgun test/javascript/config.ru -p #{PORT} --server thin"
33 |   end
34 | 
35 |   task :open do
36 |     url = "http://localhost:#{PORT}"
37 |     puts "Opening test app at #{url} ..."
38 |     sleep 3
39 |     system( *browse_cmd(url) )
40 |   end
41 | end
42 | 
43 | PORT = 4567
44 | 
45 | # Returns an array e.g.: ['open', 'http://example.com']
46 | def browse_cmd(url)
47 |   require 'rbconfig'
48 |   browser = ENV['BROWSER'] ||
49 |     (RbConfig::CONFIG['host_os'].include?('darwin') && 'open') ||
50 |     (RbConfig::CONFIG['host_os'] =~ /msdos|mswin|djgpp|mingw|windows/ && 'start') ||
51 |     %w[xdg-open x-www-browser firefox opera mozilla netscape].find { |comm| which comm }
52 | 
53 |   abort('ERROR: no web browser detected') unless browser
54 |   Array(browser) << url
55 | end
56 | 
57 | # which('ruby') #=> /usr/bin/ruby
58 | def which cmd
59 |   exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
60 |   ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
61 |     exts.each { |ext|
62 |       exe = "#{path}/#{cmd}#{ext}"
63 |       return exe if File.executable? exe
64 |     }
65 |   end
66 |   return nil
67 | end
68 | 
69 | 


--------------------------------------------------------------------------------
/test/javascript/server.rb:
--------------------------------------------------------------------------------
 1 | require 'sinatra'
 2 | require 'json'
 3 | require 'ruby-debug'
 4 | 
 5 | use Rack::Static, :urls => ['/javascript'], :root => File.expand_path('../..', settings.root)
 6 | 
 7 | helpers do
 8 |   def jquery_link version
 9 |     if params[:version] == version
10 |       "[#{version}]"
11 |     else
12 |       "<a href='/?version=#{version}'>#{version}</a>"
13 |     end
14 |   end
15 | 
16 |   def jquery_src
17 |     if params[:version] == 'edge' then '/vendor/jquery.js'
18 |     else "http://code.jquery.com/jquery-#{params[:version]}.js"
19 |     end
20 |   end
21 | 
22 |   def test_base
23 |     names = ['/vendor/qunit.js', 'settings']
24 |     names.map { |name| script_tag name }.join("\n")
25 |   end
26 | 
27 |   def test *types
28 |     types.map do |type|
29 |       Dir.glob(File.expand_path("public/test/#{type}", settings.root) + '/*.js').map { |file| File.basename(file) }.map do |file|
30 |         script_tag "/test/#{type}/#{file}"
31 |       end.join("\n")
32 |     end.join("\n")
33 |   end
34 | 
35 |   def script_tag src
36 |     src = "/test/#{src}.js" unless src.index('/')
37 |     %(<script src='#{src}' type='text/javascript'></script>)
38 |   end
39 | end
40 | 
41 | get '/' do
42 |   params[:version] ||= '1.4.4'
43 |   erb :index
44 | end
45 | 
46 | get '/validators/uniqueness.json' do
47 |   content_type 'application/json'
48 | 
49 |   if scope = params[:scope]
50 |     if scope[:name] == 'test name' || scope[:name] == 'taken name'
51 |       status 200
52 |       'false'
53 |     else
54 |       status 404
55 |       'true'
56 |     end
57 |   elsif params[:case_sensitive] == 'false' && (params[:user][:email] || params[:users][:email]) == 'taken@test.com'
58 |     status 200
59 |     'false'
60 |   else
61 |     status 404
62 |     'true'
63 |   end
64 | 
65 | end
66 | 
67 | post '/users' do
68 |   data = { :params => params }.update(request.env)
69 |   payload = data.to_json.gsub('<', '&lt;').gsub('>', '&gt;')
70 |   <<-HTML
71 |     <script>
72 |       if (window.top && window.top !== window)
73 |         window.top.jQuery.event.trigger('iframe:loaded', #{payload})
74 |     </script>
75 |     <p id="response">Form submitted</p>
76 |   HTML
77 | end
78 | 
79 | 


--------------------------------------------------------------------------------
/test/mongoid/cases/test_uniqueness_validator.rb:
--------------------------------------------------------------------------------
 1 | require 'mongoid/cases/test_base'
 2 | 
 3 | class Mongoid::UniqunessValidatorTest < ClientSideValidations::MongoidTestBase
 4 | 
 5 |   def test_uniqueness_client_side_hash
 6 |     expected_hash = { :message => "is already taken" }
 7 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name]).client_side_hash(@book, :age)
 8 |   end
 9 | 
10 |   def test_uniqueness_client_side_hash_with_custom_message
11 |     expected_hash = { :message => "is not available" }
12 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name], :message => "is not available").client_side_hash(@book, :age)
13 |   end
14 | 
15 |   def test_uniqueness_client_side_hash
16 |     @book.stubs(:new_record?).returns(false)
17 |     @book.stubs(:id).returns(1)
18 |     expected_hash = { :message => "is already taken", :id => 1 }
19 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name]).client_side_hash(@book, :age)
20 |   end
21 | 
22 |   def test_uniqueness_client_side_hash_with_single_scope_item
23 |     @book.stubs(:author_email).returns("test@test.com")
24 |     expected_hash = { :message => "is already taken", :scope => {:author_email => "test@test.com"} }
25 |     result_hash = UniquenessValidator.new(:attributes => [:author_name], :scope => :author_email).client_side_hash(@book, :author_name)
26 |     assert_equal expected_hash, result_hash
27 |   end
28 | 
29 |   def test_uniqueness_client_side_hash_with_multiple_scope_items
30 |     @book.stubs(:age).returns(30)
31 |     @book.stubs(:author_email).returns("test@test.com")
32 |     expected_hash = { :message => "is already taken", :scope => {:age => 30, :author_email => "test@test.com"} }
33 |     result_hash = UniquenessValidator.new(:attributes => [:author_name], :scope => [:age, :author_email]).client_side_hash(@book, :author_name)
34 |     assert_equal expected_hash, result_hash
35 |   end
36 | 
37 |   def test_uniqueness_client_side_hash_with_empty_scope_array
38 |     expected_hash = { :message => "is already taken" }
39 |     result_hash = UniquenessValidator.new(:attributes => [:author_name], :scope => []).client_side_hash(@book, :author_name)
40 |     assert_equal expected_hash, result_hash
41 |   end
42 | 
43 | end
44 | 
45 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/elementPass.js:
--------------------------------------------------------------------------------
 1 | module('Element Validate Pass Callback', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'ActionView::Helpers::FormBuilder',
 5 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
 6 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
 7 |       validators: {"user[name]":{"presence":{"message": "must be present"}}}
 8 |     }
 9 | 
10 |     $('#qunit-fixture')
11 |       .append($('<span id="result" />'))
12 |       .append($('<form />', {
13 |         action: '/users',
14 |         'data-validate': true,
15 |         method: 'post',
16 |         id: 'new_user'
17 |       }))
18 |       .find('form')
19 |         .append($('<input />', {
20 |           name: 'user[name]',
21 |           id: 'user_name',
22 |           'data-validate': 'true',
23 |           type: 'text'
24 |         }))
25 |         .append($('<label for="user_name">Name</label>'));
26 | 
27 |     clientSideValidations.callbacks.element.pass = function(element) {
28 |       $('#result').text('Element Validate Pass ' + element.attr('id'));
29 |     }
30 |     $('form#new_user').validate();
31 |   },
32 |   teardown: function() {
33 |     clientSideValidations.callbacks.element.pass = function(element, callback) { callback() }
34 |   }
35 | });
36 | 
37 | test('runs callback when form element validate', function() {
38 |   var input = $('input');
39 | 
40 |   equal($('#result').text(), '');
41 | 
42 |   input.val('')
43 |   input.trigger('change');
44 |   input.trigger('focusout');
45 |   equal($('#result').text(), '');
46 | 
47 |   input.val('test')
48 |   input.trigger('change');
49 |   input.trigger('focusout');
50 |   equal($('#result').text(), 'Element Validate Pass user_name');
51 | });
52 | 
53 | test('runs callback when form validates', function() {
54 |   var form = $('form'), input = form.find('input');
55 | 
56 |   equal($('#result').text(), '');
57 | 
58 |   input.val('')
59 |   input.trigger('change');
60 |   form.trigger('submit');
61 | 
62 |   equal($('#result').text(), '');
63 | 
64 |   input.val('test')
65 |   input.trigger('change');
66 |   form.trigger('submit');
67 | 
68 |   equal($('#result').text(), 'Element Validate Pass user_name');
69 | });
70 | 
71 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/elementFail.js:
--------------------------------------------------------------------------------
 1 | module('Element Validate Fail Callback', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'ActionView::Helpers::FormBuilder',
 5 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
 6 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
 7 |       validators: {"user[name]":{"presence":{"message": "must be present"}}}
 8 |     }
 9 | 
10 |     $('#qunit-fixture')
11 |       .append($('<span id="result" />'))
12 |       .append($('<form />', {
13 |         action: '/users',
14 |         'data-validate': true,
15 |         method: 'post',
16 |         id: 'new_user'
17 |       }))
18 |       .find('form')
19 |         .append($('<input />', {
20 |           name: 'user[name]',
21 |           id: 'user_name',
22 |           'data-validate': 'true',
23 |           type: 'text'
24 |         }))
25 |         .append($('<label for="user_name">Name</label>'));
26 | 
27 |     clientSideValidations.callbacks.element.fail = function(element, message) {
28 |       $('#result').text('Element Validate Fail ' + element.attr('id') + ' ' + message);
29 |     }
30 |     $('form#new_user').validate();
31 |   },
32 |   teardown: function() {
33 |     clientSideValidations.callbacks.element.fail = function(element, message, callback) { callback(); }
34 |   }
35 | });
36 | 
37 | test('runs callback when form element validate', function() {
38 |   var input = $('input');
39 | 
40 |   equal($('#result').text(), '');
41 | 
42 |   input.val('test')
43 |   input.trigger('change');
44 |   input.trigger('focusout');
45 |   equal($('#result').text(), '');
46 | 
47 |   input.val('')
48 |   input.trigger('change');
49 |   input.trigger('focusout');
50 |   equal($('#result').text(), 'Element Validate Fail user_name must be present');
51 | });
52 | 
53 | test('runs callback when form validates', function() {
54 |   var form = $('form'), input = form.find('input');
55 | 
56 |   equal($('#result').text(), '');
57 | 
58 |   input.val('test')
59 |   input.trigger('change');
60 |   form.trigger('submit');
61 | 
62 |   equal($('#result').text(), '');
63 | 
64 |   input.val('')
65 |   input.trigger('change');
66 |   form.trigger('submit');
67 | 
68 |   equal($('#result').text(), 'Element Validate Fail user_name must be present');
69 | });
70 | 
71 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/form_builders/validateForm.js:
--------------------------------------------------------------------------------
 1 | module('Validate Form', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'ActionView::Helpers::FormBuilder',
 5 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
 6 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
 7 |       validators: {'user[name]':{"presence":{"message": "must be present"}}}
 8 |     }
 9 | 
10 |     $('#qunit-fixture')
11 |       .append($('<form />', {
12 |         action: '/users',
13 |         'data-validate': true,
14 |         method: 'post',
15 |         id: 'new_user'
16 |       }))
17 |       .find('form')
18 |         .append($('<input />', {
19 |           name: 'user[name]',
20 |           id: 'user_name',
21 |           'data-validate': 'true',
22 |           type: 'text'
23 |         }))
24 |         .append($('<label for="user_name">Name</label>'));
25 |     $('form#new_user').validate();
26 |   }
27 | });
28 | 
29 | asyncTest('Validate form with invalid form', 4, function() {
30 |   var form = $('form#new_user'), input = form.find('input#user_name');
31 |   var label = $('label[for="user_name"]');
32 | 
33 |   form.trigger('submit');
34 |   setTimeout(function() {
35 |     start();
36 |     ok(input.parent().hasClass('field_with_errors'));
37 |     ok(label.parent().hasClass('field_with_errors'));
38 |     ok(input.parent().find('label:contains("must be present")')[0]);
39 |     ok(!$('iframe').contents().find('p:contains("Form submitted")')[0]);
40 |   }, 30);
41 | });
42 | 
43 | asyncTest('Validate form with valid form', 1, function() {
44 |   var form = $('form#new_user'), input = form.find('input#user_name');
45 |   input.val('Test');
46 | 
47 |   form.trigger('submit');
48 |   setTimeout(function() {
49 |     start();
50 |     ok($('iframe').contents().find('p:contains("Form submitted")')[0]);
51 |   }, 30);
52 | });
53 | 
54 | asyncTest('Validate form with an input changed to false', 1, function() {
55 |   var form = $('form#new_user'), input = form.find('input#user_name');
56 |   input.val('Test');
57 |   input.attr('changed', false);
58 |   input.attr('data-valid', true);
59 | 
60 |   form.trigger('submit');
61 |   setTimeout(function() {
62 |     start();
63 |     ok($('iframe').contents().find('p:contains("Form submitted")')[0]);
64 |   }, 30);
65 | });
66 | 
67 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/middleware.rb:
--------------------------------------------------------------------------------
 1 | # encoding: utf-8
 2 | 
 3 | module ClientSideValidations
 4 | 
 5 |   module Middleware
 6 | 
 7 |     class Validators
 8 |       def initialize(app)
 9 |         @app = app
10 |       end
11 | 
12 |       def call(env)
13 |         case env['PATH_INFO']
14 |         when %r{\/validators\/(\w+)\.json}
15 |           "::ClientSideValidations::Middleware::#{$1.camelize}".constantize.new(env).response
16 |         else
17 |           @app.call(env)
18 |         end
19 |       end
20 |     end
21 | 
22 |     class Base
23 |       attr_accessor :request, :body, :status
24 | 
25 |       def initialize(env)
26 |         self.body    = ''
27 |         self.status  = 200
28 |         self.request = ActionDispatch::Request.new(env)
29 |       end
30 | 
31 |       def response
32 |         [status, {'Content-Type' => content_type, 'Content-Length' => body.length.to_s}, [body]]
33 |       end
34 | 
35 |       def content_type
36 |         'application/json'
37 |       end
38 |     end
39 | 
40 |     class Uniqueness < Base
41 |       IGNORE_PARAMS = %w{case_sensitive id scope}
42 | 
43 |       def response
44 |         if is_unique?
45 |           self.status = 404
46 |           self.body   = 'true'
47 |         else
48 |           self.status = 200
49 |           self.body   = 'false'
50 |         end
51 |         super
52 |       end
53 | 
54 |       private
55 | 
56 |       def is_unique?
57 |         resource = extract_resource
58 |         klass = resource.classify.constantize
59 |         attribute = request.params[resource].keys.first
60 |         value = request.params[resource][attribute]
61 | 
62 |         if (defined?(::ActiveRecord::Base) && klass < ::ActiveRecord::Base)
63 |           middleware_klass = ClientSideValidations::ActiveRecord::Middleware
64 |         elsif (defined?(::Mongoid::Document) && klass.included_modules.include?(::Mongoid::Document))
65 |           middleware_klass = ClientSideValidations::Mongoid::Middleware
66 |         end
67 | 
68 |         middleware_klass.is_unique?(klass, attribute, value, request.params)
69 |       end
70 | 
71 |       def extract_resource
72 |         parent_key = (request.params.keys - IGNORE_PARAMS).first
73 |       end
74 |     end
75 | 
76 |   end
77 | 
78 |   class Engine < ::Rails::Engine
79 |     config.app_middleware.use ClientSideValidations::Middleware::Validators
80 |   end
81 | 
82 | end
83 | 
84 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model.rb:
--------------------------------------------------------------------------------
 1 | require 'client_side_validations/core_ext'
 2 | 
 3 | module ClientSideValidations::ActiveModel
 4 |   module Validator
 5 | 
 6 |     def client_side_hash(model, attribute)
 7 |       options = self.options.dup
 8 |       { :message => model.errors.generate_message(attribute, message_type, options) }.
 9 |         merge(options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:allow_blank]))
10 |     end
11 | 
12 |     private
13 | 
14 |     def message_type
15 |       kind
16 |     end
17 |   end
18 | 
19 |   module Validations
20 |     def client_side_validation_hash
21 |       @client_side_validation_hash ||= _validators.inject({}) do |attr_hash, attr|
22 |         unless [nil, :block].include?(attr[0])
23 | 
24 |           validator_hash = attr[1].inject({}) do |kind_hash, validator|
25 |             client_side_hash = validator.client_side_hash(self, attr[0])
26 |             # Yeah yeah, #new_record? is not part of ActiveModel :p
27 |             if (can_use_for_client_side_validation?(client_side_hash, validator))
28 |               kind_hash.merge!(validator.kind => client_side_hash.except(:on))
29 |             else
30 |               kind_hash.merge!({})
31 |             end
32 |           end
33 | 
34 |           if validator_hash.present?
35 |             attr_hash.merge!(attr[0] => validator_hash)
36 |           else
37 |             attr_hash
38 |           end
39 |         else
40 |           attr_hash
41 |         end
42 |       end
43 |     end
44 | 
45 |     private
46 | 
47 |     def can_use_for_client_side_validation?(client_side_hash, validator)
48 |       ((self.respond_to?(:new_record?) && validator.options[:on] == (self.new_record? ? :create : :update)) || validator.options[:on].nil?) && !validator.options.key?(:if) && !validator.options.key?(:unless) && validator.kind != :block
49 |     end
50 |   end
51 | end
52 | 
53 | ActiveModel::Validator.send(:include, ClientSideValidations::ActiveModel::Validator)
54 | ActiveModel::Validations.send(:include, ClientSideValidations::ActiveModel::Validations)
55 | 
56 | %w{acceptance exclusion inclusion length format numericality presence}.each do |validator|
57 |   require "client_side_validations/active_model/#{validator}"
58 |   validator.capitalize!
59 |   eval "ActiveModel::Validations::#{validator}Validator.send(:include, ClientSideValidations::ActiveModel::#{validator})"
60 | end
61 | 
62 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_length_validator.rb:
--------------------------------------------------------------------------------
 1 | require 'active_model/cases/test_base'
 2 | 
 3 | class ActiveModel::LengthValidatorTest < ClientSideValidations::ActiveModelTestBase
 4 | 
 5 |   def test_length_client_side_hash
 6 |     expected_hash = {
 7 |       :messages => {
 8 |         :is => "is the wrong length (should be 10 characters)"
 9 |       },
10 |       :is => 10
11 |     }
12 |     assert_equal expected_hash, LengthValidator.new(:attributes => [:age], :is => 10).client_side_hash(@person, :first_name)
13 |   end
14 | 
15 |   def test_length_client_side_hash_with_custom_message
16 |     expected_hash = {
17 |       :messages => {
18 |         :is => "is the wrong length (should be 10 words)"
19 |       },
20 |       :is => 10
21 |     }
22 |     assert_equal expected_hash, LengthValidator.new(:attributes => [:age], :is => 10, :wrong_length => "is the wrong length (should be %{count} words)").client_side_hash(@person, :first_name)
23 |   end
24 | 
25 |   def test_length_client_side_hash_with_js_tokenizer
26 |     expected_hash = {
27 |       :messages => {
28 |         :is => "is the wrong length (should be 10 characters)"
29 |       },
30 |       :is => 10,
31 |       :js_tokenizer => %q{match(/\w+/g)}
32 |     }
33 |     assert_equal expected_hash, LengthValidator.new(:attributes => [:age], :is => 10, :tokenizer => proc { |value| value.split(/\w+/) }, :js_tokenizer => %q{match(/\w+/g)}).client_side_hash(@person, :first_name)
34 |   end
35 | 
36 |   def test_length_client_side_hash_with_minimum_and_maximum
37 |     expected_hash = {
38 |       :messages => {
39 |         :minimum => "is too short (minimum is 5 characters)",
40 |         :maximum => "is too long (maximum is 10 characters)"
41 |       },
42 |       :minimum => 5,
43 |       :maximum => 10
44 |     }
45 |     assert_equal expected_hash, LengthValidator.new(:attributes => [:age], :minimum => 5, :maximum => 10).client_side_hash(@person, :first_name)
46 |   end
47 | 
48 |   def test_length_client_side_hash_with_range
49 |     expected_hash = {
50 |       :messages => {
51 |         :minimum => "is too short (minimum is 5 characters)",
52 |         :maximum => "is too long (maximum is 10 characters)"
53 |       },
54 |       :minimum => 5,
55 |       :maximum => 10
56 |     }
57 |     assert_equal expected_hash, LengthValidator.new(:attributes => [:age], :within => 5..10).client_side_hash(@person, :first_name)
58 |   end
59 | 
60 | end
61 | 
62 | 


--------------------------------------------------------------------------------
/test/active_record/cases/test_uniqueness_validator.rb:
--------------------------------------------------------------------------------
 1 | require 'active_record/cases/test_base'
 2 | 
 3 | class ActiveRecord::UniquenessValidatorTest < ClientSideValidations::ActiveRecordTestBase
 4 | 
 5 |   def test_uniqueness_client_side_hash
 6 |     expected_hash = { :message => "has already been taken", :case_sensitive => true }
 7 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name]).client_side_hash(@user, :name)
 8 |   end
 9 | 
10 |   def test_uniqueness_client_side_hash_with_custom_message
11 |     expected_hash = { :message => "is not available", :case_sensitive => true }
12 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name], :message => "is not available").client_side_hash(@user, :name)
13 |   end
14 | 
15 |   def test_uniqueness_client_side_hash
16 |     @user.stubs(:new_record?).returns(false)
17 |     @user.stubs(:id).returns(1)
18 |     expected_hash = { :message => "has already been taken", :case_sensitive => true, :id => 1 }
19 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name]).client_side_hash(@user, :name)
20 |   end
21 | 
22 |   def test_uniqueness_client_side_hash_with_single_scope_item
23 |     @user.stubs(:age).returns(30)
24 |     @user.stubs(:title).returns("test title")
25 |     expected_hash = { :message => "has already been taken", :case_sensitive => true, :scope => {:title => "test title"} }
26 |     result_hash = UniquenessValidator.new(:attributes => [:name], :scope => :title).client_side_hash(@user, :name)
27 |     assert_equal expected_hash, result_hash
28 |   end
29 | 
30 |   def test_uniqueness_client_side_hash_with_multiple_scope_items
31 |     @user.stubs(:age).returns(30)
32 |     @user.stubs(:title).returns("test title")
33 |     expected_hash = { :message => "has already been taken", :case_sensitive => true, :scope => {:age => 30, :title => "test title"} }
34 |     result_hash = UniquenessValidator.new(:attributes => [:name], :scope => [:age, :title]).client_side_hash(@user, :name)
35 |     assert_equal expected_hash, result_hash
36 |   end
37 | 
38 |   def test_uniqueness_client_side_hash_with_empty_scope_array
39 |     expected_hash = { :message => "has already been taken", :case_sensitive => true }
40 |     result_hash = UniquenessValidator.new(:attributes => [:name], :scope => []).client_side_hash(@user, :name)
41 |     assert_equal expected_hash, result_hash
42 |   end
43 | 
44 | end
45 | 
46 | 


--------------------------------------------------------------------------------
/test/mongoid/cases/test_middleware.rb:
--------------------------------------------------------------------------------
 1 | require 'middleware/cases/helper'
 2 | require 'mongoid/cases/helper'
 3 | 
 4 | class ClientSideValidationsMongoidMiddlewareTest < Test::Unit::TestCase
 5 |   include Rack::Test::Methods
 6 | 
 7 |   def setup
 8 |     # I've been burned enough times with not having the db clear
 9 |     # I should probably use a db cleaner instead of this
10 |     Book.delete_all
11 |   end
12 | 
13 |   def teardown
14 |     Book.delete_all
15 |   end
16 | 
17 |   def app
18 |     app = Proc.new { |env| [200, {}, ['success']] }
19 |     ClientSideValidations::Middleware::Validators.new(app)
20 |   end
21 | 
22 |   def test_uniqueness_when_resource_exists
23 |     Book.create(:author_email => 'book@test.com')
24 |     get '/validators/uniqueness.json', { 'book[author_email]' => 'book@test.com' }
25 | 
26 |     assert_equal 'false', last_response.body
27 |     assert last_response.ok?
28 |   end
29 | 
30 |   def test_uniqueness_when_resource_does_not_exist
31 |     get '/validators/uniqueness.json', { 'book[author_email]' => 'book@test.com' }
32 | 
33 |     assert_equal 'true', last_response.body
34 |     assert last_response.not_found?
35 |   end
36 | 
37 |   def test_uniqueness_when_id_is_given
38 |     book = Book.create(:author_email => 'book@test.com')
39 |     get '/validators/uniqueness.json', { 'book[author_email]' => 'book@test.com', 'id' => book.id }
40 | 
41 |     assert_equal 'true', last_response.body
42 |     assert last_response.not_found?
43 |   end
44 | 
45 |   def test_uniqueness_when_scope_is_given
46 |     Book.create(:author_email => 'book@test.com', :age => 25)
47 |     get '/validators/uniqueness.json', { 'book[author_email]' => 'book@test.com', 'scope' => { 'age' => 30 } }
48 | 
49 |     assert_equal 'true', last_response.body
50 |     assert last_response.not_found?
51 |   end
52 | 
53 |   def test_uniqueness_when_multiple_scopes_are_given
54 |     Book.create(:author_email => 'book@test.com', :age => 30, :author_name => 'Brian')
55 |     get '/validators/uniqueness.json', { 'book[author_email]' => 'book@test.com', 'scope' => { 'age' => 30, 'author_name' => 'Robert' } }
56 | 
57 |     assert_equal 'true', last_response.body
58 |     assert last_response.not_found?
59 |   end
60 | 
61 |   def test_uniqueness_when_case_insensitive
62 |     Book.create(:author_name => 'Brian')
63 |     get '/validators/uniqueness.json', { 'book[author_name]' => 'BRIAN', 'case_sensitive' => false }
64 | 
65 |     assert_equal 'false', last_response.body
66 |     assert last_response.ok?
67 |   end
68 | end
69 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/action_view/form_helper.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActionView::Helpers
 2 |   module FormHelper
 3 |     class Error < StandardError; end
 4 | 
 5 |     def form_for(record_or_name_or_array, *args, &proc)
 6 |       options = args.extract_options!
 7 |       if options[:validate]
 8 | 
 9 |         # Always turn off HTML5 Validations
10 |         options[:html] ||= {}
11 |         options[:html][:novalidate] = true
12 | 
13 |         case record_or_name_or_array
14 |         when String, Symbol
15 |           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.'
16 |         when Array
17 |           object = record_or_name_or_array.last
18 |         else
19 |           object = record_or_name_or_array
20 |         end
21 |       end
22 | 
23 |       @validators = {}
24 |       # Order matters here. Rails mutates the options object
25 |       script = client_side_form_settings(object, options)
26 |       form   = super(record_or_name_or_array, *(args << options), &proc)
27 |       # Because of the load order requirement above this sub is necessary
28 |       # Would be nice to not do this
29 |       "#{form}#{script ? script.sub('"validator_hash"', @validators.to_json) : nil}".html_safe
30 |     end
31 | 
32 |     def apply_form_for_options!(object_or_array, options)
33 |       super
34 |       options[:html][:validate] = true if options[:validate]
35 |     end
36 | 
37 |     def fields_for(record_or_name_or_array, *args, &block)
38 |       output = super
39 |       @validators.merge!(args.last[:validators]) if @validators
40 |       output
41 |     end
42 | 
43 |     private
44 | 
45 |     def client_side_form_settings(object, options)
46 |       if options[:validate]
47 |         builder = options[:builder] || ActionView::Base.default_form_builder
48 | 
49 |         if options[:html] && options[:html][:id]
50 |           var_name = options[:html][:id]
51 |         else
52 |           var_name = if object.respond_to?(:persisted?) && object.persisted?
53 |             options[:as] ? "#{options[:as]}_edit" : dom_id(object, :edit)
54 |           else
55 |             options[:as] ? "#{options[:as]}_new" : dom_id(object)
56 |           end
57 |         end
58 | 
59 |         content_tag(:script) do
60 |           "var #{var_name} = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};".html_safe
61 |         end
62 | 
63 |       end
64 |     end
65 | 
66 |   end
67 | end
68 | 
69 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/length.js:
--------------------------------------------------------------------------------
 1 | module('Length options');
 2 | 
 3 | test('when allowed length is 3 and value length is 3', function() {
 4 |   var element = $('<input type="text" />');
 5 |   var options = { messages: { is: "failed validation" }, is: 3 };
 6 |   element.val('123');
 7 |   equal(clientSideValidations.validators.local.length(element, options), undefined);
 8 | });
 9 | 
10 | test('when allowed length is 3 and value length is 4', function() {
11 |   var element = $('<input type="text" />');
12 |   var options = { messages: { is: "failed validation" }, is: 3 };
13 |   element.val('1234');
14 |   equal(clientSideValidations.validators.local.length(element, options), "failed validation");
15 | });
16 | 
17 | test('when allowed length is 3 and value length is 2', function() {
18 |   var element = $('<input type="text" />');
19 |   var options = { messages: { is: "failed validation" }, is: 3 };
20 |   element.val('12');
21 |   equal(clientSideValidations.validators.local.length(element, options), "failed validation");
22 | });
23 | 
24 | test('when allowing blank and allowed length is 3', function() {
25 |   var element = $('<input type="text" />');
26 |   var options = { messages: { is: "failed validation" }, is: 3, allow_blank: true };
27 |   equal(clientSideValidations.validators.local.length(element, options), undefined);
28 | });
29 | 
30 | test('when allowing blank and allowed length is 3', function() {
31 |   var element = $('<input type="text" />');
32 |   var options = { messages: { is: "failed validation" }, is: 3 };
33 |   equal(clientSideValidations.validators.local.length(element, options), "failed validation");
34 | });
35 | 
36 | test('when allowed length is 3 and a differnet tokenizer', function() {
37 |   var element = $('<input type="text" />');
38 |   element.val("one two three");
39 |   var options = { messages: { is: "failed validation" }, is: 3, js_tokenizer: "match(/\\w+/g)" };
40 |   equal(clientSideValidations.validators.local.length(element, options), undefined);
41 | });
42 | 
43 | test('when allowed length minimum is 3 and value length is 3', function() {
44 |   var element = $('<input type="text" />');
45 |   var options = { messages: { is: "failed validation" }, is: 3 };
46 |   element.val('123');
47 |   equal(clientSideValidations.validators.local.length(element, options), undefined);
48 | });
49 | 
50 | test('when allowed length minimum is 3 and value length is 2', function() {
51 |   var element = $('<input type="text" />');
52 |   var options = { messages: { minimum: "failed validation" }, minimum: 3 };
53 |   element.val('12');
54 |   equal(clientSideValidations.validators.local.length(element, options), "failed validation");
55 | });
56 | 
57 | test('when allowed length maximum is 3 and value length is 3', function() {
58 |   var element = $('<input type="text" />');
59 |   var options = { messages: { is: "failed validation" }, is: 3 };
60 |   element.val('123');
61 |   equal(clientSideValidations.validators.local.length(element, options), undefined);
62 | });
63 | 
64 | test('when allowed length maximum is 3 and value length is 4', function() {
65 |   var element = $('<input type="text" />');
66 |   var options = { messages: { maximum: "failed validation" }, maximum: 3 };
67 |   element.val('1234');
68 |   equal(clientSideValidations.validators.local.length(element, options), "failed validation");
69 | });
70 | 
71 | 


--------------------------------------------------------------------------------
/HISTORY:
--------------------------------------------------------------------------------
  1 | == 3.0.5
  2 |   Resolved confirmation field without validators bug issue #62
  3 | 
  4 | == 3.0.4
  5 |   ActiveRecord Uniquness middleware fix for primary key [mat813]
  6 |   Support for select helpers
  7 | 
  8 | == 3.0.3
  9 |   Ignore generic block validators
 10 |   Filter validators per form input
 11 |   Case sensitive fix for MySQL
 12 |   Always turn off HTML5 validations by forcing novalidate
 13 | 
 14 | == 3.0.2
 15 |   Fixed conditional validator issue. Critical bug
 16 | 
 17 | == 3.0.1
 18 |   Validators no longer rendered as attributes for HTML elements but as part of the settings JSON
 19 |   Fixed single scope item bug with uniqueness validators
 20 |   Fixed autofocus issue
 21 |   Fixed validate_with, ignore all of them
 22 |   Fixed issue with empty scope arrays on uniqueness validator
 23 | 
 24 | == 3.0.0
 25 |   Includes all changes from 3.0.0.alpha.1 - 3.0.0.rc.2
 26 | 
 27 | == 3.0.0.rc.2
 28 |   Includes all changes from 3.0.0.beta.7 - 3.0.0.beta.9
 29 | 
 30 | == 3.0.0.beta.9
 31 |   Removed allow_blank for uniqueness
 32 |   Namespaced middleware
 33 | 
 34 | == 3.0.0.beta.8
 35 |   addError and removeError are not callbacks
 36 |   test against more versions of jQuery
 37 |   resolved issue 19, handling ranges with floats
 38 |   Custom remote validators through middleware
 39 |   Fixed tests for all browsers. Only the async tests are failing
 40 |   in Firefox and IE. It can be ignored for now.
 41 | 
 42 | == 3.0.0.beta.7
 43 |   Significant changes required a move back to beta
 44 | 
 45 |   Don't require #new_record?
 46 |   Moved applyErrorField to the element:valdiate:fail callback
 47 | 
 48 |   Rewrote the Javascript to play nicer with jQuery
 49 |   client-side-validations.js is now rails.validations.js
 50 | 
 51 | == 3.0.0.rc.1
 52 |   Scopes on uniqeuness validator
 53 | 
 54 | == 3.0.0.beta.6
 55 |   Renamed clientSideValidations.validator to clientSideValidations.validators
 56 | 
 57 | == 3.0.0.beta.5
 58 |   Fixed load order issue with other form builders
 59 |   Better ActiveRecord Uniqueness
 60 |   JS Validator Callbacks
 61 | 
 62 | == 3.0.0.beta.4
 63 |   Fix for lower case \z as Regex terminator
 64 |   Reduce complecity of error wrapper rendering
 65 |   SimpleForm and Formtastic javascript unit tests
 66 |   Removed keyup events
 67 | 
 68 | == 3.0.0.beta.3
 69 |   Custom form id
 70 | 
 71 | == 3.0.0.beta.2
 72 |   Forgot to include javascript files in the gem
 73 | 
 74 | == 3.0.0.beta.1
 75 |   Javascript file fixes
 76 |   Added QUnit tests
 77 |   Fixed some JS bugs found while writing QUnit tests
 78 | 
 79 | == 3.0.0.alpha.9
 80 |   I'm an idiot. I yanked alpha.8 by mistake
 81 | 
 82 | == 3.0.0.alpha.8
 83 |   Range JSON fix
 84 |   Handle nested resources for uniqueness validator
 85 |   Don't repeat validation if value hasn't changed
 86 |   Fix for :on => :create & :on => :update
 87 | 
 88 | == 3.0.0.alpha.7
 89 |   Regex JSON fix
 90 |   Javascript Function metaprogramming fix
 91 | 
 92 | == 3.0.0.alpha.6
 93 |   Fix for data-validators parsing
 94 |   Fix for length Javscript validator
 95 | 
 96 | == 3.0.0.alpha.5
 97 |   Formtastic support
 98 | 
 99 | == 3.0.0.alpha.4
100 |   fields_for now inherits :validate option from parent
101 |   SimpleForm support
102 |   Added adapters for error field detach and apply functions
103 | 
104 | == 3.0.0.alpha.3
105 |   Turn off client side validations per field
106 |   Support remote forms
107 |   Fix load order issue with conflicting gems
108 | 
109 | == 3.0.0.alpha.2
110 |   Ruby 1.8.7 support
111 | 
112 | == 3.0.0.alpha.1
113 |   Complete rewrite!
114 | 
115 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/uniqueness.js:
--------------------------------------------------------------------------------
 1 | module('Uniqueness options', {
 2 |   setup: function() {
 3 |     new_user = {
 4 |       type: 'ActionView::Helpers::FormBuilder',
 5 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label class="message"></label></div>',
 6 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
 7 |       validators: {'user[email]':{"uniqueness":{"message": "must be unique", "scope":{name:"pass"}},"presence":{"message": "must be present"}}}
 8 |     }
 9 | 
10 |     $('#qunit-fixture')
11 |       .append($('<form />', {
12 |         action: '/users',
13 |         'data-validate': true,
14 |         method: 'post',
15 |         id: 'new_user'
16 |       }))
17 |       .find('form')
18 |         .append($('<input />', {
19 |           name: 'user[name]',
20 |           id: 'user_name',
21 |           type: 'text'
22 |         }))
23 |         .append($('<input />', {
24 |           name: 'user[email]',
25 |           id: 'user_email',
26 |           'data-validate': 'true',
27 |           type: 'text'
28 |         }))
29 | 
30 |     $('form#new_user').validate();
31 |   }
32 | });
33 | 
34 | test('when matching uniqueness on a non-nested resource', function() {
35 |   var element = $('<input type="text" name="user[email]"/>');
36 |   var options = { 'message': "failed validation" };
37 |   element.val('nottaken@test.com');
38 |   equal(clientSideValidations.validators.remote.uniqueness(element, options), undefined);
39 | });
40 | 
41 | test('when matching uniqueness on a non-nested resource', function() {
42 |   var element = $('<input type="text" name="user[email]"/>');
43 |   var options = { 'message': "failed validation" };
44 |   element.val('taken@test.com');
45 |   equal(clientSideValidations.validators.remote.uniqueness(element, options), "failed validation");
46 | });
47 | 
48 | test('when matching uniqueness on a nested singular resource', function() {
49 |   var element = $('<input type="text" name="profile[user_attributes][email]"/>');
50 |   var options = { 'message': "failed validation" };
51 |   element.val('nottaken@test.com');
52 |   equal(clientSideValidations.validators.remote.uniqueness(element, options), undefined);
53 | });
54 | 
55 | test('when matching uniqueness on a nested singular resource', function() {
56 |   var element = $('<input type="text" name="profile[user_attributes][email]"/>');
57 |   var options = { 'message': "failed validation" };
58 |   element.val('taken@test.com');
59 |   equal(clientSideValidations.validators.remote.uniqueness(element, options), "failed validation");
60 | });
61 | 
62 | test('when using scopes with no replacement', function() {
63 |   var element = $('<input type="text" name="person[age]" />');
64 |   var options = { 'message': "failed validation", 'with': /\d+/, 'scope': { 'name': 'test name' } };
65 |   element.val('test');
66 |   equal(clientSideValidations.validators.remote.uniqueness(element, options), "failed validation");
67 | });
68 | 
69 | test('when using scopes with replacement', function() {
70 |   var element = $('<input type="text" name="person[age]" />');
71 |   var options = { 'message': "failed validation", 'with': /\d+/, 'scope': { 'name': 'test name' } };
72 |   element.val('test')
73 |   $('#qunit-fixture').append('<input type="text" name="person[name]" />').find('input[name="person[name]"]').val('other name');
74 |   equal(clientSideValidations.validators.remote.uniqueness(element, options), undefined);
75 | });
76 | 
77 | test('when validating by scope and mixed focus order', function() {
78 |   var unique_element = $('#user_email'), scope_element = $('#user_name');
79 |   unique_element.val('free@test.com');
80 |   unique_element.trigger('change');
81 |   unique_element.trigger('focusout');
82 |   equal($('.message[for="user_email"]').text(), '');
83 | 
84 |   scope_element.val('test name');
85 |   scope_element.trigger('change');
86 |   scope_element.trigger('focusout');
87 |   equal($('.message[for="user_email"]').text(), 'must be unique');
88 | });
89 | 
90 | 


--------------------------------------------------------------------------------
/README.markdown:
--------------------------------------------------------------------------------
  1 | # Rails 3 Client Side Validations #
  2 | 
  3 | Client Side Validations made easy for your Rails 3 applications!
  4 | 
  5 | In addition to this README please checkout the [wiki](https://github.com/bcardarella/client_side_validations/wiki)
  6 | 
  7 | ## Project Goals ##
  8 | 
  9 | 1. Follow the best practices for client side validations developed by [Luke Wroblewski](http://www.alistapart.com/articles/inline-validation-in-web-forms/)
 10 | 2. Automatically extract and apply validation rules defined on the
 11 |    server to the client.
 12 | 3. In the cases where a server-side validation rule would not work on
 13 |    the client (i.e. conditional callbacks like :if, :unless) then do not
 14 |    attempt client side validations. Fall back to the server side
 15 |    validation.
 16 | 4. The client side validation error rendering should be
 17 |    indistinguishable from the server side validation error rendering.
 18 | 5. Wide browser compliancy. I've tested with IE8, seems to work OK.
 19 | 6. Work with any ActiveModel::Validations based model
 20 | 7. Validate nested fields
 21 | 8. Support custom validations
 22 | 9. Support custom FormBuilders like [SimpleForm](https://github.com/plataformatec/simple_form) and [Formtastic](https://github.com/justinfrench/formtastic)
 23 | 10. Client side validation callbacks
 24 | 
 25 | ## Install ##
 26 | 
 27 | Include Client Side Validations in your Gemfile
 28 | 
 29 |     gem 'client_side_validations'
 30 | 
 31 | Then run the install generator
 32 | 
 33 |     rails g client_side_validations:install
 34 | 
 35 | This will install two files:
 36 | 
 37 |     config/initializers/client_side_validations.rb
 38 |     public/javascripts/rails.validations.js
 39 | 
 40 | ## Upgrading ##
 41 | 
 42 | Always be sure to run
 43 | 
 44 |     rails g client_side_validations:install
 45 | 
 46 | After upgrading Client Side Validations. There is a good chance that the
 47 | rails.validations.js file has changed.
 48 | 
 49 | ## Usage ##
 50 | 
 51 | Client Side Validations requires [jQuery](http://jquery.com) version >= 1.4.1
 52 | 
 53 | Include the client-side-validations.js file in your layout
 54 | 
 55 |     <%= javascript_include_tag 'jquery', 'rails.validations'-%>
 56 | 
 57 | Turn on the validations for each form_for
 58 | 
 59 |     <%= form_for @book, :validate => true do |book| -%>
 60 | 
 61 | Nested fields automatically inherit the :validate value. If you want to
 62 | turn it off just pass :validate => false to fields_for
 63 | 
 64 |     <%= book.fields_for :pages, :validate => false do |page| -%>
 65 | 
 66 | ## Initializer ##
 67 | 
 68 | The initializer includes a commented out ActionView::Base.field_error_proc.
 69 | Uncomment this to render your error messages inline with the input fields.
 70 | 
 71 | I recommend you not use a solution similar to error_messages_for. Client
 72 | Side Validations is never going to support rendering these type of error
 73 | messages. If you want to maintain consistency between the client side
 74 | rendered validation error messages and the server side rendered
 75 | validation error messages please use what is in
 76 | config/initializers/client_side_validations.rb
 77 | 
 78 | ## SimpleForm ##
 79 | 
 80 | Client Side Validations supports [SimpleForm](https://github.com/plataformatec/simple_form):
 81 | 
 82 |     <%= simple_form_for @book, :validate => true do |book| -%>
 83 | 
 84 | By default the latest version of SimpleForm will attach HTML5 Form
 85 | Validators. Client Side Validations will turn off the HTML5 Form
 86 | Validators if a given form is told to use Client Side Validations.
 87 | 
 88 | ## Formtastic ##
 89 | 
 90 | Client Side Validations supports [Formtastic](https://github.com/justinfrench/formtastic):
 91 | 
 92 |     <%= semantic_form_for @book, :validate => true do |book| -%>
 93 | 
 94 | ## Mongoid ##
 95 | 
 96 | NOTE: Mongoid *must* be required before ClientSideValidations in your Gemfile.
 97 | 
 98 | Client Side Validations supports [Mongoid](https://github.com/mongoid/mongoid) >= 2.0
 99 | 
100 | Anything before 2.0 won't work with Client Side Validations.
101 | 
102 | ## Client Side Validation Callbacks ##
103 | [See the wiki](https://github.com/bcardarella/client_side_validations/wiki/Callbacks)
104 | 
105 | ## Known Issues ##
106 | 
107 | The major outstanding issue is with radio buttons. [See the open ticket](https://github.com/bcardarella/client_side_validations/issues#issue/24).
108 | 
109 | ## Legal ##
110 | 
111 | Brian Cardarella &copy; 2011
112 | 
113 | [@bcardarella](http://twitter.com/bcardarella)
114 | 
115 | [Licensed under the MIT license](http://www.opensource.org/licenses/mit-license.php)
116 | 


--------------------------------------------------------------------------------
/test/javascript/public/vendor/jquery.metadata.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Metadata - jQuery plugin for parsing metadata from elements
  3 |  *
  4 |  * Copyright (c) 2006 John Resig, Yehuda Katz, J�örn Zaefferer, Paul McLanahan
  5 |  *
  6 |  * Dual licensed under the MIT and GPL licenses:
  7 |  *   http://www.opensource.org/licenses/mit-license.php
  8 |  *   http://www.gnu.org/licenses/gpl.html
  9 |  *
 10 |  * Revision: $Id: jquery.metadata.js 4187 2007-12-16 17:15:27Z joern.zaefferer $
 11 |  *
 12 |  */
 13 | 
 14 | /**
 15 |  * Sets the type of metadata to use. Metadata is encoded in JSON, and each property
 16 |  * in the JSON will become a property of the element itself.
 17 |  *
 18 |  * There are three supported types of metadata storage:
 19 |  *
 20 |  *   attr:  Inside an attribute. The name parameter indicates *which* attribute.
 21 |  *
 22 |  *   class: Inside the class attribute, wrapped in curly braces: { }
 23 |  *
 24 |  *   elem:  Inside a child element (e.g. a script tag). The
 25 |  *          name parameter indicates *which* element.
 26 |  *
 27 |  * The metadata for an element is loaded the first time the element is accessed via jQuery.
 28 |  *
 29 |  * As a result, you can define the metadata type, use $(expr) to load the metadata into the elements
 30 |  * matched by expr, then redefine the metadata type and run another $(expr) for other elements.
 31 |  *
 32 |  * @name $.metadata.setType
 33 |  *
 34 |  * @example <p id="one" class="some_class {item_id: 1, item_label: 'Label'}">This is a p</p>
 35 |  * @before $.metadata.setType("class")
 36 |  * @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
 37 |  * @desc Reads metadata from the class attribute
 38 |  *
 39 |  * @example <p id="one" class="some_class" data="{item_id: 1, item_label: 'Label'}">This is a p</p>
 40 |  * @before $.metadata.setType("attr", "data")
 41 |  * @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
 42 |  * @desc Reads metadata from a "data" attribute
 43 |  *
 44 |  * @example <p id="one" class="some_class"><script>{item_id: 1, item_label: 'Label'}</script>This is a p</p>
 45 |  * @before $.metadata.setType("elem", "script")
 46 |  * @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
 47 |  * @desc Reads metadata from a nested script element
 48 |  *
 49 |  * @param String type The encoding type
 50 |  * @param String name The name of the attribute to be used to get metadata (optional)
 51 |  * @cat Plugins/Metadata
 52 |  * @descr Sets the type of encoding to be used when loading metadata for the first time
 53 |  * @type undefined
 54 |  * @see metadata()
 55 |  */
 56 | 
 57 | (function($) {
 58 | 
 59 | $.extend({
 60 |   metadata : {
 61 |     defaults : {
 62 |       type: 'class',
 63 |       name: 'metadata',
 64 |       cre: /({.*})/,
 65 |       single: 'metadata'
 66 |     },
 67 |     setType: function( type, name ){
 68 |       this.defaults.type = type;
 69 |       this.defaults.name = name;
 70 |     },
 71 |     get: function( elem, opts ){
 72 |       var settings = $.extend({},this.defaults,opts);
 73 |       // check for empty string in single property
 74 |       if ( !settings.single.length ) settings.single = 'metadata';
 75 | 
 76 |       var data = $.data(elem, settings.single);
 77 |       // returned cached data if it already exists
 78 |       if ( data ) return data;
 79 | 
 80 |       data = "{}";
 81 | 
 82 |       if ( settings.type == "class" ) {
 83 |         var m = settings.cre.exec( elem.className );
 84 |         if ( m )
 85 |           data = m[1];
 86 |       } else if ( settings.type == "elem" ) {
 87 |         if( !elem.getElementsByTagName )
 88 |           return undefined;
 89 |         var e = elem.getElementsByTagName(settings.name);
 90 |         if ( e.length )
 91 |           data = $.trim(e[0].innerHTML);
 92 |       } else if ( elem.getAttribute != undefined ) {
 93 |         var attr = elem.getAttribute( settings.name );
 94 |         if ( attr )
 95 |           data = attr;
 96 |       }
 97 | 
 98 |       if ( data.indexOf( '{' ) <0 )
 99 |       data = "{" + data + "}";
100 | 
101 |       data = eval("(" + data + ")");
102 | 
103 |       $.data( elem, settings.single, data );
104 |       return data;
105 |     }
106 |   }
107 | });
108 | 
109 | /**
110 |  * Returns the metadata object for the first member of the jQuery object.
111 |  *
112 |  * @name metadata
113 |  * @descr Returns element's metadata object
114 |  * @param Object opts An object contianing settings to override the defaults
115 |  * @type jQuery
116 |  * @cat Plugins/Metadata
117 |  */
118 | $.fn.metadata = function( opts ){
119 |   return $.metadata.get( this[0], opts );
120 | };
121 | 
122 | })(jQuery);
123 | 


--------------------------------------------------------------------------------
/test/action_view/cases/helper.rb:
--------------------------------------------------------------------------------
  1 | require 'base_helper'
  2 | require 'action_view'
  3 | require 'client_side_validations/action_view'
  4 | require 'action_view/template/handlers/erb'
  5 | require 'action_view/models'
  6 | 
  7 | module ActionViewTestSetup
  8 |   include ::ClientSideValidations::ActionView::Helpers::FormHelper
  9 |   include ::ClientSideValidations::ActionView::Helpers::FormTagHelper
 10 | 
 11 |   def form_for(*)
 12 |     @output_buffer = super
 13 |   end
 14 | 
 15 |   def setup
 16 |     super
 17 | 
 18 |     # Create "label" locale for testing I18n label helpers
 19 |     I18n.backend.store_translations 'label', {
 20 |       :activemodel => {
 21 |         :attributes => {
 22 |           :post => {
 23 |             :cost => "Total cost"
 24 |           }
 25 |         }
 26 |       },
 27 |       :helpers => {
 28 |         :label => {
 29 |           :post => {
 30 |             :body => "Write entire text here"
 31 |           }
 32 |         }
 33 |       }
 34 |     }
 35 | 
 36 |     # Create "submit" locale for testing I18n submit helpers
 37 |     I18n.backend.store_translations 'submit', {
 38 |       :helpers => {
 39 |         :submit => {
 40 |           :create => 'Create %{model}',
 41 |           :update => 'Confirm %{model} changes',
 42 |           :submit => 'Save changes',
 43 |           :another_post => {
 44 |             :update => 'Update your %{model}'
 45 |           }
 46 |         }
 47 |       }
 48 |     }
 49 | 
 50 |     @post = Post.new
 51 |     @comment = Comment.new
 52 |     def @post.errors()
 53 |       Class.new{
 54 |         def [](field); field == "author_name" ? ["can't be empty"] : [] end
 55 |         def empty?() false end
 56 |         def count() 1 end
 57 |         def full_messages() [ "Author name can't be empty" ] end
 58 |       }.new
 59 |     end
 60 |     def @post.id; 123; end
 61 |     def @post.id_before_type_cast; 123; end
 62 |     def @post.to_param; '123'; end
 63 | 
 64 |     @post.persisted   = true
 65 |     @post.title       = "Hello World"
 66 |     @post.author_name = ""
 67 |     @post.body        = "Back to the hill and over it again!"
 68 |     @post.secret      = 1
 69 |     @post.written_on  = Date.new(2004, 6, 15)
 70 |   end
 71 | 
 72 |   def url_for(object)
 73 |     @url_for_options = object
 74 |     if object.is_a?(Hash)
 75 |       "http://www.example.com"
 76 |     else
 77 |       super
 78 |     end
 79 |   end
 80 | 
 81 |   def snowman(method = nil)
 82 |     txt =  %{<div style="margin:0;padding:0;display:inline">}
 83 |     txt << %{<input name="utf8" type="hidden" value="&#x2713;" />}
 84 |     txt << %{<input name="_method" type="hidden" value="#{method}" />} if method
 85 |     txt << %{</div>}
 86 |   end
 87 | 
 88 |   def form_text(action = "http://www.example.com", id = nil, html_class = nil, remote = nil, validators = nil)
 89 |     txt =  %{<form accept-charset="UTF-8" action="#{action}"}
 90 |     txt << %{ data-remote="true"} if remote
 91 |     txt << %{ class="#{html_class}"} if html_class
 92 |     txt << %{ data-validate="true"} if validators
 93 |     txt << %{ id="#{id}"} if id
 94 |     txt << %{ method="post"}
 95 |     txt << %{ novalidate="novalidate"} if validators
 96 |     txt << %{>}
 97 |   end
 98 | 
 99 |   def whole_form(action = "http://www.example.com", id = nil, html_class = nil, options = nil)
100 |     contents = block_given? ? yield : ""
101 | 
102 |     if options.is_a?(Hash)
103 |       method, remote, validators = options.values_at(:method, :remote, :validators)
104 |     else
105 |       method = options
106 |     end
107 | 
108 |     html = form_text(action, id, html_class, remote, validators) + snowman(method) + (contents || "") + "</form>"
109 | 
110 |     if options.is_a?(Hash) && options[:validators]
111 |       html + %Q{<script>var #{id} = #{client_side_form_settings_helper.merge(:validators => validators).to_json};</script>}
112 |     else
113 |       html
114 |     end
115 |   end
116 | 
117 |   protected
118 |     def comments_path(post)
119 |       "/posts/#{post.id}/comments"
120 |     end
121 |     alias_method :post_comments_path, :comments_path
122 | 
123 |     def comment_path(post, comment)
124 |       "/posts/#{post.id}/comments/#{comment.id}"
125 |     end
126 |     alias_method :post_comment_path, :comment_path
127 | 
128 |     def admin_comments_path(post)
129 |       "/admin/posts/#{post.id}/comments"
130 |     end
131 |     alias_method :admin_post_comments_path, :admin_comments_path
132 | 
133 |     def admin_comment_path(post, comment)
134 |       "/admin/posts/#{post.id}/comments/#{comment.id}"
135 |     end
136 |     alias_method :admin_post_comment_path, :admin_comment_path
137 | 
138 |     def posts_path
139 |       "/posts"
140 |     end
141 | 
142 |     def post_path(post, options = {})
143 |       if options[:format]
144 |         "/posts/#{post.id}.#{options[:format]}"
145 |       else
146 |         "/posts/#{post.id}"
147 |       end
148 |     end
149 | 
150 |     def protect_against_forgery?
151 |       false
152 |     end
153 | 
154 | end
155 | 


--------------------------------------------------------------------------------
/test/javascript/public/vendor/qunit.css:
--------------------------------------------------------------------------------
  1 | /** Font Family and Sizes */
  2 | 
  3 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
  4 |   font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
  5 | }
  6 | 
  7 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
  8 | #qunit-tests { font-size: smaller; }
  9 | 
 10 | 
 11 | /** Resets */
 12 | 
 13 | #qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult {
 14 |   margin: 0;
 15 |   padding: 0;
 16 | }
 17 | 
 18 | 
 19 | /** Header */
 20 | 
 21 | #qunit-header {
 22 |   padding: 0.5em 0 0.5em 1em;
 23 | 
 24 |   color: #8699a4;
 25 |   background-color: #0d3349;
 26 | 
 27 |   font-size: 1.5em;
 28 |   line-height: 1em;
 29 |   font-weight: normal;
 30 | 
 31 |   border-radius: 15px 15px 0 0;
 32 |   -moz-border-radius: 15px 15px 0 0;
 33 |   -webkit-border-top-right-radius: 15px;
 34 |   -webkit-border-top-left-radius: 15px;
 35 | }
 36 | 
 37 | #qunit-header a {
 38 |   text-decoration: none;
 39 |   color: #c2ccd1;
 40 | }
 41 | 
 42 | #qunit-header a:hover,
 43 | #qunit-header a:focus {
 44 |   color: #fff;
 45 | }
 46 | 
 47 | #qunit-banner {
 48 |   height: 5px;
 49 | }
 50 | 
 51 | #qunit-testrunner-toolbar {
 52 |   padding: 0em 0 0.5em 2em;
 53 | }
 54 | 
 55 | #qunit-userAgent {
 56 |   padding: 0.5em 0 0.5em 2.5em;
 57 |   background-color: #2b81af;
 58 |   color: #fff;
 59 |   text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
 60 | }
 61 | 
 62 | 
 63 | /** Tests: Pass/Fail */
 64 | 
 65 | #qunit-tests {
 66 |   list-style-position: inside;
 67 | }
 68 | 
 69 | #qunit-tests li {
 70 |   padding: 0.4em 0.5em 0.4em 2.5em;
 71 |   border-bottom: 1px solid #fff;
 72 |   list-style-position: inside;
 73 | }
 74 | 
 75 | #qunit-tests li strong {
 76 |   cursor: pointer;
 77 | }
 78 | 
 79 | #qunit-tests ol {
 80 |   margin-top: 0.5em;
 81 |   padding: 0.5em;
 82 | 
 83 |   background-color: #fff;
 84 | 
 85 |   border-radius: 15px;
 86 |   -moz-border-radius: 15px;
 87 |   -webkit-border-radius: 15px;
 88 | 
 89 |   box-shadow: inset 0px 2px 13px #999;
 90 |   -moz-box-shadow: inset 0px 2px 13px #999;
 91 |   -webkit-box-shadow: inset 0px 2px 13px #999;
 92 | }
 93 | 
 94 | #qunit-tests table {
 95 |   border-collapse: collapse;
 96 |   margin-top: .2em;
 97 | }
 98 | 
 99 | #qunit-tests th {
100 |   text-align: right;
101 |   vertical-align: top;
102 |   padding: 0 .5em 0 0;
103 | }
104 | 
105 | #qunit-tests td {
106 |   vertical-align: top;
107 | }
108 | 
109 | #qunit-tests pre {
110 |   margin: 0;
111 |   white-space: pre-wrap;
112 |   word-wrap: break-word;
113 | }
114 | 
115 | #qunit-tests del {
116 |   background-color: #e0f2be;
117 |   color: #374e0c;
118 |   text-decoration: none;
119 | }
120 | 
121 | #qunit-tests ins {
122 |   background-color: #ffcaca;
123 |   color: #500;
124 |   text-decoration: none;
125 | }
126 | 
127 | /*** Test Counts */
128 | 
129 | #qunit-tests b.counts                       { color: black; }
130 | #qunit-tests b.passed                       { color: #5E740B; }
131 | #qunit-tests b.failed                       { color: #710909; }
132 | 
133 | #qunit-tests li li {
134 |   margin: 0.5em;
135 |   padding: 0.4em 0.5em 0.4em 0.5em;
136 |   background-color: #fff;
137 |   border-bottom: none;
138 |   list-style-position: inside;
139 | }
140 | 
141 | /*** Passing Styles */
142 | 
143 | #qunit-tests li li.pass {
144 |   color: #5E740B;
145 |   background-color: #fff;
146 |   border-left: 26px solid #C6E746;
147 | }
148 | 
149 | #qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
150 | #qunit-tests .pass .test-name               { color: #366097; }
151 | 
152 | #qunit-tests .pass .test-actual,
153 | #qunit-tests .pass .test-expected           { color: #999999; }
154 | 
155 | #qunit-banner.qunit-pass                    { background-color: #C6E746; }
156 | 
157 | /*** Failing Styles */
158 | 
159 | #qunit-tests li li.fail {
160 |   color: #710909;
161 |   background-color: #fff;
162 |   border-left: 26px solid #EE5757;
163 | }
164 | 
165 | #qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
166 | #qunit-tests .fail .test-name,
167 | #qunit-tests .fail .module-name             { color: #000000; }
168 | 
169 | #qunit-tests .fail .test-actual             { color: #EE5757; }
170 | #qunit-tests .fail .test-expected           { color: green;   }
171 | 
172 | #qunit-banner.qunit-fail,
173 | #qunit-testrunner-toolbar                   { background-color: #EE5757; }
174 | 
175 | 
176 | /** Footer */
177 | 
178 | #qunit-testresult {
179 |   padding: 0.5em 0.5em 0.5em 2.5em;
180 | 
181 |   color: #2b81af;
182 |   background-color: #D2E0E6;
183 | 
184 |   border-radius: 0 0 15px 15px;
185 |   -moz-border-radius: 0 0 15px 15px;
186 |   -webkit-border-bottom-right-radius: 15px;
187 |   -webkit-border-bottom-left-radius: 15px;
188 | }
189 | 
190 | /** Fixture */
191 | 
192 | #qunit-fixture {
193 |   position: absolute;
194 |   top: -10000px;
195 |   left: -10000px;
196 | }
197 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_validations.rb:
--------------------------------------------------------------------------------
  1 | require 'active_model/cases/test_base'
  2 | 
  3 | class ActiveModel::ValidationsTest < ClientSideValidations::ActiveModelTestBase
  4 | 
  5 |   class Person
  6 |     include ::ActiveModel::Validations
  7 |     attr_accessor :first_name, :last_name, :age, :weight
  8 | 
  9 |     def self.name
 10 |       "Person"
 11 |     end
 12 | 
 13 |     def new_record?
 14 |       true
 15 |     end
 16 |   end
 17 | 
 18 |   def new_person
 19 |     person = Class.new(Person)
 20 |     yield(person)
 21 |     person.new
 22 |   end
 23 | 
 24 |   def test_validations_to_client_side_hash
 25 |     person = new_person do |p|
 26 |       p.validates_presence_of :first_name
 27 |     end
 28 |     expected_hash = {
 29 |       :first_name => {
 30 |         :presence => {
 31 |           :message => "can't be blank"
 32 |         }
 33 |       }
 34 |     }
 35 |     assert_equal expected_hash, person.client_side_validation_hash
 36 |   end
 37 | 
 38 |   def test_validations_to_client_side_hash_with_validations_allow_blank
 39 |     person = new_person do |p|
 40 |       p.validates_length_of :first_name, :is => 10, :allow_blank => true
 41 |       p.validates_format_of :first_name, :with => //, :allow_blank => true
 42 |     end
 43 |     expected_hash = {
 44 |       :first_name => {
 45 |         :length => {
 46 |           :messages => { :is => 'is the wrong length (should be 10 characters)'},
 47 |           :is => 10,
 48 |           :allow_blank => true
 49 |         },
 50 |         :format => {
 51 |           :message => 'is invalid',
 52 |           :with => //,
 53 |           :allow_blank => true
 54 |         }
 55 |       }
 56 |     }
 57 |     assert_equal expected_hash, person.client_side_validation_hash
 58 |   end
 59 | 
 60 |   def test_validations_to_client_side_hash_with_validations_on_create
 61 |     person = new_person do |p|
 62 |       p.validates_length_of :first_name, :is => 10, :on => :create
 63 |       p.validates_length_of :last_name, :is => 10, :on => :update
 64 |       p.validates_format_of :first_name, :with => //, :on => :update
 65 |       p.validates_format_of :last_name, :with => //, :on => :create
 66 |       p.validates_numericality_of :age, :on => :create
 67 |       p.validates_numericality_of :weight, :on => :update
 68 |       p.class_eval do
 69 |         def new_record?
 70 |           true
 71 |         end
 72 |       end
 73 |     end
 74 |     expected_hash = {
 75 |       :first_name => {
 76 |         :length => {
 77 |           :messages => { :is => 'is the wrong length (should be 10 characters)'},
 78 |           :is => 10,
 79 |         },
 80 |       },
 81 |       :last_name => {
 82 |         :format => {
 83 |           :message => 'is invalid',
 84 |           :with => //,
 85 |         }
 86 |       },
 87 |       :age => {
 88 |         :numericality => {
 89 |           :messages => { :numericality => 'is not a number' },
 90 |         }
 91 |       }
 92 |     }
 93 |     assert_equal expected_hash, person.client_side_validation_hash
 94 |   end
 95 | 
 96 |   def test_validations_to_client_side_hash_with_validations_on_update
 97 |     person = new_person do |p|
 98 |       p.validates_length_of :first_name, :is => 10, :on => :update
 99 |       p.validates_length_of :last_name, :is => 10, :on => :create
100 |       p.validates_format_of :first_name, :with => //, :on => :create
101 |       p.validates_format_of :last_name, :with => //, :on => :update
102 |       p.validates_numericality_of :age, :on => :update
103 |       p.validates_numericality_of :weight, :on => :create
104 |       p.class_eval do
105 |         def new_record?
106 |           false
107 |         end
108 |       end
109 |     end
110 |     expected_hash = {
111 |       :first_name => {
112 |         :length => {
113 |           :messages => { :is => 'is the wrong length (should be 10 characters)'},
114 |           :is => 10,
115 |         },
116 |       },
117 |       :last_name => {
118 |         :format => {
119 |           :message => 'is invalid',
120 |           :with => //,
121 |         }
122 |       },
123 |       :age => {
124 |         :numericality => {
125 |           :messages => { :numericality => 'is not a number' },
126 |         }
127 |       }
128 |     }
129 |     assert_equal expected_hash, person.client_side_validation_hash
130 |   end
131 | 
132 |   def test_validates_with_should_be_ignored
133 |     person = new_person do |p|
134 |       p.validates_with PersonValidator
135 |     end
136 | 
137 |     expected_hash = {}
138 |     assert_equal expected_hash, person.client_side_validation_hash
139 |   end
140 | 
141 |   def test_validators_with_if_or_unless_are_ignored
142 |     person = new_person do |p|
143 |       p.validates_presence_of :first_name, :if     => Proc.new { |p| true }
144 |       p.validates_presence_of :last_name,  :unless => Proc.new { |p| true }
145 |     end
146 | 
147 |     expected_hash = {}
148 |     assert_equal expected_hash, person.client_side_validation_hash
149 |   end
150 | 
151 |   def test_generic_block_validators_should_be_ignored
152 |     person = new_person do |p|
153 |       p.validates_each(:first_name) do |record, attr, value|
154 |         record.errors.add(:first_name, "failed")
155 |       end
156 |     end
157 | 
158 |     expected_hash = {}
159 |     assert_equal expected_hash, person.client_side_validation_hash
160 |   end
161 | end
162 | 
163 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/action_view/form_builder.rb:
--------------------------------------------------------------------------------
  1 | module ClientSideValidations::ActionView::Helpers
  2 |   module FormBuilder
  3 | 
  4 |     def self.included(base)
  5 |       (base.field_helpers - %w(apply_form_for_options! label check_box radio_button fields_for hidden_field)).each do |selector|
  6 |         base.class_eval <<-RUBY_EVAL
  7 |           def #{selector}_with_client_side_validations(method, options = {})
  8 |             apply_client_side_validators(method, options)
  9 |             options.delete(:validate)
 10 |             #{selector}_without_client_side_validations(method, options)
 11 |           end
 12 |         RUBY_EVAL
 13 | 
 14 |         base.class_eval { alias_method_chain selector, :client_side_validations }
 15 |       end
 16 | 
 17 |       base.class_eval do
 18 |         alias_method_chain :initialize,                :client_side_validations
 19 |         alias_method_chain :fields_for,                :client_side_validations
 20 |         alias_method_chain :check_box,                 :client_side_validations
 21 |         alias_method_chain :radio_button,              :client_side_validations
 22 |         alias_method_chain :select,                    :client_side_validations
 23 |         alias_method_chain :collection_select,         :client_side_validations
 24 |         alias_method_chain :grouped_collection_select, :client_side_validations
 25 |         alias_method_chain :time_zone_select,          :client_side_validations
 26 | 
 27 |         def self.client_side_form_settings(options, form_helper)
 28 |           {
 29 |             :type => self.to_s,
 30 |             :input_tag => form_helper.class.field_error_proc.call(%{<span id="input_tag" />}, Struct.new(:error_message, :tag_id).new([], "")),
 31 |             :label_tag => form_helper.class.field_error_proc.call(%{<label id="label_tag" />}, Struct.new(:error_message, :tag_id).new([], ""))
 32 |           }
 33 |         end
 34 |       end
 35 |     end
 36 | 
 37 |     def initialize_with_client_side_validations(object_name, object, template, options, proc)
 38 |       initialize_without_client_side_validations(object_name, object, template, options, proc)
 39 |       @options[:validators] = {}
 40 |     end
 41 | 
 42 |     def fields_for_with_client_side_validations(record_or_name_or_array, *args, &block)
 43 |       options = args.extract_options!
 44 |       options[:validate] ||= @options[:validate] if @options[:validate] && !options.key?(:validate)
 45 |       fields_for_without_client_side_validations(record_or_name_or_array, *(args << options), &block)
 46 |     end
 47 | 
 48 |     def check_box_with_client_side_validations(method, options = {}, checked_value = "1", unchecked_value = "0")
 49 |       apply_client_side_validators(method, options)
 50 |       check_box_without_client_side_validations(method, options, checked_value, unchecked_value)
 51 |     end
 52 | 
 53 |     def radio_button_with_client_side_validations(method, tag_value, options = {})
 54 |       apply_client_side_validators(method, options)
 55 |       radio_button_without_client_side_validations(method, tag_value, options)
 56 |     end
 57 | 
 58 |     def select_with_client_side_validations(method, choices, options = {}, html_options = {})
 59 |       apply_client_side_validators(method, html_options)
 60 |       select_without_client_side_validations(method, choices, options, html_options)
 61 |     end
 62 | 
 63 |     def collection_select_with_client_side_validations(method, collection, value_method, text_method, options = {}, html_options = {})
 64 |       apply_client_side_validators(method, html_options)
 65 |       collection_select_without_client_side_validations(method, collection, value_method, text_method, options, html_options)
 66 |     end
 67 | 
 68 |     def grouped_collection_select_with_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
 69 |       apply_client_side_validators(method, html_options)
 70 |       grouped_collection_select_without_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
 71 |     end
 72 | 
 73 |     def time_zone_select_with_client_side_validations(method, priority_zones = nil, options = {}, html_options = {})
 74 |       apply_client_side_validators(method, html_options)
 75 |       time_zone_select_without_client_side_validations(method, priority_zones = nil, options, html_options)
 76 |     end
 77 | 
 78 |   private
 79 | 
 80 |     def apply_client_side_validators(method, options = {})
 81 |       if @options[:validate] && options[:validate] != false && validators = filter_validators(@object.client_side_validation_hash[method], options[:validate])
 82 |         options.merge!("data-validate" => true)
 83 |         @options[:validators].merge!("#{@object_name}[#{method}]" => validators)
 84 |       end
 85 |     end
 86 | 
 87 |     def filter_validators(validators, filters)
 88 |       if validators
 89 |         filtered_validators = validators.inject({}) do |filtered_validators, validator|
 90 |           unless filters && filters.key?(validator.first) && !filters[validator.first]
 91 |             filtered_validators[validator.first] = validator.last
 92 |           end
 93 | 
 94 |           filtered_validators
 95 |         end
 96 | 
 97 |         filtered_validators.empty? ? nil : filtered_validators
 98 |       end
 99 |     end
100 | 
101 |   end
102 | end
103 | 


--------------------------------------------------------------------------------
/test/active_record/cases/test_middleware.rb:
--------------------------------------------------------------------------------
  1 | # encoding: utf-8
  2 | 
  3 | require 'middleware/cases/helper'
  4 | require 'active_record/cases/helper'
  5 | 
  6 | class ClientSideValidationsActiveRecordMiddlewareTest < Test::Unit::TestCase
  7 |   include Rack::Test::Methods
  8 | 
  9 |   def teardown
 10 |     User.delete_all
 11 |   end
 12 | 
 13 |   def with_kcode(kcode)
 14 |     if RUBY_VERSION < '1.9'
 15 |       orig_kcode, $KCODE = $KCODE, kcode
 16 |       begin
 17 |         yield
 18 |       ensure
 19 |         $KCODE = orig_kcode
 20 |       end
 21 |     else
 22 |       yield
 23 |     end
 24 |   end
 25 | 
 26 |   def app
 27 |     app = Proc.new { |env| [200, {}, ['success']] }
 28 |     ClientSideValidations::Middleware::Validators.new(app)
 29 |   end
 30 | 
 31 |   def test_uniqueness_when_resource_exists
 32 |     User.create(:email => 'user@test.com')
 33 |     get '/validators/uniqueness.json', { 'user[email]' => 'user@test.com', 'case_sensitive' => true }
 34 | 
 35 |     assert_equal 'false', last_response.body
 36 |     assert last_response.ok?
 37 |   end
 38 | 
 39 |   def test_uniqueness_when_resource_exists_and_param_order_is_backwards
 40 |     User.create(:email => 'user@test.com')
 41 |     get '/validators/uniqueness.json', { 'case_sensitive' => true, 'user[email]' => 'user@test.com' }
 42 | 
 43 |     assert_equal 'false', last_response.body
 44 |     assert last_response.ok?
 45 |   end
 46 | 
 47 |   def test_uniqueness_when_resource_does_not_exist
 48 |     get '/validators/uniqueness.json', { 'user[email]' => 'user@test.com', 'case_sensitive' => true }
 49 | 
 50 |     assert_equal 'true', last_response.body
 51 |     assert last_response.not_found?
 52 |   end
 53 | 
 54 |   def test_uniqueness_when_id_is_given
 55 |     user = User.create(:email => 'user@test.com')
 56 |     get '/validators/uniqueness.json', { 'user[email]' => 'user@test.com', 'id' => user.id, 'case_sensitive' => true }
 57 | 
 58 |     assert_equal 'true', last_response.body
 59 |     assert last_response.not_found?
 60 |   end
 61 | 
 62 |   def test_mysql_adapter_uniqueness_when_id_is_given
 63 |     user = User.create(:email => 'user@test.com')
 64 |     ActiveRecord::ConnectionAdapters::SQLite3Adapter.
 65 |                                         any_instance.expects(:instance_variable_get).
 66 |                                         with("@config").
 67 |                                         returns({:adapter => "mysql"})
 68 | 
 69 |     sql_without_binary = "#{User.arel_table["email"].eq(user.email).to_sql} AND #{User.arel_table.primary_key.not_eq(user.id).to_sql}"
 70 |     relation = Arel::Nodes::SqlLiteral.new("BINARY #{sql_without_binary}")
 71 | 
 72 |     #NOTE: Stubs User#where because SQLite3 don't know BINARY
 73 |     result = User.where(sql_without_binary)
 74 |     User.expects(:where).with(relation).returns(result)
 75 | 
 76 |     get '/validators/uniqueness.json', { 'user[email]' => user.email, 'case_sensitive' => true, 'id' => user.id}
 77 |     assert_equal 'true', last_response.body
 78 |   end
 79 | 
 80 |   def test_uniqueness_when_scope_is_given
 81 |     User.create(:email => 'user@test.com', :age => 25)
 82 |     get '/validators/uniqueness.json', { 'user[email]' => 'user@test.com', 'scope' => { 'age' => 30 }, 'case_sensitive' => true }
 83 | 
 84 |     assert_equal 'true', last_response.body
 85 |     assert last_response.not_found?
 86 |   end
 87 | 
 88 |   def test_uniqueness_when_multiple_scopes_are_given
 89 |     User.create(:email => 'user@test.com', :age => 30, :name => 'Brian')
 90 |     get '/validators/uniqueness.json', { 'user[email]' => 'user@test.com', 'scope' => { 'age' => 30, 'name' => 'Robert' }, 'case_sensitive' => true }
 91 | 
 92 |     assert_equal 'true', last_response.body
 93 |     assert last_response.not_found?
 94 |   end
 95 | 
 96 |   def test_uniqueness_when_case_insensitive
 97 |     User.create(:name => 'Brian')
 98 |     get '/validators/uniqueness.json', { 'user[name]' => 'BRIAN', 'case_sensitive' => false }
 99 | 
100 |     assert_equal 'false', last_response.body
101 |     assert last_response.ok?
102 |   end
103 | 
104 |   def test_uniqueness_when_attribute_passes_as_an_integer
105 |     User.create(:name => 123)
106 |     get '/validators/uniqueness.json', { 'user[name]' => 123, 'case_sensitive' => true }
107 | 
108 |     assert_equal 'false', last_response.body
109 |     assert last_response.ok?
110 |   end
111 | 
112 |   def test_uniqueness_when_attribute_passes_as_an_integer
113 |     User.create(:name => 123)
114 |     get '/validators/uniqueness.json', { 'user[name]' => 123, 'case_sensitive' => true }
115 | 
116 |     assert_equal 'false', last_response.body
117 |     assert last_response.ok?
118 |   end
119 | 
120 |   def test_uniqueness_with_columns_which_are_sql_keywords
121 |     Guid.validates_uniqueness_of :key
122 |     assert_nothing_raised do
123 |       get '/validators/uniqueness.json', { 'guid[key]' => 'test', 'case_sensitive' => true }
124 |     end
125 |   end
126 | 
127 |   def test_uniqueness_with_limit
128 |     # User.title is limited to 5 characters
129 |     User.create(:title => "abcde")
130 |     get '/validators/uniqueness.json', { 'user[title]' => 'abcdefgh', 'case_sensitive' => true }
131 | 
132 |     assert_equal 'false', last_response.body
133 |     assert last_response.ok?
134 |   end
135 | 
136 |   def test_uniqueness_with_limit_and_utf8
137 |     with_kcode('UTF8') do
138 |       # User.title is limited to 5 characters
139 |       User.create(:title => "一二三四五")
140 |       get '/validators/uniqueness.json', { 'user[title]' => '一二三四五六七八', 'case_sensitive' => true }
141 | 
142 |       assert_equal 'false', last_response.body
143 |     assert last_response.ok?
144 |     end
145 |   end
146 | 
147 |   def test_validate_straight_inheritance_uniqueness
148 |     get '/validators/uniqueness.json', { 'inept_wizard[name]' => 'Rincewind', 'case_sensitive' => true }
149 |     assert_equal 'true', last_response.body
150 |     assert last_response.not_found?
151 | 
152 |     IneptWizard.create(:name => 'Rincewind')
153 |     get '/validators/uniqueness.json', { 'inept_wizard[name]' => 'Rincewind', 'case_sensitive' => true }
154 |     assert_equal 'false', last_response.body
155 |     assert last_response.ok?
156 | 
157 |     get '/validators/uniqueness.json', { 'conjurer[name]' => 'Rincewind', 'case_sensitive' => true }
158 |     assert_equal 'false', last_response.body
159 |     assert last_response.ok?
160 | 
161 |     Conjurer.create(:name => 'The Amazing Bonko')
162 |     get '/validators/uniqueness.json', { 'thaumaturgist[name]' => 'The Amazing Bonko', 'case_sensitive' => true }
163 |     assert_equal 'false', last_response.body
164 |     assert last_response.ok?
165 |   end
166 | 
167 | end
168 | 
169 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/numericality.js:
--------------------------------------------------------------------------------
  1 | module('Numericality options');
  2 | 
  3 | test('when value is a number', function() {
  4 |   var element = $('<input type="text" />');
  5 |   var options = { message: "failed validation" };
  6 |   element.val('123');
  7 |   equal(clientSideValidations.validators.local.numericality(element, options), undefined);
  8 | });
  9 | 
 10 | test('when value is a decimal number', function() {
 11 |   var element = $('<input type="text" />');
 12 |   var options = { message: "failed validation" };
 13 |   element.val('123.456');
 14 |   equal(clientSideValidations.validators.local.numericality(element, options), undefined);
 15 | });
 16 | 
 17 | test('when value is not a number', function() {
 18 |   var element = $('<input type="text" />');
 19 |   var options = { messages: { numericality: "failed validation" } };
 20 |   element.val('abc123');
 21 |   equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
 22 | });
 23 | 
 24 | test('when only allowing integers and value is integer', function() {
 25 |   var element = $('<input type="text" />');
 26 |   var options = { messages: { only_integer: "failed validation" }, only_integer: true };
 27 |   element.val('123');
 28 |   equal(clientSideValidations.validators.local.numericality(element, options), undefined);
 29 | });
 30 | 
 31 | test('when only allowing integers and value is not integer', function() {
 32 |   var element = $('<input type="text" />');
 33 |   var options = { messages: { only_integer: "failed validation" }, only_integer: true };
 34 |   element.val('123.456');
 35 |   equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
 36 | });
 37 | 
 38 | test('when only allowing values greater than 10 and value is greater than 10', function() {
 39 |   var element = $('<input type="text" />');
 40 |   var options = { messages: { greater_than: "failed validation" }, greater_than: 10 };
 41 |   element.val('11');
 42 |   equal(clientSideValidations.validators.local.numericality(element, options), undefined);
 43 | });
 44 | 
 45 | test('when only allowing values greater than 10 and value is 10', function() {
 46 |   var element = $('<input type="text" />');
 47 |   var options = { messages: { greater_than: "failed validation" }, greater_than: 10 };
 48 |   element.val('10');
 49 |   equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
 50 | });
 51 | 
 52 | test('when only allowing values greater than or equal to 10 and value is 10', function() {
 53 |   var element = $('<input type="text" />');
 54 |   var options = { messages: { greater_than_or_equal_to: "failed validation" }, greater_than_or_equal_to: 10 };
 55 |   element.val('10');
 56 |   equal(clientSideValidations.validators.local.numericality(element, options), undefined);
 57 | });
 58 | 
 59 | test('when only allowing values greater than or equal to 10 and value is 9', function() {
 60 |   var element = $('<input type="text" />');
 61 |   var options = { messages: { greater_than_or_equal_to: "failed validation" }, greater_than_or_equal_to: 10 };
 62 |   element.val('9');
 63 |   equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
 64 | });
 65 | 
 66 | test('when only allowing values less than 10 and value is less than 10', function() {
 67 |   var element = $('<input type="text" />');
 68 |   var options = { messages: { less_than: "failed validation" }, less_than: 10 };
 69 |   element.val('9');
 70 |   equal(clientSideValidations.validators.local.numericality(element, options), undefined);
 71 | });
 72 | 
 73 | test('when only allowing values less than 10 and value is 10', function() {
 74 |   var element = $('<input type="text" />');
 75 |   var options = { messages: { less_than: "failed validation" }, less_than: 10 };
 76 |   element.val('10');
 77 |   equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
 78 | });
 79 | 
 80 | test('when only allowing values less than or equal to 10 and value is 10', function() {
 81 |   var element = $('<input type="text" />');
 82 |   var options = { messages: { less_than_or_equal_to: "failed validation" }, less_than_or_equal_to: 10 };
 83 |   element.val('10');
 84 |   equal(clientSideValidations.validators.local.numericality(element, options), undefined);
 85 | });
 86 | 
 87 | test('when only allowing values less than or equal to 10 and value is 11', function() {
 88 |   var element = $('<input type="text" />');
 89 |   var options = { messages: { less_than_or_equal_to: "failed validation" }, less_than_or_equal_to: 10 };
 90 |   element.val('11');
 91 |   equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
 92 | });
 93 | 
 94 | test('when only allowing values equal to 10 and value is 10', function() {
 95 |   var element = $('<input type="text" />');
 96 |   var options = { messages: { equal_to: "failed validation" }, equal_to: 10 };
 97 |   element.val('10');
 98 |   equal(clientSideValidations.validators.local.numericality(element, options), undefined);
 99 | });
100 | 
101 | test('when only allowing values equal to 10 and value is 11', function() {
102 |   var element = $('<input type="text" />');
103 |   var options = { messages: { equal_to: "failed validation" }, equal_to: 10 };
104 |   element.val('11');
105 |   equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
106 | });
107 | 
108 | test('when only allowing odd values and the value is odd', function() {
109 |   var element = $('<input type="text" />');
110 |   var options = { messages: { odd: "failed validation" }, odd: true };
111 |   element.val('11');
112 |   equal(clientSideValidations.validators.local.numericality(element, options), undefined);
113 | });
114 | 
115 | test('when only allowing odd values and the value is even', function() {
116 |   var element = $('<input type="text" />');
117 |   var options = { messages: { odd: "failed validation" }, odd: true };
118 |   element.val('10');
119 |   equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
120 | });
121 | 
122 | test('when only allowing even values and the value is even', function() {
123 |   var element = $('<input type="text" />');
124 |   var options = { messages: { even: "failed validation" }, even: true };
125 |   element.val('10');
126 |   equal(clientSideValidations.validators.local.numericality(element, options), undefined);
127 | });
128 | 
129 | test('when only allowing even values and the value is odd', function() {
130 |   var element = $('<input type="text" />');
131 |   var options = { messages: { even: "failed validation" }, even: true };
132 |   element.val('11');
133 |   equal(clientSideValidations.validators.local.numericality(element, options), "failed validation");
134 | });
135 | 
136 | 


--------------------------------------------------------------------------------
/test/action_view/cases/test_legacy_helpers.rb:
--------------------------------------------------------------------------------
  1 | require 'action_view/cases/helper'
  2 | 
  3 | class ClientSideValidations::LegacyActionViewHelpersTest < ActionView::TestCase
  4 |   include ActionViewTestSetup
  5 | 
  6 |   def test_text_field
  7 |     form_for(@post) do |f|
  8 |       concat f.text_field(:cost)
  9 |     end
 10 | 
 11 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
 12 |       %{<input id="post_cost" name="post[cost]" size="30" type="text" />}
 13 |     end
 14 |     assert_equal expected, output_buffer
 15 |   end
 16 | 
 17 |   def test_password_field
 18 |     form_for(@post) do |f|
 19 |       concat f.password_field(:cost)
 20 |     end
 21 | 
 22 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
 23 |       %{<input id="post_cost" name="post[cost]" size="30" type="password" />}
 24 |     end
 25 |     assert_equal expected, output_buffer
 26 |   end
 27 | 
 28 |   def test_file_field
 29 |     form_for(@post) do |f|
 30 |       concat f.file_field(:cost)
 31 |     end
 32 | 
 33 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
 34 |       %{<input id="post_cost" name="post[cost]" type="file" />}
 35 |     end
 36 |     assert_equal expected, output_buffer
 37 |   end
 38 | 
 39 |   def test_text_area
 40 |     form_for(@post) do |f|
 41 |       concat f.text_area(:cost)
 42 |     end
 43 | 
 44 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
 45 |       %{<textarea cols="40" id="post_cost" name="post[cost]" rows="20"></textarea>}
 46 |     end
 47 |     assert_equal expected, output_buffer
 48 |   end
 49 | 
 50 |   def test_search_field
 51 |     form_for(@post) do |f|
 52 |       concat f.search_field(:cost)
 53 |     end
 54 | 
 55 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
 56 |       %{<input id="post_cost" name="post[cost]" size="30" type="search" />}
 57 |     end
 58 |     assert_equal expected, output_buffer
 59 |   end
 60 | 
 61 |   def test_telephone_field
 62 |     form_for(@post) do |f|
 63 |       concat f.telephone_field(:cost)
 64 |     end
 65 | 
 66 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
 67 |       %{<input id="post_cost" name="post[cost]" size="30" type="tel" />}
 68 |     end
 69 |     assert_equal expected, output_buffer
 70 |   end
 71 | 
 72 |   def test_phone_field
 73 |     form_for(@post) do |f|
 74 |       concat f.phone_field(:cost)
 75 |     end
 76 | 
 77 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
 78 |       %{<input id="post_cost" name="post[cost]" size="30" type="tel" />}
 79 |     end
 80 |     assert_equal expected, output_buffer
 81 |   end
 82 | 
 83 |   def test_url_field
 84 |     form_for(@post) do |f|
 85 |       concat f.url_field(:cost)
 86 |     end
 87 | 
 88 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
 89 |       %{<input id="post_cost" name="post[cost]" size="30" type="url" />}
 90 |     end
 91 |     assert_equal expected, output_buffer
 92 |   end
 93 | 
 94 |   def test_email_field
 95 |     form_for(@post) do |f|
 96 |       concat f.email_field(:cost)
 97 |     end
 98 | 
 99 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
100 |       %{<input id="post_cost" name="post[cost]" size="30" type="email" />}
101 |     end
102 |     assert_equal expected, output_buffer
103 |   end
104 | 
105 |   def test_number_field
106 |     form_for(@post) do |f|
107 |       concat f.number_field(:cost)
108 |     end
109 | 
110 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
111 |       %{<input id="post_cost" name="post[cost]" size="30" type="number" />}
112 |     end
113 |     assert_equal expected, output_buffer
114 |   end
115 | 
116 |   def test_range_field
117 |     form_for(@post) do |f|
118 |       concat f.range_field(:cost)
119 |     end
120 | 
121 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
122 |       %{<input id="post_cost" name="post[cost]" size="30" type="range" />}
123 |     end
124 |     assert_equal expected, output_buffer
125 |   end
126 | 
127 |   def test_check_box
128 |     form_for(@post) do |f|
129 |       concat f.check_box(:cost)
130 |     end
131 | 
132 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
133 |       %{<input name="post[cost]" type="hidden" value="0" />} +
134 |       %{<input id="post_cost" name="post[cost]" type="checkbox" value="1" />}
135 |     end
136 |     assert_equal expected, output_buffer
137 |   end
138 | 
139 |   def test_radio_button
140 |     form_for(@post) do |f|
141 |       concat f.radio_button(:cost, "10")
142 |     end
143 | 
144 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
145 |       %{<input id="post_cost_10" name="post[cost]" type="radio" value="10" />}
146 |     end
147 |     assert_equal expected, output_buffer
148 |   end
149 | 
150 |   def test_fields_for
151 |     result = fields_for(@comment) do |c|
152 |       c.text_field(:title)
153 |     end
154 | 
155 |     expected = %{<input id="comment_title" name="comment[title]" size="30" type="text" />}
156 | 
157 |     assert_equal expected, result
158 |   end
159 | 
160 |   def test_select
161 |     form_for(@post) do |f|
162 |       concat f.select(:cost, [])
163 |     end
164 | 
165 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
166 |       %{<select id="post_cost" name="post[cost]"></select>}
167 |     end
168 |     assert_equal expected, output_buffer
169 |   end
170 | 
171 |   def test_collection_select
172 |     form_for(@post) do |f|
173 |       concat f.collection_select(:cost, [], :id, :name)
174 |     end
175 | 
176 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
177 |       %{<select id="post_cost" name="post[cost]"></select>}
178 |     end
179 |     assert_equal expected, output_buffer
180 |   end
181 | 
182 |   def test_grouped_collection_select
183 |     form_for(@post) do |f|
184 |       concat f.grouped_collection_select(:cost, [], :group_method, :group_label_method, :id, :name)
185 |     end
186 | 
187 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
188 |       %{<select id="post_cost" name="post[cost]"></select>}
189 |     end
190 |     assert_equal expected, output_buffer
191 |   end
192 | 
193 |   def test_time_zone_select
194 |     zones = mock('TimeZones')
195 |     zones.stubs(:all).returns([])
196 |     form_for(@post) do |f|
197 |       concat f.time_zone_select(:cost, nil, :model => zones)
198 |     end
199 | 
200 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", "put") do
201 |       %{<select id="post_cost" name="post[cost]"></select>}
202 |     end
203 |     assert_equal expected, output_buffer
204 |   end
205 | end
206 | 
207 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validateElement.js:
--------------------------------------------------------------------------------
  1 | module('Validate Element', {
  2 |   setup: function() {
  3 |     new_user = {
  4 |       type: 'ActionView::Helpers::FormBuilder',
  5 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
  6 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
  7 |       validators: {
  8 |         'user[name]':{"presence":{"message": "must be present"}, "format":{"message":"is invalid","with":/\d+/}},
  9 |         'user[password]':{"confirmation":{"message": "must match confirmation"}},
 10 |         'user[agree]':{"acceptance": {"message": "must be accepted"}},
 11 |         'user[email]':{"uniqueness":{"message": "must be unique"},"presence":{"message": "must be present"}}
 12 |       }
 13 |     }
 14 | 
 15 |     $('#qunit-fixture')
 16 |       .append($('<form />', {
 17 |         action: '/users',
 18 |         'data-validate': true,
 19 |         method: 'post',
 20 |         id: 'new_user'
 21 |       }))
 22 |       .find('form')
 23 |         .append($('<label for="user_name">Name</label>'))
 24 |         .append($('<input />', {
 25 |           name: 'user[name]',
 26 |           id: 'user_name',
 27 |           'data-validate': 'true',
 28 |           type: 'text'
 29 |         }))
 30 |         .append($('<label for="user_password">Password</label>'))
 31 |         .append($('<input />', {
 32 |           name: 'user[password]',
 33 |           id: 'user_password',
 34 |           'data-validate': 'true',
 35 |           type: 'password'
 36 |         }))
 37 |         .append($('<label for="user_password_confirmation">Password Confirmation</label>'))
 38 |         .append($('<input />', {
 39 |           name: 'user[password_confirmation]',
 40 |           id: 'user_password_confirmation',
 41 |           type: 'password'
 42 |         }))
 43 |         .append($('<label for="user_agree">Agree</label>'))
 44 |         .append($('<input />', {
 45 |           name: 'user[agree]',
 46 |           id: 'user_agree',
 47 |           'data-validate': 'true',
 48 |           type: 'checkbox',
 49 |           value: 1
 50 |         }))
 51 |         .append($('<input />', {
 52 |           name: 'user[email]',
 53 |           id: 'user_email',
 54 |           'data-validate': 'true',
 55 |           type: 'text'
 56 |         }))
 57 | 
 58 |     $('form#new_user').validate();
 59 |   }
 60 | });
 61 | 
 62 | test('Validate when focusouting', function() {
 63 |   var form = $('form#new_user'), input = form.find('input#user_name');
 64 |   var label = $('label[for="user_name"]');
 65 | 
 66 |   input.trigger('focusout');
 67 |   ok(input.parent().hasClass('field_with_errors'));
 68 |   ok(label.parent().hasClass('field_with_errors'));
 69 | });
 70 | 
 71 | test('Validate when checkbox is clicked', function() {
 72 |   var form = $('form#new_user'), input = form.find('input#user_agree');
 73 |   var label = $('label[for="user_agree"]');
 74 | 
 75 |   input.attr('checked', false)
 76 |   input.trigger('click');
 77 |   ok(input.parent().hasClass('field_with_errors'));
 78 |   ok(label.parent().hasClass('field_with_errors'));
 79 | });
 80 | 
 81 | test('Validate when focusout on confirmation', function() {
 82 |   var form = $('form#new_user'), password = form.find('input#user_password'), confirmation = form.find('input#user_password_confirmation');
 83 |   var label = $('label[for="user_password"]');
 84 | 
 85 |   password.val('password');
 86 |   confirmation.trigger('focusout');
 87 |   ok(password.parent().hasClass('field_with_errors'));
 88 |   ok(label.parent().hasClass('field_with_errors'));
 89 | });
 90 | 
 91 | test('Validate when keyup on confirmation', function() {
 92 |   var form = $('form#new_user'), password = form.find('input#user_password'), confirmation = form.find('input#user_password_confirmation');
 93 |   var label = $('label[for="user_password"]');
 94 | 
 95 |   password.val('password');
 96 | 
 97 |   confirmation.trigger('keyup');
 98 |   ok(password.parent().hasClass('field_with_errors'));
 99 |   ok(label.parent().hasClass('field_with_errors'));
100 | 
101 |   confirmation.val('password')
102 |   confirmation.trigger('keyup');
103 |   ok(!password.parent().hasClass('field_with_errors'));
104 |   ok(!label.parent().hasClass('field_with_errors'));
105 | });
106 | 
107 | test('Forcing remote validators to run last', function() {
108 |   var form = $('form#new_user'), input = form.find('input#user_email');
109 | 
110 |   input.trigger('focusout');
111 |   equal(input.parent().find('label').text(), "must be present")
112 | });
113 | 
114 | test("Don't validate when value hasn't changed", function() {
115 |   var form = $('form#new_user'), input = form.find('input#user_name');
116 |   var label = $('label[for="user_name"]');
117 | 
118 |   input.trigger('focusout');
119 |   ok(input.parent().hasClass('field_with_errors'));
120 |   ok(label.parent().hasClass('field_with_errors'));
121 | 
122 |   input.val('123');
123 |   input.trigger('focusout');
124 |   ok(input.parent().hasClass('field_with_errors'));
125 |   ok(label.parent().hasClass('field_with_errors'));
126 | 
127 |   input.trigger('change');
128 |   input.trigger('focusout');
129 |   ok(!input.parent().hasClass('field_with_errors'));
130 |   ok(!label.parent().hasClass('field_with_errors'));
131 | });
132 | 
133 | test('Validate when error message needs to change', function() {
134 |   var form = $('form#new_user'), input = form.find('input#user_name');
135 |   var label = $('label[for="user_name"]');
136 | 
137 |   input.trigger('focusout');
138 |   equal(input.parent().find('label.message').text(), "must be present");
139 |   input.val('abc');
140 |   input.trigger('change')
141 |   input.trigger('focusout');
142 |   equal(input.parent().find('label.message').text(), "is invalid");
143 | })
144 | 
145 | test("Don't validate confirmation when not a validatable input", function() {
146 |   $('#qunit-fixture')
147 |     .append($('<form />', {
148 |       action: '/users',
149 |       'data-validate': true,
150 |       method: 'post',
151 |       id: 'new_user_2'
152 |     }))
153 |     .find('form')
154 |       .append($('<label for="user_2_password">Password</label>'))
155 |       .append($('<input />', {
156 |         name: 'user_2[password]',
157 |         id: 'user_2_password',
158 |         type: 'password'
159 |       }))
160 |       .append($('<label for="user_2_password_confirmation">Password Confirmation</label>'))
161 |       .append($('<input />', {
162 |         name: 'user_2[password_confirmation]',
163 |         id: 'user_2_password_confirmation',
164 |         type: 'password'
165 |       }))
166 |   new_user_2 = {
167 |     type: 'ActionView::Helpers::FormBuilder',
168 |     input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
169 |     label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
170 |     validators: {
171 |     }
172 |   }
173 |   $('form#new_user_2').validate();
174 |   var form = $('form#new_user_2'), input = form.find('input#user_2_password_confirmation');
175 |   input.val('123');
176 |   input.trigger('focusout');
177 |   ok(!input.parent().hasClass('field_with_errors'));
178 | });
179 | 
180 | 


--------------------------------------------------------------------------------
/test/action_view/cases/test_helpers.rb:
--------------------------------------------------------------------------------
  1 | require 'action_view/cases/helper'
  2 | 
  3 | class ClientSideValidations::ActionViewHelpersTest < ActionView::TestCase
  4 |   include ActionViewTestSetup
  5 | 
  6 |   cattr_accessor :field_error_proc
  7 |   @@field_error_proc = Proc.new { |html_tag, instance| html_tag }
  8 | 
  9 |   def client_side_form_settings_helper
 10 |     {
 11 |       :type => "ActionView::Helpers::FormBuilder",
 12 |       :input_tag => %{<span id="input_tag" />},
 13 |       :label_tag => %{<label id="label_tag" />}
 14 |     }
 15 |   end
 16 | 
 17 |   def test_text_field
 18 |     form_for(@post, :validate => true) do |f|
 19 |       concat f.text_field(:cost)
 20 |     end
 21 | 
 22 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
 23 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
 24 |       %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="text" />}
 25 |     end
 26 |     assert_equal expected, output_buffer
 27 |   end
 28 | 
 29 |   def test_password_field
 30 |     form_for(@post, :validate => true) do |f|
 31 |       concat f.password_field(:cost)
 32 |     end
 33 | 
 34 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
 35 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
 36 |       %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="password" />}
 37 |     end
 38 |     assert_equal expected, output_buffer
 39 |   end
 40 | 
 41 |   def test_file_field
 42 |     form_for(@post, :validate => true) do |f|
 43 |       concat f.file_field(:cost)
 44 |     end
 45 | 
 46 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
 47 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
 48 |       %{<input data-validate="true" id="post_cost" name="post[cost]" type="file" />}
 49 |     end
 50 |     assert_equal expected, output_buffer
 51 |   end
 52 | 
 53 |   def test_text_area
 54 |     form_for(@post, :validate => true) do |f|
 55 |       concat f.text_area(:cost)
 56 |     end
 57 | 
 58 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
 59 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
 60 |       %{<textarea cols="40" data-validate="true" id="post_cost" name="post[cost]" rows="20"></textarea>}
 61 |     end
 62 |     assert_equal expected, output_buffer
 63 |   end
 64 | 
 65 |   def test_search_field
 66 |     form_for(@post, :validate => true) do |f|
 67 |       concat f.search_field(:cost)
 68 |     end
 69 | 
 70 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
 71 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
 72 |       %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="search" />}
 73 |     end
 74 |     assert_equal expected, output_buffer
 75 |   end
 76 | 
 77 |   def test_telephone_field
 78 |     form_for(@post, :validate => true) do |f|
 79 |       concat f.telephone_field(:cost)
 80 |     end
 81 | 
 82 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
 83 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
 84 |       %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="tel" />}
 85 |     end
 86 |     assert_equal expected, output_buffer
 87 |   end
 88 | 
 89 |   def test_phone_field
 90 |     form_for(@post, :validate => true) do |f|
 91 |       concat f.phone_field(:cost)
 92 |     end
 93 | 
 94 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
 95 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
 96 |       %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="tel" />}
 97 |     end
 98 |     assert_equal expected, output_buffer
 99 |   end
100 | 
101 |   def test_url_field
102 |     form_for(@post, :validate => true) do |f|
103 |       concat f.url_field(:cost)
104 |     end
105 | 
106 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
107 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
108 |       %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="url" />}
109 |     end
110 |     assert_equal expected, output_buffer
111 |   end
112 | 
113 |   def test_email_field
114 |     form_for(@post, :validate => true) do |f|
115 |       concat f.email_field(:cost)
116 |     end
117 | 
118 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
119 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
120 |       %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="email" />}
121 |     end
122 |     assert_equal expected, output_buffer
123 |   end
124 | 
125 |   def test_number_field
126 |     form_for(@post, :validate => true) do |f|
127 |       concat f.number_field(:cost)
128 |     end
129 | 
130 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
131 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
132 |       %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="number" />}
133 |     end
134 |     assert_equal expected, output_buffer
135 |   end
136 | 
137 |   def test_range_field
138 |     form_for(@post, :validate => true) do |f|
139 |       concat f.range_field(:cost)
140 |     end
141 | 
142 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
143 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
144 |       %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="range" />}
145 |     end
146 |     assert_equal expected, output_buffer
147 |   end
148 | 
149 |   def test_check_box
150 |     form_for(@post, :validate => true) do |f|
151 |       concat f.check_box(:cost)
152 |     end
153 | 
154 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
155 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
156 |       %{<input name="post[cost]" type="hidden" value="0" />} +
157 |       %{<input data-validate="true" id="post_cost" name="post[cost]" type="checkbox" value="1" />}
158 |     end
159 |     assert_equal expected, output_buffer
160 |   end
161 | 
162 |   def test_radio_button
163 |     form_for(@post, :validate => true) do |f|
164 |       concat f.radio_button(:cost, "10")
165 |     end
166 | 
167 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
168 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
169 |       %{<input data-validate="true" id="post_cost_10" name="post[cost]" type="radio" value="10" />}
170 |     end
171 |     assert_equal expected, output_buffer
172 |   end
173 | 
174 |   def test_field_without_validations
175 |     form_for(@post, :validate => true) do |f|
176 |       concat f.text_field(:title)
177 |     end
178 | 
179 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => {}) do
180 |       %{<input id="post_title" name="post[title]" size="30" type="text" value="Hello World" />}
181 |     end
182 |     assert_equal expected, output_buffer
183 |   end
184 | 
185 |   def test_text_field_with_validations_turned_off
186 |     form_for(@post, :validate => true) do |f|
187 |       concat f.text_field(:cost, :validate => false)
188 |     end
189 | 
190 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => {}) do
191 |       %{<input id="post_cost" name="post[cost]" size="30" type="text" />}
192 |     end
193 |     assert_equal expected, output_buffer
194 |   end
195 | 
196 |   def test_nested_fields_for_inherit_validation_settings
197 |     form_for(@post, :validate => true) do |f|
198 |       concat f.fields_for(:comment, @comment) { |c|
199 |         concat c.text_field(:title)
200 |       }
201 |     end
202 | 
203 |     validators = {'post[comment][title]' => {:presence => {:message => "can't be blank"}}}
204 |     expected =  whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
205 |       %{<input data-validate="true" id="post_comment_title" name="post[comment][title]" size="30" type="text" />}
206 |     end
207 | 
208 |     assert_equal expected, output_buffer
209 |   end
210 | 
211 |   def test_nested_fields_for_dont_overwrite_validation_with_inheritance
212 |     form_for(@post, :validate => true) do |f|
213 |       concat f.fields_for(:comment, @comment, :validate => false) { |c|
214 |         concat c.text_field(:title)
215 |       }
216 |     end
217 | 
218 |     expected =  whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => {}) do
219 |       %{<input id="post_comment_title" name="post[comment][title]" size="30" type="text" />}
220 |     end
221 | 
222 |     assert_equal expected, output_buffer
223 |   end
224 | 
225 |   def test_with_custom_id_for_form
226 |     form_for(@post, :validate => true, :html => { :id => 'some_form' }) do |f|
227 |       concat f.text_field(:cost)
228 |     end
229 | 
230 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
231 |     expected = whole_form("/posts/123", "some_form", "edit_post", :method => "put", :validators => validators) do
232 |       %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="text" />}
233 |     end
234 |     assert_equal expected, output_buffer
235 |   end
236 | 
237 |   def test_ignore_an_individual_validator
238 |     hash = {
239 |       :cost => {
240 |         :presence => {
241 |           :message => "can't be blank"
242 |         },
243 |         :format => {
244 |           :with => /.+/,
245 |           :message => "is invalid"
246 |         }
247 |       }
248 |     }
249 |     @post.stubs(:client_side_validation_hash).returns(hash)
250 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
251 |     form_for(@post, :validate => true) do |f|
252 |       concat f.text_field(:cost, :validate => { :format => false })
253 |     end
254 | 
255 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
256 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
257 |       %{<input data-validate="true" id="post_cost" name="post[cost]" size="30" type="text" />}
258 |     end
259 |     assert_equal expected, output_buffer
260 |   end
261 | 
262 |   def test_ignore_many_validators
263 |     hash = {
264 |       :cost => {
265 |         :presence => {
266 |           :message => "can't be blank"
267 |         },
268 |         :format => {
269 |           :with => /.+/,
270 |           :message => "is invalid"
271 |         }
272 |       }
273 |     }
274 |     @post.stubs(:client_side_validation_hash).returns(hash)
275 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
276 |     form_for(@post, :validate => true) do |f|
277 |       concat f.text_field(:cost, :validate => { :presence => false, :format => false })
278 |     end
279 | 
280 |     validators = {}
281 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
282 |       %{<input id="post_cost" name="post[cost]" size="30" type="text" />}
283 |     end
284 |     assert_equal expected, output_buffer
285 |   end
286 | 
287 |   def test_select
288 |     form_for(@post, :validate => true) do |f|
289 |       concat f.select(:cost, [])
290 |     end
291 | 
292 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
293 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
294 |       %{<select data-validate="true" id="post_cost" name="post[cost]"></select>}
295 |     end
296 |     assert_equal expected, output_buffer
297 |   end
298 | 
299 |   def test_collection_select
300 |     form_for(@post, :validate => true) do |f|
301 |       concat f.collection_select(:cost, [], :id, :name)
302 |     end
303 | 
304 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
305 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
306 |       %{<select data-validate="true" id="post_cost" name="post[cost]"></select>}
307 |     end
308 |     assert_equal expected, output_buffer
309 |   end
310 | 
311 |   def test_grouped_collection_select
312 |     form_for(@post, :validate => true) do |f|
313 |       concat f.grouped_collection_select(:cost, [], :group_method, :group_label_method, :id, :name)
314 |     end
315 | 
316 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
317 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
318 |       %{<select data-validate="true" id="post_cost" name="post[cost]"></select>}
319 |     end
320 |     assert_equal expected, output_buffer
321 |   end
322 | 
323 |   def test_time_zone_select
324 |     zones = mock('TimeZones')
325 |     zones.stubs(:all).returns([])
326 |     form_for(@post, :validate => true) do |f|
327 |       concat f.time_zone_select(:cost, nil, :model => zones)
328 |     end
329 | 
330 |     validators = {'post[cost]' => {:presence => {:message => "can't be blank"}}}
331 |     expected = whole_form("/posts/123", "edit_post_123", "edit_post", :method => "put", :validators => validators) do
332 |       %{<select data-validate="true" id="post_cost" name="post[cost]"></select>}
333 |     end
334 |     assert_equal expected, output_buffer
335 |   end
336 | end
337 | 
338 | 


--------------------------------------------------------------------------------
/javascript/rails.validations.js:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * Rails 3 Client Side Validations - v3.0.4
  3 |  * https://github.com/bcardarlela/client_side_validations
  4 |  *
  5 |  * Copyright (c) 2011 Brian Cardarella
  6 |  * Licensed under the MIT license
  7 |  * http://www.opensource.org/licenses/mit-license.php
  8 |  */
  9 | 
 10 | (function($) {
 11 |   $.fn.validate = function() {
 12 |     return this.filter('form[data-validate]').each(function() {
 13 |       var form = $(this);
 14 |       var settings = window[form.attr('id')];
 15 | 
 16 |       // Set up the events for the form
 17 |       form
 18 |         .submit(function() { return form.isValid(settings.validators); })
 19 |         .bind('ajax:beforeSend',      function()          { return form.isValid(settings.validators); })
 20 |         // Callbacks
 21 |         .bind('form:validate:after',  function(eventData) { clientSideValidations.callbacks.form.after( form, eventData); })
 22 |         .bind('form:validate:before', function(eventData) { clientSideValidations.callbacks.form.before(form, eventData); })
 23 |         .bind('form:validate:fail',   function(eventData) { clientSideValidations.callbacks.form.fail(  form, eventData); })
 24 |         .bind('form:validate:pass',   function(eventData) { clientSideValidations.callbacks.form.pass(  form, eventData); })
 25 | 
 26 |         // Set up the events for each validatable form element
 27 |         .find('[data-validate]:input')
 28 |           .live('focusout',                function()          { $(this).isValid(settings.validators); })
 29 |           .live('change',                  function()          { $(this).data('changed', true); })
 30 |           // Callbacks
 31 |           .live('element:validate:after',  function(eventData) { clientSideValidations.callbacks.element.after( $(this), eventData); })
 32 |           .live('element:validate:before', function(eventData) { clientSideValidations.callbacks.element.before($(this), eventData); })
 33 |           .live('element:validate:fail',   function(eventData, message) {
 34 |             var element = $(this);
 35 |             clientSideValidations.callbacks.element.fail(element, message, function() {
 36 |               addError(element, message);
 37 |             }, eventData) })
 38 |           .live('element:validate:pass',   function(eventData) {
 39 |             var element = $(this);
 40 |             clientSideValidations.callbacks.element.pass(element, function() {
 41 |               removeError(element);
 42 |             }, eventData) })
 43 |         // Checkboxes - Live events don't support filter
 44 |         .end().find('[data-validate]:checkbox')
 45 |           .live('click', function() { $(this).isValid(settings.validators); })
 46 |         // Inputs for confirmations
 47 |         .end().find('[id*=_confirmation]').each(function() {
 48 |           var confirmationElement = $(this),
 49 |               element = form.find('#' + this.id.match(/(.+)_confirmation/)[1] + '[data-validate]:input');
 50 | 
 51 |           if (element[0]) {
 52 |             $('#' + confirmationElement.attr('id'))
 53 |               .live('focusout', function() {
 54 |                 element.data('changed', true).isValid(settings.validators);
 55 |               })
 56 |               .live('keyup', function() {
 57 |                 element.data('changed', true).isValid(settings.validators);
 58 |               })
 59 |           }
 60 |         });
 61 | 
 62 |       var addError = function(element, message) {
 63 |         clientSideValidations.formBuilders[settings.type].add(element, settings, message);
 64 |       }
 65 | 
 66 |       var removeError = function(element) {
 67 |         clientSideValidations.formBuilders[settings.type].remove(element, settings);
 68 |       }
 69 |     });
 70 |   }
 71 | 
 72 |   $.fn.isValid = function(validators) {
 73 |     if ($(this[0]).is('form')) {
 74 |       return validateForm($(this[0]), validators);
 75 |     } else {
 76 |       return validateElement($(this[0]), validators[this[0].name]);
 77 |     }
 78 |   }
 79 | 
 80 |   var validateForm = function(form, validators) {
 81 |     var valid = true;
 82 | 
 83 |     form.trigger('form:validate:before').find('[data-validate]:input').each(function() {
 84 |       if (!$(this).isValid(validators)) { valid = false; }
 85 |     });
 86 | 
 87 |     if (valid) {
 88 |       form.trigger('form:validate:pass');
 89 |     } else {
 90 |       form.trigger('form:validate:fail');
 91 |     }
 92 | 
 93 |     form.trigger('form:validate:after');
 94 |     return valid;
 95 |   }
 96 | 
 97 |   var validateElement = function(element, validators) {
 98 |     element.trigger('element:validate:before');
 99 | 
100 |     if (element.data('changed') !== false) {
101 |       var valid = true;
102 |       element.data('changed', false);
103 | 
104 |       // Because 'length' is defined on the list of validators we cannot call jQuery.each on
105 |       // the clientSideValidations.validators.all() object
106 |       for (kind in clientSideValidations.validators.all()) {
107 |         if (validators[kind] && (message = clientSideValidations.validators.all()[kind](element, validators[kind]))) {
108 |           element.trigger('element:validate:fail', message).data('valid', false);
109 |           valid = false;
110 |           break;
111 |         }
112 |       }
113 | 
114 |       if (valid) { element.data('valid', null); element.trigger('element:validate:pass'); }
115 |     }
116 | 
117 |     element.trigger('element:validate:after');
118 |     return element.data('valid') === false ? false : true;
119 |   }
120 | 
121 |   // Main hook
122 |   // If new forms are dynamically introduced into the DOM the .validate() method
123 |   // must be invoked on that form
124 |   $(function() { $('form[data-validate]').validate(); })
125 | })(jQuery);
126 | 
127 | var clientSideValidations = {
128 |   validators: {
129 |     all: function() { return jQuery.extend({}, clientSideValidations.validators.local, clientSideValidations.validators.remote) },
130 |     local: {
131 |       presence: function(element, options) {
132 |         if (/^\s*$/.test(element.val())) {
133 |           return options.message;
134 |         }
135 |       },
136 |       acceptance: function(element, options) {
137 |         switch (element.attr('type')) {
138 |           case 'checkbox':
139 |             if (!element.attr('checked')) {
140 |               return options.message;
141 |             }
142 |             break;
143 |           case 'text':
144 |             if (element.val() != (options.accept || '1')) {
145 |               return options.message;
146 |             }
147 |             break;
148 |         }
149 |       },
150 |       format: function(element, options) {
151 |         if ((message = this.presence(element, options)) && options.allow_blank == true) {
152 |           return;
153 |         } else if (message) {
154 |           return message;
155 |         } else {
156 |           if (options['with'] && !options['with'].test(element.val())) {
157 |             return options.message;
158 |           } else if (options['without'] && options['without'].test(element.val())) {
159 |             return options.message;
160 |           }
161 |         }
162 |       },
163 |       numericality: function(element, options) {
164 |         if (!/^-?(?:\d+|\d{1,3}(?:,\d{3})+)(?:\.\d*)?$/.test(element.val())) {
165 |           return options.messages.numericality;
166 |         }
167 | 
168 |         if (options.only_integer && !/^\d+$/.test(element.val())) {
169 |           return options.messages.only_integer;
170 |         }
171 | 
172 |         var CHECKS = { greater_than: '>', greater_than_or_equal_to: '>=',
173 |           equal_to: '==', less_than: '<', less_than_or_equal_to: '<=' }
174 | 
175 |         for (var check in CHECKS) {
176 |           if (options[check] && !(new Function("return " + element.val() + CHECKS[check] + options[check])())) {
177 |             return options.messages[check];
178 |           }
179 |         }
180 | 
181 |         if (options.odd && !(parseInt(element.val()) % 2)) {
182 |           return options.messages.odd;
183 |         }
184 | 
185 |         if (options.even && (parseInt(element.val()) % 2)) {
186 |           return options.messages.even;
187 |         }
188 |       },
189 |       length: function(element, options) {
190 |         var blankOptions = {};
191 |         if (options.is) {
192 |           blankOptions.message = options.messages.is;
193 |         } else if (options.minimum) {
194 |           blankOptions.message = options.messages.minimum;
195 |         }
196 |         if ((message = this.presence(element, blankOptions)) && options.allow_blank == true && !options.maximum) {
197 |           return;
198 |         } else if (message) {
199 |           return message;
200 |         } else {
201 |           var CHECKS = { is: '==', minimum: '>=', maximum: '<=' }
202 |           var tokenizer = options.js_tokenizer || "split('')";
203 |           var tokenized_length = new Function("element", "return (element.val()." + tokenizer + " || '').length;")(element);
204 | 
205 |           for (var check in CHECKS) {
206 |             if (options[check] && !(new Function("return " + tokenized_length + CHECKS[check] + options[check])())) {
207 |               return options.messages[check];
208 |             }
209 |           }
210 |         }
211 |       },
212 |       exclusion: function(element, options) {
213 |         if ((message = this.presence(element, options)) && options.allow_blank == true) {
214 |           return;
215 |         } else if (message) {
216 |           return message;
217 |         } else {
218 |           if (options['in']) {
219 |             for (var i = 0; i < options['in'].length; i++) {
220 |               if (options['in'][i] == element.val()) {
221 |                 return options.message;
222 |               }
223 |             }
224 |           } else if (options['range']) {
225 |             var lower = options['range'][0],
226 |                 upper = options['range'][1];
227 |             if (element.val() >= lower && element.val() <= upper) {
228 |               return options.message;
229 |             }
230 |           }
231 |         }
232 |       },
233 |       inclusion: function(element, options) {
234 |         if ((message = this.presence(element, options)) && options.allow_blank == true) {
235 |           return;
236 |         } else if (message) {
237 |           return message;
238 |         } else {
239 |           if (options['in']) {
240 |             for (var i = 0; i < options['in'].length; i++) {
241 |               if (options['in'][i] == element.val()) {
242 |                 return;
243 |               }
244 |             }
245 |             return options.message;
246 |           } else if (options['range']) {
247 |             var lower = options['range'][0],
248 |                 upper = options['range'][1];
249 | 
250 |             if (element.val() >= lower && element.val() <= upper) {
251 |               return;
252 |             } else {
253 |               return options.message;
254 |             }
255 |           }
256 |         }
257 |       },
258 |       confirmation: function(element, options) {
259 |         if (element.val() != jQuery('#' + element.attr('id') + '_confirmation').val()) {
260 |           return options.message;
261 |         }
262 |       }
263 |     },
264 |     remote: {
265 |       uniqueness: function(element, options) {
266 |         var data = {};
267 |         data['case_sensitive'] = !!options.case_sensitive;
268 |         if (options.id) {
269 |           data['id'] = options.id;
270 |         }
271 | 
272 |         if (options.scope) {
273 |           data.scope = {}
274 |           for (key in options.scope) {
275 |             var scoped_element = jQuery('[name="' + element.attr('name').replace(/\[\w+]$/, '[' + key + ']' + '"]'));
276 |             if (scoped_element[0] && scoped_element.val() != options.scope[key]) {
277 |               data.scope[key] = scoped_element.val();
278 |               scoped_element.unbind('change.' + element.id).bind('change.' + element.id, function() { element.trigger('change'); element.trigger('focusout'); });
279 |             } else {
280 |               data.scope[key] = options.scope[key];
281 |             }
282 |           }
283 |         }
284 | 
285 |         // Kind of a hack but this will isolate the resource name and attribute.
286 |         // e.g. user[records_attributes][0][title] => records[title]
287 |         // e.g. user[record_attributes][title] => record[title]
288 |         // Server side handles classifying the resource properly
289 |         if (/_attributes]/.test(element.attr('name'))) {
290 |           var name = element.attr('name').match(/\[\w+_attributes]/g).pop().match(/\[(\w+)_attributes]/).pop();
291 |           name += /(\[\w+])$/.exec(element.attr('name'))[1];
292 |         } else {
293 |           var name = element.attr('name');
294 |         }
295 |         data[name] = element.val();
296 | 
297 |         if (jQuery.ajax({
298 |           url: '/validators/uniqueness.json',
299 |           data: data,
300 |           async: false
301 |         }).status == 200) {
302 |           return options.message;
303 |         }
304 |       }
305 |     }
306 |   },
307 |   formBuilders: {
308 |     'ActionView::Helpers::FormBuilder': {
309 |       add: function(element, settings, message) {
310 |         if (element.data('valid') !== false) {
311 |           var inputErrorField = jQuery(settings.input_tag),
312 |               labelErrorField = jQuery(settings.label_tag),
313 |               label = jQuery('label[for="' + element.attr('id') + '"]:not(.message)');
314 | 
315 |           if (element.attr('autofocus')) { element.attr('autofocus', false) };
316 |           element.before(inputErrorField);
317 |           inputErrorField.find('span#input_tag').replaceWith(element);
318 |           inputErrorField.find('label.message').attr('for', element.attr('id'));
319 |           labelErrorField.find('label.message').attr('for', element.attr('id'));
320 |           label.replaceWith(labelErrorField);
321 |           labelErrorField.find('label#label_tag').replaceWith(label);
322 |         }
323 |         jQuery('label.message[for="' + element.attr('id') + '"]').text(message);
324 |       },
325 |       remove: function(element, settings) {
326 |         var errorFieldClass = jQuery(settings.input_tag).attr('class'),
327 |             inputErrorField = element.closest('.' + errorFieldClass),
328 |             label = jQuery('label[for="' + element.attr('id') + '"]:not(.message)'),
329 |             labelErrorField = label.closest('.' + errorFieldClass);
330 | 
331 |         if (inputErrorField[0]) {
332 |           inputErrorField.find('#' + element.attr('id')).detach();
333 |           inputErrorField.replaceWith(element);
334 |           label.detach();
335 |           labelErrorField.replaceWith(label);
336 |         }
337 |       }
338 |     },
339 |     'SimpleForm::FormBuilder': {
340 |       add: function(element, settings, message) {
341 |         if (element.data('valid') !== false) {
342 |           var wrapper = element.closest(settings.wrapper_tag);
343 |           wrapper.addClass(settings.wrapper_error_class);
344 |           var errorElement = $('<' + settings.error_tag + ' class="' + settings.error_class + '">' + message + '</' + settings.error_tag + '>');
345 |           wrapper.append(errorElement);
346 |         } else {
347 |           element.parent().find(settings.error_tag + '.' + settings.error_class).text(message);
348 |         }
349 |       },
350 |       remove: function(element, settings) {
351 |         var wrapper = element.closest(settings.wrapper_tag + '.' + settings.wrapper_error_class);
352 |         wrapper.removeClass(settings.wrapper_error_class);
353 |         var errorElement = wrapper.find(settings.error_tag + '.' + settings.error_class);
354 |         errorElement.remove();
355 |       }
356 | 
357 |     },
358 |     'Formtastic::SemanticFormBuilder': {
359 |       add: function(element, settings, message) {
360 |         if (element.data('valid') !== false) {
361 |           var wrapper = element.closest('li');
362 |           wrapper.addClass('error');
363 |           var errorElement = $('<p class="' + settings.inline_error_class + '">' + message + '</p>');
364 |           wrapper.append(errorElement);
365 |         } else {
366 |           element.parent().find('p.' + settings.inline_error_class).text(message);
367 |         }
368 |       },
369 |       remove: function(element, settings) {
370 |         var wrapper = element.closest('li.error');
371 |         wrapper.removeClass('error');
372 |         var errorElement = wrapper.find('p.' + settings.inline_error_class);
373 |         errorElement.remove();
374 |       }
375 | 
376 |     }
377 |   },
378 |   callbacks: {
379 |     element: {
380 |       after:  function(element, eventData)                    { },
381 |       before: function(element, eventData)                    { },
382 |       fail:   function(element, message, addError, eventData) { addError() },
383 |       pass:   function(element, removeError, eventData)       { removeError() }
384 |     },
385 |     form: {
386 |       after:  function(form, eventData) { },
387 |       before: function(form, eventData) { },
388 |       fail:   function(form, eventData) { },
389 |       pass:   function(form, eventData) { }
390 |     }
391 |   }
392 | }
393 | 


--------------------------------------------------------------------------------