client_side_validations 2.8.0 → 2.9.2

data/README.markdown

@@ -53,21 +53,7 @@ This will copy client_side_validations.js to "public/javascripts"
 Download [jQuery](http://docs.jquery.com/Downloading_jQuery) and [jQuery Validation](http://bassistance.de/jquery-plugins/jquery-plugin-validation/) plugin to "public/javascripts"
 
 ### Rack
-If you want to validate_uniqueness_of a call to the server must be made. You can do this with the ClidenSideValidations::Uniqueness middleware.
-
-The following route will be reserved for client side validations:
-
-/validations/uniqueness.json
-
-Add the middleware to your stack:
-
-config/environment.rb for Rails 2.x
-
-config/application.rb for Rails 3.x
-
-    ...
-    config.middleware.use 'ClientSideValidations::Uniqueness'
-    ...
+As of version 2.9.0 the ClientSideValidations::Uniqueness middleware is automatically included as a Rails Engine. (both Rails 2 and Rails 3)
 
 ### Model
 Validate your models as you normally would

data/javascript/lib/client_side_validations.js

@@ -1,3 +1,15 @@
+jQuery.validator.addMethod("numericality", function(value, element) { 
+  return this.optional(element) || /^(\d+(\.|,)\d+|\d+)$/.test(value);
+}, jQuery.validator.format("Is not a number."));
+
+jQuery.validator.addMethod("odd", function(value, element) { 
+  return this.optional(element) || parseInt(value) % 2 == 1;
+}, jQuery.validator.format("Must be odd."));
+
+jQuery.validator.addMethod("even", function(value, element) { 
+  return this.optional(element) || parseInt(value) % 2 == 0;
+}, jQuery.validator.format("Must be even."));
+
 jQuery.validator.addMethod("format", function(value, element, params) { 
   var pattern = new RegExp(params, "i");
   return this.optional(element) || pattern.test(value);
@@ -44,6 +56,9 @@ $.extend($.fn, {
       var form                        = $(this[i]);
       var object                      = form.attr('data-csv');
       var validate_options            = eval(object + "_validate_options");
+      if (typeof(validate_options['options']) == 'undefined') {
+        validate_options['options'] = { };
+      }
       validate_options.options.ignore = ':hidden';
       form.validate(validate_options);
     }

data/lib/client_side_validations.rb

@@ -56,4 +56,5 @@ module ClientSideValidations
 end
 
 require 'client_side_validations/orm'
-require 'client_side_validations/template'
+require 'client_side_validations/template'
+require 'client_side_validations/rails' if defined?(Rails)

data/lib/client_side_validations/adapters/action_view.rb

@@ -128,7 +128,11 @@ module DNCLabs
             when Class
               get_object_name(object.new)
             else
-              ActionController::RecordIdentifier.singular_class_name(object)
+              if rails3?
+                ActiveModel::Naming.singular(object)
+              else
+                ActionController::RecordIdentifier.singular_class_name(object)
+              end
             end
           end
         end # BaseMethods

data/lib/client_side_validations/adapters/active_model.rb

@@ -1,110 +1,120 @@
 require 'client_side_validations/adapters/orm_base'
 
-module DNCLabs
-  module ClientSideValidations
-    module Adapters
-      class ActiveModel < ORMBase
+module ClientSideValidations
+  module Adapters
+    class ActiveModel < ORMBase
 
-        def validations_to_hash(attr)
-          base._validators[attr.to_sym].inject({}) do |hash, validation|
-            hash.merge!(build_validation_hash(validation.clone))
-          end
+      def validations_to_hash(attr)
+        base._validators[attr.to_sym].inject({}) do |hash, validation|
+          hash.merge!(build_validation_hash(validation.clone))
         end
-        
-        def validation_fields
-          base._validators.keys
+      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
         
-        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
+        if validation.kind == :size
+          validation.kind = :length
         end
-
-        def supported_validation?(validation)
-          SupportedValidations.include?(validation.kind.to_sym)
+        
+        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
         
-        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
-            I18n.translate(i18n_prefix + 'errors.messages.not_a_number')
-          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)
-              I18n.translate('errors.messages.taken')
-            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
+        super
+      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}")
+      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
-            default
+            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)
+            I18n.translate('errors.messages.taken')
+          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
 
-        def get_validation_method(validation)
-          validation.kind.to_s
+        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
-        
-        def i18n_prefix
-          if defined?(::ActiveModel)
-            ''
-          else # ActiveRecord 2.x
-            'activerecord.'
-          end
+      end
+
+      def get_validation_method(validation)
+        validation.kind.to_s
+      end
+      
+      def i18n_prefix
+        if defined?(::ActiveModel)
+          ''
+        else # ActiveRecord 2.x
+          'activerecord.'
         end
-        
-        def orm_error_interpolation(name)
-          if defined?(::ActiveModel)
-            "%{#{name}}"
-            
-          else # ActiveRecord 2.x
-            "{{#{name}}}"
-          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

@@ -1,88 +1,89 @@
-module DNCLabs
-  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
+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)
+      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
+          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
-        
-        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
+      
+      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_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, :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.sub("\\A","^").sub("\\Z","$").sub(%r{^/},"").sub(%r{/i?$}, "")
-          end
-          options
+      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.sub("\\A","^").sub("\\Z","$").sub(%r{^/},"").sub(%r{/i?$}, "")
         end
-        
-        def get_validation_method(validation)
+        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

@@ -1,163 +1,213 @@
-module DNCLabs
-  module ClientSideValidations
+require 'client_side_validations/adapters/active_model'
+
+module ClientSideValidations
+  module ORM
     def validate_options
-      rules    = Hash.new { |h, field| h[field] = {} }
-      messages = Hash.new { |h, field| h[field] = {} }
-      validation_fields.each do |field|
-        validations = validations_to_hash(field)
-        rules[field.to_s].merge!(extract_rules(validations, field))
-        messages[field.to_s].merge!(extract_messages(validations))
-      end
-      {"rules" => rules, "messages" => messages}
+      ValidateOptions.new(self).to_hash
     end
-    
-    def validations_to_hash(field)
-      dnc_csv_adapter.validations_to_hash(field)
+
+    def validation_fields
+      self._validators.keys
     end
     
-    private
+    class ValidateOptions
+      attr_accessor :base
+      
+      def initialize(base)
+        self.base = base
+      end
     
-    def convert_kind(kind, options = nil)
-      case kind
-      when 'acceptance', 'exclusion', 'inclusion'
-        kind
-      when 'confirmation'
-        'equalTo'
-      when 'presence'
-        'required'
-      when 'numericality'
-        'digits'
-      when 'length'
-        if options['is']
-          'islength'
-        elsif options['minimum'] && options['maximum']
-          ['minlength', 'maxlength']
-        elsif options['minimum']
-          'minlength'
-        elsif options['maximum']
-          'maxlength'
+      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
-      when 'uniqueness'
-        'remote'
+        {"rules" => rules, "messages" => messages}
       end
-    end
-    
-    def extract_rules(validations, field = nil)
-      rules = {}
-      validations.each do |kind, options|
-        kind = convert_kind(kind, options)
-        value = case kind
-        when 'acceptance'
-          true
-        when 'equalTo'
-          %{[name="#{field}_confirmation"]}
-        when 'required'
-          true
-        when 'digits'
-          true
-        when 'exclusion', 'inclusion'
-          options['in']
-        when 'islength'
-          options['is']
-        when 'minlength'
-          options['minimum']
-        when 'maxlength'
-          options['maximum']
-        when 'remote'
-          if self.new_record?
-            data = {}
+
+      def validations_for(field)
+        adapter.validations_to_hash(field)
+      end
+
+      private
+
+      def convert_kind(kind, options = nil)
+        case kind
+        when 'acceptance', 'exclusion', 'inclusion', 'format'
+          kind
+        when 'confirmation'
+          'equalTo'
+        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
-            data = { "#{self.class.to_s.underscore}[id]" => self.id}
+            'numericality'
+          end
+        when 'length'
+          if options['is']
+            'islength'
+          elsif options['minimum'] && options['maximum']
+            ['minlength', 'maxlength']
+          elsif options['minimum']
+            'minlength'
+          elsif options['maximum']
+            'maxlength'
           end
-          {'url' => '/validations/uniqueness.json', 'data' => data}
+        when 'uniqueness'
+          'remote'
         end
+      end
 
-        unless Array === kind
-          rules[kind] = value
-        else
-          kind.each do |k|
-            special_rule = case k
-            when 'minlength'
-              options['minimum']
-            when 'maxlength'
-              options['maximum']
+      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', 'greater_than', 'min', 'less_than', 'max', 'odd', 'even'
+            true
+          when 'format'
+            options['with']
+          when 'equalTo'
+            %{[name="#{field}_confirmation"]}
+          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
-            
-            rules[k] = special_rule
+            {'url' => '/validations/uniqueness.json', 'data' => data}
           end
-        end
 
-        if required?(kind, options)
-          unless rules['required']
-            rules['required'] = true
-          end
-        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
         
-      end
-      rules
-    end
+              rules[k] = special_rule
+            end
+          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'
+          if numericality?(kind)
+            unless rules['numericality'] || rules['digits']
+              rules['numericality'] = true
             end
+          end
 
-            messages[k] = options[special_message]
+          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
 
-        if required?(kind, options)
-          unless messages['required']
-            messages['required'] = options['message']
+              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
-      messages
-    end
-    
-    def required?(kind, options)
-      case kind
-      when 'digits', 'exclusion', 'inclusion', 'islength', 'minlength', 'remote'
-        !options['allow_blank']
-      when Array
-        required?('minlength', options) if kind.include?('minlength')
+
+      def i18n_prefix
+        if defined?(::ActiveModel)
+          ''
+        else # ActiveRecord 2.x
+          'activerecord.'
+        end
       end
-    end
-    
-    def validation_fields
-      dnc_csv_adapter.validation_fields
-    end
-    
-    def dnc_csv_adapter
-      unless @dnc_csv_adapter
-        @dnc_csv_adapter = Adapter.new(self)
+
+      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
-      @dnc_csv_adapter
     end
   end
 end
 
 if defined?(::ActiveModel)
-  require 'client_side_validations/adapters/active_model'
-  DNCLabs::ClientSideValidations::Adapter = DNCLabs::ClientSideValidations::Adapters::ActiveModel
   klass = ::ActiveModel::Validations
 
 elsif defined?(::ActiveRecord)
   if ::ActiveRecord::VERSION::MAJOR == 2
     require 'validation_reflection/active_model'
-    require 'client_side_validations/adapters/active_model'
-    DNCLabs::ClientSideValidations::Adapter = DNCLabs::ClientSideValidations::Adapters::ActiveModel
     klass = ::ActiveRecord::Base
     
     ActiveRecord::Base.class_eval do
@@ -169,6 +219,6 @@ end
 
 if klass
   klass.class_eval do
-    include DNCLabs::ClientSideValidations
+    include ClientSideValidations::ORM
   end
 end

data/lib/client_side_validations/rails.rb

@@ -0,0 +1,11 @@
+module ClientSideValidations
+  if Rails::VERSION::MAJOR == 3
+    class Engine < ::Rails::Engine
+      config.app_middleware.use ClientSideValidations::Uniqueness
+    end
+  else
+    Rails.configuration.after_initialize do
+      Rails.configuration.middleware.use ClientSideValidations::Uniqueness
+    end
+  end
+end

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 2
-  - 8
-  - 0
-  version: 2.8.0
+  - 9
+  - 2
+  version: 2.9.2
 platform: ruby
 authors: 
 - Brian Cardarella
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-25 00:00:00 -04:00
+date: 2010-08-10 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,6 +50,144 @@ dependencies:
         version: 1.4.3
   type: :runtime
   version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 7712042
+        segments: 
+        - 3
+        - 0
+        - 0
+        - rc
+        version: 3.0.0.rc
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 7712042
+        segments: 
+        - 3
+        - 0
+        - 0
+        - rc
+        version: 3.0.0.rc
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 0
+        - 4
+        version: 1.0.4
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 62196419
+        segments: 
+        - 2
+        - 0
+        - 0
+        - beta
+        - 16
+        version: 2.0.0.beta.16
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: crack
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: bourne
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id010
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id011
 description: Client Side Validations for Rails 2.x and 3.x
 email: bcardarella@gmail.com
 executables: []
@@ -70,6 +208,7 @@ files:
 - lib/client_side_validations/adapters/active_model.rb
 - lib/client_side_validations/adapters/orm_base.rb
 - lib/client_side_validations/orm.rb
+- lib/client_side_validations/rails.rb
 - lib/client_side_validations/template.rb
 - lib/generators/client_side_validations_generator.rb
 has_rdoc: true