client_side_validations 2.9.9 → 3.0.0

data/lib/client_side_validations/action_view.rb

@@ -0,0 +1,13 @@
+module ClientSideValidations::ActionView
+  module Helpers
+  end
+end
+
+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,57 @@
+module ClientSideValidations::ActionView::Helpers
+  module FormBuilder
+
+    def self.included(base)
+      (base.field_helpers - %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 :fields_for, :client_side_validations
+        alias_method_chain :check_box, :client_side_validations
+        alias_method_chain :radio_button, :client_side_validations
+
+        def self.client_side_form_js_hash(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" />})
+          }
+        end
+      end
+    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
+
+  private
+
+    def apply_client_side_validators(method, options = {})
+      if @options[:validate] && options[:validate] != false && validators = @object.client_side_validation_hash[method]
+        options.merge!("data-validators" => validators.to_json)
+      end
+    end
+
+  end
+end

data/lib/client_side_validations/action_view/form_helper.rb

@@ -0,0 +1,58 @@
+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]
+
+        # Turn off SimpleForm's HTML5 Form Validations
+        if options[:builder].to_s == 'SimpleForm::FormBuilder'
+          options[:html][:novalidate] = true
+        end
+
+        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
+
+      script_tag = client_side_form_js_variable(object, options)
+      "#{super(record_or_name_or_array, *(args << options), &proc)}#{script_tag}".html_safe
+    end
+
+    def apply_form_for_options!(object_or_array, options)
+      super
+      options[:html][:validate] = true if options[:validate]
+    end
+
+    private
+
+    def client_side_form_js_variable(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
+          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
+
+        content_tag(:script) do
+          "var #{var_name} = #{builder.client_side_form_js_hash(options, self).to_json};".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,46 @@
+require 'client_side_validations/core_ext'
+
+module ClientSideValidations::ActiveModel
+  module Validator
+
+    def client_side_hash(model, attribute)
+      extra_options = options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:on, :allow_blank])
+      { :message => model.errors.generate_message(attribute, message_type, extra_options) }.merge(extra_options)
+    end
+
+    private
+
+    def message_type
+      kind
+    end
+  end
+
+  module Validations
+    def client_side_validation_hash
+      _validators.inject({}) do |attr_hash, attr|
+
+        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 ((self.respond_to?(:new_record?) && client_side_hash[:on] == (self.new_record? ? :create : :update)) || client_side_hash[:on].nil?)
+            kind_hash.merge!(validator.kind => client_side_hash.except(:on))
+          else
+            kind_hash.merge!({})
+          end
+        end
+
+        attr_hash.merge!(attr[0] => validator_hash)
+      end.delete_if { |key, value| value.blank? }
+    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
+

data/lib/client_side_validations/active_model/format.rb

@@ -0,0 +1,10 @@
+module ClientSideValidations::ActiveModel
+  module Format
+    private
+
+    def message_type
+      :invalid
+    end
+  end
+end
+

data/lib/client_side_validations/active_model/inclusion.rb

@@ -0,0 +1,15 @@
+module ClientSideValidations::ActiveModel
+  module Inclusion
+
+    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
+

data/lib/client_side_validations/active_model/length.rb

@@ -0,0 +1,22 @@
+module ClientSideValidations::ActiveModel
+  module Length
+
+    def client_side_hash(model, attribute)
+      extra_options = options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:allow_blank, :on]).except(:tokenizer, :too_long, :too_short, :wrong_length)
+
+      errors_options = options.except(*self.class::RESERVED_OPTIONS)
+      messages = extra_options.except(:js_tokenizer, :allow_blank, :on).keys.inject({}) do |hash, key|
+        errors_options[:count] = extra_options[key]
+        count = extra_options[key]
+        default_message = options[self.class::MESSAGES[key]]
+        errors_options[:message] ||= default_message if default_message
+
+        hash.merge!(key => model.errors.generate_message(attribute, self.class::MESSAGES[key], errors_options))
+      end
+
+      { :messages => messages }.merge(extra_options)
+    end
+
+  end
+end
+

data/lib/client_side_validations/active_model/numericality.rb

@@ -0,0 +1,26 @@
+module ClientSideValidations::ActiveModel
+  module Numericality
+
+    OPTION_MAP = {}
+
+    def self.included(base)
+      OPTION_MAP.merge!(base::CHECKS.keys.inject({}) { |hash, key| hash.merge!(key => key) })
+      OPTION_MAP.merge!(:numericality => :not_a_number, :only_integer => :not_an_integer)
+    end
+
+    def client_side_hash(model, attribute)
+      except_options = ::ActiveModel::Errors::CALLBACKS_OPTIONS - [:on] + [:message]
+      extra_options = options.except(*except_options).reject { |key, value| key == :only_integer && !value }
+      keys = [:numericality] | (extra_options.keys - [:message, :on])
+      filtered_options = options.except(*self.class::RESERVED_OPTIONS)
+      messages = keys.inject({}) do |hash, key|
+        count = extra_options[key]
+        hash.merge!(key => model.errors.generate_message(attribute, OPTION_MAP[key], filtered_options.merge(:count => count)))
+      end
+
+      { :messages => messages }.merge(extra_options)
+    end
+
+  end
+end
+

data/lib/client_side_validations/active_model/presence.rb

@@ -0,0 +1,10 @@
+module ClientSideValidations::ActiveModel
+  module Presence
+    private
+
+    def message_type
+      :blank
+    end
+  end
+end
+

data/lib/client_side_validations/active_record.rb

@@ -0,0 +1,11 @@
+require 'client_side_validations/active_model'
+require 'client_side_validations/active_record/middleware'
+
+%w{uniqueness}.each do |validator|
+  require "client_side_validations/active_record/#{validator}"
+  validator.capitalize!
+  eval "ActiveRecord::Validations::#{validator}Validator.send(:include, ClientSideValidations::ActiveRecord::#{validator})"
+end
+
+ActiveRecord::Base.send(:include, ClientSideValidations::ActiveModel::Validations)
+

data/lib/client_side_validations/active_record/middleware.rb

@@ -0,0 +1,25 @@
+module ClientSideValidations::ActiveRecord
+  class Middleware
+
+    def self.is_unique?(klass, attribute, value, params)
+      column = klass.columns_hash[attribute.to_s]
+      value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s if column.text?
+
+      t = klass.arel_table
+
+      if params[:case_sensitive] == 'true'
+        relation = t[attribute].eq(value)
+      else
+        relation = t[attribute].matches(value)
+      end
+
+      relation = relation.and(t[:id].not_eq(params[:id])) if params[:id]
+
+      (params[:scope] || {}).each do |key, value|
+        relation = relation.and(t[key].eq(value))
+      end
+
+      !klass.where(relation).exists?
+    end
+  end
+end

data/lib/client_side_validations/active_record/uniqueness.rb

@@ -0,0 +1,24 @@
+module ClientSideValidations::ActiveRecord
+  module Uniqueness
+    def client_side_hash(model, attribute)
+      extra_options = options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:on, :allow_blank])
+      hash = { :message => model.errors.generate_message(attribute, message_type, extra_options.except(:case_sensitive, :scope)) }
+      hash = hash.merge(extra_options).merge(model.new_record? ? {} : { :id => model.id })
+
+      if hash[:scope]
+        hash[:scope] = hash[:scope].inject({}) do |scope_hash, scope_item|
+          scope_hash.merge!(scope_item => model.send(scope_item))
+        end
+      end
+
+      hash
+    end
+
+    private
+
+    def message_type
+      :taken
+    end
+  end
+end
+

data/lib/client_side_validations/core_ext.rb

@@ -0,0 +1,3 @@
+require 'active_support/json'
+require 'client_side_validations/core_ext/range'
+require 'client_side_validations/core_ext/regexp'

data/lib/client_side_validations/core_ext/range.rb

@@ -0,0 +1,10 @@
+class Range
+  def as_json(options = nil)
+    [first, last]
+  end
+
+  def to_json(options = nil)
+    as_json(options).inspect
+  end
+end
+

data/lib/client_side_validations/core_ext/regexp.rb

@@ -0,0 +1,14 @@
+class Regexp
+  def as_json(options = nil)
+    Regexp.new inspect.sub("\\A","^").sub("\\Z","$").sub("\\z","$").sub(/^\//,"").sub(/\/[a-z]*$/,""), self.options
+  end
+
+  def to_json(options = nil)
+    as_json(options).inspect
+  end
+
+  def encode_json(encoder)
+    inspect
+  end
+end
+

data/lib/client_side_validations/formtastic.rb

@@ -0,0 +1,21 @@
+module ClientSideValidations
+  module Formtastic
+    module SemanticFormBuilder
+
+      def self.included(base)
+        base.class_eval do
+          def self.client_side_form_js_hash(options, form_helper)
+            {
+              :type => self.to_s,
+              :inline_error_class => ::Formtastic::SemanticFormBuilder.default_inline_error_class
+            }
+          end
+        end
+      end
+
+    end
+  end
+end
+
+Formtastic::SemanticFormBuilder.send(:include, ClientSideValidations::Formtastic::SemanticFormBuilder)
+

data/lib/client_side_validations/middleware.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+module ClientSideValidations
+
+  module Middleware
+
+    class Validators
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        case env['PATH_INFO']
+        when %r{\/validators\/(\w+)\.json}
+          "::ClientSideValidations::Middleware::#{$1.camelize}".constantize.new(env).response
+        else
+          @app.call(env)
+        end
+      end
+    end
+
+    class Base
+      attr_accessor :request, :body, :status
+
+      def initialize(env)
+        self.body    = ''
+        self.status  = 200
+        self.request = ActionDispatch::Request.new(env)
+      end
+
+      def response
+        [status, {'Content-Type' => content_type, 'Content-Length' => body.length.to_s}, [body]]
+      end
+
+      def content_type
+        'application/json'
+      end
+    end
+
+    class Uniqueness < Base
+      IGNORE_PARAMS = %w{case_sensitive id scope}
+
+      def response
+        if is_unique?
+          self.status = 404
+          self.body   = 'true'
+        else
+          self.status = 200
+          self.body   = 'false'
+        end
+        super
+      end
+
+      private
+
+      def is_unique?
+        resource = extract_resource
+        klass = resource.classify.constantize
+        attribute = request.params[resource].keys.first
+        value = request.params[resource][attribute]
+
+        if (defined?(::ActiveRecord::Base) && klass < ::ActiveRecord::Base)
+          middleware_klass = ClientSideValidations::ActiveRecord::Middleware
+        elsif (defined?(::Mongoid::Document) && klass.included_modules.include?(::Mongoid::Document))
+          middleware_klass = ClientSideValidations::Mongoid::Middleware
+        end
+
+        middleware_klass.is_unique?(klass, attribute, value, request.params)
+      end
+
+      def extract_resource
+        parent_key = (request.params.keys - IGNORE_PARAMS).first
+      end
+    end
+
+  end
+
+  class Engine < ::Rails::Engine
+    config.app_middleware.use ClientSideValidations::Middleware::Validators
+  end
+
+end
+