client_side_validations 3.0.3 → 3.1.0

data/client_side_validations.gemspec

@@ -12,22 +12,19 @@ Gem::Specification.new do |s|
   s.summary     = %q{Client Side Validations}
   s.description = %q{Client Side Validations}
 
-  s.rubyforge_project = "client_side_validations"
-
-  s.files         = `git ls-files -- {lib/*,javascript/*,*.gemspec}`.split("\n")
+  s.files         = `git ls-files -- {lib/*,vendor/*,*.gemspec}`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency 'activesupport', '~> 3.0.0'
-
-  s.add_development_dependency 'rails', '~> 3.0.0'
+  s.add_development_dependency 'rails', '3.1.0.rc4'
   s.add_development_dependency 'sqlite3'
   s.add_development_dependency 'bson_ext'
   s.add_development_dependency 'mongoid', '~> 2.0.0'
+  s.add_development_dependency 'mongo_mapper','~>0.9.0'
   s.add_development_dependency 'mocha'
   s.add_development_dependency 'simple_form'
-  s.add_development_dependency 'formtastic'
+  s.add_development_dependency 'formtastic', '~> 2.0.0.rc3'
 
   # For QUnit testing
   s.add_development_dependency 'sinatra', '~> 1.0'

data/lib/client_side_validations/action_view/form_builder.rb

@@ -2,7 +2,7 @@ module ClientSideValidations::ActionView::Helpers
   module FormBuilder
 
     def self.included(base)
-      (base.field_helpers - %w(apply_form_for_options! label check_box radio_button fields_for hidden_field)).each do |selector|
+      (base.field_helpers.map(&:to_s) - %w(apply_form_for_options! label check_box radio_button fields_for hidden_field)).each do |selector|
         base.class_eval <<-RUBY_EVAL
           def #{selector}_with_client_side_validations(method, options = {})
             apply_client_side_validators(method, options)
@@ -15,16 +15,20 @@ module ClientSideValidations::ActionView::Helpers
       end
 
       base.class_eval do
-        alias_method_chain :initialize,   :client_side_validations
-        alias_method_chain :fields_for,   :client_side_validations
-        alias_method_chain :check_box,    :client_side_validations
-        alias_method_chain :radio_button, :client_side_validations
+        alias_method_chain :initialize,                :client_side_validations
+        alias_method_chain :fields_for,                :client_side_validations
+        alias_method_chain :check_box,                 :client_side_validations
+        alias_method_chain :radio_button,              :client_side_validations
+        alias_method_chain :select,                    :client_side_validations
+        alias_method_chain :collection_select,         :client_side_validations
+        alias_method_chain :grouped_collection_select, :client_side_validations
+        alias_method_chain :time_zone_select,          :client_side_validations
 
         def self.client_side_form_settings(options, form_helper)
           {
             :type => self.to_s,
-            :input_tag => form_helper.class.field_error_proc.call(%{<span id="input_tag" />}, Struct.new(:error_message, :tag_id).new([], "")),
-            :label_tag => form_helper.class.field_error_proc.call(%{<label id="label_tag" />})
+            :input_tag => form_helper.class.field_error_proc.call(%{<span id="input_tag" />},  Struct.new(:error_message, :tag_id).new([], "")),
+            :label_tag => form_helper.class.field_error_proc.call(%{<label id="label_tag" />}, Struct.new(:error_message, :tag_id).new([], ""))
           }
         end
       end
@@ -51,22 +55,52 @@ module ClientSideValidations::ActionView::Helpers
       radio_button_without_client_side_validations(method, tag_value, options)
     end
 
+    def select_with_client_side_validations(method, choices, options = {}, html_options = {})
+      apply_client_side_validators(method, html_options)
+      select_without_client_side_validations(method, choices, options, html_options)
+    end
+
+    def collection_select_with_client_side_validations(method, collection, value_method, text_method, options = {}, html_options = {})
+      apply_client_side_validators(method, html_options)
+      collection_select_without_client_side_validations(method, collection, value_method, text_method, options, html_options)
+    end
+
+    def grouped_collection_select_with_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
+      apply_client_side_validators(method, html_options)
+      grouped_collection_select_without_client_side_validations(method, collection, group_method, group_label_method, option_key_method, option_value_method, options, html_options)
+    end
+
+    def time_zone_select_with_client_side_validations(method, priority_zones = nil, options = {}, html_options = {})
+      apply_client_side_validators(method, html_options)
+      time_zone_select_without_client_side_validations(method, priority_zones = nil, options, html_options)
+    end
+
   private
 
     def apply_client_side_validators(method, options = {})
       if @options[:validate] && options[:validate] != false && validators = filter_validators(@object.client_side_validation_hash[method], options[:validate])
         options.merge!("data-validate" => true)
-        @options[:validators].merge!("#{@object_name}[#{method}]" => validators)
+        @options[:validators].merge!("#{@object_name}[#{method}]#{options[:multiple] ? "[]" : nil}" => validators)
       end
     end
 
     def filter_validators(validators, filters)
       if validators
         filtered_validators = validators.inject({}) do |filtered_validators, validator|
-          unless filters && filters.key?(validator.first) && !filters[validator.first]
-            filtered_validators[validator.first] = validator.last
+          filtered_validators[validator.first] = validator.last
+          if has_filter_for_validator?(validator, filters)
+            if filter_validator?(validator, filters)
+              filtered_validators.delete(validator.first)
+            elsif force_validator_despite_conditional?(validator, filters) && !can_run_validator?(validator)
+              filtered_validators.delete(validator.first)
+            end
+          else
+            if validator.last.key?(:if) || validator.last.key?(:unless)
+              filtered_validators.delete(validator.first)
+            end
           end
-
+          filtered_validators[validator.first].delete(:if) if filtered_validators[validator.first]
+          filtered_validators[validator.first].delete(:unless) if filtered_validators[validator.first]
           filtered_validators
         end
 
@@ -74,5 +108,45 @@ module ClientSideValidations::ActionView::Helpers
       end
     end
 
+    def has_filter_for_validator?(validator, filters)
+      filters && (filters == true || filters.key?(validator.first))
+    end
+
+    def filter_validator?(validator, filters)
+      filters != true && filters[validator.first] == false
+    end
+
+    def force_validator_despite_conditional?(validator, filters)
+      filters == true || filters[validator.first] == true
+    end
+
+    def can_run_validator?(validator)
+      result        = true
+      if_result     = can_run_if_validator?(validator.last[:if])
+      unless_result = can_run_unless_validator?(validator.last[:unless])
+      result        = result && if_result unless if_result.nil?
+      result        = result && unless_result unless unless_result.nil?
+      result
+    end
+
+    def can_run_if_validator?(conditional)
+      if conditional
+        if conditional.is_a?(Symbol)
+          !!@object.send(conditional)
+        else
+          !!conditional.call(@object)
+        end
+      end
+    end
+
+    def can_run_unless_validator?(conditional)
+      if conditional
+        if conditional.is_a?(Symbol)
+          !@object.send(conditional)
+        else
+          !conditional.call(@object)
+        end
+      end
+    end
   end
 end

data/lib/client_side_validations/action_view/form_helper.rb

@@ -6,9 +6,11 @@ module ClientSideValidations::ActionView::Helpers
       options = args.extract_options!
       if options[:validate]
 
+        content_for_name = options[:validate] unless options[:validate] == true
+
         # Always turn off HTML5 Validations
         options[:html] ||= {}
-        options[:html][:novalidate] = true
+        options[:html][:novalidate] = 'novalidate'
 
         case record_or_name_or_array
         when String, Symbol
@@ -26,7 +28,12 @@ module ClientSideValidations::ActionView::Helpers
       form   = super(record_or_name_or_array, *(args << options), &proc)
       # Because of the load order requirement above this sub is necessary
       # Would be nice to not do this
-      "#{form}#{script ? script.sub('"validator_hash"', @validators.to_json) : nil}".html_safe
+      script = insert_validators_into_script(script)
+      if content_for_name
+        content_for(content_for_name) { script.html_safe }
+        script = nil
+      end
+      "#{form}#{script}".html_safe
     end
 
     def apply_form_for_options!(object_or_array, options)
@@ -42,6 +49,17 @@ module ClientSideValidations::ActionView::Helpers
 
     private
 
+    def insert_validators_into_script(script)
+      # There is probably a more performant way of doing this
+      # But using String#sub has some issues. Undocumented "features"
+      if script
+        script = script.split(/"validator_hash"/)
+        script = "#{script[0]}#{@validators.to_json}#{script[1]}"
+      end
+
+      script
+    end
+
     def client_side_form_settings(object, options)
       if options[:validate]
         builder = options[:builder] || ActionView::Base.default_form_builder
@@ -57,7 +75,7 @@ module ClientSideValidations::ActionView::Helpers
         end
 
         content_tag(:script) do
-          "var #{var_name} = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};".html_safe
+          "window['#{var_name}'] = #{builder.client_side_form_settings(options, self).merge(:validators => 'validator_hash').to_json};".html_safe
         end
 
       end

data/lib/client_side_validations/action_view.rb

@@ -3,9 +3,10 @@ module ClientSideValidations::ActionView
   end
 end
 
-require "client_side_validations/action_view/form_helper"
-require "client_side_validations/action_view/form_tag_helper"
-require "client_side_validations/action_view/form_builder"
+require 'client_side_validations/core_ext'
+require 'client_side_validations/action_view/form_helper'
+require 'client_side_validations/action_view/form_tag_helper'
+require 'client_side_validations/action_view/form_builder'
 
 ActionView::Base.send(:include, ClientSideValidations::ActionView::Helpers::FormHelper)
 ActionView::Base.send(:include, ClientSideValidations::ActionView::Helpers::FormTagHelper)

data/lib/client_side_validations/active_model/length.rb

@@ -2,19 +2,21 @@ module ClientSideValidations::ActiveModel
   module Length
 
     def client_side_hash(model, attribute)
-      extra_options = options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:allow_blank, :on]).except(:tokenizer, :too_long, :too_short, :wrong_length)
+      options = self.options.dup
+      hash    = { :messages => {} }
+      hash[:js_tokenizer] = options[:js_tokenizer] if options[:js_tokenizer]
+      hash[:allow_blank]  = true if options[:allow_blank]
 
-      errors_options = options.except(*self.class::RESERVED_OPTIONS)
-      messages = extra_options.except(:js_tokenizer, :allow_blank, :on).keys.inject({}) do |hash, key|
-        errors_options[:count] = extra_options[key]
-        count = extra_options[key]
-        default_message = options[self.class::MESSAGES[key]]
-        errors_options[:message] ||= default_message if default_message
-
-        hash.merge!(key => model.errors.generate_message(attribute, self.class::MESSAGES[key], errors_options))
+      self.class::MESSAGES.each do |option, message_type|
+        if count = options[option]
+          options[:message] = options[message_type]
+          options.delete(:message) if options[:message].nil?
+          hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(:count => count))
+          hash[option] = count
+        end
       end
 
-      { :messages => messages }.merge(extra_options)
+      hash
     end
 
   end

data/lib/client_side_validations/active_model/numericality.rb

@@ -5,20 +5,25 @@ module ClientSideValidations::ActiveModel
 
     def self.included(base)
       OPTION_MAP.merge!(base::CHECKS.keys.inject({}) { |hash, key| hash.merge!(key => key) })
-      OPTION_MAP.merge!(:numericality => :not_a_number, :only_integer => :not_an_integer)
     end
 
     def client_side_hash(model, attribute)
-      except_options = ::ActiveModel::Errors::CALLBACKS_OPTIONS - [:on] + [:message]
-      extra_options = options.except(*except_options).reject { |key, value| key == :only_integer && !value }
-      keys = [:numericality] | (extra_options.keys - [:message, :on])
-      filtered_options = options.except(*self.class::RESERVED_OPTIONS)
-      messages = keys.inject({}) do |hash, key|
-        count = extra_options[key]
-        hash.merge!(key => model.errors.generate_message(attribute, OPTION_MAP[key], filtered_options.merge(:count => count)))
+      options = self.options.dup
+      hash    = { :messages => { :numericality => model.errors.generate_message(attribute, :not_a_number, options) } }
+
+      if options[:only_integer]
+        hash[:messages][:only_integer] = model.errors.generate_message(attribute, :not_an_integer, options)
+        hash[:only_integer] = true
+      end
+
+      OPTION_MAP.each do |option, message_type|
+        if count = options[option]
+          hash[:messages][option] = model.errors.generate_message(attribute, message_type, options.merge(:count => count))
+          hash[option] = count
+        end
       end
 
-      { :messages => messages }.merge(extra_options)
+      hash
     end
 
   end

data/lib/client_side_validations/active_model.rb

@@ -4,8 +4,8 @@ module ClientSideValidations::ActiveModel
   module Validator
 
     def client_side_hash(model, attribute)
-      extra_options = options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:on, :allow_blank])
-      { :message => model.errors.generate_message(attribute, message_type, extra_options) }.merge(extra_options)
+      options = self.options.dup
+      { :message => model.errors.generate_message(attribute, message_type, options) }.merge(options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:allow_blank, :if, :unless]))
     end
 
     private
@@ -17,26 +17,34 @@ module ClientSideValidations::ActiveModel
 
   module Validations
     def client_side_validation_hash
-      _validators.except(nil, :block).inject({}) do |attr_hash, attr|
+      @client_side_validation_hash ||= _validators.inject({}) do |attr_hash, attr|
+        unless [nil, :block].include?(attr[0])
+
+          validator_hash = attr[1].inject({}) do |kind_hash, validator|
+            client_side_hash = validator.client_side_hash(self, attr[0])
+            # Yeah yeah, #new_record? is not part of ActiveModel :p
+            if (can_use_for_client_side_validation?(client_side_hash, validator))
+              kind_hash.merge!(validator.kind => client_side_hash.except(:on))
+            else
+              kind_hash.merge!({})
+            end
+          end
 
-        validator_hash = attr[1].inject({}) do |kind_hash, validator|
-          client_side_hash = validator.client_side_hash(self, attr[0])
-          # Yeah yeah, #new_record? is not part of ActiveModel :p
-          if (can_use_for_client_side_validation?(client_side_hash, validator))
-            kind_hash.merge!(validator.kind => client_side_hash.except(:on))
+          if validator_hash.present?
+            attr_hash.merge!(attr[0] => validator_hash)
           else
-            kind_hash.merge!({})
+            attr_hash
           end
+        else
+          attr_hash
         end
-
-        attr_hash.merge!(attr[0] => validator_hash)
-      end.delete_if { |key, value| value.blank? }
+      end
     end
 
     private
 
     def can_use_for_client_side_validation?(client_side_hash, validator)
-      ((self.respond_to?(:new_record?) && client_side_hash[:on] == (self.new_record? ? :create : :update)) || client_side_hash[:on].nil?) && !validator.options.key?(:if) && !validator.options.key?(:unless) && validator.kind != :block
+      ((self.respond_to?(:new_record?) && validator.options[:on] == (self.new_record? ? :create : :update)) || validator.options[:on].nil?) && validator.kind != :block
     end
   end
 end

data/lib/client_side_validations/active_record/middleware.rb

@@ -17,7 +17,11 @@ module ClientSideValidations::ActiveRecord
         relation = t[attribute].matches(value)
       end
 
-      relation = relation.and(t[:id].not_eq(params[:id])) if params[:id]
+      if relation.is_a?(Arel::Nodes::SqlLiteral)
+        relation = Arel::Nodes::SqlLiteral.new("BINARY #{t[attribute].eq(value).to_sql} AND #{t.primary_key.not_eq(params[:id]).to_sql}")
+      else
+        relation = relation.and(t.primary_key.not_eq(params[:id])) if params[:id]
+      end
 
       (params[:scope] || {}).each do |key, value|
         relation = relation.and(t[key].eq(value))

data/lib/client_side_validations/active_record/uniqueness.rb

@@ -1,16 +1,18 @@
 module ClientSideValidations::ActiveRecord
   module Uniqueness
     def client_side_hash(model, attribute)
-      extra_options = options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:on, :allow_blank])
-      hash = { :message => model.errors.generate_message(attribute, message_type, extra_options.except(:case_sensitive, :scope)) }
-      hash = hash.merge(extra_options).merge(model.new_record? ? {} : { :id => model.id })
-
-      if hash[:scope].present?
-        hash[:scope] = Array.wrap(hash[:scope]).inject({}) do |scope_hash, scope_item|
+      hash = {}
+      hash[:message] = model.errors.generate_message(attribute, message_type, options.except(:scope))
+      hash[:case_sensitive] = options[:case_sensitive]
+      hash[:id] = model.id unless model.new_record?
+      if options.key?(:scope) && options[:scope].present?
+        hash[:scope] = Array.wrap(options[:scope]).inject({}) do |scope_hash, scope_item|
           scope_hash.merge!(scope_item => model.send(scope_item))
         end
-      else
-        hash.delete(:scope)
+      end
+
+      unless model.class.name.demodulize == model.class.name
+        hash[:class] = model.class.name.underscore
       end
 
       hash

data/lib/client_side_validations/engine.rb

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

data/lib/client_side_validations/files.rb

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

data/lib/client_side_validations/formtastic.rb

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

data/lib/client_side_validations/middleware.rb

@@ -1,9 +1,10 @@
 # encoding: utf-8
 
+require 'client_side_validations/core_ext'
+
 module ClientSideValidations
 
   module Middleware
-
     class Validators
       def initialize(app)
         @app = app
@@ -11,7 +12,7 @@ module ClientSideValidations
 
       def call(env)
         case env['PATH_INFO']
-        when %r{\/validators\/(\w+)\.json}
+        when %r{\/validators\/(\w+)}
           "::ClientSideValidations::Middleware::#{$1.camelize}".constantize.new(env).response
         else
           @app.call(env)
@@ -63,6 +64,8 @@ module ClientSideValidations
           middleware_klass = ClientSideValidations::ActiveRecord::Middleware
         elsif (defined?(::Mongoid::Document) && klass.included_modules.include?(::Mongoid::Document))
           middleware_klass = ClientSideValidations::Mongoid::Middleware
+        elsif (defined?(::MongoMapper::Document) && klass.included_modules.include?(::MongoMapper::Document))
+          middleware_klass = ClientSideValidations::MongoMapper::Middleware
         end
 
         middleware_klass.is_unique?(klass, attribute, value, request.params)
@@ -72,11 +75,6 @@ module ClientSideValidations
         parent_key = (request.params.keys - IGNORE_PARAMS).first
       end
     end
-
-  end
-
-  class Engine < ::Rails::Engine
-    config.app_middleware.use ClientSideValidations::Middleware::Validators
   end
 
 end

data/lib/client_side_validations/mongo_mapper/middleware.rb

@@ -0,0 +1,20 @@
+module ClientSideValidations::MongoMapper
+  class Middleware
+
+    # Still need to handle embedded documents
+    def self.is_unique?(klass, attribute, value, params)
+      if params[:case_sensitive] == 'false'
+        value = Regexp.new("^#{Regexp.escape(value.to_s)}$", Regexp::IGNORECASE)
+      end
+
+      criteria = klass.where(attribute => value)
+      criteria = criteria.where(:_id => {'$ne' => BSON::ObjectId(params[:id])}) if params[:id]
+
+      (params[:scope] || {}).each do |key, value|
+        criteria = criteria.where(key => value)
+      end
+
+      !criteria.exists?
+    end
+  end
+end

data/lib/client_side_validations/mongo_mapper/uniqueness.rb

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

data/lib/client_side_validations/mongo_mapper.rb

@@ -0,0 +1,9 @@
+require 'client_side_validations/active_model'
+require 'client_side_validations/mongo_mapper/middleware'
+
+%w{uniqueness}.each do |validator|
+  require "client_side_validations/mongo_mapper/#{validator}"
+  validator.capitalize!
+  eval "MongoMapper::Plugins::Validations::#{validator}Validator.send(:include, ClientSideValidations::MongoMapper::#{validator})"
+end
+

data/lib/client_side_validations/mongoid/uniqueness.rb

@@ -1,16 +1,18 @@
 module ClientSideValidations::Mongoid
   module Uniqueness
     def client_side_hash(model, attribute)
-      extra_options = options.except(*::ActiveModel::Errors::CALLBACKS_OPTIONS - [:on, :allow_blank])
-      hash = { :message => model.errors.generate_message(attribute, message_type, extra_options.except(:case_sensitive, :scope)) }
-      hash = hash.merge(extra_options).merge(model.new_record? ? {} : { :id => model.id })
-
-      if hash[:scope].present?
-        hash[:scope] = Array.wrap(hash[:scope]).inject({}) do |scope_hash, scope_item|
+      hash = {}
+      hash[:message] = model.errors.generate_message(attribute, message_type, options.except(:scope))
+      hash[:case_sensitive] = options[:case_sensitive] if options.key?(:case_sensitive)
+      hash[:id] = model.id unless model.new_record?
+      if options.key?(:scope) && options[:scope].present?
+        hash[:scope] = Array.wrap(options[:scope]).inject({}) do |scope_hash, scope_item|
           scope_hash.merge!(scope_item => model.send(scope_item))
         end
-      else
-        hash.delete(:scope)
+      end
+
+      unless model.class.name.demodulize == model.class.name
+        hash[:class] = model.class.name.underscore
       end
 
       hash

data/lib/client_side_validations/version.rb

@@ -1,3 +1,3 @@
 module ClientSideValidations
-  VERSION = "3.0.3"
+  VERSION = '3.1.0'
 end

data/lib/client_side_validations.rb

@@ -1,8 +1,13 @@
 module ClientSideValidations
 end
 
+require 'client_side_validations/active_model'  if defined?(::ActiveModel)
 require 'client_side_validations/active_record' if defined?(::ActiveRecord)
-require 'client_side_validations/mongoid' if defined?(::Mongoid)
-require 'client_side_validations/action_view'
-require 'client_side_validations/middleware' if defined?(::Rails)
+require 'client_side_validations/mongoid'       if defined?(::Mongoid)
+require 'client_side_validations/mongo_mapper'  if defined?(::MongoMapper)
+require 'client_side_validations/action_view'   if defined?(::ActionView)
+if defined?(::Rails)
+  require 'client_side_validations/middleware'
+  require 'client_side_validations/engine'
+end
 

data/lib/generators/client_side_validations/copy_asset_generator.rb

@@ -0,0 +1,23 @@
+module ClientSideValidations
+  module Generators
+    class CopyAssetGenerator < Rails::Generators::Base
+      source_root File.expand_path('../../../../vendor/assets/javascripts', __FILE__)
+      if Rails.version >= '3.1'
+        desc 'Creates a ClientSideValidations initializer and copies rails.validations.js to app/assets/javascripts.'
+      else
+        desc 'Creates a ClientSideValidations initializer and copies rails.validations.js to public/javascripts.'
+      end
+
+      def copy_javascript_asset
+        if Rails.version >= '3.1'
+          destination = 'app/assets/javascripts'
+        else
+          destination = 'public/javascripts'
+        end
+
+        copy_file 'rails.validations.js', "#{destination}/rails.validations.js"
+      end
+    end
+  end
+end
+