client_side_validations 2.4.2 → 2.5.2

data/lib/client_side_validations/adapters/active_model.rb

@@ -1,40 +1,14 @@
+require 'client_side_validations/adapters/orm_base'
+
 module DNCLabs
   module ClientSideValidations
     module Adapters
-      class ActiveModel
-        attr_accessor :base
-        
-        def initialize(base)
-          self.base = base
-        end
-        
-        def validation_to_hash(_attr, _options = {})
-          validation_hash = {}
-          base._validators[_attr.to_sym].each do |validation|
-            if can_validate?(validation) && supported_validation?(validation)
-              message = get_validation_message(validation, _options[:locale])
-              validation.options.delete(:message)
-              options = get_validation_options(validation.options)
-              method  = get_validation_method(validation.kind)
-              if conditional_method = remove_reserved_conditionals(options[:if])
-                if base.instance_eval(conditional_method.to_s)
-                  options.delete(:if)
-                  validation_hash[method] = { 'message' => message }.merge(options.stringify_keys)
-                end
-              elsif conditional_method = options[:unless]
-                unless base.instance_eval(conditional_method.to_s)
-                  options.delete(:unless)
-                  validation_hash[method] = { 'message' => message }.merge(options.stringify_keys)
-                end
-              else
-                options.delete(:if)
-                options.delete(:unless)
-                validation_hash[method] = { 'message' => message }.merge(options.stringify_keys)
-              end
-            end
-          end
+      class ActiveModel < ORMBase
 
-          validation_hash
+        def validation_to_hash(attr)
+          base._validators[attr.to_sym].inject({}) do |hash, validation|
+            hash.merge!(build_validation_hash(validation.clone))
+          end
         end
         
         def validation_fields
@@ -42,80 +16,62 @@ module DNCLabs
         end
         
         private
-        
-        def supported_validation?(validation)
-          [:presence, :format, :length, :numericality, :uniqueness,
-            :confirmation ].include?(validation.kind.to_sym)
-        end
-        
-        def can_validate?(validation)
-          if on = validation.options[:on]
-            on = on.to_sym
-            (on == :save) ||
-            (on == :create && base.new_record?) ||
-            (on == :update && !base.new_record?)
-          else
-            true
+
+        def build_validation_hash(validation, message_key = 'message')
+          if validation.kind == :inclusion || validation.kind == :exclusion
+            validation.options[:in] = validation.options[:in].to_a
           end
+          super
         end
 
-        def get_validation_message(validation, locale)
+        def supported_validation?(validation)
+          SupportedValidations.include?(validation.kind.to_sym)
+        end
+        
+        def get_validation_message(validation)
           default = case validation.kind
           when :presence
-            I18n.translate('errors.messages.blank', :locale => locale)
+            I18n.translate('errors.messages.blank')
           when :format
-            I18n.translate('errors.messages.invalid', :locale => locale)
+            I18n.translate('errors.messages.invalid')
           when :length
             if count = validation.options[:minimum]
-              I18n.translate('errors.messages.too_short', :locale => locale).sub('%{count}', count.to_s)
+              I18n.translate('errors.messages.too_short').sub('%{count}', count.to_s)
             elsif count = validation.options[:maximum]
-              I18n.translate('errors.messages.too_long', :locale => locale).sub('%{count}', count.to_s)
+              I18n.translate('errors.messages.too_long').sub('%{count}', count.to_s)
             end
           when :numericality
-            I18n.translate('errors.messages.not_a_number', :locale => locale)
+            I18n.translate('errors.messages.not_a_number')
           when :uniqueness
             if defined?(ActiveRecord) && base.kind_of?(ActiveRecord::Base)
-              I18n.translate('activerecord.errors.messages.taken', :locale => locale)
+              I18n.translate('activerecord.errors.messages.taken')
             elsif defined?(Mongoid) && base.class.included_modules.include?(Mongoid::Document)
-              I18n.translate('errors.messages.taken', :locale => locale)
+              I18n.translate('errors.messages.taken')
             end
           when :confirmation
-            I18n.translate('errors.messages.confirmation', :locale => locale)
+            I18n.translate('errors.messages.confirmation')
+          when :acceptance
+            I18n.translate('errors.messages.accepted')
+          when :inclusion
+            I18n.translate('errors.messages.inclusion')
+          when :exclusion
+            I18n.translate('errors.messages.exclusion')
           end
 
-          message = validation.options[:message]
+          message = validation.options.delete(:message)
           if message.kind_of?(String)
             message
           elsif message.kind_of?(Symbol)
-            I18n.translate("errors.models.#{base.class.to_s.downcase}.attributes.#{validation.attributes.first}.#{message}", :locale => locale)
+            I18n.translate("errors.models.#{base.class.to_s.downcase}.attributes.#{validation.attributes.first}.#{message}")
           else
             default
           end
         end
 
-        def get_validation_options(options)
-          options.symbolize_keys!
-          options.delete(:on) == :create
-          options.delete(:tokenizer)
-          options.delete(:only_integer)
-          options.delete(:allow_nil)
-          options.delete(:case_sensitive)
-          if options[:with].kind_of?(Regexp)
-            options[:with] = options[:with].inspect.to_s.sub("\\A","^").sub("\\Z","$").sub(%r{^/},"").sub(%r{/i?$}, "")
-          end
-          options
+        def get_validation_method(validation)
+          validation.kind.to_s
         end
         
-        def get_validation_method(kind)
-          kind.to_s
-        end
-        
-        def remove_reserved_conditionals(*conditionals)
-          conditionals.flatten!
-          conditionals.delete_if { |conditional| conditional =~ /@_/ }
-          conditionals.delete_if { |conditional| conditional =~ /validation_context/ }
-          conditionals.first
-        end
       end
     end
   end

data/lib/client_side_validations/adapters/active_record_2.rb

@@ -1,40 +1,15 @@
 require 'validation_reflection'
+require 'client_side_validations/adapters/orm_base'
 
 module DNCLabs
   module ClientSideValidations
     module Adapters
-      class ActiveRecord2
-        attr_accessor :base
-        
-        def initialize(base)
-          self.base = base
-        end
-        
-        def validation_to_hash(attr, options = {})
-          validation_hash = {}
-          base.class.reflect_on_validations_for(attr).each do |validation|
-            if can_validate?(validation) && supported_validation?(validation)
-              message = get_validation_message(validation, options[:locale])
-              validation.options.delete(:message)
-              options = get_validationoptions(validation.options)
-              method  = get_validation_method(validation.macro)
-              if conditional_method = options[:if]
-                if base.instance_eval(conditional_method.to_s)
-                  options.delete(:if)
-                  validation_hash[method] = { 'message' => message }.merge(options.stringify_keys)
-                end
-              elsif conditional_method = options[:unless]
-                unless base.instance_eval(conditional_method.to_s)
-                  options.delete(:unless)
-                  validation_hash[method] = { 'message' => message }.merge(options.stringify_keys)
-                end
-              else
-                validation_hash[method] = { 'message' => message }.merge(options.stringify_keys)
-              end
-            end
-          end
+      class ActiveRecord2 < ORMBase
 
-          validation_hash
+        def validation_to_hash(attr)
+          base.class.reflect_on_validations_for(attr).inject({}) do |hash, validation|
+            hash.merge!(build_validation_hash(validation.clone))
+          end
         end
         
         def validation_fields
@@ -43,79 +18,60 @@ module DNCLabs
         
         private
         
-        def supported_validation?(validation)
-          [:validates_presence_of, :validates_format_of, :validates_length_of,
-           :validates_numericality_of, :validates_uniqueness_of,
-           :validates_confirmation_of].include?(validation.macro.to_sym)
+        def build_validation_hash(validation, message_key = 'message')
+          if validation.macro == :validates_length_of &&
+            (range = (validation.options.delete(:within) || validation.options.delete(:in)))
+            validation.options[:minimum] = range.first
+            validation.options[:maximum] = range.last
+          elsif validation.macro == :validates_inclusion_of || validation.macro == :validates_exclusion_of
+            validation.options[:in] = validation.options[:in].to_a
+          end
+          super
         end
         
-        def can_validate?(validation)
-          if on = validation.options[:on]
-            on = on.to_sym
-            (on == :save) ||
-            (on == :create && base.new_record?) ||
-            (on == :update && !base.new_record?)
-          else
-            true
-          end
+        def supported_validation?(validation)
+          SupportedValidations.include?(validation.macro.to_s.match(/\w+_(\w+)_\w+/)[1].to_sym)
         end
-
-        def get_validation_message(validation, locale)
+        
+        def get_validation_message(validation)
           default = case validation.macro.to_sym
           when :validates_presence_of
-            I18n.translate('activerecord.errors.messages.blank', :locale => locale)
+            I18n.translate('activerecord.errors.messages.blank')
           when :validates_format_of
-            I18n.translate('activerecord.errors.messages.invalid', :locale => locale)
+            I18n.translate('activerecord.errors.messages.invalid')
           when :validates_length_of
             if count = validation.options[:minimum]
-              I18n.translate('activerecord.errors.messages.too_short', :locale => locale).sub('{{count}}', count.to_s)
+              I18n.translate('activerecord.errors.messages.too_short').sub('{{count}}', count.to_s)
             elsif count = validation.options[:maximum]
-              I18n.translate('activerecord.errors.messages.too_long', :locale => locale).sub('{{count}}', count.to_s)
+              I18n.translate('activerecord.errors.messages.too_long').sub('{{count}}', count.to_s)
             end
           when :validates_numericality_of
-            I18n.translate('activerecord.errors.messages.not_a_number', :locale => locale)
+            I18n.translate('activerecord.errors.messages.not_a_number')
           when :validates_uniqueness_of
-            I18n.translate('activerecord.errors.messages.taken', :locale => locale)
+            I18n.translate('activerecord.errors.messages.taken')
           when :validates_confirmation_of
-            I18n.translate('activerecord.errors.messages.confirmation', :locale => locale)
+            I18n.translate('activerecord.errors.messages.confirmation')
+          when :validates_acceptance_of
+            I18n.translate('activerecord.errors.messages.accepted')
+          when :validates_inclusion_of
+            I18n.translate('activerecord.errors.messages.inclusion')
+          when :validates_exclusion_of
+            I18n.translate('activerecord.errors.messages.exclusion')
           end
-
-          message = validation.options[:message]
+          
+          message = validation.options.delete(:message)
           if message.kind_of?(String)
             message
           elsif message.kind_of?(Symbol)
-            I18n.translate("activerecord.errors.models.#{base.class.to_s.downcase}.attributes.#{validation.name}.#{message}", :locale => locale)
+            I18n.translate("activerecord.errors.models.#{base.class.to_s.downcase}.attributes.#{validation.name}.#{message}")
           else
             default
           end
         end
 
-        def get_validationoptions(options)
-          options.symbolize_keys!
-          options.delete(:on)
-          if options[:with].kind_of?(Regexp)
-            options[:with] = options[:with].inspect.to_s.sub("\\A","^").sub("\\Z","$").sub(%r{^/},"").sub(%r{/i?$}, "")
-          end
-          options
-        end
-        
-        def get_validation_method(method)
-          method = case method.to_sym
-          when :validates_presence_of
-            :presence
-          when :validates_format_of
-            :format
-          when :validates_numericality_of
-            :numericality
-          when :validates_length_of
-            :length
-          when :validates_uniqueness_of
-            :uniqueness
-          when :validates_confirmation_of
-            :confirmation
-          end
-          
-          method.to_s
+        def get_validation_method(validation)
+          method = validation.macro.to_s
+          method.match(/\w+_(\w+)_\w+/)[1]
         end
       end
     end

data/lib/client_side_validations/adapters/orm_base.rb

@@ -0,0 +1,88 @@
+module DNCLabs
+  module ClientSideValidations
+    module Adapters
+      class ORMBase
+        attr_accessor :base
+        
+        def initialize(base)
+          self.base = base
+        end
+        
+        def validation_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]
+              base.instance_eval(if_condition.to_s)
+            elsif unless_condition = validation.options[:unless]
+              !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, :only_integer, :allow_nil, :case_sensitive, :accept, :if, :unless]
+          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.sub("\\A","^").sub("\\Z","$").sub(%r{^/},"").sub(%r{/i?$}, "")
+          end
+          options
+        end
+        
+        def get_validation_method(validation)
+        end
+        
+      end
+    end
+  end
+end

data/lib/client_side_validations/orm.rb

@@ -8,8 +8,8 @@ module DNCLabs
       hash.to_json
     end
     
-    def validation_to_hash(field, options = {})
-      dnc_csv_adapter.validation_to_hash(field, options)
+    def validation_to_hash(field)
+      dnc_csv_adapter.validation_to_hash(field)
     end
     
     def validation_fields

data/lib/generators/client_side_validations_generator.rb

@@ -9,5 +9,7 @@ class ClientSideValidationsGenerator < Rails::Generators::Base
   def install_client_side_validations
     copy_file('../../javascript/lib/client_side_validations.js',
       'public/javascripts/client_side_validations.js')
+    copy_file('../../javascript/lib/jquery.validate.js',
+      'public/javascripts/jquery.validate.js')
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 2
-  - 4
+  - 5
   - 2
-  version: 2.4.2
+  version: 2.5.2
 platform: ruby
 authors: 
 - Brian Cardarella
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-11 00:00:00 -04:00
+date: 2010-07-12 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -60,10 +60,12 @@ files:
 - README.markdown
 - generators/client_side_validations/client_side_validations_generator.rb
 - javascript/lib/client_side_validations.js
+- javascript/lib/jquery.validate.js
 - lib/client_side_validations.rb
 - lib/client_side_validations/adapters/action_view.rb
 - lib/client_side_validations/adapters/active_model.rb
 - lib/client_side_validations/adapters/active_record_2.rb
+- lib/client_side_validations/adapters/orm_base.rb
 - lib/client_side_validations/orm.rb
 - lib/client_side_validations/template.rb
 - lib/generators/client_side_validations_generator.rb