pcai_client_side_validations 3.1.5 → 3.2.1

data/lib/client_side_validations/action_view/form_helper.rb

@@ -1,86 +0,0 @@
-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]
-
-        content_for_name = options[:validate] unless options[:validate] == true
-
-        # 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 content_for_name
-        content_for(content_for_name) { script.html_safe }
-        script = nil
-      end
-      "#{form}#{script}".html_safe
-    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 ? args.last[:validators] : {}) if @validators
-      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
-          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
-          "window['#{var_name}'] = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};".html_safe
-        end
-
-      end
-    end
-
-  end
-end
-

data/lib/client_side_validations/action_view/form_tag_helper.rb

@@ -1,12 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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
-
-    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))
-              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
-  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

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

data/lib/client_side_validations/active_model/exclusion.rb

@@ -1,15 +0,0 @@
-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

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

data/lib/client_side_validations/active_model/inclusion.rb

@@ -1,15 +0,0 @@
-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

@@ -1,24 +0,0 @@
-module ClientSideValidations::ActiveModel
-  module Length
-
-    def client_side_hash(model, attribute)
-      options = self.options.dup
-      hash    = { :messages => {} }
-      hash[:js_tokenizer] = options[:js_tokenizer] if options[:js_tokenizer]
-      hash[:allow_blank]  = true if options[:allow_blank]
-
-      self.class::MESSAGES.each do |option, message_type|
-        if count = options[option]
-          options[:message] = options[message_type]
-          options.delete(:message) if options[:message].nil?
-          hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(:count => count))
-          hash[option] = count
-        end
-      end
-
-      hash
-    end
-
-  end
-end
-

data/lib/client_side_validations/active_model/numericality.rb

@@ -1,31 +0,0 @@
-module ClientSideValidations::ActiveModel
-  module Numericality
-
-    OPTION_MAP = {}
-
-    def self.included(base)
-      OPTION_MAP.merge!(base::CHECKS.keys.inject({}) { |hash, key| hash.merge!(key => key) })
-    end
-
-    def client_side_hash(model, attribute)
-      options = self.options.dup
-      hash    = { :messages => { :numericality => model.errors.generate_message(attribute, :not_a_number, options) } }
-
-      if options[:only_integer]
-        hash[:messages][:only_integer] = model.errors.generate_message(attribute, :not_an_integer, options)
-        hash[:only_integer] = true
-      end
-
-      OPTION_MAP.each do |option, message_type|
-        if count = options[option]
-          hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(:count => count))
-          hash[option] = count
-        end
-      end
-
-      hash
-    end
-
-  end
-end
-

data/lib/client_side_validations/active_model/presence.rb

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

data/lib/client_side_validations/active_record.rb

@@ -1,11 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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'
-        if t.engine.connection.instance_variable_get("@config")[:adapter] == 'mysql'
-          relation = Arel::Nodes::SqlLiteral.new("BINARY #{t[attribute].eq(value).to_sql}")
-        else
-          relation = t[attribute].eq(value)
-        end
-      else
-        relation = t[attribute].matches(value)
-      end
-
-      if relation.is_a?(Arel::Nodes::SqlLiteral)
-        relation = Arel::Nodes::SqlLiteral.new("BINARY #{t[attribute].eq(value).to_sql} AND #{t.primary_key.not_eq(params[:id]).to_sql}")
-      else
-        relation = relation.and(t.primary_key.not_eq(params[:id])) if params[:id]
-      end
-
-      (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

@@ -1,28 +0,0 @@
-module ClientSideValidations::ActiveRecord
-  module Uniqueness
-    def client_side_hash(model, attribute)
-      hash = {}
-      hash[:message] = model.errors.generate_message(attribute, message_type, options.except(:scope))
-      hash[:case_sensitive] = options[:case_sensitive]
-      hash[:id] = model.id unless model.new_record?
-      if options.key?(:scope) && options[:scope].present?
-        hash[:scope] = Array.wrap(options[:scope]).inject({}) do |scope_hash, scope_item|
-          scope_hash.merge!(scope_item => model.send(scope_item))
-        end
-      end
-
-      unless model.class.name.demodulize == model.class.name
-        hash[:class] = model.class.name.underscore
-      end
-
-      hash
-    end
-
-    private
-
-    def message_type
-      :taken
-    end
-  end
-end
-

data/lib/client_side_validations/core_ext.rb

@@ -1,3 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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/engine.rb

@@ -1,6 +0,0 @@
-module ClientSideValidations
-  class Engine < ::Rails::Engine
-    config.app_middleware.use ClientSideValidations::Middleware::Validators
-  end
-end
-

data/lib/client_side_validations/files.rb

@@ -1,8 +0,0 @@
-# This is only used by dependant libraries that need to find the files
-
-module ClientSideValidations
-  module Files
-    Initializer = File.expand_path(File.dirname(__FILE__) + '/../generators/templates/client_side_validations/initializer.rb')
-    Javascript  = File.expand_path(File.dirname(__FILE__) + '/../../vendor/assets/javascripts/rails.validations.js')
-  end
-end

data/lib/client_side_validations/formtastic.rb

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

data/lib/client_side_validations/middleware.rb

@@ -1,81 +0,0 @@
-# encoding: utf-8
-
-require 'client_side_validations/core_ext'
-
-module ClientSideValidations
-
-  module Middleware
-    class Validators
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        case env['PATH_INFO']
-        when %r{\/validators\/(\w+)}
-          "::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
-        elsif (defined?(::MongoMapper::Document) && klass.included_modules.include?(::MongoMapper::Document))
-          middleware_klass = ClientSideValidations::MongoMapper::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
-
-end
-