├── lib
    ├── client_side_validations
    │   ├── version.rb
    │   ├── core_ext.rb
    │   ├── engine.rb
    │   ├── active_model
    │   │   ├── presence.rb
    │   │   ├── acceptance.rb
    │   │   ├── inclusion.rb
    │   │   ├── exclusion.rb
    │   │   ├── format.rb
    │   │   ├── length.rb
    │   │   └── numericality.rb
    │   ├── core_ext
    │   │   ├── range.rb
    │   │   └── regexp.rb
    │   ├── generators.rb
    │   ├── config.rb
    │   ├── files.rb
    │   ├── generators
    │   │   └── rails_validations.rb
    │   ├── action_view
    │   │   ├── form_tag_helper.rb
    │   │   ├── form_builder.rb
    │   │   └── form_helper.rb
    │   ├── action_view.rb
    │   ├── active_record.rb
    │   ├── active_record
    │   │   ├── uniqueness.rb
    │   │   └── middleware.rb
    │   ├── active_model.rb
    │   └── middleware.rb
    ├── client_side_validations.rb
    └── generators
    │   ├── client_side_validations
    │       ├── install_generator.rb
    │       └── copy_assets_generator.rb
    │   └── templates
    │       └── client_side_validations
    │           └── initializer.rb
├── .travis.yml
├── test
    ├── javascript
    │   ├── config.ru
    │   ├── public
    │   │   ├── test
    │   │   │   ├── utilities.js
    │   │   │   ├── settings.js
    │   │   │   ├── validators
    │   │   │   │   ├── presence.js
    │   │   │   │   ├── confirmation.js
    │   │   │   │   ├── format.js
    │   │   │   │   ├── acceptance.js
    │   │   │   │   ├── exclusion.js
    │   │   │   │   ├── inclusion.js
    │   │   │   │   ├── length.js
    │   │   │   │   ├── uniqueness.js
    │   │   │   │   └── numericality.js
    │   │   │   ├── disableValidators.js
    │   │   │   ├── callbacks
    │   │   │   │   ├── formAfter.js
    │   │   │   │   ├── formBefore.js
    │   │   │   │   ├── formPass.js
    │   │   │   │   ├── formFail.js
    │   │   │   │   ├── elementBefore.js
    │   │   │   │   ├── elementAfter.js
    │   │   │   │   ├── elementPass.js
    │   │   │   │   └── elementFail.js
    │   │   │   ├── form_builders
    │   │   │   │   └── validateForm.js
    │   │   │   └── validateElement.js
    │   │   └── vendor
    │   │   │   ├── jquery.metadata.js
    │   │   │   └── qunit.css
    │   ├── views
    │   │   ├── layout.erb
    │   │   └── index.erb
    │   └── server.rb
    ├── active_model
    │   ├── cases
    │   │   ├── helper.rb
    │   │   ├── test_base.rb
    │   │   ├── test_presence_validator.rb
    │   │   ├── test_confirmation_validator.rb
    │   │   ├── test_acceptance_validator.rb
    │   │   ├── test_exclusion_validator.rb
    │   │   ├── test_inclusion_validator.rb
    │   │   ├── test_format_validator.rb
    │   │   ├── test_length_validator.rb
    │   │   ├── test_numericality_validator.rb
    │   │   └── test_validations.rb
    │   └── models
    │   │   └── person.rb
    ├── action_view
    │   ├── models.rb
    │   ├── models
    │   │   ├── comment.rb
    │   │   └── post.rb
    │   └── cases
    │   │   ├── helper.rb
    │   │   └── test_legacy_helpers.rb
    ├── active_record
    │   ├── models
    │   │   ├── guid.rb
    │   │   ├── thing.rb
    │   │   └── user.rb
    │   └── cases
    │   │   ├── test_base.rb
    │   │   ├── helper.rb
    │   │   ├── test_uniqueness_validator.rb
    │   │   └── test_middleware.rb
    ├── test_loader.rb
    ├── middleware
    │   └── cases
    │   │   ├── helper.rb
    │   │   └── test_middleware.rb
    ├── base_helper.rb
    ├── core_ext
    │   └── cases
    │   │   └── test_core_ext.rb
    └── generators
    │   └── cases
    │       └── test_generators.rb
├── .gitignore
├── Gemfile
├── coffeescript
    ├── processor.rb
    └── rails.validations.coffee
├── client_side_validations.gemspec
├── CONTRIBUTING.md
├── HISTORY.md
└── Rakefile


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


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | rvm:
2 |   - 1.9.3
3 | before_install:
4 |   - gem update --system
5 |   - gem install bundler --pre
6 | 


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


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.gem
 2 | .bundle
 3 | *.lock
 4 | pkg/*
 5 | tags
 6 | test/generators/tmp/*
 7 | *.swp
 8 | .*rc
 9 | bundler_stubs/*
10 | binstubs/*
11 | bin/*
12 | 


--------------------------------------------------------------------------------
/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/action_view/models.rb:
--------------------------------------------------------------------------------
1 | require 'active_model'
2 | require 'client_side_validations/active_model'
3 | require 'action_view/models/comment'
4 | require 'action_view/models/post'
5 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/engine.rb:
--------------------------------------------------------------------------------
1 | module ClientSideValidations
2 |   class Engine < ::Rails::Engine
3 |     config.app_middleware.use ClientSideValidations::Middleware::Validators
4 |   end
5 | end
6 | 
7 | 


--------------------------------------------------------------------------------
/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/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 | 


--------------------------------------------------------------------------------
/test/test_loader.rb:
--------------------------------------------------------------------------------
1 | # Sanity check to make sure the entire library loads OK
2 | 
3 | require 'base_helper'
4 | require 'client_side_validations'
5 | require 'client_side_validations/files'
6 | require 'client_side_validations/version'
7 | 


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
 1 | source "http://rubygems.org"
 2 | 
 3 | # Specify your gem's dependencies in client_side_validations.gemspec
 4 | gemspec
 5 | 
 6 | if RUBY_VERSION >= '1.9.3'
 7 |   gem 'debugger'
 8 | elsif RUBY_VERSION < '1.9'
 9 |   gem 'minitest'
10 | end
11 | 


--------------------------------------------------------------------------------
/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/helper.rb:
--------------------------------------------------------------------------------
1 | require 'base_helper'
2 | require 'action_controller'
3 | require 'action_controller/railtie'
4 | require 'client_side_validations/middleware'
5 | require 'client_side_validations/engine'
6 | require 'active_record/cases/helper'
7 | 
8 | TestApp::Application.initialize!
9 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/generators.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations
 2 |   module Generators
 3 |     Assets = []
 4 | 
 5 |     def self.register_assets(klass)
 6 |       Assets.push(*klass.assets)
 7 |     end
 8 |   end
 9 | end
10 | 
11 | require 'client_side_validations/generators/rails_validations'
12 | 
13 | 


--------------------------------------------------------------------------------
/test/active_record/models/thing.rb:
--------------------------------------------------------------------------------
 1 | things_table = %{CREATE TABLE things (id INTEGER PRIMARY KEY, name text);}
 2 | ActiveRecord::Base.connection.execute(things_table)
 3 | 
 4 | class AbstractThing < ActiveRecord::Base
 5 |     self.abstract_class = true
 6 | end
 7 | 
 8 | class Thing < AbstractThing
 9 |     validates_uniqueness_of :name
10 | end
11 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/config.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations
 2 |   module Config
 3 |     class << self
 4 |       attr_accessor :disabled_validators
 5 |       attr_accessor :number_format_with_locale
 6 |       attr_accessor :root_path
 7 |     end
 8 | 
 9 |     self.disabled_validators = []
10 |     self.number_format_with_locale = false
11 |     self.root_path = nil
12 |   end
13 | end
14 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/files.rb:
--------------------------------------------------------------------------------
1 | # This is only used by dependant libraries that need to find the files
2 | 
3 | module ClientSideValidations
4 |   module Files
5 |     Initializer = File.expand_path(File.dirname(__FILE__) + '/../generators/templates/client_side_validations/initializer.rb')
6 |     Javascript  = File.expand_path(File.dirname(__FILE__) + '/../../vendor/assets/javascripts/rails.validations.js')
7 |   end
8 | end
9 | 


--------------------------------------------------------------------------------
/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]*$/,'').gsub(/\(\?#.+\)/, '').gsub(/\(\?-\w+:/,'(').gsub(/\s/,''), self.options & 5
 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 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/generators/rails_validations.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations
 2 |   module Generators
 3 |     class RailsValidations
 4 |       def self.assets
 5 |         [{
 6 |           :path => File.expand_path('../../../../vendor/assets/javascripts', __FILE__),
 7 |           :file => 'rails.validations.js'
 8 |         }]
 9 |       end
10 | 
11 |       Generators.register_assets(self)
12 |     end
13 |   end
14 | end
15 | 
16 | 


--------------------------------------------------------------------------------
/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/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 | require 'active_record/models/thing'
14 | 


--------------------------------------------------------------------------------
/test/action_view/models/comment.rb:
--------------------------------------------------------------------------------
 1 | class Comment
 2 |   extend  ActiveModel::Naming
 3 |   extend  ActiveModel::Translation
 4 |   include ActiveModel::Validations
 5 |   include ActiveModel::Conversion
 6 | 
 7 |   attr_reader :id, :post_id, :title, :body
 8 |   validates :title, :body, :presence => true
 9 | 
10 |   def initialize(params={})
11 |     params.each do |attr, value|
12 |       self.public_send("#{attr}=", value)
13 |     end if params
14 |   end
15 | 
16 |   def persisted?
17 |     false
18 |   end
19 | end
20 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/test/base_helper.rb:
--------------------------------------------------------------------------------
 1 | require 'rubygems'
 2 | require 'bundler/setup'
 3 | require 'test/unit'
 4 | if RUBY_VERSION >= '1.9.3'
 5 |   require 'debugger'
 6 | end
 7 | require 'mocha/setup'
 8 | require 'rails'
 9 | require 'client_side_validations/config'
10 | 
11 | module TestApp
12 |   class Application < Rails::Application
13 |     config.root = File.dirname(__FILE__)
14 |     config.active_support.deprecation = :log
15 |     config.logger = Logger.new(STDOUT)
16 |   end
17 | end
18 | 
19 | module ClientSideValidations; end
20 | 


--------------------------------------------------------------------------------
/lib/client_side_validations.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations
 2 | end
 3 | 
 4 | require 'client_side_validations/config'
 5 | require 'client_side_validations/active_model'  if defined?(::ActiveModel)
 6 | require 'client_side_validations/active_record' if defined?(::ActiveRecord)
 7 | require 'client_side_validations/action_view'   if defined?(::ActionView)
 8 | if defined?(::Rails)
 9 |   require 'client_side_validations/generators'
10 |   require 'client_side_validations/middleware'
11 |   require 'client_side_validations/engine'
12 | end
13 | 
14 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/utilities.js:
--------------------------------------------------------------------------------
 1 | module('Utilities');
 2 | 
 3 | test('Remote Validator Url without setting', function() {
 4 |   ClientSideValidations.remote_validators_prefix = undefined;
 5 |   equal(ClientSideValidations.remote_validators_url_for('test'), '//'+window.location.host+'/validators/test');
 6 | });
 7 | 
 8 | test('Remote Validator Url with setting', function() {
 9 |   ClientSideValidations.remote_validators_prefix = 'other';
10 |   equal(ClientSideValidations.remote_validators_url_for('test'), '//'+window.location.host+'/other/validators/test');
11 | });
12 | 


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


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


--------------------------------------------------------------------------------
/test/action_view/models/post.rb:
--------------------------------------------------------------------------------
 1 | class Post
 2 |   extend  ActiveModel::Naming
 3 |   extend  ActiveModel::Translation
 4 |   include ActiveModel::Validations
 5 |   include ActiveModel::Conversion
 6 | 
 7 |   attr_accessor :title, :author_name, :body, :secret, :written_on, :cost
 8 |   validates :cost, :body, :presence => true
 9 |   validates :body, :length => { :minimum => 200 }
10 | 
11 |   def initialize(params={})
12 |     params.each do |attr, value|
13 |       self.public_send("#{attr}=", value)
14 |     end if params
15 |   end
16 | 
17 |   def persisted?
18 |     false
19 |   end
20 | 
21 |   attr_accessor :comments, :comment_ids
22 |   def comments_attributes=(attributes); end
23 | end
24 | 
25 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_presence_validator.rb:
--------------------------------------------------------------------------------
 1 | require 'active_model/cases/test_base'
 2 | 
 3 | class ActiveModel::PresenceValidatorTest < 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 | 


--------------------------------------------------------------------------------
/lib/generators/client_side_validations/install_generator.rb:
--------------------------------------------------------------------------------
 1 | require 'generators/client_side_validations/copy_assets_generator'
 2 | 
 3 | module ClientSideValidations
 4 |   module Generators
 5 |     class InstallGenerator < CopyAssetsGenerator
 6 | 
 7 |       def copy_initializer
 8 |         source_paths << File.expand_path('../../templates/client_side_validations', __FILE__)
 9 |         copy_file 'initializer.rb', 'config/initializers/client_side_validations.rb'
10 |       end
11 | 
12 |       private
13 | 
14 |       def self.installation_message
15 |         "Copies initializer into config/initializers and #{super.downcase}"
16 |       end
17 | 
18 |       desc installation_message
19 |     end
20 |   end
21 | end
22 | 
23 | 


--------------------------------------------------------------------------------
/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/active_model/inclusion.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveModel
 2 |   module Inclusion
 3 | 
 4 |     def client_side_hash(model, attribute, force = nil)
 5 |       if options[:in].respond_to?(:call)
 6 |         if force
 7 |           options = self.options.dup
 8 |           options[:in] = options[:in].call(model)
 9 |           hash = build_client_side_hash(model, attribute, options)
10 |         else
11 |           return
12 |         end
13 |       else
14 |         hash = build_client_side_hash(model, attribute, self.options.dup)
15 |       end
16 | 
17 |       if hash[:in].is_a?(Range)
18 |         hash[:range] = hash[:in]
19 |         hash.delete(:in)
20 |       end
21 |       hash
22 |     end
23 | 
24 |   end
25 | end
26 | 
27 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/exclusion.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveModel
 2 |   module Exclusion
 3 | 
 4 |     def client_side_hash(model, attribute, force = nil)
 5 |       if options[:in].respond_to?(:call)
 6 |         if force
 7 |           options = self.options.dup
 8 |           options[:in] = options[:in].call(model)
 9 |           hash = build_client_side_hash(model, attribute, options)
10 |         else
11 |           return
12 |         end
13 |       else
14 |         hash = build_client_side_hash(model, attribute, self.options.dup)
15 |       end
16 | 
17 |       if hash[:in].is_a?(Range)
18 |         hash[:range] = hash[:in]
19 |         hash.delete(:in)
20 |       end
21 | 
22 |       hash
23 |     end
24 | 
25 |   end
26 | end
27 | 
28 | 


--------------------------------------------------------------------------------
/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 "/vendor/assets/javascripts/jquery_ujs.js" %>
16 |     <%= script_tag "/vendor/assets/javascripts/rails.validations.js" %>
17 |   </head>
18 | 
19 |   <body id="body">
20 |     <%= yield %>
21 |   </body>
22 | </html>
23 | 


--------------------------------------------------------------------------------
/test/javascript/views/index.erb:
--------------------------------------------------------------------------------
 1 | <% @title = "client_side_validations test" %>
 2 | 
 3 | <%= test_base %>
 4 | <%= script_tag 'validateElement' %>
 5 | <%= script_tag 'utilities' %>
 6 | <%= test :validators, :form_builders, :callbacks %>
 7 | <%= script_tag 'disableValidators' %>
 8 | 
 9 | <h1 id="qunit-header"><%= @title %></h1>
10 | 
11 | <div id="jquery-version">
12 |   jQuery version:
13 | 
14 |   <% jquery_versions.each do |v| %>
15 |     <%= ' • ' if v != jquery_versions.first %>
16 |     <%= jquery_link v %>
17 |   <% end %>
18 |  <%= (' • ' + jquery_link('edge')) if File.exist?(settings.root + '/public/vendor/jquery.js') %>
19 | </div>
20 | <h2 id="qunit-banner"></h2>
21 | <div id="qunit-testrunner-toolbar"></div>
22 | <h2 id="qunit-userAgent"></h2>
23 | <ol id="qunit-tests"></ol>
24 | 
25 | <div id="qunit-fixture"></div>
26 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/format.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveModel
 2 |   module Format
 3 |     def client_side_hash(model, attribute, force = nil)
 4 |       options = self.options.dup
 5 |       if options[:with].respond_to?(:call)
 6 |         if force
 7 |           options[:with] = options[:with].call(model)
 8 |           build_client_side_hash(model, attribute, options)
 9 |         else
10 |           return
11 |         end
12 |       elsif options[:without].respond_to?(:call)
13 |         if force
14 |           options[:without] = options[:without].call(model)
15 |           build_client_side_hash(model, attribute, options)
16 |         else
17 |           return
18 |         end
19 |       else
20 |         super
21 |       end
22 |     end
23 | 
24 |     private
25 | 
26 |     def message_type
27 |       :invalid
28 |     end
29 |   end
30 | end
31 | 
32 | 


--------------------------------------------------------------------------------
/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), parent_id INTEGER, active BOOLEAN, type VARCHAR(255));}
 2 | ActiveRecord::Base.connection.execute(users_table)
 3 | 
 4 | class User < ActiveRecord::Base
 5 |   validates :email, :title, :active, :name, :uniqueness => { :allow_nil => true }
 6 | end
 7 | 
 8 | class IneptWizard < User; end
 9 | class Conjurer < IneptWizard; end
10 | class Thaumaturgist < Conjurer; end
11 | 
12 | module ActiveRecordTestModule
13 |   class User2 < User; end
14 | end
15 | 
16 | class UserForm
17 |   include ActiveRecord::Validations
18 | 
19 |   attr_accessor :name
20 | 
21 |   validates_uniqueness_of :name, :client_validations => { :class => User }
22 | 
23 |   def self.i18n_scope
24 |     :activerecord
25 |   end
26 | 
27 |   def new_record?
28 |     true
29 |   end
30 | end
31 | 


--------------------------------------------------------------------------------
/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('when value is null from non-selected multi-select element', function() {
17 |   var element = $('<select multiple="multiple />');
18 |   var options = { message: "failed validation" };
19 |   equal(ClientSideValidations.validators.local.presence(element, options), "failed validation");
20 | });
21 | 
22 | 


--------------------------------------------------------------------------------
/coffeescript/processor.rb:
--------------------------------------------------------------------------------
 1 | $:.unshift(File.expand_path('../../lib', __FILE__))
 2 | 
 3 | require 'client_side_validations/version'
 4 | require 'coffee_script'
 5 | require 'date'
 6 | require 'erb'
 7 | 
 8 | module ClientSideValidations
 9 |   class Processor
10 |     def self.run
11 |       write_file
12 |     end
13 | 
14 |     def self.root_path
15 |       File.expand_path('../..', __FILE__)
16 |     end
17 | 
18 |     def self.file_name
19 |       'rails.validations'
20 |     end
21 | 
22 |     def self.template
23 |       ERB.new(File.open(File.join(root_path, 'coffeescript', "#{file_name}.coffee")).read)
24 |     end
25 | 
26 |     def self.compiled_coffeescript
27 |       CoffeeScript.compile(template.result(binding))
28 |     end
29 | 
30 |     def self.write_file
31 |       file = File.new(File.join(root_path, "vendor/assets/javascripts/#{file_name}.js"), 'w')
32 |       file << compiled_coffeescript
33 |       file.close
34 |     end
35 |   end
36 | end
37 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/length.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveModel
 2 |   module Length
 3 | 
 4 |     def client_side_hash(model, attribute, force = nil)
 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] if options[message_type].present?
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 |       copy_conditional_attributes(hash, options)
20 | 
21 |       hash
22 |     end
23 | 
24 |   end
25 | end
26 | 
27 | 


--------------------------------------------------------------------------------
/lib/generators/templates/client_side_validations/initializer.rb:
--------------------------------------------------------------------------------
 1 | # ClientSideValidations Initializer
 2 | 
 3 | # Uncomment to disable uniqueness validator, possible security issue
 4 | # ClientSideValidations::Config.disabled_validators = [:uniqueness]
 5 | 
 6 | # Uncomment to validate number format with current I18n locale
 7 | # ClientSideValidations::Config.number_format_with_locale = true
 8 | 
 9 | # Uncomment the following block if you want each input field to have the validation messages attached.
10 | #
11 | # Note: client_side_validation requires the error to be encapsulated within
12 | # <label for="#{instance.send(:tag_id)}" class="message"></label>
13 | #
14 | # ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
15 | #   unless html_tag =~ /^<label/
16 | #     %{<div class="field_with_errors">#{html_tag}<label for="#{instance.send(:tag_id)}" class="message">#{instance.error_message.first}</label></div>}.html_safe
17 | #   else
18 | #     %{<div class="field_with_errors">#{html_tag}</div>}.html_safe
19 | #   end
20 | # end
21 | 
22 | 


--------------------------------------------------------------------------------
/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 do not 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 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_record/uniqueness.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveRecord
 2 |   module Uniqueness
 3 |     def client_side_hash(model, attribute, force = nil)
 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 |       hash[:allow_blank]    = true if options[:allow_blank]
 9 | 
10 |       if options.key?(:client_validations) && options[:client_validations].key?(:class)
11 |         hash[:class] = options[:client_validations][:class].underscore
12 |       elsif model.class.name.demodulize != model.class.name
13 |         hash[:class] = model.class.name.underscore
14 |       end
15 | 
16 |       if options.key?(:scope) && options[:scope].present?
17 |         hash[:scope] = Array.wrap(options[:scope]).inject({}) do |scope_hash, scope_item|
18 |           scope_hash.merge!(scope_item => model.send(scope_item))
19 |         end
20 |       end
21 | 
22 |       hash
23 |     end
24 | 
25 |     private
26 | 
27 |     def message_type
28 |       :taken
29 |     end
30 |   end
31 | end
32 | 
33 | 


--------------------------------------------------------------------------------
/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.files         = `git ls-files -- {lib/*,vendor/*,*.gemspec}`.split("\n")
16 |   s.require_paths = ["lib"]
17 | 
18 |   s.add_development_dependency 'rails', '~> 3.2.0'
19 |   s.add_development_dependency 'sqlite3'
20 |   s.add_development_dependency 'mocha'
21 |   s.add_development_dependency 'm'
22 | 
23 |   # For QUnit testing
24 |   s.add_development_dependency 'sinatra', '~> 1.0'
25 |   s.add_development_dependency 'shotgun'
26 |   s.add_development_dependency 'thin'
27 |   s.add_development_dependency 'json'
28 |   s.add_development_dependency 'coffee-script'
29 |   s.add_development_dependency 'jquery-rails'
30 | end
31 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/disableValidators.js:
--------------------------------------------------------------------------------
 1 | module('Disabling validators', {
 2 |   setup: function() {
 3 |     ClientSideValidations.validators = {
 4 |       local: {
 5 |         test: function(){},
 6 |         test2: function(){}
 7 |       },
 8 |       remote: {
 9 |         test: function(){},
10 |         test3: function(){}
11 |       }
12 |     }
13 |   }
14 | });
15 | 
16 | test('when some validators are disabled', function() {
17 |   var keys = []; for(var k in ClientSideValidations.validators.remote) keys.push(k);
18 |   deepEqual(keys, ['test', 'test3']);
19 |   ClientSideValidations.disabled_validators = ['test'];
20 |   ClientSideValidations.disableValidators();
21 |   keys = []; for(var k in ClientSideValidations.validators.remote) keys.push(k);
22 |   deepEqual(keys, ['test3']);
23 | });
24 | 
25 | test('when none of validators are disabled', function() {
26 |   var keys = []; for(var k in ClientSideValidations.validators.remote) keys.push(k);
27 |   deepEqual(keys, ['test', 'test3']);
28 |   ClientSideValidations.disabled_validators = [];
29 |   ClientSideValidations.disableValidators();
30 |   keys = []; for(var k in ClientSideValidations.validators.remote) keys.push(k);
31 |   deepEqual(keys, ['test', 'test3']);
32 | });
33 | 


--------------------------------------------------------------------------------
/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, force = nil)
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 |       hash[:allow_blank] = true if options[:allow_nil] || options[:allow_blank]
20 | 
21 |       OPTION_MAP.each do |option, message_type|
22 |         if count = options[option]
23 |           if count.respond_to?(:call)
24 |             if force
25 |               count = count.call(model)
26 |             else
27 |               next
28 |             end
29 |           end
30 |           hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(:count => count))
31 |           hash[option] = count
32 |         end
33 |       end
34 | 
35 |       copy_conditional_attributes(hash, options)
36 | 
37 |       hash
38 |     end
39 | 
40 |   end
41 | end
42 | 
43 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contribution Guidelines #
 2 | 
 3 | ## Submitting a new issue ##
 4 | 
 5 | If you need to open a new issue you *must* provide the following:
 6 | 
 7 | 1. Version of ClientSideValidations
 8 | 2. Version of Rails
 9 | 3. Code snippet from your model of the validations
10 | 4. The form code from your template
11 | 5. The resulting HTML along with the script tag
12 | 
13 | Failure to include the above mentioned requirements will result in the
14 | issue being closed.
15 | 
16 | If you want to ensure that your issue gets fixed *fast* you should
17 | attempt to reproduce the issue in an isolated example application that
18 | you can share.
19 | 
20 | ## Making a pull request ##
21 | 
22 | If you'd like to submit a pull request please adhere to the following:
23 | 
24 | 1. Your code *must* be tested. Please TDD your code!
25 | 2. No single-character variables
26 | 3. Two-spaces instead of tabs
27 | 4. Single-quotes instead of double-quotes unless you are using string
28 |    interpolation or escapes.
29 | 5. General Rails/Ruby naming conventions for files and classes
30 | 6. *Do not* use Ruby 1.9 hash syntax
31 | 7. *Do not* use Ruby 1.9 stubby proc syntax
32 | 
33 | Plase note that you must adhere to each of the above mentioned rules.
34 | Failure to do so will result in an immediate closing of the pull
35 | request. If you update and rebase the pull request to follow the
36 | guidelines your pull request will be re-opened and considered for
37 | inclusion.
38 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/formAfter.js:
--------------------------------------------------------------------------------
 1 | module('Form Validate After Callback', {
 2 |   setup: function() {
 3 |     ClientSideValidations.forms['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 |           type: 'text'
23 |         }))
24 |         .append($('<label for="user_name">Name</label>'));
25 | 
26 |     ClientSideValidations.callbacks.form.after = function(form, message) {
27 |       $('#result').text('Form Validate After ' + form.attr('id'));
28 |     }
29 |     $('form#new_user').validate();
30 |   },
31 |   teardown: function() {
32 |     ClientSideValidations.callbacks.form.after = function(form, eventData) {}
33 |   }
34 | });
35 | 
36 | test('runs callback', function() {
37 |   var form = $('form'), input = form.find('input');
38 | 
39 |   equal($('#result').text(), '');
40 | 
41 |   form.submit();
42 |   equal($('#result').text(), 'Form Validate After new_user');
43 | });
44 | 
45 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/formBefore.js:
--------------------------------------------------------------------------------
 1 | module('Form Validate Before Callback', {
 2 |   setup: function() {
 3 |     ClientSideValidations.forms['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 |           type: 'text'
23 |         }))
24 |         .append($('<label for="user_name">Name</label>'));
25 | 
26 |     ClientSideValidations.callbacks.form.before = function(form, message) {
27 |       $('#result').text('Form Validate Before ' + form.attr('id'));
28 |     }
29 |     $('form#new_user').validate();
30 |   },
31 |   teardown: function() {
32 |     ClientSideValidations.callbacks.form.before = function(form, eventData) {}
33 |   }
34 | });
35 | 
36 | test('runs callback', function() {
37 |   var form = $('form'), input = form.find('input');
38 | 
39 |   equal($('#result').text(), '');
40 | 
41 |   form.submit();
42 |   equal($('#result').text(), 'Form Validate Before new_user');
43 | });
44 | 
45 | 


--------------------------------------------------------------------------------
/lib/generators/client_side_validations/copy_assets_generator.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations
 2 |   module Generators
 3 |     class CopyAssetsGenerator < Rails::Generators::Base
 4 | 
 5 |       def copy_javascript_asset
 6 |         if self.class == CopyAssetsGenerator || !asset_pipeline_enabled?
 7 |           assets.each do |asset|
 8 |             source_paths << asset[:path]
 9 |             copy_file asset[:file], "#{asset_directory}/#{asset[:file]}"
10 |           end
11 |         end
12 |       end
13 | 
14 |       private
15 | 
16 |       def self.asset_directory
17 |         if asset_pipeline_enabled?
18 |           "app#{Rails.configuration.assets.prefix}/javascripts"
19 |         else
20 |           'public/javascripts'
21 |         end
22 |       end
23 | 
24 |       def asset_directory
25 |         CopyAssetsGenerator.asset_directory
26 |       end
27 | 
28 |       def self.assets
29 |         Assets
30 |       end
31 | 
32 |       def assets
33 |         CopyAssetsGenerator.assets
34 |       end
35 | 
36 |       def self.asset_file_names
37 |         assets.map { |asset| asset[:file] }.join(', ')
38 |       end
39 | 
40 |       def self.asset_pipeline_enabled?
41 |         if Rails.application
42 |           (Rails.configuration.respond_to?(:assets) ? (Rails.configuration.assets || {}) : {})[:enabled]
43 |         end
44 |       end
45 | 
46 |       def asset_pipeline_enabled?
47 |         self.class.asset_pipeline_enabled?
48 |       end
49 | 
50 |       def self.installation_message
51 |         "Copies #{asset_file_names} to #{asset_directory}"
52 |       end
53 | 
54 |       desc installation_message
55 |     end
56 |   end
57 | end
58 | 
59 | 


--------------------------------------------------------------------------------
/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 | 
20 |   def test_exclusion_client_side_hash_ignore_proc
21 |     @person.stubs(:range).returns([1,2])
22 |     expected_hash = nil
23 |     assert_equal expected_hash, ExclusionValidator.new(:attributes => [:name], :in => Proc.new { |o| o.range }).client_side_hash(@person, :age)
24 |   end
25 | 
26 |   def test_exclusion_client_side_hash_observe_proc
27 |     @person.stubs(:range).returns([1,2])
28 |     expected_hash = { :message => "is reserved", :in => [1, 2] }
29 |     assert_equal expected_hash, ExclusionValidator.new(:attributes => [:name], :in => Proc.new { |o| o.range }).client_side_hash(@person, :age, true)
30 |   end
31 | end
32 | 
33 | 


--------------------------------------------------------------------------------
/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 |   def test_inclusion_client_side_hash_ignore_proc
21 |     @person.stubs(:range).returns([1,2])
22 |     expected_hash = nil
23 |     assert_equal expected_hash, InclusionValidator.new(:attributes => [:name], :in => Proc.new { |o| o.range }).client_side_hash(@person, :age)
24 |   end
25 | 
26 |   def test_inclusion_client_side_hash_observe_proc
27 |     @person.stubs(:range).returns([1,2])
28 |     expected_hash = { :message => "is not included in the list", :in => [1, 2] }
29 |     assert_equal expected_hash, InclusionValidator.new(:attributes => [:name], :in => Proc.new { |o| o.range }).client_side_hash(@person, :age, true)
30 |   end
31 | end
32 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/formPass.js:
--------------------------------------------------------------------------------
 1 | module('Form Validate Pass Callback', {
 2 |   setup: function() {
 3 |     ClientSideValidations.forms['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 |           type: 'text'
23 |         }))
24 |         .append($('<label for="user_name">Name</label>'));
25 | 
26 |     ClientSideValidations.callbacks.form.pass = function(form, message) {
27 |       $('#result').text('Form Validate Pass ' + form.attr('id'));
28 |     }
29 |     $('form#new_user').validate();
30 |   },
31 |   teardown: function() {
32 |     ClientSideValidations.callbacks.form.pass = function(form, eventData) {}
33 |   }
34 | });
35 | 
36 | test('runs callback', function() {
37 |   var form = $('form'), input = form.find('input');
38 | 
39 |   equal($('#result').text(), '');
40 | 
41 |   form.submit();
42 |   equal($('#result').text(), '');
43 | 
44 |   input.val('test');
45 |   input.trigger('change');
46 |   form.submit();
47 |   equal($('#result').text(), 'Form Validate Pass new_user');
48 | });
49 | 
50 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/formFail.js:
--------------------------------------------------------------------------------
 1 | module('Form Validate Fail Callback', {
 2 |   setup: function() {
 3 |     ClientSideValidations.forms['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 |           type: 'text'
23 |         }))
24 |         .append($('<label for="user_name">Name</label>'));
25 | 
26 |     ClientSideValidations.callbacks.form.fail = function(form, message) {
27 |       $('#result').text('Form Validate Fail ' + form.attr('id'));
28 |     }
29 |     $('form#new_user').validate();
30 |   },
31 |   teardown: function() {
32 |     ClientSideValidations.callbacks.form.fail = function(form, eventData) {}
33 |   }
34 | });
35 | 
36 | test('runs callback', function() {
37 |   var form = $('form'), input = form.find('input');
38 | 
39 |   equal($('#result').text(), '');
40 | 
41 |   form.submit();
42 |   equal($('#result').text(), 'Form Validate Fail new_user');
43 | 
44 |   $('#result').text('');
45 |   input.val('test');
46 |   input.trigger('change');
47 |   form.submit();
48 |   equal($('#result').text(), '');
49 | });
50 | 
51 | 


--------------------------------------------------------------------------------
/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.prop('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 | 


--------------------------------------------------------------------------------
/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/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/elementBefore.js:
--------------------------------------------------------------------------------
 1 | module('Element Validate Before Callback', {
 2 |   setup: function() {
 3 |     ClientSideValidations.forms['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 |           type: 'text'
23 |         }))
24 |         .append($('<label for="user_name">Name</label>'));
25 | 
26 |     ClientSideValidations.callbacks.element.before = function(element) {
27 |       $('#result').text('Element Validate Before ' + element.attr('id'));
28 |     }
29 |     $('form#new_user').validate();
30 |   },
31 |   teardown: function() {
32 |     ClientSideValidations.callbacks.element.before = function(element, eventData) {}
33 |   }
34 | });
35 | 
36 | test('runs callback when form element validate', function() {
37 |   var input = $('input');
38 | 
39 |   equal($('#result').text(), '');
40 | 
41 |   input.trigger('focusout');
42 |   equal($('#result').text(), 'Element Validate Before user_name');
43 | });
44 | 
45 | test('runs callback when form validates', function() {
46 |   var form = $('form'), input = form.find('input');
47 | 
48 |   equal($('#result').text(), '');
49 | 
50 |   form.submit();
51 |   equal($('#result').text(), 'Element Validate Before user_name');
52 | });
53 | 
54 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/elementAfter.js:
--------------------------------------------------------------------------------
 1 | module('Element Validate After Callback', {
 2 |   setup: function() {
 3 |     ClientSideValidations.forms['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 |           type: 'text'
23 |         }))
24 |         .append($('<label for="user_name">Name</label>'));
25 | 
26 |     ClientSideValidations.callbacks.element.after = function(element, message) {
27 |       $('#result').text('Element Validate After ' + element.attr('id'));
28 |     }
29 |     $('form#new_user').validate();
30 |   },
31 |   teardown: function() {
32 |     ClientSideValidations.callbacks.element.after = function(element, eventData) {}
33 |   }
34 | });
35 | 
36 | test('runs callback when form element validate', function() {
37 |   var input = $('input');
38 | 
39 |   equal($('#result').text(), '');
40 | 
41 |   input.trigger('focusout');
42 |   equal($('#result').text(), 'Element Validate After user_name');
43 | });
44 | 
45 | test('runs callback when form validates', function() {
46 |   var form = $('form'), input = form.find('input');
47 | 
48 |   equal($('#result').text(), '');
49 | 
50 |   form.submit();
51 |   equal($('#result').text(), 'Element Validate After user_name');
52 | });
53 | 
54 | 


--------------------------------------------------------------------------------
/test/core_ext/cases/test_core_ext.rb:
--------------------------------------------------------------------------------
 1 | require 'base_helper'
 2 | require 'client_side_validations/core_ext'
 3 | 
 4 | class CoreExtTest < Test::Unit::TestCase
 5 |   def test_regexp_as_json
 6 |     regexp = //
 7 |     assert_equal regexp, regexp.as_json
 8 |   end
 9 | 
10 |   def test_regexp_replace_A_and_Z
11 |     test_regexp = /\A\Z/
12 |     expected_regexp = /^$/
13 |     assert_equal expected_regexp, test_regexp.as_json
14 |   end
15 | 
16 |   def test_regexp_replace_a_and_z
17 |     test_regexp = /\A\z/
18 |     expected_regexp = /^$/
19 |     assert_equal expected_regexp, test_regexp.as_json
20 |   end
21 | 
22 |   def test_regexp_to_json
23 |     assert_equal "/^$/", /\A\Z/.to_json(nil)
24 |   end
25 | 
26 |   def test_regexp_encode_json
27 |     assert_equal "//", //.encode_json(nil)
28 |   end
29 | 
30 |   def test_regexp_remove_comment
31 |     assert_equal "//", /(?# comment)/.to_json(nil)
32 |   end
33 | 
34 |   def test_regexp_remove_group_options
35 |     assert_equal "/(something)/", /(?-mix:something)/.to_json(nil)
36 |   end
37 | 
38 |   def test_regexp_as_jason_with_options
39 |     assert_equal //i, //i.as_json
40 |   end
41 | 
42 |   def test_range_as_json
43 |     assert_equal [1,3], (1..3).as_json
44 |   end
45 | 
46 |   def test_range_to_json
47 |     assert_equal '[1, 3]', (1..3).to_json(nil)
48 |   end
49 | 
50 |   def test_range_as_json_with_floats
51 |     assert_equal [0.5,5.5], (0.5..5.5).as_json
52 |   end
53 | 
54 |   def test_multiline_regexp_as_json
55 |     test_regexp = /
56 |     /
57 |     expected_regexp = //
58 |     assert_equal expected_regexp, test_regexp.as_json
59 |   end
60 | 
61 |   def test_regexp_modifiers_as_json
62 |     # JS allows /i and /m modifiers, all other lead to error
63 |     assert_equal(//i, //i.as_json)
64 |     assert_equal(//m, //m.as_json)
65 |     assert_equal(//im, //im.as_json)
66 |     assert_equal(//, //x.as_json)
67 |     assert_equal(//i, //ix.as_json)
68 |   end
69 | end
70 | 


--------------------------------------------------------------------------------
/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 | 
 8 |   def test_scope_value_forced_to_nil_if_null
 9 |     env = {'rack.input' => String.new, 'QUERY_STRING' => 'user[email]=test@test.com&scope[parent_id]=null'}
10 |     middleware = ClientSideValidations::Middleware::Uniqueness.new(env)
11 |     middleware.response
12 |     assert_nil middleware.request.params['scope']['parent_id']
13 |   end
14 | 
15 |   def test_filter_out_jquery_cachebuster
16 |     env = {'rack.input' => String.new, 'QUERY_STRING' => 'user[email]=test@test.com&scope[parent_id]=null&_=123456'}
17 |     base = ClientSideValidations::Middleware::Base.new(env)
18 |     assert_nil base.request.params[:_]
19 |   end
20 | 
21 |   def test_calling_on_attribute_without_uniquness_validator
22 |     env = {'rack.input' => String.new, 'QUERY_STRING' => 'user[age]=7', 'PATH_INFO' => '/validators/uniqueness'}
23 |     app = Proc.new { [200, { }, []] }
24 |     response = ClientSideValidations::Middleware::Validators.new(app).call(env)
25 |     assert_equal 500, response.first
26 |   end
27 | 
28 |   def test_uniqueness_with_disabled
29 |     ClientSideValidations::Config.stubs(:disabled_validators).returns([:uniqueness])
30 |     env = {'rack.input' => String.new, 'QUERY_STRING' => 'user[email]=test@test.com', 'PATH_INFO' => '/validators/uniqueness'}
31 |     app = Proc.new { [200, { }, []] }
32 |     response = ClientSideValidations::Middleware::Validators.new(app).call(env)
33 |     assert_equal 500, response.first
34 |   end
35 | 
36 |   def test_uniqueness_with_nested_attributes
37 |     env = {'rack.input' => String.new, 'QUERY_STRING' => 'admin[user][email]=test@test.com', 'PATH_INFO' => '/validators/uniqueness'}
38 |     app = Proc.new { [200, { }, []] }
39 |     response = ClientSideValidations::Middleware::Validators.new(app).call(env)
40 |     assert_equal 404, response.first
41 |   end
42 | end
43 | 
44 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_record/middleware.rb:
--------------------------------------------------------------------------------
 1 | module ClientSideValidations::ActiveRecord
 2 |   class Middleware
 3 | 
 4 |     def self.is_class?(klass)
 5 |       klass.abstract_class.blank? && klass < ::ActiveRecord::Base
 6 |     end
 7 | 
 8 |     def self.is_unique?(klass, attribute, value, params)
 9 |       klass = find_topmost_superclass(klass)
10 |       value = type_cast_value(klass, attribute, value)
11 |       column = klass.columns_hash[attribute.to_s]
12 |       value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if column.text?
13 | 
14 |       t = klass.arel_table
15 | 
16 |       if params[:case_sensitive] == 'true'
17 |         if t.engine.connection.adapter_name =~ /^mysql/i
18 |           relation = Arel::Nodes::SqlLiteral.new("BINARY #{t[attribute].eq(value).to_sql}")
19 |         else
20 |           relation = t[attribute].eq(value)
21 |         end
22 |       else
23 |         relation = t[attribute].matches(value)
24 |       end
25 | 
26 |       if relation.is_a?(Arel::Nodes::SqlLiteral)
27 |         relation = Arel::Nodes::SqlLiteral.new("BINARY #{t[attribute].eq(value).to_sql} AND #{t[klass.primary_key].not_eq(params[:id]).to_sql}")
28 |       else
29 |         relation = relation.and(t[klass.primary_key].not_eq(params[:id])) if params[:id]
30 |       end
31 | 
32 |       (params[:scope] || {}).each do |attribute, value|
33 |         value    = type_cast_value(klass, attribute, value)
34 |         if relation.is_a?(Arel::Nodes::SqlLiteral)
35 |           relation =  Arel::Nodes::SqlLiteral.new("#{relation} AND #{t[attribute].eq(value).to_sql}")
36 |         else
37 |           relation = relation.and(t[attribute].eq(value))
38 |         end
39 |       end
40 | 
41 |       !klass.where(relation).exists?
42 |     end
43 | 
44 |     private
45 | 
46 |     def self.type_cast_value(klass, attribute, value)
47 |       klass.columns_hash[attribute].type_cast(value)
48 |     end
49 | 
50 |     def self.find_topmost_superclass(klass)
51 |       if is_class?(klass.superclass)
52 |         find_topmost_superclass(klass.superclass)
53 |       else
54 |         klass
55 |       end
56 |     end
57 | 
58 |   end
59 | end
60 | 


--------------------------------------------------------------------------------
/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 |   def test_format_client_side_hash_ignore_proc
21 |     @person.stubs(:matcher).returns(/.+/)
22 |     expected_hash = nil
23 |     assert_equal expected_hash, FormatValidator.new(:attributes => [:name], :with => Proc.new { |o| o.matcher }).client_side_hash(@person, :age)
24 |   end
25 | 
26 |   def test_format_client_side_hash_without_ignore_proc
27 |     @person.stubs(:matcher).returns(/.+/)
28 |     expected_hash = nil
29 |     assert_equal expected_hash, FormatValidator.new(:attributes => [:name], :without => Proc.new { |o| o.matcher }).client_side_hash(@person, :age)
30 |   end
31 | 
32 |   def test_format_client_side_hash_observe_proc
33 |     @person.stubs(:matcher).returns(/.+/)
34 |     expected_hash = { :message => "is invalid", :with => /.+/ }
35 |     assert_equal expected_hash, FormatValidator.new(:attributes => [:name], :with => Proc.new { |o| o.matcher }).client_side_hash(@person, :age, true)
36 |   end
37 | 
38 |   def test_format_client_side_hash_without_observe_proc
39 |     @person.stubs(:matcher).returns(/.+/)
40 |     expected_hash = { :message => "is invalid", :without => /.+/ }
41 |     assert_equal expected_hash, FormatValidator.new(:attributes => [:name], :without => Proc.new { |o| o.matcher }).client_side_hash(@person, :age, true)
42 |   end
43 | end
44 | 
45 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/elementPass.js:
--------------------------------------------------------------------------------
 1 | module('Element Validate Pass Callback', {
 2 |   setup: function() {
 3 |     ClientSideValidations.forms['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 |           type: 'text'
23 |         }))
24 |         .append($('<label for="user_name">Name</label>'));
25 | 
26 |     ClientSideValidations.callbacks.element.pass = function(element) {
27 |       $('#result').text('Element Validate Pass ' + element.attr('id'));
28 |     }
29 |     $('form#new_user').validate();
30 |   },
31 |   teardown: function() {
32 |     ClientSideValidations.callbacks.element.pass = function(element, callback) { callback() }
33 |   }
34 | });
35 | 
36 | test('runs callback when form element validate', function() {
37 |   var input = $('input');
38 | 
39 |   equal($('#result').text(), '');
40 | 
41 |   input.val('')
42 |   input.trigger('change');
43 |   input.trigger('focusout');
44 |   equal($('#result').text(), '');
45 | 
46 |   input.val('test')
47 |   input.trigger('change');
48 |   input.trigger('focusout');
49 |   equal($('#result').text(), 'Element Validate Pass user_name');
50 | });
51 | 
52 | test('runs callback when form validates', function() {
53 |   var form = $('form'), input = form.find('input');
54 | 
55 |   equal($('#result').text(), '');
56 | 
57 |   input.val('')
58 |   input.trigger('change');
59 |   form.trigger('submit');
60 | 
61 |   equal($('#result').text(), '');
62 | 
63 |   input.val('test')
64 |   input.trigger('change');
65 |   form.trigger('submit');
66 | 
67 |   equal($('#result').text(), 'Element Validate Pass user_name');
68 | });
69 | 
70 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/callbacks/elementFail.js:
--------------------------------------------------------------------------------
 1 | module('Element Validate Fail Callback', {
 2 |   setup: function() {
 3 |     ClientSideValidations.forms['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 |           type: 'text'
23 |         }))
24 |         .append($('<label for="user_name">Name</label>'));
25 | 
26 |     ClientSideValidations.callbacks.element.fail = function(element, message) {
27 |       $('#result').text('Element Validate Fail ' + element.attr('id') + ' ' + message);
28 |     }
29 |     $('form#new_user').validate();
30 |   },
31 |   teardown: function() {
32 |     ClientSideValidations.callbacks.element.fail = function(element, message, callback) { callback(); }
33 |   }
34 | });
35 | 
36 | test('runs callback when form element validate', function() {
37 |   var input = $('input');
38 | 
39 |   equal($('#result').text(), '');
40 | 
41 |   input.val('test')
42 |   input.trigger('change');
43 |   input.trigger('focusout');
44 |   equal($('#result').text(), '');
45 | 
46 |   input.val('')
47 |   input.trigger('change');
48 |   input.trigger('focusout');
49 |   equal($('#result').text(), 'Element Validate Fail user_name must be present');
50 | });
51 | 
52 | test('runs callback when form validates', function() {
53 |   var form = $('form'), input = form.find('input');
54 | 
55 |   equal($('#result').text(), '');
56 | 
57 |   input.val('test')
58 |   input.trigger('change');
59 |   form.trigger('submit');
60 | 
61 |   equal($('#result').text(), '');
62 | 
63 |   input.val('')
64 |   input.trigger('change');
65 |   form.trigger('submit');
66 | 
67 |   equal($('#result').text(), 'Element Validate Fail user_name must be present');
68 | });
69 | 
70 | 


--------------------------------------------------------------------------------
/HISTORY.md:
--------------------------------------------------------------------------------
 1 | # ClientSideValidation History #
 2 | 
 3 | ## Version 3.2 ##
 4 | * [v3.2.1](https://github.com/bcardarella/client_side_validations/compare/v3.2.0...v3.2.1)
 5 | * [v3.2.0](https://github.com/bcardarella/client_side_validations/compare/v3.1.5...v3.2.0)
 6 | 
 7 | ## Version 3.1
 8 | * [v3.1.5](https://github.com/bcardarella/client_side_validations/compare/v3.1.4...v3.1.5)
 9 | * [v3.1.4](https://github.com/bcardarella/client_side_validations/compare/v3.1.3...v3.1.4)
10 | * [v3.1.3](https://github.com/bcardarella/client_side_validations/compare/v3.1.2...v3.1.3)
11 | * [v3.1.2](https://github.com/bcardarella/client_side_validations/compare/v3.1.1...v3.1.2)
12 | * [v3.1.1](https://github.com/bcardarella/client_side_validations/compare/v3.1.0...v3.1.1)
13 | * [v3.1.0](https://github.com/bcardarella/client_side_validations/compare/badf88aa6a09012900e9275bb01c80f4d19482ce...v3.1.0)
14 | 
15 | ## Version 3.0
16 | * [v3.0.13](https://github.com/bcardarella/client_side_validations/compare/v3.0.12...v3.0.13)
17 | * [v3.0.12](https://github.com/bcardarella/client_side_validations/compare/v3.0.11...v3.0.12)
18 | * [v3.0.11](https://github.com/bcardarella/client_side_validations/compare/v3.0.10...v3.0.11)
19 | * [v3.0.10](https://github.com/bcardarella/client_side_validations/compare/v3.0.9...v3.0.10)
20 | * [v3.0.9](https://github.com/bcardarella/client_side_validations/compare/v3.0.8...v3.0.9)
21 | * [v3.0.8](https://github.com/bcardarella/client_side_validations/compare/v3.0.7...v3.0.8)
22 | * [v3.0.7](https://github.com/bcardarella/client_side_validations/compare/v3.0.6...v3.0.7)
23 | * [v3.0.6](https://github.com/bcardarella/client_side_validations/compare/v3.0.5...v3.0.6)
24 | * [v3.0.5](https://github.com/bcardarella/client_side_validations/compare/v3.0.4...v3.0.5)
25 | * [v3.0.4](https://github.com/bcardarella/client_side_validations/compare/v3.0.3...v3.0.4)
26 | * [v3.0.3](https://github.com/bcardarella/client_side_validations/compare/v3.0.2...v3.0.3)
27 | * [v3.0.2](https://github.com/bcardarella/client_side_validations/compare/v3.0.1...v3.0.2)
28 | * [v3.0.1](https://github.com/bcardarella/client_side_validations/compare/v3.0.0...v3.0.1)
29 | * [v3.0.0](https://github.com/bcardarella/client_side_validations/compare/4c6262702e513f1c4c063d36ccc88c0f3071199a...v3.0.0)
30 | 
31 | ## Prior to Version 3.0
32 | 
33 | This gem was a re-write of the original [ClientSideValidationsgem](https://github.com/dnclabs/client_side_validations).
34 | Versions were not tagged.
35 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
  1 | require 'bundler'
  2 | require File.join(File.expand_path('..', __FILE__), 'coffeescript/processor')
  3 | Bundler::GemHelper.install_tasks
  4 | 
  5 | multitask :default => 'test:ruby'
  6 | 
  7 | require 'rake/testtask'
  8 | namespace :test do
  9 |   desc %(Run all tests)
 10 |   multitask :all => ['test:ruby', 'test:js']
 11 | 
 12 |   desc %(Test Ruby code)
 13 |   Rake::TestTask.new(:ruby) do |test|
 14 |     test.libs << 'lib' << 'test'
 15 |     test.test_files = Dir.glob("#{File.dirname(__FILE__)}/test/**/test_*.rb").sort
 16 |   end
 17 | 
 18 |   desc %(Test Javascript code)
 19 |   multitask :js => ['test:server', 'test:open']
 20 | 
 21 |   desc %(Starts the test server)
 22 |   task :server do
 23 |     system 'bundle exec ruby test/javascript/server.rb'
 24 |   end
 25 | 
 26 |   desc %(Starts the test server which reloads everything on each refresh)
 27 |   task :reloadable do
 28 |     exec "bundle exec shotgun test/javascript/config.ru -p #{PORT} --server thin"
 29 |   end
 30 | 
 31 |   task :open do
 32 |     url = "http://localhost:#{PORT}"
 33 |     puts "Opening test app at #{url} ..."
 34 |     sleep 3
 35 |     system( *browse_cmd(url) )
 36 |   end
 37 | end
 38 | 
 39 | desc %{Regenerate and commit JavaScript file}
 40 | task :regenerate_javascript do
 41 |   regenerate_javascript
 42 | end
 43 | 
 44 | Rake::Task[:build].instance_eval { @actions.clear }
 45 | task :build do
 46 |   regenerate_javascript
 47 |   perform_git_commit
 48 |   Bundler::GemHelper.new(Dir.pwd).build_gem
 49 | end
 50 | 
 51 | def perform_git_commit
 52 |   sh_with_code('git add vendor')
 53 |   out, code = sh_with_code('git commit -m "Regenerated JavaScript"')
 54 |   if code == 0
 55 |     puts "Committed changes"
 56 |   else
 57 |     puts "Nothing to commit"
 58 |   end
 59 | end
 60 | 
 61 | def regenerate_javascript
 62 |   ClientSideValidations::Processor.run
 63 |   puts 'Regenerated JavaScript'
 64 | end
 65 | 
 66 | def sh_with_code(cmd, &block)
 67 |   cmd << " 2>&1"
 68 |   outbuf = ''
 69 |   Bundler.ui.debug(cmd)
 70 |   Dir.chdir(Dir.pwd) {
 71 |     outbuf = `#{cmd}`
 72 |     if $? == 0
 73 |       block.call(outbuf) if block
 74 |     end
 75 |   }
 76 |   [outbuf, $?]
 77 | end
 78 | 
 79 | PORT = 4567
 80 | 
 81 | # Returns an array e.g.: ['open', 'http://example.com']
 82 | def browse_cmd(url)
 83 |   require 'rbconfig'
 84 |   browser = ENV['BROWSER'] ||
 85 |     (RbConfig::CONFIG['host_os'].include?('darwin') && 'open') ||
 86 |     (RbConfig::CONFIG['host_os'] =~ /msdos|mswin|djgpp|mingw|windows/ && 'start') ||
 87 |     %w[xdg-open x-www-browser firefox opera mozilla netscape].find { |comm| which comm }
 88 | 
 89 |   abort('ERROR: no web browser detected') unless browser
 90 |   Array(browser) << url
 91 | end
 92 | 
 93 | # which('ruby') #=> /usr/bin/ruby
 94 | def which cmd
 95 |   exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
 96 |   ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
 97 |     exts.each { |ext|
 98 |       exe = "#{path}/#{cmd}#{ext}"
 99 |       return exe if File.executable? exe
100 |     }
101 |   end
102 |   return nil
103 | end
104 | 
105 | 


--------------------------------------------------------------------------------
/test/generators/cases/test_generators.rb:
--------------------------------------------------------------------------------
 1 | require 'rails/generators/test_case'
 2 | require 'client_side_validations'
 3 | require 'generators/client_side_validations/copy_assets_generator'
 4 | require 'generators/client_side_validations/install_generator'
 5 | 
 6 | class InstallGeneratorTest < Rails::Generators::TestCase
 7 |   tests ClientSideValidations::Generators::InstallGenerator
 8 |   destination File.expand_path('../../tmp', __FILE__)
 9 |   setup :prepare_destination
10 | 
11 |   test 'Assert all files are properly created when no asset pipeline present' do
12 |     stub_configuration
13 |     run_generator
14 |     assert_file 'config/initializers/client_side_validations.rb'
15 |     assert_file 'public/javascripts/rails.validations.js'
16 |   end
17 | 
18 |   test 'Assert all files are properly created when asset pipeline present and disabled' do
19 |     stub_configuration
20 |     configuration = {:enabled => false}
21 |     configuration.stubs(:prefix).returns('/assets')
22 |     Rails.configuration.stubs(:assets).returns(configuration)
23 |     run_generator
24 |     assert_file 'config/initializers/client_side_validations.rb'
25 |     assert_file 'public/javascripts/rails.validations.js'
26 |   end
27 | 
28 |   test 'Assert all files are properly created when asset pipeline present and enabled' do
29 |     stub_configuration
30 |     configuration = {:enabled => true}
31 |     configuration.stubs(:prefix).returns('/assets')
32 |     Rails.configuration.stubs(:assets).returns(configuration)
33 |     run_generator
34 |     assert_file    'config/initializers/client_side_validations.rb'
35 |     assert_no_file 'app/assets/javascripts/rails.validations.js'
36 |   end
37 | 
38 |   def stub_configuration
39 |     Rails.stubs(:configuration).returns(mock('Configuration'))
40 |   end
41 | end
42 | 
43 | class CopyAssetsGeneratorTest < Rails::Generators::TestCase
44 |   tests ClientSideValidations::Generators::CopyAssetsGenerator
45 |   destination File.expand_path('../../tmp', __FILE__)
46 |   setup :prepare_destination
47 | 
48 |   test 'Assert file is properly created when no asset pipeline present' do
49 |     stub_configuration
50 |     run_generator
51 |     assert_file 'public/javascripts/rails.validations.js'
52 |   end
53 | 
54 |   test 'Assert file is properly created when asset pipeline present and disabled' do
55 |     stub_configuration
56 |     configuration = {:enabled => false}
57 |     configuration.stubs(:prefix).returns('/assets')
58 |     Rails.configuration.stubs(:assets).returns(configuration)
59 |     run_generator
60 |     assert_file 'public/javascripts/rails.validations.js'
61 |   end
62 | 
63 |   test 'Assert file is properly created when asset pipeline present and enabled' do
64 |     stub_configuration
65 |     configuration = {:enabled => true}
66 |     configuration.stubs(:prefix).returns('/assets')
67 |     Rails.configuration.stubs(:assets).returns(configuration)
68 |     run_generator
69 |     assert_file 'app/assets/javascripts/rails.validations.js'
70 |   end
71 | 
72 |   def stub_configuration
73 |     Rails.stubs(:configuration).returns(mock('Configuration'))
74 |   end
75 | end
76 | 
77 | 


--------------------------------------------------------------------------------
/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_custom_general_message
26 |     expected_hash = {
27 |       :messages => {
28 |         :minimum => "is not the correct length",
29 |         :maximum => "is way too long"
30 |       },
31 |       :minimum => 4,
32 |       :maximum => 10
33 |     }
34 |     assert_equal expected_hash, LengthValidator.new(:attributes => [:age], :minimum => 4, :maximum => 10, :message => "is not the correct length", :too_long => "is way too long").client_side_hash(@person, :first_name)
35 |   end
36 | 
37 |   def test_length_client_side_hash_with_js_tokenizer
38 |     expected_hash = {
39 |       :messages => {
40 |         :is => "is the wrong length (should be 10 characters)"
41 |       },
42 |       :is => 10,
43 |       :js_tokenizer => %q{match(/\w+/g)}
44 |     }
45 |     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)
46 |   end
47 | 
48 |   def test_length_client_side_hash_with_minimum_and_maximum
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], :minimum => 5, :maximum => 10).client_side_hash(@person, :first_name)
58 |   end
59 | 
60 |   def test_length_client_side_hash_with_range
61 |     expected_hash = {
62 |       :messages => {
63 |         :minimum => "is too short (minimum is 5 characters)",
64 |         :maximum => "is too long (maximum is 10 characters)"
65 |       },
66 |       :minimum => 5,
67 |       :maximum => 10
68 |     }
69 |     assert_equal expected_hash, LengthValidator.new(:attributes => [:age], :within => 5..10).client_side_hash(@person, :first_name)
70 |   end
71 | 
72 |   def test_length_client_side_hash
73 |     expected_hash = {
74 |       :messages => {
75 |         :is => "is the wrong length (should be 10 characters)"
76 |       },
77 |       :is => 10
78 |     }
79 |     assert_equal expected_hash, LengthValidator.new(:attributes => [:age], :is => 10).client_side_hash(@person, :first_name)
80 |   end
81 | end
82 | 
83 | 


--------------------------------------------------------------------------------
/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_allow_nil
11 |     expected_hash = { :messages => { :numericality => "is not a number" }, :allow_blank => true }
12 |     assert_equal expected_hash, NumericalityValidator.new(:attributes => [:age], :allow_nil => true).client_side_hash(@person, :age)
13 |   end
14 | 
15 |   def test_numericality_client_side_hash_with_custom_message
16 |     expected_hash = { :messages => { :numericality => "bad number" } }
17 |     assert_equal expected_hash, NumericalityValidator.new(:attributes => [:age], :message => "bad number").client_side_hash(@person, :age)
18 |   end
19 | 
20 |   def test_numericality_client_side_hash_with_options
21 |     expected_hash = {
22 |       :messages => {
23 |         :numericality => "is not a number",
24 |         :only_integer => "must be an integer",
25 |         :greater_than => "must be greater than 10",
26 |         :greater_than_or_equal_to => "must be greater than or equal to 10",
27 |         :equal_to => "must be equal to 10",
28 |         :less_than => "must be less than 10",
29 |         :less_than_or_equal_to => "must be less than or equal to 10",
30 |         :odd => "must be odd",
31 |         :even => "must be even"
32 |       },
33 |       :only_integer => true,
34 |       :greater_than => 10,
35 |       :greater_than_or_equal_to => 10,
36 |       :equal_to => 10,
37 |       :less_than => 10,
38 |       :less_than_or_equal_to => 10,
39 |       :odd => true,
40 |       :even => true
41 |     }
42 |     test_hash = NumericalityValidator.new(:attributes => [:age],
43 |       :only_integer => true, :greater_than => 10, :greater_than_or_equal_to => 10,
44 |       :equal_to => 10, :less_than => 10, :less_than_or_equal_to => 10,
45 |       :odd => true, :even => true).client_side_hash(@person, :age)
46 | 
47 |     assert_equal expected_hash, test_hash
48 |   end
49 | 
50 |   def test_numericality_message_always_present
51 |     expected_hash = { :messages => { :numericality => 'is not a number', :only_integer => 'must be an integer' }, :only_integer => true }
52 |     assert_equal expected_hash, NumericalityValidator.new(:attributes => [:age], :only_integer => true).client_side_hash(@person, :age)
53 |   end
54 | 
55 |   def test_numericality_client_side_hash_ignore_proc
56 |     @person.stubs(:years).returns(5)
57 |     expected_hash = { :messages => { :numericality => "is not a number" } }
58 |     assert_equal expected_hash, NumericalityValidator.new(:attributes => [:age], :equal_to => Proc.new { |o| o.years }).client_side_hash(@person, :age)
59 |   end
60 | 
61 |   def test_numericality_client_side_hash_observe_proc
62 |     @person.stubs(:years).returns(5)
63 |     expected_hash = { :messages => { :numericality => "is not a number", :equal_to => 'must be equal to 5' }, :equal_to => 5 }
64 |     assert_equal expected_hash, NumericalityValidator.new(:attributes => [:age], :equal_to => Proc.new { |o| o.years }).client_side_hash(@person, :age, true)
65 |   end
66 | end
67 | 
68 | 


--------------------------------------------------------------------------------
/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_allowing_blank
11 |     expected_hash = { :message => "has already been taken", :case_sensitive => true, :allow_blank => true }
12 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name], :allow_blank => true).client_side_hash(@user, :name)
13 |   end
14 | 
15 |   def test_uniqueness_client_side_hash_with_custom_message
16 |     expected_hash = { :message => "is not available", :case_sensitive => true }
17 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name], :message => "is not available").client_side_hash(@user, :name)
18 |   end
19 | 
20 |   def test_uniqueness_client_side_hash
21 |     @user.stubs(:new_record?).returns(false)
22 |     @user.stubs(:id).returns(1)
23 |     expected_hash = { :message => "has already been taken", :case_sensitive => true, :id => 1 }
24 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name]).client_side_hash(@user, :name)
25 |   end
26 | 
27 |   def test_uniqueness_client_side_hash_with_single_scope_item
28 |     @user.stubs(:age).returns(30)
29 |     @user.stubs(:title).returns("test title")
30 |     expected_hash = { :message => "has already been taken", :case_sensitive => true, :scope => {:title => "test title"} }
31 |     result_hash = UniquenessValidator.new(:attributes => [:name], :scope => :title).client_side_hash(@user, :name)
32 |     assert_equal expected_hash, result_hash
33 |   end
34 | 
35 |   def test_uniqueness_client_side_hash_with_multiple_scope_items
36 |     @user.stubs(:age).returns(30)
37 |     @user.stubs(:title).returns("test title")
38 |     expected_hash = { :message => "has already been taken", :case_sensitive => true, :scope => {:age => 30, :title => "test title"} }
39 |     result_hash = UniquenessValidator.new(:attributes => [:name], :scope => [:age, :title]).client_side_hash(@user, :name)
40 |     assert_equal expected_hash, result_hash
41 |   end
42 | 
43 |   def test_uniqueness_client_side_hash_with_empty_scope_array
44 |     expected_hash = { :message => "has already been taken", :case_sensitive => true }
45 |     result_hash = UniquenessValidator.new(:attributes => [:name], :scope => []).client_side_hash(@user, :name)
46 |     assert_equal expected_hash, result_hash
47 |   end
48 | 
49 |   def test_uniqueness_client_side_hash_when_nested_module
50 |     @user = ActiveRecordTestModule::User2.new
51 |     expected_hash = { :message => "has already been taken", :case_sensitive => true, :class => 'active_record_test_module/user2' }
52 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name]).client_side_hash(@user, :name)
53 |   end
54 | 
55 |   def test_uniqueness_client_side_hash_with_class_from_options
56 |     @user = UserForm.new
57 |     expected_hash = { :message => "has already been taken", :case_sensitive => true, :class => 'user' }
58 |     assert_equal expected_hash, UniquenessValidator.new(:attributes => [:name], :client_validations => { :class => 'User' } ).client_side_hash(@user, :name)
59 |   end
60 | end
61 | 
62 | 


--------------------------------------------------------------------------------
/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 minimum length is 3 and maximum length is 100', function() {
31 |   var element = $('<input type="text" />');
32 |   var options = { messages: { minimum: "failed minimum validation", maximum: "failed maximum validation" }, minimum: 3, maximum: 100, allow_blank: true };
33 |   equal(ClientSideValidations.validators.local.length(element, options), undefined);
34 | });
35 | 
36 | test('when not allowing blank and allowed length is 3', function() {
37 |   var element = $('<input type="text" />');
38 |   var options = { messages: { is: "failed validation" }, is: 3 };
39 |   equal(ClientSideValidations.validators.local.length(element, options), "failed validation");
40 | });
41 | 
42 | test('when allowed length is 3 and a differnet tokenizer', function() {
43 |   var element = $('<input type="text" />');
44 |   element.val("one two three");
45 |   var options = { messages: { is: "failed validation" }, is: 3, js_tokenizer: "match(/\\w+/g)" };
46 |   equal(ClientSideValidations.validators.local.length(element, options), undefined);
47 | });
48 | 
49 | test('when allowed length minimum is 3 and value length is 3', function() {
50 |   var element = $('<input type="text" />');
51 |   var options = { messages: { is: "failed validation" }, is: 3 };
52 |   element.val('123');
53 |   equal(ClientSideValidations.validators.local.length(element, options), undefined);
54 | });
55 | 
56 | test('when allowed length minimum is 3 and value length is 2', function() {
57 |   var element = $('<input type="text" />');
58 |   var options = { messages: { minimum: "failed validation" }, minimum: 3 };
59 |   element.val('12');
60 |   equal(ClientSideValidations.validators.local.length(element, options), "failed validation");
61 | });
62 | 
63 | test('when allowed length maximum is 3 and value length is 3', function() {
64 |   var element = $('<input type="text" />');
65 |   var options = { messages: { is: "failed validation" }, is: 3 };
66 |   element.val('123');
67 |   equal(ClientSideValidations.validators.local.length(element, options), undefined);
68 | });
69 | 
70 | test('when allowed length maximum is 3 and value length is 4', function() {
71 |   var element = $('<input type="text" />');
72 |   var options = { messages: { maximum: "failed validation" }, maximum: 3 };
73 |   element.val('1234');
74 |   equal(ClientSideValidations.validators.local.length(element, options), "failed validation");
75 | });
76 | 
77 | 


--------------------------------------------------------------------------------
/test/javascript/server.rb:
--------------------------------------------------------------------------------
  1 | require 'bundler'
  2 | Bundler.setup
  3 | require 'sinatra'
  4 | require 'json'
  5 | require 'ruby-debug'
  6 | require File.join(File.expand_path('../../..', __FILE__), 'coffeescript/processor')
  7 | 
  8 | ClientSideValidations::Processor.run
  9 | 
 10 | class AssetPath
 11 |   def initialize(app, options={})
 12 |     @app = app
 13 |     @urls = options[:urls] || ["/favicon.ico"]
 14 |     @index = options[:index]
 15 |     root = options[:root] || Dir.pwd
 16 |     cache_control = options[:cache_control]
 17 |     @file_server = Rack::File.new(root, cache_control)
 18 |   end
 19 | 
 20 |   def overwrite_file_path(path)
 21 |     @urls.kind_of?(Hash) && @urls.key?(path) || @index && path == '/'
 22 |   end
 23 | 
 24 |   def route_file(path)
 25 |     @urls.kind_of?(Array) && @urls.any? { |url| path.index(url) == 0 }
 26 |   end
 27 | 
 28 |   def can_serve(path)
 29 |     route_file(path) || overwrite_file_path(path)
 30 |   end
 31 | 
 32 |   def call(env)
 33 |     path = env["PATH_INFO"]
 34 | 
 35 |     if can_serve(path)
 36 |       env["PATH_INFO"] = (path == '/' ? @index : @urls[path]) if overwrite_file_path(path)
 37 |       response = @file_server.call(env)
 38 |       if response.first == 404
 39 |         @app.call(env)
 40 |       else
 41 |         response
 42 |       end
 43 |     else
 44 |       @app.call(env)
 45 |     end
 46 |   end
 47 | end
 48 | 
 49 | use AssetPath, :urls => ['/vendor/assets/javascripts'], :root => File.expand_path('../..', settings.root)
 50 | use AssetPath, :urls => ['/vendor/assets/javascripts'], :root => File.expand_path('../', $:.find { |p| p =~ /jquery-rails/ })
 51 | 
 52 | JQUERY_VERSIONS = %w[ 1.6 1.6.1 1.6.2 1.6.3 1.6.4 1.7 1.7.1 1.7.2].freeze
 53 | 
 54 | helpers do
 55 |   def jquery_link version
 56 |     if params[:version] == version
 57 |       "[#{version}]"
 58 |     else
 59 |       "<a href='/?version=#{version}'>#{version}</a>"
 60 |     end
 61 |   end
 62 | 
 63 |   def jquery_src
 64 |     if params[:version] == 'edge' then '/vendor/jquery.js'
 65 |     else "http://code.jquery.com/jquery-#{params[:version]}.js"
 66 |     end
 67 |   end
 68 | 
 69 |   def test_base
 70 |     names = ['/vendor/qunit.js', 'settings']
 71 |     names.map { |name| script_tag name }.join("\n")
 72 |   end
 73 | 
 74 |   def test *types
 75 |     types.map do |type|
 76 |       Dir.glob(File.expand_path("public/test/#{type}", settings.root) + '/*.js').map { |file| File.basename(file) }.map do |file|
 77 |         script_tag "/test/#{type}/#{file}"
 78 |       end.join("\n")
 79 |     end.join("\n")
 80 |   end
 81 | 
 82 |   def script_tag src
 83 |     src = "/test/#{src}.js" unless src.index('/')
 84 |     %(<script src='#{src}' type='text/javascript'></script>)
 85 |   end
 86 | 
 87 |   def jquery_versions
 88 |     JQUERY_VERSIONS
 89 |   end
 90 | end
 91 | 
 92 | get '/' do
 93 |   params[:version] ||= '1.7.2'
 94 |   erb :index
 95 | end
 96 | 
 97 | get '/validators/uniqueness' do
 98 |   content_type 'application/json'
 99 | 
100 |   if user = params[:user2]
101 |     status 500
102 |     'error'
103 |   elsif user = params['active_record_test_module/user2']
104 |     status 200
105 |     'false'
106 |   elsif scope = params[:scope]
107 |     if scope[:name] == 'test name' || scope[:name] == 'taken name'
108 |       status 200
109 |       'false'
110 |     else
111 |       status 404
112 |       'true'
113 |     end
114 |   elsif params[:case_sensitive] == 'false' && (params[:user][:email] || params[:users][:email]) == 'taken@test.com'
115 |     status 200
116 |     'false'
117 |   else
118 |     status 404
119 |     'true'
120 |   end
121 | 
122 | end
123 | 
124 | post '/users' do
125 |   data = { :params => params }.update(request.env)
126 |   payload = data.to_json.gsub('<', '&lt;').gsub('>', '&gt;')
127 |   <<-HTML
128 |     <script>
129 |       if (window.top && window.top !== window)
130 |         window.top.jQuery.event.trigger('iframe:loaded', #{payload})
131 |     </script>
132 |     <p id="response">Form submitted</p>
133 |   HTML
134 | end
135 | 
136 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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, force = nil)
  7 |       build_client_side_hash(model, attribute, self.options.dup)
  8 |     end
  9 | 
 10 |     def copy_conditional_attributes(to, from)
 11 |       [:if, :unless].each { |key| to[key] = from[key] if from[key].present? }
 12 |     end
 13 | 
 14 |     private
 15 | 
 16 |     def build_client_side_hash(model, attribute, options)
 17 |       { :message => model.errors.generate_message(attribute, message_type, options) }.merge(options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:allow_blank, :if, :unless]))
 18 |     end
 19 | 
 20 |     def message_type
 21 |       kind
 22 |     end
 23 |   end
 24 | 
 25 |   module Validations
 26 |     def client_side_validation_hash(force = nil)
 27 |       _validators.inject({}) do |attr_hash, attr|
 28 |         unless [nil, :block].include?(attr[0])
 29 | 
 30 |           validator_hash = attr[1].inject(Hash.new { |h,k| h[k] = []}) do |kind_hash, validator|
 31 |             if can_use_for_client_side_validation?(attr[0], validator, force)
 32 |               if client_side_hash = validator.client_side_hash(self, attr[0], extract_force_option(attr[0], force))
 33 |                 kind_hash[validator.kind] << client_side_hash.except(:on, :if, :unless)
 34 |               end
 35 |             end
 36 | 
 37 |             kind_hash
 38 |           end
 39 | 
 40 |           if validator_hash.present?
 41 |             attr_hash.merge!(attr[0] => validator_hash)
 42 |           else
 43 |             attr_hash
 44 |           end
 45 |         else
 46 |           attr_hash
 47 |         end
 48 |       end
 49 |     end
 50 | 
 51 |     private
 52 | 
 53 |     def extract_force_option(attr, force)
 54 |       case force
 55 |       when FalseClass, TrueClass, NilClass
 56 |         force
 57 |       when Hash
 58 |         extract_force_option(nil, force[attr])
 59 |       else
 60 |         nil
 61 |       end
 62 |     end
 63 | 
 64 |     def can_use_for_client_side_validation?(attr, validator, force)
 65 |       if validator_turned_off?(attr, validator, force)
 66 |         result = false
 67 |       else
 68 |         # Yeah yeah, #new_record? is not part of ActiveModel :p
 69 |         result = ((self.respond_to?(:new_record?) && validator.options[:on] == (self.new_record? ? :create : :update)) || validator.options[:on].nil?)
 70 |         result = result && validator.kind != :block
 71 | 
 72 |         if validator.options[:if] || validator.options[:unless]
 73 |           if validator.options[:if] && validator.options[:if] =~ /changed\?/
 74 |             result = true
 75 |           else result = can_force_validator?(attr, validator, force)
 76 |             if validator.options[:if]
 77 |               result = result && run_conditional(validator.options[:if])
 78 |             end
 79 |             if validator.options[:unless]
 80 |               result = result && !run_conditional(validator.options[:unless])
 81 |             end
 82 |           end
 83 |         end
 84 |       end
 85 | 
 86 |       result
 87 |     end
 88 | 
 89 |     def run_conditional(method_name_value_or_proc)
 90 |       if method_name_value_or_proc.respond_to?(:call)
 91 |         method_name_value_or_proc.call(self)
 92 |       else
 93 |         self.send(method_name_value_or_proc)
 94 |       end
 95 |     end
 96 | 
 97 |     def validator_turned_off?(attr, validator, force)
 98 |       case force
 99 |       when FalseClass
100 |         true
101 |       when Hash
102 |         case force[attr]
103 |         when FalseClass
104 |           true
105 |         when Hash
106 |           force[attr][validator.kind] == false
107 |         else
108 |           false
109 |         end
110 |       else
111 |         ::ClientSideValidations::Config.disabled_validators.include?(validator.kind)
112 |       end
113 |     end
114 | 
115 |     def can_force_validator?(attr, validator, force)
116 |       case force
117 |       when TrueClass
118 |         true
119 |       when Hash
120 |         case force[attr]
121 |         when TrueClass
122 |           true
123 |         when Hash
124 |           force[attr][validator.kind]
125 |         else
126 |           false
127 |         end
128 |       else
129 |         false
130 |       end
131 |     end
132 |   end
133 | end
134 | 
135 | ActiveModel::Validator.send(:include, ClientSideValidations::ActiveModel::Validator)
136 | ActiveModel::Validations.send(:include, ClientSideValidations::ActiveModel::Validations)
137 | 
138 | %w{acceptance exclusion inclusion length format numericality presence}.each do |validator|
139 |   require "client_side_validations/active_model/#{validator}"
140 |   validator.capitalize!
141 |   eval "ActiveModel::Validations::#{validator}Validator.send(:include, ClientSideValidations::ActiveModel::#{validator})"
142 | end
143 | 
144 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/middleware.rb:
--------------------------------------------------------------------------------
  1 | # encoding: utf-8
  2 | 
  3 | require 'client_side_validations/core_ext'
  4 | 
  5 | module ClientSideValidations
  6 | 
  7 |   module Middleware
  8 |     class Validators
  9 |       def initialize(app)
 10 |         @app = app
 11 |       end
 12 | 
 13 |       def call(env)
 14 |         if matches = /\A\/validators\/(\w+)\z/.match(env['PATH_INFO'])
 15 |           process_request(matches.captures.first, env)
 16 |         else
 17 |           @app.call(env)
 18 |         end
 19 |       end
 20 | 
 21 |       def process_request(validation, env)
 22 |         if disabled_validators.include?(validation)
 23 |           error_resp
 24 |         else
 25 |           klass_name = validation.camelize
 26 |           klass_name = "::ClientSideValidations::Middleware::#{klass_name}"
 27 |           klass_name.constantize.new(env).response
 28 |         end
 29 |       rescue => e
 30 |         error_resp
 31 |       end
 32 | 
 33 |       def disabled_validators
 34 |         ClientSideValidations::Config.disabled_validators.map(&:to_s)
 35 |       end
 36 | 
 37 |       def error_resp
 38 |         [500, {'Content-Type' => 'application/json', 'Content-Length' => '0'}, ['']]
 39 |       end
 40 |     end
 41 | 
 42 |     class Base
 43 |       attr_accessor :request, :body, :status
 44 | 
 45 |       def initialize(env)
 46 |         # Filter out cache buster
 47 |         env['QUERY_STRING'] = env['QUERY_STRING'].split('&').select { |p| !p.match(/^_=/) }.join('&')
 48 |         self.body           = ''
 49 |         self.status         = 200
 50 |         self.request        = ActionDispatch::Request.new(env)
 51 |       end
 52 | 
 53 |       def response
 54 |         [status, {'Content-Type' => content_type, 'Content-Length' => body.length.to_s}, [body]]
 55 |       end
 56 | 
 57 |       def content_type
 58 |         'application/json'
 59 |       end
 60 |     end
 61 | 
 62 |     class Uniqueness < Base
 63 |       IGNORE_PARAMS = %w{case_sensitive id scope}
 64 |       REGISTERED_ORMS = []
 65 |       class NotValidatable < StandardError; end
 66 | 
 67 |       def response
 68 |         begin
 69 |           if is_unique?
 70 |             self.status = 404
 71 |             self.body   = 'true'
 72 |           else
 73 |             self.status = 200
 74 |             self.body   = 'false'
 75 |           end
 76 |         rescue NotValidatable
 77 |           self.status = 500
 78 |           self.body = ''
 79 |         end
 80 |         super
 81 |       end
 82 | 
 83 |       def self.register_orm(orm)
 84 |         registered_orms << orm
 85 |       end
 86 | 
 87 |       def self.registered_orms
 88 |         REGISTERED_ORMS
 89 |       end
 90 | 
 91 |       def registered_orms
 92 |         self.class.registered_orms
 93 |       end
 94 | 
 95 |       private
 96 | 
 97 |       def is_unique?
 98 |         convert_scope_value_from_null_to_nil
 99 |         klass, attribute, value = extract_resources
100 |         middleware_class        = nil
101 | 
102 |         unless Array.wrap(klass._validators[attribute.to_sym]).find { |v| v.kind == :uniqueness }
103 |           raise NotValidatable
104 |         end
105 | 
106 |         registered_orms.each do |orm|
107 |           if orm.is_class?(klass)
108 |             middleware_class = orm
109 |             break
110 |           end
111 |         end
112 | 
113 |         middleware_class.is_unique?(klass, attribute, value, request.params)
114 |       end
115 | 
116 |       def convert_scope_value_from_null_to_nil
117 |         if request.params['scope']
118 |           request.params['scope'].each do |key, value|
119 |             if value == 'null'
120 |               request.params['scope'][key] = nil
121 |             end
122 |           end
123 |         end
124 |       end
125 | 
126 |       def extract_resources
127 |         parent_key = (request.params.keys - IGNORE_PARAMS).first
128 | 
129 |         if nested?(request.params[parent_key], 1)
130 |           klass, attribute, value = uproot(request.params[parent_key])
131 |           klass = klass.classify.constantize
132 |         else
133 |           klass            = parent_key.classify.constantize
134 |           attribute        = request.params[parent_key].keys.first
135 |           value            = request.params[parent_key][attribute]
136 |         end
137 | 
138 |         [klass, attribute, value]
139 |       end
140 | 
141 |       def uproot(nested_hash = nil)
142 |         uproot_helper(nested_hash)[-3..-1]
143 |       end
144 | 
145 |       def uproot_helper(nested_hash = nil, keys = [])
146 |         if nested_hash.respond_to?(:keys)
147 |           keys << nested_hash.keys.first
148 |           uproot_helper(nested_hash[nested_hash.keys.first], keys)
149 |         else
150 |           keys << nested_hash
151 |         end
152 |       end
153 | 
154 |       def nested?(hash = nil, levels = 0)
155 |         i = 0
156 |         until !(hash.respond_to? :keys)
157 |           hash = hash[hash.keys.first]
158 |           i += 1
159 |         end
160 |         i > levels
161 |       end
162 | 
163 |     end
164 |   end
165 | end
166 | 
167 | 


--------------------------------------------------------------------------------
/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 | 


--------------------------------------------------------------------------------
/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.map(&:to_s) - %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 |             build_validation_options(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 client_side_form_settings(options, form_helper)
 28 |           {
 29 |             :type => self.class.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 validate(*attrs)
 38 |       options = attrs.pop if attrs.last.is_a?(Hash)
 39 |       (attrs.present? ? attrs : @object._validators.keys).each do |attr|
 40 |         build_validation_options(attr, :validate => options)
 41 |       end
 42 |       nil
 43 |     end
 44 | 
 45 |     def initialize_with_client_side_validations(object_name, object, template, options, proc)
 46 |       initialize_without_client_side_validations(object_name, object, template, options, proc)
 47 |       @options[:validators] = { object => {} }
 48 |     end
 49 | 
 50 |     def fields_for_with_client_side_validations(record_or_name_or_array, *args, &block)
 51 |       options = args.extract_options!
 52 |       options[:validate] ||= @options[:validate] if @options[:validate] && !options.key?(:validate)
 53 |       fields_for_without_client_side_validations(record_or_name_or_array, *(args << options), &block)
 54 |     end
 55 | 
 56 |     def check_box_with_client_side_validations(method, options = {}, checked_value = "1", unchecked_value = "0")
 57 |       build_validation_options(method, options)
 58 |       options.delete(:validate)
 59 |       check_box_without_client_side_validations(method, options, checked_value, unchecked_value)
 60 |     end
 61 | 
 62 |     def radio_button_with_client_side_validations(method, tag_value, options = {})
 63 |       build_validation_options(method, options)
 64 |       options.delete(:validate)
 65 |       radio_button_without_client_side_validations(method, tag_value, options)
 66 |     end
 67 | 
 68 |     def select_with_client_side_validations(method, choices, options = {}, html_options = {})
 69 |       build_validation_options(method, html_options.merge(:name => options[:name]))
 70 |       html_options.delete(:validate)
 71 |       select_without_client_side_validations(method, choices, options, html_options)
 72 |     end
 73 | 
 74 |     def collection_select_with_client_side_validations(method, collection, value_method, text_method, options = {}, html_options = {})
 75 |       build_validation_options(method, html_options.merge(:name => options[:name]))
 76 |       html_options.delete(:validate)
 77 |       collection_select_without_client_side_validations(method, collection, value_method, text_method, options, html_options)
 78 |     end
 79 | 
 80 |     def grouped_collection_select_with_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
 81 |       build_validation_options(method, html_options.merge(:name => options[:name]))
 82 |       html_options.delete(:validate)
 83 |       grouped_collection_select_without_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
 84 |     end
 85 | 
 86 |     def time_zone_select_with_client_side_validations(method, priority_zones = nil, options = {}, html_options = {})
 87 |       build_validation_options(method, html_options.merge(:name => options[:name]))
 88 |       html_options.delete(:validate)
 89 |       time_zone_select_without_client_side_validations(method, priority_zones, options, html_options)
 90 |     end
 91 | 
 92 |   private
 93 | 
 94 |     def build_validation_options(method, options = {})
 95 |       if @options[:validate]
 96 |         index = @default_options[:index].present? ? "[#{@default_options[:index]}]" : ''
 97 |         name = options[:name] || "#{@object_name}#{index}[#{method}]"
 98 |         child_index = @options[:child_index] ? "(\\d+|#{Regexp.escape(@options[:child_index].to_s)})" : "\\d+"
 99 |         name = name.to_s.gsub(/_attributes\]\[#{child_index}\]/, '_attributes][]')
100 |         name = "#{name}#{options[:multiple] ? "[]" : nil}"
101 |         @options[:validators][@object][method] = { :name => name, :options => options[:validate] }
102 |       end
103 |     end
104 |   end
105 | end
106 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/form_builders/validateForm.js:
--------------------------------------------------------------------------------
  1 | module('Validate Form', {
  2 |   setup: function() {
  3 |     ClientSideValidations.forms['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 |           type: 'text'
 22 |         }))
 23 |         .append($('<label for="user_name">Name</label>'));
 24 |     $('form#new_user').validate();
 25 |   }
 26 | });
 27 | 
 28 | asyncTest('Validate form with invalid form', 4, function() {
 29 |   var form = $('form#new_user'), input = form.find('input#user_name');
 30 |   var label = $('label[for="user_name"]');
 31 | 
 32 |   form.trigger('submit');
 33 |   setTimeout(function() {
 34 |     start();
 35 |     ok(input.parent().hasClass('field_with_errors'));
 36 |     ok(label.parent().hasClass('field_with_errors'));
 37 |     ok(input.parent().find('label:contains("must be present")')[0]);
 38 |     ok(!$('iframe').contents().find('p:contains("Form submitted")')[0]);
 39 |   }, 60);
 40 | });
 41 | 
 42 | asyncTest('Validate form with valid form', 1, function() {
 43 |   var form = $('form#new_user'), input = form.find('input#user_name');
 44 |   input.val('Test');
 45 | 
 46 |   form.trigger('submit');
 47 |   setTimeout(function() {
 48 |     start();
 49 |     ok($('iframe').contents().find('p:contains("Form submitted")')[0]);
 50 |   }, 60);
 51 | });
 52 | 
 53 | asyncTest('Validate form with an input changed to false', 1, function() {
 54 |   var form = $('form#new_user'), input = form.find('input#user_name');
 55 |   input.val('Test');
 56 |   input.attr('changed', false);
 57 |   input.attr('data-valid', true);
 58 | 
 59 |   form.trigger('submit');
 60 |   setTimeout(function() {
 61 |     start();
 62 |     ok($('iframe').contents().find('p:contains("Form submitted")')[0]);
 63 |   }, 60);
 64 | });
 65 | 
 66 | asyncTest('Ensure ajax:beforeSend is not from a bubbled event', 1, function() {
 67 |   var form = $('form#new_user'), input = form.find('input#user_name');
 68 | 
 69 |   form
 70 |     .append('<a />')
 71 |     .find('a').trigger('ajax:beforeSend');
 72 |   setTimeout(function() {
 73 |     start();
 74 |     ok(!input.parent().hasClass('field_with_errors'));
 75 |   });
 76 | });
 77 | 
 78 | asyncTest('Validate form with invalid form and disabling validations', 1, function() {
 79 |   var form = $('form#new_user'), input = form.find('input#user_name');
 80 |   var label = $('label[for="user_name"]');
 81 | 
 82 |   form.disableClientSideValidations();
 83 |   form.trigger('submit');
 84 |   setTimeout(function() {
 85 |     start();
 86 |     ok($('iframe').contents().find('p:contains("Form submitted")')[0]);
 87 |   }, 100);
 88 | });
 89 | 
 90 | test('Resetting client side validations', 9, function() {
 91 |   var form = $('form#new_user'), input = form.find('input#user_name');
 92 |   var label = $('label[for="user_name"]');
 93 | 
 94 |   form.trigger('submit');
 95 |   ok(input.parent().hasClass('field_with_errors'));
 96 |   ok(label.parent().hasClass('field_with_errors'));
 97 |   ok(input.parent().find('label:contains("must be present")')[0]);
 98 | 
 99 |   form.resetClientSideValidations();
100 |   ok(!input.parent().hasClass('field_with_errors'));
101 |   ok(!label.parent().hasClass('field_with_errors'));
102 |   ok(!input.parent().find('label:contains("must be present")')[0]);
103 | 
104 |   form.trigger('submit');
105 |   ok(input.parent().hasClass('field_with_errors'));
106 |   ok(label.parent().hasClass('field_with_errors'));
107 |   ok(input.parent().find('label:contains("must be present")')[0]);
108 | });
109 | 
110 | test('Disable client side validations on all child inputs', 3, function() {
111 |   var form = $('form#new_user'), input = form.find('input#user_name');
112 |   var label = $('label[for="user_name"]');
113 | 
114 |   form.disableClientSideValidations();
115 | 
116 |   input.trigger('focusout');
117 | 
118 |   ok(!input.parent().hasClass('field_with_errors'));
119 |   ok(!label.parent().hasClass('field_with_errors'));
120 |   ok(!input.parent().find('label:contains("must be present")')[0]);
121 | });
122 | 
123 | asyncTest('Handle disable-with', 1, function() {
124 |   var form = $('form#new_user'), input = form.find('input#user_name');
125 |   var label = $('label[for="user_name"]');
126 |   form.append($('<input />', {
127 |     type:                'submit',
128 |     'data-disable-with': 'Waiting...',
129 |     name:                'commit',
130 |     value:               'Save',
131 |     id:                  'submit_button'
132 |   }));
133 | 
134 |   form.trigger('submit');
135 |   setTimeout(function() {
136 |     start();
137 |     ok($('#submit_button').attr('disabled') === undefined)
138 |   }, 60);
139 | });
140 | 
141 | asyncTest('Disabled inputs do not stop form submission', 1, function() {
142 |   var form = $('form#new_user'), input = form.find('input#user_name');
143 |   var label = $('label[for="user_name"]');
144 | 
145 |   input.disableClientSideValidations()
146 |   form.trigger('submit');
147 |   setTimeout(function() {
148 |     start();
149 |     ok($('iframe').contents().find('p:contains("Form submitted")')[0]);
150 |   }, 60);
151 | });
152 | 
153 | asyncTest('Decorative (without name) inputs aren\'t validated', 1, function() {
154 |   var form = $('form#new_user'), input = form.find('input#user_name');
155 |   input.val('Test');
156 |   form.append($('<input />', {type: 'text'})).validate();
157 | 
158 |   form.trigger('submit');
159 |   setTimeout(function() {
160 |     start();
161 |     ok($('iframe').contents().find('p:contains("Form submitted")')[0]);
162 |   }, 60);
163 | });
164 | 


--------------------------------------------------------------------------------
/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, *args, &block)
  6 |       options = args.extract_options!
  7 |       if options[:validate]
  8 | 
  9 |         # Always turn off HTML5 Validations
 10 |         options[:html] ||= {}
 11 |         options[:html][:novalidate] = 'novalidate'
 12 | 
 13 |         case record
 14 |         when String, Symbol
 15 |           raise ClientSideValidations::ActionView::Helpers::FormHelper::Error, 'Using form_for(:name, @resource) is not supported with ClientSideValidations. Please use form_for(@resource, :as => :name) instead.'
 16 |         else
 17 |           object = record.is_a?(Array) ? record.last : record
 18 |         end
 19 |       end
 20 | 
 21 |       @validators = {}
 22 | 
 23 |       # Order matters here. Rails mutates the options object
 24 |       html_id = options[:html][:id] if options[:html]
 25 |       form   = super(record, *(args << options), &block)
 26 |       build_bound_validators(options)
 27 |       options[:id] = html_id if html_id
 28 |       script = client_side_form_settings(object, options)
 29 | 
 30 |       # Because of the load order requirement above this sub is necessary
 31 |       # Would be nice to not do this
 32 |       script = insert_validators_into_script(script)
 33 | 
 34 |       if assign_script_to_content_for(options[:validate], script)
 35 |         form.html_safe
 36 |       else
 37 |         "#{form}#{script}".html_safe
 38 |       end
 39 |     end
 40 | 
 41 |     def assign_script_to_content_for(name, script)
 42 |       if name && name != true
 43 |         content_for(name) { script.html_safe }
 44 |         true
 45 |       end
 46 |     end
 47 | 
 48 |     def apply_form_for_options!(object_or_array, options)
 49 |       super
 50 |       options[:html][:validate] = true if options[:validate]
 51 |     end
 52 | 
 53 |     def fields_for(record_or_name_or_array, record_object = nil, options = {}, &block)
 54 |       output = super
 55 |       build_bound_validators(options)
 56 |       output
 57 |     end
 58 | 
 59 |     private
 60 | 
 61 |     def build_bound_validators(options)
 62 |       if @validators
 63 |         options[:validators].each do |key, value|
 64 |           if @validators.key?(key)
 65 |             @validators[key].merge! value
 66 |           else
 67 |             @validators[key] = value
 68 |           end
 69 |         end
 70 |       end
 71 |     end
 72 | 
 73 |     def insert_validators_into_script(script)
 74 |       # There is probably a more performant way of doing this
 75 |       # But using String#sub has some issues. Undocumented "features"
 76 |       if script
 77 |         script = script.split(/"validator_hash"/)
 78 |         script = "#{script[0]}#{construct_validators.to_json}#{script[1]}"
 79 |       end
 80 | 
 81 |       script
 82 |     end
 83 | 
 84 |     def construct_validators
 85 |       @validators.inject({}) do |validator_hash, object_opts|
 86 |         option_hash = object_opts[1].inject({}) do |option_hash, attr|
 87 |           option_hash.merge!(attr[0] => attr[1][:options])
 88 |         end
 89 | 
 90 |         if object_opts[0].respond_to?(:client_side_validation_hash)
 91 |           validation_hash = object_opts[0].client_side_validation_hash(option_hash)
 92 |         else
 93 |           validation_hash = {}
 94 |         end
 95 | 
 96 |         option_hash.each_key do |attr|
 97 |           if validation_hash[attr]
 98 |             validator_hash.merge!(object_opts[1][attr][:name] => validation_hash[attr])
 99 |           end
100 |         end
101 | 
102 |         validator_hash
103 |       end
104 |     end
105 | 
106 |     def client_side_form_settings(object, options)
107 |       if options[:validate]
108 |         builder = options[:parent_builder]
109 | 
110 |         if options[:id]
111 |           var_name = options[:id]
112 |         else
113 |           if Rails.version >= '3.2.0'
114 |             var_name = if object.respond_to?(:persisted?) && object.persisted?
115 |               options[:as] ? "edit_#{options[:as]}" : [options[:namespace], dom_id(object, :edit)].compact.join("_")
116 |             else
117 |               options[:as] ? "new_#{options[:as]}" : [options[:namespace], dom_id(object)].compact.join("_")
118 |             end
119 |           else
120 |             # This is to maintain backward compatibility with Rails 3.1
121 |             # see: https://github.com/rails/rails/commit/e29773f885fd500189ffd964550ae20061d745ba#commitcomment-948052
122 |             var_name = if object.respond_to?(:persisted?) && object.persisted?
123 |               options[:as] ? "#{options[:as]}_edit" : dom_id(object, :edit)
124 |             else
125 |               options[:as] ? "#{options[:as]}_new" : dom_id(object)
126 |             end
127 |           end
128 |         end
129 | 
130 |         if ClientSideValidations::Config.number_format_with_locale and defined?(I18n)
131 |           number_format = I18n.t("number.format").slice(:separator, :delimiter)
132 |         else
133 |           number_format = {:separator=>".", :delimiter=>","}
134 |         end
135 |         patterns = {:numericality=>"/^(-|\\+)?(?:\\d+|\\d{1,3}(?:\\#{number_format[:delimiter]}\\d{3})+)(?:\\#{number_format[:separator]}\\d*)?$/"}
136 | 
137 | 
138 |         content_tag(:script) do
139 |           "//<![CDATA[\nif(window.ClientSideValidations===undefined)window.ClientSideValidations={};window.ClientSideValidations.disabled_validators=#{ClientSideValidations::Config.disabled_validators.to_json};window.ClientSideValidations.number_format=#{number_format.to_json};if(window.ClientSideValidations.patterns===undefined)window.ClientSideValidations.patterns = {};window.ClientSideValidations.patterns.numericality=#{patterns[:numericality]};#{"if(window.ClientSideValidations.remote_validators_prefix===undefined)window.ClientSideValidations.remote_validators_prefix='#{(ClientSideValidations::Config.root_path).sub(/\/+\Z/,'')}';" if ClientSideValidations::Config.root_path.present? }if(window.ClientSideValidations.forms===undefined)window.ClientSideValidations.forms={};window.ClientSideValidations.forms['#{var_name}'] = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};\n//]]>".html_safe
140 |         end
141 |       end
142 |     end
143 | 
144 |   end
145 | end
146 | 
147 | 


--------------------------------------------------------------------------------
/test/action_view/cases/helper.rb:
--------------------------------------------------------------------------------
  1 | require 'base_helper'
  2 | require 'action_view'
  3 | require 'action_view/template'
  4 | require 'action_view/models'
  5 | require 'client_side_validations/action_view'
  6 | 
  7 | module ActionController
  8 |   class Base
  9 |     include ActionDispatch::Routing::RouteSet.new.url_helpers
 10 |   end
 11 | end
 12 | 
 13 | module ActionViewTestSetup
 14 |   include ::ClientSideValidations::ActionView::Helpers::FormHelper
 15 |   include ::ClientSideValidations::ActionView::Helpers::FormTagHelper
 16 | 
 17 |   def form_for(*)
 18 |     @output_buffer = super
 19 |   end
 20 | 
 21 |   Routes = ActionDispatch::Routing::RouteSet.new
 22 |   Routes.draw do
 23 |     resources :posts do
 24 |       resources :comments
 25 |     end
 26 | 
 27 |     root :to => 'main#index'
 28 |   end
 29 | 
 30 |   def url_for(object)
 31 |     @url_for_options = object
 32 |     if object.is_a?(Hash) && object[:use_route].blank? && object[:controller].blank?
 33 |       object.merge!(:controller => "main", :action => "index")
 34 |     end
 35 |     super
 36 |   end
 37 | 
 38 |   def _routes
 39 |     Routes
 40 |   end
 41 | 
 42 |   # Rails 3.2.0 dropped size from the form elements
 43 |   def legacy_size
 44 |     if Rails.version < '3.2.0'
 45 |       'size="30" '
 46 |     end
 47 |   end
 48 | 
 49 |   def hidden_input_for_select(name)
 50 |     if Rails.version >= '3.2.0'
 51 |       %{<input name="#{name}" type="hidden" value="" />}
 52 |     end
 53 |   end
 54 | 
 55 |   include Routes.url_helpers
 56 | 
 57 |   def setup
 58 |     super
 59 | 
 60 |     # Create 'label' locale for testing I18n label helpers
 61 |     I18n.backend.store_translations 'label', {
 62 |       :activemodel => {
 63 |         :attributes => {
 64 |           :post => {
 65 |             :cost => 'Total cost'
 66 |           }
 67 |         }
 68 |       },
 69 |       :helpers => {
 70 |         :label => {
 71 |           :post => {
 72 |             :body => 'Write entire text here'
 73 |           }
 74 |         }
 75 |       }
 76 |     }
 77 | 
 78 |     # Create "submit" locale for testing I18n submit helpers
 79 |     I18n.backend.store_translations 'submit', {
 80 |       :helpers => {
 81 |         :submit => {
 82 |           :create => 'Create %{model}',
 83 |           :update => 'Confirm %{model} changes',
 84 |           :submit => 'Save changes',
 85 |           :another_post => {
 86 |             :update => 'Update your %{model}'
 87 |           }
 88 |         }
 89 |       }
 90 |     }
 91 | 
 92 |     @post = Post.new
 93 |     @comment = Comment.new
 94 | 
 95 |     if defined?(ActionView::OutputFlow)
 96 |       @view_flow        = ActionView::OutputFlow.new
 97 |     else
 98 |       @_content_for     = Hash.new { |h,k| h[k] = ActiveSupport::SafeBuffer.new }
 99 |     end
100 |   end
101 | 
102 |   def snowman(method = nil)
103 |     txt =  %{<div style="margin:0;padding:0;display:inline">}
104 |     txt << %{<input name="utf8" type="hidden" value="&#x2713;" />}
105 |     txt << %{<input name="_method" type="hidden" value="#{method}" />} if method
106 |     txt << %{</div>}
107 |   end
108 | 
109 |   def form_text(action = "http://www.example.com", id = nil, html_class = nil, remote = nil, validators = nil, file = nil)
110 |     txt =  %{<form accept-charset="UTF-8" action="#{action}"}
111 |     txt << %{ data-remote="true"} if remote
112 |     txt << %{ class="#{html_class}"} if html_class
113 |     txt << %{ data-validate="true"} if validators
114 |     txt << %{ enctype="multipart/form-data"} if file
115 |     txt << %{ id="#{id}"} if id
116 |     txt << %{ method="post"}
117 |     txt << %{ novalidate="novalidate"} if validators
118 |     txt << %{>}
119 |   end
120 | 
121 |   def whole_form(action = "http://www.example.com", id = nil, html_class = nil, options = nil)
122 |     contents = block_given? ? yield : ""
123 | 
124 |     if options.is_a?(Hash)
125 |       method, remote, validators, file = options.values_at(:method, :remote, :validators, :file)
126 |     else
127 |       method = options
128 |     end
129 | 
130 |     html = form_text(action, id, html_class, remote, validators, file) + snowman(method) + (contents || "") + "</form>"
131 | 
132 |     if options.is_a?(Hash) && options[:validators]
133 |       build_script_tag(html, id, options[:validators])
134 |     else
135 |       html
136 |     end
137 |   end
138 | 
139 |   def build_script_tag(html, id, validators)
140 |     number_format = {:separator => '.', :delimiter => ','}
141 |     patterns = {:numericality=>"/^(-|\\+)?(?:\\d+|\\d{1,3}(?:\\#{number_format[:delimiter]}\\d{3})+)(?:\\#{number_format[:separator]}\\d*)?$/"}
142 |     (html || '') + %Q{<script>//<![CDATA[\nif(window.ClientSideValidations===undefined)window.ClientSideValidations={};window.ClientSideValidations.disabled_validators=#{ClientSideValidations::Config.disabled_validators.to_json};window.ClientSideValidations.number_format=#{number_format.to_json};if(window.ClientSideValidations.patterns===undefined)window.ClientSideValidations.patterns = {};window.ClientSideValidations.patterns.numericality=#{patterns[:numericality]};if(window.ClientSideValidations.forms===undefined)window.ClientSideValidations.forms={};window.ClientSideValidations.forms['#{id}'] = #{client_side_form_settings_helper.merge(:validators => validators).to_json};\n//]]></script>}
143 |   end
144 | 
145 |   protected
146 |     def comments_path(post)
147 |       "/posts/#{post.id}/comments"
148 |     end
149 |     alias_method :post_comments_path, :comments_path
150 | 
151 |     def comment_path(post, comment)
152 |       "/posts/#{post.id}/comments/#{comment.id}"
153 |     end
154 |     alias_method :post_comment_path, :comment_path
155 | 
156 |     def admin_comments_path(post)
157 |       "/admin/posts/#{post.id}/comments"
158 |     end
159 |     alias_method :admin_post_comments_path, :admin_comments_path
160 | 
161 |     def admin_comment_path(post, comment)
162 |       "/admin/posts/#{post.id}/comments/#{comment.id}"
163 |     end
164 |     alias_method :admin_post_comment_path, :admin_comment_path
165 | 
166 |     def posts_path(options={})
167 |       "/posts"
168 |     end
169 | 
170 |     def post_path(post, options = {})
171 |       if options[:format]
172 |         "/posts/#{post.id}.#{options[:format]}"
173 |       else
174 |         "/posts/#{post.id}"
175 |       end
176 |     end
177 | 
178 |     def protect_against_forgery?
179 |       false
180 |     end
181 | 
182 | end
183 | 
184 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/uniqueness.js:
--------------------------------------------------------------------------------
  1 | module('Uniqueness options', {
  2 |   setup: function() {
  3 |     ClientSideValidations.remote_validators_prefix = undefined;
  4 |     ClientSideValidations.forms['new_user'] = {
  5 |       type: 'ActionView::Helpers::FormBuilder',
  6 |       input_tag: '<div class="field_with_errors"><span id="input_tag" /><label class="message"></label></div>',
  7 |       label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
  8 |       validators: {'user[email]':{"uniqueness":[{"message": "must be unique", "scope":{'name':"pass"}}]},"presence":[{"message": "must be present"}]}
  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($('<input />', {
 20 |           name: 'user[name]',
 21 |           id: 'user_name',
 22 |           type: 'text'
 23 |         }))
 24 |         .append($('<input />', {
 25 |           name: 'user[email]',
 26 |           id: 'user_email',
 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 | test('when using scopes with replacement as checkboxes', function() {
 91 |   var element = $('<input type="text" name="person[age]" />');
 92 |   var options = { 'message': "failed validation", 'with': /\d+/, 'scope': { 'name': 'test name' } };
 93 |   element.val('test')
 94 |   $('#qunit-fixture')
 95 |     .append('<input type="hidden" name="person[name]" value="other name"')
 96 |     .append('<input type="checkbox" name="person[name]" value="test name"/>')
 97 |     .find('input[name="person[name]"]').val('other name');
 98 |   equal(ClientSideValidations.validators.remote.uniqueness(element, options), undefined);
 99 |   $('[name="person[name]"]:checkbox')[0].checked = true;
100 |   equal(ClientSideValidations.validators.remote.uniqueness(element, options), 'failed validation');
101 | });
102 | 
103 | test('when matching uniqueness on a resource with a defined class name', function() {
104 |   var element = $('<input type="text" name="user2[email]"/>');
105 |   var options = { 'message': "failed validation", 'class': "active_record_test_module/user2" };
106 |   element.val('nottaken@test.com');
107 |   equal(ClientSideValidations.validators.remote.uniqueness(element, options), 'failed validation');
108 | });
109 | 
110 | test('when allowing blank', function() {
111 |  var element = $('<input type="text" name="user2[email]" />');
112 |  var options = { 'message': "failed validation", 'with': /\d+/, 'allow_blank': true };
113 |  equal(ClientSideValidations.validators.remote.uniqueness(element, options), undefined);
114 | });
115 | 
116 | test('when not allowing blank', function() {
117 |  var element = $('<input type="text" name="user2[email]" />');
118 |  var options = { 'message': "failed validation", 'with': /\d+/ };
119 |  equal(ClientSideValidations.validators.remote.uniqueness(element, options), "failed validation");
120 | });
121 | 
122 | test('when matching local uniqueness for nested has-many resources', function() {
123 |   $('#qunit-fixture')
124 |     .append($('<form />', {
125 |       action: '/users',
126 |       'data-validate': true,
127 |       method: 'post',
128 |       id: 'new_user_2'
129 |     }))
130 |     .find('form')
131 |       .append($('<input />', {
132 |         name: 'profile[user_attributes][0][email]',
133 |         id: 'user_0_email',
134 |       }))
135 |       .append($('<input />', {
136 |         name: 'profile[user_attributes][1][email]',
137 |         id: 'user_1_email',
138 |       }));
139 | 
140 |   ClientSideValidations.forms['new_user_2'] = {
141 |     type: 'ActionView::Helpers::FormBuilder',
142 |     input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
143 |     label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
144 |     validators: { 'user[email]':{"uniqueness":[{"message": "must be unique"}]}}
145 |   }
146 |   $('form#new_user_2').validate();
147 | 
148 |   var user_0_email = $('#user_0_email'),
149 |       user_1_email = $('#user_1_email'),
150 |       options = { 'message': "must be unique" };
151 | 
152 |   user_0_email.val('not-locally-unique');
153 |   user_1_email.val('not-locally-unique');
154 | 
155 |   equal(ClientSideValidations.validators.remote.uniqueness(user_1_email, options), undefined);
156 |   equal(ClientSideValidations.validators.local.uniqueness(user_1_email, options), "must be unique");
157 | });
158 | 


--------------------------------------------------------------------------------
/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', 'new_post', 'new_post') 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', 'new_post', 'new_post') 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, :html => {:multipart => true}) do |f|
 30 |       concat f.file_field(:cost)
 31 |     end
 32 | 
 33 |     expected = whole_form('/posts', 'new_post', 'new_post', :file => true) do
 34 |       %{<input id="post_cost" name="post[cost]" type="file" />}
 35 |     end
 36 |     assert_equal expected, output_buffer
 37 |   end
 38 | 
 39 |   if Rails.version >= '3.2.0'
 40 |     def test_text_area
 41 |       form_for(@post) do |f|
 42 |         concat f.text_area(:cost)
 43 |       end
 44 | 
 45 |       expected = whole_form('/posts', 'new_post', 'new_post') do
 46 |         %{<textarea cols="40" id="post_cost" name="post[cost]" rows="20">\n</textarea>}
 47 |       end
 48 |       assert_equal expected, output_buffer
 49 |     end
 50 |   elsif Rails.version >= '3.1.0'
 51 |     def test_text_area
 52 |       form_for(@post) do |f|
 53 |         concat f.text_area(:cost)
 54 |       end
 55 | 
 56 |       expected = whole_form('/posts', 'new_post', 'new_post') do
 57 |         %{<textarea cols="40" id="post_cost" name="post[cost]" rows="20"></textarea>}
 58 |       end
 59 |       assert_equal expected, output_buffer
 60 |     end
 61 |   end
 62 | 
 63 |   def test_search_field
 64 |     form_for(@post) do |f|
 65 |       concat f.search_field(:cost)
 66 |     end
 67 | 
 68 |     expected = whole_form('/posts', 'new_post', 'new_post') do
 69 |       %{<input id="post_cost" name="post[cost]" size="30" type="search" />}
 70 |     end
 71 |     assert_equal expected, output_buffer
 72 |   end
 73 | 
 74 |   def test_telephone_field
 75 |     form_for(@post) do |f|
 76 |       concat f.telephone_field(:cost)
 77 |     end
 78 | 
 79 |     expected = whole_form('/posts', 'new_post', 'new_post') do
 80 |       %{<input id="post_cost" name="post[cost]" size="30" type="tel" />}
 81 |     end
 82 |     assert_equal expected, output_buffer
 83 |   end
 84 | 
 85 |   def test_phone_field
 86 |     form_for(@post) do |f|
 87 |       concat f.phone_field(:cost)
 88 |     end
 89 | 
 90 |     expected = whole_form('/posts', 'new_post', 'new_post') do
 91 |       %{<input id="post_cost" name="post[cost]" size="30" type="tel" />}
 92 |     end
 93 |     assert_equal expected, output_buffer
 94 |   end
 95 | 
 96 |   def test_url_field
 97 |     form_for(@post) do |f|
 98 |       concat f.url_field(:cost)
 99 |     end
100 | 
101 |     expected = whole_form('/posts', 'new_post', 'new_post') do
102 |       %{<input id="post_cost" name="post[cost]" size="30" type="url" />}
103 |     end
104 |     assert_equal expected, output_buffer
105 |   end
106 | 
107 |   def test_email_field
108 |     form_for(@post) do |f|
109 |       concat f.email_field(:cost)
110 |     end
111 | 
112 |     expected = whole_form('/posts', 'new_post', 'new_post') do
113 |       %{<input id="post_cost" name="post[cost]" size="30" type="email" />}
114 |     end
115 |     assert_equal expected, output_buffer
116 |   end
117 | 
118 |   def test_number_field
119 |     form_for(@post) do |f|
120 |       concat f.number_field(:cost)
121 |     end
122 | 
123 |     expected = whole_form('/posts', 'new_post', 'new_post') do
124 |       %{<input id="post_cost" name="post[cost]" #{legacy_size}type="number" />}
125 |     end
126 |     assert_equal expected, output_buffer
127 |   end
128 | 
129 |   def test_range_field
130 |     form_for(@post) do |f|
131 |       concat f.range_field(:cost)
132 |     end
133 | 
134 |     expected = whole_form('/posts', 'new_post', 'new_post') do
135 |       %{<input id="post_cost" name="post[cost]" #{legacy_size}type="range" />}
136 |     end
137 |     assert_equal expected, output_buffer
138 |   end
139 | 
140 |   def test_check_box
141 |     form_for(@post) do |f|
142 |       concat f.check_box(:cost)
143 |     end
144 | 
145 |     expected = whole_form('/posts', 'new_post', 'new_post') do
146 |       %{<input name="post[cost]" type="hidden" value="0" />} +
147 |       %{<input id="post_cost" name="post[cost]" type="checkbox" value="1" />}
148 |     end
149 |     assert_equal expected, output_buffer
150 |   end
151 | 
152 |   def test_radio_button
153 |     form_for(@post) do |f|
154 |       concat f.radio_button(:cost, "10")
155 |     end
156 | 
157 |     expected = whole_form('/posts', 'new_post', 'new_post') do
158 |       %{<input id="post_cost_10" name="post[cost]" type="radio" value="10" />}
159 |     end
160 |     assert_equal expected, output_buffer
161 |   end
162 | 
163 |   def test_fields_for
164 |     result = fields_for(@comment) do |c|
165 |       c.text_field(:title)
166 |     end
167 | 
168 |     expected = %{<input id="comment_title" name="comment[title]" size="30" type="text" />}
169 | 
170 |     assert_equal expected, result
171 |   end
172 | 
173 |   def test_select
174 |     form_for(@post) do |f|
175 |       concat f.select(:cost, [])
176 |     end
177 | 
178 |     expected = whole_form('/posts', 'new_post', 'new_post') do
179 |       %{<select id="post_cost" name="post[cost]"></select>}
180 |     end
181 |     assert_equal expected, output_buffer
182 |   end
183 | 
184 |   def test_select_multiple
185 |     form_for(@post) do |f|
186 |       concat f.select(:cost, [], {}, :multiple => true)
187 |     end
188 | 
189 |     expected = whole_form('/posts', 'new_post', 'new_post') do
190 |       %{#{hidden_input_for_select('post[cost][]')}<select id="post_cost" multiple="multiple" name="post[cost][]"></select>}
191 |     end
192 |     assert_equal expected, output_buffer
193 |   end
194 | 
195 |   def test_collection_select
196 |     form_for(@post) do |f|
197 |       concat f.collection_select(:cost, [], :id, :name)
198 |     end
199 | 
200 |     expected = whole_form('/posts', 'new_post', 'new_post') do
201 |       %{<select id="post_cost" name="post[cost]"></select>}
202 |     end
203 |     assert_equal expected, output_buffer
204 |   end
205 | 
206 |   def test_grouped_collection_select
207 |     form_for(@post) do |f|
208 |       concat f.grouped_collection_select(:cost, [], :group_method, :group_label_method, :id, :name)
209 |     end
210 | 
211 |     expected = whole_form('/posts', 'new_post', 'new_post') do
212 |       %{<select id="post_cost" name="post[cost]"></select>}
213 |     end
214 |     assert_equal expected, output_buffer
215 |   end
216 | 
217 |   def test_time_zone_select
218 |     zones = mock('TimeZones')
219 |     zones.stubs(:all).returns([])
220 |     form_for(@post) do |f|
221 |       concat f.time_zone_select(:cost, nil, :model => zones)
222 |     end
223 | 
224 |     expected = whole_form('/posts', 'new_post', 'new_post') do
225 |       %{<select id="post_cost" name="post[cost]"></select>}
226 |     end
227 |     assert_equal expected, output_buffer
228 |   end
229 | 
230 |   def test_string_as_record
231 |     form_for('post') do |f|
232 |       concat f.text_field(:cost)
233 |     end
234 | 
235 |     expected = whole_form('/') do
236 |       %{<input id="post_cost" name="post[cost]" size="30" type="text" />}
237 |     end
238 |     assert_equal expected, output_buffer
239 |   end
240 | 
241 |   def test_symbol_as_record
242 |     form_for(:post) do |f|
243 |       concat f.text_field(:cost)
244 |     end
245 | 
246 |     expected = whole_form('/') do
247 |       %{<input id="post_cost" name="post[cost]" size="30" type="text" />}
248 |     end
249 |     assert_equal expected, output_buffer
250 |   end
251 | end
252 | 
253 | 


--------------------------------------------------------------------------------
/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', { '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', { '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', { '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_value_must_be_typecast
 55 |     User.create(:active => false)
 56 |     get '/validators/uniqueness', { 'user[active]' => 'false', 'case_sensitive' => true }
 57 | 
 58 |     assert_equal 'false', last_response.body
 59 |     assert last_response.ok?
 60 |   end
 61 | 
 62 |   def test_uniqueness_when_id_is_given
 63 |     user = User.create(:email => 'user@test.com')
 64 |     get '/validators/uniqueness', { 'user[email]' => 'user@test.com', 'id' => user.id, 'case_sensitive' => true }
 65 | 
 66 |     assert_equal 'true', last_response.body
 67 |     assert last_response.not_found?
 68 |   end
 69 | 
 70 |   def test_mysql_adapter_uniqueness_when_id_is_given
 71 |     user = User.create(:email => 'user@test.com')
 72 |     User.connection.stubs('adapter_name').returns('Mysql2')
 73 | 
 74 |     sql_without_binary = "#{User.arel_table["email"].eq(user.email).to_sql} AND #{User.arel_table.primary_key.not_eq(user.id).to_sql}"
 75 |     relation = Arel::Nodes::SqlLiteral.new("BINARY #{sql_without_binary}")
 76 | 
 77 |     # NOTE: Stubs User#where because SQLite3 don't know BINARY
 78 |     result = User.where(sql_without_binary)
 79 |     User.expects(:where).with(relation).returns(result)
 80 | 
 81 |     get '/validators/uniqueness', { 'user[email]' => user.email, 'case_sensitive' => true, 'id' => user.id}
 82 |     assert_equal 'true', last_response.body
 83 |   end
 84 | 
 85 |   def test_mysql_adapter_uniqueness_when_id_is_given_with_scope
 86 |     user = User.create(:email => 'user@test.com', :name => 'Brian')
 87 |     User.connection.stubs('adapter_name').returns('Mysql2')
 88 | 
 89 |     sql_without_binary = "#{User.arel_table["email"].eq(user.email).to_sql} AND #{User.arel_table.primary_key.not_eq(user.id).to_sql} AND #{User.arel_table["name"].eq(user.name).to_sql}"
 90 |     relation = Arel::Nodes::SqlLiteral.new("BINARY #{sql_without_binary}")
 91 | 
 92 |     #NOTE: Stubs User#where because SQLite3 don't know BINARY
 93 |     result = User.where(sql_without_binary)
 94 |     User.expects(:where).with(relation).returns(result)
 95 | 
 96 |     get '/validators/uniqueness', { 'user[email]' => user.email, 'scope' => {'name' => user.name}, 'case_sensitive' => true, 'id' => user.id}
 97 |     assert_equal 'true', last_response.body
 98 |   end
 99 | 
100 |   def test_uniqueness_when_scope_is_given
101 |     User.create(:email => 'user@test.com', :age => 25)
102 |     get '/validators/uniqueness', { 'user[email]' => 'user@test.com', 'scope' => { 'age' => 30 }, 'case_sensitive' => true }
103 | 
104 |     assert_equal 'true', last_response.body
105 |     assert last_response.not_found?
106 |   end
107 | 
108 |   def test_uniqueness_when_scope_is_given_and_value_must_be_typecast
109 |     User.create(:email => 'user@test.com', :active => true)
110 |     get '/validators/uniqueness', { 'user[email]' => 'user@test.com', 'scope' => { 'active' => 'true' }, 'case_sensitive' => true }
111 | 
112 |     assert_equal 'false', last_response.body
113 |     assert last_response.ok?
114 |   end
115 | 
116 |   def test_uniqueness_when_multiple_scopes_are_given
117 |     User.create(:email => 'user@test.com', :age => 30, :name => 'Brian')
118 |     get '/validators/uniqueness', { 'user[email]' => 'user@test.com', 'scope' => { 'age' => 30, 'name' => 'Robert' }, 'case_sensitive' => true }
119 | 
120 |     assert_equal 'true', last_response.body
121 |     assert last_response.not_found?
122 |   end
123 | 
124 |   def test_uniqueness_when_case_insensitive
125 |     User.create(:name => 'Brian')
126 |     get '/validators/uniqueness', { 'user[name]' => 'BRIAN', 'case_sensitive' => false }
127 | 
128 |     assert_equal 'false', last_response.body
129 |     assert last_response.ok?
130 |   end
131 | 
132 |   def test_uniqueness_when_attribute_passes_as_an_integer
133 |     User.create(:name => 123)
134 |     get '/validators/uniqueness', { 'user[name]' => 123, 'case_sensitive' => true }
135 | 
136 |     assert_equal 'false', last_response.body
137 |     assert last_response.ok?
138 |   end
139 | 
140 |   def test_uniqueness_when_attribute_passes_as_an_integer
141 |     User.create(:name => 123)
142 |     get '/validators/uniqueness', { 'user[name]' => 123, 'case_sensitive' => true }
143 | 
144 |     assert_equal 'false', last_response.body
145 |     assert last_response.ok?
146 |   end
147 | 
148 |   def test_uniqueness_with_columns_which_are_sql_keywords
149 |     Guid.validates_uniqueness_of :key
150 |     assert_nothing_raised do
151 |       get '/validators/uniqueness', { 'guid[key]' => 'test', 'case_sensitive' => true }
152 |     end
153 |   end
154 | 
155 |   def test_uniqueness_with_limit
156 |     # User.title is limited to 5 characters
157 |     User.create(:title => "abcde")
158 |     get '/validators/uniqueness', { 'user[title]' => 'abcdefgh', 'case_sensitive' => true }
159 | 
160 |     assert_equal 'false', last_response.body
161 |     assert last_response.ok?
162 |   end
163 | 
164 |   def test_uniqueness_with_limit_and_utf8
165 |     with_kcode('UTF8') do
166 |       # User.title is limited to 5 characters
167 |       User.create(:title => "一二三四五")
168 |       get '/validators/uniqueness', { 'user[title]' => '一二三四五六七八', 'case_sensitive' => true }
169 | 
170 |       assert_equal 'false', last_response.body
171 |     assert last_response.ok?
172 |     end
173 |   end
174 | 
175 |   def test_validate_straight_inheritance_uniqueness
176 |     get '/validators/uniqueness', { 'inept_wizard[name]' => 'Rincewind', 'case_sensitive' => true }
177 |     assert_equal 'true', last_response.body
178 |     assert last_response.not_found?
179 | 
180 |     IneptWizard.create(:name => 'Rincewind')
181 |     get '/validators/uniqueness', { 'inept_wizard[name]' => 'Rincewind', 'case_sensitive' => true }
182 |     assert_equal 'false', last_response.body
183 |     assert last_response.ok?
184 | 
185 |     get '/validators/uniqueness', { 'conjurer[name]' => 'Rincewind', 'case_sensitive' => true }
186 |     assert_equal 'false', last_response.body
187 |     assert last_response.ok?
188 | 
189 |     Conjurer.create(:name => 'The Amazing Bonko')
190 |     get '/validators/uniqueness', { 'thaumaturgist[name]' => 'The Amazing Bonko', 'case_sensitive' => true }
191 |     assert_equal 'false', last_response.body
192 |     assert last_response.ok?
193 |   end
194 | 
195 |   def test_uniqueness_when_resource_is_a_nested_module
196 |     ActiveRecordTestModule::User2.create(:email => 'user@test.com')
197 |     get '/validators/uniqueness', { 'active_record_test_module/user2[email]' => 'user@test.com', 'case_sensitive' => true }
198 | 
199 |     assert_equal 'false', last_response.body
200 |     assert last_response.ok?
201 |   end
202 | 
203 |   def test_uniqueness_when_resource_descends_from_an_abstract_base_class
204 |       Thing.create(:name => 'name_to_be_duplicated')
205 |       get '/validators/uniqueness', { 'thing[name]' => 'name_to_be_duplicated', 'case_sensitive' => true }
206 | 
207 |       assert_equal 'false', last_response.body
208 |       assert last_response.ok?
209 |   end
210 | end
211 | 
212 | 


--------------------------------------------------------------------------------
/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 = { messages: { numericality: "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 = { messages: { numericality: "failed validation" } };
 13 |   // element.val('123.456');
 14 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
 15 | // });
 16 | 
 17 | // test('when there is a custom numericality pattern', function() {
 18 |   // var element = $('<input type="text" />');
 19 |   // var options = { messages: { numericality: "failed validation" } };
 20 |   // var oldPattern = ClientSideValidations.patterns.numericality;
 21 |   // element.val('123,45');
 22 |   // ClientSideValidations.patterns.numericality = /^-?(?:\d+|\d{1,3}(?:\.\d{3})+)(?:,\d*)?$/;
 23 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
 24 |   // ClientSideValidations.patterns.numericality = oldPattern;
 25 | // });
 26 | 
 27 | // test('when value is not a number', function() {
 28 |   // var element = $('<input type="text" />');
 29 |   // var options = { messages: { numericality: "failed validation" } };
 30 |   // element.val('abc123');
 31 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
 32 | // });
 33 | 
 34 | // test('when no value', function() {
 35 |   // var element = $('<input type="text" />');
 36 |   // var options = { messages: { numericality: "failed validation" } };
 37 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
 38 | // });
 39 | 
 40 | test('when no value and allowing blank', function() {
 41 |   var element = $('<input type="text" />');
 42 |   var options = { messages: { numericality: "failed validation" }, allow_blank: true };
 43 |   equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
 44 | });
 45 | 
 46 | // test('when bad value and allowing blank', function() {
 47 |   // var element = $('<input type="text" />');
 48 |   // var options = { messages: { numericality: "failed validation" }, allow_blank: true };
 49 |   // element.val('abc123');
 50 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
 51 | // });
 52 | 
 53 | // test('when only allowing integers and value is integer', function() {
 54 |   // var element = $('<input type="text" />');
 55 |   // var options = { messages: { only_integer: "failed validation", numericality: "failed validation" }, only_integer: true };
 56 |   // element.val('123');
 57 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
 58 | // });
 59 | 
 60 | // test('when only allowing integers and value is integer with whitespace', function() {
 61 |   // var element = $('<input type="text" />');
 62 |   // var options = { messages: { only_integer: "failed validation", numericality: "failed validation" }, only_integer: true };
 63 |   // element.val(' 123 ');
 64 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
 65 | // });
 66 | 
 67 | // test('when only allowing integers and value has a negative or positive sign', function() {
 68 |   // var element = $('<input type="text" />');
 69 |   // var options = { messages: { only_integer: "failed validation", numericality: "failed validation" }, only_integer: true };
 70 |   // element.val('-23');
 71 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
 72 |   // element.val('+23');
 73 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
 74 | // });
 75 | 
 76 | // test('when only allowing integers and value is not integer', function() {
 77 |   // var element = $('<input type="text" />');
 78 |   // var options = { messages: { only_integer: "failed validation", numericality: "failed validation" }, only_integer: true };
 79 |   // element.val('123.456');
 80 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
 81 | // });
 82 | 
 83 | // test('when only allowing values greater than 10 and value is greater than 10', function() {
 84 |   // var element = $('<input type="text" />');
 85 |   // var options = { messages: { greater_than: "failed validation", numericality: "failed validation" }, greater_than: 10 };
 86 |   // element.val('11');
 87 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
 88 | // });
 89 | 
 90 | // test('when only allowing values greater than 10 and value is 10', function() {
 91 |   // var element = $('<input type="text" />');
 92 |   // var options = { messages: { greater_than: "failed validation", numericality: "failed validation" }, greater_than: 10 };
 93 |   // element.val('10');
 94 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
 95 | // });
 96 | 
 97 | // test('when only allowing values greater than or equal to 10 and value is 10', function() {
 98 |   // var element = $('<input type="text" />');
 99 |   // var options = { messages: { greater_than_or_equal_to: "failed validation", numericality: "failed validation" }, greater_than_or_equal_to: 10 };
100 |   // element.val('10');
101 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
102 | // });
103 | 
104 | // test('when only allowing values greater than or equal to 10 and value is 9', function() {
105 |   // var element = $('<input type="text" />');
106 |   // var options = { messages: { greater_than_or_equal_to: "failed validation", numericality: "failed validation" }, greater_than_or_equal_to: 10 };
107 |   // element.val('9');
108 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
109 | // });
110 | 
111 | // test('when only allowing values less than 10 and value is less than 10', function() {
112 |   // var element = $('<input type="text" />');
113 |   // var options = { messages: { less_than: "failed validation", numericality: "failed validation" }, less_than: 10 };
114 |   // element.val('9');
115 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
116 | // });
117 | 
118 | // test('when only allowing values less than 10 and value is 10', function() {
119 |   // var element = $('<input type="text" />');
120 |   // var options = { messages: { less_than: "failed validation", numericality: "failed validation" }, less_than: 10 };
121 |   // element.val('10');
122 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
123 | // });
124 | 
125 | // test('when only allowing values less than or equal to 10 and value is 10', function() {
126 |   // var element = $('<input type="text" />');
127 |   // var options = { messages: { less_than_or_equal_to: "failed validation", numericality: "failed validation" }, less_than_or_equal_to: 10 };
128 |   // element.val('10');
129 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
130 | // });
131 | 
132 | // test('when only allowing values less than or equal to 10 and value is 11', function() {
133 |   // var element = $('<input type="text" />');
134 |   // var options = { messages: { less_than_or_equal_to: "failed validation", numericality: "failed validation" }, less_than_or_equal_to: 10 };
135 |   // element.val('11');
136 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
137 | // });
138 | 
139 | // test('when only allowing values equal to 10 and value is 10', function() {
140 |   // var element = $('<input type="text" />');
141 |   // var options = { messages: { equal_to: "failed validation", numericality: "failed validation" }, equal_to: 10 };
142 |   // element.val('10');
143 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
144 | // });
145 | 
146 | // test('when only allowing values equal to 10 and value is 11', function() {
147 |   // var element = $('<input type="text" />');
148 |   // var options = { messages: { equal_to: "failed validation", numericality: "failed validation" }, equal_to: 10 };
149 |   // element.val('11');
150 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
151 | // });
152 | 
153 | // test('when only allowing value equal to 0 and value is 1', function() {
154 |   // var element = $('<input type="text" />');
155 |   // var options = { messages: { equal_to: "failed validation", numericality: "failed validation" }, equal_to: 0 };
156 |   // element.val('1');
157 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
158 | // });
159 | 
160 | // test('when only allowing odd values and the value is odd', function() {
161 |   // var element = $('<input type="text" />');
162 |   // var options = { messages: { odd: "failed validation", numericality: "failed validation" }, odd: true };
163 |   // element.val('11');
164 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
165 | // });
166 | 
167 | // test('when only allowing odd values and the value is even', function() {
168 |   // var element = $('<input type="text" />');
169 |   // var options = { messages: { odd: "failed validation", numericality: "failed validation" }, odd: true };
170 |   // element.val('10');
171 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
172 | // });
173 | 
174 | // test('when only allowing even values and the value is even', function() {
175 |   // var element = $('<input type="text" />');
176 |   // var options = { messages: { even: "failed validation", numericality: "failed validation" }, even: true };
177 |   // element.val('10');
178 |   // equal(ClientSideValidations.validators.local.numericality(element, options), undefined);
179 | // });
180 | 
181 | // test('when only allowing even values and the value is odd', function() {
182 |   // var element = $('<input type="text" />');
183 |   // var options = { messages: { even: "failed validation", numericality: "failed validation" }, even: true };
184 |   // element.val('11');
185 |   // equal(ClientSideValidations.validators.local.numericality(element, options), "failed validation");
186 | // });
187 | 
188 | // test('when value refers to another present input', function() {
189 |   // var form = $('<form />')
190 |   // var element_1 = $('<input type="text" name="points_1" />');
191 |   // var element_2 = $('<input type="text" name="points_2" />');
192 |   // var options   = { messages: { greater_than: "failed to be greater", numericality: "failed validation" }, greater_than: 'points_2' };
193 | 
194 |   // form.append(element_1).append(element_2);
195 |   // $('#qunit-fixture')
196 |     // .append(form);
197 | 
198 |   // element_1.val(0)
199 |   // element_2.val(1)
200 |   // equal(ClientSideValidations.validators.local.numericality(element_1, options), "failed to be greater");
201 |   // element_1.val(2)
202 |   // equal(ClientSideValidations.validators.local.numericality(element_1, options), undefined);
203 | // });
204 | 
205 | // test('when value refers to another present input but with more than one match', function() {
206 |   // var form = $('<form />')
207 |   // var element_1 = $('<input type="text" name="points_1" />');
208 |   // var element_2 = $('<input type="text" name="points_2" />');
209 |   // var element_3 = $('<input type="text" name="points_21" />');
210 |   // var options   = { messages: { greater_than: "failed to be greater", numericality: "failed validation" }, greater_than: 'points_2' };
211 | 
212 |   // form.append(element_1).append(element_2).append(element_3);
213 |   // $('#qunit-fixture')
214 |     // .append(form);
215 | 
216 |   // element_1.val(1)
217 |   // element_2.val(2)
218 |   // element_3.val(0)
219 |   // equal(ClientSideValidations.validators.local.numericality(element_1, options), undefined);
220 | // });
221 | 


--------------------------------------------------------------------------------
/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, :allow_blank => true
 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 |           :allow_blank => true
 91 |         }]
 92 |       }
 93 |     }
 94 |     assert_equal expected_hash, person.client_side_validation_hash
 95 |   end
 96 | 
 97 |   def test_validations_to_client_side_hash_with_validations_on_update
 98 |     person = new_person do |p|
 99 |       p.validates_length_of :first_name, :is => 10, :on => :update
100 |       p.validates_length_of :last_name, :is => 10, :on => :create
101 |       p.validates_format_of :first_name, :with => //, :on => :create
102 |       p.validates_format_of :last_name, :with => //, :on => :update
103 |       p.validates_numericality_of :age, :on => :update
104 |       p.validates_numericality_of :weight, :on => :create
105 |       p.class_eval do
106 |         def new_record?
107 |           false
108 |         end
109 |       end
110 |     end
111 |     expected_hash = {
112 |       :first_name => {
113 |         :length => [{
114 |           :messages => { :is => 'is the wrong length (should be 10 characters)'},
115 |           :is => 10,
116 |         }],
117 |       },
118 |       :last_name => {
119 |         :format => [{
120 |           :message => 'is invalid',
121 |           :with => //,
122 |         }]
123 |       },
124 |       :age => {
125 |         :numericality => [{
126 |           :messages => { :numericality => 'is not a number' },
127 |         }]
128 |       }
129 |     }
130 |     assert_equal expected_hash, person.client_side_validation_hash
131 |   end
132 | 
133 |   def test_validates_with_should_be_ignored
134 |     person = new_person do |p|
135 |       p.validates_with PersonValidator
136 |     end
137 | 
138 |     expected_hash = {}
139 |     assert_equal expected_hash, person.client_side_validation_hash
140 |   end
141 | 
142 |   def test_generic_block_validators_should_be_ignored
143 |     person = new_person do |p|
144 |       p.validates_each(:first_name) do |record, attr, value|
145 |         record.errors.add(:first_name, "failed")
146 |       end
147 |     end
148 | 
149 |     expected_hash = {}
150 |     assert_equal expected_hash, person.client_side_validation_hash
151 |   end
152 | 
153 |   def test_conditionals_when_not_forced
154 |     person = new_person do |p|
155 |       p.validates :first_name, :presence => { :if => :can_validate? }
156 |       p.validates :last_name,  :presence => { :unless => :cannot_validate? }
157 | 
158 |       p.class_eval do
159 |         def can_validate?
160 |           true
161 |         end
162 | 
163 |         def cannot_validate?
164 |           false
165 |         end
166 |       end
167 |     end
168 | 
169 |     expected_hash = {}
170 |     assert_equal expected_hash, person.client_side_validation_hash
171 |   end
172 | 
173 |   def test_conditionals_when_all_forced_on
174 |     person = new_person do |p|
175 |       p.validates :first_name, :presence => { :if => :can_validate? }
176 |       p.validates :last_name,  :presence => { :unless => :cannot_validate? }
177 | 
178 |       p.class_eval do
179 |         def can_validate?
180 |           true
181 |         end
182 | 
183 |         def cannot_validate?
184 |           false
185 |         end
186 |       end
187 |     end
188 | 
189 |     expected_hash = {
190 |       :first_name => {
191 |         :presence => [{
192 |           :message => "can't be blank"
193 |         }]
194 |       },
195 |       :last_name => {
196 |         :presence => [{
197 |           :message => "can't be blank"
198 |         }]
199 |       }
200 |     }
201 |     assert_equal expected_hash, person.client_side_validation_hash(true)
202 |   end
203 | 
204 |   def test_conditionals_forcing_individual_attributes_on
205 |     person = new_person do |p|
206 |       p.validates :first_name, :presence => { :if => :can_validate? }, :length => { :is => 5, :if => :can_validate? }
207 |       p.validates :last_name, :presence => { :unless => :cannot_validate? }, :length => { :is => 10, :unless => :cannot_validate? }
208 | 
209 |       p.class_eval do
210 |         def can_validate?
211 |           true
212 |         end
213 | 
214 |         def cannot_validate?
215 |           true
216 |         end
217 |       end
218 |     end
219 | 
220 |     expected_hash = {
221 |       :first_name => {
222 |         :presence => [{
223 |           :message => "can't be blank"
224 |         }],
225 |         :length => [{
226 |           :messages => { :is => 'is the wrong length (should be 5 characters)' },
227 |           :is => 5
228 |         }]
229 |       }
230 |     }
231 |     assert_equal expected_hash, person.client_side_validation_hash(:first_name => true)
232 |   end
233 | 
234 |   def test_conditionals_forcing_individual_validators_on
235 |     person = new_person do |p|
236 |       p.validates :first_name, :presence => { :if => :can_validate? }, :length => { :is => 5, :if => :can_validate? }
237 |       p.validates :last_name, :presence => { :unless => :cannot_validate? }, :length => { :is => 10, :unless => :cannot_validate? }
238 | 
239 |       p.class_eval do
240 |         def can_validate?
241 |           true
242 |         end
243 | 
244 |         def cannot_validate?
245 |           true
246 |         end
247 |       end
248 |     end
249 | 
250 |     expected_hash = {
251 |       :first_name => {
252 |         :presence => [{
253 |           :message => "can't be blank"
254 |         }]
255 |       }
256 |     }
257 |     assert_equal expected_hash, person.client_side_validation_hash(:first_name => { :presence => true }, :last_name => { :presence => true })
258 |   end
259 | 
260 |   def test_forcing_all_validators_off
261 |     person = new_person do |p|
262 |       p.validates :first_name, :presence => true
263 |       p.validates :last_name, :presence => true
264 | 
265 |       p.class_eval do
266 |         def can_validate?
267 |           true
268 |         end
269 | 
270 |         def cannot_validate?
271 |           true
272 |         end
273 |       end
274 |     end
275 | 
276 |     expected_hash = {}
277 |     assert_equal expected_hash, person.client_side_validation_hash(false)
278 |   end
279 | 
280 |   def test_conditionals_forcing_individual_attributes_off
281 |     person = new_person do |p|
282 |       p.validates :first_name, :presence => true
283 |       p.validates :last_name, :presence => true
284 | 
285 |       p.class_eval do
286 |         def can_validate?
287 |           true
288 |         end
289 | 
290 |         def cannot_validate?
291 |           true
292 |         end
293 |       end
294 |     end
295 | 
296 |     expected_hash = {
297 |       :last_name => {
298 |         :presence => [{
299 |           :message => "can't be blank"
300 |         }]
301 |       }
302 |     }
303 |     assert_equal expected_hash, person.client_side_validation_hash(:first_name => false)
304 |   end
305 | 
306 |   def test_conditionals_forcing_individual_validators_off
307 |     person = new_person do |p|
308 |       p.validates :first_name, :presence => true, :length => { :is => 5 }
309 | 
310 |       p.class_eval do
311 |         def can_validate?
312 |           true
313 |         end
314 | 
315 |         def cannot_validate?
316 |           true
317 |         end
318 |       end
319 |     end
320 | 
321 |     expected_hash = {
322 |       :first_name => {
323 |         :presence => [{
324 |           :message => "can't be blank"
325 |         }]
326 |       }
327 |     }
328 |     assert_equal expected_hash, person.client_side_validation_hash(:first_name => { :length => false })
329 |   end
330 | 
331 |   def test_conditional_proc_validators
332 |     person = new_person do |p|
333 |       p.validates :first_name, :presence => { :if => Proc.new { |o| o.can_validate? } }
334 |       p.validates :last_name,  :presence => { :unless => Proc.new { |o| o.cannot_validate? } }
335 | 
336 |       p.class_eval do
337 |         def can_validate?
338 |           true
339 |         end
340 | 
341 |         def cannot_validate?
342 |           false
343 |         end
344 |       end
345 |     end
346 | 
347 |     expected_hash = {
348 |       :first_name => {
349 |         :presence => [{
350 |           :message => "can't be blank"
351 |         }]
352 |       },
353 |       :last_name => {
354 |         :presence => [{
355 |           :message => "can't be blank"
356 |         }]
357 |       }
358 |     }
359 |     assert_equal expected_hash, person.client_side_validation_hash(true)
360 |   end
361 | 
362 |   def test_conditionals_forced_when_used_changed_helpers
363 |     person = new_person do |p|
364 |       p.validates :first_name, :presence => { :if => :first_name_changed? }
365 |       p.validates :last_name,  :presence => { :unless => :last_name_changed? }
366 |     end
367 | 
368 |     expected_hash = {
369 |       :first_name => {
370 |         :presence => [{
371 |           :message => "can't be blank"
372 |         }]
373 |       },
374 |     }
375 |     assert_equal expected_hash, person.client_side_validation_hash
376 |   end
377 | 
378 |   def test_multiple_validators_of_same_type_on_same_attribute
379 |     person = new_person do |p|
380 |       p.validates :first_name, :format => /\d/
381 |       p.validates :first_name, :format => /\w/
382 |     end
383 |     expected_hash = {
384 |       :first_name => {
385 |         :format => [{
386 |           :message => 'is invalid',
387 |           :with => /\d/,
388 |         },
389 |         {
390 |           :message => 'is invalid',
391 |           :with => /\w/
392 |         }]
393 |       }
394 |     }
395 |     assert_equal expected_hash, person.client_side_validation_hash
396 |   end
397 | 
398 |   def test_ignored_procs_validators
399 |     person = new_person do |p|
400 |       p.validates :first_name, :format => Proc.new { |o| o.matcher }
401 | 
402 |       def matcher
403 |         /\d/
404 |       end
405 |     end
406 |     expected_hash = {}
407 |     assert_equal expected_hash, person.client_side_validation_hash
408 |   end
409 | 
410 |   def test_validations_to_client_side_hash_with_validator_is_disabled
411 |     ::ClientSideValidations::Config.stubs(:disabled_validators).returns([:presence])
412 |     person = new_person do |p|
413 |       p.validates_presence_of :first_name
414 |     end
415 |     expected_hash = {}
416 |     assert_equal expected_hash, person.client_side_validation_hash
417 |   end
418 | end
419 | 
420 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validateElement.js:
--------------------------------------------------------------------------------
  1 | module('Validate Element', {
  2 |   setup: function() {
  3 |     ClientSideValidations.forms['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 |         'user[info_attributes][eye_color]':{"presence":[{"message": "must be present"}]},
 13 |         'user[phone_numbers_attributes][][number]':{"presence":[{"message": "must be present"}]},
 14 |         'user[phone_numbers_attributes][country_code][][code]':{"presence":[{"message": "must be present"}]},
 15 |         'user[phone_numbers_attributes][deeply][nested][][attribute]':{"presence":[{"message": "must be present"}]}
 16 |       }
 17 |     }
 18 | 
 19 |     $('#qunit-fixture')
 20 |       .append($('<form />', {
 21 |         action: '/users',
 22 |         'data-validate': true,
 23 |         method: 'post',
 24 |         id: 'new_user'
 25 |       }))
 26 |       .find('form')
 27 |         .append($('<label for="user_name">Name</label>'))
 28 |         .append($('<input />', {
 29 |           name: 'user[name]',
 30 |           id: 'user_name',
 31 |           type: 'text'
 32 |         }))
 33 |         .append($('<label for="user_password">Password</label>'))
 34 |         .append($('<input />', {
 35 |           name: 'user[password]',
 36 |           id: 'user_password',
 37 |           type: 'password'
 38 |         }))
 39 |         .append($('<label for="user_password_confirmation">Password Confirmation</label>'))
 40 |         .append($('<input />', {
 41 |           name: 'user[password_confirmation]',
 42 |           id: 'user_password_confirmation',
 43 |           type: 'password'
 44 |         }))
 45 |         .append($('<label for="user_agree">Agree</label>'))
 46 |         .append($('<input />', {
 47 |           name: 'user[agree]',
 48 |           id: 'user_agree',
 49 |           type: 'checkbox',
 50 |           value: 1
 51 |         }))
 52 |         .append($('<input />', {
 53 |           name: 'user[email]',
 54 |           id: 'user_email',
 55 |           type: 'text'
 56 |         }))
 57 |         .append($('<label for="user_phone_numbers_attributes_0_number">Phone Number</label>'))
 58 |         .append($('<input />', {
 59 |           name: 'user[phone_numbers_attributes][0][number]',
 60 |           id: 'user_phone_numbers_attributes_0_number',
 61 |           type: 'text'
 62 |         })
 63 |         .append($('<input />', {
 64 |           name: 'user[phone_numbers_attributes][0][_destroy]',
 65 |           id: 'user_phone_numbers_attributes_0__destroy',
 66 |           type: 'hidden',
 67 |           value: "1"
 68 |         })))
 69 |         .append($('<label for="user_phone_numbers_attributes_1_number">Phone Number</label>'))
 70 |         .append($('<input />', {
 71 |           name: 'user[phone_numbers_attributes][1][number]',
 72 |           id: 'user_phone_numbers_attributes_1_number',
 73 |           type: 'text'
 74 |         }))
 75 |         .append($('<label for="user_phone_numbers_attributes_new_1234_number">Phone Number</label>'))
 76 |         .append($('<input />', {
 77 |           name: 'user[phone_numbers_attributes][new_1234][number]',
 78 |           id: 'user_phone_numbers_attributes_new_1234_number',
 79 |           type: 'text'
 80 |         }))
 81 |         .append($('<label for="user_phone_numbers_attributes_country_code_0_code">Country code</label>'))
 82 |         .append($('<input />', {
 83 |           name: 'user[phone_numbers_attributes][country_code][0][code]',
 84 |           id: 'user_phone_numbers_attributes_country_code_0_code',
 85 |           type: 'text'
 86 |         }))
 87 |         .append($('<label for="user_phone_numbers_attributes_deeply_nested_0_attribute">Deeply nested attribute</label>'))
 88 |         .append($('<input />', {
 89 |           name: 'user[phone_numbers_attributes][deeply][nested][0][attribute]',
 90 |           id: 'user_phone_numbers_attributes_deeply_nested_0_attribute',
 91 |           type: 'text'
 92 |         }))
 93 |         .append($('<label for="user_phone_numbers_attributes_deeply_nested_5154ce728c06dedad4000001_attribute">Deeply nested attribute</label>'))
 94 |         .append($('<input />', {
 95 |           name: 'user[phone_numbers_attributes][deeply][nested][5154ce728c06dedad4000001][attribute]',
 96 |           id: 'user_phone_numbers_attributes_deeply_nested_5154ce728c06dedad4000001_attribute',
 97 |           type: 'text'
 98 |         }))
 99 |         .append($('<label for="user_info_attributes_eye_color">Eye Color</label>'))
100 |         .append($('<input />', {
101 |           name: 'user[info_attributes][eye_color]',
102 |           id: 'user_info_attributes_eye_color',
103 |           type: 'text'
104 |         }));
105 | 
106 |     $('form#new_user').validate();
107 |   },
108 | 
109 |   teardown: function() {
110 |     $('#qunit-fixture').remove('form');
111 |     delete ClientSideValidations.forms.new_user;
112 |   }
113 | });
114 | 
115 | test('Validate when focusouting', function() {
116 |   var form = $('form#new_user'), input = form.find('input#user_name');
117 |   var label = $('label[for="user_name"]');
118 | 
119 |   input.trigger('focusout');
120 |   ok(input.parent().hasClass('field_with_errors'));
121 |   ok(label.parent().hasClass('field_with_errors'));
122 | });
123 | 
124 | test('Validate when checkbox is clicked', function() {
125 |   var form = $('form#new_user'), input = form.find('input#user_agree');
126 |   var label = $('label[for="user_agree"]');
127 | 
128 |   input.prop('checked', false)
129 |   input.trigger('click');
130 |   ok(input.parent().hasClass('field_with_errors'));
131 |   ok(label.parent().hasClass('field_with_errors'));
132 | });
133 | 
134 | test('Validate when focusout on confirmation', function() {
135 |   var form = $('form#new_user'), password = form.find('input#user_password'), confirmation = form.find('input#user_password_confirmation');
136 |   var label = $('label[for="user_password"]');
137 | 
138 |   password.val('password');
139 |   confirmation.trigger('focusout');
140 |   ok(password.parent().hasClass('field_with_errors'));
141 |   ok(label.parent().hasClass('field_with_errors'));
142 | });
143 | 
144 | test('Validate nested attributes', function() {
145 |   var form = $('form#new_user'), input, label;
146 | 
147 |   input = form.find('input#user_phone_numbers_attributes_1_number');
148 |   label = $('label[for="user_phone_numbers_attributes_1_number"]');
149 |   input.trigger('focusout');
150 |   ok(input.parent().hasClass('field_with_errors'));
151 |   ok(label.parent().hasClass('field_with_errors'));
152 | 
153 |   input = form.find('input#user_phone_numbers_attributes_0_number');
154 |   label = $('label[for="user_phone_numbers_attributes_0_number"]');
155 |   input.trigger('focusout');
156 |   ok(!input.parent().hasClass('field_with_errors'));
157 |   ok(!label.parent().hasClass('field_with_errors'));
158 | 
159 |   input = form.find('input#user_phone_numbers_attributes_new_1234_number');
160 |   label = $('label[for="user_phone_numbers_attributes_new_1234_number"]');
161 |   input.trigger('focusout');
162 |   ok(input.parent().hasClass('field_with_errors'));
163 |   ok(label.parent().hasClass('field_with_errors'));
164 | 
165 |   input = form.find('input#user_phone_numbers_attributes_country_code_0_code');
166 |   label = $('label[for="user_phone_numbers_attributes_country_code_0_code"]');
167 |   input.trigger('focusout');
168 |   ok(input.parent().hasClass('field_with_errors'));
169 |   ok(label.parent().hasClass('field_with_errors'));
170 | 
171 |   input = form.find('input#user_phone_numbers_attributes_deeply_nested_0_attribute');
172 |   label = $('label[for="user_phone_numbers_attributes_deeply_nested_0_attribute"]');
173 |   input.trigger('focusout');
174 |   ok(input.parent().hasClass('field_with_errors'));
175 |   ok(label.parent().hasClass('field_with_errors'));
176 | 
177 |   input = form.find('input#user_phone_numbers_attributes_deeply_nested_5154ce728c06dedad4000001_attribute');
178 |   label = $('label[for="user_phone_numbers_attributes_deeply_nested_5154ce728c06dedad4000001_attribute"]');
179 |   input.trigger('focusout');
180 |   ok(input.parent().hasClass('field_with_errors'));
181 |   ok(label.parent().hasClass('field_with_errors'));
182 | });
183 | 
184 | test('Validate additional attributes', function() {
185 |   var form = $('form#new_user'), input, label;
186 | 
187 |   input = form.find('input#user_info_attributes_eye_color');
188 |   label = $('label[for="user_info_attributes_eye_color"]');
189 |   input.trigger('focusout');
190 |   ok(input.parent().hasClass('field_with_errors'));
191 |   ok(label.parent().hasClass('field_with_errors'));
192 | });
193 | 
194 | test('Validate when keyup on confirmation', function() {
195 |   var form = $('form#new_user'), password = form.find('input#user_password'), confirmation = form.find('input#user_password_confirmation');
196 |   var label = $('label[for="user_password"]');
197 | 
198 |   password.val('password');
199 | 
200 |   confirmation.trigger('keyup');
201 |   ok(password.parent().hasClass('field_with_errors'));
202 |   ok(label.parent().hasClass('field_with_errors'));
203 | 
204 |   confirmation.val('password')
205 |   confirmation.trigger('keyup');
206 |   ok(!password.parent().hasClass('field_with_errors'));
207 |   ok(!label.parent().hasClass('field_with_errors'));
208 | });
209 | 
210 | test('Forcing remote validators to run last', function() {
211 |   var form = $('form#new_user'), input = form.find('input#user_email');
212 | 
213 |   input.trigger('focusout');
214 |   equal(input.parent().find('label').text(), "must be present")
215 | });
216 | 
217 | test("Don't validate when value hasn't changed", function() {
218 |   var form = $('form#new_user'), input = form.find('input#user_name');
219 |   var label = $('label[for="user_name"]');
220 | 
221 |   input.trigger('focusout');
222 |   ok(input.parent().hasClass('field_with_errors'));
223 |   ok(label.parent().hasClass('field_with_errors'));
224 | 
225 |   input.val('123');
226 |   input.trigger('focusout');
227 |   ok(input.parent().hasClass('field_with_errors'));
228 |   ok(label.parent().hasClass('field_with_errors'));
229 | 
230 |   input.trigger('change');
231 |   input.trigger('focusout');
232 |   ok(!input.parent().hasClass('field_with_errors'));
233 |   ok(!label.parent().hasClass('field_with_errors'));
234 | });
235 | 
236 | test('Validate when error message needs to change', function() {
237 |   var form = $('form#new_user'), input = form.find('input#user_name');
238 |   var label = $('label[for="user_name"]');
239 | 
240 |   input.trigger('focusout');
241 |   equal(input.parent().find('label.message').text(), "must be present");
242 |   input.val('abc');
243 |   input.trigger('change')
244 |   input.trigger('focusout');
245 |   equal(input.parent().find('label.message').text(), "is invalid");
246 | })
247 | 
248 | test("Don't validate confirmation when not a validatable input", function() {
249 |   $('#qunit-fixture')
250 |     .append($('<form />', {
251 |       action: '/users',
252 |       'data-validate': true,
253 |       method: 'post',
254 |       id: 'new_user_2'
255 |     }))
256 |     .find('form')
257 |       .append($('<label for="user_2_password">Password</label>'))
258 |       .append($('<input />', {
259 |         name: 'user_2[password]',
260 |         id: 'user_2_password',
261 |         type: 'password'
262 |       }))
263 |       .append($('<label for="user_2_password_confirmation">Password Confirmation</label>'))
264 |       .append($('<input />', {
265 |         name: 'user_2[password_confirmation]',
266 |         id: 'user_2_password_confirmation',
267 |         type: 'password'
268 |       }))
269 |   ClientSideValidations.forms['new_user_2'] = {
270 |     type: 'ActionView::Helpers::FormBuilder',
271 |     input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
272 |     label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
273 |     validators: { }
274 |   }
275 |   $('form#new_user_2').validate();
276 |   var form = $('form#new_user_2'), input = form.find('input#user_2_password_confirmation');
277 |   input.val('123');
278 |   input.trigger('focusout');
279 |   ok(!input.parent().hasClass('field_with_errors'));
280 | });
281 | 
282 | test("Don't validate disabled inputs", function() {
283 |   $('#qunit-fixture')
284 |     .append($('<form />', {
285 |       action: '/users',
286 |       'data-validate': true,
287 |       method: 'post',
288 |       id: 'new_user_2'
289 |     }))
290 |     .find('form')
291 |       .append($('<label for="user_2_name">name</label>'))
292 |       .append($('<input />', {
293 |         name: 'user_2[name]',
294 |         id: 'user_2_name',
295 |         type: 'name',
296 |         disabled: 'disabled'
297 |       }))
298 |   ClientSideValidations.forms['new_user_2'] = {
299 |     type: 'ActionView::Helpers::FormBuilder',
300 |     input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
301 |     label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
302 |     validators: { 'user_2[name]':{"presence":{"message": "must be present"}}}
303 |   }
304 |   $('form#new_user_2').validate();
305 |   var form = $('form#new_user_2'), input = form.find('input#user_2_name');
306 |   input.val('');
307 |   input.trigger('focusout');
308 |   ok(!input.parent().hasClass('field_with_errors'));
309 | });
310 | 
311 | test("Don't validate dynamically disabled inputs", function() {
312 |   $('#qunit-fixture')
313 |     .append($('<form />', {
314 |       action: '/users',
315 |       'data-validate': true,
316 |       method: 'post',
317 |       id: 'new_user_2'
318 |     }))
319 |     .find('form')
320 |       .append($('<label for="user_2_name">name</label>'))
321 |       .append($('<input />', {
322 |         name: 'user_2[name]',
323 |         id: 'user_2_name',
324 |         type: 'name',
325 |       }))
326 |   ClientSideValidations.forms['new_user_2'] = {
327 |     type: 'ActionView::Helpers::FormBuilder',
328 |     input_tag: '<div class="field_with_errors"><span id="input_tag" /><label for="user_name" class="message"></label></div>',
329 |     label_tag: '<div class="field_with_errors"><label id="label_tag" /></div>',
330 |     validators: { 'user_2[name]':{"presence":{"message": "must be present"}}}
331 |   }
332 |   $('form#new_user_2').validate();
333 |   var form = $('form#new_user_2'), input = form.find('input#user_2_name');
334 |   input.attr('disabled', 'disabled');
335 |   input.val('');
336 |   input.trigger('focusout');
337 |   ok(!input.parent().hasClass('field_with_errors'));
338 | });
339 | 
340 | test('ensure label is scoped to form', function() {
341 |   var form = $('form#new_user'), input = form.find('input#user_name');
342 |   var label = $('label[for="user_name"]');
343 | 
344 |   $('#qunit-fixture')
345 |     .prepend($('<form />', { id: 'other_form', 'data-validate': true })
346 |     .append($('<label for="user_name">Name</label>')));
347 | 
348 |   var otherLabel = $('form#other_form').find('label')
349 | 
350 |   input.trigger('focusout');
351 |   ok(!otherLabel.parent().hasClass('field_with_errors'));
352 | });
353 | 
354 | test("Return validation result", function() {
355 |   var input = $('#user_name');
356 | 
357 |   ok(!input.isValid(ClientSideValidations.forms['new_user'].validators));
358 | 
359 |   input.val('123').data('changed', true);
360 |   ok(input.isValid(ClientSideValidations.forms['new_user'].validators));
361 | });
362 | 
363 | test('Validate when focusouting and field has disabled validations', function() {
364 |   var form = $('form#new_user'), input = form.find('input#user_name');
365 |   var label = $('label[for="user_name"]');
366 | 
367 |   input.disableClientSideValidations();
368 |   input.trigger('focusout');
369 |   ok(!input.parent().hasClass('field_with_errors'));
370 |   ok(!label.parent().hasClass('field_with_errors'));
371 | 
372 |   input.enableClientSideValidations();
373 |   input.trigger('focusout');
374 |   ok(input.parent().hasClass('field_with_errors'));
375 |   ok(label.parent().hasClass('field_with_errors'));
376 | });
377 | 


--------------------------------------------------------------------------------
/coffeescript/rails.validations.coffee:
--------------------------------------------------------------------------------
  1 | # Rails 3 Client Side Validations - v<%= ClientSideValidations::VERSION %>
  2 | # https://github.com/bcardarella/client_side_validations
  3 | #
  4 | # Copyright (c) <%= DateTime.now.year %> Brian Cardarella
  5 | # Licensed under the MIT license
  6 | # http://www.opensource.org/licenses/mit-license.php
  7 | 
  8 | $ = jQuery
  9 | $.fn.disableClientSideValidations = ->
 10 |   ClientSideValidations.disable(@)
 11 |   @
 12 | 
 13 | $.fn.enableClientSideValidations = ->
 14 |   @filter(ClientSideValidations.selectors.forms).each ->
 15 |     ClientSideValidations.enablers.form(@)
 16 |   @filter(ClientSideValidations.selectors.inputs).each ->
 17 |     ClientSideValidations.enablers.input(@)
 18 |   @
 19 | 
 20 | $.fn.resetClientSideValidations = ->
 21 |   @filter(ClientSideValidations.selectors.forms).each ->
 22 |     ClientSideValidations.reset(@)
 23 |   @
 24 | 
 25 | $.fn.validate = ->
 26 |   @filter(ClientSideValidations.selectors.forms).each ->
 27 |     $(@).enableClientSideValidations()
 28 |   @
 29 | 
 30 | $.fn.isValid = (validators) ->
 31 |   obj = $(@[0])
 32 |   if obj.is('form')
 33 |     validateForm(obj, validators)
 34 |   else
 35 |     validateElement(obj, validatorsFor(@[0].name, validators))
 36 | 
 37 | validatorsFor = (name, validators) ->
 38 |   if captures = name.match /\[(\w+_attributes)\].*\[(\w+)\]$/
 39 |     for validator_name, validator of validators
 40 |       if validator_name.match "\\[#{captures[1]}\\].*\\[\\]\\[#{captures[2]}\\]$"
 41 |         name = name.replace /\[[\da-z_]+\]\[(\w+)\]$/g, "[][$1]"
 42 |   validators[name] || {}
 43 | 
 44 | validateForm = (form, validators) ->
 45 |   form.trigger('form:validate:before.ClientSideValidations')
 46 | 
 47 |   valid = true
 48 |   form.find(ClientSideValidations.selectors.validate_inputs).each ->
 49 |     valid = false unless $(@).isValid(validators)
 50 |     # we don't want the loop to break out by mistake
 51 |     true
 52 | 
 53 |   if valid then form.trigger('form:validate:pass.ClientSideValidations') else form.trigger('form:validate:fail.ClientSideValidations')
 54 | 
 55 |   form.trigger('form:validate:after.ClientSideValidations')
 56 |   valid
 57 | 
 58 | validateElement = (element, validators) ->
 59 |   element.trigger('element:validate:before.ClientSideValidations')
 60 | 
 61 |   passElement = ->
 62 |     element.trigger('element:validate:pass.ClientSideValidations').data('valid', null)
 63 | 
 64 |   failElement = (message) ->
 65 |     element.trigger('element:validate:fail.ClientSideValidations', message).data('valid', false)
 66 |     false
 67 | 
 68 |   afterValidate = ->
 69 |     element.trigger('element:validate:after.ClientSideValidations').data('valid') != false
 70 | 
 71 |   executeValidators = (context) ->
 72 |     valid = true
 73 | 
 74 |     for kind, fn of context
 75 |       if validators[kind]
 76 |         for validator in validators[kind]
 77 |           if message = fn.call(context, element, validator)
 78 |             valid = failElement(message)
 79 |             break
 80 |         unless valid
 81 |           break
 82 | 
 83 |     valid
 84 | 
 85 |   # if _destroy for this input group == "1" pass with flying colours, it'll get deleted anyway..
 86 |   destroyInputName = element.attr('name').replace(/\[([^\]]*?)\]$/, '[_destroy]')
 87 |   if $("input[name='#{destroyInputName}']").val() == "1"
 88 |     passElement()
 89 |     return afterValidate()
 90 | 
 91 |   # if the value hasn't changed since last validation, do nothing
 92 |   unless element.data('changed') != false
 93 |     return afterValidate()
 94 | 
 95 |   element.data('changed', false)
 96 | 
 97 |   local  = ClientSideValidations.validators.local
 98 |   remote = ClientSideValidations.validators.remote
 99 | 
100 |   if executeValidators(local) and executeValidators(remote)
101 |     passElement()
102 | 
103 |   afterValidate()
104 | 
105 | if window.ClientSideValidations == undefined
106 |   window.ClientSideValidations = {}
107 | 
108 | if window.ClientSideValidations.forms == undefined
109 |   window.ClientSideValidations.forms = {}
110 | 
111 | window.ClientSideValidations.selectors =
112 |   inputs: ':input:not(button):not([type="submit"])[name]:visible:enabled'
113 |   validate_inputs: ':input:enabled:visible[data-validate]'
114 |   forms:  'form[data-validate]'
115 | 
116 | window.ClientSideValidations.reset = (form) ->
117 |   $form = $(form)
118 |   ClientSideValidations.disable(form)
119 |   for key of form.ClientSideValidations.settings.validators
120 |     form.ClientSideValidations.removeError($form.find("[name='#{key}']"))
121 | 
122 |   ClientSideValidations.enablers.form(form)
123 | 
124 | window.ClientSideValidations.disable = (target) ->
125 |   $target = $(target)
126 |   $target.off('.ClientSideValidations')
127 |   if $target.is('form')
128 |     ClientSideValidations.disable($target.find(':input'))
129 |   else
130 |     $target.removeData('valid')
131 |     $target.removeData('changed')
132 |     $target.filter(':input').each ->
133 |       $(@).removeAttr('data-validate')
134 | 
135 | window.ClientSideValidations.enablers =
136 |   form: (form) ->
137 |     $form = $(form)
138 |     form.ClientSideValidations =
139 |       settings: window.ClientSideValidations.forms[$form.attr('id')]
140 |       addError: (element, message) ->
141 |         ClientSideValidations.formBuilders[form.ClientSideValidations.settings.type].add(element, form.ClientSideValidations.settings, message)
142 |       removeError: (element) ->
143 |         ClientSideValidations.formBuilders[form.ClientSideValidations.settings.type].remove(element, form.ClientSideValidations.settings)
144 | 
145 |     # Set up the events for the form
146 |     $form.on(event, binding) for event, binding of {
147 |       'submit.ClientSideValidations'              : (eventData) ->
148 |         unless $form.isValid(form.ClientSideValidations.settings.validators)
149 |           eventData.preventDefault()
150 |           eventData.stopImmediatePropagation()
151 |       'ajax:beforeSend.ClientSideValidations'     : (eventData) -> $form.isValid(form.ClientSideValidations.settings.validators) if eventData.target == @
152 |       'form:validate:after.ClientSideValidations' : (eventData) -> ClientSideValidations.callbacks.form.after( $form, eventData)
153 |       'form:validate:before.ClientSideValidations': (eventData) -> ClientSideValidations.callbacks.form.before($form, eventData)
154 |       'form:validate:fail.ClientSideValidations'  : (eventData) -> ClientSideValidations.callbacks.form.fail(  $form, eventData)
155 |       'form:validate:pass.ClientSideValidations'  : (eventData) -> ClientSideValidations.callbacks.form.pass(  $form, eventData)
156 |     }
157 | 
158 |     $form.find(ClientSideValidations.selectors.inputs).each ->
159 |       ClientSideValidations.enablers.input(@)
160 | 
161 |   input: (input) ->
162 |     $input = $(input)
163 |     form   = input.form
164 |     $form  = $(form)
165 | 
166 |     $input.filter(':not(:radio):not([id$=_confirmation])')
167 |       .each ->
168 |         $(@).attr('data-validate', true)
169 |       .on(event, binding) for event, binding of {
170 |         'focusout.ClientSideValidations': ->
171 |           $(@).isValid(form.ClientSideValidations.settings.validators)
172 |         'change.ClientSideValidations':   -> $(@).data('changed', true)
173 |         # Callbacks
174 |         'element:validate:after.ClientSideValidations':  (eventData) -> ClientSideValidations.callbacks.element.after($(@),  eventData)
175 |         'element:validate:before.ClientSideValidations': (eventData) -> ClientSideValidations.callbacks.element.before($(@), eventData)
176 |         'element:validate:fail.ClientSideValidations':   (eventData, message) ->
177 |           element = $(@)
178 |           ClientSideValidations.callbacks.element.fail(element, message, ->
179 |             form.ClientSideValidations.addError(element, message)
180 |           , eventData)
181 |         'element:validate:pass.ClientSideValidations':   (eventData) ->
182 |           element = $(@)
183 |           ClientSideValidations.callbacks.element.pass(element, ->
184 |             form.ClientSideValidations.removeError(element)
185 |           , eventData)
186 |       }
187 | 
188 |     $input.filter(':checkbox').on('click.ClientSideValidations', ->
189 |        $(@).isValid(form.ClientSideValidations.settings.validators)
190 |        # If we don't return true here the checkbox will immediately uncheck itself.
191 |        return true
192 |     )
193 | 
194 |     # Inputs for confirmations
195 |     $input.filter('[id$=_confirmation]').each ->
196 |       confirmationElement = $(@)
197 |       element = $form.find("##{@id.match(/(.+)_confirmation/)[1]}:input")
198 |       if element[0]
199 |         $("##{confirmationElement.attr('id')}").on(event, binding) for event, binding of {
200 |           'focusout.ClientSideValidations': -> element.data('changed', true).isValid(form.ClientSideValidations.settings.validators)
201 |           'keyup.ClientSideValidations'   : -> element.data('changed', true).isValid(form.ClientSideValidations.settings.validators)
202 |         }
203 | 
204 | window.ClientSideValidations.validators =
205 |     all: -> jQuery.extend({}, ClientSideValidations.validators.local, ClientSideValidations.validators.remote)
206 |     local:
207 |       presence: (element, options) ->
208 |         options.message if /^\s*$/.test(element.val() || '')
209 | 
210 |       acceptance: (element, options) ->
211 |         switch element.attr('type')
212 |           when 'checkbox'
213 |             unless element.prop('checked')
214 |               return options.message
215 |           when 'text'
216 |             if element.val() != (options.accept?.toString() || '1')
217 |               return options.message
218 | 
219 |       format: (element, options) ->
220 |         message = @presence(element, options)
221 |         if message
222 |           return if options.allow_blank == true
223 |           return message
224 | 
225 |         return options.message if options.with and !options.with.test(element.val())
226 |         return options.message if options.without and options.without.test(element.val())
227 | 
228 |       numericality: (element, options) ->
229 |         val = jQuery.trim(element.val())
230 |         unless ClientSideValidations.patterns.numericality.test(val)
231 |           return if options.allow_blank == true and @presence(element, {message: options.messages.numericality})
232 |           return options.messages.numericality
233 | 
234 |         val = val.replace(new RegExp("\\#{ClientSideValidations.number_format.delimiter}",'g'),"").replace(new RegExp("\\#{ClientSideValidations.number_format.separator}",'g'),".")
235 | 
236 |         if options.only_integer and !/^[+-]?\d+$/.test(val)
237 |           return options.messages.only_integer
238 | 
239 |         CHECKS =
240 |           greater_than: '>'
241 |           greater_than_or_equal_to: '>='
242 |           equal_to: '=='
243 |           less_than: '<'
244 |           less_than_or_equal_to: '<='
245 | 
246 |         form = $(element[0].form)
247 |         # options[check] may be 0 so we must check for undefined
248 |         for check, operator of CHECKS when options[check]?
249 |           if !isNaN(parseFloat(options[check])) && isFinite(options[check])
250 |             check_value = options[check]
251 |           else if form.find("[name*=#{options[check]}]").size() == 1
252 |             check_value = form.find("[name*=#{options[check]}]").val()
253 |           else
254 |             return
255 | 
256 |           fn = new Function("return #{val} #{operator} #{check_value}")
257 |           return options.messages[check] unless fn()
258 | 
259 |         if options.odd and !(parseInt(val, 10) % 2)
260 |           return options.messages.odd
261 | 
262 |         if options.even and (parseInt(val, 10) % 2)
263 |           return options.messages.even
264 | 
265 |       length: (element, options) ->
266 |         tokenizer = options.js_tokenizer || "split('')"
267 |         tokenized_length = new Function('element', "return (element.val().#{tokenizer} || '').length")(element)
268 |         CHECKS =
269 |           is: '=='
270 |           minimum: '>='
271 |           maximum: '<='
272 |         blankOptions = {}
273 |         blankOptions.message = if options.is
274 |           options.messages.is
275 |         else if options.minimum
276 |           options.messages.minimum
277 | 
278 |         message = @presence(element, blankOptions)
279 |         if message
280 |           return if options.allow_blank == true
281 |           return message
282 | 
283 |         for check, operator of CHECKS when options[check]
284 |           fn = new Function("return #{tokenized_length} #{operator} #{options[check]}")
285 |           return options.messages[check] unless fn()
286 | 
287 |       exclusion: (element, options) ->
288 |         message = @presence(element, options)
289 |         if message
290 |           return if options.allow_blank == true
291 |           return message
292 | 
293 |         if options.in
294 |           return options.message if element.val() in (option.toString() for option in options.in)
295 | 
296 |         if options.range
297 |           lower = options.range[0]
298 |           upper = options.range[1]
299 |           return options.message if element.val() >= lower and element.val() <= upper
300 | 
301 |       inclusion: (element, options) ->
302 |         message = @presence(element, options)
303 |         if message
304 |           return if options.allow_blank == true
305 |           return message
306 | 
307 |         if options.in
308 |           return if element.val() in (option.toString() for option in options.in)
309 |           return options.message
310 | 
311 |         if options.range
312 |           lower = options.range[0]
313 |           upper = options.range[1]
314 |           return if element.val() >= lower and element.val() <= upper
315 |           return options.message
316 | 
317 |       confirmation: (element, options) ->
318 |         if element.val() != jQuery("##{element.attr('id')}_confirmation").val()
319 |           return options.message
320 | 
321 |       uniqueness: (element, options) ->
322 |         name = element.attr('name')
323 | 
324 |         # only check uniqueness if we're in a nested form
325 |         if /_attributes\]\[\d/.test(name)
326 |           matches = name.match(/^(.+_attributes\])\[\d+\](.+)$/)
327 |           name_prefix = matches[1]
328 |           name_suffix = matches[2]
329 |           value = element.val()
330 | 
331 |           if name_prefix && name_suffix
332 |             form = element.closest('form')
333 |             valid = true
334 | 
335 |             form.find(':input[name^="' + name_prefix + '"][name$="' + name_suffix + '"]').each ->
336 |               if $(@).attr('name') != name
337 |                 if $(@).val() == value
338 |                   valid = false
339 |                   $(@).data('notLocallyUnique', true)
340 |                 else
341 |                   # items that were locally non-unique which become locally unique need to be
342 |                   # marked as changed, so they will get revalidated and thereby have their
343 |                   # error state cleared. but we should only do this once; therefore the
344 |                   # notLocallyUnique flag.
345 |                   if $(this).data('notLocallyUnique')
346 |                     $(this)
347 |                       .removeData('notLocallyUnique')
348 |                       .data('changed', true)
349 | 
350 |             if(!valid)
351 |               return options.message
352 | 
353 |     remote:
354 |       uniqueness: (element, options) ->
355 |         message = ClientSideValidations.validators.local.presence(element, options)
356 |         if message
357 |           return if options.allow_blank == true
358 |           return message
359 | 
360 |         data = {}
361 |         data.case_sensitive = !!options.case_sensitive
362 |         data.id = options.id if options.id
363 | 
364 |         if options.scope
365 |           data.scope = {}
366 |           for key, scope_value of options.scope
367 |             scoped_name = element.attr('name').replace(/\[\w+\]$/, "[#{key}]")
368 |             scoped_element = jQuery("[name='#{scoped_name}']")
369 |             jQuery("[name='#{scoped_name}']:checkbox").each ->
370 |               if @.checked
371 |                 scoped_element = @
372 | 
373 |             if scoped_element[0] and scoped_element.val() != scope_value
374 |               data.scope[key] = scoped_element.val()
375 |               scoped_element.unbind("change.#{element.id}").bind "change.#{element.id}", ->
376 |                 element.trigger('change.ClientSideValidations')
377 |                 element.trigger('focusout.ClientSideValidations')
378 |             else
379 |               data.scope[key] = scope_value
380 | 
381 |         # Kind of a hack but this will isolate the resource name and attribute.
382 |         # e.g. user[records_attributes][0][title] => records[title]
383 |         # e.g. user[record_attributes][title] => record[title]
384 |         # Server side handles classifying the resource properly
385 |         if /_attributes\]/.test(element.attr('name'))
386 |           name = element.attr('name').match(/\[\w+_attributes\]/g).pop().match(/\[(\w+)_attributes\]/).pop()
387 |           name += /(\[\w+\])$/.exec(element.attr('name'))[1]
388 |         else
389 |           name = element.attr('name')
390 | 
391 |         # Override the name if a nested module class is passed
392 |         name = options['class'] + '[' + name.split('[')[1] if options['class']
393 |         data[name] = element.val()
394 | 
395 |         if jQuery.ajax({
396 |           url: ClientSideValidations.remote_validators_url_for('uniqueness')
397 |           data: data,
398 |           async: false
399 |           cache: false
400 |         }).status == 200
401 |           return options.message
402 | 
403 | window.ClientSideValidations.remote_validators_url_for = (validator) ->
404 |   if ClientSideValidations.remote_validators_prefix?
405 |     "//#{window.location.host}/#{ClientSideValidations.remote_validators_prefix}/validators/#{validator}"
406 |   else
407 |     "//#{window.location.host}/validators/#{validator}"
408 | 
409 | 
410 | window.ClientSideValidations.disableValidators = () ->
411 |   return if window.ClientSideValidations.disabled_validators == undefined
412 |   for validator, func of window.ClientSideValidations.validators.remote
413 |     if validator in window.ClientSideValidations.disabled_validators
414 |       delete window.ClientSideValidations.validators.remote[validator]
415 | 
416 | window.ClientSideValidations.formBuilders =
417 |     'ActionView::Helpers::FormBuilder':
418 |       add: (element, settings, message) ->
419 |         form = $(element[0].form)
420 |         if element.data('valid') != false and not form.find("label.message[for='#{element.attr('id')}']")[0]?
421 |           inputErrorField = jQuery(settings.input_tag)
422 |           labelErrorField = jQuery(settings.label_tag)
423 |           label = form.find("label[for='#{element.attr('id')}']:not(.message)")
424 | 
425 |           element.attr('autofocus', false) if element.attr('autofocus')
426 | 
427 |           element.before(inputErrorField)
428 |           inputErrorField.find('span#input_tag').replaceWith(element)
429 |           inputErrorField.find('label.message').attr('for', element.attr('id'))
430 |           labelErrorField.find('label.message').attr('for', element.attr('id'))
431 |           labelErrorField.insertAfter(label)
432 |           labelErrorField.find('label#label_tag').replaceWith(label)
433 | 
434 |         form.find("label.message[for='#{element.attr('id')}']").text(message)
435 | 
436 |       remove: (element, settings) ->
437 |         form = $(element[0].form)
438 |         errorFieldClass = jQuery(settings.input_tag).attr('class')
439 |         inputErrorField = element.closest(".#{errorFieldClass.replace(" ", ".")}")
440 |         label = form.find("label[for='#{element.attr('id')}']:not(.message)")
441 |         labelErrorField = label.closest(".#{errorFieldClass}")
442 | 
443 |         if inputErrorField[0]
444 |           inputErrorField.find("##{element.attr('id')}").detach()
445 |           inputErrorField.replaceWith(element)
446 |           label.detach()
447 |           labelErrorField.replaceWith(label)
448 | 
449 | window.ClientSideValidations.patterns =
450 |     numericality: /^(-|\+)?(?:\d+|\d{1,3}(?:,\d{3})+)(?:\.\d*)?$/
451 | 
452 | window.ClientSideValidations.callbacks =
453 |     element:
454 |       after:  (element, eventData)                    ->
455 |       before: (element, eventData)                    ->
456 |       fail:   (element, message, addError, eventData) -> addError()
457 |       pass:   (element, removeError, eventData)       -> removeError()
458 | 
459 |     form:
460 |       after:  (form, eventData) ->
461 |       before: (form, eventData) ->
462 |       fail:   (form, eventData) ->
463 |       pass:   (form, eventData) ->
464 | 
465 | # Main hook
466 | # If new forms are dynamically introduced into the DOM the .validate() method
467 | # must be invoked on that form
468 | $(->
469 |   ClientSideValidations.disableValidators()
470 |   $(ClientSideValidations.selectors.forms).validate()
471 | )
472 | 


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