RubyGems - client_side_validations - Versions diffs - 2.4.2 → 2.5.2 - Mend

client_side_validations 2.4.2 → 2.5.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

data/README.markdown +8 -0
data/generators/client_side_validations/client_side_validations_generator.rb +1 -0
data/javascript/lib/client_side_validations.js +58 -6
data/javascript/lib/jquery.validate.js +1146 -0
data/lib/client_side_validations/adapters/active_model.rb +35 -79
data/lib/client_side_validations/adapters/active_record_2.rb +38 -82
data/lib/client_side_validations/adapters/orm_base.rb +88 -0
data/lib/client_side_validations/orm.rb +2 -2
data/lib/generators/client_side_validations_generator.rb +2 -0
metadata +5 -3

data/lib/client_side_validations/adapters/active_model.rb CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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