pcai_client_side_validations 3.2.1 → 3.2.2

data/client_side_validations.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "client_side_validations/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pcai_client_side_validations"
+  s.version     = ClientSideValidations::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Brian Cardarella"]
+  s.email       = ["bcardarella@gmail.com"]
+  s.homepage    = "https://github.com/bcardarella/client_side_validations"
+  s.summary     = %q{Client Side Validations}
+  s.description = %q{Client Side Validations}
+
+  s.files         = Dir.glob("{lib}/**/*") + Dir.glob("{vendor}/**/*") + Dir.glob("*.gemspec")
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rails', '~> 3.2.0'
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'mocha'
+
+  # For QUnit testing
+  s.add_development_dependency 'sinatra', '~> 1.0'
+  s.add_development_dependency 'shotgun'
+  s.add_development_dependency 'thin'
+  s.add_development_dependency 'json'
+  s.add_development_dependency 'coffee-script'
+end

data/lib/client_side_validations.rb

@@ -0,0 +1,18 @@
+module ClientSideValidations
+  module Config
+    class << self
+      attr_accessor :uniqueness_validator_disabled
+      @uniqueness_validator_disabled = false
+    end
+  end
+end
+
+require 'client_side_validations/active_model'  if defined?(::ActiveModel)
+require 'client_side_validations/active_record' if defined?(::ActiveRecord)
+require 'client_side_validations/action_view'   if defined?(::ActionView)
+if defined?(::Rails)
+  require 'client_side_validations/generators'
+  require 'client_side_validations/middleware'
+  require 'client_side_validations/engine'
+end
+

data/lib/client_side_validations/action_view.rb

@@ -0,0 +1,14 @@
+module ClientSideValidations::ActionView
+  module Helpers
+  end
+end
+
+require 'client_side_validations/core_ext'
+require 'client_side_validations/action_view/form_helper'
+require 'client_side_validations/action_view/form_tag_helper'
+require 'client_side_validations/action_view/form_builder'
+
+ActionView::Base.send(:include, ClientSideValidations::ActionView::Helpers::FormHelper)
+ActionView::Base.send(:include, ClientSideValidations::ActionView::Helpers::FormTagHelper)
+ActionView::Helpers::FormBuilder.send(:include, ClientSideValidations::ActionView::Helpers::FormBuilder)
+

data/lib/client_side_validations/action_view/form_builder.rb

@@ -0,0 +1,176 @@
+module ClientSideValidations::ActionView::Helpers
+  module FormBuilder
+
+    def self.included(base)
+      (base.field_helpers.map(&:to_s) - %w(apply_form_for_options! label check_box radio_button fields_for hidden_field)).each do |selector|
+        base.class_eval <<-RUBY_EVAL
+          def #{selector}_with_client_side_validations(method, options = {})
+            apply_client_side_validators(method, options)
+            options.delete(:validate)
+            #{selector}_without_client_side_validations(method, options)
+          end
+        RUBY_EVAL
+
+        base.class_eval { alias_method_chain selector, :client_side_validations }
+      end
+
+      base.class_eval do
+        alias_method_chain :initialize,                :client_side_validations
+        alias_method_chain :fields_for,                :client_side_validations
+        alias_method_chain :check_box,                 :client_side_validations
+        alias_method_chain :radio_button,              :client_side_validations
+        alias_method_chain :select,                    :client_side_validations
+        alias_method_chain :collection_select,         :client_side_validations
+        alias_method_chain :grouped_collection_select, :client_side_validations
+        alias_method_chain :time_zone_select,          :client_side_validations
+
+        def self.client_side_form_settings(options, form_helper)
+          {
+            :type => self.to_s,
+            :input_tag => form_helper.class.field_error_proc.call(%{<span id="input_tag" />},  Struct.new(:error_message, :tag_id).new([], "")),
+            :label_tag => form_helper.class.field_error_proc.call(%{<label id="label_tag" />}, Struct.new(:error_message, :tag_id).new([], ""))
+          }
+        end
+      end
+    end
+
+    def initialize_with_client_side_validations(object_name, object, template, options, proc)
+      initialize_without_client_side_validations(object_name, object, template, options, proc)
+      @options[:validators] = {}
+    end
+
+    def fields_for_with_client_side_validations(record_or_name_or_array, *args, &block)
+      options = args.extract_options!
+      options[:validate] ||= @options[:validate] if @options[:validate] && !options.key?(:validate)
+      fields_for_without_client_side_validations(record_or_name_or_array, *(args << options), &block)
+    end
+
+    def check_box_with_client_side_validations(method, options = {}, checked_value = "1", unchecked_value = "0")
+      apply_client_side_validators(method, options)
+      check_box_without_client_side_validations(method, options, checked_value, unchecked_value)
+    end
+
+    def radio_button_with_client_side_validations(method, tag_value, options = {})
+      apply_client_side_validators(method, options)
+      radio_button_without_client_side_validations(method, tag_value, options)
+    end
+
+    def select_with_client_side_validations(method, choices, options = {}, html_options = {})
+      apply_client_side_validators(method, html_options)
+      select_without_client_side_validations(method, choices, options, html_options)
+    end
+
+    def collection_select_with_client_side_validations(method, collection, value_method, text_method, options = {}, html_options = {})
+      apply_client_side_validators(method, html_options)
+      collection_select_without_client_side_validations(method, collection, value_method, text_method, options, html_options)
+    end
+
+    def grouped_collection_select_with_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
+      apply_client_side_validators(method, html_options)
+      grouped_collection_select_without_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
+    end
+
+    def time_zone_select_with_client_side_validations(method, priority_zones = nil, options = {}, html_options = {})
+      apply_client_side_validators(method, html_options)
+      time_zone_select_without_client_side_validations(method, priority_zones = nil, options, html_options)
+    end
+
+  private
+
+    def apply_client_side_validators(method, options = {})
+      if @options[:validate] && options[:validate] != false && validators = filter_validators(method, options[:validate])
+        options.merge!("data-validate" => true)
+        name = options[:name] || "#{@object_name}[#{method}]"
+        child_index = @options[:child_index] ? "(\\d+|#{Regexp.escape(@options[:child_index])})" : "\\d+"
+        name = name.gsub(/_attributes\]\[#{child_index}\]/, '_attributes][]')
+        @options[:validators].merge!("#{name}#{options[:multiple] ? "[]" : nil}" => validators)
+      end
+    end
+
+    def filter_validators(method, filters)
+      if validators = @object.client_side_validation_hash[method]
+        unfiltered_validators = validators.inject({}) do |unfiltered_validators, validator|
+          unfiltered_validators[validator.first] = validator.last
+          if has_filter_for_validator?(validator, filters)
+            if filter_validator?(validator, filters)
+              unfiltered_validators.delete(validator.first)
+            elsif force_validator_despite_conditional?(validator, filters) && !can_run_validator?(validator, method)
+              unfiltered_validators.delete(validator.first)
+            end
+          else
+            if (conditional = (validator.last[:if] || validator.last[:unless]))
+              result = case conditional
+                when Symbol
+                  if @object.respond_to?(conditional)
+                    @object.send(conditional)
+                  else
+                    raise(ArgumentError, "unknown method called '#{conditional}'")
+                  end
+                when String
+                  eval(conditional)
+                when Proc
+                  conditional.call(@object)
+                end
+
+              # :if was specified and result is false OR :unless was specified and result was true
+              if (validator.last[:if] && !result) || (validator.last[:unless] && result)
+                unfiltered_validators.delete(validator.first)
+              end
+            end
+          end
+          unfiltered_validators[validator.first].delete(:if)     if unfiltered_validators[validator.first]
+          unfiltered_validators[validator.first].delete(:unless) if unfiltered_validators[validator.first]
+          unfiltered_validators
+        end
+
+        unfiltered_validators.empty? ? nil : unfiltered_validators
+      end
+    end
+
+    def has_filter_for_validator?(validator, filters)
+      filters && (filters == true || filters.key?(validator.first))
+    end
+
+    def filter_validator?(validator, filters)
+      filters != true && filters[validator.first] == false
+    end
+
+    def force_validator_despite_conditional?(validator, filters)
+      filters == true || filters[validator.first] == true
+    end
+
+    def can_run_validator?(validator, method)
+      result        = true
+      if_result     = run_if_validator(validator.last[:if], method)
+      unless_result = run_unless_validator(validator.last[:unless], method)
+      result        = result && if_result unless if_result.nil?
+      result        = result && unless_result unless unless_result.nil?
+      result
+    end
+
+    def run_if_validator(conditional, method)
+      if conditional
+        if conditional.is_a?(Symbol)
+          conditional_method_is_change_method?(conditional, method) ? true : !!@object.send(conditional)
+        else
+          !!conditional.call(@object)
+        end
+      end
+    end
+
+    def run_unless_validator(conditional, method)
+      if conditional
+        if conditional.is_a?(Symbol)
+          conditional_method_is_change_method?(conditional, method) ? true : !@object.send(conditional)
+        else
+          !conditional.call(@object)
+        end
+      end
+    end
+
+    def conditional_method_is_change_method?(conditional, method)
+      conditional.to_sym == "#{method}_changed?".to_sym
+    end
+  end
+end
+

data/lib/client_side_validations/action_view/form_helper.rb

@@ -0,0 +1,105 @@
+module ClientSideValidations::ActionView::Helpers
+  module FormHelper
+    class Error < StandardError; end
+
+    def form_for(record_or_name_or_array, *args, &proc)
+      options = args.extract_options!
+      if options[:validate]
+
+        # Always turn off HTML5 Validations
+        options[:html] ||= {}
+        options[:html][:novalidate] = 'novalidate'
+
+        case record_or_name_or_array
+        when String, Symbol
+          raise ClientSideValidations::ActionView::Helpers::FormHelper::Error, 'Using form_for(:name, @resource) is deprecated in Rails and is not supported with ClientSideValidations. Please use form_for(@resource, :as => :name) instead.'
+        when Array
+          object = record_or_name_or_array.last
+        else
+          object = record_or_name_or_array
+        end
+      end
+
+      @validators = {}
+
+      # Order matters here. Rails mutates the options object
+      script = client_side_form_settings(object, options)
+      form   = super(record_or_name_or_array, *(args << options), &proc)
+
+      # Because of the load order requirement above this sub is necessary
+      # Would be nice to not do this
+      script = insert_validators_into_script(script)
+
+      if assign_script_to_content_for(options[:validate], script)
+        form.html_safe
+      else
+        "#{form}#{script}".html_safe
+      end
+    end
+
+    def assign_script_to_content_for(name, script)
+      if name && name != true
+        content_for(name) { script.html_safe }
+        true
+      end
+    end
+
+    def apply_form_for_options!(object_or_array, options)
+      super
+      options[:html][:validate] = true if options[:validate]
+    end
+
+    def fields_for(record_or_name_or_array, *args, &block)
+      output = super
+      @validators.merge!(args.last[:validators]) if @validators && !args.last[:validators].nil?
+      output
+    end
+
+    private
+
+    def insert_validators_into_script(script)
+      # There is probably a more performant way of doing this
+      # But using String#sub has some issues. Undocumented "features"
+      if script
+        script = script.split(/"validator_hash"/)
+        script = "#{script[0]}#{@validators.to_json}#{script[1]}"
+      end
+
+      script
+    end
+
+    def client_side_form_settings(object, options)
+      if options[:validate]
+        builder = options[:builder] || ActionView::Base.default_form_builder
+
+        if options[:html] && options[:html][:id]
+          var_name = options[:html][:id]
+        else
+          if Rails.version >= '3.2.0'
+            var_name = if object.respond_to?(:persisted?) && object.persisted?
+              options[:as] ? "edit_#{options[:as]}" : [options[:namespace], dom_id(object, :edit)].compact.join("_")
+            else
+              options[:as] ? "new_#{options[:as]}" : [options[:namespace], dom_id(object)].compact.join("_")
+            end
+          else
+            # This is to maintain backward compatibility with Rails 3.1
+            # see: https://github.com/rails/rails/commit/e29773f885fd500189ffd964550ae20061d745ba#commitcomment-948052
+            var_name = if object.respond_to?(:persisted?) && object.persisted?
+              options[:as] ? "#{options[:as]}_edit" : dom_id(object, :edit)
+            else
+              options[:as] ? "#{options[:as]}_new" : dom_id(object)
+            end
+          end
+          
+          
+        end
+
+        content_tag(:script) do
+          "//<![CDATA[\nwindow.ClientSideValidations.forms['#{var_name}'] = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};\n//]]>".html_safe
+        end
+      end
+    end
+
+  end
+end
+

data/lib/client_side_validations/action_view/form_tag_helper.rb

@@ -0,0 +1,12 @@
+module ClientSideValidations::ActionView::Helpers
+  module FormTagHelper
+    private
+      def html_options_for_form(url_for_options, options, *parameters_for_url)
+        options.stringify_keys!
+        html_options = {}
+        html_options['data-validate'] = options.delete('validate') if options['validate']
+        html_options.merge!(super(url_for_options, options, *parameters_for_url))
+      end
+  end
+end
+

data/lib/client_side_validations/active_model.rb

@@ -0,0 +1,68 @@
+require 'client_side_validations/core_ext'
+
+module ClientSideValidations::ActiveModel
+  module Validator
+
+    def client_side_hash(model, attribute)
+      options = self.options.dup
+      { :message => model.errors.generate_message(attribute, message_type, options) }.merge(options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:allow_blank, :if, :unless]))
+    end
+
+    def copy_conditional_attributes(to, from)
+      [:if, :unless].each { |key| to[key] = from[key] if from[key].present? }
+    end
+
+    private
+
+    def message_type
+      kind
+    end
+  end
+
+  module Validations
+    def client_side_validation_hash
+      @client_side_validation_hash ||= _validators.inject({}) do |attr_hash, attr|
+        unless [nil, :block].include?(attr[0])
+
+          validator_hash = attr[1].inject({}) do |kind_hash, validator|
+            client_side_hash = validator.client_side_hash(self, attr[0])
+            # Yeah yeah, #new_record? is not part of ActiveModel :p
+            if can_use_for_client_side_validation?(client_side_hash, validator) && uniqueness_validations_allowed_or_not_applicable?(validator)
+              kind_hash.merge!(validator.kind => client_side_hash.except(:on))
+            else
+              kind_hash.merge!({})
+            end
+          end
+
+          if validator_hash.present?
+            attr_hash.merge!(attr[0] => validator_hash)
+          else
+            attr_hash
+          end
+        else
+          attr_hash
+        end
+      end
+    end
+
+    private
+
+    def can_use_for_client_side_validation?(client_side_hash, validator)
+      ((self.respond_to?(:new_record?) && validator.options[:on] == (self.new_record? ? :create : :update)) || validator.options[:on].nil?) && validator.kind != :block
+    end
+
+    def uniqueness_validations_allowed_or_not_applicable?(validator)
+      validator.kind != :uniqueness || !ClientSideValidations::Config.uniqueness_validator_disabled
+    end
+  end
+end
+
+ActiveModel::Validator.send(:include, ClientSideValidations::ActiveModel::Validator)
+ActiveModel::Validations.send(:include, ClientSideValidations::ActiveModel::Validations)
+
+%w{acceptance exclusion inclusion length format numericality presence}.each do |validator|
+  require "client_side_validations/active_model/#{validator}"
+  validator.capitalize!
+  eval "ActiveModel::Validations::#{validator}Validator.send(:include, ClientSideValidations::ActiveModel::#{validator})"
+end
+

data/lib/client_side_validations/active_model/acceptance.rb

@@ -0,0 +1,10 @@
+module ClientSideValidations::ActiveModel
+  module Acceptance
+    private
+
+    def message_type
+      :accepted
+    end
+  end
+end
+

data/lib/client_side_validations/active_model/exclusion.rb

@@ -0,0 +1,15 @@
+module ClientSideValidations::ActiveModel
+  module Exclusion
+
+    def client_side_hash(model, attribute)
+      hash = super
+      if hash[:in].is_a?(Range)
+        hash[:range] = hash[:in]
+        hash.delete(:in)
+      end
+      hash
+    end
+
+  end
+end
+