├── .gitattributes
├── lib
    ├── client_side_validations
    │   ├── version.rb
    │   ├── engine.rb
    │   ├── core_ext.rb
    │   ├── active_model
    │   │   ├── exclusion.rb
    │   │   ├── inclusion.rb
    │   │   ├── absence.rb
    │   │   ├── presence.rb
    │   │   ├── acceptance.rb
    │   │   ├── format.rb
    │   │   ├── length.rb
    │   │   ├── conditionals.rb
    │   │   └── numericality.rb
    │   ├── core_ext
    │   │   ├── range.rb
    │   │   └── regexp.rb
    │   ├── active_record.rb
    │   ├── config.rb
    │   ├── generators.rb
    │   ├── files.rb
    │   ├── generators
    │   │   └── rails_validations.rb
    │   ├── extender.rb
    │   ├── action_view.rb
    │   ├── active_record
    │   │   └── uniqueness.rb
    │   ├── action_view
    │   │   ├── form_with_helper.rb
    │   │   ├── form_helper.rb
    │   │   └── form_builder.rb
    │   └── active_model.rb
    ├── client_side_validations.rb
    └── generators
    │   ├── client_side_validations
    │       ├── install_generator.rb
    │       └── copy_assets_generator.rb
    │   └── templates
    │       └── client_side_validations
    │           └── initializer.rb
├── .babelrc
├── test
    ├── javascript
    │   ├── config.ru
    │   ├── views
    │   │   ├── layout.erb
    │   │   └── index.erb
    │   ├── public
    │   │   └── test
    │   │   │   ├── settings.js
    │   │   │   ├── validators
    │   │   │       ├── presence.js
    │   │   │       ├── format.js
    │   │   │       ├── exclusion.js
    │   │   │       ├── inclusion.js
    │   │   │       ├── confirmation.js
    │   │   │       ├── absence.js
    │   │   │       ├── acceptance.js
    │   │   │       ├── length.js
    │   │   │       └── uniqueness.js
    │   │   │   ├── callbacks
    │   │   │       ├── formAfter.js
    │   │   │       ├── formBefore.js
    │   │   │       ├── formPass.js
    │   │   │       ├── formFail.js
    │   │   │       ├── elementBefore.js
    │   │   │       ├── elementAfter.js
    │   │   │       ├── elementPass.js
    │   │   │       └── elementFail.js
    │   │   │   └── form_builders
    │   │   │       └── validateForm.js
    │   ├── server.rb
    │   └── run-qunit.mjs
    ├── active_model
    │   ├── cases
    │   │   ├── helper.rb
    │   │   ├── test_base.rb
    │   │   ├── test_absence_validator.rb
    │   │   ├── test_presence_validator.rb
    │   │   ├── test_acceptance_validator.rb
    │   │   ├── test_confirmation_validator.rb
    │   │   ├── test_exclusion_validator.rb
    │   │   ├── test_inclusion_validator.rb
    │   │   ├── test_format_validator.rb
    │   │   ├── test_length_validator.rb
    │   │   └── test_numericality_validator.rb
    │   └── models
    │   │   └── person.rb
    ├── active_record
    │   ├── models
    │   │   ├── guid.rb
    │   │   ├── thing.rb
    │   │   └── user.rb
    │   └── cases
    │   │   ├── helper.rb
    │   │   ├── test_base.rb
    │   │   └── test_uniqueness_validator.rb
    ├── test_loader.rb
    ├── action_view
    │   ├── models.rb
    │   ├── models
    │   │   ├── tag.rb
    │   │   ├── category.rb
    │   │   ├── comment.rb
    │   │   ├── post.rb
    │   │   └── format_thing.rb
    │   └── cases
    │   │   ├── test_legacy_form_for_helpers.rb
    │   │   ├── test_legacy_form_with_helpers.rb
    │   │   └── helper.rb
    ├── base_helper.rb
    ├── generators
    │   └── cases
    │   │   └── test_generators.rb
    └── core_ext
    │   └── cases
    │       └── test_core_ext.rb
├── .gitignore
├── eslint.config.mjs
├── gemfiles
    ├── rails_7.1.gemfile
    ├── rails_7.2.gemfile
    ├── rails_8.0.gemfile
    ├── rails_6.1.gemfile
    ├── rails_7.0.gemfile
    └── rails_edge.gemfile
├── Gemfile
├── src
    ├── validators
    │   └── local
    │   │   ├── confirmation.js
    │   │   ├── absence_presence.js
    │   │   ├── format.js
    │   │   ├── acceptance.js
    │   │   ├── length.js
    │   │   ├── exclusion_inclusion.js
    │   │   ├── uniqueness.js
    │   │   └── numericality.js
    ├── utils.js
    ├── index.js
    └── core.js
├── .github
    ├── dependabot.yml
    ├── workflows
    │   ├── eslint.yml
    │   ├── rubocop.yml
    │   ├── javascript.yml
    │   └── ruby.yml
    └── ISSUE_TEMPLATE
    │   └── bug_report.md
├── Appraisals
├── LICENSE.md
├── CONTRIBUTING.md
├── client_side_validations.gemspec
├── rollup.config.mjs
├── .rubocop.yml
├── package.json
└── Rakefile


/.gitattributes:
--------------------------------------------------------------------------------
1 | dist/** linguist-generated
2 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/version.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 | 
3 | module ClientSideValidations
4 |   VERSION = '23.0.0.alpha1'
5 | end
6 | 


--------------------------------------------------------------------------------
/.babelrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "presets": [
 3 |     [
 4 |       "@babel/preset-env",
 5 |       {
 6 |         "modules": false
 7 |       }
 8 |     ]
 9 |   ]
10 | }
11 | 


--------------------------------------------------------------------------------
/test/javascript/config.ru:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 | 
3 | $LOAD_PATH.unshift File.expand_path(__dir__)
4 | require 'server'
5 | run Sinatra::Application
6 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/engine.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 | 
3 | module ClientSideValidations
4 |   class Engine < ::Rails::Engine
5 |   end
6 | end
7 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/core_ext.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 | 
3 | require 'active_support/json'
4 | 
5 | require_relative 'core_ext/range'
6 | require_relative 'core_ext/regexp'
7 | 


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


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/exclusion.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module ClientSideValidations
 4 |   module ActiveModel
 5 |     module Exclusion
 6 |       include EnumerableValidator
 7 |     end
 8 |   end
 9 | end
10 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/inclusion.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module ClientSideValidations
 4 |   module ActiveModel
 5 |     module Inclusion
 6 |       include EnumerableValidator
 7 |     end
 8 |   end
 9 | end
10 | 


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


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


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


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.gem
 2 | *.lock
 3 | *.swp
 4 | 
 5 | .*rc
 6 | .bundle
 7 | .byebug_history
 8 | 
 9 | bundler_stubs/*
10 | bin/*
11 | binstubs/*
12 | coverage
13 | pkg/*
14 | tags
15 | test/generators/tmp/*
16 | test/log
17 | 
18 | node_modules
19 | 
20 | !.babelrc
21 | 
22 | pnpm-lock.yaml
23 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/absence.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module ClientSideValidations
 4 |   module ActiveModel
 5 |     module Absence
 6 |       private
 7 | 
 8 |       def message_type
 9 |         :present
10 |       end
11 |     end
12 |   end
13 | end
14 | 


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


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


--------------------------------------------------------------------------------
/lib/client_side_validations/active_record.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 | 
3 | require_relative 'active_model'
4 | 
5 | ActiveSupport.on_load(:active_record) { include ClientSideValidations::ActiveModel::Validations }
6 | 
7 | ClientSideValidations::Extender.extend 'ActiveRecord', %w[Uniqueness]
8 | 


--------------------------------------------------------------------------------
/test/action_view/models.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 | 
3 | require 'active_model'
4 | require 'client_side_validations/active_model'
5 | require 'action_view/models/category'
6 | require 'action_view/models/comment'
7 | require 'action_view/models/format_thing'
8 | require 'action_view/models/post'
9 | 


--------------------------------------------------------------------------------
/test/active_record/cases/helper.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'base_helper'
 4 | require 'active_record'
 5 | require 'client_side_validations/active_record'
 6 | 
 7 | require 'active_record/models/user'
 8 | require 'active_record/models/guid'
 9 | require 'active_record/models/thing'
10 | 


--------------------------------------------------------------------------------
/eslint.config.mjs:
--------------------------------------------------------------------------------
 1 | import neostandard from 'neostandard'
 2 | import compat from 'eslint-plugin-compat'
 3 | 
 4 | export default [
 5 |   {
 6 |     ignores: [
 7 |       'coverage/*',
 8 |       'dist/*',
 9 |       'test/*',
10 |       'vendor/*',
11 |     ]
12 |   },
13 |   compat.configs['flat/recommended'],
14 |   ...neostandard()
15 | ]
16 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/core_ext/regexp.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'js_regex'
 4 | 
 5 | class Regexp
 6 |   def as_json(*)
 7 |     JsRegex.new(self).to_h
 8 |   end
 9 | 
10 |   def to_json(options = nil)
11 |     as_json(options)
12 |   end
13 | 
14 |   def encode_json(_encoder)
15 |     inspect
16 |   end
17 | end
18 | 


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


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


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


--------------------------------------------------------------------------------
/test/javascript/views/layout.erb:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta name="viewport" content="width=device-width">
 6 |     <title><%= @title %></title>
 7 |     <link rel="stylesheet" href="https://code.jquery.com/qunit/qunit-<%= qunit_version %>.css">
 8 |   </head>
 9 |   <body>
10 |     <%= yield %>
11 |   </body>
12 | </html>
13 | 


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


--------------------------------------------------------------------------------
/lib/client_side_validations/generators.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module ClientSideValidations
 4 |   module Generators
 5 |     @@assets = []
 6 | 
 7 |     def self.register_assets(klass)
 8 |       @@assets.concat(klass.assets)
 9 |     end
10 | 
11 |     def self.assets
12 |       @@assets
13 |     end
14 |   end
15 | end
16 | 
17 | require_relative 'generators/rails_validations'
18 | 


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


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


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


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


--------------------------------------------------------------------------------
/test/javascript/views/index.erb:
--------------------------------------------------------------------------------
 1 | <% @title = "client_side_validations test" %>
 2 | 
 3 | <div id="qunit"></div>
 4 | <div id="qunit-fixture"></div>
 5 | 
 6 | <%= script_tag "https://code.jquery.com/jquery-#{jquery_version}.min.js" %>
 7 | <%= script_tag '/vendor/assets/javascripts/rails.validations.js' %>
 8 | <%= script_tag "https://code.jquery.com/qunit/qunit-#{qunit_version}.js" %>
 9 | <%= script_tag 'settings' %>
10 | <%= script_tag 'validateElement' %>
11 | <%= test :validators, :form_builders, :callbacks %>
12 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/extender.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module ClientSideValidations
 4 |   module Extender
 5 |     module_function
 6 | 
 7 |     def extend(klass, validators)
 8 |       validators.each do |validator|
 9 |         require "client_side_validations/#{klass.underscore}/#{validator.downcase}"
10 | 
11 |         const_get(klass)::Validations.const_get(:"#{validator}Validator").include ClientSideValidations.const_get(klass).const_get(validator)
12 |       end
13 |     end
14 |   end
15 | end
16 | 


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


--------------------------------------------------------------------------------
/lib/client_side_validations.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require_relative 'client_side_validations/config'
 4 | require_relative 'client_side_validations/active_model'  if defined?(ActiveModel)
 5 | require_relative 'client_side_validations/active_record' if defined?(ActiveRecord)
 6 | require_relative 'client_side_validations/action_view'   if defined?(ActionView)
 7 | 
 8 | if defined?(Rails)
 9 |   require_relative 'client_side_validations/engine'
10 |   require_relative 'client_side_validations/generators'
11 | end
12 | 


--------------------------------------------------------------------------------
/gemfiles/rails_7.1.gemfile:
--------------------------------------------------------------------------------
 1 | # This file was generated by Appraisal
 2 | 
 3 | source "https://rubygems.org"
 4 | 
 5 | gem "appraisal"
 6 | gem "byebug"
 7 | gem "m"
 8 | gem "minitest"
 9 | gem "mocha"
10 | gem "rake"
11 | gem "rubocop"
12 | gem "rubocop-minitest"
13 | gem "rubocop-packaging"
14 | gem "rubocop-performance"
15 | gem "rubocop-rails"
16 | gem "rubocop-rake"
17 | gem "shotgun"
18 | gem "simplecov"
19 | gem "simplecov-lcov"
20 | gem "sinatra"
21 | gem "sqlite3"
22 | gem "webrick"
23 | gem "rails", "~> 7.1.0"
24 | 
25 | gemspec path: "../"
26 | 


--------------------------------------------------------------------------------
/gemfiles/rails_7.2.gemfile:
--------------------------------------------------------------------------------
 1 | # This file was generated by Appraisal
 2 | 
 3 | source "https://rubygems.org"
 4 | 
 5 | gem "appraisal"
 6 | gem "byebug"
 7 | gem "m"
 8 | gem "minitest"
 9 | gem "mocha"
10 | gem "rake"
11 | gem "rubocop"
12 | gem "rubocop-minitest"
13 | gem "rubocop-packaging"
14 | gem "rubocop-performance"
15 | gem "rubocop-rails"
16 | gem "rubocop-rake"
17 | gem "shotgun"
18 | gem "simplecov"
19 | gem "simplecov-lcov"
20 | gem "sinatra"
21 | gem "sqlite3"
22 | gem "webrick"
23 | gem "rails", "~> 7.2.0"
24 | 
25 | gemspec path: "../"
26 | 


--------------------------------------------------------------------------------
/gemfiles/rails_8.0.gemfile:
--------------------------------------------------------------------------------
 1 | # This file was generated by Appraisal
 2 | 
 3 | source "https://rubygems.org"
 4 | 
 5 | gem "appraisal"
 6 | gem "byebug"
 7 | gem "m"
 8 | gem "minitest"
 9 | gem "mocha"
10 | gem "rake"
11 | gem "rubocop"
12 | gem "rubocop-minitest"
13 | gem "rubocop-packaging"
14 | gem "rubocop-performance"
15 | gem "rubocop-rails"
16 | gem "rubocop-rake"
17 | gem "shotgun"
18 | gem "simplecov"
19 | gem "simplecov-lcov"
20 | gem "sinatra"
21 | gem "sqlite3"
22 | gem "webrick"
23 | gem "rails", "~> 8.0.0"
24 | 
25 | gemspec path: "../"
26 | 


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


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | source 'https://rubygems.org'
 4 | 
 5 | # Specify your gem's dependencies in client_side_validations.gemspec
 6 | gemspec
 7 | 
 8 | gem 'appraisal'
 9 | gem 'byebug'
10 | gem 'm'
11 | gem 'minitest'
12 | gem 'mocha'
13 | gem 'rake'
14 | gem 'rubocop'
15 | gem 'rubocop-minitest'
16 | gem 'rubocop-packaging'
17 | gem 'rubocop-performance'
18 | gem 'rubocop-rails'
19 | gem 'rubocop-rake'
20 | gem 'shotgun'
21 | gem 'simplecov'
22 | gem 'simplecov-lcov'
23 | gem 'sinatra'
24 | gem 'sqlite3'
25 | gem 'webrick'
26 | 


--------------------------------------------------------------------------------
/src/validators/local/confirmation.js:
--------------------------------------------------------------------------------
 1 | export const confirmationLocalValidator = ($element, options) => {
 2 |   const element = $element[0]
 3 |   let value = element.value
 4 |   let confirmationValue = document.getElementById(`${element.id}_confirmation`).value
 5 | 
 6 |   if (!options.case_sensitive) {
 7 |     value = value.toLowerCase()
 8 |     confirmationValue = confirmationValue.toLowerCase()
 9 |   }
10 | 
11 |   if (value !== confirmationValue) {
12 |     return options.message
13 |   }
14 | }
15 | 
16 | export default {
17 |   confirmationLocalValidator
18 | }
19 | 


--------------------------------------------------------------------------------
/.github/dependabot.yml:
--------------------------------------------------------------------------------
 1 | version: 2
 2 | updates:
 3 |   - package-ecosystem: github-actions
 4 |     directory: "/"
 5 |     schedule:
 6 |       interval: daily
 7 |   - package-ecosystem: bundler
 8 |     directory: "/"
 9 |     schedule:
10 |       interval: daily
11 |     open-pull-requests-limit: 10
12 |     ignore:
13 |       - dependency-name: sqlite3
14 |         versions: ">= 2" # FIXME: Remove when rails/rails#51636 will be released
15 |   - package-ecosystem: npm
16 |     directory: "/"
17 |     schedule:
18 |       interval: daily
19 |     open-pull-requests-limit: 10
20 | 


--------------------------------------------------------------------------------
/src/validators/local/absence_presence.js:
--------------------------------------------------------------------------------
 1 | import { isValuePresent } from '../../utils'
 2 | 
 3 | export const absenceLocalValidator = ($element, options) => {
 4 |   const element = $element[0]
 5 | 
 6 |   if (isValuePresent(element.value)) {
 7 |     return options.message
 8 |   }
 9 | }
10 | 
11 | export const presenceLocalValidator = ($element, options) => {
12 |   const element = $element[0]
13 | 
14 |   if (!isValuePresent(element.value)) {
15 |     return options.message
16 |   }
17 | }
18 | 
19 | export default {
20 |   absenceLocalValidator,
21 |   presenceLocalValidator
22 | }
23 | 


--------------------------------------------------------------------------------
/gemfiles/rails_6.1.gemfile:
--------------------------------------------------------------------------------
 1 | # This file was generated by Appraisal
 2 | 
 3 | source "https://rubygems.org"
 4 | 
 5 | gem "appraisal"
 6 | gem "byebug"
 7 | gem "m"
 8 | gem "minitest"
 9 | gem "mocha"
10 | gem "rake"
11 | gem "rubocop"
12 | gem "rubocop-minitest"
13 | gem "rubocop-packaging"
14 | gem "rubocop-performance"
15 | gem "rubocop-rails"
16 | gem "rubocop-rake"
17 | gem "shotgun"
18 | gem "simplecov"
19 | gem "simplecov-lcov"
20 | gem "sinatra"
21 | gem "sqlite3", "~> 1.7"
22 | gem "webrick"
23 | gem "rails", "~> 6.1.0"
24 | gem "concurrent-ruby", "< 1.3.5"
25 | 
26 | gemspec path: "../"
27 | 


--------------------------------------------------------------------------------
/gemfiles/rails_7.0.gemfile:
--------------------------------------------------------------------------------
 1 | # This file was generated by Appraisal
 2 | 
 3 | source "https://rubygems.org"
 4 | 
 5 | gem "appraisal"
 6 | gem "byebug"
 7 | gem "m"
 8 | gem "minitest"
 9 | gem "mocha"
10 | gem "rake"
11 | gem "rubocop"
12 | gem "rubocop-minitest"
13 | gem "rubocop-packaging"
14 | gem "rubocop-performance"
15 | gem "rubocop-rails"
16 | gem "rubocop-rake"
17 | gem "shotgun"
18 | gem "simplecov"
19 | gem "simplecov-lcov"
20 | gem "sinatra"
21 | gem "sqlite3", "~> 1.7"
22 | gem "webrick"
23 | gem "rails", "~> 7.0.0"
24 | gem "concurrent-ruby", "< 1.3.5"
25 | 
26 | gemspec path: "../"
27 | 


--------------------------------------------------------------------------------
/gemfiles/rails_edge.gemfile:
--------------------------------------------------------------------------------
 1 | # This file was generated by Appraisal
 2 | 
 3 | source "https://rubygems.org"
 4 | 
 5 | gem "appraisal"
 6 | gem "byebug"
 7 | gem "m"
 8 | gem "minitest"
 9 | gem "mocha"
10 | gem "rake"
11 | gem "rubocop"
12 | gem "rubocop-minitest"
13 | gem "rubocop-packaging"
14 | gem "rubocop-performance"
15 | gem "rubocop-rails"
16 | gem "rubocop-rake"
17 | gem "shotgun"
18 | gem "simplecov"
19 | gem "simplecov-lcov"
20 | gem "sinatra"
21 | gem "sqlite3"
22 | gem "webrick"
23 | gem "rails", git: "https://github.com/rails/rails.git", branch: "main"
24 | 
25 | gemspec path: "../"
26 | 


--------------------------------------------------------------------------------
/.github/workflows/eslint.yml:
--------------------------------------------------------------------------------
 1 | name: ESLint
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ main ]
 6 |   pull_request:
 7 |     branches: [ main ]
 8 | 
 9 | permissions:
10 |   contents: read
11 | 
12 | jobs:
13 |   eslint:
14 |     name: ESLint
15 |     runs-on: ubuntu-latest
16 |     steps:
17 |     - uses: actions/checkout@v6
18 |     - uses: pnpm/action-setup@v4
19 |     - name: Set up Node
20 |       uses: actions/setup-node@v6
21 |       with:
22 |         node-version: '22'
23 |     - name: Install node dependencies
24 |       run: pnpm install
25 |     - name: Run JavaScript linter
26 |       run: pnpm eslint
27 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/action_view.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module ClientSideValidations
 4 |   module ActionView
 5 |     module Helpers
 6 |     end
 7 |   end
 8 | end
 9 | 
10 | require_relative 'core_ext'
11 | require_relative 'action_view/form_helper'
12 | 
13 | if ActionView::Helpers::FormHelper.method_defined?(:form_with)
14 |   require_relative 'action_view/form_with_helper'
15 | end
16 | 
17 | require_relative 'action_view/form_builder'
18 | 
19 | ActiveSupport.on_load(:action_view) { include ClientSideValidations::ActionView::Helpers::FormHelper }
20 | ActionView::Helpers::FormBuilder.prepend ClientSideValidations::ActionView::Helpers::FormBuilder
21 | 


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


--------------------------------------------------------------------------------
/Appraisals:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | appraise 'rails-6.1' do
 4 |   gem 'rails', '~> 6.1.0'
 5 |   gem 'sqlite3', '~> 1.7'
 6 |   gem 'concurrent-ruby', '< 1.3.5' # Ref: rails/rails#54260
 7 | end
 8 | 
 9 | appraise 'rails-7.0' do
10 |   gem 'rails', '~> 7.0.0'
11 |   gem 'sqlite3', '~> 1.7'
12 |   gem 'concurrent-ruby', '< 1.3.5' # Ref: rails/rails#54260
13 | end
14 | 
15 | appraise 'rails-7.1' do
16 |   gem 'rails', '~> 7.1.0'
17 | end
18 | 
19 | appraise 'rails-7.2' do
20 |   gem 'rails', '~> 7.2.0'
21 | end
22 | 
23 | appraise 'rails-8.0' do
24 |   gem 'rails', '~> 8.0.0'
25 | end
26 | 
27 | appraise 'rails-edge' do
28 |   gem 'rails', git: 'https://github.com/rails/rails.git', branch: 'main'
29 | end
30 | 


--------------------------------------------------------------------------------
/.github/workflows/rubocop.yml:
--------------------------------------------------------------------------------
 1 | name: Rubocop
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ main ]
 6 |   pull_request:
 7 |     branches: [ main ]
 8 | 
 9 | permissions:
10 |   contents: read
11 | 
12 | jobs:
13 |   rubocop:
14 |     name: Rubocop
15 |     runs-on: ${{ matrix.os }}
16 |     env:
17 |       BUNDLE_JOBS: 4
18 |       BUNDLE_RETRY: 3
19 |     strategy:
20 |       matrix:
21 |         os: [ubuntu-latest]
22 |         ruby-version: ['3.4']
23 | 
24 |     steps:
25 |     - uses: actions/checkout@v6
26 |     - name: Set up Ruby
27 |       uses: ruby/setup-ruby@v1
28 |       with:
29 |         ruby-version: ${{ matrix.ruby-version }}
30 |         bundler-cache: true
31 |     - name: Ruby linter
32 |       run: bundle exec rubocop -f github
33 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_absence_validator.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'active_model/cases/test_base'
 4 | 
 5 | module ActiveModel
 6 |   class AbsenceValidatorTest < ClientSideValidations::ActiveModelTestBase
 7 |     def test_absence_client_side_hash
 8 |       expected_hash = { message: 'must be blank' }
 9 | 
10 |       assert_equal expected_hash, AbsenceValidator.new(attributes: [:name]).client_side_hash(@person, :age)
11 |     end
12 | 
13 |     def test_absence_client_side_hash_with_custom_message
14 |       expected_hash = { message: 'is required to be blank' }
15 | 
16 |       assert_equal expected_hash, AbsenceValidator.new(attributes: [:name], message: 'is required to be blank').client_side_hash(@person, :age)
17 |     end
18 |   end
19 | end
20 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_presence_validator.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'active_model/cases/test_base'
 4 | 
 5 | module ActiveModel
 6 |   class PresenceValidatorTest < ClientSideValidations::ActiveModelTestBase
 7 |     def test_presence_client_side_hash
 8 |       expected_hash = { message: I18n.t('errors.messages.blank') }
 9 | 
10 |       assert_equal expected_hash, PresenceValidator.new(attributes: [:name]).client_side_hash(@person, :age)
11 |     end
12 | 
13 |     def test_presence_client_side_hash_with_custom_message
14 |       expected_hash = { message: 'is required' }
15 | 
16 |       assert_equal expected_hash, PresenceValidator.new(attributes: [:name], message: 'is required').client_side_hash(@person, :age)
17 |     end
18 |   end
19 | end
20 | 


--------------------------------------------------------------------------------
/.github/workflows/javascript.yml:
--------------------------------------------------------------------------------
 1 | name: JavaScript tests
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ main ]
 6 |   pull_request:
 7 |     branches: [ main ]
 8 | 
 9 | permissions:
10 |   contents: read
11 | 
12 | jobs:
13 |   test:
14 |     name: JavaScript Tests
15 |     runs-on: ubuntu-latest
16 |     steps:
17 |     - uses: actions/checkout@v6
18 |     - name: Set up Ruby
19 |       uses: ruby/setup-ruby@v1
20 |       with:
21 |         ruby-version: '3.4'
22 |         bundler-cache: true
23 |     - uses: pnpm/action-setup@v4
24 |     - name: Set up Node
25 |       uses: actions/setup-node@v6
26 |       with:
27 |         node-version: '22'
28 |     - name: Install node dependencies
29 |       run: pnpm install
30 |     - name: Run tests
31 |       run: bundle exec rake test:js
32 | 


--------------------------------------------------------------------------------
/src/validators/local/format.js:
--------------------------------------------------------------------------------
 1 | import { isValuePresent } from '../../utils'
 2 | 
 3 | const isMatching = (value, regExpOptions) => {
 4 |   return new RegExp(regExpOptions.source, regExpOptions.options).test(value)
 5 | }
 6 | 
 7 | const hasValidFormat = (value, withOptions, withoutOptions) => {
 8 |   return (withOptions && isMatching(value, withOptions)) || (withoutOptions && !isMatching(value, withoutOptions))
 9 | }
10 | 
11 | export const formatLocalValidator = ($element, options) => {
12 |   const element = $element[0]
13 |   const value = element.value
14 | 
15 |   if (options.allow_blank && !isValuePresent(value)) {
16 |     return
17 |   }
18 | 
19 |   if (!hasValidFormat(value, options.with, options.without)) {
20 |     return options.message
21 |   }
22 | }
23 | 
24 | export default {
25 |   formatLocalValidator
26 | }
27 | 


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


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


--------------------------------------------------------------------------------
/src/validators/local/acceptance.js:
--------------------------------------------------------------------------------
 1 | import { arrayHasValue } from '../../utils'
 2 | 
 3 | const DEFAULT_ACCEPT_OPTION = ['1', true]
 4 | 
 5 | const isTextAccepted = (value, acceptOption) => {
 6 |   if (!acceptOption) {
 7 |     acceptOption = DEFAULT_ACCEPT_OPTION
 8 |   }
 9 | 
10 |   if (Array.isArray(acceptOption)) {
11 |     return arrayHasValue(value, acceptOption)
12 |   }
13 | 
14 |   return value === acceptOption
15 | }
16 | 
17 | export const acceptanceLocalValidator = ($element, options) => {
18 |   const element = $element[0]
19 |   let valid = true
20 | 
21 |   if (element.type === 'checkbox') {
22 |     valid = element.checked
23 |   }
24 | 
25 |   if (element.type === 'text') {
26 |     valid = isTextAccepted(element.value, options.accept)
27 |   }
28 | 
29 |   if (!valid) {
30 |     return options.message
31 |   }
32 | }
33 | 
34 | export default {
35 |   acceptanceLocalValidator
36 | }
37 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/settings.js:
--------------------------------------------------------------------------------
 1 | QUnit.config.autostart = window.location.search.search('autostart=false') < 0
 2 | 
 3 | QUnit.config.urlConfig.push({
 4 |   id: 'jquery',
 5 |   label: 'jQuery version',
 6 |   value: ['3.7.1', '3.7.1.slim'],
 7 |   tooltip: 'What jQuery Core version to test against'
 8 | })
 9 | 
10 | /* Hijacks normal form submit; lets it submit to an iframe to prevent
11 |  * navigating away from the test suite
12 |  */
13 | $(document).on('submit', function (e) {
14 |   if (!e.isDefaultPrevented()) {
15 |     var form = $(e.target)
16 |     var action = form.attr('action')
17 |     var name = 'form-frame' + jQuery.guid++
18 |     var iframe = $('<iframe>', { name: name })
19 | 
20 |     if (action && action.indexOf('iframe') < 0) form.attr('action', action + '?iframe=true')
21 |     form.attr('target', name)
22 |     $('#qunit-fixture').append(iframe)
23 |     form.trigger('iframe:loading')
24 |   }
25 | })
26 | 


--------------------------------------------------------------------------------
/test/active_record/models/user.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | users_table = %{CREATE TABLE users (id INTEGER PRIMARY KEY, age INTEGER, name TEXT, email TEXT, title VARCHAR(5), parent_id INTEGER, active BOOLEAN, type VARCHAR(255));}
 4 | ActiveRecord::Base.connection.execute(users_table)
 5 | 
 6 | class User < ActiveRecord::Base
 7 |   validates :email, :title, :active, :name, uniqueness: { allow_nil: true }
 8 | end
 9 | 
10 | class IneptWizard < User; end
11 | 
12 | class Conjurer < IneptWizard; end
13 | 
14 | class Thaumaturgist < Conjurer; end
15 | 
16 | module ActiveRecordTestModule
17 |   class User2 < User; end
18 | end
19 | 
20 | class UserForm
21 |   include ActiveModel::Validations
22 |   include ActiveRecord::Validations
23 | 
24 |   attr_accessor :name
25 | 
26 |   validates_uniqueness_of :name, client_validations: { class: User }
27 | 
28 |   def self.i18n_scope
29 |     :activerecord
30 |   end
31 | 
32 |   def new_record?
33 |     true
34 |   end
35 | end
36 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/presence.js:
--------------------------------------------------------------------------------
 1 | QUnit.module('Presence options')
 2 | 
 3 | QUnit.test('when value is not empty', function (assert) {
 4 |   var element = $('<input type="text" />')
 5 |   var options = { message: 'failed validation' }
 6 |   element.val('not empty')
 7 |   assert.equal(ClientSideValidations.validators.local.presence(element, options), undefined)
 8 | })
 9 | 
10 | QUnit.test('when value is empty', function (assert) {
11 |   var element = $('<input type="text" />')
12 |   var options = { message: 'failed validation' }
13 |   assert.equal(ClientSideValidations.validators.local.presence(element, options), 'failed validation')
14 | })
15 | 
16 | QUnit.test('when value is null from non-selected multi-select element', function (assert) {
17 |   var element = $('<select multiple="multiple">')
18 |   var options = { message: 'failed validation' }
19 |   assert.equal(ClientSideValidations.validators.local.presence(element, options), 'failed validation')
20 | })
21 | 


--------------------------------------------------------------------------------
/src/utils.js:
--------------------------------------------------------------------------------
 1 | export const addClass = (element, customClass) => {
 2 |   if (customClass) {
 3 |     element.classList.add(...customClass.split(' '))
 4 |   }
 5 | }
 6 | 
 7 | export const arrayHasValue = (value, otherValues) => {
 8 |   for (let i = 0, l = otherValues.length; i < l; i++) {
 9 |     if (value === otherValues[i]) {
10 |       return true
11 |     }
12 |   }
13 | 
14 |   return false
15 | }
16 | 
17 | export const createElementFromHTML = (html) => {
18 |   const element = document.createElement('div')
19 |   element.innerHTML = html
20 | 
21 |   return element.firstChild
22 | }
23 | 
24 | export const isValuePresent = (value) => {
25 |   return !/^\s*$/.test(value || '')
26 | }
27 | 
28 | export const removeClass = (element, customClass) => {
29 |   if (customClass) {
30 |     element.classList.remove(...customClass.split(' '))
31 |   }
32 | }
33 | 
34 | export default {
35 |   addClass,
36 |   arrayHasValue,
37 |   createElementFromHTML,
38 |   isValuePresent,
39 |   removeClass
40 | }
41 | 


--------------------------------------------------------------------------------
/test/action_view/models/post.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | class Post
 4 |   extend ActiveModel::Naming
 5 |   extend ActiveModel::Translation
 6 |   include ActiveModel::Validations
 7 |   include ActiveModel::Conversion
 8 | 
 9 |   attr_accessor :title, :author_name, :body, :secret, :written_on, :cost, :comments, :comment_ids, :category, :category_id, :tags, :tag_ids
10 | 
11 |   validates :cost, :body, presence: true
12 |   validates :body, length: { minimum: 200 }
13 |   validates :tags, length: { minimum: 0, maximum: 3 }
14 | 
15 |   # Simulate default Rails 5's association
16 |   validates :category, presence: { message: :required }
17 | 
18 |   def initialize(params = {})
19 |     params.each do |attr, value|
20 |       public_send(:"#{attr}=", value)
21 |     end
22 |   end
23 | 
24 |   def persisted?
25 |     false
26 |   end
27 | 
28 |   def comments_attributes=(attributes); end
29 | 
30 |   def category_attributes=(attributes); end
31 | 
32 |   def tags_attributes=(attributes); end
33 | end
34 | 


--------------------------------------------------------------------------------
/src/validators/local/length.js:
--------------------------------------------------------------------------------
 1 | import { isValuePresent } from '../../utils'
 2 | 
 3 | const VALIDATIONS = {
 4 |   is: (a, b) => {
 5 |     return (a === parseInt(b, 10))
 6 |   },
 7 |   minimum: (a, b) => {
 8 |     return (a >= parseInt(b, 10))
 9 |   },
10 |   maximum: (a, b) => {
11 |     return (a <= parseInt(b, 10))
12 |   }
13 | }
14 | 
15 | const runValidations = (valueLength, options) => {
16 |   for (const validation in VALIDATIONS) {
17 |     const validationOption = options[validation]
18 |     const validationFunction = VALIDATIONS[validation]
19 | 
20 |     if (validationOption && !validationFunction(valueLength, validationOption)) {
21 |       return options.messages[validation]
22 |     }
23 |   }
24 | }
25 | 
26 | export const lengthLocalValidator = ($element, options) => {
27 |   const element = $element[0]
28 |   const value = element.value
29 | 
30 |   if (options.allow_blank && !isValuePresent(value)) {
31 |     return
32 |   }
33 | 
34 |   return runValidations(value.length, options)
35 | }
36 | 
37 | export default {
38 |   lengthLocalValidator
39 | }
40 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/length.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module ClientSideValidations
 4 |   module ActiveModel
 5 |     module Length
 6 |       def client_side_hash(model, attribute, _force = nil)
 7 |         options = self.options.dup
 8 |         hash    = options_hash(options)
 9 | 
10 |         self.class::MESSAGES.each do |option, message_type|
11 |           count = options[option]
12 |           next unless count
13 | 
14 |           options[:message] = options[message_type] if options[message_type].present?
15 |           options.delete(:message) if options[:message].nil?
16 |           hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(count: count))
17 |           hash[option] = count
18 |         end
19 | 
20 |         copy_conditional_attributes(hash, options)
21 | 
22 |         hash
23 |       end
24 | 
25 |       private
26 | 
27 |       def options_hash(options)
28 |         hash = { messages: {} }
29 |         hash[:allow_blank] = true if options[:allow_nil] || options[:allow_blank]
30 |         hash
31 |       end
32 |     end
33 |   end
34 | end
35 | 


--------------------------------------------------------------------------------
/lib/generators/templates/client_side_validations/initializer.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | # ClientSideValidations Initializer
 4 | 
 5 | # Disabled validators
 6 | # ClientSideValidations::Config.disabled_validators = []
 7 | 
 8 | # Uncomment to validate number format with current I18n locale
 9 | # ClientSideValidations::Config.number_format_with_locale = true
10 | 
11 | # Uncomment the following block if you want each input field to have the validation messages attached.
12 | #
13 | # Alternatively, for a cleaner approach, it is possible to set
14 | # `config.action_view.field_error_proc` in the application configuration
15 | #
16 | # Note: client_side_validation requires the error to be encapsulated within
17 | # <label for="#{instance.send(:tag_id)}" class="message"></label>
18 | #
19 | # ActionView::Base.field_error_proc = proc do |html_tag, instance|
20 | #   if /^<label/.match?(html_tag)
21 | #     %(<div class="field_with_errors">#{html_tag}</div>).html_safe
22 | #   else
23 | #     %(<div class="field_with_errors">#{html_tag}<label for="#{instance.send(:tag_id)}" class="message">#{instance.error_message.first}</label></div>).html_safe
24 | #   end
25 | # end
26 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2024 Geremia Taglialatela, Brian Cardarella
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/conditionals.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module ClientSideValidations
 4 |   module ActiveModel
 5 |     module Conditionals
 6 |       private
 7 | 
 8 |       def run_conditionals(conditionals, conditional_type)
 9 |         Array.wrap(conditionals).all? do |conditional|
10 |           value = run_one_conditional(conditional)
11 |           if conditional_type == :unless
12 |             !value
13 |           else
14 |             value
15 |           end
16 |         end
17 |       end
18 | 
19 |       def run_one_conditional(conditional)
20 |         case conditional
21 |         when ::Proc
22 |           case conditional.arity
23 |           when 0
24 |             instance_exec(&conditional)
25 |           when 1
26 |             instance_exec(self, &conditional)
27 |           else
28 |             raise ArgumentError, 'Missing argument'
29 |           end
30 |         when Symbol
31 |           send conditional
32 |         else
33 |           raise ArgumentError, "Unknown conditional #{conditional}. If supported by ActiveModel/ActiveRecord open a bug for client_side_validations gem."
34 |         end
35 |       end
36 |     end
37 |   end
38 | end
39 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug_report.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Bug report
 3 | about: Create a report to help us improve
 4 | title: ''
 5 | labels: ''
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | ### Steps to reproduce*
11 | 
12 | ### Expected behavior*
13 | _Tell us what should happen_
14 | 
15 | ### Actual behavior*
16 | _Tell us what happens instead_
17 | 
18 | ### System configuration*
19 | **Rails version**:
20 | 
21 | **Ruby version**:
22 | 
23 | **Client Side Validations version**:
24 | 
25 | ### Code snippet from your model of the validations*
26 | 
27 | ### The whole form code from your template*
28 | 
29 | ### The resulting HTML*
30 | 
31 | ### Browser's development console output*
32 | - [ ] I confirm that my browser's development console output does not contain errors
33 | 
34 | ### Additional JavaScript Libraries*
35 | _If your issue depends on other JavaScript libraries, please list them here. E.g: *Bootstrap Modal v3.3.7, jQuery UI Datepicker 1.12.4*._
36 | 
37 | ### Repository demostrating the issue
38 | Debugging CSV issues is a time consuming task. If you want to speed up things, please
39 | provide a link to a repository showing the issue.
40 | 
41 | ---
42 | 
43 | **\*** Failure to include this requirement may result in the issue being closed.
44 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_confirmation_validator.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'active_model/cases/test_base'
 4 | 
 5 | module ActiveModel
 6 |   class ConfirmationValidatorTest < ClientSideValidations::ActiveModelTestBase
 7 |     def test_confirmation_client_side_hash
 8 |       expected_hash = { message: I18n.t('errors.messages.confirmation', attribute: 'Age'), case_sensitive: true }
 9 | 
10 |       assert_equal expected_hash, ConfirmationValidator.new(attributes: [:name], class: Person).client_side_hash(@person, :age)
11 |     end
12 | 
13 |     def test_confirmation_client_side_without_case_sensitive
14 |       expected_hash = { message: I18n.t('errors.messages.confirmation', attribute: 'Age'), case_sensitive: false }
15 | 
16 |       assert_equal expected_hash, ConfirmationValidator.new(attributes: [:name], class: Person, case_sensitive: false).client_side_hash(@person, :age)
17 |     end
18 | 
19 |     def test_confirmation_client_side_hash_with_custom_message
20 |       expected_hash = { message: 'you must confirm', case_sensitive: true }
21 | 
22 |       assert_equal expected_hash, ConfirmationValidator.new(attributes: [:name], class: Person, message: 'you must confirm').client_side_hash(@person, :age)
23 |     end
24 |   end
25 | end
26 | 


--------------------------------------------------------------------------------
/src/validators/local/exclusion_inclusion.js:
--------------------------------------------------------------------------------
 1 | import { arrayHasValue, isValuePresent } from '../../utils'
 2 | 
 3 | const isInList = (value, otherValues) => {
 4 |   const normalizedOtherValues = []
 5 | 
 6 |   for (const otherValueIndex in otherValues) {
 7 |     normalizedOtherValues.push(otherValues[otherValueIndex].toString())
 8 |   }
 9 | 
10 |   return arrayHasValue(value, normalizedOtherValues)
11 | }
12 | 
13 | const isInRange = (value, range) => {
14 |   return value >= range[0] && value <= range[1]
15 | }
16 | 
17 | const isIncluded = (value, options, allowBlank) => {
18 |   if ((options.allow_blank && !isValuePresent(value)) === allowBlank) {
19 |     return true
20 |   }
21 | 
22 |   return (options.in && isInList(value, options.in)) || (options.range && isInRange(value, options.range))
23 | }
24 | 
25 | export const exclusionLocalValidator = ($element, options) => {
26 |   const element = $element[0]
27 |   const value = element.value
28 | 
29 |   if (isIncluded(value, options, false) || (!options.allow_blank && !isValuePresent(value))) {
30 |     return options.message
31 |   }
32 | }
33 | 
34 | export const inclusionLocalValidator = ($element, options) => {
35 |   const element = $element[0]
36 |   const value = element.value
37 | 
38 |   if (!isIncluded(value, options, true)) {
39 |     return options.message
40 |   }
41 | }
42 | 
43 | export default {
44 |   exclusionLocalValidator,
45 |   inclusionLocalValidator
46 | }
47 | 


--------------------------------------------------------------------------------
/src/validators/local/uniqueness.js:
--------------------------------------------------------------------------------
 1 | const isLocallyUnique = (element, value, otherValue, caseSensitive) => {
 2 |   if (!caseSensitive) {
 3 |     value = value.toLowerCase()
 4 |     otherValue = otherValue.toLowerCase()
 5 |   }
 6 | 
 7 |   if (otherValue === value) {
 8 |     element.dataset.notLocallyUnique = true
 9 |     return false
10 |   }
11 | 
12 |   if (element.dataset.notLocallyUnique) {
13 |     delete element.dataset.notLocallyUnique
14 |     element.dataset.changed = true
15 |   }
16 | 
17 |   return true
18 | }
19 | 
20 | export const uniquenessLocalValidator = ($element, options) => {
21 |   const element = $element[0]
22 |   const elementName = element.name
23 |   const matches = elementName.match(/^(.+_attributes\])\[\d+\](.+)$/)
24 | 
25 |   if (!matches) {
26 |     return
27 |   }
28 | 
29 |   const form = element.form
30 | 
31 |   const value = element.value
32 |   let valid = true
33 | 
34 |   const query = `[name^="${matches[1]}"][name$="${matches[2]}"]:not([name="${elementName}"])`
35 |   const otherElements = form.querySelectorAll(query)
36 | 
37 |   Array.prototype.slice.call(otherElements).forEach(function (otherElement) {
38 |     const otherValue = otherElement.value
39 | 
40 |     if (!isLocallyUnique(otherElement, value, otherValue, options.case_sensitive)) {
41 |       valid = false
42 |     }
43 |   })
44 | 
45 |   if (!valid) {
46 |     return options.message
47 |   }
48 | }
49 | 
50 | export default {
51 |   uniquenessLocalValidator
52 | }
53 | 


--------------------------------------------------------------------------------
/test/action_view/models/format_thing.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | class FormatThing
 4 |   extend ActiveModel::Naming
 5 |   extend ActiveModel::Translation
 6 |   include ActiveModel::Validations
 7 |   include ActiveModel::Conversion
 8 | 
 9 |   attr_accessor :a,
10 |                 :backslash,
11 |                 :space,
12 |                 :escaped_space,
13 |                 :ascii_escape,
14 |                 :unicode_escape,
15 |                 :unicode_literal,
16 |                 :newline_escape,
17 |                 :newline_literal,
18 |                 :devise_email
19 | 
20 |   validates_format_of :a, with: /a/
21 |   validates_format_of :backslash, with: /\\/
22 |   validates_format_of :space, with: / /
23 |   validates_format_of :escaped_space, with: /\ /
24 |   validates_format_of :ascii_escape, with: /\x41/
25 |   validates_format_of :unicode_escape, with: /\u263A/
26 |   validates_format_of :unicode_literal, with: /☺/
27 |   validates_format_of :newline_escape, with: /\n/
28 |   validates_format_of :newline_literal, with: /
29 | /
30 | 
31 |   # email regexp of devise gem
32 |   # https://github.com/plataformatec/devise/blob/
33 |   # 7df57d5081f9884849ca15e4fde179ef164a575f/lib/devise.rb#L109
34 |   validates_format_of :devise_email, with: /\A[^@\s]+@([^@\s]+\.)+[^@\W]+\z/
35 | 
36 |   def initialize(params = {})
37 |     params.each do |attr, value|
38 |       public_send(:"#{attr}=", value)
39 |     end
40 |   end
41 | 
42 |   def persisted?
43 |     false
44 |   end
45 | end
46 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Contribution Guidelines #
 2 | 
 3 | ## Submitting a new issue ##
 4 | 
 5 | If you need to open a new issue you *must* provide the following:
 6 | 
 7 | 1. Version of ClientSideValidations
 8 | 2. Version of Rails
 9 | 3. Code snippet from your model of the validations
10 | 4. The form code from your template
11 | 5. The resulting HTML
12 | 
13 | Failure to include the above mentioned requirements will result in the
14 | issue being closed.
15 | 
16 | If you want to ensure that your issue gets fixed *fast* you should
17 | attempt to reproduce the issue in an isolated example application that
18 | you can share.
19 | 
20 | ## Making a pull request ##
21 | 
22 | If you'd like to submit a pull request please adhere to the following:
23 | 
24 | 1. Your code *must* be tested.
25 | 2. Make sure that `bundle exec rake test:all` pass
26 | 
27 | Please note that you must adhere to each of the above mentioned rules.
28 | Failure to do so will result in an immediate closing of the pull
29 | request. If you update and rebase the pull request to follow the
30 | guidelines your pull request will be re-opened and considered for
31 | inclusion.
32 | 
33 | ## Coding standards
34 | 
35 | ### Ruby
36 | 
37 | - [Ruby Styleguide](https://github.com/rubocop/ruby-style-guide)
38 | 
39 | ### Commits
40 | 
41 | - [How to Write a Git Commit Message](https://cbea.ms/git-commit/#seven-rules)
42 | 
43 | ## License
44 | 
45 | By contributing your code, you agree to license your contribution under the terms of the [MIT License](LICENSE)
46 | 


--------------------------------------------------------------------------------
/client_side_validations.gemspec:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | lib = File.expand_path('lib', __dir__)
 4 | $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 5 | require 'client_side_validations/version'
 6 | 
 7 | Gem::Specification.new do |spec|
 8 |   spec.name        = 'client_side_validations'
 9 |   spec.version     = ClientSideValidations::VERSION
10 |   spec.authors     = ['Geremia Taglialatela', 'Brian Cardarella']
11 |   spec.email       = ['tagliala.dev@gmail.com', 'bcardarella@gmail.com']
12 | 
13 |   spec.summary     = 'Client Side Validations'
14 |   spec.description = 'Client Side Validations made easy for your Rails 6.1, 7.x, and 8.0 applications'
15 |   spec.homepage    = 'https://github.com/DavyJonesLocker/client_side_validations'
16 |   spec.license     = 'MIT'
17 | 
18 |   spec.metadata['rubygems_mfa_required'] = 'true'
19 | 
20 |   spec.metadata['bug_tracker_uri'] = 'https://github.com/DavyJonesLocker/client_side_validations/issues'
21 |   spec.metadata['changelog_uri']   = 'https://github.com/DavyJonesLocker/client_side_validations/blob/main/CHANGELOG.md'
22 |   spec.metadata['source_code_uri'] = 'https://github.com/DavyJonesLocker/client_side_validations'
23 | 
24 |   spec.files         = Dir.glob('{CHANGELOG.md,LICENSE.md,README.md,lib/**/*.rb,vendor/**/*.js}', File::FNM_DOTMATCH)
25 |   spec.require_paths = ['lib']
26 | 
27 |   spec.platform              = Gem::Platform::RUBY
28 |   spec.required_ruby_version = '>= 3.1'
29 | 
30 |   spec.add_dependency 'js_regex', '~> 3.7'
31 |   spec.add_dependency 'rails', '>= 6.1'
32 | end
33 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_record/uniqueness.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module ClientSideValidations
 4 |   module ActiveRecord
 5 |     module Uniqueness
 6 |       def client_side_hash(model, attribute, _force = nil)
 7 |         hash = {}
 8 |         hash[:message]        = model.errors.generate_message(attribute, message_type, options.except(:scope))
 9 |         hash[:case_sensitive] = true if options[:case_sensitive]
10 |         hash[:id]             = model.id unless model.new_record?
11 |         hash[:allow_blank]    = true if options[:allow_nil] || options[:allow_blank]
12 | 
13 |         apply_class_option! hash, model
14 |         apply_scope_option! hash, model
15 | 
16 |         hash
17 |       end
18 | 
19 |       private
20 | 
21 |       def apply_class_option!(hash, model)
22 |         if options.key?(:client_validations) && options[:client_validations].key?(:class)
23 |           hash[:class] = options[:client_validations][:class].underscore
24 |         elsif model.class.name.demodulize != model.class.name
25 |           hash[:class] = model.class.name.underscore
26 |         end
27 |       end
28 | 
29 |       def apply_scope_option!(hash, model)
30 |         return unless options.key?(:scope) && options[:scope].present?
31 | 
32 |         hash[:scope] = Array.wrap(options[:scope]).inject({}) do |scope_hash, scope_item|
33 |           scope_hash.merge!(scope_item => model.send(scope_item))
34 |         end
35 |       end
36 | 
37 |       def message_type
38 |         :taken
39 |       end
40 |     end
41 |   end
42 | end
43 | 


--------------------------------------------------------------------------------
/rollup.config.mjs:
--------------------------------------------------------------------------------
 1 | import babel from '@rollup/plugin-babel'
 2 | import copy from 'rollup-plugin-copy'
 3 | import resolve from '@rollup/plugin-node-resolve'
 4 | 
 5 | import { createRequire } from 'node:module'
 6 | 
 7 | const require = createRequire(import.meta.url)
 8 | const pkg = require('./package.json')
 9 | 
10 | const year = new Date().getFullYear()
11 | 
12 | const banner = `/*!
13 |  * Client Side Validations JS - v${pkg.version} (https://github.com/DavyJonesLocker/client_side_validations)
14 |  * Copyright (c) ${year} Geremia Taglialatela, Brian Cardarella
15 |  * Licensed under MIT (https://opensource.org/licenses/mit-license.php)
16 |  */
17 | `
18 | 
19 | export default [
20 |   {
21 |     input: 'src/index.js',
22 |     external: ['jquery'],
23 |     output: [
24 |       {
25 |         file: pkg.main,
26 |         banner,
27 |         format: 'umd',
28 |         name: 'ClientSideValidations',
29 |         globals: {
30 |           jquery: 'jQuery'
31 |         }
32 |       }
33 |     ],
34 |     plugins: [
35 |       resolve(),
36 |       babel({ babelHelpers: 'bundled' }),
37 |       copy({
38 |         targets: [
39 |           { src: pkg.main, dest: 'vendor/assets/javascripts/', rename: 'rails.validations.js' }
40 |         ],
41 |         hook: 'writeBundle',
42 |         verbose: true
43 |       })
44 |     ]
45 |   },
46 | 
47 |   {
48 |     input: 'src/index.js',
49 |     external: ['jquery'],
50 |     output: [
51 |       {
52 |         file: pkg.module,
53 |         banner,
54 |         format: 'es'
55 |       }
56 |     ],
57 |     plugins: [
58 |       babel({ babelHelpers: 'bundled' })
59 |     ]
60 |   }
61 | ]
62 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_exclusion_validator.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'active_model/cases/test_base'
 4 | 
 5 | module ActiveModel
 6 |   class ExclusionValidatorTest < ClientSideValidations::ActiveModelTestBase
 7 |     def test_exclusion_client_side_hash
 8 |       expected_hash = { message: 'is reserved', in: [1, 2] }
 9 | 
10 |       assert_equal expected_hash, ExclusionValidator.new(attributes: [:name], in: [1, 2]).client_side_hash(@person, :age)
11 |     end
12 | 
13 |     def test_exclusion_client_side_hash_with_custom_message
14 |       expected_hash = { message: 'is exclusive', in: [1, 2] }
15 | 
16 |       assert_equal expected_hash, ExclusionValidator.new(attributes: [:name], in: [1, 2], message: 'is exclusive').client_side_hash(@person, :age)
17 |     end
18 | 
19 |     def test_exclusion_client_side_hash_with_ranges
20 |       expected_hash = { message: 'is reserved', range: 1..2 }
21 | 
22 |       assert_equal expected_hash, ExclusionValidator.new(attributes: [:name], in: 1..2).client_side_hash(@person, :age)
23 |     end
24 | 
25 |     def test_exclusion_client_side_hash_ignore_proc
26 |       @person.stubs(:range).returns([1, 2])
27 | 
28 |       assert_nil ExclusionValidator.new(attributes: [:name], in: proc { |o| o.range }).client_side_hash(@person, :age)
29 |     end
30 | 
31 |     def test_exclusion_client_side_hash_observe_proc
32 |       @person.stubs(:range).returns([1, 2])
33 |       expected_hash = { message: 'is reserved', in: [1, 2] }
34 | 
35 |       assert_equal expected_hash, ExclusionValidator.new(attributes: [:name], in: proc { |o| o.range }).client_side_hash(@person, :age, true)
36 |     end
37 |   end
38 | end
39 | 


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


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


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


--------------------------------------------------------------------------------
/test/active_model/cases/test_inclusion_validator.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'active_model/cases/test_base'
 4 | 
 5 | module ActiveModel
 6 |   class InclusionValidatorTest < ClientSideValidations::ActiveModelTestBase
 7 |     def test_inclusion_client_side_hash
 8 |       expected_hash = { message: 'is not included in the list', in: [1, 2] }
 9 | 
10 |       assert_equal expected_hash, InclusionValidator.new(attributes: [:name], in: [1, 2]).client_side_hash(@person, :age)
11 |     end
12 | 
13 |     def test_inclusion_client_side_hash_with_custom_message
14 |       expected_hash = { message: 'is not a choice', in: [1, 2] }
15 | 
16 |       assert_equal expected_hash, InclusionValidator.new(attributes: [:name], in: [1, 2], message: 'is not a choice').client_side_hash(@person, :age)
17 |     end
18 | 
19 |     def test_inclusion_client_side_hash_with_range
20 |       expected_hash = { message: 'is not included in the list', range: 1..2 }
21 | 
22 |       assert_equal expected_hash, InclusionValidator.new(attributes: [:name], in: 1..2).client_side_hash(@person, :age)
23 |     end
24 | 
25 |     def test_inclusion_client_side_hash_ignore_proc
26 |       @person.stubs(:range).returns([1, 2])
27 | 
28 |       assert_nil InclusionValidator.new(attributes: [:name], in: proc { |o| o.range }).client_side_hash(@person, :age)
29 |     end
30 | 
31 |     def test_inclusion_client_side_hash_observe_proc
32 |       @person.stubs(:range).returns([1, 2])
33 |       expected_hash = { message: 'is not included in the list', in: [1, 2] }
34 | 
35 |       assert_equal expected_hash, InclusionValidator.new(attributes: [:name], in: proc { |o| o.range }).client_side_hash(@person, :age, true)
36 |     end
37 |   end
38 | end
39 | 


--------------------------------------------------------------------------------
/test/base_helper.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | # Configure Rails Environment
 4 | ENV['RAILS_ENV'] = 'test'
 5 | 
 6 | require 'simplecov'
 7 | 
 8 | SimpleCov.start 'rails' do
 9 |   if ENV['CI']
10 |     require 'simplecov-lcov'
11 | 
12 |     SimpleCov::Formatter::LcovFormatter.config do |c|
13 |       c.report_with_single_file = true
14 |       c.single_report_path = 'coverage/lcov.info'
15 |     end
16 | 
17 |     formatter SimpleCov::Formatter::LcovFormatter
18 |   end
19 | 
20 |   add_filter %w[version.rb initializer.rb]
21 | end
22 | 
23 | require 'rubygems'
24 | require 'minitest/autorun'
25 | require 'byebug'
26 | require 'mocha/minitest'
27 | 
28 | require 'rails'
29 | require 'active_model/railtie'
30 | require 'active_record/railtie'
31 | require 'action_view/railtie'
32 | require 'rails/test_unit/railtie'
33 | 
34 | require 'client_side_validations/config'
35 | 
36 | ENV['DATABASE_URL'] = "#{defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'}::memory:"
37 | 
38 | module TestApp
39 |   class Application < Rails::Application
40 |     config.try :load_defaults, "#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}"
41 | 
42 |     config.root = __dir__
43 |     config.active_support.deprecation = :log
44 |     config.active_support.test_order = :random
45 |     config.eager_load = false
46 |     config.secret_key_base = '42'
47 |     I18n.enforce_available_locales = true
48 |   end
49 | end
50 | 
51 | Rails.application.initialize!
52 | 
53 | class CustomValidationValidator < ActiveModel::EachValidator
54 |   def validate_each(record, attribute, value)
55 |     return if value.blank?
56 | 
57 |     record.errors.add(attribute, :invalid, **options)
58 |   end
59 | end
60 | 
61 | module ClientSideValidations; end
62 | 


--------------------------------------------------------------------------------
/.rubocop.yml:
--------------------------------------------------------------------------------
 1 | plugins:
 2 |   - rubocop-minitest
 3 |   - rubocop-packaging
 4 |   - rubocop-performance
 5 |   - rubocop-rails
 6 |   - rubocop-rake
 7 | 
 8 | AllCops:
 9 |   TargetRailsVersion: 6.1
10 |   TargetRubyVersion: 3.1
11 |   NewCops: enable
12 |   DisplayStyleGuide: true
13 |   ExtraDetails: true
14 |   Exclude:
15 |     - .git/**/*
16 |     - gemfiles/**/*
17 |     - node_modules/**/*
18 |     - test/generators/tmp/**/*
19 |     - tmp/**/*
20 |     - vendor/**/*
21 | 
22 | Layout/HashAlignment:
23 |   EnforcedColonStyle: table
24 |   EnforcedHashRocketStyle: table
25 | 
26 | Layout/LineLength:
27 |   Enabled: false
28 | 
29 | Metrics/AbcSize:
30 |   Max: 21.91
31 | 
32 | Metrics/BlockLength:
33 |   Exclude:
34 |     - '*.gemspec'
35 |     - 'Rakefile'
36 |     - 'test/**/*'
37 | 
38 | Metrics/ClassLength:
39 |   Exclude:
40 |     - 'test/**/*'
41 | 
42 | Metrics/CyclomaticComplexity:
43 |   Exclude:
44 |     - 'test/**/*'
45 | 
46 | Metrics/MethodLength:
47 |   Max: 16
48 |   Exclude:
49 |     - 'test/**/*'
50 | 
51 | Metrics/ModuleLength:
52 |   Max: 109
53 |   Exclude:
54 |     - 'test/**/*'
55 | 
56 | Metrics/ParameterLists:
57 |   Max: 8
58 |   Exclude:
59 |     - 'test/**/*'
60 | 
61 | Metrics/PerceivedComplexity:
62 |   Exclude:
63 |     - 'test/**/*'
64 | 
65 | Minitest/MultipleAssertions:
66 |   Enabled: false
67 | 
68 | Rails/ApplicationRecord:
69 |   Exclude:
70 |     - 'test/**/*'
71 | 
72 | Rails/Pluck:
73 |   Enabled: false
74 | 
75 | Rails/RakeEnvironment:
76 |   Enabled: false
77 | 
78 | Style/ClassVars:
79 |   Enabled: false
80 | 
81 | Style/Documentation:
82 |   Enabled: false
83 | 
84 | Style/FormatStringToken:
85 |   Exclude:
86 |     - 'test/**/*'
87 | 
88 | Style/IfUnlessModifier:
89 |   Enabled: false
90 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model/numericality.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module ClientSideValidations
 4 |   module ActiveModel
 5 |     module Numericality
 6 |       @@option_map = {}
 7 | 
 8 |       def self.included(base)
 9 |         checks = base::RESERVED_OPTIONS - [:only_integer]
10 | 
11 |         @@option_map.merge!(checks.inject({}) { |acc, elem| acc.merge!(elem => elem) })
12 |         super
13 |       end
14 | 
15 |       def client_side_hash(model, attribute, force = nil)
16 |         options = self.options.dup
17 |         hash    = options_hash(model, attribute, options)
18 | 
19 |         @@option_map.each do |option, message_type|
20 |           count = options[option]
21 |           next unless count
22 | 
23 |           if count.respond_to?(:call)
24 |             next unless force
25 | 
26 |             count = count.call(model)
27 |           end
28 | 
29 |           hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(count: count))
30 |           hash[option] = count
31 |         end
32 | 
33 |         copy_conditional_attributes(hash, options)
34 | 
35 |         hash
36 |       end
37 | 
38 |       private
39 | 
40 |       def options_hash(model, attribute, options)
41 |         hash = { messages: { numericality: model.errors.generate_message(attribute, :not_a_number, options) } }
42 | 
43 |         if options[:only_integer]
44 |           hash[:messages][:only_integer] = model.errors.generate_message(attribute, :not_an_integer, options)
45 |           hash[:only_integer] = true
46 |         end
47 | 
48 |         hash[:allow_blank] = true if options[:allow_nil] || options[:allow_blank]
49 | 
50 |         hash
51 |       end
52 |     end
53 |   end
54 | end
55 | 


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


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


--------------------------------------------------------------------------------
/lib/client_side_validations/action_view/form_with_helper.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | module ClientSideValidations
 4 |   module ActionView
 5 |     module Helpers
 6 |       module FormHelper
 7 |         def form_with(model: false, scope: nil, url: nil, format: nil, **options, &block)
 8 |           return super unless options[:validate]
 9 | 
10 |           options[:allow_method_names_outside_object] = true
11 |           options[:skip_default_ids] = false
12 | 
13 |           url, model, scope = check_model(url, model, format, scope) if model
14 | 
15 |           if block
16 |             form_tag_with_validators scope, model, options, url, &block
17 |           else
18 |             html_options = html_options_for_form_with(url, model, **options)
19 |             form_tag_html(html_options)
20 |           end
21 |         end
22 | 
23 |         private
24 | 
25 |         def check_model(url, model, format, scope)
26 |           url ||= polymorphic_path(model, format: format)
27 | 
28 |           model   = model.last if model.is_a?(Array)
29 |           scope ||= model_name_from_record_or_class(model).param_key
30 | 
31 |           [url, model, scope]
32 |         end
33 | 
34 |         def form_tag_with_validators(scope, model, options, url, &)
35 |           @validators = {}
36 | 
37 |           builder = instantiate_builder(scope, model, options)
38 |           output  = capture(builder, &)
39 |           options[:multipart] ||= builder.multipart?
40 | 
41 |           build_bound_validators! options
42 | 
43 |           html_options = html_options_for_form_with(url, model, **options)
44 | 
45 |           if model
46 |             html_options[:novalidate] ||= 'novalidate'
47 |             apply_csv_html_options! html_options, options, builder
48 |           end
49 | 
50 |           form_tag_with_body(html_options, output)
51 |         end
52 |       end
53 |     end
54 |   end
55 | end
56 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/format.js:
--------------------------------------------------------------------------------
 1 | QUnit.module('Format options')
 2 | 
 3 | QUnit.test('when matching format', function (assert) {
 4 |   var element = $('<input type="text" />')
 5 |   var options = { message: 'failed validation', 'with': /\d+/ }
 6 |   element.val('123')
 7 |   assert.equal(ClientSideValidations.validators.local.format(element, options), undefined)
 8 | })
 9 | 
10 | QUnit.test('when not matching format', function (assert) {
11 |   var element = $('<input type="text" />')
12 |   var options = { message: 'failed validation', 'with': /\d+/ }
13 |   element.val('abc')
14 |   assert.equal(ClientSideValidations.validators.local.format(element, options), 'failed validation')
15 | })
16 | 
17 | QUnit.test('when allowing blank', function (assert) {
18 |   var element = $('<input type="text" />')
19 |   var options = { message: 'failed validation', 'with': /\d+/, allow_blank: true }
20 |   assert.equal(ClientSideValidations.validators.local.format(element, options), undefined)
21 | })
22 | 
23 | QUnit.test('when not allowing blank', function (assert) {
24 |   var element = $('<input type="text" />')
25 |   var options = { message: 'failed validation', 'with': /\d+/ }
26 |   assert.equal(ClientSideValidations.validators.local.format(element, options), 'failed validation')
27 | })
28 | 
29 | QUnit.test('when using the without option and the Regex is matched', function (assert) {
30 |   var element = $('<input type="text" value="Rock"/>')
31 |   var options = { message: 'failed validation', without: /R/ }
32 |   assert.equal(ClientSideValidations.validators.local.format(element, options), 'failed validation')
33 | })
34 | 
35 | QUnit.test('when using the without option and the Regex is not matched', function (assert) {
36 |   var element = $('<input type="text" value="Lock"/>')
37 |   var options = { message: 'failed validation', without: /R/ }
38 |   assert.equal(ClientSideValidations.validators.local.format(element, options), undefined)
39 | })
40 | 


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


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


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


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


--------------------------------------------------------------------------------
/test/javascript/server.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'bundler'
 4 | Bundler.setup
 5 | require 'sinatra'
 6 | require 'json'
 7 | require 'byebug'
 8 | 
 9 | disable :logging
10 | 
11 | class AssetPath < Rack::Static
12 |   def call(env)
13 |     path = env['PATH_INFO']
14 | 
15 |     if can_serve(path)
16 |       env['PATH_INFO'] = (path == '/' ? @index : @urls[path]) if overwrite_file_path(path)
17 |       response = @file_server.call(env)
18 |       if response.first == 404
19 |         @app.call(env)
20 |       else
21 |         response
22 |       end
23 |     else
24 |       @app.call(env)
25 |     end
26 |   end
27 | end
28 | 
29 | use AssetPath, urls: ['/vendor/assets/javascripts'], root: File.expand_path('../..', settings.root)
30 | use AssetPath, urls: ['/vendor/assets/javascripts'], root: File.expand_path('../', $LOAD_PATH.find { |p| p.include?('jquery-rails') })
31 | 
32 | DEFAULT_JQUERY_VERSION = '3.7.1'
33 | QUNIT_VERSION          = '2.24.3'
34 | 
35 | helpers do
36 |   def jquery_version
37 |     params[:jquery] || DEFAULT_JQUERY_VERSION
38 |   end
39 | 
40 |   def qunit_version
41 |     QUNIT_VERSION
42 |   end
43 | 
44 |   def script_tag(src)
45 |     src = "/test/#{src}.js" unless src.index('/')
46 |     %(<script src='#{src}' type='text/javascript'></script>)
47 |   end
48 | 
49 |   def test(*types)
50 |     types.map do |type|
51 |       Dir.glob(File.expand_path("public/test/#{type}/*.js", settings.root)).map { |file| File.basename(file) }.map do |file|
52 |         script_tag "/test/#{type}/#{file}"
53 |       end.join("\n")
54 |     end.join("\n")
55 |   end
56 | end
57 | 
58 | get '/' do
59 |   erb :index
60 | end
61 | 
62 | post '/users' do
63 |   data = { params: params }.update(request.env)
64 |   payload = data.to_json.gsub('<', '&lt;').gsub('>', '&gt;')
65 |   <<-HTML
66 |     <script>
67 |       if (window.top && window.top !== window)
68 |         window.top.jQuery.event.trigger('iframe:loaded', #{payload})
69 |     </script>
70 |     <p id="response">Form submitted</p>
71 |   HTML
72 | end
73 | 
74 | get '/favicon.ico' do
75 |   halt 200
76 | end
77 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@client-side-validations/client-side-validations",
 3 |   "description": "Client Side Validations made easy for your Rails 6.1, 7.x, and 8.0 applications",
 4 |   "repository": {
 5 |     "type": "git",
 6 |     "url": "git+https://github.com/DavyJonesLocker/client_side_validations.git"
 7 |   },
 8 |   "keywords": [
 9 |     "rails",
10 |     "browser",
11 |     "client side validations"
12 |   ],
13 |   "author": "Geremia Taglialatela <tagliala.dev@gmail.com>",
14 |   "contributors": [],
15 |   "license": "MIT",
16 |   "bugs": {
17 |     "url": "https://github.com/DavyJonesLocker/client_side_validations/issues"
18 |   },
19 |   "homepage": "https://github.com/DavyJonesLocker/client_side_validations",
20 |   "scripts": {
21 |     "build": "rollup -c",
22 |     "test": "test/javascript/run-qunit.mjs"
23 |   },
24 |   "devDependencies": {
25 |     "@babel/core": "^7.28.5",
26 |     "@babel/preset-env": "^7.28.5",
27 |     "@rollup/plugin-babel": "^6.1.0",
28 |     "@rollup/plugin-node-resolve": "^16.0.3",
29 |     "chrome-launcher": "^1.2.1",
30 |     "eslint": "^9.39.1",
31 |     "eslint-plugin-compat": "^6.0.2",
32 |     "neostandard": "^0.12.2",
33 |     "puppeteer-core": "^24.32.1",
34 |     "rollup": "^4.53.3",
35 |     "rollup-plugin-copy": "^3.5.0"
36 |   },
37 |   "peerDependencies": {
38 |     "jquery": "^3.7.1"
39 |   },
40 |   "main": "dist/client-side-validations.js",
41 |   "module": "dist/client-side-validations.esm.js",
42 |   "engines": {
43 |     "node": ">= 18.12"
44 |   },
45 |   "packageManager": "pnpm@10.10.0",
46 |   "browserslist": [
47 |     ">= 0.5%",
48 |     "last 2 major versions",
49 |     "not dead",
50 |     "Chrome >= 60",
51 |     "Firefox >= 60",
52 |     "Firefox ESR",
53 |     "iOS >= 12",
54 |     "Safari >= 12"
55 |   ],
56 |   "files": [
57 |     "dist",
58 |     "src/**/*.js"
59 |   ],
60 |   "standard": {
61 |     "ignore": [
62 |       "/dist/",
63 |       "/gemfiles/",
64 |       "/test/",
65 |       "/vendor/"
66 |     ]
67 |   },
68 |   "version": "0.5.0",
69 |   "directories": {
70 |     "lib": "lib",
71 |     "test": "test"
72 |   }
73 | }
74 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/confirmation.js:
--------------------------------------------------------------------------------
 1 | QUnit.module('Confirmation options', {
 2 |   beforeEach: function () {
 3 |     $('#qunit-fixture')
 4 |       .append('<input id="password" type="password" autocomplete="new-password" />')
 5 |       .append('<input id="password_confirmation" type="password" />')
 6 |       .append('<input id="username" type="text" />')
 7 |       .append('<input id="username_confirmation" type="text" />')
 8 |   }
 9 | })
10 | 
11 | QUnit.test('when values match (case sensitive)', function (assert) {
12 |   var passwordElement = $('#password')
13 |   var passwordConfirmationElement = $('#password_confirmation')
14 |   var options = { message: 'failed validation' }
15 |   passwordElement.val('test')
16 |   passwordConfirmationElement.val('test')
17 |   assert.equal(ClientSideValidations.validators.local.confirmation(passwordElement, options), undefined)
18 | })
19 | 
20 | QUnit.test('when values do not match', function (assert) {
21 |   var passwordElement = $('#password')
22 |   var passwordConfirmationElement = $('#password_confirmation')
23 |   var options = { message: 'failed validation' }
24 |   passwordElement.val('test')
25 |   passwordConfirmationElement.val('bad test')
26 |   assert.equal(ClientSideValidations.validators.local.confirmation(passwordElement, options), 'failed validation')
27 | })
28 | 
29 | QUnit.test('when values match (case insensitive)', function (assert) {
30 |   var usernameElement = $('#username')
31 |   var usernameConfirmationElement = $('#username_confirmation')
32 |   var options = { message: 'failed validation' }
33 |   usernameElement.val('tEsT')
34 |   usernameConfirmationElement.val('test')
35 |   assert.equal(ClientSideValidations.validators.local.confirmation(usernameElement, options), undefined)
36 | })
37 | 
38 | QUnit.test('when values contain special characters', function (assert) {
39 |   var usernameElement = $('#username')
40 |   var usernameConfirmationElement = $('#username_confirmation')
41 |   var options = { message: 'failed validation' }
42 |   usernameElement.val('te+st')
43 |   usernameConfirmationElement.val('te+st')
44 |   assert.equal(ClientSideValidations.validators.local.confirmation(usernameElement, options), undefined)
45 | })
46 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_format_validator.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'active_model/cases/test_base'
 4 | 
 5 | module ActiveModel
 6 |   class FormatValidatorTest < ClientSideValidations::ActiveModelTestBase
 7 |     def test_format_client_side_hash
 8 |       expected_hash = { message: 'is invalid', with: /.+/ }
 9 | 
10 |       assert_equal expected_hash, FormatValidator.new(attributes: [:name], with: /.+/).client_side_hash(@person, :age)
11 |     end
12 | 
13 |     def test_format_client_side_hash_without
14 |       expected_hash = { message: 'is invalid', without: /.+/ }
15 | 
16 |       assert_equal expected_hash, FormatValidator.new(attributes: [:name], without: /.+/).client_side_hash(@person, :age)
17 |     end
18 | 
19 |     def test_format_client_side_hash_with_custom_message
20 |       expected_hash = { message: 'is wrong format', with: /.+/ }
21 | 
22 |       assert_equal expected_hash, FormatValidator.new(attributes: [:name], with: /.+/, message: 'is wrong format').client_side_hash(@person, :age)
23 |     end
24 | 
25 |     def test_format_client_side_hash_ignore_proc
26 |       @person.stubs(:matcher).returns(/.+/)
27 | 
28 |       assert_nil FormatValidator.new(attributes: [:name], with: proc { |o| o.matcher }).client_side_hash(@person, :age)
29 |     end
30 | 
31 |     def test_format_client_side_hash_without_ignore_proc
32 |       @person.stubs(:matcher).returns(/.+/)
33 | 
34 |       assert_nil FormatValidator.new(attributes: [:name], without: proc { |o| o.matcher }).client_side_hash(@person, :age)
35 |     end
36 | 
37 |     def test_format_client_side_hash_observe_proc
38 |       @person.stubs(:matcher).returns(/.+/)
39 |       expected_hash = { message: 'is invalid', with: /.+/ }
40 | 
41 |       assert_equal expected_hash, FormatValidator.new(attributes: [:name], with: proc { |o| o.matcher }).client_side_hash(@person, :age, true)
42 |     end
43 | 
44 |     def test_format_client_side_hash_without_observe_proc
45 |       @person.stubs(:matcher).returns(/.+/)
46 |       expected_hash = { message: 'is invalid', without: /.+/ }
47 | 
48 |       assert_equal expected_hash, FormatValidator.new(attributes: [:name], without: proc { |o| o.matcher }).client_side_hash(@person, :age, true)
49 |     end
50 |   end
51 | end
52 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/absence.js:
--------------------------------------------------------------------------------
 1 | QUnit.module('Absence options')
 2 | 
 3 | QUnit.test('when value is not empty', function (assert) {
 4 |   var element = $('<input type="text" />')
 5 |   var options = { message: 'failed validation' }
 6 |   element.val('not empty')
 7 |   assert.equal(ClientSideValidations.validators.local.absence(element, options), 'failed validation')
 8 | })
 9 | 
10 | QUnit.test('when value is only spaces', function (assert) {
11 |   var element = $('<input type="text" />')
12 |   var options = { message: 'failed validation' }
13 |   element.val('   ')
14 |   assert.equal(ClientSideValidations.validators.local.absence(element, options), undefined)
15 | })
16 | 
17 | QUnit.test('when value is empty', function (assert) {
18 |   var element = $('<input type="text" />')
19 |   var options = { message: 'failed validation' }
20 |   assert.equal(ClientSideValidations.validators.local.absence(element, options), undefined)
21 | })
22 | 
23 | QUnit.test('when value is null from non-selected multi-select element', function (assert) {
24 |   var element = $('<select multiple="multiple">')
25 |   var options = { message: 'failed validation' }
26 |   assert.equal(ClientSideValidations.validators.local.absence(element, options), undefined)
27 | })
28 | 
29 | QUnit.test('when value is not null from multi-select element', function (assert) {
30 |   var element = $('<select multiple="multiple">')
31 |   var options = { message: 'failed validation' }
32 |   element.append('<option value="selected-option">Option</option>')
33 |   element.val('selected-option')
34 |   assert.equal(ClientSideValidations.validators.local.absence(element, options), 'failed validation')
35 | })
36 | 
37 | QUnit.test('when value is null from select element', function (assert) {
38 |   var element = $('<select>')
39 |   var options = { message: 'failed validation' }
40 |   assert.equal(ClientSideValidations.validators.local.absence(element, options), undefined)
41 | })
42 | 
43 | QUnit.test('when value is not null from select element', function (assert) {
44 |   var element = $('<select>')
45 |   var options = { message: 'failed validation' }
46 |   element.append('<option value="selected-option">Option</option>')
47 |   element.val('selected-option')
48 |   assert.equal(ClientSideValidations.validators.local.absence(element, options), 'failed validation')
49 | })
50 | 


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


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


--------------------------------------------------------------------------------
/.github/workflows/ruby.yml:
--------------------------------------------------------------------------------
 1 | name: Ruby tests
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ main ]
 6 |   pull_request:
 7 |     branches: [ main ]
 8 | 
 9 | permissions:
10 |   contents: read
11 | 
12 | jobs:
13 |   test:
14 |     name: Ruby Tests
15 |     runs-on: ubuntu-latest
16 |     strategy:
17 |       matrix:
18 |         ruby-version: ['3.1', '3.2', '3.3', '3.4']
19 |         gemfile: [rails_6.1, rails_7.0, rails_7.1, rails_7.2, rails_8.0]
20 |         channel: ['stable']
21 | 
22 |         include:
23 |           - ruby-version: '3.2'
24 |             gemfile: rails_edge
25 |             channel: 'experimental'
26 |           - ruby-version: '3.3'
27 |             gemfile: rails_edge
28 |             channel: 'experimental'
29 |           - ruby-version: '3.4'
30 |             gemfile: rails_edge
31 |             channel: 'experimental'
32 |           - ruby-version: 'head'
33 |             gemfile: rails_7.1
34 |             channel: 'experimental'
35 |           - ruby-version: 'head'
36 |             gemfile: rails_7.2
37 |             channel: 'experimental'
38 |           - ruby-version: 'head'
39 |             gemfile: rails_8.0
40 |             channel: 'experimental'
41 |           - ruby-version: 'head'
42 |             gemfile: rails_edge
43 |             channel: 'experimental'
44 | 
45 |         exclude:
46 |           - ruby-version: '3.1'
47 |             gemfile: rails_8.0
48 |           - ruby-version: '3.2'
49 |             gemfile: rails_6.1
50 |           - ruby-version: '3.3'
51 |             gemfile: rails_6.1
52 |           - ruby-version: '3.4'
53 |             gemfile: rails_6.1
54 |           - ruby-version: '3.4'
55 |             gemfile: rails_7.0
56 | 
57 |     env:
58 |       BUNDLE_GEMFILE: gemfiles/${{ matrix.gemfile }}.gemfile
59 | 
60 |     continue-on-error: ${{ matrix.channel != 'stable' }}
61 | 
62 |     steps:
63 |     - uses: actions/checkout@v6
64 |     - name: Set up Ruby
65 |       uses: ruby/setup-ruby@v1
66 |       with:
67 |         ruby-version: ${{ matrix.ruby-version }}
68 |         bundler-cache: true
69 |     - name: Run tests
70 |       run: bundle exec rake test:ruby
71 |     - name: Coveralls Parallel
72 |       uses: coverallsapp/github-action@v2
73 |       with:
74 |         github-token: ${{ secrets.github_token }}
75 |         flag-name: run-${{ matrix.ruby-version }}
76 |         parallel: true
77 | 
78 |   coverage:
79 |     name: Coverage
80 |     needs: test
81 |     runs-on: ubuntu-latest
82 |     steps:
83 |     - name: Coveralls Finished
84 |       uses: coverallsapp/github-action@v2
85 |       with:
86 |         github-token: ${{ secrets.github_token }}
87 |         parallel-finished: true
88 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/acceptance.js:
--------------------------------------------------------------------------------
 1 | QUnit.module('Acceptance options')
 2 | 
 3 | QUnit.test('when checkbox and checked', function (assert) {
 4 |   var element = $('<input type="checkbox" />')
 5 |   var options = { message: 'failed validation' }
 6 |   element.prop('checked', true)
 7 |   assert.equal(ClientSideValidations.validators.local.acceptance(element, options), undefined)
 8 | })
 9 | 
10 | QUnit.test('when checkbox and not checked', function (assert) {
11 |   var element = $('<input type="checkbox" />')
12 |   var options = { message: 'failed validation' }
13 |   assert.equal(ClientSideValidations.validators.local.acceptance(element, options), 'failed validation')
14 | })
15 | 
16 | QUnit.test('when text and value default of 1', function (assert) {
17 |   var element = $('<input type="text" />')
18 |   var options = { message: 'failed validation' }
19 |   element.val('1')
20 |   assert.equal(ClientSideValidations.validators.local.acceptance(element, options), undefined)
21 | })
22 | 
23 | QUnit.test('when text and value \'1 and accept value is \'1\'', function (assert) {
24 |   var element = $('<input type="text" />')
25 |   var options = { message: 'failed validation', accept: '1' }
26 |   element.val('1')
27 |   assert.equal(ClientSideValidations.validators.local.acceptance(element, options), undefined)
28 | })
29 | 
30 | QUnit.test('when text and value empty', function (assert) {
31 |   var element = $('<input type="text" />')
32 |   var options = { message: 'failed validation' }
33 |   assert.equal(ClientSideValidations.validators.local.acceptance(element, options), 'failed validation')
34 | })
35 | 
36 | QUnit.test('when text and value \'1\' and accept value is 1', function (assert) {
37 |   var element = $('<input type="text" />')
38 |   var options = { message: 'failed validation', accept: 1 }
39 |   element.val('1')
40 |   assert.equal(ClientSideValidations.validators.local.acceptance(element, options), 'failed validation')
41 | })
42 | 
43 | QUnit.test('when text and value \'yes\' and accept value is [\'yes\', \'y\']', function (assert) {
44 |   var element = $('<input type="text" />')
45 |   var options = { message: 'failed validation', accept: ['yes', 'y'] }
46 |   element.val('yes')
47 |   assert.equal(ClientSideValidations.validators.local.acceptance(element, options), undefined)
48 | })
49 | 
50 | QUnit.test('when text and value \'true\' and accept value is [\'yes\', true]', function (assert) {
51 |   var element = $('<input type="text" />')
52 |   var options = { message: 'failed validation', accept: ['yes', true] }
53 |   element.val('true')
54 |   assert.equal(ClientSideValidations.validators.local.acceptance(element, options), 'failed validation')
55 | })
56 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_length_validator.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'active_model/cases/test_base'
 4 | 
 5 | module ActiveModel
 6 |   class LengthValidatorTest < ClientSideValidations::ActiveModelTestBase
 7 |     def test_length_client_side_hash
 8 |       expected_hash = {
 9 |         messages: {
10 |           is: 'is the wrong length (should be 10 characters)'
11 |         },
12 |         is:       10
13 |       }
14 | 
15 |       assert_equal expected_hash, LengthValidator.new(attributes: [:age], is: 10).client_side_hash(@person, :first_name)
16 |     end
17 | 
18 |     def test_length_client_side_hash_with_allow_nil
19 |       expected_hash = { messages: { is: 'is the wrong length (should be 10 characters)' }, is: 10, allow_blank: true }
20 | 
21 |       assert_equal expected_hash, LengthValidator.new(attributes: [:age], is: 10, allow_nil: true).client_side_hash(@person, :age)
22 |     end
23 | 
24 |     def test_length_client_side_hash_with_custom_message
25 |       expected_hash = {
26 |         messages: {
27 |           is: 'is the wrong length (should be 10 words)'
28 |         },
29 |         is:       10
30 |       }
31 | 
32 |       assert_equal expected_hash, LengthValidator.new(attributes: [:age], is: 10, wrong_length: 'is the wrong length (should be %{count} words)').client_side_hash(@person, :first_name)
33 |     end
34 | 
35 |     def test_length_client_side_hash_with_custom_general_message
36 |       expected_hash = {
37 |         messages: {
38 |           minimum: 'is not the correct length',
39 |           maximum: 'is way too long'
40 |         },
41 |         minimum:  4,
42 |         maximum:  10
43 |       }
44 | 
45 |       assert_equal expected_hash, LengthValidator.new(attributes: [:age], minimum: 4, maximum: 10, message: 'is not the correct length', too_long: 'is way too long').client_side_hash(@person, :first_name)
46 |     end
47 | 
48 |     def test_length_client_side_hash_with_minimum_and_maximum
49 |       expected_hash = {
50 |         messages: {
51 |           minimum: 'is too short (minimum is 5 characters)',
52 |           maximum: 'is too long (maximum is 10 characters)'
53 |         },
54 |         minimum:  5,
55 |         maximum:  10
56 |       }
57 | 
58 |       assert_equal expected_hash, LengthValidator.new(attributes: [:age], minimum: 5, maximum: 10).client_side_hash(@person, :first_name)
59 |     end
60 | 
61 |     def test_length_client_side_hash_with_range
62 |       expected_hash = {
63 |         messages: {
64 |           minimum: 'is too short (minimum is 5 characters)',
65 |           maximum: 'is too long (maximum is 10 characters)'
66 |         },
67 |         minimum:  5,
68 |         maximum:  10
69 |       }
70 | 
71 |       assert_equal expected_hash, LengthValidator.new(attributes: [:age], within: 5..10).client_side_hash(@person, :first_name)
72 |     end
73 |   end
74 | end
75 | 


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


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


--------------------------------------------------------------------------------
/src/validators/local/numericality.js:
--------------------------------------------------------------------------------
  1 | import ClientSideValidations from '../../core'
  2 | import { isValuePresent } from '../../utils'
  3 | 
  4 | const VALIDATIONS = {
  5 |   even: (a) => {
  6 |     return parseInt(a, 10) % 2 === 0
  7 |   },
  8 |   greater_than: (a, b) => {
  9 |     return parseFloat(a) > parseFloat(b)
 10 |   },
 11 |   greater_than_or_equal_to: (a, b) => {
 12 |     return parseFloat(a) >= parseFloat(b)
 13 |   },
 14 |   equal_to: (a, b) => {
 15 |     return parseFloat(a) === parseFloat(b)
 16 |   },
 17 |   less_than: (a, b) => {
 18 |     return parseFloat(a) < parseFloat(b)
 19 |   },
 20 |   less_than_or_equal_to: (a, b) => {
 21 |     return parseFloat(a) <= parseFloat(b)
 22 |   },
 23 |   odd: (a) => {
 24 |     return parseInt(a, 10) % 2 === 1
 25 |   },
 26 |   other_than: (a, b) => {
 27 |     return parseFloat(a) !== parseFloat(b)
 28 |   }
 29 | }
 30 | 
 31 | const formatValue = (element) => {
 32 |   const value = element.value || ''
 33 |   const numberFormat = element.form.ClientSideValidations.settings.number_format
 34 | 
 35 |   return value.trim().replace(new RegExp(`\\${numberFormat.separator}`, 'g'), '.')
 36 | }
 37 | 
 38 | const getOtherValue = (validationOption, form) => {
 39 |   if (!isNaN(parseFloat(validationOption))) {
 40 |     return validationOption
 41 |   }
 42 | 
 43 |   const validationElements = form.querySelectorAll(`[name*="${validationOption}"]`)
 44 | 
 45 |   if (validationElements.length === 1) {
 46 |     const validationElement = validationElements[0]
 47 |     const otherFormattedValue = formatValue(validationElement)
 48 | 
 49 |     if (!isNaN(parseFloat(otherFormattedValue))) {
 50 |       return otherFormattedValue
 51 |     }
 52 |   }
 53 | }
 54 | 
 55 | const isValid = (validationFunction, validationOption, formattedValue, form) => {
 56 |   if (validationFunction.length === 2) {
 57 |     const otherValue = getOtherValue(validationOption, form)
 58 |     return (otherValue == null || otherValue === '') || validationFunction(formattedValue, otherValue)
 59 |   } else {
 60 |     return validationFunction(formattedValue)
 61 |   }
 62 | }
 63 | 
 64 | const runFunctionValidations = (formattedValue, form, options) => {
 65 |   for (const validation in VALIDATIONS) {
 66 |     const validationOption = options[validation]
 67 |     const validationFunction = VALIDATIONS[validation]
 68 | 
 69 |     // Must check for null because this could be 0
 70 |     if (validationOption == null) {
 71 |       continue
 72 |     }
 73 | 
 74 |     if (!isValid(validationFunction, validationOption, formattedValue, form)) {
 75 |       return options.messages[validation]
 76 |     }
 77 |   }
 78 | }
 79 | 
 80 | const runValidations = (formattedValue, form, options) => {
 81 |   if (options.only_integer && !ClientSideValidations.patterns.numericality.only_integer.test(formattedValue)) {
 82 |     return options.messages.only_integer
 83 |   }
 84 | 
 85 |   if (!ClientSideValidations.patterns.numericality.default.test(formattedValue)) {
 86 |     return options.messages.numericality
 87 |   }
 88 | 
 89 |   return runFunctionValidations(formattedValue, form, options)
 90 | }
 91 | 
 92 | export const numericalityLocalValidator = ($element, options) => {
 93 |   const element = $element[0]
 94 |   const value = element.value
 95 | 
 96 |   if (options.allow_blank && !isValuePresent(value)) {
 97 |     return
 98 |   }
 99 | 
100 |   const form = element.form
101 |   const formattedValue = formatValue(element)
102 | 
103 |   return runValidations(formattedValue, form, options)
104 | }
105 | 
106 | export default {
107 |   numericalityLocalValidator
108 | }
109 | 


--------------------------------------------------------------------------------
/test/active_model/cases/test_numericality_validator.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'active_model/cases/test_base'
 4 | 
 5 | module ActiveModel
 6 |   class NumericalityValidatorTest < ClientSideValidations::ActiveModelTestBase
 7 |     def test_numericality_client_side_hash
 8 |       expected_hash = { messages: { numericality: 'is not a number' } }
 9 | 
10 |       assert_equal expected_hash, NumericalityValidator.new(attributes: [:age]).client_side_hash(@person, :age)
11 |     end
12 | 
13 |     def test_numericality_client_side_hash_with_allow_nil
14 |       expected_hash = { messages: { numericality: 'is not a number' }, allow_blank: true }
15 | 
16 |       assert_equal expected_hash, NumericalityValidator.new(attributes: [:age], allow_nil: true).client_side_hash(@person, :age)
17 |     end
18 | 
19 |     def test_numericality_client_side_hash_with_custom_message
20 |       expected_hash = { messages: { numericality: 'bad number' } }
21 | 
22 |       assert_equal expected_hash, NumericalityValidator.new(attributes: [:age], message: 'bad number').client_side_hash(@person, :age)
23 |     end
24 | 
25 |     def test_numericality_client_side_hash_with_options
26 |       expected_hash = {
27 |         messages:                 {
28 |           numericality:             'is not a number',
29 |           only_integer:             'must be an integer',
30 |           greater_than:             'must be greater than 10',
31 |           greater_than_or_equal_to: 'must be greater than or equal to 10',
32 |           equal_to:                 'must be equal to 10',
33 |           less_than:                'must be less than 10',
34 |           less_than_or_equal_to:    'must be less than or equal to 10',
35 |           odd:                      'must be odd',
36 |           even:                     'must be even'
37 |         },
38 |         only_integer:             true,
39 |         greater_than:             10,
40 |         greater_than_or_equal_to: 10,
41 |         equal_to:                 10,
42 |         less_than:                10,
43 |         less_than_or_equal_to:    10,
44 |         odd:                      true,
45 |         even:                     true
46 |       }
47 |       test_hash = NumericalityValidator.new(attributes: [:age],
48 |                                             only_integer: true, greater_than: 10, greater_than_or_equal_to: 10,
49 |                                             equal_to: 10, less_than: 10, less_than_or_equal_to: 10,
50 |                                             odd: true, even: true).client_side_hash(@person, :age)
51 | 
52 |       assert_equal expected_hash, test_hash
53 |     end
54 | 
55 |     def test_numericality_message_always_present
56 |       expected_hash = { messages: { numericality: 'is not a number', only_integer: 'must be an integer' }, only_integer: true }
57 | 
58 |       assert_equal expected_hash, NumericalityValidator.new(attributes: [:age], only_integer: true).client_side_hash(@person, :age)
59 |     end
60 | 
61 |     def test_numericality_client_side_hash_ignore_proc
62 |       @person.stubs(:years).returns(5)
63 |       expected_hash = { messages: { numericality: 'is not a number' } }
64 | 
65 |       assert_equal expected_hash, NumericalityValidator.new(attributes: [:age], equal_to: proc { |o| o.years }).client_side_hash(@person, :age)
66 |     end
67 | 
68 |     def test_numericality_client_side_hash_observe_proc
69 |       @person.stubs(:years).returns(5)
70 |       expected_hash = { messages: { numericality: 'is not a number', equal_to: 'must be equal to 5' }, equal_to: 5 }
71 | 
72 |       assert_equal expected_hash, NumericalityValidator.new(attributes: [:age], equal_to: proc { |o| o.years }).client_side_hash(@person, :age, true)
73 |     end
74 |   end
75 | end
76 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
  1 | # frozen_string_literal: true
  2 | 
  3 | require 'bundler'
  4 | Bundler::GemHelper.install_tasks
  5 | require 'rubocop/rake_task'
  6 | 
  7 | RuboCop::RakeTask.new
  8 | 
  9 | task default: [:rubocop, 'test:ruby']
 10 | 
 11 | require 'rake/testtask'
 12 | namespace :test do
 13 |   desc %(Run all tests)
 14 |   task all: [:rubocop, :lint_javascript, 'test:ruby', 'test:js']
 15 | 
 16 |   desc %(Test Ruby code)
 17 |   Rake::TestTask.new(:ruby) do |test|
 18 |     test.libs << 'lib' << 'test'
 19 |     test.test_files = Dir.glob("#{__dir__}/test/**/test_*.rb")
 20 |     test.warning = false
 21 |   end
 22 | 
 23 |   desc %(Test JavaScript code)
 24 |   task js: ['regenerate_javascript', 'test:server', 'test:qunit']
 25 | 
 26 |   desc %(Starts the test server)
 27 |   task :server do
 28 |     puts "Opening test app at #{test_url} ..."
 29 |     server_command = "bundle exec rackup test/javascript/config.ru -q -p #{test_port}"
 30 | 
 31 |     if ENV['UI']
 32 |       system server_command
 33 |     else
 34 |       @server = fork { exec server_command }
 35 |     end
 36 | 
 37 |     # Give Sinatra some time to start
 38 |     sleep 3
 39 |   end
 40 | 
 41 |   desc %(Starts the test server which reloads everything on each refresh)
 42 |   task :reloadable do
 43 |     exec "bundle exec shotgun test/javascript/config.ru -p #{test_port} --server webrick"
 44 |   end
 45 | 
 46 |   desc %(Starts qunit tests)
 47 |   task :qunit do
 48 |     if ENV['UI']
 49 |       system(*browse_cmd(url))
 50 |     else
 51 |       run_headless_tests
 52 |     end
 53 |   end
 54 | end
 55 | 
 56 | desc %(Lint JavaScript files)
 57 | task :lint_javascript do
 58 |   run_pnpm_script 'eslint'
 59 | end
 60 | 
 61 | desc %(Regenerate JavaScript files)
 62 | task :regenerate_javascript do
 63 |   run_pnpm_script 'build'
 64 | end
 65 | 
 66 | desc %(Commit JavaScript files)
 67 | task :commit_javascript do
 68 |   perform_git_commit
 69 | end
 70 | 
 71 | def perform_git_commit
 72 |   system('git add dist vendor', out: File::NULL, err: File::NULL)
 73 | 
 74 |   if system('git commit -m "Regenerated JavaScript files"', out: File::NULL, err: File::NULL)
 75 |     puts 'Committed changes'
 76 |   else
 77 |     puts 'Nothing to commit'
 78 |   end
 79 | end
 80 | 
 81 | # Returns an array e.g.: ['open', 'http://example.com']
 82 | # rubocop:disable Metrics/CyclomaticComplexity
 83 | def browse_cmd(url)
 84 |   require 'rbconfig'
 85 |   browser = ENV.fetch('BROWSER', nil) ||
 86 |             (RbConfig::CONFIG['host_os'].include?('darwin') && 'open') ||
 87 |             (RbConfig::CONFIG['host_os'] =~ /msdos|mswin|djgpp|mingw|windows/ && 'start') ||
 88 |             %w[xdg-open x-www-browser firefox opera mozilla netscape].find { |comm| which comm }
 89 | 
 90 |   abort('ERROR: no web browser detected') unless browser
 91 |   Array(browser) << url
 92 | end
 93 | # rubocop:enable Metrics/CyclomaticComplexity
 94 | 
 95 | # which('ruby') #=> /usr/bin/ruby
 96 | def which(cmd)
 97 |   exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
 98 |   ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
 99 |     exts.each do |ext|
100 |       exe = "#{path}/#{cmd}#{ext}"
101 |       return exe if File.executable? exe
102 |     end
103 |   end
104 |   nil
105 | end
106 | 
107 | def run_headless_tests
108 |   run_pnpm_script 'test', "#{test_url}?autostart=false" do
109 |     Process.kill 'INT', @server
110 |   end
111 | end
112 | 
113 | def run_pnpm_script(script, options = '')
114 |   require 'English'
115 | 
116 |   system "pnpm #{script} #{options}"
117 |   exit_code = $CHILD_STATUS.exitstatus
118 | 
119 |   yield if block_given?
120 | 
121 |   exit exit_code unless exit_code.zero?
122 | end
123 | 
124 | def test_port
125 |   @test_port ||= 4567
126 | end
127 | 
128 | def test_url
129 |   @test_url ||= "http://localhost:#{test_port}"
130 | end
131 | 
132 | task build: %i[regenerate_javascript commit_javascript]
133 | 


--------------------------------------------------------------------------------
/test/core_ext/cases/test_core_ext.rb:
--------------------------------------------------------------------------------
  1 | # frozen_string_literal: true
  2 | 
  3 | require 'base_helper'
  4 | require 'client_side_validations/core_ext'
  5 | 
  6 | class CoreExtTest < Minitest::Test
  7 |   def test_regexp_replace_uppercase_a_and_uppercase_z
  8 |     test_regexp = /\A\Z/
  9 |     # \Z allows optional newline before end of string
 10 |     expected_regexp = { source: '^(?=\\n?$)', options: '' }
 11 | 
 12 |     assert_equal expected_regexp, test_regexp.as_json
 13 |   end
 14 | 
 15 |   def test_regexp_replace_uppercase_a_and_lowercase_z
 16 |     test_regexp = /\A\z/
 17 |     expected_regexp = { source: '^$', options: '' }
 18 | 
 19 |     assert_equal expected_regexp, test_regexp.as_json
 20 |   end
 21 | 
 22 |   def test_regexp_to_json
 23 |     expected_regexp = { source: '^$', options: '' }
 24 | 
 25 |     assert_equal expected_regexp, /\A\z/.to_json
 26 |   end
 27 | 
 28 |   def test_regexp_in_hash_to_json
 29 |     expected_regexp = { hello: { source: 'world', options: 'i' } }
 30 |     hash = { hello: /world/i }
 31 | 
 32 |     assert_equal expected_regexp.to_json, hash.to_json
 33 |   end
 34 | 
 35 |   def test_regexp_encode_json
 36 |     assert_equal '//', //.encode_json(nil)
 37 |   end
 38 | 
 39 |   def test_regexp_remove_comment
 40 |     expected_regexp = { source: '', options: '' }
 41 | 
 42 |     assert_equal expected_regexp, /(?# comment)/.to_json
 43 |   end
 44 | 
 45 |   def test_regexp_convert_group_options
 46 |     expected_regexp = { source: '(?:something)', options: '' }
 47 | 
 48 |     assert_equal expected_regexp, /(?-mix:something)/.to_json
 49 |   end
 50 | 
 51 |   def test_regexp_as_json_with_options
 52 |     expected_regexp = { source: '', options: 'i' }
 53 | 
 54 |     assert_equal expected_regexp, //i.as_json
 55 |   end
 56 | 
 57 |   def test_range_as_json
 58 |     assert_equal [1, 3], (1..3).as_json
 59 |   end
 60 | 
 61 |   def test_range_to_json
 62 |     assert_equal '[1, 3]', (1..3).to_json
 63 |   end
 64 | 
 65 |   def test_range_as_json_with_floats
 66 |     assert_equal [0.5, 5.5], (0.5..5.5).as_json
 67 |   end
 68 | 
 69 |   def test_multiline_regexp_as_json
 70 |     # A regexp with a line break in it WILL match line breaks in Ruby
 71 |     # if the extended option /x is not set. It WILL also match any
 72 |     # spaces with which the line that follows the line break is indented.
 73 |     test_regexp = /
 74 | /
 75 |     expected_regexp = { source: '\\n', options: '' }
 76 | 
 77 |     assert_equal expected_regexp, test_regexp.as_json
 78 |   end
 79 | 
 80 |   def test_regexp_with_literal_whitespace_as_json
 81 |     # regression test for issue #460
 82 |     test_regexp = / /
 83 |     expected_regexp = { source: ' ', options: '' }
 84 | 
 85 |     assert_equal expected_regexp, test_regexp.as_json
 86 |   end
 87 | 
 88 |   def test_regexp_with_unicode_properties_as_json
 89 |     # regression test for issue #615
 90 |     # The double backslashes are needed by JS' new RegExp() constructor.
 91 |     test_regexp = /\p{ASCII}/
 92 |     expected_regexp = { source: '[\\x00-\\x7F]', options: '' }
 93 | 
 94 |     assert_equal expected_regexp, test_regexp.as_json
 95 |   end
 96 | 
 97 |   def test_extended_mode_regexp_with_escaped_whitespace_as_json
 98 |     # regression test for issue #625
 99 |     test_regexp = /    [\ a]\    /x
100 |     expected_regexp = { source: '[ a] ', options: '' }
101 | 
102 |     assert_equal expected_regexp, test_regexp.as_json
103 |   end
104 | 
105 |   def test_regexp_modifiers_as_json
106 |     # - JS has the same /i option as Ruby, so this should be transferred.
107 |     # - /m in JS has nothing to do with /m in Ruby. Ruby's /m can only be
108 |     #   achieved in JS by modifying the source, not by setting /m.
109 |     assert_equal({ source: '', options: 'i' }, //i.as_json)
110 |     assert_equal({ source: '', options: 'i' }, //im.as_json)
111 |     assert_equal({ source: '', options: 'i' }, //ix.as_json)
112 |     assert_equal({ source: '', options: ''  }, //m.as_json)
113 |     assert_equal({ source: '', options: ''  }, //x.as_json)
114 |   end
115 | end
116 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/validators/uniqueness.js:
--------------------------------------------------------------------------------
  1 | QUnit.module('Uniqueness options', {
  2 |   beforeEach: function () {
  3 |     ClientSideValidations.remote_validators_prefix = undefined
  4 |     dataCsv = {
  5 |       html_settings: {
  6 |         type: 'ActionView::Helpers::FormBuilder',
  7 |         input_tag: '<div class="field_with_errors"><span id="input_tag"></span><label class="message"></label></div>',
  8 |         label_tag: '<div class="field_with_errors"><label id="label_tag"></label></div>'
  9 |       },
 10 |       validators: { 'user[email]': { uniqueness: [{ message: 'must be unique', scope: { name: 'pass' } }] }, presence: [{ message: 'must be present' }] }
 11 |     }
 12 | 
 13 |     $('#qunit-fixture')
 14 |       .append($('<form>', {
 15 |         action: '/users',
 16 |         'data-client-side-validations': JSON.stringify(dataCsv),
 17 |         method: 'post',
 18 |         id: 'new_user'
 19 |       }))
 20 |       .find('form')
 21 |       .append($('<input />', {
 22 |         name: 'user[name]',
 23 |         id: 'user_name',
 24 |         type: 'text'
 25 |       }))
 26 |       .append($('<input />', {
 27 |         name: 'user[email]',
 28 |         id: 'user_email',
 29 |         type: 'text'
 30 |       }))
 31 | 
 32 |     $('form#new_user').validate()
 33 |   }
 34 | })
 35 | 
 36 | QUnit.test('when matching local case-insensitive uniqueness for nested has-many resources', function (assert) {
 37 |   dataCsv = {
 38 |     html_settings: {
 39 |       type: 'ActionView::Helpers::FormBuilder',
 40 |       input_tag: '<div class="field_with_errors"><span id="input_tag"></span><label for="user_name" class="message"></label></div>',
 41 |       label_tag: '<div class="field_with_errors"><label id="label_tag"></label></div>'
 42 |     },
 43 |     validators: { 'user[email]': { uniqueness: [{ message: 'must be unique' }] } }
 44 |   }
 45 | 
 46 |   $('#qunit-fixture')
 47 |     .append($('<form>', {
 48 |       action: '/users',
 49 |       'data-client-side-validations': JSON.stringify(dataCsv),
 50 |       method: 'post',
 51 |       id: 'new_user_2'
 52 |     }))
 53 |     .find('form')
 54 |     .append($('<input />', {
 55 |       name: 'profile[user_attributes][0][email]',
 56 |       id: 'user_0_email'
 57 |     }))
 58 |     .append($('<input />', {
 59 |       name: 'profile[user_attributes][1][email]',
 60 |       id: 'user_1_email'
 61 |     }))
 62 | 
 63 |   $('form#new_user_2').validate()
 64 | 
 65 |   var user0EmailElement = $('#user_0_email')
 66 |   var user1EmailElement = $('#user_1_email')
 67 |   var options = { message: 'must be unique' }
 68 | 
 69 |   user0EmailElement.val('not-locally-unique')
 70 |   user1EmailElement.val('Not-Locally-Unique')
 71 | 
 72 |   assert.equal(ClientSideValidations.validators.local.uniqueness(user1EmailElement, options), 'must be unique')
 73 | })
 74 | 
 75 | QUnit.test('when matching case-sensitive local uniqueness for nested has-many resources', function (assert) {
 76 |   dataCsv = {
 77 |     html_settings: {
 78 |       type: 'ActionView::Helpers::FormBuilder',
 79 |       input_tag: '<div class="field_with_errors"><span id="input_tag"></span><label for="user_name" class="message"></label></div>',
 80 |       label_tag: '<div class="field_with_errors"><label id="label_tag"></label></div>'
 81 |     },
 82 |     validators: { 'user[email]': { uniqueness: [{ message: 'must be unique' }] } }
 83 |   }
 84 | 
 85 |   $('#qunit-fixture')
 86 |     .append($('<form>', {
 87 |       action: '/users',
 88 |       'data-client-side-validations': JSON.stringify(dataCsv),
 89 |       method: 'post',
 90 |       id: 'new_user_3'
 91 |     }))
 92 |     .find('form')
 93 |     .append($('<input />', {
 94 |       name: 'profile[user_attributes][0][email]',
 95 |       id: 'user_0_email'
 96 |     }))
 97 |     .append($('<input />', {
 98 |       name: 'profile[user_attributes][1][email]',
 99 |       id: 'user_1_email'
100 |     }))
101 | 
102 |   $('form#new_user_3').validate()
103 | 
104 |   var user0EmailElement = $('#user_0_email')
105 |   var user1EmailElement = $('#user_1_email')
106 |   var options = { message: 'must be unique', case_sensitive: true }
107 | 
108 |   user0EmailElement.val('locally-unique')
109 |   user1EmailElement.val('Locally-Unique')
110 | 
111 |   assert.equal(ClientSideValidations.validators.local.uniqueness(user1EmailElement, options), undefined)
112 | })
113 | 


--------------------------------------------------------------------------------
/test/active_record/cases/test_uniqueness_validator.rb:
--------------------------------------------------------------------------------
 1 | # frozen_string_literal: true
 2 | 
 3 | require 'active_record/cases/test_base'
 4 | 
 5 | module ActiveRecord
 6 |   class UniquenessValidatorTest < ClientSideValidations::ActiveRecordTestBase
 7 |     def test_uniqueness_client_side_hash
 8 |       expected_hash = { message: 'has already been taken' }
 9 | 
10 |       assert_equal expected_hash, UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name]).client_side_hash(@user, :name)
11 |     end
12 | 
13 |     def test_uniqueness_client_side_hash_allowing_blank
14 |       expected_hash = { message: 'has already been taken', allow_blank: true }
15 | 
16 |       assert_equal expected_hash, UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name], allow_blank: true).client_side_hash(@user, :name)
17 |     end
18 | 
19 |     def test_uniqueness_client_side_hash_allowing_nil
20 |       expected_hash = { message: 'has already been taken', allow_blank: true }
21 | 
22 |       assert_equal expected_hash, UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name], allow_nil: true).client_side_hash(@user, :name)
23 |     end
24 | 
25 |     def test_uniqueness_client_side_hash_case_insensitive
26 |       expected_hash = { message: 'has already been taken' }
27 | 
28 |       assert_equal expected_hash, UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name], case_sensitive: false).client_side_hash(@user, :name)
29 |     end
30 | 
31 |     def test_uniqueness_client_side_hash_case_sensitive
32 |       expected_hash = { message: 'has already been taken', case_sensitive: true }
33 | 
34 |       assert_equal expected_hash, UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name], case_sensitive: true).client_side_hash(@user, :name)
35 |     end
36 | 
37 |     def test_uniqueness_client_side_hash_with_custom_message
38 |       expected_hash = { message: 'is not available' }
39 | 
40 |       assert_equal expected_hash, UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name], message: 'is not available').client_side_hash(@user, :name)
41 |     end
42 | 
43 |     def test_uniqueness_client_side_hash_with_existing_record
44 |       @user.stubs(:new_record?).returns(false)
45 |       @user.stubs(:id).returns(1)
46 |       expected_hash = { message: 'has already been taken', id: 1 }
47 | 
48 |       assert_equal expected_hash, UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name]).client_side_hash(@user, :name)
49 |     end
50 | 
51 |     def test_uniqueness_client_side_hash_with_single_scope_item
52 |       @user.stubs(:age).returns(30)
53 |       @user.stubs(:title).returns('test title')
54 |       expected_hash = { message: 'has already been taken', scope: { title: 'test title' } }
55 |       result_hash = UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name], scope: :title).client_side_hash(@user, :name)
56 | 
57 |       assert_equal expected_hash, result_hash
58 |     end
59 | 
60 |     def test_uniqueness_client_side_hash_with_multiple_scope_items
61 |       @user.stubs(:age).returns(30)
62 |       @user.stubs(:title).returns('test title')
63 |       expected_hash = { message: 'has already been taken', scope: { age: 30, title: 'test title' } }
64 |       result_hash = UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name], scope: %i[age title]).client_side_hash(@user, :name)
65 | 
66 |       assert_equal expected_hash, result_hash
67 |     end
68 | 
69 |     def test_uniqueness_client_side_hash_with_empty_scope_array
70 |       expected_hash = { message: 'has already been taken' }
71 |       result_hash = UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name], scope: []).client_side_hash(@user, :name)
72 | 
73 |       assert_equal expected_hash, result_hash
74 |     end
75 | 
76 |     def test_uniqueness_client_side_hash_when_nested_module
77 |       @user = ActiveRecordTestModule::User2.new
78 |       expected_hash = { message: 'has already been taken', class: 'active_record_test_module/user2' }
79 | 
80 |       assert_equal expected_hash, UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name]).client_side_hash(@user, :name)
81 |     end
82 | 
83 |     def test_uniqueness_client_side_hash_with_class_from_options
84 |       @user = UserForm.new
85 |       expected_hash = { message: 'has already been taken', class: 'user' }
86 | 
87 |       assert_equal expected_hash, UniquenessValidator.new(class: ClientSideValidations::ActiveRecordTestBase, attributes: [:name], client_validations: { class: 'User' }).client_side_hash(@user, :name)
88 |     end
89 |   end
90 | end
91 | 


--------------------------------------------------------------------------------
/test/javascript/run-qunit.mjs:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env node
  2 | 
  3 | // Inspired by David Taylor's qunit puppeteer
  4 | //
  5 | 
  6 | /* global QUnit */
  7 | 
  8 | import * as chromeLauncher from 'chrome-launcher'
  9 | import puppeteer from 'puppeteer-core'
 10 | 
 11 | const args = process.argv.slice(2)
 12 | 
 13 | if (args.length < 1 || args.length > 2) {
 14 |   console.log('Usage: node run-qunit.mjs <URL> <timeout>')
 15 |   process.exit(1)
 16 | }
 17 | 
 18 | const targetURL = args[0]
 19 | const timeout = Number.parseInt(args[1] || 300000, 10)
 20 | 
 21 | export default (async () => {
 22 |   console.log('\nRunning QUnit tests\n')
 23 | 
 24 |   function wait (ms) {
 25 |     return new Promise(resolve => setTimeout(resolve, ms))
 26 |   }
 27 | 
 28 |   let browser
 29 | 
 30 |   try {
 31 |     const chromeExecutablePath = chromeLauncher.Launcher.getInstallations()[0]
 32 |     browser = await puppeteer.launch({ executablePath: chromeExecutablePath, headless: 'new' })
 33 |     const page = await browser.newPage()
 34 | 
 35 |     // Attach to browser console log events, and log to node console
 36 |     await page.on('console', msg => console.log(msg.text()))
 37 | 
 38 |     const moduleErrors = []
 39 |     let testErrors = []
 40 |     let assertionErrors = []
 41 | 
 42 |     await page.exposeFunction('harness_moduleStart', context => {
 43 |       testErrors = []
 44 |       const skippedTests = context.tests.filter(t => t.skip).length
 45 |       if (skippedTests === context.tests.length) {
 46 |         // console.log(`\x1b[4m\x1b[36mSkipping Module: ${context.name}\x1b[0m`)
 47 |       } else {
 48 |         // console.log(`\x1b[4mRunning Module: ${context.name}\x1b[0m`)
 49 |       }
 50 |     })
 51 | 
 52 |     await page.exposeFunction('harness_moduleDone', context => {
 53 |       if (context.failed) {
 54 |         const msg = 'Module Failed: ' + context.name + '\n' + testErrors.join('\n')
 55 |         moduleErrors.push(msg)
 56 |       }
 57 |     })
 58 | 
 59 |     await page.exposeFunction('harness_testDone', context => {
 60 |       if (context.failed) {
 61 |         const msg = '  Test Failed: ' + context.name + assertionErrors.join('    ')
 62 |         testErrors.push(msg)
 63 |         assertionErrors = []
 64 |         process.stdout.write('\x1b[31mF\x1b[0m')
 65 |       } else if (context.skipped) {
 66 |         process.stdout.write('\x1b[33mS\x1b[0m')
 67 |       } else {
 68 |         process.stdout.write('\x1b[32m.\x1b[0m')
 69 |       }
 70 |     })
 71 | 
 72 |     await page.exposeFunction('harness_log', context => {
 73 |       if (context.result) { return } // If success don't log
 74 | 
 75 |       let msg = '\n    Assertion Failed:'
 76 |       if (context.message) {
 77 |         msg += ' ' + context.message
 78 |       }
 79 | 
 80 |       if (context.expected) {
 81 |         msg += '\n      Expected: ' + context.expected + ', Actual: ' + context.actual
 82 |       }
 83 | 
 84 |       assertionErrors.push(msg)
 85 |     })
 86 | 
 87 |     await page.exposeFunction('harness_done', context => {
 88 |       process.stdout.write('\n')
 89 | 
 90 |       if (moduleErrors.length > 0) {
 91 |         for (let idx = 0; idx < moduleErrors.length; idx++) {
 92 |           console.log(moduleErrors[idx])
 93 |         }
 94 |       }
 95 | 
 96 |       const stats = [
 97 |         'Time: ' + context.runtime + 'ms',
 98 |         'Total: ' + context.total,
 99 |         'Passed: ' + context.passed,
100 |         'Failed: ' + context.failed
101 |       ]
102 | 
103 |       console.log(`\n${stats.join(', ')}\n`)
104 | 
105 |       browser.close()
106 | 
107 |       if (context.failed > 0) {
108 |         process.exit(1)
109 |       } else {
110 |         process.exit()
111 |       }
112 |     })
113 | 
114 |     await page.goto(targetURL)
115 | 
116 |     await page.evaluate(() => {
117 |       QUnit.config.testTimeout = 10000
118 | 
119 |       // Cannot pass the window.harness_blah methods directly, because they are
120 |       // automatically defined as async methods, which QUnit does not support
121 |       QUnit.log((context) => { window.harness_log(context) })
122 |       QUnit.moduleStart((context) => { window.harness_moduleStart(context) })
123 |       QUnit.moduleDone((context) => { window.harness_moduleDone(context) })
124 |       QUnit.testDone((context) => { window.harness_testDone(context) })
125 |       QUnit.done((context) => { window.harness_done(context) })
126 | 
127 |       if (Object.keys(QUnit.urlParams).length) {
128 |         console.log('With params: ' + JSON.stringify(QUnit.urlParams) + '\n')
129 |       }
130 | 
131 |       if (!QUnit.config.autostart) {
132 |         QUnit.start()
133 |       }
134 |     })
135 | 
136 |     await wait(timeout)
137 | 
138 |     console.error('\nTests timed out\n')
139 |     await browser.close()
140 |     process.exit(124)
141 |   } catch (error) {
142 |     console.error(`\nERROR: ${error.message}\n`)
143 |   } finally {
144 |     await browser.close()
145 |   }
146 | })()
147 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/action_view/form_helper.rb:
--------------------------------------------------------------------------------
  1 | # frozen_string_literal: true
  2 | 
  3 | module ClientSideValidations
  4 |   module ActionView
  5 |     module Helpers
  6 |       module FormHelper
  7 |         class Error < StandardError
  8 |         end
  9 | 
 10 |         def form_for(record, options = {}, &block)
 11 |           return super unless options[:validate]
 12 | 
 13 |           # We are not going to use super here, because we need
 14 |           # to inject the csv options in a data attribute in a clean way.
 15 |           # So we basically reimplement the whole form_for method
 16 |           raise ArgumentError, 'Missing block' unless block
 17 | 
 18 |           options[:html] ||= {}
 19 | 
 20 |           # Moving the switch statement to another method to
 21 |           # lower complexity
 22 |           model, object_name = check_record(record, options)
 23 | 
 24 |           remote = options.delete(:remote)
 25 | 
 26 |           if remote && !embed_authenticity_token_in_remote_forms && options[:authenticity_token].blank?
 27 |             options[:authenticity_token] = false
 28 |           end
 29 | 
 30 |           options[:model] = model
 31 |           options[:scope] = object_name
 32 |           options[:local] = !remote
 33 |           options[:skip_default_ids] = false
 34 |           options[:allow_method_names_outside_object] = options.fetch(:allow_method_names_outside_object, false)
 35 | 
 36 |           form_with(**options, &block)
 37 |         end
 38 | 
 39 |         def apply_csv_form_for_options!(record, object, options)
 40 |           options[:html][:validate] = true if options[:validate]
 41 |           options[:html][:method] ||= options[:method]
 42 | 
 43 |           # TODO: remove else branch when minimum compatible version when dropping 6.1 support
 44 |           if method(:apply_form_for_options!).arity == 2
 45 |             apply_form_for_options! object, options
 46 |           else
 47 |             apply_form_for_options! record, object, options
 48 |           end
 49 |         end
 50 | 
 51 |         def fields_for(record_name, record_object = nil, options = {}, &)
 52 |           # Order matters here. Rails mutates the `options` object
 53 |           builder = instantiate_builder(record_name, record_object, options)
 54 |           output = capture(builder, &)
 55 | 
 56 |           build_bound_validators! options
 57 | 
 58 |           output
 59 |         end
 60 | 
 61 |         private
 62 | 
 63 |         def check_record(record, options)
 64 |           case record
 65 |           when String, Symbol
 66 |             raise ClientSideValidations::ActionView::Helpers::FormHelper::Error, 'Using form_for(:name, @resource) is not supported with ClientSideValidations. Please use form_for(@resource, as: :name) instead.'
 67 |           else
 68 |             object = record.is_a?(Array) ? record.last : record
 69 |             raise ArgumentError, 'First argument in form cannot contain nil or be empty' unless object
 70 | 
 71 |             object_name = options[:as] || model_name_from_record_or_class(object).param_key
 72 |             apply_csv_form_for_options!(record, object, options)
 73 |           end
 74 | 
 75 |           [record, object_name]
 76 |         end
 77 | 
 78 |         def build_bound_validators!(options)
 79 |           return unless @validators
 80 | 
 81 |           options[:validators].each do |key, value|
 82 |             if @validators.key?(key)
 83 |               @validators[key].merge! value
 84 |             else
 85 |               @validators[key] = value
 86 |             end
 87 |           end
 88 |         end
 89 | 
 90 |         def construct_validators
 91 |           @validators.each_with_object({}) do |object_opts, validator_hash|
 92 |             next unless object_opts[0].respond_to?(:client_side_validation_hash)
 93 | 
 94 |             option_hash = object_opts[1].each_with_object({}) do |attr, result|
 95 |               result[attr[0]] = attr[1][:options]
 96 |             end
 97 | 
 98 |             validation_hash = object_opts[0].client_side_validation_hash(option_hash)
 99 | 
100 |             option_hash.each_key do |attr|
101 |               add_validator validator_hash, validation_hash, object_opts[1][attr][:name], attr
102 |             end
103 |           end
104 |         end
105 | 
106 |         def add_validator(validator_hash, validation_hash, name, attr)
107 |           if validation_hash.key?(attr)
108 |             validator_hash[name] = validation_hash[attr]
109 |           elsif attr.to_s.end_with?('_id')
110 |             association_name = attr.to_s.gsub(/_id\Z/, '').to_sym
111 |             add_validator_with_association validator_hash, validation_hash, name, association_name
112 |           elsif attr.to_s.end_with?('_ids')
113 |             association_name = attr.to_s.gsub(/_ids\Z/, '').pluralize.to_sym
114 |             add_validator_with_association validator_hash, validation_hash, name, association_name
115 |           end
116 |         end
117 | 
118 |         def add_validator_with_association(validator_hash, validation_hash, name, association_name)
119 |           return unless validation_hash.key?(association_name)
120 | 
121 |           validator_hash[name] = validation_hash[association_name]
122 |         end
123 | 
124 |         def number_format
125 |           if ClientSideValidations::Config.number_format_with_locale && defined?(I18n)
126 |             I18n.t('number.format').slice :separator, :delimiter
127 |           else
128 |             { separator: '.', delimiter: ',' }
129 |           end
130 |         end
131 | 
132 |         def apply_csv_html_options!(html_options, options, builder)
133 |           html_options.delete 'validate'
134 | 
135 |           csv_options = {
136 |             html_settings: builder.client_side_form_settings(options, self),
137 |             number_format: number_format,
138 |             validators:    construct_validators
139 |           }
140 | 
141 |           html_options['data-client-side-validations'] = csv_options.to_json
142 |         end
143 |       end
144 |     end
145 |   end
146 | end
147 | 


--------------------------------------------------------------------------------
/test/action_view/cases/test_legacy_form_for_helpers.rb:
--------------------------------------------------------------------------------
  1 | # frozen_string_literal: true
  2 | 
  3 | require 'action_view/cases/helper'
  4 | 
  5 | module ClientSideValidations
  6 |   class LegacyFormForActionViewHelpersTest < ::ActionView::TestCase
  7 |     include ::ActionViewTestSetup
  8 | 
  9 |     BASE_FIELD_HELPERS.each do |field_helper, options|
 10 |       define_method(:"test_#{field_helper}") do
 11 |         form_for(@post) do |f|
 12 |           concat f.public_send(field_helper, :cost)
 13 |         end
 14 | 
 15 |         expected = whole_form_for('/posts', 'new_post', 'new_post') do
 16 |           form_field('input', id: 'post_cost', name: 'post[cost]', type: options[:type], **options.fetch(:html_options, {}))
 17 |         end
 18 | 
 19 |         assert_dom_equal expected, output_buffer
 20 |       end
 21 |     end
 22 | 
 23 |     def test_text_area
 24 |       form_for(@post) do |f|
 25 |         concat f.text_area(:cost)
 26 |       end
 27 | 
 28 |       expected = whole_form_for('/posts', 'new_post', 'new_post') do
 29 |         form_field('textarea', id: 'post_cost', name: 'post[cost]', tag_content: "\n")
 30 |       end
 31 | 
 32 |       assert_dom_equal expected, output_buffer
 33 |     end
 34 | 
 35 |     if ::ActionView::Helpers::FormBuilder.field_helpers.include?(:textarea)
 36 |       def test_textarea
 37 |         form_for(@post) do |f|
 38 |           concat f.textarea(:cost)
 39 |         end
 40 | 
 41 |         expected = whole_form_for('/posts', 'new_post', 'new_post') do
 42 |           form_field('textarea', id: 'post_cost', name: 'post[cost]', tag_content: "\n")
 43 |         end
 44 | 
 45 |         assert_dom_equal expected, output_buffer
 46 |       end
 47 |     end
 48 | 
 49 |     def test_file_field
 50 |       form_for(@post) do |f|
 51 |         concat f.file_field(:cost)
 52 |       end
 53 | 
 54 |       expected = whole_form_for('/posts', 'new_post', 'new_post', file: true) do
 55 |         form_field('input', id: 'post_cost', name: 'post[cost]', type: 'file')
 56 |       end
 57 | 
 58 |       assert_dom_equal expected, output_buffer
 59 |     end
 60 | 
 61 |     def test_check_box
 62 |       form_for(@post) do |f|
 63 |         concat f.check_box(:cost)
 64 |       end
 65 | 
 66 |       expected = whole_form_for('/posts', 'new_post', 'new_post') do
 67 |         hidden_input_for_checkbox('post[cost]') +
 68 |           form_field('input', id: 'post_cost', name: 'post[cost]', type: 'checkbox', value: '1')
 69 |       end
 70 | 
 71 |       assert_dom_equal expected, output_buffer
 72 |     end
 73 | 
 74 |     if ::ActionView::Helpers::FormBuilder.field_helpers.include?(:checkbox)
 75 |       def test_checkbox
 76 |         form_for(@post) do |f|
 77 |           concat f.checkbox(:cost)
 78 |         end
 79 | 
 80 |         expected = whole_form_for('/posts', 'new_post', 'new_post') do
 81 |           hidden_input_for_checkbox('post[cost]') +
 82 |             form_field('input', id: 'post_cost', name: 'post[cost]', type: 'checkbox', value: '1')
 83 |         end
 84 | 
 85 |         assert_dom_equal expected, output_buffer
 86 |       end
 87 |     end
 88 | 
 89 |     def test_radio_button
 90 |       form_for(@post) do |f|
 91 |         concat f.radio_button(:cost, '10')
 92 |       end
 93 | 
 94 |       expected = whole_form_for('/posts', 'new_post', 'new_post') do
 95 |         form_field('input', id: 'post_cost_10', name: 'post[cost]', type: 'radio', value: '10')
 96 |       end
 97 | 
 98 |       assert_dom_equal expected, output_buffer
 99 |     end
100 | 
101 |     def test_fields_for
102 |       result = fields_for(@comment) do |c|
103 |         c.text_field(:title)
104 |       end
105 | 
106 |       expected = form_field('input', id: 'comment_title', name: 'comment[title]', type: 'text')
107 | 
108 |       assert_dom_equal expected, result
109 |     end
110 | 
111 |     def test_select
112 |       form_for(@post) do |f|
113 |         concat f.select(:cost, [])
114 |       end
115 | 
116 |       expected = whole_form_for('/posts', 'new_post', 'new_post') do
117 |         form_field('select', id: 'post_cost', name: 'post[cost]')
118 |       end
119 | 
120 |       assert_dom_equal expected, output_buffer
121 |     end
122 | 
123 |     def test_select_multiple
124 |       form_for(@post) do |f|
125 |         concat f.select(:cost, [], {}, multiple: true)
126 |       end
127 | 
128 |       expected = whole_form_for('/posts', 'new_post', 'new_post') do
129 |         hidden_input('post[cost][]') +
130 |           form_field('select', id: 'post_cost', name: 'post[cost][]', multiple: true)
131 |       end
132 | 
133 |       assert_dom_equal expected, output_buffer
134 |     end
135 | 
136 |     def test_collection_select
137 |       form_for(@post) do |f|
138 |         concat f.collection_select(:cost, [], :id, :name)
139 |       end
140 | 
141 |       expected = whole_form_for('/posts', 'new_post', 'new_post') do
142 |         form_field('select', id: 'post_cost', name: 'post[cost]')
143 |       end
144 | 
145 |       assert_dom_equal expected, output_buffer
146 |     end
147 | 
148 |     def test_grouped_collection_select
149 |       form_for(@post) do |f|
150 |         concat f.grouped_collection_select(:cost, [], :group_method, :group_label_method, :id, :name)
151 |       end
152 | 
153 |       expected = whole_form_for('/posts', 'new_post', 'new_post') do
154 |         form_field('select', id: 'post_cost', name: 'post[cost]')
155 |       end
156 | 
157 |       assert_dom_equal expected, output_buffer
158 |     end
159 | 
160 |     def test_time_zone_select
161 |       zones = mock('TimeZones')
162 |       zones.stubs(:all).returns([])
163 |       form_for(@post) do |f|
164 |         concat f.time_zone_select(:cost, nil, model: zones)
165 |       end
166 | 
167 |       expected = whole_form_for('/posts', 'new_post', 'new_post') do
168 |         form_field('select', id: 'post_cost', name: 'post[cost]')
169 |       end
170 | 
171 |       assert_dom_equal expected, output_buffer
172 |     end
173 | 
174 |     def test_string_as_record
175 |       form_for('post') do |f|
176 |         concat f.text_field(:cost)
177 |       end
178 | 
179 |       expected = whole_form_for('/') do
180 |         form_field('input', id: 'post_cost', name: 'post[cost]', type: 'text')
181 |       end
182 | 
183 |       assert_dom_equal expected, output_buffer
184 |     end
185 | 
186 |     def test_symbol_as_record
187 |       form_for(:post) do |f|
188 |         concat f.text_field(:cost)
189 |       end
190 | 
191 |       expected = whole_form_for('/') do
192 |         form_field('input', id: 'post_cost', name: 'post[cost]', type: 'text')
193 |       end
194 | 
195 |       assert_dom_equal expected, output_buffer
196 |     end
197 |   end
198 | end
199 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/active_model.rb:
--------------------------------------------------------------------------------
  1 | # frozen_string_literal: true
  2 | 
  3 | require_relative 'core_ext'
  4 | require_relative 'extender'
  5 | require_relative 'active_model/conditionals'
  6 | 
  7 | module ClientSideValidations
  8 |   module ActiveModel
  9 |     module Validator
 10 |       def client_side_hash(model, attribute, _force = nil)
 11 |         build_client_side_hash(model, attribute, options.dup)
 12 |       end
 13 | 
 14 |       def copy_conditional_attributes(attribute_to, attribute_from)
 15 |         %i[if unless].each { |key| attribute_to[key] = attribute_from[key] if attribute_from[key].present? }
 16 |       end
 17 | 
 18 |       private
 19 | 
 20 |       def build_client_side_hash(model, attribute, options)
 21 |         # Rails mutates `options` object when calling `model.errors.generate_message`
 22 |         # by removing `message` option, if any.
 23 |         # By raising on missing translations, CSV has the same behavior across
 24 |         # all supported Rails versions and `config.i18n.raise_on_missing_translations`
 25 |         # possible configurations.
 26 |         options[:raise] = true
 27 | 
 28 |         message =
 29 |           begin
 30 |             model.errors.generate_message(attribute, message_type, options)
 31 |           rescue I18n::MissingTranslationData
 32 |             options[:message] = :invalid
 33 |             model.errors.generate_message(attribute, message_type, options)
 34 |           end
 35 | 
 36 |         options.delete(:raise)
 37 | 
 38 |         { message: message }.merge(options.except(*callbacks_options - %i[allow_blank if unless]))
 39 |       end
 40 | 
 41 |       def message_type
 42 |         kind
 43 |       end
 44 | 
 45 |       def callbacks_options
 46 |         ::ActiveModel::Error::CALLBACKS_OPTIONS
 47 |       end
 48 |     end
 49 | 
 50 |     module Validations
 51 |       include ClientSideValidations::ActiveModel::Conditionals
 52 | 
 53 |       ATTRIBUTES_DENYLIST = [nil, :block].freeze
 54 | 
 55 |       def client_side_validation_hash(force = nil)
 56 |         _validators.inject({}) do |attr_hash, attr|
 57 |           next attr_hash if ATTRIBUTES_DENYLIST.include?(attr[0])
 58 | 
 59 |           validator_hash = validator_hash_for(attr, force)
 60 | 
 61 |           if validator_hash.present?
 62 |             attr_hash.merge!(attr[0] => validator_hash)
 63 |           else
 64 |             attr_hash
 65 |           end
 66 |         end
 67 |       end
 68 | 
 69 |       private
 70 | 
 71 |       def validator_hash_for(attr, force)
 72 |         attr[1].each_with_object(Hash.new { |h, k| h[k] = [] }) do |validator, kind_hash|
 73 |           next unless can_use_for_client_side_validation?(attr[0], validator, force)
 74 | 
 75 |           client_side_hash = validator.client_side_hash(self, attr[0], extract_force_option(attr[0], force))
 76 |           if client_side_hash
 77 |             kind_hash[validator.kind] << client_side_hash.except(:on, :if, :unless)
 78 |           end
 79 |         end
 80 |       end
 81 | 
 82 |       def extract_force_option(attr, force)
 83 |         case force
 84 |         when FalseClass, TrueClass, NilClass
 85 |           force
 86 |         when Hash
 87 |           extract_force_option(nil, force[attr])
 88 |         end
 89 |       end
 90 | 
 91 |       def can_use_for_client_side_validation?(attr, validator, force)
 92 |         return false if validator_turned_off?(attr, validator, force)
 93 | 
 94 |         result = check_new_record(validator)
 95 |         result &&= validator.kind != :block
 96 | 
 97 |         if validator.options[:if] || validator.options[:unless]
 98 |           check_conditionals attr, validator, force
 99 |         else
100 |           result
101 |         end
102 |       end
103 | 
104 |       # Yeah yeah, #new_record? is not part of ActiveModel :p
105 |       def check_new_record(validator)
106 |         (respond_to?(:new_record?) && validator.options[:on] == (new_record? ? :create : :update)) || validator.options[:on].nil?
107 |       end
108 | 
109 |       def will_save_change?(options)
110 |         options.is_a?(Symbol) && (options.to_s.end_with?('changed?') || options.to_s.start_with?('will_save_change_to'))
111 |       end
112 | 
113 |       def check_conditionals(attr, validator, force)
114 |         return true if validator.options[:if] && will_save_change?(validator.options[:if])
115 | 
116 |         result = can_force_validator?(attr, validator, force)
117 | 
118 |         if validator.options[:if]
119 |           result &&= run_conditionals(validator.options[:if], :if)
120 |         end
121 | 
122 |         if validator.options[:unless]
123 |           result &&= run_conditionals(validator.options[:unless], :unless)
124 |         end
125 | 
126 |         result
127 |       end
128 | 
129 |       def validator_turned_off?(attr, validator, force)
130 |         return true if ::ClientSideValidations::Config.disabled_validators.include?(validator.kind)
131 | 
132 |         case force
133 |         when FalseClass
134 |           true
135 |         when Hash
136 |           case force[attr]
137 |           when FalseClass
138 |             true
139 |           when Hash
140 |             force[attr][validator.kind] == false
141 |           else
142 |             false
143 |           end
144 |         else
145 |           false
146 |         end
147 |       end
148 | 
149 |       def can_force_validator?(attr, validator, force)
150 |         case force
151 |         when TrueClass
152 |           true
153 |         when Hash
154 |           case force[attr]
155 |           when TrueClass
156 |             true
157 |           when Hash
158 |             force[attr][validator.kind]
159 |           else
160 |             false
161 |           end
162 |         else
163 |           false
164 |         end
165 |       end
166 |     end
167 | 
168 |     module EnumerableValidator
169 |       def client_side_hash(model, attribute, force = nil)
170 |         options = self.options.dup
171 | 
172 |         if options[:in].respond_to?(:call)
173 |           return unless force
174 | 
175 |           options[:in] = options[:in].call(model)
176 |         end
177 | 
178 |         hash = build_client_side_hash(model, attribute, options)
179 | 
180 |         if hash[:in].is_a?(Range)
181 |           hash[:range] = hash[:in]
182 |           hash.delete(:in)
183 |         end
184 | 
185 |         hash
186 |       end
187 |     end
188 |   end
189 | end
190 | 
191 | ActiveModel::Validator.include ClientSideValidations::ActiveModel::Validator
192 | ActiveModel::Validations.include ClientSideValidations::ActiveModel::Validations
193 | 
194 | ClientSideValidations::Extender.extend 'ActiveModel', %w[Absence Acceptance Exclusion Format Inclusion Length Numericality Presence]
195 | 


--------------------------------------------------------------------------------
/lib/client_side_validations/action_view/form_builder.rb:
--------------------------------------------------------------------------------
  1 | # frozen_string_literal: true
  2 | 
  3 | module ClientSideValidations
  4 |   module ActionView
  5 |     module Helpers
  6 |       module FormBuilder
  7 |         def self.prepended(base)
  8 |           selectors = base.field_helpers - %i[label check_box checkbox radio_button fields_for fields hidden_field file_field]
  9 | 
 10 |           selectors.each do |selector|
 11 |             base.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
 12 |               # Cannot call super here, rewrite all
 13 |               def #{selector}(method, options = {})       # def text_field(method, options = {})
 14 |                 build_validation_options(method, options) #   build_validation_options(method, options)
 15 |                 options.delete(:validate)                 #   options.delete(:validate)
 16 |                 @template.send(                           #   @template.send(
 17 |                   #{selector.inspect},                    #     "text_field",
 18 |                   @object_name,                           #     @object_name,
 19 |                   method,                                 #     method,
 20 |                   objectify_options(options))             #     objectify_options(options))
 21 |               end                                         # end
 22 |             RUBY_EVAL
 23 |           end
 24 | 
 25 |           base.class_eval do
 26 |             alias_method :text_area, :textarea if ::ActionView::Helpers::FormBuilder.field_helpers.include?(:textarea)
 27 |           end
 28 |         end
 29 | 
 30 |         def initialize(object_name, object, template, options)
 31 |           super
 32 |           @options[:validators] = { object => {} }
 33 |         end
 34 | 
 35 |         def client_side_form_settings(_options, form_helper)
 36 |           {
 37 |             type:      self.class.name,
 38 |             input_tag: error_field(form_helper, :span, 'input_tag'),
 39 |             label_tag: error_field(form_helper, :label, 'label_tag')
 40 |           }
 41 |         end
 42 | 
 43 |         def validate(*attrs)
 44 |           options = attrs.pop if attrs.last.is_a?(Hash)
 45 |           (attrs.presence || @object._validators.keys).each do |attr|
 46 |             build_validation_options(attr, validate: options)
 47 |           end
 48 |           nil
 49 |         end
 50 | 
 51 |         def check_box(method, options = {}, checked_value = '1', unchecked_value = '0')
 52 |           build_validation_options(method, options)
 53 |           options.delete(:validate)
 54 |           super
 55 |         end
 56 |         alias checkbox check_box if ::ActionView::Helpers::FormBuilder.field_helpers.include?(:checkbox)
 57 | 
 58 |         %i[collection_check_boxes collection_radio_buttons].each do |method_name|
 59 |           define_method method_name do |method, collection, value_method, text_method, options = {}, html_options = {}, &block|
 60 |             build_validation_options(method, html_options.merge(name: options[:name]))
 61 |             html_options.delete(:validate)
 62 |             super(method, collection, value_method, text_method, options, html_options, &block)
 63 |           end
 64 |         end
 65 | 
 66 |         if ::ActionView::Helpers::FormBuilder.public_instance_methods.include?(:collection_checkboxes)
 67 |           alias collection_checkboxes collection_check_boxes
 68 |         end
 69 | 
 70 |         def collection_select(method, collection, value_method, text_method, options = {}, html_options = {})
 71 |           build_validation_options(method, html_options.merge(name: options[:name]))
 72 |           html_options.delete(:validate)
 73 |           super
 74 |         end
 75 | 
 76 |         def fields_for(record_name, record_object = nil, fields_options = {}, &)
 77 |           if record_object.is_a?(Hash) && record_object.extractable_options?
 78 |             fields_options = record_object
 79 |             record_object  = nil
 80 |           end
 81 | 
 82 |           fields_options[:validate] ||= @options[:validate] if @options[:validate] && !fields_options.key?(:validate)
 83 |           super
 84 |         end
 85 | 
 86 |         def fields(scope = nil, model: nil, **options, &block)
 87 |           options[:validate] ||= @options[:validate] if @options[:validate] && !options.key?(:validate)
 88 |           super
 89 |         end
 90 | 
 91 |         def file_field(method, options = {})
 92 |           build_validation_options(method, options)
 93 |           options.delete(:validate)
 94 |           super
 95 |         end
 96 | 
 97 |         def grouped_collection_select(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
 98 |           build_validation_options(method, html_options.merge(name: options[:name]))
 99 |           html_options.delete(:validate)
100 |           super
101 |         end
102 | 
103 |         def radio_button(method, tag_value, options = {})
104 |           build_validation_options(method, options)
105 |           options.delete(:validate)
106 |           super
107 |         end
108 | 
109 |         def select(method, choices = nil, options = {}, html_options = {}, &)
110 |           build_validation_options(method, html_options.merge(name: options[:name]))
111 |           html_options.delete(:validate)
112 |           super
113 |         end
114 | 
115 |         def time_zone_select(method, priority_zones = nil, options = {}, html_options = {})
116 |           build_validation_options(method, html_options.merge(name: options[:name]))
117 |           html_options.delete(:validate)
118 |           super
119 |         end
120 | 
121 |         private
122 | 
123 |         def error_field(form_helper, tag, id)
124 |           form_helper.instance_exec form_helper.content_tag(tag, nil, id: id),
125 |                                     Struct.new(:error_message, :tag_id).new([], ''),
126 |                                     &form_helper.class.field_error_proc
127 |         end
128 | 
129 |         def build_validation_options(method, options = {})
130 |           return unless @options[:validate]
131 | 
132 |           index       = @default_options[:index].present? ? "[#{@default_options[:index]}]" : ''
133 |           child_index = @options[:child_index] ? "(\\d+|#{Regexp.escape(@options[:child_index].to_s)})" : '\\d+'
134 | 
135 |           name = options[:name] || "#{@object_name}#{index}[#{method}]"
136 |           name = name.to_s.gsub(/_attributes\]\[#{child_index}\]/, '_attributes][]')
137 |           name << '[]' if options[:multiple]
138 | 
139 |           @options[:validators][@object][method] = { name: name, options: options[:validate] }
140 |         end
141 |       end
142 |     end
143 |   end
144 | end
145 | 


--------------------------------------------------------------------------------
/test/javascript/public/test/form_builders/validateForm.js:
--------------------------------------------------------------------------------
  1 | QUnit.module('Validate Form', {
  2 |   beforeEach: function () {
  3 |     dataCsv = {
  4 |       html_settings: {
  5 |         type: 'ActionView::Helpers::FormBuilder',
  6 |         input_tag: '<div class="field_with_errors"><span id="input_tag"></span><label for="user_name" class="message"></label></div>',
  7 |         label_tag: '<div class="field_with_errors"><label id="label_tag"></label></div>'
  8 |       },
  9 |       validators: { 'user[name]': { presence: [{ message: 'must be present' }] } }
 10 |     }
 11 | 
 12 |     $('#qunit-fixture')
 13 |       .append($('<form>', {
 14 |         action: '/users',
 15 |         'data-client-side-validations': JSON.stringify(dataCsv),
 16 |         method: 'post',
 17 |         id: 'new_user'
 18 |       }))
 19 |       .find('form')
 20 |       .append($('<input />', {
 21 |         name: 'user[name]',
 22 |         id: 'user_name',
 23 |         type: 'text'
 24 |       }))
 25 |       .append($('<label for="user_name">Name</label>'))
 26 |     $('form#new_user').validate()
 27 |   }
 28 | })
 29 | 
 30 | QUnit.test('Validate form with invalid form (async)', function (assert) {
 31 |   var done = assert.async()
 32 |   var form = $('form#new_user')
 33 |   var input = form.find('input#user_name')
 34 |   var label = $('label[for="user_name"]')
 35 | 
 36 |   form.trigger('submit')
 37 | 
 38 |   setTimeout(function () {
 39 |     assert.ok(input.parent().hasClass('field_with_errors'))
 40 |     assert.ok(label.parent().hasClass('field_with_errors'))
 41 |     assert.ok(input.parent().find('label:contains("must be present")')[0])
 42 |     assert.notOk($('iframe').contents().find('p:contains("Form submitted")')[0])
 43 |     done()
 44 |   }, 250)
 45 | })
 46 | 
 47 | QUnit.test('Validate form with valid form (async)', function (assert) {
 48 |   var done = assert.async()
 49 |   var form = $('form#new_user')
 50 |   var input = form.find('input#user_name')
 51 | 
 52 |   input.val('Test')
 53 | 
 54 |   form.trigger('submit')
 55 | 
 56 |   setTimeout(function () {
 57 |     assert.ok($('iframe').contents().find('p:contains("Form submitted")')[0])
 58 |     done()
 59 |   }, 250)
 60 | })
 61 | 
 62 | QUnit.test('Validate form with an input changed to false (async)', function (assert) {
 63 |   var done = assert.async()
 64 |   var form = $('form#new_user')
 65 |   var input = form.find('input#user_name')
 66 | 
 67 |   input.val('Test')
 68 |   input[0].dataset.csvChanged = 'false'
 69 | 
 70 |   form.trigger('submit')
 71 | 
 72 |   setTimeout(function () {
 73 |     assert.ok($('iframe').contents().find('p:contains("Form submitted")')[0])
 74 |     done()
 75 |   }, 250)
 76 | })
 77 | 
 78 | QUnit.test('Ensure ajax:beforeSend is not from a bubbled event (async)', function (assert) {
 79 |   var done = assert.async()
 80 |   var form = $('form#new_user')
 81 |   var input = form.find('input#user_name')
 82 | 
 83 |   form
 84 |     .append('<a>')
 85 |     .find('a').trigger('ajax:beforeSend')
 86 | 
 87 |   setTimeout(function () {
 88 |     assert.notOk(input.parent().hasClass('field_with_errors'))
 89 |     done()
 90 |   }, 250)
 91 | })
 92 | 
 93 | QUnit.test('Validate form with invalid form and disabling validations (async)', function (assert) {
 94 |   var done = assert.async()
 95 |   var form = $('form#new_user')
 96 |   var input = form.find('input#user_name')
 97 |   var label = $('label[for="user_name"]')
 98 | 
 99 |   form.disableClientSideValidations()
100 |   form.trigger('submit')
101 | 
102 |   setTimeout(function () {
103 |     assert.ok($('iframe').contents().find('p:contains("Form submitted")')[0])
104 |     done()
105 |   }, 250)
106 | })
107 | 
108 | QUnit.test('Handle disable-with (async)', function (assert) {
109 |   var done = assert.async()
110 |   var form = $('form#new_user')
111 |   var input = form.find('input#user_name')
112 |   var label = $('label[for="user_name"]')
113 | 
114 |   form.append($('<input />', {
115 |     type: 'submit',
116 |     'data-disable-with': 'Waiting...',
117 |     name: 'commit',
118 |     value: 'Save',
119 |     id: 'submit_button'
120 |   }))
121 | 
122 |   form.trigger('submit')
123 | 
124 |   setTimeout(function () {
125 |     assert.ok($('#submit_button').attr('disabled') === undefined)
126 |     done()
127 |   }, 250)
128 | })
129 | 
130 | QUnit.test('Disabled inputs do not stop form submission (async)', function (assert) {
131 |   var done = assert.async()
132 |   var form = $('form#new_user')
133 |   var input = form.find('input#user_name')
134 |   var label = $('label[for="user_name"]')
135 | 
136 |   input.disableClientSideValidations()
137 |   form.trigger('submit')
138 | 
139 |   setTimeout(function () {
140 |     assert.ok($('iframe').contents().find('p:contains("Form submitted")')[0])
141 |     done()
142 |   }, 250)
143 | })
144 | 
145 | QUnit.test('Decorative (without name) inputs aren\'t validated (async)', function (assert) {
146 |   var done = assert.async()
147 |   var form = $('form#new_user')
148 |   var input = form.find('input#user_name')
149 | 
150 |   input.val('Test')
151 |   form.append($('<input />', { type: 'text' })).validate()
152 | 
153 |   form.trigger('submit')
154 | 
155 |   setTimeout(function () {
156 |     assert.ok($('iframe').contents().find('p:contains("Form submitted")')[0])
157 |     done()
158 |   }, 250)
159 | })
160 | 
161 | QUnit.test('Resetting client side validations', function (assert) {
162 |   var form = $('form#new_user')
163 |   var input = form.find('input#user_name')
164 |   var label = $('label[for="user_name"]')
165 | 
166 |   form.trigger('submit')
167 |   assert.ok(input.parent().hasClass('field_with_errors'))
168 |   assert.ok(label.parent().hasClass('field_with_errors'))
169 |   assert.ok(input.parent().find('label:contains("must be present")')[0])
170 | 
171 |   form.resetClientSideValidations()
172 |   assert.notOk(input.parent().hasClass('field_with_errors'))
173 |   assert.notOk(label.parent().hasClass('field_with_errors'))
174 |   assert.notOk(input.parent().find('label:contains("must be present")')[0])
175 | 
176 |   form.trigger('submit')
177 |   assert.ok(input.parent().hasClass('field_with_errors'))
178 |   assert.ok(label.parent().hasClass('field_with_errors'))
179 |   assert.ok(input.parent().find('label:contains("must be present")')[0])
180 | })
181 | 
182 | QUnit.test('Disable client side validations on all child inputs', function (assert) {
183 |   var form = $('form#new_user')
184 |   var input = form.find('input#user_name')
185 |   var label = $('label[for="user_name"]')
186 | 
187 |   form.disableClientSideValidations()
188 | 
189 |   input.trigger('focusout')
190 | 
191 |   assert.notOk(input.parent().hasClass('field_with_errors'))
192 |   assert.notOk(label.parent().hasClass('field_with_errors'))
193 |   assert.notOk(input.parent().find('label:contains("must be present")')[0])
194 | })
195 | 


--------------------------------------------------------------------------------
/test/action_view/cases/test_legacy_form_with_helpers.rb:
--------------------------------------------------------------------------------
  1 | # frozen_string_literal: true
  2 | 
  3 | require 'action_view/cases/helper'
  4 | 
  5 | if ActionView::Helpers::FormHelper.method_defined?(:form_with)
  6 |   module ClientSideValidations
  7 |     class LegacyFormWithActionViewHelpersTest < ::ActionView::TestCase
  8 |       include ::ActionViewTestSetup
  9 | 
 10 |       BASE_FIELD_HELPERS.each do |field_helper, options|
 11 |         define_method(:"test_form_with_#{field_helper}") do
 12 |           form_with(model: @post) do |f|
 13 |             concat f.public_send(field_helper, :cost)
 14 |           end
 15 | 
 16 |           expected = whole_form_with('/posts') do
 17 |             form_field('input', name: 'post[cost]', id: 'post_cost', type: options[:type], **options.fetch(:html_options, {}))
 18 |           end
 19 | 
 20 |           assert_dom_equal expected, output_buffer
 21 |         end
 22 |       end
 23 | 
 24 |       def test_form_with_text_area
 25 |         form_with(model: @post) do |f|
 26 |           concat f.text_area(:cost)
 27 |         end
 28 | 
 29 |         expected = whole_form_with('/posts') do
 30 |           form_field('textarea', name: 'post[cost]', id: 'post_cost', tag_content: "\n")
 31 |         end
 32 | 
 33 |         assert_dom_equal expected, output_buffer
 34 |       end
 35 | 
 36 |       if ::ActionView::Helpers::FormBuilder.field_helpers.include?(:textarea)
 37 |         def test_form_with_textarea
 38 |           form_with(model: @post) do |f|
 39 |             concat f.textarea(:cost)
 40 |           end
 41 | 
 42 |           expected = whole_form_with('/posts') do
 43 |             form_field('textarea', name: 'post[cost]', id: 'post_cost', tag_content: "\n")
 44 |           end
 45 | 
 46 |           assert_dom_equal expected, output_buffer
 47 |         end
 48 |       end
 49 | 
 50 |       def test_form_with_file_field
 51 |         form_with(model: @post) do |f|
 52 |           concat f.file_field(:cost)
 53 |         end
 54 | 
 55 |         expected = whole_form_with('/posts', file: true) do
 56 |           form_field('input', name: 'post[cost]', id: 'post_cost', type: 'file')
 57 |         end
 58 | 
 59 |         assert_dom_equal expected, output_buffer
 60 |       end
 61 | 
 62 |       if Rails.version >= '7.0'
 63 |         def test_form_with_file_multiple_include_hidden
 64 |           form_with(model: @post) do |f|
 65 |             concat f.file_field(:cost, multiple: true, include_hidden: true)
 66 |           end
 67 | 
 68 |           expected = whole_form_with('/posts', file: true) do
 69 |             hidden_input('post[cost][]') +
 70 |               form_field('input', id: 'post_cost', name: 'post[cost][]', type: 'file', multiple: 'multiple')
 71 |           end
 72 | 
 73 |           assert_dom_equal expected, output_buffer
 74 |         end
 75 |       end
 76 | 
 77 |       def test_form_with_check_box
 78 |         form_with(model: @post) do |f|
 79 |           concat f.check_box(:cost)
 80 |         end
 81 | 
 82 |         expected = whole_form_with('/posts') do
 83 |           hidden_input_for_checkbox('post[cost]') +
 84 |             form_field('input', name: 'post[cost]', id: 'post_cost', type: 'checkbox', value: '1')
 85 |         end
 86 | 
 87 |         assert_dom_equal expected, output_buffer
 88 |       end
 89 | 
 90 |       if ::ActionView::Helpers::FormBuilder.field_helpers.include?(:checkbox)
 91 |         def test_form_with_checkbox
 92 |           form_with(model: @post) do |f|
 93 |             concat f.checkbox(:cost)
 94 |           end
 95 | 
 96 |           expected = whole_form_with('/posts') do
 97 |             hidden_input_for_checkbox('post[cost]') +
 98 |               form_field('input', name: 'post[cost]', id: 'post_cost', type: 'checkbox', value: '1')
 99 |           end
100 | 
101 |           assert_dom_equal expected, output_buffer
102 |         end
103 |       end
104 | 
105 |       def test_form_with_radio_button
106 |         form_with(model: @post) do |f|
107 |           concat f.radio_button(:cost, '10')
108 |         end
109 | 
110 |         expected = whole_form_with('/posts') do
111 |           form_field('input', name: 'post[cost]', id: 'post_cost_10', type: 'radio', value: '10')
112 |         end
113 | 
114 |         assert_dom_equal expected, output_buffer
115 |       end
116 | 
117 |       def test_form_with_fields_for
118 |         result = fields_for(@comment) do |c|
119 |           c.text_field(:title)
120 |         end
121 | 
122 |         expected = form_field('input', id: 'comment_title', name: 'comment[title]', type: 'text')
123 | 
124 |         assert_dom_equal expected, result
125 |       end
126 | 
127 |       def test_form_with_fields
128 |         result = fields(:comment, model: @comment) do |c|
129 |           c.text_field(:title)
130 |         end
131 | 
132 |         expected = form_field('input', id: 'comment_title', name: 'comment[title]', type: 'text')
133 | 
134 |         assert_dom_equal expected, result
135 |       end
136 | 
137 |       def test_form_with_select
138 |         form_with(model: @post) do |f|
139 |           concat f.select(:cost, [])
140 |         end
141 | 
142 |         expected = whole_form_with('/posts') do
143 |           form_field('select', name: 'post[cost]', id: 'post_cost')
144 |         end
145 | 
146 |         assert_dom_equal expected, output_buffer
147 |       end
148 | 
149 |       def test_form_with_select_multiple
150 |         form_with(model: @post) do |f|
151 |           concat f.select(:cost, [], {}, multiple: true)
152 |         end
153 | 
154 |         expected = whole_form_with('/posts') do
155 |           hidden_input('post[cost][]') +
156 |             form_field('select', name: 'post[cost][]', id: 'post_cost', multiple: true)
157 |         end
158 | 
159 |         assert_dom_equal expected, output_buffer
160 |       end
161 | 
162 |       def test_form_with_collection_select
163 |         form_with(model: @post) do |f|
164 |           concat f.collection_select(:cost, [], :id, :name)
165 |         end
166 | 
167 |         expected = whole_form_with('/posts') do
168 |           form_field('select', name: 'post[cost]', id: 'post_cost')
169 |         end
170 | 
171 |         assert_dom_equal expected, output_buffer
172 |       end
173 | 
174 |       def test_form_with_grouped_collection_select
175 |         form_with(model: @post) do |f|
176 |           concat f.grouped_collection_select(:cost, [], :group_method, :group_label_method, :id, :name)
177 |         end
178 | 
179 |         expected = whole_form_with('/posts') do
180 |           form_field('select', name: 'post[cost]', id: 'post_cost')
181 |         end
182 | 
183 |         assert_dom_equal expected, output_buffer
184 |       end
185 | 
186 |       def test_form_with_time_zone_select
187 |         zones = mock('TimeZones')
188 |         zones.stubs(:all).returns([])
189 |         form_with(model: @post) do |f|
190 |           concat f.time_zone_select(:cost, nil, model: zones)
191 |         end
192 | 
193 |         expected = whole_form_with('/posts') do
194 |           form_field('select', name: 'post[cost]', id: 'post_cost')
195 |         end
196 | 
197 |         assert_dom_equal expected, output_buffer
198 |       end
199 |     end
200 |   end
201 | end
202 | 


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
  1 | import jQuery from 'jquery'
  2 | import ClientSideValidations from './core'
  3 | 
  4 | import { absenceLocalValidator, presenceLocalValidator } from './validators/local/absence_presence'
  5 | import { acceptanceLocalValidator } from './validators/local/acceptance'
  6 | import { formatLocalValidator } from './validators/local/format'
  7 | import { numericalityLocalValidator } from './validators/local/numericality'
  8 | import { lengthLocalValidator } from './validators/local/length'
  9 | import { exclusionLocalValidator, inclusionLocalValidator } from './validators/local/exclusion_inclusion'
 10 | import { confirmationLocalValidator } from './validators/local/confirmation'
 11 | import { uniquenessLocalValidator } from './validators/local/uniqueness'
 12 | 
 13 | // Validators will run in the following order
 14 | ClientSideValidations.validators.local = {
 15 |   absence: absenceLocalValidator,
 16 |   presence: presenceLocalValidator,
 17 |   acceptance: acceptanceLocalValidator,
 18 |   format: formatLocalValidator,
 19 |   numericality: numericalityLocalValidator,
 20 |   length: lengthLocalValidator,
 21 |   inclusion: inclusionLocalValidator,
 22 |   exclusion: exclusionLocalValidator,
 23 |   confirmation: confirmationLocalValidator,
 24 |   uniqueness: uniquenessLocalValidator
 25 | }
 26 | 
 27 | jQuery.fn.disableClientSideValidations = function () {
 28 |   ClientSideValidations.disable(this)
 29 | 
 30 |   return this
 31 | }
 32 | 
 33 | jQuery.fn.enableClientSideValidations = function () {
 34 |   const selectors = { forms: 'form', inputs: 'input' }
 35 | 
 36 |   for (const selector in selectors) {
 37 |     const enablers = selectors[selector]
 38 | 
 39 |     this.filter(ClientSideValidations.selectors[selector]).each(function () {
 40 |       ClientSideValidations.enablers[enablers](this)
 41 |     })
 42 |   }
 43 | 
 44 |   return this
 45 | }
 46 | 
 47 | jQuery.fn.resetClientSideValidations = function () {
 48 |   this.filter(ClientSideValidations.selectors.forms).each(function () {
 49 |     ClientSideValidations.reset(this)
 50 |   })
 51 | 
 52 |   return this
 53 | }
 54 | 
 55 | jQuery.fn.validate = function () {
 56 |   this.filter(ClientSideValidations.selectors.forms).each(function () {
 57 |     jQuery(this).enableClientSideValidations()
 58 |   })
 59 | 
 60 |   return this
 61 | }
 62 | 
 63 | jQuery.fn.isValid = function (validators) {
 64 |   const obj = jQuery(this[0])
 65 | 
 66 |   if (obj.is('form')) {
 67 |     return validateForm(obj, validators)
 68 |   } else {
 69 |     return validateElement(obj, validatorsFor(this[0].name, validators))
 70 |   }
 71 | }
 72 | 
 73 | const cleanNestedElementName = (elementName, nestedMatches, validators) => {
 74 |   for (const validatorName in validators) {
 75 |     if (validatorName.match(`\\[${nestedMatches[1]}\\].*\\[\\]\\[${nestedMatches[2]}\\]$`)) {
 76 |       elementName = elementName.replace(/\[[\da-z_]+\]\[(\w+)\]$/g, '[][$1]')
 77 |     }
 78 |   }
 79 | 
 80 |   return elementName
 81 | }
 82 | 
 83 | const cleanElementName = (elementName, validators) => {
 84 |   elementName = elementName.replace(/\[(\w+_attributes)\]\[[\da-z_]+\](?=\[(?:\w+_attributes)\])/g, '[$1][]')
 85 | 
 86 |   const nestedMatches = elementName.match(/\[(\w+_attributes)\].*\[(\w+)\]$/)
 87 | 
 88 |   if (nestedMatches) {
 89 |     elementName = cleanNestedElementName(elementName, nestedMatches, validators)
 90 |   }
 91 | 
 92 |   return elementName
 93 | }
 94 | 
 95 | const validatorsFor = (elementName, validators) => {
 96 |   if (Object.prototype.hasOwnProperty.call(validators, elementName)) {
 97 |     return validators[elementName]
 98 |   }
 99 | 
100 |   return validators[cleanElementName(elementName, validators)] || {}
101 | }
102 | 
103 | const validateForm = ($form, validators) => {
104 |   let valid = true
105 | 
106 |   $form.trigger('form:validate:before.ClientSideValidations')
107 | 
108 |   $form.find(ClientSideValidations.selectors.validate_inputs).each(function () {
109 |     if (!jQuery(this).isValid(validators)) {
110 |       valid = false
111 |     }
112 | 
113 |     return true
114 |   })
115 | 
116 |   if (valid) {
117 |     $form.trigger('form:validate:pass.ClientSideValidations')
118 |   } else {
119 |     $form.trigger('form:validate:fail.ClientSideValidations')
120 |   }
121 | 
122 |   $form.trigger('form:validate:after.ClientSideValidations')
123 | 
124 |   return valid
125 | }
126 | 
127 | const passElement = ($element) => {
128 |   const element = $element[0]
129 |   $element.trigger('element:validate:pass.ClientSideValidations')
130 |   delete element.dataset.csvValid
131 | }
132 | 
133 | const failElement = ($element, message) => {
134 |   const element = $element[0]
135 |   $element.trigger('element:validate:fail.ClientSideValidations', message)
136 |   element.dataset.csvValid = 'false'
137 | }
138 | 
139 | const afterValidate = ($element) => {
140 |   const element = $element[0]
141 |   $element.trigger('element:validate:after.ClientSideValidations')
142 |   return element.dataset.csvValid !== 'false'
143 | }
144 | 
145 | const executeValidator = (validatorFunctions, validatorFunction, validatorOptions, $element) => {
146 |   for (const validatorOption in validatorOptions) {
147 |     if (!validatorOptions[validatorOption]) {
148 |       continue
149 |     }
150 | 
151 |     const message = validatorFunction.call(validatorFunctions, $element, validatorOptions[validatorOption])
152 | 
153 |     if (message) {
154 |       failElement($element, message)
155 |       return false
156 |     }
157 |   }
158 | 
159 |   return true
160 | }
161 | 
162 | const executeValidators = (validatorFunctions, $element, validators) => {
163 |   for (const validator in validators) {
164 |     if (!validatorFunctions[validator]) {
165 |       continue
166 |     }
167 | 
168 |     if (!executeValidator(validatorFunctions, validatorFunctions[validator], validators[validator], $element)) {
169 |       return false
170 |     }
171 |   }
172 | 
173 |   return true
174 | }
175 | 
176 | const isMarkedForDestroy = ($element) => {
177 |   const element = $element[0]
178 |   const elementName = element.name
179 | 
180 |   if (/\[([^\]]*?)\]$/.test(elementName)) {
181 |     const destroyInputName = elementName.replace(/\[([^\]]*?)\]$/, '[_destroy]')
182 |     const destroyInputElement = document.querySelector(`input[name="${destroyInputName}"]`)
183 | 
184 |     if (destroyInputElement && destroyInputElement.value === '1') {
185 |       return true
186 |     }
187 |   }
188 | 
189 |   return false
190 | }
191 | 
192 | const executeAllValidators = ($element, validators) => {
193 |   const element = $element[0]
194 |   if (element.dataset.csvChanged === 'false' || element.disabled) {
195 |     return
196 |   }
197 | 
198 |   element.dataset.csvChanged = 'false'
199 | 
200 |   if (executeValidators(ClientSideValidations.validators.all(), $element, validators)) {
201 |     passElement($element)
202 |   }
203 | }
204 | 
205 | const validateElement = ($element, validators) => {
206 |   $element.trigger('element:validate:before.ClientSideValidations')
207 | 
208 |   if (isMarkedForDestroy($element)) {
209 |     passElement($element)
210 |   } else {
211 |     executeAllValidators($element, validators)
212 |   }
213 | 
214 |   return afterValidate($element)
215 | }
216 | 
217 | if (!window.ClientSideValidations) {
218 |   window.ClientSideValidations = ClientSideValidations
219 | 
220 |   if (!isAMD() && !isCommonJS()) {
221 |     ClientSideValidations.start()
222 |   }
223 | }
224 | 
225 | function isAMD () {
226 |   return typeof define === 'function' && define.amd // eslint-disable-line no-undef
227 | }
228 | 
229 | function isCommonJS () {
230 |   return typeof exports === 'object' && typeof module !== 'undefined'
231 | }
232 | 
233 | export default ClientSideValidations
234 | 


--------------------------------------------------------------------------------
/test/action_view/cases/helper.rb:
--------------------------------------------------------------------------------
  1 | # frozen_string_literal: true
  2 | 
  3 | require 'base_helper'
  4 | require 'action_view'
  5 | require 'action_view/template'
  6 | require 'action_view/models'
  7 | require 'client_side_validations/action_view'
  8 | 
  9 | module ActionController
 10 |   class Base
 11 |     include ActionDispatch::Routing::RouteSet.new.url_helpers
 12 |   end
 13 | end
 14 | 
 15 | module ActionViewTestSetup
 16 |   include ::ClientSideValidations::ActionView::Helpers::FormHelper
 17 | 
 18 |   BASE_FIELD_HELPERS = {
 19 |     color_field:          { type: 'color', html_options: { value: '#000000' } },
 20 |     date_field:           { type: 'date' },
 21 |     datetime_field:       { type: 'datetime-local' },
 22 |     datetime_local_field: { type: 'datetime-local' },
 23 |     email_field:          { type: 'email' },
 24 |     month_field:          { type: 'month' },
 25 |     number_field:         { type: 'number' },
 26 |     password_field:       { type: 'password' },
 27 |     phone_field:          { type: 'tel' },
 28 |     range_field:          { type: 'range' },
 29 |     search_field:         { type: 'search' },
 30 |     telephone_field:      { type: 'tel' },
 31 |     text_field:           { type: 'text' },
 32 |     time_field:           { type: 'time' },
 33 |     url_field:            { type: 'url' },
 34 |     week_field:           { type: 'week' }
 35 |   }.freeze
 36 | 
 37 |   def form_for(*, **)
 38 |     @output_buffer = super
 39 |   end
 40 | 
 41 |   def form_with(*, **)
 42 |     @output_buffer = super
 43 |   end
 44 | 
 45 |   Routes = ActionDispatch::Routing::RouteSet.new
 46 |   include Routes.url_helpers
 47 | 
 48 |   def _routes
 49 |     Routes
 50 |   end
 51 | 
 52 |   Routes.draw do
 53 |     resources :posts do
 54 |       resources :comments
 55 |     end
 56 | 
 57 |     resources :format_things
 58 | 
 59 |     root to: 'main#index'
 60 |   end
 61 | 
 62 |   def default_url_options
 63 |     { only_path: true }
 64 |   end
 65 | 
 66 |   def url_for(object)
 67 |     @url_for_options = object
 68 |     if object.is_a?(Hash) && object[:use_route].blank? && object[:controller].blank?
 69 |       object[:controller] = 'main'
 70 |       object[:action] = 'index'
 71 |     end
 72 |     super
 73 |   end
 74 | 
 75 |   def autocomplete_attribute
 76 |     @autocomplete_attribute ||=
 77 |       if hidden_field_tag(:test).include?('autocomplete')
 78 |         'autocomplete="off"'
 79 |       else
 80 |         ''
 81 |       end
 82 |   end
 83 | 
 84 |   def hidden_input(name, value = '')
 85 |     %(<input name="#{name}" type="hidden" value="#{value}" #{autocomplete_attribute} />)
 86 |   end
 87 | 
 88 |   def hidden_input_for_checkbox(name)
 89 |     hidden_input(name, '0')
 90 |   end
 91 | 
 92 |   def setup
 93 |     super
 94 | 
 95 |     # Create 'label' locale for testing I18n label helpers
 96 |     label_translations = {
 97 |       activemodel: {
 98 |         attributes: {
 99 |           post: {
100 |             cost: 'Total cost'
101 |           }
102 |         }
103 |       },
104 |       helpers:     {
105 |         label: {
106 |           post: {
107 |             body: 'Write entire text here'
108 |           }
109 |         }
110 |       }
111 |     }
112 |     I18n.backend.store_translations 'label', label_translations
113 | 
114 |     # Create "submit" locale for testing I18n submit helpers
115 |     submit_translations = {
116 |       helpers: {
117 |         submit: {
118 |           create:       'Create %{model}',
119 |           update:       'Confirm %{model} changes',
120 |           submit:       'Save changes',
121 |           another_post: {
122 |             update: 'Update your %{model}'
123 |           }
124 |         }
125 |       }
126 |     }
127 |     I18n.backend.store_translations 'submit', submit_translations
128 | 
129 |     @post = Post.new
130 |     @comment = Comment.new
131 |     @format_thing = FormatThing.new
132 | 
133 |     if defined?(ActionView::OutputFlow)
134 |       @view_flow = ActionView::OutputFlow.new
135 |     else
136 |       @_content_for = Hash.new { |h, k| h[k] = ActiveSupport::SafeBuffer.new }
137 |     end
138 |   end
139 | 
140 |   def snowman(method = nil)
141 |     txt = +''
142 | 
143 |     txt << hidden_input('utf8', '&#x2713;') if default_enforce_utf8
144 | 
145 |     txt << hidden_input('_method', method) if method
146 | 
147 |     txt
148 |   end
149 | 
150 |   def form_field(tag, id: nil, name: nil, type: nil, value: nil, multiple: false, tag_content: nil, custom_name: nil)
151 |     txt = %(<#{tag})
152 | 
153 |     txt << %( name="#{custom_name}") if custom_name
154 |     txt << %( type="#{type}") if type
155 |     txt << %( #{autocomplete_attribute}) if %w[hidden].include?(type) && autocomplete_attribute.present?
156 |     txt << %( value="#{value}") if value
157 |     txt << %( multiple="multiple") if multiple
158 |     txt << %( name="#{name}") if name
159 |     txt << %( id="#{id}") if id
160 |     txt <<
161 |       if %w[select textarea].include?(tag)
162 |         %(>#{tag_content}</#{tag}>)
163 |       else
164 |         %( />)
165 |       end
166 | 
167 |     txt
168 |   end
169 | 
170 |   def form_for_text(action = 'http://www.example.com', id = nil, html_class = nil, remote = nil, validators = nil, file = nil)
171 |     txt = %(<form action="#{action}" accept-charset="UTF-8" method="post")
172 | 
173 |     if validators
174 |       txt << %( data-client-side-validations="#{CGI.escapeHTML(csv_data_attribute(validators))}")
175 |       txt << %( novalidate="novalidate") if validators
176 |     end
177 | 
178 |     txt << %( data-remote="true") if remote
179 |     txt << %( id="#{id}") if id
180 |     txt << %( class="#{html_class}") if html_class
181 |     txt << %( enctype="multipart/form-data") if file
182 |     txt << %(>)
183 | 
184 |     txt
185 |   end
186 | 
187 |   def whole_form_for(action = 'http://www.example.com', id = nil, html_class = nil, options = nil)
188 |     contents = block_given? ? yield : ''
189 | 
190 |     if options.is_a?(Hash)
191 |       method, remote, validators, file, no_validate = options.values_at(:method, :remote, :validators, :file, :no_validate)
192 |     else
193 |       method = options
194 |     end
195 | 
196 |     form_for_text(action, id, html_class, remote, validators || no_validate, file) << snowman(method) << (contents || '') << '</form>'
197 |   end
198 | 
199 |   def form_with_text(action = 'http://www.example.com', id = nil, html_class = nil, local = nil, validators = nil, file = nil)
200 |     txt = %(<form action="#{action}" accept-charset="UTF-8" method="post")
201 | 
202 |     if validators
203 |       txt << %( data-client-side-validations="#{CGI.escapeHTML(csv_data_attribute(validators))}")
204 |       txt << %( novalidate="novalidate") if validators
205 |     end
206 | 
207 |     txt << %( id="#{id}") if id
208 |     txt << %( data-remote="true") if !local && form_with_generates_remote_forms
209 |     txt << %( class="#{html_class}") if html_class
210 |     txt << %( enctype="multipart/form-data") if file
211 |     txt << %(>)
212 | 
213 |     txt
214 |   end
215 | 
216 |   def whole_form_with(action = 'http://www.example.com', options = nil)
217 |     contents = block_given? ? yield : ''
218 | 
219 |     if options.is_a?(Hash)
220 |       method, local, validators, file, id, html_class, no_validate = options.values_at(:method, :local, :validators, :file, :id, :class, :no_validate)
221 |     else
222 |       method = options
223 |     end
224 | 
225 |     form_with_text(action, id, html_class, local, validators || no_validate, file) << snowman(method) << (contents || '') << '</form>'
226 |   end
227 | 
228 |   def client_side_form_settings_helper
229 |     {
230 |       type:      'ActionView::Helpers::FormBuilder',
231 |       input_tag: %(<div class="field_with_errors"><span id="input_tag"></span></div>),
232 |       label_tag: %(<div class="field_with_errors"><label id="label_tag"></label></div>)
233 |     }
234 |   end
235 | 
236 |   def csv_data_attribute(validators)
237 |     {
238 |       html_settings: client_side_form_settings_helper,
239 |       number_format: { separator: '.', delimiter: ',' },
240 |       validators:    validators
241 |     }.to_json
242 |   end
243 | 
244 |   def comments_path(post)
245 |     "/posts/#{post.id}/comments"
246 |   end
247 |   alias post_comments_path comments_path
248 | 
249 |   def comment_path(post, comment)
250 |     "/posts/#{post.id}/comments/#{comment.id}"
251 |   end
252 |   alias post_comment_path comment_path
253 | 
254 |   def admin_comments_path(post)
255 |     "/admin/posts/#{post.id}/comments"
256 |   end
257 |   alias admin_post_comments_path admin_comments_path
258 | 
259 |   def admin_comment_path(post, comment)
260 |     "/admin/posts/#{post.id}/comments/#{comment.id}"
261 |   end
262 |   alias admin_post_comment_path admin_comment_path
263 | 
264 |   def posts_path(*)
265 |     '/posts'
266 |   end
267 | 
268 |   def post_path(post, options = {})
269 |     if options[:format]
270 |       "/posts/#{post.id}.#{options[:format]}"
271 |     else
272 |       "/posts/#{post.id}"
273 |     end
274 |   end
275 | 
276 |   def protect_against_forgery?
277 |     false
278 |   end
279 | 
280 |   delegate :default_enforce_utf8, to: :'ActionView::Helpers::FormTagHelper'
281 | 
282 |   delegate :form_with_generates_remote_forms, to: :'ActionView::Helpers::FormHelper'
283 | end
284 | 


--------------------------------------------------------------------------------
/src/core.js:
--------------------------------------------------------------------------------
  1 | import jQuery from 'jquery'
  2 | import { createElementFromHTML } from './utils'
  3 | 
  4 | const ClientSideValidations = {
  5 |   callbacks: {
  6 |     element: {
  7 |       after: ($element, eventData) => {},
  8 |       before: ($element, eventData) => {},
  9 |       fail: ($element, message, addError, eventData) => addError(),
 10 |       pass: ($element, removeError, eventData) => removeError()
 11 |     },
 12 |     form: {
 13 |       after: ($form, eventData) => {},
 14 |       before: ($form, eventData) => {},
 15 |       fail: ($form, eventData) => {},
 16 |       pass: ($form, eventData) => {}
 17 |     }
 18 |   },
 19 |   eventsToBind: {
 20 |     form: (form, $form) => ({
 21 |       'submit.ClientSideValidations': (eventData) => {
 22 |         if (!$form.isValid(form.ClientSideValidations.settings.validators)) {
 23 |           eventData.preventDefault()
 24 |           eventData.stopImmediatePropagation()
 25 |         }
 26 |       },
 27 |       'ajax:beforeSend.ClientSideValidations': function (eventData) {
 28 |         if (eventData.target === this) {
 29 |           $form.isValid(form.ClientSideValidations.settings.validators)
 30 |         }
 31 |       },
 32 |       'form:validate:after.ClientSideValidations': (eventData) => {
 33 |         ClientSideValidations.callbacks.form.after($form, eventData)
 34 |       },
 35 |       'form:validate:before.ClientSideValidations': (eventData) => {
 36 |         ClientSideValidations.callbacks.form.before($form, eventData)
 37 |       },
 38 |       'form:validate:fail.ClientSideValidations': (eventData) => {
 39 |         ClientSideValidations.callbacks.form.fail($form, eventData)
 40 |       },
 41 |       'form:validate:pass.ClientSideValidations': (eventData) => {
 42 |         ClientSideValidations.callbacks.form.pass($form, eventData)
 43 |       }
 44 |     }),
 45 |     input: (form) => ({
 46 |       'focusout.ClientSideValidations': function () {
 47 |         jQuery(this).isValid(form.ClientSideValidations.settings.validators)
 48 |       },
 49 |       'change.ClientSideValidations': function () {
 50 |         this.dataset.csvChanged = 'true'
 51 |       },
 52 |       'element:validate:after.ClientSideValidations': function (eventData) {
 53 |         ClientSideValidations.callbacks.element.after(jQuery(this), eventData)
 54 |       },
 55 |       'element:validate:before.ClientSideValidations': function (eventData) {
 56 |         ClientSideValidations.callbacks.element.before(jQuery(this), eventData)
 57 |       },
 58 |       'element:validate:fail.ClientSideValidations': function (eventData, message) {
 59 |         const $element = jQuery(this)
 60 | 
 61 |         ClientSideValidations.callbacks.element.fail($element, message, function () {
 62 |           form.ClientSideValidations.addError($element, message)
 63 |         }, eventData)
 64 |       },
 65 |       'element:validate:pass.ClientSideValidations': function (eventData) {
 66 |         const $element = jQuery(this)
 67 | 
 68 |         ClientSideValidations.callbacks.element.pass($element, function () {
 69 |           form.ClientSideValidations.removeError($element)
 70 |         }, eventData)
 71 |       }
 72 |     }),
 73 |     inputConfirmation: ($element, form) => ({
 74 |       'focusout.ClientSideValidations': () => {
 75 |         $element[0].dataset.csvChanged = 'true'
 76 |         $element.isValid(form.ClientSideValidations.settings.validators)
 77 |       },
 78 |       'keyup.ClientSideValidations': () => {
 79 |         $element[0].dataset.csvChanged = 'true'
 80 |         $element.isValid(form.ClientSideValidations.settings.validators)
 81 |       }
 82 |     })
 83 |   },
 84 |   enablers: {
 85 |     form: (form) => {
 86 |       const $form = jQuery(form)
 87 | 
 88 |       form.ClientSideValidations = {
 89 |         settings: JSON.parse(form.dataset.clientSideValidations),
 90 |         addError: ($element, message) => ClientSideValidations
 91 |           .formBuilders[form.ClientSideValidations.settings.html_settings.type]
 92 |           .add($element, form.ClientSideValidations.settings.html_settings, message),
 93 |         removeError: ($element) => ClientSideValidations
 94 |           .formBuilders[form.ClientSideValidations.settings.html_settings.type]
 95 |           .remove($element, form.ClientSideValidations.settings.html_settings)
 96 |       }
 97 | 
 98 |       const eventsToBind = ClientSideValidations.eventsToBind.form(form, $form)
 99 | 
100 |       for (const eventName in eventsToBind) {
101 |         const eventFunction = eventsToBind[eventName]
102 |         $form.on(eventName, eventFunction)
103 |       }
104 | 
105 |       $form.find(ClientSideValidations.selectors.inputs).each(function () {
106 |         ClientSideValidations.enablers.input(this)
107 |       })
108 |     },
109 |     input: function (input) {
110 |       const $input = jQuery(input)
111 |       const form = input.form
112 |       const $form = jQuery(form)
113 | 
114 |       const eventsToBind = ClientSideValidations.eventsToBind.input(form)
115 | 
116 |       for (const eventName in eventsToBind) {
117 |         const eventFunction = eventsToBind[eventName]
118 | 
119 |         $input.filter(':not(:radio):not([id$=_confirmation])').each(function () {
120 |           this.dataset.csvValidate = 'true'
121 |         }).on(eventName, eventFunction)
122 |       }
123 | 
124 |       $input.filter(':checkbox').on('change.ClientSideValidations', function () {
125 |         jQuery(this).isValid(form.ClientSideValidations.settings.validators)
126 |       })
127 | 
128 |       $input.filter('[id$=_confirmation]').each(function () {
129 |         const $element = jQuery(this)
130 |         const $elementToConfirm = $form.find(`#${this.id.match(/(.+)_confirmation/)[1]}:input`)
131 | 
132 |         if ($elementToConfirm.length) {
133 |           const eventsToBind = ClientSideValidations.eventsToBind.inputConfirmation($elementToConfirm, form)
134 | 
135 |           for (const eventName in eventsToBind) {
136 |             const eventFunction = eventsToBind[eventName]
137 |             jQuery(`#${$element.attr('id')}`).on(eventName, eventFunction)
138 |           }
139 |         }
140 |       })
141 |     }
142 |   },
143 |   formBuilders: {
144 |     'ActionView::Helpers::FormBuilder': {
145 |       add: ($element, settings, message) => {
146 |         const element = $element[0]
147 | 
148 |         const form = element.form
149 | 
150 |         const inputErrorTemplate = createElementFromHTML(settings.input_tag)
151 |         let inputErrorElement = element.closest(`.${inputErrorTemplate.getAttribute('class').replace(/ /g, '.')}`)
152 | 
153 |         if (!inputErrorElement) {
154 |           inputErrorElement = inputErrorTemplate
155 | 
156 |           if (element.getAttribute('autofocus')) {
157 |             element.setAttribute('autofocus', false)
158 |           }
159 | 
160 |           element.before(inputErrorElement)
161 |           inputErrorElement.querySelector('span#input_tag').replaceWith(element)
162 | 
163 |           const inputErrorLabelMessageElement = inputErrorElement.querySelector('label.message')
164 | 
165 |           if (inputErrorLabelMessageElement) {
166 |             inputErrorLabelMessageElement.setAttribute('for', element.id)
167 |           }
168 |         }
169 | 
170 |         const labelElement = form.querySelector(`label[for="${element.id}"]:not(.message)`)
171 | 
172 |         if (labelElement) {
173 |           const labelErrorTemplate = createElementFromHTML(settings.label_tag)
174 |           const labelErrorContainer = labelElement.closest(`.${labelErrorTemplate.getAttribute('class').replace(/ /g, '.')}`)
175 | 
176 |           if (!labelErrorContainer) {
177 |             labelElement.after(labelErrorTemplate)
178 |             labelErrorTemplate.querySelector('label#label_tag').replaceWith(labelElement)
179 |           }
180 |         }
181 | 
182 |         const labelMessageElement = form.querySelector(`label.message[for="${element.id}"]`)
183 | 
184 |         if (labelMessageElement) {
185 |           labelMessageElement.textContent = message
186 |         }
187 |       },
188 |       remove: ($element, settings) => {
189 |         const element = $element[0]
190 | 
191 |         const form = element.form
192 | 
193 |         const inputErrorClass = createElementFromHTML(settings.input_tag).getAttribute('class')
194 |         const inputErrorElement = element.closest(`.${inputErrorClass.replace(/ /g, '.')}`)
195 | 
196 |         if (inputErrorElement) {
197 |           inputErrorElement.querySelector(`#${element.id}`).remove()
198 |           inputErrorElement.replaceWith(element)
199 |         }
200 | 
201 |         const labelElement = form.querySelector(`label[for="${element.id}"]:not(.message)`)
202 | 
203 |         if (labelElement) {
204 |           const labelErrorClass = createElementFromHTML(settings.label_tag).getAttribute('class')
205 |           const labelErrorElement = labelElement.closest(`.${labelErrorClass.replace(/ /g, '.')}`)
206 | 
207 |           if (labelErrorElement) {
208 |             labelErrorElement.replaceWith(labelElement)
209 |           }
210 |         }
211 | 
212 |         const labelMessageElement = form.querySelector(`label.message[for="${element.id}"]`)
213 | 
214 |         if (labelMessageElement) {
215 |           labelMessageElement.remove()
216 |         }
217 |       }
218 |     }
219 |   },
220 |   patterns: {
221 |     numericality: {
222 |       default: /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$/,
223 |       only_integer: /^[+-]?\d+$/
224 |     }
225 |   },
226 |   selectors: {
227 |     inputs: ':input:not(button):not([type="submit"])[name]:visible:enabled',
228 |     validate_inputs: ':input:enabled:visible[data-csv-validate]',
229 |     forms: 'form[data-client-side-validations]'
230 |   },
231 |   validators: {
232 |     all: () => {
233 |       return {
234 |         ...ClientSideValidations.validators.local,
235 |         ...ClientSideValidations.validators.remote
236 |       }
237 |     },
238 |     local: {},
239 |     remote: {}
240 |   },
241 |   disable: (target) => {
242 |     const $target = jQuery(target)
243 | 
244 |     $target.off('.ClientSideValidations')
245 | 
246 |     if ($target.is('form')) {
247 |       ClientSideValidations.disable($target.find(':input'))
248 |     } else {
249 |       delete $target[0].dataset.csvValid
250 |       delete $target[0].dataset.csvChanged
251 |       $target.filter(':input').each(function () {
252 |         delete this.dataset.csvValidate
253 |       })
254 |     }
255 |   },
256 |   reset: (form) => {
257 |     const $form = jQuery(form)
258 | 
259 |     ClientSideValidations.disable(form)
260 | 
261 |     for (const key in form.ClientSideValidations.settings.validators) {
262 |       form.ClientSideValidations.removeError($form.find(`[name="${key}"]`))
263 |     }
264 | 
265 |     ClientSideValidations.enablers.form(form)
266 |   },
267 |   initializeOnEvent: () => {
268 |     if (window.Turbo != null) {
269 |       return 'turbo:load'
270 |     } else if ((window.Turbolinks != null) && window.Turbolinks.supported) {
271 |       return (window.Turbolinks.EVENTS != null) ? 'page:change' : 'turbolinks:load'
272 |     }
273 |   },
274 |   start: () => {
275 |     const initializeOnEvent = ClientSideValidations.initializeOnEvent()
276 | 
277 |     if (initializeOnEvent != null) {
278 |       jQuery(document).on(initializeOnEvent, () => jQuery(ClientSideValidations.selectors.forms).validate())
279 |     } else {
280 |       jQuery(() => jQuery(ClientSideValidations.selectors.forms).validate())
281 |     }
282 |   }
283 | }
284 | 
285 | export default ClientSideValidations
286 | 


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