adamhunter-client_side_validations 2.9.10

data/lib/client_side_validations.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'json'
+require 'cgi'
+
+module ClientSideValidations
+  def self.default_options=(options)
+    @default_options = options
+  end
+  
+  def self.default_options
+    @default_options
+  end
+  
+  class Uniqueness
+    def initialize(app)
+      @app = app
+    end
+  
+    def call(env)
+      # By default CGI::parse will instantize a hash that defaults nil elements to [].
+      # We need to override this
+      case env['PATH_INFO']
+      when %r{^/validations/uniqueness.json}
+        params              = {}.merge!(CGI::parse(env['QUERY_STRING']))
+        field               = params.keys.first
+        resource, attribute = field.split(/[^\w]/)
+        value               = params[field][0]
+        # Because params returns an array for each field value we want to always grab
+        # the first element of the array for id, even if it is nil
+        id                  = [params["#{resource}[id]"]].flatten.first
+        body                = is_unique?(resource, attribute, value, id).to_s
+        [200, {'Content-Type' => 'application/json', 'Content-Length' => "#{body.length}"}, [body]]
+      else
+        @app.call(env)
+      end
+    end
+  
+    private
+  
+    def is_unique?(resource, attribute, value, id = nil)
+      klass    = constantize_resource(resource)
+      instance = nil
+      instance = klass.send("find_by_#{attribute}", value)
+    
+      if instance
+        return instance.id.to_i == id.to_i
+      else
+        return true
+      end
+    end
+  
+    def constantize_resource(resource)
+      eval(resource.split('_').map{ |word| word.capitalize}.join)
+    end
+  end
+end
+
+require 'client_side_validations/orm'
+require 'client_side_validations/template'
+require 'client_side_validations/rails' if defined?(Rails)

data/lib/client_side_validations/adapters/action_view.rb

@@ -0,0 +1,153 @@
+module ClientSideValidations
+  module Adapters
+    module ActionView
+      module BaseMethods
+        
+        def self.included(base)
+          form_method = base.instance_method(:form_for)
+          base.class_eval do
+            attr_accessor :validate_options
+            
+            define_method(:form_for) do |record_or_name_or_array, *args, &proc|
+              options = args.extract_options!.symbolize_keys!
+              script = ""
+              if validations = options.delete(:validations)
+                set_validate_options(validations, record_or_name_or_array, options)
+                unless options.has_key?(:html)
+                  options[:html] = {}
+                end
+                options[:html]['data-csv'] = validate_options.delete('data-csv')
+                script = %{<script type='text/javascript'>var #{options[:html]['data-csv']}_validate_options=#{validate_options.to_json};</script>}
+              end
+              args << options
+              result = form_method.bind(self).call(record_or_name_or_array, *args, &proc)
+              if rails3?
+                result += script.html_safe
+              else
+                concat(script)
+              end
+              result
+            end
+          end
+        end
+        
+        private
+        
+        def rails3?
+          version =
+            if defined?(ActionPack::VERSION::MAJOR)
+              ActionPack::VERSION::MAJOR
+            end
+          !version.blank? && version >= 3
+        end
+        
+        def set_validate_options(validations, record_or_name_or_array, form_for_options)
+          options = ::ClientSideValidations.default_options || { }
+          
+          case validations
+          when true
+            object_name      = get_object_name(record_or_name_or_array, form_for_options)
+            data_csv         = get_data_csv(record_or_name_or_array, form_for_options)
+            validate_options = rules_and_messages(record_or_name_or_array)
+          when Hash
+            validations.symbolize_keys!
+            if validations.has_key?(:instance)
+              object_name      = get_object_name(validations[:instance], form_for_options)
+              data_csv         = get_data_csv(validations[:instance], form_for_options)
+              validate_options = validations[:instance].validate_options
+            elsif validations.has_key?(:class)
+              object_name      = get_object_name(validations[:class], form_for_options)
+              data_csv         = get_data_csv(validations[:class], form_for_options)
+              validate_options = validations[:class].new.validate_options
+            else
+              object_name      = get_object_name(record_or_name_or_array, form_for_options)
+              data_csv         = get_data_csv(record_or_name_or_array, form_for_options)
+              validate_options = rules_and_messages(record_or_name_or_array)
+            end
+
+            options.merge!(validations[:options] || {})
+          else
+            object_name      = get_object_name(validations, form_for_options)
+            data_csv         = get_data_csv(validations, form_for_options)
+            validate_options = validations.new.validate_options
+          end
+          
+          self.validate_options = build_validate_options(object_name, validate_options, options, data_csv)
+        end
+        
+        def build_validate_options(object_name, validate_options, options, data_csv)
+          %w{rules messages}.each do |option|
+            validate_options[option].keys.each do |key|
+              validate_options[option]["#{object_name}[#{key}]"] = validate_options[option].delete(key)
+            end
+          end
+          
+          validate_options['options']  = options unless options.empty?
+          validate_options['data-csv'] = data_csv
+          validate_options
+        end
+        
+        def rules_and_messages(record_or_name_or_array)
+          case record_or_name_or_array
+          when String, Symbol
+            record_or_name_or_array.to_s.camelize.constantize.new.validate_options
+          when Array
+            rules_and_messages(record_or_name_or_array.last)
+          else
+            record_or_name_or_array.validate_options
+          end
+        end
+        
+        def get_data_csv(object, form_for_options)
+          case object
+          when String, Symbol
+            form_for_options[:as] || object.to_s
+          when Array
+            get_data_csv(object.last, form_for_options)
+          when Class
+            form_for_options[:as] || object.to_s.underscore
+          else
+            if object.respond_to?(:persisted?) && object.persisted?
+              form_for_options[:as] ? "#{form_for_options[:as]}_edit" : dom_id(object)
+            else
+              form_for_options[:as] ? "#{form_for_options[:as]}_new" : dom_id(object)
+            end
+          end
+        end
+        
+        def get_object_name(object, form_for_options)
+          case object
+          when String, Symbol
+            form_for_options[:as] || object.to_s
+          when Array
+            get_object_name(object.last, form_for_options)
+          when Class
+            get_object_name(object.new, form_for_options)
+          else
+            if rails3?
+              form_for_options[:as] || ::ActiveModel::Naming.singular(object)
+            else
+              form_for_options[:as] || ::ActionController::RecordIdentifier.singular_class_name(object)
+            end
+          end
+        end
+      end # BaseMethods
+      
+      module FormBuilderMethods
+      
+        def client_side_validations(options = {})
+          @template.send(:client_side_validations, @object_name, objectify_options(options))
+        end
+        
+      end # FormBuilderMethods
+    end
+  end
+end
+
+ActionView::Base.class_eval do
+  include ClientSideValidations::Adapters::ActionView::BaseMethods
+end
+
+ActionView::Helpers::FormBuilder.class_eval do
+  include ClientSideValidations::Adapters::ActionView::FormBuilderMethods
+end

data/lib/client_side_validations/adapters/active_model.rb

@@ -0,0 +1,137 @@
+require 'client_side_validations/adapters/orm_base'
+
+module ClientSideValidations
+  module Adapters
+    class ActiveModel < ORMBase
+
+      def validations_to_hash(attr)
+        base._validators[attr.to_sym].inject({}) do |hash, validation|
+          validation.instance_variable_set('@options', validation.options.dup)
+          hash.merge!(build_validation_hash(validation.dup))
+        end
+      end
+      
+      private
+
+      def build_validation_hash(validation, message_key = 'message')
+        if validation.kind == :inclusion || validation.kind == :exclusion
+          validation.options[:in] = validation.options[:in].to_a
+        end
+        
+        if validation.kind == :size
+          validation.kind = :length
+        end
+        
+        if validation.kind == :length &&
+          (range = (validation.options.delete(:within) || validation.options.delete(:in)))
+          validation.options[:minimum] = range.first
+          validation.options[:maximum] = range.last
+        elsif validation.kind == :inclusion || validation.kind == :exclusion
+          validation.options[:in] = validation.options[:in].to_a
+        end
+        
+        super
+      end
+
+      def supported_validation?(validation)
+        SupportedValidations.include?(validation.kind.to_sym)
+      end
+      
+      def get_validation_message(validation)
+        default = case validation.kind
+        when :presence
+          I18n.translate(i18n_prefix + 'errors.messages.blank')
+        when :format
+          I18n.translate(i18n_prefix + 'errors.messages.invalid')
+        when :length
+          if count = validation.options[:is]
+            I18n.translate(i18n_prefix + 'errors.messages.wrong_length').sub(orm_error_interpolation(:count), count.to_s)
+          elsif count = validation.options[:minimum]
+            I18n.translate(i18n_prefix + 'errors.messages.too_short').sub(orm_error_interpolation(:count), count.to_s)
+          elsif count = validation.options[:maximum]
+            I18n.translate(i18n_prefix + 'errors.messages.too_long').sub(orm_error_interpolation(:count), count.to_s)
+          end
+        when :numericality
+          if validation.options[:only_integer]
+            I18n.translate(i18n_prefix + 'errors.messages.not_a_number')
+          elsif count = validation.options[:greater_than]
+            I18n.translate(i18n_prefix + 'errors.messages.greater_than').sub(orm_error_interpolation(:count), count.to_s)
+          elsif count = validation.options[:greater_than_or_equal_to]
+            I18n.translate(i18n_prefix + 'errors.messages.greater_than_or_equal_to').sub(orm_error_interpolation(:count), count.to_s)
+          elsif count = validation.options[:less_than]
+            I18n.translate(i18n_prefix + 'errors.messages.less_than').sub(orm_error_interpolation(:count), count.to_s)
+          elsif count = validation.options[:less_than_or_equal_to]
+            I18n.translate(i18n_prefix + 'errors.messages.less_than_or_equal_to').sub(orm_error_interpolation(:count), count.to_s)
+          elsif validation.options[:odd]
+            I18n.translate(i18n_prefix + 'errors.messages.odd')
+          elsif validation.options[:even]
+            I18n.translate(i18n_prefix + 'errors.messages.even')
+          else
+            I18n.translate(i18n_prefix + 'errors.messages.not_a_number')
+          end
+        when :uniqueness
+          if defined?(ActiveRecord) && base.kind_of?(ActiveRecord::Base)
+            I18n.translate('activerecord.errors.messages.taken')
+          elsif defined?(Mongoid) && base.class.included_modules.include?(Mongoid::Document)
+            if ruby18?
+              I18n.translate('errors.messages.taken')
+            else
+              I18n.translate('activemodel.errors.messages.taken')
+            end
+          end
+        when :confirmation
+          I18n.translate(i18n_prefix + 'errors.messages.confirmation')
+        when :acceptance
+          I18n.translate(i18n_prefix + 'errors.messages.accepted')
+        when :inclusion
+          I18n.translate(i18n_prefix + 'errors.messages.inclusion')
+        when :exclusion
+          I18n.translate(i18n_prefix + 'errors.messages.exclusion')
+        end
+
+        message = validation.options.delete(:message)
+        if message.kind_of?(String)
+          message
+        elsif message.kind_of?(Symbol)
+          I18n.translate(i18n_prefix + "errors.models.#{base.class.to_s.downcase}.attributes.#{validation.attributes.first}.#{message}")
+        else
+          default
+        end
+      end
+
+      def get_validation_method(validation)
+        validation.kind.to_s
+      end
+      
+      def ruby18?
+        ruby_split[0] == '1' && ruby_split[1] == '8'
+      end
+
+      def ruby19?
+        ruby_split[0] == '1' && ruby_split[1] == '9'
+      end
+
+      def ruby_split
+        RUBY_VERSION.split('.')
+      end
+      
+      def i18n_prefix
+        if defined?(::ActiveModel)
+          ''
+        else # ActiveRecord 2.x
+          'activerecord.'
+        end
+      end
+      
+      def orm_error_interpolation(name)
+        if defined?(::ActiveModel)
+          "%{#{name}}"
+          
+        else # ActiveRecord 2.x
+          "{{#{name}}}"
+        end
+      end
+      
+    end
+  end
+end

data/lib/client_side_validations/adapters/orm_base.rb

@@ -0,0 +1,89 @@
+module ClientSideValidations
+  module Adapters
+    class ORMBase
+      attr_accessor :base
+      
+      def initialize(base)
+        self.base = base
+      end
+      
+      def validations_to_hash(attr)
+      end
+      
+      def validation_fields
+        []
+      end
+      
+      private
+
+      SupportedValidations = [:presence, :format, :length, :numericality, :uniqueness,
+        :confirmation, :acceptance, :inclusion, :exclusion]
+      
+      def build_validation_hash(validation, message_key = 'message')
+        if can_validate?(validation)
+          validation_hash = {}
+          message         = get_validation_message(validation)
+          options         = get_validation_options(validation)
+          method          = get_validation_method(validation)
+
+          if validation.options.has_key?(:minimum) && validation.options.has_key?(:maximum)
+            message_key       = 'message_min'
+            cloned_validation = validation.clone
+            cloned_validation.options.delete(:minimum)
+            validation_hash.merge!(build_validation_hash(cloned_validation, 'message_max'))
+          end
+          
+          new_validation_hash = { method => { message_key => message }.merge(options.stringify_keys) }
+          
+          unless validation_hash.empty?
+            validation_hash["length"].merge!(new_validation_hash["length"])
+            validation_hash
+          else
+            new_validation_hash
+          end
+        else
+          {}
+        end
+      end
+      
+      def can_validate?(validation)
+        if supported_validation?(validation)
+          if on = validation.options[:on]
+            on = on.to_sym
+            (on == :save) ||
+            (on == :create && base.new_record?) ||
+            (on == :update && !base.new_record?)
+          elsif(if_condition = (validation.options[:if] || validation.options[:allow_validation]))
+            base.instance_eval(if_condition.to_s)
+          elsif(unless_condition = (validation.options[:unless] || validation.options[:skip_validation]))
+            !base.instance_eval(unless_condition.to_s)
+          else
+            true
+          end
+        end
+      end
+
+      def get_validation_message(validation)
+      end
+
+      def get_validation_options(validation)
+        options = validation.options.clone
+        options.symbolize_keys!
+        deleteable_keys = [:on, :tokenizer, :allow_nil, :case_sensitive, :accept, :if, :unless, :allow_validation]
+        options.delete(:maximum) if options.has_key?(:minimum)
+        options.delete_if { |k, v| deleteable_keys.include?(k) }
+        if options[:with].kind_of?(Regexp)
+          options[:with] = options[:with].inspect.to_s.gsub("\\A","^").gsub("\\Z","$").sub(%r{^/},"").sub(%r{/i?$}, "")
+        end
+        if options[:only_integer] == false
+          options.delete(:only_integer)
+        end
+        options
+      end
+      
+      def get_validation_method(validation)
+      end
+      
+    end
+  end
+end

data/lib/client_side_validations/orm.rb

@@ -0,0 +1,226 @@
+require 'client_side_validations/adapters/active_model'
+
+module ClientSideValidations
+  module ORM
+    def validate_options
+      ValidateOptions.new(self).to_hash
+    end
+
+    def validation_fields
+      self._validators.keys
+    end
+    
+    class ValidateOptions
+      attr_accessor :base
+      
+      def initialize(base)
+        self.base = base
+      end
+    
+      def to_hash
+        rules    = Hash.new { |h, field| h[field] = {} }
+        messages = Hash.new { |h, field| h[field] = {} }
+        base.validation_fields.each do |field|
+          validations = validations_for(field)
+          rules[field.to_s].merge!(extract_rules(validations, field))
+          messages[field.to_s].merge!(extract_messages(validations))
+        end
+        {"rules" => rules, "messages" => messages}
+      end
+
+      def validations_for(field)
+        adapter.validations_to_hash(field)
+      end
+
+      private
+
+      def convert_kind(kind, options = nil)
+        case kind
+        when 'acceptance', 'exclusion', 'inclusion', 'format', 'confirmation'
+          kind
+        when 'presence'
+          'required'
+        when 'numericality'
+          if options['only_integer']
+            'digits'
+          elsif options['greater_than']
+            'greater_than'
+          elsif options['greater_than_or_equal_to']
+            'min'
+          elsif options['less_than']
+            'less_than'
+          elsif options['less_than_or_equal_to']
+            'max'
+          elsif options['odd']
+            'odd'
+          elsif options['even']
+            'even'
+          else
+            'numericality'
+          end
+        when 'length'
+          if options['is']
+            'islength'
+          elsif options['minimum'] && options['maximum']
+            ['minlength', 'maxlength']
+          elsif options['minimum']
+            'minlength'
+          elsif options['maximum']
+            'maxlength'
+          end
+        when 'uniqueness'
+          'remote'
+        end
+      end
+
+      def extract_rules(validations, field = nil)
+        rules = {}
+        validations.each do |kind, options|
+          kind = convert_kind(kind, options)
+          value = case kind
+          when 'acceptance', 'required', 'digits', 'numericality', 'odd', 'even', 'confirmation'
+            true
+          when 'greater_than', 'less_than'
+            options[kind]
+          when 'max'
+            options['less_than_or_equal_to']
+          when 'min'
+            options['greater_than_or_equal_to']
+          when 'format'
+            options['with']
+          when 'exclusion', 'inclusion'
+            options['in']
+          when 'islength'
+            options['is']
+          when 'minlength'
+            options['minimum']
+          when 'maxlength'
+            options['maximum']
+          when 'remote'
+            if base.new_record?
+              data = {}
+            else
+              data = { "#{base.class.to_s.underscore}[id]" => base.id}
+            end
+            {'url' => '/validations/uniqueness.json', 'data' => data}
+          end
+
+          unless Array === kind
+            rules[kind] = value
+          else
+            kind.each do |k|
+              special_rule = case k
+              when 'minlength'
+                options['minimum']
+              when 'maxlength'
+                options['maximum']
+              end
+        
+              rules[k] = special_rule
+            end
+          end
+    
+          if numericality?(kind)
+            unless rules['numericality'] || rules['digits']
+              rules['numericality'] = true
+            end
+          end
+
+          if required?(kind, options)
+            unless rules['required']
+              rules['required'] = true
+            end
+          end
+    
+        end
+        rules
+      end
+
+      def extract_messages(validations)
+        messages = {}
+        validations.each do |kind, options|
+          kind = convert_kind(kind, options)
+          unless Array === kind
+            messages[kind] = options['message']
+          else
+            kind.each do |k|
+              special_message = case k
+              when 'minlength'
+                options['message'] = options['message_min']
+                'message_min'
+              when 'maxlength'
+                'message_max'
+              end
+
+              messages[k] = options[special_message]
+            end
+          end
+
+          if numericality?(kind)
+            messages['numericality'] = I18n.translate(i18n_prefix + 'errors.messages.not_a_number')
+          end
+
+          if required?(kind, options)
+            unless messages['required']
+              if ['greater_than', 'min', 'less_than', 'max', 'odd', 'even'].include?(kind)
+                messages['required']     = I18n.translate(i18n_prefix + 'errors.messages.not_a_number')
+              else
+                messages['required'] = options['message']
+              end
+            end
+          end
+        end
+        messages
+      end
+
+      def i18n_prefix
+        if defined?(::ActiveModel)
+          ''
+        else # ActiveRecord 2.x
+          'activerecord.'
+        end
+      end
+
+      def numericality?(kind)
+        ['greater_than', 'min', 'less_than', 'max', 'even', 'odd'].include?(kind)
+      end
+
+      def required?(kind, options)
+        case kind
+        when 'digits', 'exclusion', 'inclusion', 'islength', 'minlength', 'remote', 'numericality', 'greater_than', 'min', 'less_than', 'max', 'even', 'odd', 'format'
+          !options['allow_blank']
+        when Array
+          required?('minlength', options) if kind.include?('minlength')
+        end
+      end
+
+      def adapter
+        unless @adapter
+          @adapter = ClientSideValidations::Adapters::ActiveModel.new(base)
+        end
+        @adapter
+      end
+    end
+  end
+end
+
+if defined?(::ActiveModel)
+  klass = ::ActiveModel::Validations
+
+elsif defined?(::ActiveRecord)
+  if ::ActiveRecord::VERSION::MAJOR == 2
+    require 'validation_reflection/active_model'
+    klass = ::ActiveRecord::Base
+    
+    ActiveRecord::Base.class_eval do
+      ::ActiveRecordExtensions::ValidationReflection.reflected_validations << :validates_size_of
+      ::ActiveRecordExtensions::ValidationReflection.install(self)
+    end
+  end
+end
+
+if klass
+  klass.class_eval do
+    include ClientSideValidations::ORM
+  end
+end