client_side_validations 2.2.2 → 2.3.0

data/README.markdown

@@ -17,6 +17,7 @@ Currently the following validations are supported:
 * validates_numericality_of
 * validates_length_of
 * validates_uniqueness_of
+* validates_confirmation_of
 
 The uniqueness validation works for both ActiveRecord and Mongoid.
 
@@ -43,9 +44,10 @@ This will copy client_side_validations.js to "public/javascripts"
 Currently only [jquery.validate](http://bassistance.de/jquery-plugins/jquery-plugin-validation/) is supported so you will need to download [jQuery](http://docs.jquery.com/Downloading_jQuery) and the jQuery Validate plugin to "public/javascripts"
 
 ### Rack
-The following routes will be reserved for client side validations:
+If you want to validate_uniqueness_of a call to the server must be made. You can do this by simply drop in the ClidenSideValidations Rack middleware.
+
+The following route will be reserved for client side validations:
 
-/validations.json
 /validations/uniqueness.json
 
 Add the middleware to your stack:
@@ -55,7 +57,7 @@ config/environment.rb for Rails 2.x
 config/application.rb for Rails 3.x
 
     ...
-    config.middleware.use 'ClientSideValidations'
+    config.middleware.use 'ClientSideValidations::Uniqueness'
     ...
 
 ### Model

data/javascript/lib/client_side_validations.js

@@ -6,29 +6,28 @@ if (typeof(jQuery) != "undefined") {
   
   $.extend($.fn, {
     clientSideValidations: function() {
-      var form         = this;
-      var object       = form.attr('object-csv');
-      var edit_pattern = new RegExp('^edit_' + object + '_(.+)', 'i');
-      var url          = '/validations.json?model=' + object;
-      var id           = form[0].id;
-      var object_id    = null;
-      if (edit_pattern.test(id)) {
-        object_id = Number(edit_pattern.exec(id)[1]);
-      }
-      var adapter = 'jquery.validate';
+      var form      = this;
+      var object    = form.attr('object-csv');
+      var id        = form[0].id;
+      var object_id = null;
+      var adapter   = 'jquery.validate';
       if (/new/.test(id)) {
         id = /new_(\w+)/.exec(id)[1]
       } else if (/edit/.test(id)) {
-        id = /edit_(\w+)_\d+/.exec(id)[1]
+        id        = /edit_(\w+)_\d+/.exec(id)[1]
+        object_id = /edit_\w+_(\d+)/.exec(id)[1]
+      }
+      if (eval("typeof(" + object + "_validation_options)") != "undefined") {
+        var options = eval(object + '_validation_options');
+      } else {
+        var options = { }
       }
-      var client = new ClientSideValidations(id, adapter, object_id)
-      $.getJSON(url, function(json) {
-        var validations = client.adaptValidations(json);
-        form.validate({
-          rules:    validations.rules,
-          messages: validations.messages
-        });
-      });
+      var client          = new ClientSideValidations(id, adapter, object_id)
+      var rules           = eval(object + '_validation_rules');
+      var validations     = client.adaptValidations(rules);
+      options['rules']    = validations.rules;
+      options['messages'] = validations.messages;
+      form.validate(options);
     }
   });
 
@@ -84,6 +83,10 @@ ClientSideValidations = function(id, adapter, object_id) {
                 }
               }
               break;
+            case 'confirmation':
+              rule  = 'equalTo';
+              value = "[name='" + this.id + "[" + attr + "_confirmation]"  + "']";
+              break;
 
             default:
           }

data/lib/client_side_validations.rb

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

data/lib/client_side_validations/adapters/action_view.rb

@@ -10,34 +10,98 @@ module DNCLabs
               define_method(:form_for) do |record_or_name_or_array, *args, &proc|
                 options = args.extract_options!
                 options.symbolize_keys!
+                script = ""
                 if validations = options.delete(:validations)
                   unless options.key?(:html)
                     options[:html] = {}
                   end
-                  
-                  unless validations == true
-                    object = validations.to_s.underscore
-                  else
-                    case record_or_name_or_array
-                    when String, Symbol
-                      object = record_or_name_or_array.to_s
-                    else
-                      object = record_or_name_or_array.class.to_s.underscore
-                    end
-                  end
-                  
+                  object, rules, csv_options = csv_get_variables(validations, record_or_name_or_array)
                   options[:html]['object-csv'] = object
+                  csv_rules = %{var #{object}_validation_rules=#{rules};}
+                  script    = %{<script type='text/javascript'>#{csv_rules}#{csv_options}</script>}
                 end
                 args << options
-                form_method.bind(self).call(record_or_name_or_array, *args, &proc)
+                result = form_method.bind(self).call(record_or_name_or_array, *args, &proc)
+                
+                if rails3?
+                  result += script.html_safe
+                else
+                  concat(script)
+                end
+                result
               end
             end
           end
           
+          private
+          
+          def rails3?
+            version=
+              if defined?(ActionPack::VERSION::MAJOR)
+                ActionPack::VERSION::MAJOR
+              end
+            !version.blank? && version >= 3
+          end
+          
+          def csv_get_variables(validations, record_or_name_or_array)
+            csv_options = ::ClientSideValidations.default_options || { }
+            case validations
+            when true
+              object, rules = csv_get_object_and_validation_rules(record_or_name_or_array)
+            when Hash
+              validations.symbolize_keys!
+              if validations.has_key?(:instance)
+                object = validations[:instance].class.to_s.underscore
+                rules  = validations[:instance].validations_to_json
+              elsif validations.has_key?(:class)
+                object = validations[:instance].to_s.underscore
+                rules  = validations[:instance].new.validations_to_json
+              else
+                object, rules = csv_get_object_and_validation_rules(record_or_name_or_array)
+              end
+              if validations.has_key?(:options)
+                csv_options.merge!(validations[:options])
+              end
+            else
+              object = validations.to_s.underscore
+              rules  = validations.new.validations_to_json
+            end
+            
+            if csv_options.empty?
+              csv_options = ""
+            else
+              csv_options = %{var #{object}_validation_options=#{convert_csv_options_to_json(csv_options)};}
+            end
+            
+            [object, rules, csv_options]
+          end
+          
+          def convert_csv_options_to_json(csv_options)
+            json = []
+            csv_options.each do |k, v|
+              json << %{#{k}:#{v}}
+            end
+            %{{#{json.join(',')}}}
+          end
+          
+          def csv_get_object_and_validation_rules(record_or_name_or_array)
+            case record_or_name_or_array
+            when String, Symbol
+              object = record_or_name_or_array.to_s
+              rules  = object.camelize.constantize.new.validations_to_json
+            when Array
+              object, rules = csv_get_object_and_validation_rules(record_or_name_or_array.last)
+            else
+              object = record_or_name_or_array.class.to_s.underscore
+              rules  = record_or_name_or_array.validations_to_json
+            end
+            
+            [object, rules]
+          end
         end # BaseMethods
         
         module FormBuilderMethods
-
+        
           def client_side_validations(options = {})
             @template.send(:client_side_validations, @object_name, objectify_options(options))
           end

data/lib/client_side_validations/adapters/active_model.rb

@@ -61,6 +61,8 @@ module DNCLabs
             elsif defined?(Mongoid) && base.class.included_modules.include?(Mongoid::Document)
               I18n.translate('errors.messages.taken', :locale => locale)
             end
+          when :confirmation
+            I18n.translate('errors.messages.confirmation', :locale => locale)
           end
 
           message = validation.options[:message]

data/lib/client_side_validations/adapters/active_record_2.rb

@@ -57,6 +57,8 @@ module DNCLabs
             I18n.translate('activerecord.errors.messages.not_a_number', :locale => locale)
           when 'validates_uniqueness_of'
             I18n.translate('activerecord.errors.messages.taken', :locale => locale)
+          when 'validates_confirmation_of'
+            I18n.translate('activerecord.errors.messages.confirmation', :locale => locale)
           end
 
           message = validation.options[:message]
@@ -90,6 +92,8 @@ module DNCLabs
             'length'
           when 'validates_uniqueness_of'
             'uniqueness'
+          when 'validates_confirmation_of'
+            'confirmation'
           end
         end
       end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 2
-  - 2
-  - 2
-  version: 2.2.2
+  - 3
+  - 0
+  version: 2.3.0
 platform: ruby
 authors: 
 - Brian Cardarella
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-07 00:00:00 -04:00
+date: 2010-07-09 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency