pax_global_header 0000666 0000000 0000000 00000000064 12202276743 0014517 g ustar 00root root 0000000 0000000 52 comment=03dfff597e025e164f44621846cf25d85e596ddc
client_side_validations-3.2.6/ 0000775 0000000 0000000 00000000000 12202276743 0016406 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/.gitignore 0000664 0000000 0000000 00000000142 12202276743 0020373 0 ustar 00root root 0000000 0000000 *.gem
.bundle
*.lock
pkg/*
tags
test/generators/tmp/*
*.swp
.*rc
bundler_stubs/*
binstubs/*
bin/*
client_side_validations-3.2.6/.travis.yml 0000664 0000000 0000000 00000000125 12202276743 0020515 0 ustar 00root root 0000000 0000000 rvm:
- 1.9.3
before_install:
- gem update --system
- gem install bundler --pre
client_side_validations-3.2.6/CONTRIBUTING.md 0000664 0000000 0000000 00000002426 12202276743 0020643 0 ustar 00root root 0000000 0000000 # Contribution Guidelines #
## Submitting a new issue ##
If you need to open a new issue you *must* provide the following:
1. Version of ClientSideValidations
2. Version of Rails
3. Code snippet from your model of the validations
4. The form code from your template
5. The resulting HTML along with the script tag
Failure to include the above mentioned requirements will result in the
issue being closed.
If you want to ensure that your issue gets fixed *fast* you should
attempt to reproduce the issue in an isolated example application that
you can share.
## Making a pull request ##
If you'd like to submit a pull request please adhere to the following:
1. Your code *must* be tested. Please TDD your code!
2. No single-character variables
3. Two-spaces instead of tabs
4. Single-quotes instead of double-quotes unless you are using string
interpolation or escapes.
5. General Rails/Ruby naming conventions for files and classes
6. *Do not* use Ruby 1.9 hash syntax
7. *Do not* use Ruby 1.9 stubby proc syntax
Plase note that you must adhere to each of the above mentioned rules.
Failure to do so will result in an immediate closing of the pull
request. If you update and rebase the pull request to follow the
guidelines your pull request will be re-opened and considered for
inclusion.
client_side_validations-3.2.6/Gemfile 0000664 0000000 0000000 00000000310 12202276743 0017673 0 ustar 00root root 0000000 0000000 source "http://rubygems.org"
# Specify your gem's dependencies in client_side_validations.gemspec
gemspec
if RUBY_VERSION >= '1.9.3'
gem 'debugger'
elsif RUBY_VERSION < '1.9'
gem 'minitest'
end
client_side_validations-3.2.6/HISTORY.md 0000664 0000000 0000000 00000004441 12202276743 0020074 0 ustar 00root root 0000000 0000000 # ClientSideValidation History #
## Version 3.2 ##
* [v3.2.1](https://github.com/bcardarella/client_side_validations/compare/v3.2.0...v3.2.1)
* [v3.2.0](https://github.com/bcardarella/client_side_validations/compare/v3.1.5...v3.2.0)
## Version 3.1
* [v3.1.5](https://github.com/bcardarella/client_side_validations/compare/v3.1.4...v3.1.5)
* [v3.1.4](https://github.com/bcardarella/client_side_validations/compare/v3.1.3...v3.1.4)
* [v3.1.3](https://github.com/bcardarella/client_side_validations/compare/v3.1.2...v3.1.3)
* [v3.1.2](https://github.com/bcardarella/client_side_validations/compare/v3.1.1...v3.1.2)
* [v3.1.1](https://github.com/bcardarella/client_side_validations/compare/v3.1.0...v3.1.1)
* [v3.1.0](https://github.com/bcardarella/client_side_validations/compare/badf88aa6a09012900e9275bb01c80f4d19482ce...v3.1.0)
## Version 3.0
* [v3.0.13](https://github.com/bcardarella/client_side_validations/compare/v3.0.12...v3.0.13)
* [v3.0.12](https://github.com/bcardarella/client_side_validations/compare/v3.0.11...v3.0.12)
* [v3.0.11](https://github.com/bcardarella/client_side_validations/compare/v3.0.10...v3.0.11)
* [v3.0.10](https://github.com/bcardarella/client_side_validations/compare/v3.0.9...v3.0.10)
* [v3.0.9](https://github.com/bcardarella/client_side_validations/compare/v3.0.8...v3.0.9)
* [v3.0.8](https://github.com/bcardarella/client_side_validations/compare/v3.0.7...v3.0.8)
* [v3.0.7](https://github.com/bcardarella/client_side_validations/compare/v3.0.6...v3.0.7)
* [v3.0.6](https://github.com/bcardarella/client_side_validations/compare/v3.0.5...v3.0.6)
* [v3.0.5](https://github.com/bcardarella/client_side_validations/compare/v3.0.4...v3.0.5)
* [v3.0.4](https://github.com/bcardarella/client_side_validations/compare/v3.0.3...v3.0.4)
* [v3.0.3](https://github.com/bcardarella/client_side_validations/compare/v3.0.2...v3.0.3)
* [v3.0.2](https://github.com/bcardarella/client_side_validations/compare/v3.0.1...v3.0.2)
* [v3.0.1](https://github.com/bcardarella/client_side_validations/compare/v3.0.0...v3.0.1)
* [v3.0.0](https://github.com/bcardarella/client_side_validations/compare/4c6262702e513f1c4c063d36ccc88c0f3071199a...v3.0.0)
## Prior to Version 3.0
This gem was a re-write of the original [ClientSideValidationsgem](https://github.com/dnclabs/client_side_validations).
Versions were not tagged.
client_side_validations-3.2.6/README.md 0000664 0000000 0000000 00000047405 12202276743 0017677 0 ustar 00root root 0000000 0000000 # ClientSideValidations #
[](http://travis-ci.org/bcardarella/client_side_validations)
[](https://gemnasium.com/bcardarella/client_side_validations)
[](https://codeclimate.com/github/bcardarella/client_side_validations)
`ClientSideValidations` made easy for your Rails v3.1+ applications!
## Project Goals ##
1. Follow the best practices for client side validations developed by [Luke Wroblewski](http://www.alistapart.com/articles/inline-validation-in-web-forms/)
2. Automatically extract and apply validation rules defined on the
server to the client.
3. In the cases where a server-side validation rule would not work on
the client (i.e. conditional callbacks like :if, :unless) then do not
attempt client side validations. Fall back to the server side
validation.
4. The client side validation error rendering should be
indistinguishable from the server side validation error rendering.
5. Wide browser compliancy.
6. Work with any ActiveModel::Validations based model
7. Validate nested fields
8. Support custom validations
9. Client side validation callbacks
10. Plugin system to support additional FormBuilders, ORMs, etc...
## Install ##
Include `ClientSideValidations` in your Gemfile
```ruby
gem 'client_side_validations'
```
Then run the install generator
```
rails g client_side_validations:install
```
This will install the initializer:
```
config/initializers/client_side_validations.rb
```
If you want to copy the asset files from the gem into your project:
```
rails g client_side_validations:copy_assets
```
## Initializer ##
The initializer includes a commented out `ActionView::Base.field_error_proc`.
Uncomment this to render your error messages inline with the input fields.
I recommend you not use a solution similar to `error_messages_for`. Client
Side Validations is never going to support rendering this type of error
rendering. If you want to maintain consistency between the client side
rendered validation error messages and the server side rendered
validation error messages please use what is in
`config/initializers/client_side_validations.rb`
## Plugins ##
There is additional support for other `ActiveModel` based ORMs and other
Rails `FormBuilders`. Please see the [Plugin wiki page](https://github.com/bcardarella/client_side_validations/wiki/Plugins)
(feel free to add your own)
* [SimpleForm](https://github.com/DockYard/client_side_validations-simple_form)
* [Formtastic](https://github.com/DockYard/client_side_validations-formtastic)
* [Mongoid](https://github.com/DockYard/client_side_validations-mongoid)
* [MongoMapper](https://github.com/DockYard/client_side_validations-mongo_mapper)
* [Turbolinks](https://github.com/DockYard/client_side_validations-turbolinks)
## Usage ##
The javascript file is served up in the asset pipeline. Add the
following to your `app/assets/javascripts/application.js` file.
```javascript
//= require rails.validations
```
In your `FormBuilder` you only need to enable validations:
```erb
<%= form_for @user, :validate => true do |f| %>
...
```
That should be enough to get you going.
By default the validators will be serialized and embedded in a
`
```
This script registers a new form object on `ClientSideValidations.form`. The key is equal to the ID of the form that is rendered. The objects it contains will have different keys depending upon the `FormBuilder` being used. However, `type` and `validators` will always be present.
### `type` ###
This will always be equal to the class of the `FormBuilder` that did the rendering. The type will be used by the JavaScript to determine how to `add` and `remove` the error messages. If you create a new `FormBuilder` you will need to write your own handlers for adding and removing.
### `validators` ###
This object contains the validators for each of the inputs rendered on the `FormBuilder`. Each input is keyed to the `name` attribute and each containing validator could simply contain the error message itself or also specific options on how that validator should be run.
### Adding validators that aren't inputs ###
If you need to add more validators but don't want them rendered on the form immediately you can inject those validators with `FormBuilder#validate`:
```erb
<%= form_for @user, :validate => true do |f| %>
<%= f.label :name %>
<%= f.text_field :name %>
<%= f.validate :age, :bio %>
...
```
In the above example `age` and `bio` will not render as inputs on the form but their validators will be properly added to the `validators` object for use later. If you do intend to dynamically render these inputs later the `name` attributes on the inputs will have to match with the keys on the `validators` object, and the inputs will have to be enabled for client side validation.
You can add all attributes with validators for the given object by
passing nothing:
```erb
<%= f.validate %>
```
You can also force validators similarly to the input syntax:
```erb
<%= f.validate :email, :uniqueness => false %>
```
Take care when using this method. The embedded validators are
overwritten based upon the order they are rendered. So if you do
something like:
```erb
<%= f.text_field :email, :validate => { :uniqueness => false } %>
<%= f.validate %>
```
The `uniqueness` validator will not be turned off because the options
were overwritten by the call to `FormBuilder#validate`
## Customize Error Rendering ##
`ClientSideValidations` will use `ActiveRecord::Base.field_error_proc` to render the error messages. Other `FormBuilders` will use their own settings.
If you need to change the markup of how the errors are rendered you can modify that in `config/initializers/client_side_validations.rb`
*Please Note* if you modify the markup, you will also need to modify `ClientSideValidations.formBuilders['ActionView::Helpers::FormBuilder']`'s `add` and `remove` functions. You can override the behavior by creating a new javascript file called `rails.validations.actionView.js` that contains the following:
```js
window.ClientSideValidations.formBuilders['ActionView::Helpers::FormBuilder`] = {
add: function(element, settings, message) {
// custom add code here
},
remove: function(element, settings) {
// custom remove code here
}
}
```
Please view the code in `rails.validations.js` to see how the existing `add` and `remove` functions work and how best to override for your specific use-case.
## Custom Validators ##
### Local Validators ###
Client Side Validations supports the use of custom validators. The following is an example for creating a custom validator that validates the format of email addresses.
Let's say you have several models that all have email fields and you are validating the format of that email address on each one. This is a common validation and could probably benefit from a custom validator. We're going to put the validator into `app/validators/email_validator.rb`
```ruby
class EmailValidator < ActiveModel::EachValidator
def validate_each(record, attr_name, value)
unless value =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
record.errors.add(attr_name, :email, options.merge(:value => value))
end
end
end
# This allows us to assign the validator in the model
module ActiveModel::Validations::HelperMethods
def validates_email(*attr_names)
validates_with EmailValidator, _merge_attributes(attr_names)
end
end
```
Next we need to add the error message to the Rails i18n file `config/locales/en.yml`
```yaml
# config/locales/en.yml
en:
errors:
messages:
email: "Not an email address"
```
Finally we need to add a client side validator. This can be done by hooking into the `ClientSideValidations.validator` object. Create a new file `app/assets/javascripts/rails.validations.customValidators.js`
```javascript
// The validator variable is a JSON Object
// The selector variable is a jQuery Object
window.ClientSideValidations.validators.local['email'] = function(element, options) {
// Your validator code goes in here
if (!/^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i.test(element.val())) {
// When the value fails to pass validation you need to return the error message.
// It can be derived from validator.message
return options.message;
}
}
```
That's it! Now you can use the custom validator as you would any other validator in your model
```ruby
# app/models/person.rb
class Person < ActiveRecord::Base
validates_email :email
end
```
Client Side Validations will apply the new validator and validate your forms as needed.
### Remote Validators ###
A good example of a remote validator would be for Zipcodes. It wouldn't be reasonable to embed every single zipcode inline, so we'll need to check for its existence with remote javascript call back to our app. Assume we have a zipcode database mapped to the model Zipcode. The primary key is the unique zipcode. Our Rails validator would probably look something like this:
```ruby
class ZipcodeValidator < ActiveModel::EachValidator
def validate_each(record, attr_name, value)
unless ::Zipcode.where(:id => value).exists?
record.errors.add(attr_name, :zipcode, options.merge(:value => value))
end
end
end
# This allows us to assign the validator in the model
module ActiveModel::Validations::HelperMethods
def validates_zipcode(*attr_names)
validates_with ZipcodeValidator, _merge_attributes(attr_names)
end
end
```
Of course we still need to add the i18n message:
```yaml
en:
errors:
messages:
zipcode: "Not a valid US zip code"
```
And let's add the Javascript validator. Because this will be remote validator we need to add it to `ClientSideValidations.validators.remote`:
```javascript
window.ClientSideValidations.validators.remote['zipcode'] = function(element, options) {
if ($.ajax({
url: '/validators/zipcode',
data: { id: element.val() },
// async *must* be false
async: false
}).status == 404) { return options.message; }
}
```
All we're doing here is checking to see if the resource exists (in this case the given zipcode) and if it doesn't the error message is returned.
Notice that the remote call is forced to *async: false*. This is necessary and the validator may not work properly if this is left out.
Now the extra step for adding a remote validator is to add to the middleware. All ClientSideValidations middleware should inherit from `ClientSideValidations::Middleware::Base`:
```ruby
module ClientSideValidations::Middleware
class Zipcode < ClientSideValidations::Middleware::Base
def response
if ::Zipcode.where(:id => request.params[:id]).exists?
self.status = 200
else
self.status = 404
end
super
end
end
end
```
The `#response` method is always called and it should set the status accessor. Then a call to `super` is required. In the javascript we set the 'id' in the params to the value of the zipcode input, in the middleware we check to see if this zipcode exists in our zipcode database. If it does, we return 200, if it doesn't we return 404.
## Enabling, Disabling, and Resetting on the client ##
There are many reasons why you might want to enable, disable, or even completely reset the bound validation events on the client. `ClientSideValidations` offers a simple API for this.
### Enabling ###
If you have rendered a new form via AJAX into your page you will need to enable that form for validation:
```js
$(new_form).enableClientSideValidations();
```
You should attach this to an event that is fired when the new HTML renders.
You can use the same function if you introduce new inputs to an existing form:
```js
$(new_input).enableClientSideValidations();
```
### Disabling ###
If you wish to turn off validations entirely on a form:
```js
$(form).disableClientSideValidations();
```
### Resetting ###
You can reset the current state of the validations, clear all error messages, and reattach clean event handlers:
```js
$(form).resetClientSideValidations();
```
## Callbacks ##
`ClientSideValidations` will run callbacks based upon the state of the element or form. The following callbacks are supported:
* `ClientSideValidations.callbacks.element.after(element, eventData)`
* `ClientSideValidations.callbacks.element.before(element, eventData)`
* `ClientSideValidations.callbacks.element.fail(element, message, callback, eventData)`
* `ClientSideValidations.callbacks.element.pass(element, callback, eventData)`
* `ClientSideValidations.callbacks.form.after(form, eventData)`
* `ClientSideValidations.callbacks.form.before(form, eventData)`
* `ClientSideValidations.callbacks.form.fail(form, eventData)`
* `ClientSideValidations.callbacks.form.pass(form, eventData)`
The names of the callbacks should be pretty straight forward. For example, `ClientSideValidations.callbacks.form.fail` will be called if a form failed to validate. And `ClientSideValidations.callbacks.element.before` will be called before that particular element's validations are run.
All element callbacks will receive the element in a jQuery object as the first parameter and the eventData object as the second parameter. `ClientSideValidations.callbacks.element.fail()` will receive the message of the failed validation as the second parameter, the callback for adding the error fields as the third and the eventData object as the third. `ClientSideValidations.elementValidatePass()` will receive the callback for removing the error fields. The error field callbacks must be run in your custom callback in some fashion. (either after a blocking event or as a callback for another event, such as an animation)
All form callbacks will receive the form in a jQuery object as the first parameter and the eventData object as the second parameter.
Here is an example callback for sliding out the error message when the validation fails then sliding it back in when the validation passes:
``` javascript
// You will need to require 'jquery-ui' for this to work
window.ClientSideValidations.callbacks.element.fail = function(element, message, callback) {
callback();
if (element.data('valid') !== false) {
element.parent().find('.message').hide().show('slide', {direction: "left", easing: "easeOutBounce"}, 500);
}
}
window.ClientSideValidations.callbacks.element.pass = function(element, callback) {
// Take note how we're passing the callback to the hide()
// method so it is run after the animation is complete.
element.parent().find('.message').hide('slide', {direction: "left"}, 500, callback);
}
```
``` css
.message {
background-color: red;
border-bottom-right-radius: 5px 5px;
border-top-right-radius: 5px 5px;
padding: 2px 5px;
}
div.field_with_errors div.ui-effects-wrapper {
display: inline-block !important;
}
```
Finally uncomment the `ActionView::Base.field_error_proc` override in `config/initializers/client_side_validations.rb`
## Security ##
By default a uniqueness middleware is added. This can be a potential security issue. If you wish this middleware can be disabled. In `config/initializers/client_side_validations.rb` just uncomment:
```ruby
ClientSideValidations::Config.disabled_validators = [:uniqueness]
```
This will completely disable the uniqueness validator. The `FormBuilder`
will automatically skip building validators that are disabled.
## Authors ##
[Brian Cardarella](http://twitter.com/bcardarella)
[We are very thankful for the many contributors](https://github.com/bcardarella/client_side_validations/graphs/contributors)
## Versioning ##
This gem follows [Semantic Versioning](http://semver.org)
Major and minor version numbers will follow `Rails`'s major and
minor version numbers. For example,
`client_side_validations-3.2.0` will be compatible up to
`~> rails-3.2.0`
We will maintain compatibility with one minor version back. So the 3.2.0 version of
`client_side_validations` will be compatible with `~> rails-3.1.0`
Only two versions minor versions will be actively maintained.
## Want to help? ##
Please do! We are always looking to improve this gem. Please see our
[Contribution Guidelines](https://github.com/bcardarella/client_side_validations/blob/master/CONTRIBUTING.md)
on how to properly submit issues and pull requests.
## Legal ##
[DockYard](http://dockyard.com), LLC © 2012
[@dockyard](http://twitter.com/dockyard)
[Licensed under the MIT license](http://www.opensource.org/licenses/mit-license.php)
client_side_validations-3.2.6/Rakefile 0000664 0000000 0000000 00000004763 12202276743 0020065 0 ustar 00root root 0000000 0000000 require 'bundler'
require File.join(File.expand_path('..', __FILE__), 'coffeescript/processor')
Bundler::GemHelper.install_tasks
multitask :default => 'test:ruby'
require 'rake/testtask'
namespace :test do
desc %(Run all tests)
multitask :all => ['test:ruby', 'test:js']
desc %(Test Ruby code)
Rake::TestTask.new(:ruby) do |test|
test.libs << 'lib' << 'test'
test.test_files = Dir.glob("#{File.dirname(__FILE__)}/test/**/test_*.rb").sort
end
desc %(Test Javascript code)
multitask :js => ['test:server', 'test:open']
desc %(Starts the test server)
task :server do
system 'bundle exec ruby test/javascript/server.rb'
end
desc %(Starts the test server which reloads everything on each refresh)
task :reloadable do
exec "bundle exec shotgun test/javascript/config.ru -p #{PORT} --server thin"
end
task :open do
url = "http://localhost:#{PORT}"
puts "Opening test app at #{url} ..."
sleep 3
system( *browse_cmd(url) )
end
end
desc %{Regenerate and commit JavaScript file}
task :regenerate_javascript do
regenerate_javascript
end
Rake::Task[:build].instance_eval { @actions.clear }
task :build do
regenerate_javascript
perform_git_commit
Bundler::GemHelper.new(Dir.pwd).build_gem
end
def perform_git_commit
sh_with_code('git add vendor')
out, code = sh_with_code('git commit -m "Regenerated JavaScript"')
if code == 0
puts "Committed changes"
else
puts "Nothing to commit"
end
end
def regenerate_javascript
ClientSideValidations::Processor.run
puts 'Regenerated JavaScript'
end
def sh_with_code(cmd, &block)
cmd << " 2>&1"
outbuf = ''
Bundler.ui.debug(cmd)
Dir.chdir(Dir.pwd) {
outbuf = `#{cmd}`
if $? == 0
block.call(outbuf) if block
end
}
[outbuf, $?]
end
PORT = 4567
# Returns an array e.g.: ['open', 'http://example.com']
def browse_cmd(url)
require 'rbconfig'
browser = ENV['BROWSER'] ||
(RbConfig::CONFIG['host_os'].include?('darwin') && 'open') ||
(RbConfig::CONFIG['host_os'] =~ /msdos|mswin|djgpp|mingw|windows/ && 'start') ||
%w[xdg-open x-www-browser firefox opera mozilla netscape].find { |comm| which comm }
abort('ERROR: no web browser detected') unless browser
Array(browser) << url
end
# which('ruby') #=> /usr/bin/ruby
def which cmd
exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
exts.each { |ext|
exe = "#{path}/#{cmd}#{ext}"
return exe if File.executable? exe
}
end
return nil
end
client_side_validations-3.2.6/client_side_validations.gemspec 0000664 0000000 0000000 00000002076 12202276743 0024637 0 ustar 00root root 0000000 0000000 # -*- encoding: utf-8 -*-
$:.push File.expand_path("../lib", __FILE__)
require "client_side_validations/version"
Gem::Specification.new do |s|
s.name = "client_side_validations"
s.version = ClientSideValidations::VERSION
s.platform = Gem::Platform::RUBY
s.authors = ["Brian Cardarella"]
s.email = ["bcardarella@gmail.com"]
s.homepage = "https://github.com/bcardarella/client_side_validations"
s.summary = %q{Client Side Validations}
s.description = %q{Client Side Validations}
s.files = `git ls-files -- {lib/*,vendor/*,*.gemspec}`.split("\n")
s.require_paths = ["lib"]
s.add_development_dependency 'rails', '~> 3.2.0'
s.add_development_dependency 'sqlite3'
s.add_development_dependency 'mocha'
s.add_development_dependency 'm'
# For QUnit testing
s.add_development_dependency 'sinatra', '~> 1.0'
s.add_development_dependency 'shotgun'
s.add_development_dependency 'thin'
s.add_development_dependency 'json'
s.add_development_dependency 'coffee-script'
s.add_development_dependency 'jquery-rails'
end
client_side_validations-3.2.6/coffeescript/ 0000775 0000000 0000000 00000000000 12202276743 0021062 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/coffeescript/processor.rb 0000664 0000000 0000000 00000001413 12202276743 0023425 0 ustar 00root root 0000000 0000000 $:.unshift(File.expand_path('../../lib', __FILE__))
require 'client_side_validations/version'
require 'coffee_script'
require 'date'
require 'erb'
module ClientSideValidations
class Processor
def self.run
write_file
end
def self.root_path
File.expand_path('../..', __FILE__)
end
def self.file_name
'rails.validations'
end
def self.template
ERB.new(File.open(File.join(root_path, 'coffeescript', "#{file_name}.coffee")).read)
end
def self.compiled_coffeescript
CoffeeScript.compile(template.result(binding))
end
def self.write_file
file = File.new(File.join(root_path, "vendor/assets/javascripts/#{file_name}.js"), 'w')
file << compiled_coffeescript
file.close
end
end
end
client_side_validations-3.2.6/coffeescript/rails.validations.coffee 0000664 0000000 0000000 00000044621 12202276743 0025670 0 ustar 00root root 0000000 0000000 # Rails 3 Client Side Validations - v<%= ClientSideValidations::VERSION %>
# https://github.com/bcardarella/client_side_validations
#
# Copyright (c) <%= DateTime.now.year %> Brian Cardarella
# Licensed under the MIT license
# http://www.opensource.org/licenses/mit-license.php
$ = jQuery
$.fn.disableClientSideValidations = ->
ClientSideValidations.disable(@)
@
$.fn.enableClientSideValidations = ->
@filter(ClientSideValidations.selectors.forms).each ->
ClientSideValidations.enablers.form(@)
@filter(ClientSideValidations.selectors.inputs).each ->
ClientSideValidations.enablers.input(@)
@
$.fn.resetClientSideValidations = ->
@filter(ClientSideValidations.selectors.forms).each ->
ClientSideValidations.reset(@)
@
$.fn.validate = ->
@filter(ClientSideValidations.selectors.forms).each ->
$(@).enableClientSideValidations()
@
$.fn.isValid = (validators) ->
obj = $(@[0])
if obj.is('form')
validateForm(obj, validators)
else
validateElement(obj, validatorsFor(@[0].name, validators))
validatorsFor = (name, validators) ->
if captures = name.match /\[(\w+_attributes)\].*\[(\w+)\]$/
for validator_name, validator of validators
if validator_name.match "\\[#{captures[1]}\\].*\\[\\]\\[#{captures[2]}\\]$"
name = name.replace /\[[\da-z_]+\]\[(\w+)\]$/g, "[][$1]"
validators[name] || {}
validateForm = (form, validators) ->
form.trigger('form:validate:before.ClientSideValidations')
valid = true
form.find(ClientSideValidations.selectors.validate_inputs).each ->
valid = false unless $(@).isValid(validators)
# we don't want the loop to break out by mistake
true
if valid then form.trigger('form:validate:pass.ClientSideValidations') else form.trigger('form:validate:fail.ClientSideValidations')
form.trigger('form:validate:after.ClientSideValidations')
valid
validateElement = (element, validators) ->
element.trigger('element:validate:before.ClientSideValidations')
passElement = ->
element.trigger('element:validate:pass.ClientSideValidations').data('valid', null)
failElement = (message) ->
element.trigger('element:validate:fail.ClientSideValidations', message).data('valid', false)
false
afterValidate = ->
element.trigger('element:validate:after.ClientSideValidations').data('valid') != false
executeValidators = (context) ->
valid = true
for kind, fn of context
if validators[kind]
for validator in validators[kind]
if message = fn.call(context, element, validator)
valid = failElement(message)
break
unless valid
break
valid
# if _destroy for this input group == "1" pass with flying colours, it'll get deleted anyway..
destroyInputName = element.attr('name').replace(/\[([^\]]*?)\]$/, '[_destroy]')
if $("input[name='#{destroyInputName}']").val() == "1"
passElement()
return afterValidate()
# if the value hasn't changed since last validation, do nothing
unless element.data('changed') != false
return afterValidate()
element.data('changed', false)
local = ClientSideValidations.validators.local
remote = ClientSideValidations.validators.remote
if executeValidators(local) and executeValidators(remote)
passElement()
afterValidate()
if window.ClientSideValidations == undefined
window.ClientSideValidations = {}
if window.ClientSideValidations.forms == undefined
window.ClientSideValidations.forms = {}
window.ClientSideValidations.selectors =
inputs: ':input:not(button):not([type="submit"])[name]:visible:enabled'
validate_inputs: ':input:enabled:visible[data-validate]'
forms: 'form[data-validate]'
window.ClientSideValidations.reset = (form) ->
$form = $(form)
ClientSideValidations.disable(form)
for key of form.ClientSideValidations.settings.validators
form.ClientSideValidations.removeError($form.find("[name='#{key}']"))
ClientSideValidations.enablers.form(form)
window.ClientSideValidations.disable = (target) ->
$target = $(target)
$target.off('.ClientSideValidations')
if $target.is('form')
ClientSideValidations.disable($target.find(':input'))
else
$target.removeData('valid')
$target.removeData('changed')
$target.filter(':input').each ->
$(@).removeAttr('data-validate')
window.ClientSideValidations.enablers =
form: (form) ->
$form = $(form)
form.ClientSideValidations =
settings: window.ClientSideValidations.forms[$form.attr('id')]
addError: (element, message) ->
ClientSideValidations.formBuilders[form.ClientSideValidations.settings.type].add(element, form.ClientSideValidations.settings, message)
removeError: (element) ->
ClientSideValidations.formBuilders[form.ClientSideValidations.settings.type].remove(element, form.ClientSideValidations.settings)
# Set up the events for the form
$form.on(event, binding) for event, binding of {
'submit.ClientSideValidations' : (eventData) ->
unless $form.isValid(form.ClientSideValidations.settings.validators)
eventData.preventDefault()
eventData.stopImmediatePropagation()
'ajax:beforeSend.ClientSideValidations' : (eventData) -> $form.isValid(form.ClientSideValidations.settings.validators) if eventData.target == @
'form:validate:after.ClientSideValidations' : (eventData) -> ClientSideValidations.callbacks.form.after( $form, eventData)
'form:validate:before.ClientSideValidations': (eventData) -> ClientSideValidations.callbacks.form.before($form, eventData)
'form:validate:fail.ClientSideValidations' : (eventData) -> ClientSideValidations.callbacks.form.fail( $form, eventData)
'form:validate:pass.ClientSideValidations' : (eventData) -> ClientSideValidations.callbacks.form.pass( $form, eventData)
}
$form.find(ClientSideValidations.selectors.inputs).each ->
ClientSideValidations.enablers.input(@)
input: (input) ->
$input = $(input)
form = input.form
$form = $(form)
$input.filter(':not(:radio):not([id$=_confirmation])')
.each ->
$(@).attr('data-validate', true)
.on(event, binding) for event, binding of {
'focusout.ClientSideValidations': ->
$(@).isValid(form.ClientSideValidations.settings.validators)
'change.ClientSideValidations': -> $(@).data('changed', true)
# Callbacks
'element:validate:after.ClientSideValidations': (eventData) -> ClientSideValidations.callbacks.element.after($(@), eventData)
'element:validate:before.ClientSideValidations': (eventData) -> ClientSideValidations.callbacks.element.before($(@), eventData)
'element:validate:fail.ClientSideValidations': (eventData, message) ->
element = $(@)
ClientSideValidations.callbacks.element.fail(element, message, ->
form.ClientSideValidations.addError(element, message)
, eventData)
'element:validate:pass.ClientSideValidations': (eventData) ->
element = $(@)
ClientSideValidations.callbacks.element.pass(element, ->
form.ClientSideValidations.removeError(element)
, eventData)
}
$input.filter(':checkbox').on('click.ClientSideValidations', ->
$(@).isValid(form.ClientSideValidations.settings.validators)
# If we don't return true here the checkbox will immediately uncheck itself.
return true
)
# Inputs for confirmations
$input.filter('[id$=_confirmation]').each ->
confirmationElement = $(@)
element = $form.find("##{@id.match(/(.+)_confirmation/)[1]}:input")
if element[0]
$("##{confirmationElement.attr('id')}").on(event, binding) for event, binding of {
'focusout.ClientSideValidations': -> element.data('changed', true).isValid(form.ClientSideValidations.settings.validators)
'keyup.ClientSideValidations' : -> element.data('changed', true).isValid(form.ClientSideValidations.settings.validators)
}
window.ClientSideValidations.validators =
all: -> jQuery.extend({}, ClientSideValidations.validators.local, ClientSideValidations.validators.remote)
local:
presence: (element, options) ->
options.message if /^\s*$/.test(element.val() || '')
acceptance: (element, options) ->
switch element.attr('type')
when 'checkbox'
unless element.prop('checked')
return options.message
when 'text'
if element.val() != (options.accept?.toString() || '1')
return options.message
format: (element, options) ->
message = @presence(element, options)
if message
return if options.allow_blank == true
return message
return options.message if options.with and !options.with.test(element.val())
return options.message if options.without and options.without.test(element.val())
numericality: (element, options) ->
val = jQuery.trim(element.val())
unless ClientSideValidations.patterns.numericality.test(val)
return if options.allow_blank == true and @presence(element, {message: options.messages.numericality})
return options.messages.numericality
val = val.replace(new RegExp("\\#{ClientSideValidations.number_format.delimiter}",'g'),"").replace(new RegExp("\\#{ClientSideValidations.number_format.separator}",'g'),".")
if options.only_integer and !/^[+-]?\d+$/.test(val)
return options.messages.only_integer
CHECKS =
greater_than: '>'
greater_than_or_equal_to: '>='
equal_to: '=='
less_than: '<'
less_than_or_equal_to: '<='
form = $(element[0].form)
# options[check] may be 0 so we must check for undefined
for check, operator of CHECKS when options[check]?
if !isNaN(parseFloat(options[check])) && isFinite(options[check])
check_value = options[check]
else if form.find("[name*=#{options[check]}]").size() == 1
check_value = form.find("[name*=#{options[check]}]").val()
else
return
fn = new Function("return #{val} #{operator} #{check_value}")
return options.messages[check] unless fn()
if options.odd and !(parseInt(val, 10) % 2)
return options.messages.odd
if options.even and (parseInt(val, 10) % 2)
return options.messages.even
length: (element, options) ->
tokenizer = options.js_tokenizer || "split('')"
tokenized_length = new Function('element', "return (element.val().#{tokenizer} || '').length")(element)
CHECKS =
is: '=='
minimum: '>='
maximum: '<='
blankOptions = {}
blankOptions.message = if options.is
options.messages.is
else if options.minimum
options.messages.minimum
message = @presence(element, blankOptions)
if message
return if options.allow_blank == true
return message
for check, operator of CHECKS when options[check]
fn = new Function("return #{tokenized_length} #{operator} #{options[check]}")
return options.messages[check] unless fn()
exclusion: (element, options) ->
message = @presence(element, options)
if message
return if options.allow_blank == true
return message
if options.in
return options.message if element.val() in (option.toString() for option in options.in)
if options.range
lower = options.range[0]
upper = options.range[1]
return options.message if element.val() >= lower and element.val() <= upper
inclusion: (element, options) ->
message = @presence(element, options)
if message
return if options.allow_blank == true
return message
if options.in
return if element.val() in (option.toString() for option in options.in)
return options.message
if options.range
lower = options.range[0]
upper = options.range[1]
return if element.val() >= lower and element.val() <= upper
return options.message
confirmation: (element, options) ->
if element.val() != jQuery("##{element.attr('id')}_confirmation").val()
return options.message
uniqueness: (element, options) ->
name = element.attr('name')
# only check uniqueness if we're in a nested form
if /_attributes\]\[\d/.test(name)
matches = name.match(/^(.+_attributes\])\[\d+\](.+)$/)
name_prefix = matches[1]
name_suffix = matches[2]
value = element.val()
if name_prefix && name_suffix
form = element.closest('form')
valid = true
form.find(':input[name^="' + name_prefix + '"][name$="' + name_suffix + '"]').each ->
if $(@).attr('name') != name
if $(@).val() == value
valid = false
$(@).data('notLocallyUnique', true)
else
# items that were locally non-unique which become locally unique need to be
# marked as changed, so they will get revalidated and thereby have their
# error state cleared. but we should only do this once; therefore the
# notLocallyUnique flag.
if $(this).data('notLocallyUnique')
$(this)
.removeData('notLocallyUnique')
.data('changed', true)
if(!valid)
return options.message
remote:
uniqueness: (element, options) ->
message = ClientSideValidations.validators.local.presence(element, options)
if message
return if options.allow_blank == true
return message
data = {}
data.case_sensitive = !!options.case_sensitive
data.id = options.id if options.id
if options.scope
data.scope = {}
for key, scope_value of options.scope
scoped_name = element.attr('name').replace(/\[\w+\]$/, "[#{key}]")
scoped_element = jQuery("[name='#{scoped_name}']")
jQuery("[name='#{scoped_name}']:checkbox").each ->
if @.checked
scoped_element = @
if scoped_element[0] and scoped_element.val() != scope_value
data.scope[key] = scoped_element.val()
scoped_element.unbind("change.#{element.id}").bind "change.#{element.id}", ->
element.trigger('change.ClientSideValidations')
element.trigger('focusout.ClientSideValidations')
else
data.scope[key] = scope_value
# Kind of a hack but this will isolate the resource name and attribute.
# e.g. user[records_attributes][0][title] => records[title]
# e.g. user[record_attributes][title] => record[title]
# Server side handles classifying the resource properly
if /_attributes\]/.test(element.attr('name'))
name = element.attr('name').match(/\[\w+_attributes\]/g).pop().match(/\[(\w+)_attributes\]/).pop()
name += /(\[\w+\])$/.exec(element.attr('name'))[1]
else
name = element.attr('name')
# Override the name if a nested module class is passed
name = options['class'] + '[' + name.split('[')[1] if options['class']
data[name] = element.val()
if jQuery.ajax({
url: ClientSideValidations.remote_validators_url_for('uniqueness')
data: data,
async: false
cache: false
}).status == 200
return options.message
window.ClientSideValidations.remote_validators_url_for = (validator) ->
if ClientSideValidations.remote_validators_prefix?
"//#{window.location.host}/#{ClientSideValidations.remote_validators_prefix}/validators/#{validator}"
else
"//#{window.location.host}/validators/#{validator}"
window.ClientSideValidations.disableValidators = () ->
return if window.ClientSideValidations.disabled_validators == undefined
for validator, func of window.ClientSideValidations.validators.remote
if validator in window.ClientSideValidations.disabled_validators
delete window.ClientSideValidations.validators.remote[validator]
window.ClientSideValidations.formBuilders =
'ActionView::Helpers::FormBuilder':
add: (element, settings, message) ->
form = $(element[0].form)
if element.data('valid') != false and not form.find("label.message[for='#{element.attr('id')}']")[0]?
inputErrorField = jQuery(settings.input_tag)
labelErrorField = jQuery(settings.label_tag)
label = form.find("label[for='#{element.attr('id')}']:not(.message)")
element.attr('autofocus', false) if element.attr('autofocus')
element.before(inputErrorField)
inputErrorField.find('span#input_tag').replaceWith(element)
inputErrorField.find('label.message').attr('for', element.attr('id'))
labelErrorField.find('label.message').attr('for', element.attr('id'))
labelErrorField.insertAfter(label)
labelErrorField.find('label#label_tag').replaceWith(label)
form.find("label.message[for='#{element.attr('id')}']").text(message)
remove: (element, settings) ->
form = $(element[0].form)
errorFieldClass = jQuery(settings.input_tag).attr('class')
inputErrorField = element.closest(".#{errorFieldClass.replace(" ", ".")}")
label = form.find("label[for='#{element.attr('id')}']:not(.message)")
labelErrorField = label.closest(".#{errorFieldClass}")
if inputErrorField[0]
inputErrorField.find("##{element.attr('id')}").detach()
inputErrorField.replaceWith(element)
label.detach()
labelErrorField.replaceWith(label)
window.ClientSideValidations.patterns =
numericality: /^(-|\+)?(?:\d+|\d{1,3}(?:,\d{3})+)(?:\.\d*)?$/
window.ClientSideValidations.callbacks =
element:
after: (element, eventData) ->
before: (element, eventData) ->
fail: (element, message, addError, eventData) -> addError()
pass: (element, removeError, eventData) -> removeError()
form:
after: (form, eventData) ->
before: (form, eventData) ->
fail: (form, eventData) ->
pass: (form, eventData) ->
# Main hook
# If new forms are dynamically introduced into the DOM the .validate() method
# must be invoked on that form
$(->
ClientSideValidations.disableValidators()
$(ClientSideValidations.selectors.forms).validate()
)
client_side_validations-3.2.6/lib/ 0000775 0000000 0000000 00000000000 12202276743 0017154 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/lib/client_side_validations.rb 0000664 0000000 0000000 00000000717 12202276743 0024365 0 ustar 00root root 0000000 0000000 module ClientSideValidations
end
require 'client_side_validations/config'
require 'client_side_validations/active_model' if defined?(::ActiveModel)
require 'client_side_validations/active_record' if defined?(::ActiveRecord)
require 'client_side_validations/action_view' if defined?(::ActionView)
if defined?(::Rails)
require 'client_side_validations/generators'
require 'client_side_validations/middleware'
require 'client_side_validations/engine'
end
client_side_validations-3.2.6/lib/client_side_validations/ 0000775 0000000 0000000 00000000000 12202276743 0024033 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/lib/client_side_validations/action_view.rb 0000664 0000000 0000000 00000001101 12202276743 0026660 0 ustar 00root root 0000000 0000000 module ClientSideValidations::ActionView
module Helpers
end
end
require 'client_side_validations/core_ext'
require 'client_side_validations/action_view/form_helper'
require 'client_side_validations/action_view/form_tag_helper'
require 'client_side_validations/action_view/form_builder'
ActionView::Base.send(:include, ClientSideValidations::ActionView::Helpers::FormHelper)
ActionView::Base.send(:include, ClientSideValidations::ActionView::Helpers::FormTagHelper)
ActionView::Helpers::FormBuilder.send(:include, ClientSideValidations::ActionView::Helpers::FormBuilder)
client_side_validations-3.2.6/lib/client_side_validations/action_view/ 0000775 0000000 0000000 00000000000 12202276743 0026342 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/lib/client_side_validations/action_view/form_builder.rb 0000664 0000000 0000000 00000012276 12202276743 0031350 0 ustar 00root root 0000000 0000000 module ClientSideValidations::ActionView::Helpers
module FormBuilder
def self.included(base)
(base.field_helpers.map(&:to_s) - %w(apply_form_for_options! label check_box radio_button fields_for hidden_field)).each do |selector|
base.class_eval <<-RUBY_EVAL
def #{selector}_with_client_side_validations(method, options = {})
build_validation_options(method, options)
options.delete(:validate)
#{selector}_without_client_side_validations(method, options)
end
RUBY_EVAL
base.class_eval { alias_method_chain selector, :client_side_validations }
end
base.class_eval do
alias_method_chain :initialize, :client_side_validations
alias_method_chain :fields_for, :client_side_validations
alias_method_chain :check_box, :client_side_validations
alias_method_chain :radio_button, :client_side_validations
alias_method_chain :select, :client_side_validations
alias_method_chain :collection_select, :client_side_validations
alias_method_chain :grouped_collection_select, :client_side_validations
alias_method_chain :time_zone_select, :client_side_validations
def client_side_form_settings(options, form_helper)
{
:type => self.class.to_s,
:input_tag => form_helper.class.field_error_proc.call(%{#{html_tag}#{instance.error_message.first} }.html_safe
# else
# %{#{html_tag}
}.html_safe
# end
# end
client_side_validations-3.2.6/test/ 0000775 0000000 0000000 00000000000 12202276743 0017365 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/test/action_view/ 0000775 0000000 0000000 00000000000 12202276743 0021674 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/test/action_view/cases/ 0000775 0000000 0000000 00000000000 12202276743 0022772 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/test/action_view/cases/helper.rb 0000664 0000000 0000000 00000012472 12202276743 0024604 0 ustar 00root root 0000000 0000000 require 'base_helper'
require 'action_view'
require 'action_view/template'
require 'action_view/models'
require 'client_side_validations/action_view'
module ActionController
class Base
include ActionDispatch::Routing::RouteSet.new.url_helpers
end
end
module ActionViewTestSetup
include ::ClientSideValidations::ActionView::Helpers::FormHelper
include ::ClientSideValidations::ActionView::Helpers::FormTagHelper
def form_for(*)
@output_buffer = super
end
Routes = ActionDispatch::Routing::RouteSet.new
Routes.draw do
resources :posts do
resources :comments
end
root :to => 'main#index'
end
def url_for(object)
@url_for_options = object
if object.is_a?(Hash) && object[:use_route].blank? && object[:controller].blank?
object.merge!(:controller => "main", :action => "index")
end
super
end
def _routes
Routes
end
# Rails 3.2.0 dropped size from the form elements
def legacy_size
if Rails.version < '3.2.0'
'size="30" '
end
end
def hidden_input_for_select(name)
if Rails.version >= '3.2.0'
%{}
txt << %{
}
end
def form_text(action = "http://www.example.com", id = nil, html_class = nil, remote = nil, validators = nil, file = nil)
txt = %{"
if options.is_a?(Hash) && options[:validators]
build_script_tag(html, id, options[:validators])
else
html
end
end
def build_script_tag(html, id, validators)
number_format = {:separator => '.', :delimiter => ','}
patterns = {:numericality=>"/^(-|\\+)?(?:\\d+|\\d{1,3}(?:\\#{number_format[:delimiter]}\\d{3})+)(?:\\#{number_format[:separator]}\\d*)?$/"}
(html || '') + %Q{}
end
protected
def comments_path(post)
"/posts/#{post.id}/comments"
end
alias_method :post_comments_path, :comments_path
def comment_path(post, comment)
"/posts/#{post.id}/comments/#{comment.id}"
end
alias_method :post_comment_path, :comment_path
def admin_comments_path(post)
"/admin/posts/#{post.id}/comments"
end
alias_method :admin_post_comments_path, :admin_comments_path
def admin_comment_path(post, comment)
"/admin/posts/#{post.id}/comments/#{comment.id}"
end
alias_method :admin_post_comment_path, :admin_comment_path
def posts_path(options={})
"/posts"
end
def post_path(post, options = {})
if options[:format]
"/posts/#{post.id}.#{options[:format]}"
else
"/posts/#{post.id}"
end
end
def protect_against_forgery?
false
end
end
client_side_validations-3.2.6/test/action_view/cases/test_helpers.rb 0000664 0000000 0000000 00000053350 12202276743 0026026 0 ustar 00root root 0000000 0000000 require 'action_view/cases/helper'
class ClientSideValidations::ActionViewHelpersTest < ActionView::TestCase
include ActionViewTestSetup
cattr_accessor :field_error_proc
@@field_error_proc = Proc.new { |html_tag, instance| html_tag }
def client_side_form_settings_helper
{
:type => "ActionView::Helpers::FormBuilder",
:input_tag => %{Dummy Content }
end
assert_equal expected, output_buffer
end
def test_as_form_option_with_existing_record_rails
@post.stubs(:persisted?).returns(true)
@post.stubs(:id).returns(123)
test_buffer = form_for(@post, :as => :article, :validate => true) do |f|
concat content_tag(:span, 'Dummy Content')
end
expected = whole_form('/posts/123', 'edit_article', 'edit_article', :method => 'put', :validators => {}) do
%{Dummy Content }
end
assert_equal expected, output_buffer
end
def test_namespace_form_option_with_new_record
test_buffer = form_for(Post.new, :namespace => :blog, :validate => true) do |f|
concat content_tag(:span, 'Dummy Content')
end
expected = whole_form('/posts', 'blog_new_post', 'new_post', :validators => {}) do
%{Dummy Content }
end
assert_equal expected, output_buffer
end
def test_namespace_form_option_with_existing_record
@post.stubs(:persisted?).returns(true)
@post.stubs(:id).returns(123)
test_buffer = form_for(@post, :namespace => :blog, :validate => true) do |f|
concat content_tag(:span, 'Dummy Content')
end
expected = whole_form('/posts/123', 'blog_edit_post_123', 'edit_post', :method => 'put', :validators => {}) do
%{Dummy Content }
end
assert_equal expected, output_buffer
end
elsif Rails.version >= '3.1.0' && Rails.version < '3.2.0'
def test_text_area
form_for(@post, :validate => true) do |f|
concat f.text_area(:cost)
end
validators = {'post[cost]' => {:presence => [{:message => "can't be blank"}]}}
expected = whole_form('/posts', 'new_post', 'new_post', :method => 'post', :validators => validators) do
%{}
end
assert_equal expected, output_buffer
end
def test_as_form_option_with_new_record_rails
test_buffer = form_for(Post.new, :as => :article, :validate => true) do |f|
concat content_tag(:span, "Dummy Content")
end
expected = whole_form("/posts", "article_new", "article_new", :validators => {}) do
%{Dummy Content }
end
assert_equal expected, output_buffer
end
def test_as_form_option_with_existing_record_rails
test_buffer = form_for(@post, :as => :article, :validate => true) do |f|
concat content_tag(:span, "Dummy Content")
end
expected = whole_form('/posts', "article_edit", "article_edit", :method => 'post', :validators => {}) do
%{Dummy Content }
end
assert_equal expected, output_buffer
end
end
def test_string_as_record
assert_raise ClientSideValidations::ActionView::Helpers::FormHelper::Error do
form_for('post', :validate => true) do |f|
concat f.text_field(:cost)
end
end
end
def test_symbol_as_record
assert_raise ClientSideValidations::ActionView::Helpers::FormHelper::Error do
form_for(:post, :validate => true) do |f|
concat f.text_field(:cost)
end
end
end
def test_text_field_with_custom_name
form_for(@post, :validate => true) do |f|
concat f.text_field(:cost, :name => :postcost)
end
validators = {'postcost' => {:presence => [{:message => "can't be blank"}]}}
expected = whole_form('/posts', 'new_post', 'new_post', :validators => validators) do
%{
',
label_tag: '
',
validators: {"user[name]":{"presence":[{"message": "must be present"}]}}
}
$('#qunit-fixture')
.append($('Name '));
ClientSideValidations.callbacks.element.after = function(element, message) {
$('#result').text('Element Validate After ' + element.attr('id'));
}
$('form#new_user').validate();
},
teardown: function() {
ClientSideValidations.callbacks.element.after = function(element, eventData) {}
}
});
test('runs callback when form element validate', function() {
var input = $('input');
equal($('#result').text(), '');
input.trigger('focusout');
equal($('#result').text(), 'Element Validate After user_name');
});
test('runs callback when form validates', function() {
var form = $('form'), input = form.find('input');
equal($('#result').text(), '');
form.submit();
equal($('#result').text(), 'Element Validate After user_name');
});
client_side_validations-3.2.6/test/javascript/public/test/callbacks/elementBefore.js 0000664 0000000 0000000 00000003153 12202276743 0031023 0 ustar 00root root 0000000 0000000 module('Element Validate Before Callback', {
setup: function() {
ClientSideValidations.forms['new_user'] = {
type: 'ActionView::Helpers::FormBuilder',
input_tag: '
',
label_tag: '
',
validators: {"user[name]":{"{presence":[{"message": "must be present"}]}}
}
$('#qunit-fixture')
.append($('Name '));
ClientSideValidations.callbacks.element.before = function(element) {
$('#result').text('Element Validate Before ' + element.attr('id'));
}
$('form#new_user').validate();
},
teardown: function() {
ClientSideValidations.callbacks.element.before = function(element, eventData) {}
}
});
test('runs callback when form element validate', function() {
var input = $('input');
equal($('#result').text(), '');
input.trigger('focusout');
equal($('#result').text(), 'Element Validate Before user_name');
});
test('runs callback when form validates', function() {
var form = $('form'), input = form.find('input');
equal($('#result').text(), '');
form.submit();
equal($('#result').text(), 'Element Validate Before user_name');
});
client_side_validations-3.2.6/test/javascript/public/test/callbacks/elementFail.js 0000664 0000000 0000000 00000003750 12202276743 0030477 0 ustar 00root root 0000000 0000000 module('Element Validate Fail Callback', {
setup: function() {
ClientSideValidations.forms['new_user'] = {
type: 'ActionView::Helpers::FormBuilder',
input_tag: '
',
label_tag: '
',
validators: {"user[name]":{"presence":[{"message": "must be present"}]}}
}
$('#qunit-fixture')
.append($('Name '));
ClientSideValidations.callbacks.element.fail = function(element, message) {
$('#result').text('Element Validate Fail ' + element.attr('id') + ' ' + message);
}
$('form#new_user').validate();
},
teardown: function() {
ClientSideValidations.callbacks.element.fail = function(element, message, callback) { callback(); }
}
});
test('runs callback when form element validate', function() {
var input = $('input');
equal($('#result').text(), '');
input.val('test')
input.trigger('change');
input.trigger('focusout');
equal($('#result').text(), '');
input.val('')
input.trigger('change');
input.trigger('focusout');
equal($('#result').text(), 'Element Validate Fail user_name must be present');
});
test('runs callback when form validates', function() {
var form = $('form'), input = form.find('input');
equal($('#result').text(), '');
input.val('test')
input.trigger('change');
form.trigger('submit');
equal($('#result').text(), '');
input.val('')
input.trigger('change');
form.trigger('submit');
equal($('#result').text(), 'Element Validate Fail user_name must be present');
});
client_side_validations-3.2.6/test/javascript/public/test/callbacks/elementPass.js 0000664 0000000 0000000 00000003645 12202276743 0030535 0 ustar 00root root 0000000 0000000 module('Element Validate Pass Callback', {
setup: function() {
ClientSideValidations.forms['new_user'] = {
type: 'ActionView::Helpers::FormBuilder',
input_tag: '
',
label_tag: '
',
validators: {"user[name]":{"presence":[{"message": "must be present"}]}}
}
$('#qunit-fixture')
.append($('Name '));
ClientSideValidations.callbacks.element.pass = function(element) {
$('#result').text('Element Validate Pass ' + element.attr('id'));
}
$('form#new_user').validate();
},
teardown: function() {
ClientSideValidations.callbacks.element.pass = function(element, callback) { callback() }
}
});
test('runs callback when form element validate', function() {
var input = $('input');
equal($('#result').text(), '');
input.val('')
input.trigger('change');
input.trigger('focusout');
equal($('#result').text(), '');
input.val('test')
input.trigger('change');
input.trigger('focusout');
equal($('#result').text(), 'Element Validate Pass user_name');
});
test('runs callback when form validates', function() {
var form = $('form'), input = form.find('input');
equal($('#result').text(), '');
input.val('')
input.trigger('change');
form.trigger('submit');
equal($('#result').text(), '');
input.val('test')
input.trigger('change');
form.trigger('submit');
equal($('#result').text(), 'Element Validate Pass user_name');
});
client_side_validations-3.2.6/test/javascript/public/test/callbacks/formAfter.js 0000664 0000000 0000000 00000002540 12202276743 0030173 0 ustar 00root root 0000000 0000000 module('Form Validate After Callback', {
setup: function() {
ClientSideValidations.forms['new_user'] = {
type: 'ActionView::Helpers::FormBuilder',
input_tag: '
',
label_tag: '
',
validators: {"user[name]":{"presence":[{"message": "must be present"}]}}
}
$('#qunit-fixture')
.append($('Name '));
ClientSideValidations.callbacks.form.after = function(form, message) {
$('#result').text('Form Validate After ' + form.attr('id'));
}
$('form#new_user').validate();
},
teardown: function() {
ClientSideValidations.callbacks.form.after = function(form, eventData) {}
}
});
test('runs callback', function() {
var form = $('form'), input = form.find('input');
equal($('#result').text(), '');
form.submit();
equal($('#result').text(), 'Form Validate After new_user');
});
client_side_validations-3.2.6/test/javascript/public/test/callbacks/formBefore.js 0000664 0000000 0000000 00000002545 12202276743 0030341 0 ustar 00root root 0000000 0000000 module('Form Validate Before Callback', {
setup: function() {
ClientSideValidations.forms['new_user'] = {
type: 'ActionView::Helpers::FormBuilder',
input_tag: '
',
label_tag: '
',
validators: {"user[name]":{"presence":[{"message": "must be present"}]}}
}
$('#qunit-fixture')
.append($('Name '));
ClientSideValidations.callbacks.form.before = function(form, message) {
$('#result').text('Form Validate Before ' + form.attr('id'));
}
$('form#new_user').validate();
},
teardown: function() {
ClientSideValidations.callbacks.form.before = function(form, eventData) {}
}
});
test('runs callback', function() {
var form = $('form'), input = form.find('input');
equal($('#result').text(), '');
form.submit();
equal($('#result').text(), 'Form Validate Before new_user');
});
client_side_validations-3.2.6/test/javascript/public/test/callbacks/formFail.js 0000664 0000000 0000000 00000002730 12202276743 0030006 0 ustar 00root root 0000000 0000000 module('Form Validate Fail Callback', {
setup: function() {
ClientSideValidations.forms['new_user'] = {
type: 'ActionView::Helpers::FormBuilder',
input_tag: '
',
label_tag: '
',
validators: {"user[name]":{"presence":[{"message": "must be present"}]}}
}
$('#qunit-fixture')
.append($('Name '));
ClientSideValidations.callbacks.form.fail = function(form, message) {
$('#result').text('Form Validate Fail ' + form.attr('id'));
}
$('form#new_user').validate();
},
teardown: function() {
ClientSideValidations.callbacks.form.fail = function(form, eventData) {}
}
});
test('runs callback', function() {
var form = $('form'), input = form.find('input');
equal($('#result').text(), '');
form.submit();
equal($('#result').text(), 'Form Validate Fail new_user');
$('#result').text('');
input.val('test');
input.trigger('change');
form.submit();
equal($('#result').text(), '');
});
client_side_validations-3.2.6/test/javascript/public/test/callbacks/formPass.js 0000664 0000000 0000000 00000002677 12202276743 0030053 0 ustar 00root root 0000000 0000000 module('Form Validate Pass Callback', {
setup: function() {
ClientSideValidations.forms['new_user'] = {
type: 'ActionView::Helpers::FormBuilder',
input_tag: '
',
label_tag: '
',
validators: {"user[name]":{"presence":[{"message": "must be present"}]}}
}
$('#qunit-fixture')
.append($('Name '));
ClientSideValidations.callbacks.form.pass = function(form, message) {
$('#result').text('Form Validate Pass ' + form.attr('id'));
}
$('form#new_user').validate();
},
teardown: function() {
ClientSideValidations.callbacks.form.pass = function(form, eventData) {}
}
});
test('runs callback', function() {
var form = $('form'), input = form.find('input');
equal($('#result').text(), '');
form.submit();
equal($('#result').text(), '');
input.val('test');
input.trigger('change');
form.submit();
equal($('#result').text(), 'Form Validate Pass new_user');
});
client_side_validations-3.2.6/test/javascript/public/test/disableValidators.js 0000664 0000000 0000000 00000002051 12202276743 0027760 0 ustar 00root root 0000000 0000000 module('Disabling validators', {
setup: function() {
ClientSideValidations.validators = {
local: {
test: function(){},
test2: function(){}
},
remote: {
test: function(){},
test3: function(){}
}
}
}
});
test('when some validators are disabled', function() {
var keys = []; for(var k in ClientSideValidations.validators.remote) keys.push(k);
deepEqual(keys, ['test', 'test3']);
ClientSideValidations.disabled_validators = ['test'];
ClientSideValidations.disableValidators();
keys = []; for(var k in ClientSideValidations.validators.remote) keys.push(k);
deepEqual(keys, ['test3']);
});
test('when none of validators are disabled', function() {
var keys = []; for(var k in ClientSideValidations.validators.remote) keys.push(k);
deepEqual(keys, ['test', 'test3']);
ClientSideValidations.disabled_validators = [];
ClientSideValidations.disableValidators();
keys = []; for(var k in ClientSideValidations.validators.remote) keys.push(k);
deepEqual(keys, ['test', 'test3']);
});
client_side_validations-3.2.6/test/javascript/public/test/form_builders/ 0000775 0000000 0000000 00000000000 12202276743 0026624 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/test/javascript/public/test/form_builders/validateForm.js 0000664 0000000 0000000 00000012243 12202276743 0031601 0 ustar 00root root 0000000 0000000 module('Validate Form', {
setup: function() {
ClientSideValidations.forms['new_user'] = {
type: 'ActionView::Helpers::FormBuilder',
input_tag: '
',
label_tag: '
',
validators: {'user[name]':{"presence":[{"message": "must be present"}]}}
}
$('#qunit-fixture')
.append($('', {
action: '/users',
'data-validate': true,
method: 'post',
id: 'new_user'
}))
.find('form')
.append($('Name '));
$('form#new_user').validate();
}
});
asyncTest('Validate form with invalid form', 4, function() {
var form = $('form#new_user'), input = form.find('input#user_name');
var label = $('label[for="user_name"]');
form.trigger('submit');
setTimeout(function() {
start();
ok(input.parent().hasClass('field_with_errors'));
ok(label.parent().hasClass('field_with_errors'));
ok(input.parent().find('label:contains("must be present")')[0]);
ok(!$('iframe').contents().find('p:contains("Form submitted")')[0]);
}, 60);
});
asyncTest('Validate form with valid form', 1, function() {
var form = $('form#new_user'), input = form.find('input#user_name');
input.val('Test');
form.trigger('submit');
setTimeout(function() {
start();
ok($('iframe').contents().find('p:contains("Form submitted")')[0]);
}, 60);
});
asyncTest('Validate form with an input changed to false', 1, function() {
var form = $('form#new_user'), input = form.find('input#user_name');
input.val('Test');
input.attr('changed', false);
input.attr('data-valid', true);
form.trigger('submit');
setTimeout(function() {
start();
ok($('iframe').contents().find('p:contains("Form submitted")')[0]);
}, 60);
});
asyncTest('Ensure ajax:beforeSend is not from a bubbled event', 1, function() {
var form = $('form#new_user'), input = form.find('input#user_name');
form
.append('
',
label_tag: '
',
validators: {
'user[name]':{"presence":[{"message": "must be present"}], "format":[{"message":"is invalid","with":/\d+/}]},
'user[password]':{"confirmation":[{"message": "must match confirmation"}]},
'user[agree]':{"acceptance": [{"message": "must be accepted"}]},
'user[email]':{"uniqueness":[{"message": "must be unique"}],"presence":[{"message": "must be present"}]},
'user[info_attributes][eye_color]':{"presence":[{"message": "must be present"}]},
'user[phone_numbers_attributes][][number]':{"presence":[{"message": "must be present"}]},
'user[phone_numbers_attributes][country_code][][code]':{"presence":[{"message": "must be present"}]},
'user[phone_numbers_attributes][deeply][nested][][attribute]':{"presence":[{"message": "must be present"}]}
}
}
$('#qunit-fixture')
.append($('', {
action: '/users',
'data-validate': true,
method: 'post',
id: 'new_user'
}))
.find('form')
.append($('Name '))
.append($('Password '))
.append($('Password Confirmation '))
.append($('Agree '))
.append($('Phone Number '))
.append($('Phone Number '))
.append($('Phone Number '))
.append($('Country code '))
.append($('Deeply nested attribute '))
.append($('Deeply nested attribute '))
.append($('Eye Color '))
.append($('Password '))
.append($('Password Confirmation '))
.append($('
',
label_tag: '
',
validators: { }
}
$('form#new_user_2').validate();
var form = $('form#new_user_2'), input = form.find('input#user_2_password_confirmation');
input.val('123');
input.trigger('focusout');
ok(!input.parent().hasClass('field_with_errors'));
});
test("Don't validate disabled inputs", function() {
$('#qunit-fixture')
.append($('', {
action: '/users',
'data-validate': true,
method: 'post',
id: 'new_user_2'
}))
.find('form')
.append($('name '))
.append($('
',
label_tag: '
',
validators: { 'user_2[name]':{"presence":{"message": "must be present"}}}
}
$('form#new_user_2').validate();
var form = $('form#new_user_2'), input = form.find('input#user_2_name');
input.val('');
input.trigger('focusout');
ok(!input.parent().hasClass('field_with_errors'));
});
test("Don't validate dynamically disabled inputs", function() {
$('#qunit-fixture')
.append($('', {
action: '/users',
'data-validate': true,
method: 'post',
id: 'new_user_2'
}))
.find('form')
.append($('name '))
.append($('
',
label_tag: '
',
validators: { 'user_2[name]':{"presence":{"message": "must be present"}}}
}
$('form#new_user_2').validate();
var form = $('form#new_user_2'), input = form.find('input#user_2_name');
input.attr('disabled', 'disabled');
input.val('');
input.trigger('focusout');
ok(!input.parent().hasClass('field_with_errors'));
});
test('ensure label is scoped to form', function() {
var form = $('form#new_user'), input = form.find('input#user_name');
var label = $('label[for="user_name"]');
$('#qunit-fixture')
.prepend($('', { id: 'other_form', 'data-validate': true })
.append($('Name ')));
var otherLabel = $('form#other_form').find('label')
input.trigger('focusout');
ok(!otherLabel.parent().hasClass('field_with_errors'));
});
test("Return validation result", function() {
var input = $('#user_name');
ok(!input.isValid(ClientSideValidations.forms['new_user'].validators));
input.val('123').data('changed', true);
ok(input.isValid(ClientSideValidations.forms['new_user'].validators));
});
test('Validate when focusouting and field has disabled validations', function() {
var form = $('form#new_user'), input = form.find('input#user_name');
var label = $('label[for="user_name"]');
input.disableClientSideValidations();
input.trigger('focusout');
ok(!input.parent().hasClass('field_with_errors'));
ok(!label.parent().hasClass('field_with_errors'));
input.enableClientSideValidations();
input.trigger('focusout');
ok(input.parent().hasClass('field_with_errors'));
ok(label.parent().hasClass('field_with_errors'));
});
client_side_validations-3.2.6/test/javascript/public/test/validators/ 0000775 0000000 0000000 00000000000 12202276743 0026140 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/test/javascript/public/test/validators/acceptance.js 0000664 0000000 0000000 00000003150 12202276743 0030563 0 ustar 00root root 0000000 0000000 module('Acceptance options');
test('when checkbox and checked', function() {
var element = $('
',
validators: {'user[email]':{"uniqueness":[{"message": "must be unique", "scope":{'name':"pass"}}]},"presence":[{"message": "must be present"}]}
}
$('#qunit-fixture')
.append($('', {
action: '/users',
'data-validate': true,
method: 'post',
id: 'new_user'
}))
.find('form')
.append($('
',
label_tag: '
',
validators: { 'user[email]':{"uniqueness":[{"message": "must be unique"}]}}
}
$('form#new_user_2').validate();
var user_0_email = $('#user_0_email'),
user_1_email = $('#user_1_email'),
options = { 'message': "must be unique" };
user_0_email.val('not-locally-unique');
user_1_email.val('not-locally-unique');
equal(ClientSideValidations.validators.remote.uniqueness(user_1_email, options), undefined);
equal(ClientSideValidations.validators.local.uniqueness(user_1_email, options), "must be unique");
});
client_side_validations-3.2.6/test/javascript/public/vendor/ 0000775 0000000 0000000 00000000000 12202276743 0024306 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/test/javascript/public/vendor/jquery.metadata.js 0000664 0000000 0000000 00000007710 12202276743 0027747 0 ustar 00root root 0000000 0000000 /*
* Metadata - jQuery plugin for parsing metadata from elements
*
* Copyright (c) 2006 John Resig, Yehuda Katz, J�örn Zaefferer, Paul McLanahan
*
* Dual licensed under the MIT and GPL licenses:
* http://www.opensource.org/licenses/mit-license.php
* http://www.gnu.org/licenses/gpl.html
*
* Revision: $Id: jquery.metadata.js 4187 2007-12-16 17:15:27Z joern.zaefferer $
*
*/
/**
* Sets the type of metadata to use. Metadata is encoded in JSON, and each property
* in the JSON will become a property of the element itself.
*
* There are three supported types of metadata storage:
*
* attr: Inside an attribute. The name parameter indicates *which* attribute.
*
* class: Inside the class attribute, wrapped in curly braces: { }
*
* elem: Inside a child element (e.g. a script tag). The
* name parameter indicates *which* element.
*
* The metadata for an element is loaded the first time the element is accessed via jQuery.
*
* As a result, you can define the metadata type, use $(expr) to load the metadata into the elements
* matched by expr, then redefine the metadata type and run another $(expr) for other elements.
*
* @name $.metadata.setType
*
* @example This is a p
* @before $.metadata.setType("class")
* @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
* @desc Reads metadata from the class attribute
*
* @example This is a p
* @before $.metadata.setType("attr", "data")
* @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
* @desc Reads metadata from a "data" attribute
*
* @example This is a p
* @before $.metadata.setType("elem", "script")
* @after $("#one").metadata().item_id == 1; $("#one").metadata().item_label == "Label"
* @desc Reads metadata from a nested script element
*
* @param String type The encoding type
* @param String name The name of the attribute to be used to get metadata (optional)
* @cat Plugins/Metadata
* @descr Sets the type of encoding to be used when loading metadata for the first time
* @type undefined
* @see metadata()
*/
(function($) {
$.extend({
metadata : {
defaults : {
type: 'class',
name: 'metadata',
cre: /({.*})/,
single: 'metadata'
},
setType: function( type, name ){
this.defaults.type = type;
this.defaults.name = name;
},
get: function( elem, opts ){
var settings = $.extend({},this.defaults,opts);
// check for empty string in single property
if ( !settings.single.length ) settings.single = 'metadata';
var data = $.data(elem, settings.single);
// returned cached data if it already exists
if ( data ) return data;
data = "{}";
if ( settings.type == "class" ) {
var m = settings.cre.exec( elem.className );
if ( m )
data = m[1];
} else if ( settings.type == "elem" ) {
if( !elem.getElementsByTagName )
return undefined;
var e = elem.getElementsByTagName(settings.name);
if ( e.length )
data = $.trim(e[0].innerHTML);
} else if ( elem.getAttribute != undefined ) {
var attr = elem.getAttribute( settings.name );
if ( attr )
data = attr;
}
if ( data.indexOf( '{' ) <0 )
data = "{" + data + "}";
data = eval("(" + data + ")");
$.data( elem, settings.single, data );
return data;
}
}
});
/**
* Returns the metadata object for the first member of the jQuery object.
*
* @name metadata
* @descr Returns element's metadata object
* @param Object opts An object contianing settings to override the defaults
* @type jQuery
* @cat Plugins/Metadata
*/
$.fn.metadata = function( opts ){
return $.metadata.get( this[0], opts );
};
})(jQuery);
client_side_validations-3.2.6/test/javascript/public/vendor/qunit.css 0000664 0000000 0000000 00000007641 12202276743 0026170 0 ustar 00root root 0000000 0000000 /** Font Family and Sizes */
#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
}
#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
#qunit-tests { font-size: smaller; }
/** Resets */
#qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult {
margin: 0;
padding: 0;
}
/** Header */
#qunit-header {
padding: 0.5em 0 0.5em 1em;
color: #8699a4;
background-color: #0d3349;
font-size: 1.5em;
line-height: 1em;
font-weight: normal;
border-radius: 15px 15px 0 0;
-moz-border-radius: 15px 15px 0 0;
-webkit-border-top-right-radius: 15px;
-webkit-border-top-left-radius: 15px;
}
#qunit-header a {
text-decoration: none;
color: #c2ccd1;
}
#qunit-header a:hover,
#qunit-header a:focus {
color: #fff;
}
#qunit-banner {
height: 5px;
}
#qunit-testrunner-toolbar {
padding: 0em 0 0.5em 2em;
}
#qunit-userAgent {
padding: 0.5em 0 0.5em 2.5em;
background-color: #2b81af;
color: #fff;
text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
}
/** Tests: Pass/Fail */
#qunit-tests {
list-style-position: inside;
}
#qunit-tests li {
padding: 0.4em 0.5em 0.4em 2.5em;
border-bottom: 1px solid #fff;
list-style-position: inside;
}
#qunit-tests li strong {
cursor: pointer;
}
#qunit-tests ol {
margin-top: 0.5em;
padding: 0.5em;
background-color: #fff;
border-radius: 15px;
-moz-border-radius: 15px;
-webkit-border-radius: 15px;
box-shadow: inset 0px 2px 13px #999;
-moz-box-shadow: inset 0px 2px 13px #999;
-webkit-box-shadow: inset 0px 2px 13px #999;
}
#qunit-tests table {
border-collapse: collapse;
margin-top: .2em;
}
#qunit-tests th {
text-align: right;
vertical-align: top;
padding: 0 .5em 0 0;
}
#qunit-tests td {
vertical-align: top;
}
#qunit-tests pre {
margin: 0;
white-space: pre-wrap;
word-wrap: break-word;
}
#qunit-tests del {
background-color: #e0f2be;
color: #374e0c;
text-decoration: none;
}
#qunit-tests ins {
background-color: #ffcaca;
color: #500;
text-decoration: none;
}
/*** Test Counts */
#qunit-tests b.counts { color: black; }
#qunit-tests b.passed { color: #5E740B; }
#qunit-tests b.failed { color: #710909; }
#qunit-tests li li {
margin: 0.5em;
padding: 0.4em 0.5em 0.4em 0.5em;
background-color: #fff;
border-bottom: none;
list-style-position: inside;
}
/*** Passing Styles */
#qunit-tests li li.pass {
color: #5E740B;
background-color: #fff;
border-left: 26px solid #C6E746;
}
#qunit-tests .pass { color: #528CE0; background-color: #D2E0E6; }
#qunit-tests .pass .test-name { color: #366097; }
#qunit-tests .pass .test-actual,
#qunit-tests .pass .test-expected { color: #999999; }
#qunit-banner.qunit-pass { background-color: #C6E746; }
/*** Failing Styles */
#qunit-tests li li.fail {
color: #710909;
background-color: #fff;
border-left: 26px solid #EE5757;
}
#qunit-tests .fail { color: #000000; background-color: #EE5757; }
#qunit-tests .fail .test-name,
#qunit-tests .fail .module-name { color: #000000; }
#qunit-tests .fail .test-actual { color: #EE5757; }
#qunit-tests .fail .test-expected { color: green; }
#qunit-banner.qunit-fail,
#qunit-testrunner-toolbar { background-color: #EE5757; }
/** Footer */
#qunit-testresult {
padding: 0.5em 0.5em 0.5em 2.5em;
color: #2b81af;
background-color: #D2E0E6;
border-radius: 0 0 15px 15px;
-moz-border-radius: 0 0 15px 15px;
-webkit-border-bottom-right-radius: 15px;
-webkit-border-bottom-left-radius: 15px;
}
/** Fixture */
#qunit-fixture {
position: absolute;
top: -10000px;
left: -10000px;
}
client_side_validations-3.2.6/test/javascript/public/vendor/qunit.js 0000664 0000000 0000000 00000113405 12202276743 0026010 0 ustar 00root root 0000000 0000000 /*
* QUnit - A JavaScript Unit Testing Framework
*
* http://docs.jquery.com/QUnit
*
* Copyright (c) 2011 John Resig, Jörn Zaefferer
* Dual licensed under the MIT (MIT-LICENSE.txt)
* or GPL (GPL-LICENSE.txt) licenses.
*/
(function(window) {
var defined = {
setTimeout: typeof window.setTimeout !== "undefined",
sessionStorage: (function() {
try {
return !!sessionStorage.getItem;
} catch(e){
return false;
}
})()
}
var testId = 0;
var Test = function(name, testName, expected, testEnvironmentArg, async, callback) {
this.name = name;
this.testName = testName;
this.expected = expected;
this.testEnvironmentArg = testEnvironmentArg;
this.async = async;
this.callback = callback;
this.assertions = [];
};
Test.prototype = {
init: function() {
var tests = id("qunit-tests");
if (tests) {
var b = document.createElement("strong");
b.innerHTML = "Running " + this.name;
var li = document.createElement("li");
li.appendChild( b );
li.id = this.id = "test-output" + testId++;
tests.appendChild( li );
}
},
setup: function() {
if (this.module != config.previousModule) {
if ( config.previousModule ) {
QUnit.moduleDone( config.previousModule, config.moduleStats.bad, config.moduleStats.all );
}
config.previousModule = this.module;
config.moduleStats = { all: 0, bad: 0 };
QUnit.moduleStart( this.module, this.moduleTestEnvironment );
}
config.current = this;
this.testEnvironment = extend({
setup: function() {},
teardown: function() {}
}, this.moduleTestEnvironment);
if (this.testEnvironmentArg) {
extend(this.testEnvironment, this.testEnvironmentArg);
}
QUnit.testStart( this.testName, this.testEnvironment );
// allow utility functions to access the current test environment
// TODO why??
QUnit.current_testEnvironment = this.testEnvironment;
try {
if ( !config.pollution ) {
saveGlobal();
}
this.testEnvironment.setup.call(this.testEnvironment);
} catch(e) {
// TODO use testName instead of name for no-markup message?
QUnit.ok( false, "Setup failed on " + this.name + ": " + e.message );
}
},
run: function() {
if ( this.async ) {
QUnit.stop();
}
try {
this.callback.call(this.testEnvironment);
} catch(e) {
// TODO use testName instead of name for no-markup message?
fail("Test " + this.name + " died, exception and test follows", e, this.callback);
QUnit.ok( false, "Died on test #" + (this.assertions.length + 1) + ": " + e.message + " - " + QUnit.jsDump.parse(e) );
// else next test will carry the responsibility
saveGlobal();
// Restart the tests if they're blocking
if ( config.blocking ) {
start();
}
}
},
teardown: function() {
try {
checkPollution();
this.testEnvironment.teardown.call(this.testEnvironment);
} catch(e) {
// TODO use testName instead of name for no-markup message?
QUnit.ok( false, "Teardown failed on " + this.name + ": " + e.message );
}
},
finish: function() {
if ( this.expected && this.expected != this.assertions.length ) {
QUnit.ok( false, "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run" );
}
var good = 0, bad = 0,
tests = id("qunit-tests");
config.stats.all += this.assertions.length;
config.moduleStats.all += this.assertions.length;
if ( tests ) {
var ol = document.createElement("ol");
for ( var i = 0; i < this.assertions.length; i++ ) {
var assertion = this.assertions[i];
var li = document.createElement("li");
li.className = assertion.result ? "pass" : "fail";
li.innerHTML = assertion.message || (assertion.result ? "okay" : "failed");
ol.appendChild( li );
if ( assertion.result ) {
good++;
} else {
bad++;
config.stats.bad++;
config.moduleStats.bad++;
}
}
// store result when possible
defined.sessionStorage && sessionStorage.setItem("qunit-" + this.testName, bad);
if (bad == 0) {
ol.style.display = "none";
}
var b = document.createElement("strong");
b.innerHTML = this.name + " (" + bad + " , " + good + " , " + this.assertions.length + ") ";
addEvent(b, "click", function() {
var next = b.nextSibling, display = next.style.display;
next.style.display = display === "none" ? "block" : "none";
});
addEvent(b, "dblclick", function(e) {
var target = e && e.target ? e.target : window.event.srcElement;
if ( target.nodeName.toLowerCase() == "span" || target.nodeName.toLowerCase() == "b" ) {
target = target.parentNode;
}
if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
window.location.search = "?" + encodeURIComponent(getText([target]).replace(/\(.+\)$/, "").replace(/(^\s*|\s*$)/g, ""));
}
});
var li = id(this.id);
li.className = bad ? "fail" : "pass";
li.style.display = resultDisplayStyle(!bad);
li.removeChild( li.firstChild );
li.appendChild( b );
li.appendChild( ol );
if ( bad ) {
var toolbar = id("qunit-testrunner-toolbar");
if ( toolbar ) {
toolbar.style.display = "block";
id("qunit-filter-pass").disabled = null;
}
}
} else {
for ( var i = 0; i < this.assertions.length; i++ ) {
if ( !this.assertions[i].result ) {
bad++;
config.stats.bad++;
config.moduleStats.bad++;
}
}
}
try {
QUnit.reset();
} catch(e) {
// TODO use testName instead of name for no-markup message?
fail("reset() failed, following Test " + this.name + ", exception and reset fn follows", e, QUnit.reset);
}
QUnit.testDone( this.testName, bad, this.assertions.length );
},
queue: function() {
var test = this;
synchronize(function() {
test.init();
});
function run() {
// each of these can by async
synchronize(function() {
test.setup();
});
synchronize(function() {
test.run();
});
synchronize(function() {
test.teardown();
});
synchronize(function() {
test.finish();
});
}
// defer when previous test run passed, if storage is available
var bad = defined.sessionStorage && +sessionStorage.getItem("qunit-" + this.testName);
if (bad) {
run();
} else {
synchronize(run);
};
}
}
var QUnit = {
// call on start of module test to prepend name to all tests
module: function(name, testEnvironment) {
config.currentModule = name;
config.currentModuleTestEnviroment = testEnvironment;
},
asyncTest: function(testName, expected, callback) {
if ( arguments.length === 2 ) {
callback = expected;
expected = 0;
}
QUnit.test(testName, expected, callback, true);
},
test: function(testName, expected, callback, async) {
var name = '' + testName + ' ', testEnvironmentArg;
if ( arguments.length === 2 ) {
callback = expected;
expected = null;
}
// is 2nd argument a testEnvironment?
if ( expected && typeof expected === 'object') {
testEnvironmentArg = expected;
expected = null;
}
if ( config.currentModule ) {
name = '' + config.currentModule + " : " + name;
}
if ( !validTest(config.currentModule + ": " + testName) ) {
return;
}
var test = new Test(name, testName, expected, testEnvironmentArg, async, callback);
test.module = config.currentModule;
test.moduleTestEnvironment = config.currentModuleTestEnviroment;
test.queue();
},
/**
* Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through.
*/
expect: function(asserts) {
config.current.expected = asserts;
},
/**
* Asserts true.
* @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
*/
ok: function(a, msg) {
a = !!a;
var details = {
result: a,
message: msg
};
msg = escapeHtml(msg);
QUnit.log(a, msg, details);
config.current.assertions.push({
result: a,
message: msg
});
},
/**
* Checks that the first two arguments are equal, with an optional message.
* Prints out both actual and expected values.
*
* Prefered to ok( actual == expected, message )
*
* @example equal( format("Received {0} bytes.", 2), "Received 2 bytes." );
*
* @param Object actual
* @param Object expected
* @param String message (optional)
*/
equal: function(actual, expected, message) {
QUnit.push(expected == actual, actual, expected, message);
},
notEqual: function(actual, expected, message) {
QUnit.push(expected != actual, actual, expected, message);
},
deepEqual: function(actual, expected, message) {
QUnit.push(QUnit.equiv(actual, expected), actual, expected, message);
},
notDeepEqual: function(actual, expected, message) {
QUnit.push(!QUnit.equiv(actual, expected), actual, expected, message);
},
strictEqual: function(actual, expected, message) {
QUnit.push(expected === actual, actual, expected, message);
},
notStrictEqual: function(actual, expected, message) {
QUnit.push(expected !== actual, actual, expected, message);
},
raises: function(block, expected, message) {
var actual, ok = false;
if (typeof expected === 'string') {
message = expected;
expected = null;
}
try {
block();
} catch (e) {
actual = e;
}
if (actual) {
// we don't want to validate thrown error
if (!expected) {
ok = true;
// expected is a regexp
} else if (QUnit.objectType(expected) === "regexp") {
ok = expected.test(actual);
// expected is a constructor
} else if (actual instanceof expected) {
ok = true;
// expected is a validation function which returns true is validation passed
} else if (expected.call({}, actual) === true) {
ok = true;
}
}
QUnit.ok(ok, message);
},
start: function() {
config.semaphore--;
if (config.semaphore > 0) {
// don't start until equal number of stop-calls
return;
}
if (config.semaphore < 0) {
// ignore if start is called more often then stop
config.semaphore = 0;
}
// A slight delay, to avoid any current callbacks
if ( defined.setTimeout ) {
window.setTimeout(function() {
if ( config.timeout ) {
clearTimeout(config.timeout);
}
config.blocking = false;
process();
}, 13);
} else {
config.blocking = false;
process();
}
},
stop: function(timeout) {
config.semaphore++;
config.blocking = true;
if ( timeout && defined.setTimeout ) {
clearTimeout(config.timeout);
config.timeout = window.setTimeout(function() {
QUnit.ok( false, "Test timed out" );
QUnit.start();
}, timeout);
}
}
};
// Backwards compatibility, deprecated
QUnit.equals = QUnit.equal;
QUnit.same = QUnit.deepEqual;
// Maintain internal state
var config = {
// The queue of tests to run
queue: [],
// block until document ready
blocking: true
};
// Load paramaters
(function() {
var location = window.location || { search: "", protocol: "file:" },
GETParams = location.search.slice(1).split('&');
for ( var i = 0; i < GETParams.length; i++ ) {
GETParams[i] = decodeURIComponent( GETParams[i] );
if ( GETParams[i] === "noglobals" ) {
GETParams.splice( i, 1 );
i--;
config.noglobals = true;
} else if ( GETParams[i].search('=') > -1 ) {
GETParams.splice( i, 1 );
i--;
}
}
// restrict modules/tests by get parameters
config.filters = GETParams;
// Figure out if we're running the tests from a server or not
QUnit.isLocal = !!(location.protocol === 'file:');
})();
// Expose the API as global variables, unless an 'exports'
// object exists, in that case we assume we're in CommonJS
if ( typeof exports === "undefined" || typeof require === "undefined" ) {
extend(window, QUnit);
window.QUnit = QUnit;
} else {
extend(exports, QUnit);
exports.QUnit = QUnit;
}
// define these after exposing globals to keep them in these QUnit namespace only
extend(QUnit, {
config: config,
// Initialize the configuration options
init: function() {
extend(config, {
stats: { all: 0, bad: 0 },
moduleStats: { all: 0, bad: 0 },
started: +new Date,
updateRate: 1000,
blocking: false,
autostart: true,
autorun: false,
filters: [],
queue: [],
semaphore: 0
});
var tests = id("qunit-tests"),
banner = id("qunit-banner"),
result = id("qunit-testresult");
if ( tests ) {
tests.innerHTML = "";
}
if ( banner ) {
banner.className = "";
}
if ( result ) {
result.parentNode.removeChild( result );
}
},
/**
* Resets the test setup. Useful for tests that modify the DOM.
*
* If jQuery is available, uses jQuery's html(), otherwise just innerHTML.
*/
reset: function() {
if ( window.jQuery ) {
jQuery( "#main, #qunit-fixture" ).html( config.fixture );
} else {
var main = id( 'main' ) || id( 'qunit-fixture' );
if ( main ) {
main.innerHTML = config.fixture;
}
}
},
/**
* Trigger an event on an element.
*
* @example triggerEvent( document.body, "click" );
*
* @param DOMElement elem
* @param String type
*/
triggerEvent: function( elem, type, event ) {
if ( document.createEvent ) {
event = document.createEvent("MouseEvents");
event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,
0, 0, 0, 0, 0, false, false, false, false, 0, null);
elem.dispatchEvent( event );
} else if ( elem.fireEvent ) {
elem.fireEvent("on"+type);
}
},
// Safe object type checking
is: function( type, obj ) {
return QUnit.objectType( obj ) == type;
},
objectType: function( obj ) {
if (typeof obj === "undefined") {
return "undefined";
// consider: typeof null === object
}
if (obj === null) {
return "null";
}
var type = Object.prototype.toString.call( obj )
.match(/^\[object\s(.*)\]$/)[1] || '';
switch (type) {
case 'Number':
if (isNaN(obj)) {
return "nan";
} else {
return "number";
}
case 'String':
case 'Boolean':
case 'Array':
case 'Date':
case 'RegExp':
case 'Function':
return type.toLowerCase();
}
if (typeof obj === "object") {
return "object";
}
return undefined;
},
push: function(result, actual, expected, message) {
var details = {
result: result,
message: message,
actual: actual,
expected: expected
};
message = escapeHtml(message) || (result ? "okay" : "failed");
message = '' + message + " ";
expected = escapeHtml(QUnit.jsDump.parse(expected));
actual = escapeHtml(QUnit.jsDump.parse(actual));
var output = message + 'Expected: ' + expected + ' Result: ' + actual + ' Diff: ' + QUnit.diff(expected, actual) +' Source: ' + source +'
";
QUnit.log(result, message, details);
config.current.assertions.push({
result: !!result,
message: output
});
},
// Logging callbacks
begin: function() {},
done: function(failures, total) {},
log: function(result, message) {},
testStart: function(name, testEnvironment) {},
testDone: function(name, failures, total) {},
moduleStart: function(name, testEnvironment) {},
moduleDone: function(name, failures, total) {}
});
if ( typeof document === "undefined" || document.readyState === "complete" ) {
config.autorun = true;
}
addEvent(window, "load", function() {
QUnit.begin();
// Initialize the config, saving the execution queue
var oldconfig = extend({}, config);
QUnit.init();
extend(config, oldconfig);
config.blocking = false;
var userAgent = id("qunit-userAgent");
if ( userAgent ) {
userAgent.innerHTML = navigator.userAgent;
}
var banner = id("qunit-header");
if ( banner ) {
var paramsIndex = location.href.lastIndexOf(location.search);
if ( paramsIndex > -1 ) {
var mainPageLocation = location.href.slice(0, paramsIndex);
if ( mainPageLocation == location.href ) {
banner.innerHTML = ' ' + banner.innerHTML + ' ';
} else {
var testName = decodeURIComponent(location.search.slice(1));
banner.innerHTML = '' + banner.innerHTML + ' › ' + testName + ' ';
}
}
}
var toolbar = id("qunit-testrunner-toolbar");
if ( toolbar ) {
toolbar.style.display = "none";
var filter = document.createElement("input");
filter.type = "checkbox";
filter.id = "qunit-filter-pass";
filter.disabled = true;
addEvent( filter, "click", function() {
var li = document.getElementsByTagName("li");
for ( var i = 0; i < li.length; i++ ) {
if ( li[i].className.indexOf("pass") > -1 ) {
li[i].style.display = filter.checked ? "none" : "";
}
}
});
toolbar.appendChild( filter );
var label = document.createElement("label");
label.setAttribute("for", "qunit-filter-pass");
label.innerHTML = "Hide passed tests";
toolbar.appendChild( label );
}
var main = id('main') || id('qunit-fixture');
if ( main ) {
config.fixture = main.innerHTML;
}
if (config.autostart) {
QUnit.start();
}
});
function done() {
config.autorun = true;
// Log the last module results
if ( config.currentModule ) {
QUnit.moduleDone( config.currentModule, config.moduleStats.bad, config.moduleStats.all );
}
var banner = id("qunit-banner"),
tests = id("qunit-tests"),
html = ['Tests completed in ',
+new Date - config.started, ' milliseconds.', config.stats.all - config.stats.bad, ' tests of ', config.stats.all, ' passed, ', config.stats.bad,' failed.'].join('');
if ( banner ) {
banner.className = (config.stats.bad ? "qunit-fail" : "qunit-pass");
}
if ( tests ) {
var result = id("qunit-testresult");
if ( !result ) {
result = document.createElement("p");
result.id = "qunit-testresult";
result.className = "result";
tests.parentNode.insertBefore( result, tests.nextSibling );
}
result.innerHTML = html;
}
QUnit.done( config.stats.bad, config.stats.all );
}
function validTest( name ) {
var i = config.filters.length,
run = false;
if ( !i ) {
return true;
}
while ( i-- ) {
var filter = config.filters[i],
not = filter.charAt(0) == '!';
if ( not ) {
filter = filter.slice(1);
}
if ( name.indexOf(filter) !== -1 ) {
return !not;
}
if ( not ) {
run = true;
}
}
return run;
}
// so far supports only Firefox, Chrome and Opera (buggy)
// could be extended in the future to use something like https://github.com/csnover/TraceKit
function sourceFromStacktrace() {
try {
throw new Error();
} catch ( e ) {
if (e.stacktrace) {
// Opera
return e.stacktrace.split("\n")[6];
} else if (e.stack) {
// Firefox, Chrome
return e.stack.split("\n")[4];
}
}
}
function resultDisplayStyle(passed) {
return passed && id("qunit-filter-pass") && id("qunit-filter-pass").checked ? 'none' : '';
}
function escapeHtml(s) {
if (!s) {
return "";
}
s = s + "";
return s.replace(/[\&"<>\\]/g, function(s) {
switch(s) {
case "&": return "&";
case "\\": return "\\\\";
case '"': return '\"';
case "<": return "<";
case ">": return ">";
default: return s;
}
});
}
function synchronize( callback ) {
config.queue.push( callback );
if ( config.autorun && !config.blocking ) {
process();
}
}
function process() {
var start = (new Date()).getTime();
while ( config.queue.length && !config.blocking ) {
if ( config.updateRate <= 0 || (((new Date()).getTime() - start) < config.updateRate) ) {
config.queue.shift()();
} else {
window.setTimeout( process, 13 );
break;
}
}
if (!config.blocking && !config.queue.length) {
done();
}
}
function saveGlobal() {
config.pollution = [];
if ( config.noglobals ) {
for ( var key in window ) {
config.pollution.push( key );
}
}
}
function checkPollution( name ) {
var old = config.pollution;
saveGlobal();
var newGlobals = diff( old, config.pollution );
if ( newGlobals.length > 0 ) {
ok( false, "Introduced global variable(s): " + newGlobals.join(", ") );
config.current.expected++;
}
var deletedGlobals = diff( config.pollution, old );
if ( deletedGlobals.length > 0 ) {
ok( false, "Deleted global variable(s): " + deletedGlobals.join(", ") );
config.current.expected++;
}
}
// returns a new Array with the elements that are in a but not in b
function diff( a, b ) {
var result = a.slice();
for ( var i = 0; i < result.length; i++ ) {
for ( var j = 0; j < b.length; j++ ) {
if ( result[i] === b[j] ) {
result.splice(i, 1);
i--;
break;
}
}
}
return result;
}
function fail(message, exception, callback) {
if ( typeof console !== "undefined" && console.error && console.warn ) {
console.error(message);
console.error(exception);
console.warn(callback.toString());
} else if ( window.opera && opera.postError ) {
opera.postError(message, exception, callback.toString);
}
}
function extend(a, b) {
for ( var prop in b ) {
a[prop] = b[prop];
}
return a;
}
function addEvent(elem, type, fn) {
if ( elem.addEventListener ) {
elem.addEventListener( type, fn, false );
} else if ( elem.attachEvent ) {
elem.attachEvent( "on" + type, fn );
} else {
fn();
}
}
function id(name) {
return !!(typeof document !== "undefined" && document && document.getElementById) &&
document.getElementById( name );
}
// Test for equality any JavaScript type.
// Discussions and reference: http://philrathe.com/articles/equiv
// Test suites: http://philrathe.com/tests/equiv
// Author: Philippe Rathé
QUnit.equiv = function () {
var innerEquiv; // the real equiv function
var callers = []; // stack to decide between skip/abort functions
var parents = []; // stack to avoiding loops from circular referencing
// Call the o related callback with the given arguments.
function bindCallbacks(o, callbacks, args) {
var prop = QUnit.objectType(o);
if (prop) {
if (QUnit.objectType(callbacks[prop]) === "function") {
return callbacks[prop].apply(callbacks, args);
} else {
return callbacks[prop]; // or undefined
}
}
}
var callbacks = function () {
// for string, boolean, number and null
function useStrictEquality(b, a) {
if (b instanceof a.constructor || a instanceof b.constructor) {
// to catch short annotaion VS 'new' annotation of a declaration
// e.g. var i = 1;
// var j = new Number(1);
return a == b;
} else {
return a === b;
}
}
return {
"string": useStrictEquality,
"boolean": useStrictEquality,
"number": useStrictEquality,
"null": useStrictEquality,
"undefined": useStrictEquality,
"nan": function (b) {
return isNaN(b);
},
"date": function (b, a) {
return QUnit.objectType(b) === "date" && a.valueOf() === b.valueOf();
},
"regexp": function (b, a) {
return QUnit.objectType(b) === "regexp" &&
a.source === b.source && // the regex itself
a.global === b.global && // and its modifers (gmi) ...
a.ignoreCase === b.ignoreCase &&
a.multiline === b.multiline;
},
// - skip when the property is a method of an instance (OOP)
// - abort otherwise,
// initial === would have catch identical references anyway
"function": function () {
var caller = callers[callers.length - 1];
return caller !== Object &&
typeof caller !== "undefined";
},
"array": function (b, a) {
var i, j, loop;
var len;
// b could be an object literal here
if ( ! (QUnit.objectType(b) === "array")) {
return false;
}
len = a.length;
if (len !== b.length) { // safe and faster
return false;
}
//track reference to avoid circular references
parents.push(a);
for (i = 0; i < len; i++) {
loop = false;
for(j=0;j= 0) {
type = "array";
} else {
type = typeof obj;
}
return type;
},
separator:function() {
return this.multiline ? this.HTML ? 'brown fox jumped jumps over"
*/
QUnit.diff = (function() {
function diff(o, n){
var ns = new Object();
var os = new Object();
for (var i = 0; i < n.length; i++) {
if (ns[n[i]] == null)
ns[n[i]] = {
rows: new Array(),
o: null
};
ns[n[i]].rows.push(i);
}
for (var i = 0; i < o.length; i++) {
if (os[o[i]] == null)
os[o[i]] = {
rows: new Array(),
n: null
};
os[o[i]].rows.push(i);
}
for (var i in ns) {
if (ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1) {
n[ns[i].rows[0]] = {
text: n[ns[i].rows[0]],
row: os[i].rows[0]
};
o[os[i].rows[0]] = {
text: o[os[i].rows[0]],
row: ns[i].rows[0]
};
}
}
for (var i = 0; i < n.length - 1; i++) {
if (n[i].text != null && n[i + 1].text == null && n[i].row + 1 < o.length && o[n[i].row + 1].text == null &&
n[i + 1] == o[n[i].row + 1]) {
n[i + 1] = {
text: n[i + 1],
row: n[i].row + 1
};
o[n[i].row + 1] = {
text: o[n[i].row + 1],
row: i + 1
};
}
}
for (var i = n.length - 1; i > 0; i--) {
if (n[i].text != null && n[i - 1].text == null && n[i].row > 0 && o[n[i].row - 1].text == null &&
n[i - 1] == o[n[i].row - 1]) {
n[i - 1] = {
text: n[i - 1],
row: n[i].row - 1
};
o[n[i].row - 1] = {
text: o[n[i].row - 1],
row: i - 1
};
}
}
return {
o: o,
n: n
};
}
return function(o, n){
o = o.replace(/\s+$/, '');
n = n.replace(/\s+$/, '');
var out = diff(o == "" ? [] : o.split(/\s+/), n == "" ? [] : n.split(/\s+/));
var str = "";
var oSpace = o.match(/\s+/g);
if (oSpace == null) {
oSpace = [" "];
}
else {
oSpace.push(" ");
}
var nSpace = n.match(/\s+/g);
if (nSpace == null) {
nSpace = [" "];
}
else {
nSpace.push(" ");
}
if (out.n.length == 0) {
for (var i = 0; i < out.o.length; i++) {
str += '' + out.o[i] + oSpace[i] + "";
}
}
else {
if (out.n[0].text == null) {
for (n = 0; n < out.o.length && out.o[n].text == null; n++) {
str += '' + out.o[n] + oSpace[n] + "";
}
}
for (var i = 0; i < out.n.length; i++) {
if (out.n[i].text == null) {
str += '' + out.n[i] + nSpace[i] + " ";
}
else {
var pre = "";
for (n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++) {
pre += '' + out.o[n] + oSpace[n] + "";
}
str += " " + out.n[i].text + nSpace[i] + pre;
}
}
}
return str;
};
})();
})(this);
client_side_validations-3.2.6/test/javascript/server.rb 0000664 0000000 0000000 00000006335 12202276743 0023375 0 ustar 00root root 0000000 0000000 require 'bundler'
Bundler.setup
require 'sinatra'
require 'json'
require 'ruby-debug'
require File.join(File.expand_path('../../..', __FILE__), 'coffeescript/processor')
ClientSideValidations::Processor.run
class AssetPath
def initialize(app, options={})
@app = app
@urls = options[:urls] || ["/favicon.ico"]
@index = options[:index]
root = options[:root] || Dir.pwd
cache_control = options[:cache_control]
@file_server = Rack::File.new(root, cache_control)
end
def overwrite_file_path(path)
@urls.kind_of?(Hash) && @urls.key?(path) || @index && path == '/'
end
def route_file(path)
@urls.kind_of?(Array) && @urls.any? { |url| path.index(url) == 0 }
end
def can_serve(path)
route_file(path) || overwrite_file_path(path)
end
def call(env)
path = env["PATH_INFO"]
if can_serve(path)
env["PATH_INFO"] = (path == '/' ? @index : @urls[path]) if overwrite_file_path(path)
response = @file_server.call(env)
if response.first == 404
@app.call(env)
else
response
end
else
@app.call(env)
end
end
end
use AssetPath, :urls => ['/vendor/assets/javascripts'], :root => File.expand_path('../..', settings.root)
use AssetPath, :urls => ['/vendor/assets/javascripts'], :root => File.expand_path('../', $:.find { |p| p =~ /jquery-rails/ })
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
helpers do
def jquery_link version
if params[:version] == version
"[#{version}]"
else
"#{version} "
end
end
def jquery_src
if params[:version] == 'edge' then '/vendor/jquery.js'
else "http://code.jquery.com/jquery-#{params[:version]}.js"
end
end
def test_base
names = ['/vendor/qunit.js', 'settings']
names.map { |name| script_tag name }.join("\n")
end
def test *types
types.map do |type|
Dir.glob(File.expand_path("public/test/#{type}", settings.root) + '/*.js').map { |file| File.basename(file) }.map do |file|
script_tag "/test/#{type}/#{file}"
end.join("\n")
end.join("\n")
end
def script_tag src
src = "/test/#{src}.js" unless src.index('/')
%()
end
def jquery_versions
JQUERY_VERSIONS
end
end
get '/' do
params[:version] ||= '1.7.2'
erb :index
end
get '/validators/uniqueness' do
content_type 'application/json'
if user = params[:user2]
status 500
'error'
elsif user = params['active_record_test_module/user2']
status 200
'false'
elsif scope = params[:scope]
if scope[:name] == 'test name' || scope[:name] == 'taken name'
status 200
'false'
else
status 404
'true'
end
elsif params[:case_sensitive] == 'false' && (params[:user][:email] || params[:users][:email]) == 'taken@test.com'
status 200
'false'
else
status 404
'true'
end
end
post '/users' do
data = { :params => params }.update(request.env)
payload = data.to_json.gsub('<', '<').gsub('>', '>')
<<-HTML
Form submitted
HTML
end
client_side_validations-3.2.6/test/javascript/views/ 0000775 0000000 0000000 00000000000 12202276743 0022670 5 ustar 00root root 0000000 0000000 client_side_validations-3.2.6/test/javascript/views/index.erb 0000664 0000000 0000000 00000001270 12202276743 0024471 0 ustar 00root root 0000000 0000000 <% @title = "client_side_validations test" %>
<%= test_base %>
<%= script_tag 'validateElement' %>
<%= script_tag 'utilities' %>
<%= test :validators, :form_builders, :callbacks %>
<%= script_tag 'disableValidators' %>
jQuery version:
<% jquery_versions.each do |v| %>
<%= ' • ' if v != jquery_versions.first %>
<%= jquery_link v %>
<% end %>
<%= (' • ' + jquery_link('edge')) if File.exist?(settings.root + '/public/vendor/jquery.js') %>
client_side_validations-3.2.6/test/javascript/views/layout.erb 0000664 0000000 0000000 00000001256 12202276743 0024703 0 ustar 00root root 0000000 0000000
<%= @title %>