client_side_validations 2.6.2 → 2.6.3

data/javascript/lib/client_side_validations.js

@@ -1,182 +1,55 @@
-if (typeof(jQuery) != "undefined") {
-  jQuery.validator.addMethod("format", function(value, element, params) { 
-    var pattern = new RegExp(params, "i");
-    return this.optional(element) || pattern.test(value); 
-  }, jQuery.validator.format("Invalid format."));
+jQuery.validator.addMethod("format", function(value, element, params) { 
+  var pattern = new RegExp(params, "i");
+  return this.optional(element) || pattern.test(value);
+}, jQuery.validator.format("Invalid format."));
 
-  jQuery.validator.addMethod("acceptance", function(value, element, params) { 
-    return element.checked; 
-  }, jQuery.validator.format("Was not accepted."));
+jQuery.validator.addMethod("acceptance", function(value, element, params) { 
+  return element.checked; 
+}, jQuery.validator.format("Was not accepted."));
 
-  jQuery.validator.addMethod("inclusion", function(value, element, params) { 
-    if (this.optional(element)) {
-      return true;
-    } else {
-      
-      for (var i=0, len=params.length; i<len; ++i ) {
-        if (value == String(params[i])) {
-          return true;
-        }
+jQuery.validator.addMethod("inclusion", function(value, element, params) { 
+  if (this.optional(element)) {
+    return true;
+  } else {
+    
+    for (var i=0, len=params.length; i<len; ++i ) {
+      if (value == String(params[i])) {
+        return true;
       }
     }
-    return false;
-  }, jQuery.validator.format("Not included in list."));
+  }
+  return false;
+}, jQuery.validator.format("Not included in list."));
 
-  jQuery.validator.addMethod("exclusion", function(value, element, params) { 
-    if (this.optional(element)) {
-      return true;
-    } else {
-      for (var i=0, len=params.length; i<len; ++i ) {
-        if (value == String(params[i])) {
-          return false;
-        }
-      }
-    }
+jQuery.validator.addMethod("exclusion", function(value, element, params) { 
+  if (this.optional(element)) {
     return true;
-  }, jQuery.validator.format("Is reserved."));
-  
-  $.extend($.fn, {
-    clientSideValidations: function() {
-      for (var i in this) {
-        var form      = $(this[i]);
-        var object    = form.attr('object-csv');
-        var form_id   = form.attr('id');
-        var object_id = null;
-        var adapter   = 'jquery.validate';
-
-        if (/edit/.test(form_id)) {
-          object_id = /edit_\w+_(\d+)/.exec(form_id)[1];
-        }
-
-        if (eval("typeof(" + object + "_validation_options)") != "undefined") {
-          var options = eval(object + '_validation_options');
-        } else {
-          var options = { }
-        }
-        var client       = new ClientSideValidations(object, adapter, object_id)
-        var rules        = eval(object + '_validation_rules');
-        var validations  = client.adaptValidations(rules);
-        options.rules    = validations.rules;
-        options.messages = validations.messages;
-        options.ignore   = ':hidden';
-        form.validate(options);
+  } else {
+    for (var i=0, len=params.length; i<len; ++i ) {
+      if (value == String(params[i])) {
+        return false;
       }
     }
-  });
-
-  $(document).ready(function() {
-    $('form[object-csv]').clientSideValidations();
-  });
-}
-
-ClientSideValidations = function(id, adapter, object_id) {
-  this.id                = id;
-  this.adapter           = adapter;
-  this.adaptValidations  = function(validations) {
-    this.validations           = validations;
-    this.jQueryValidateAdapter = function() {
-      rules    = {}
-      messages = {}
-      for(var attr in this.validations) {
-        name           = this.id + '[' + attr + ']';
-        rules[name]    = {};
-        messages[name] = {};
-        for(var validation in this.validations[attr]) {
-          rule = null;
-          required = false;
-          switch(validation) {
-            case 'presence':
-              rule  = 'required';
-              value = true;
-              break;
-            case 'format':
-              value    = this.validations[attr][validation]['with'];
-              required = !this.validations[attr][validation]['allow_blank'];
-              break;
-            case 'numericality':
-              rule     = 'digits';
-              value    = true;
-              required = !this.validations[attr][validation]['allow_blank'];
-              break;
-            case 'length':
-              if ('minimum' in this.validations[attr][validation] && 'maximum' in this.validations[attr][validation]) {
-                maxrule                 = 'maxlength';
-                rules[name][maxrule]    = this.validations[attr][validation]['maximum'];
-                messages[name][maxrule] = this.validations[attr][validation]['message_max'];
-                
-                rule     = 'minlength';
-                value    = this.validations[attr][validation]['minimum'];
-                this.validations[attr][validation]['message'] = this.validations[attr][validation]['message_min']
-              } else if('minimum' in this.validations[attr][validation]) {
-                rule     = 'minlength';
-                value    = this.validations[attr][validation]['minimum'];
-              } else if('maximum' in this.validations[attr][validation]) {
-                rule  = 'maxlength';
-                value = this.validations[attr][validation]['maximum'];
-              }
-              break;
-            case 'uniqueness':
-              rule  = 'remote';
-              value = {
-                url: '/validations/uniqueness.json',
-                data: {}
-              }
-              if(object_id) {
-                value['data'][this.id + '[id]'] = function() {
-                  return String(object_id);
-                }
-              }
-              required = !this.validations[attr][validation]['allow_blank'];
-              break;
-            case 'confirmation':
-              rule  = 'equalTo';
-              value = "[name='" + this.id + "[" + attr + "_confirmation]"  + "']";
-              break;
-            case 'acceptance':
-              rule  = 'acceptance';
-              value = true;
-              break;
-            case 'inclusion':
-              rule     = 'inclusion';
-              value    = this.validations[attr][validation]['in']
-              required = !this.validations[attr][validation]['allow_blank'];
-              break;
-            case 'exclusion':
-              rule     = 'exclusion';
-              value    = this.validations[attr][validation]['in']
-              required = !this.validations[attr][validation]['allow_blank'];
-              break;
-
-            default:
-          }
-          if(rule == null) {
-            rule = validation;
-          }
-          
-          if (typeof(value) != 'undefined') {
-            rules[name][rule]    = value;
-            messages[name][rule] = this.validations[attr][validation]['message'];
-          }
-          if (required && rules[name]['required'] == null) {
-            rules[name].required    = true;
-            messages[name].required = this.validations[attr][validation]['message'];
-          }
-        }
-      }
-
-      result = {
-        rules : rules,
-        messages : messages
-      };
-
-      return result;
-    };
-    
-    switch(this.adapter) {
-      case 'jquery.validate':
-        return this.jQueryValidateAdapter();
-        break;
-      default:
+  }
+  return true;
+}, jQuery.validator.format("Is reserved."));
+
+jQuery.validator.addMethod("islength", function(value, element, length) { 
+  return this.optional(element) || value.length == length;
+}, jQuery.validator.format("Is the wrong length."));
+
+$.extend($.fn, {
+  clientSideValidations: function() {
+    for (var i = 0; i < this.size(); i++) {
+      var form                        = $(this[i]);
+      var object                      = form.attr('data-csv');
+      var validate_options            = eval(object + "_validate_options");
+      validate_options.options.ignore = ':hidden';
+      form.validate(validate_options);
     }
-  };
-}
+  }
+});
+
+$(function() {
+  $('form[data-csv]').clientSideValidations();
+});

data/lib/client_side_validations/adapters/action_view.rb

@@ -7,20 +7,18 @@ module DNCLabs
           def self.included(base)
             form_method = base.instance_method(:form_for)
             base.class_eval do
+              attr_accessor :validate_options
+              
               define_method(:form_for) do |record_or_name_or_array, *args, &proc|
-                options = args.extract_options!
-                options.symbolize_keys!
+                options = Hash.new { |h, k| h[k] = {}}
+                options.merge!(args.extract_options!.symbolize_keys!)
                 script = ""
                 if validations = options.delete(:validations)
-                  unless options.key?(:html)
-                    options[:html] = {}
-                  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>}
+                  set_validate_options(validations, record_or_name_or_array)
+                  options[:html]['data-csv'] = validate_options.delete('data-csv')
+                  script = %{<script type='text/javascript'>var #{options[:html]['data-csv']}_validate_options=#{validate_options.to_json};</script>}
                 end
-                args << options
+                args << {}.merge(options)
                 result = form_method.bind(self).call(record_or_name_or_array, *args, &proc)
                 
                 if rails3?
@@ -36,67 +34,102 @@ module DNCLabs
           private
           
           def rails3?
-            version=
+            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 || { }
+          def set_validate_options(validations, record_or_name_or_array)
+            options = ::ClientSideValidations.default_options || { }
+            
             case validations
             when true
-              object, rules = csv_get_object_and_validation_rules(record_or_name_or_array)
+              object_name      = get_object_name(record_or_name_or_array)
+              data_csv         = get_data_csv(record_or_name_or_array)
+              validate_options = rules_and_messages(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
+                object_name      = get_object_name(validations[:instance])
+                data_csv         = get_data_csv(validations[:instance])
+                validate_options = validations[:instance].validate_options
               elsif validations.has_key?(:class)
-                object = validations[:instance].to_s.underscore
-                rules  = validations[:instance].new.validations_to_json
+                object_name      = get_object_name(validations[:class].new)
+                data_csv         = get_data_csv(validations[:instance].new)
+                validate_options = validations[:class].new.validate_options
               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])
+                object_name      = get_object_name(record_or_name_or_array)
+                data_csv         = get_data_csv(record_or_name_or_array)
+                validate_options = rules_and_messages(record_or_name_or_array)
               end
+
+              options.merge!(validations[:options] || {})
             else
-              object = validations.to_s.underscore
-              rules  = validations.new.validations_to_json
+              object_name      = get_object_name(validations)
+              data_csv         = get_data_csv(validations)
+              validate_options = validations.new.validate_options
             end
             
-            if csv_options.empty?
-              csv_options = ""
-            else
-              csv_options = %{var #{object}_validation_options=#{convert_csv_options_to_json(csv_options)};}
+            self.validate_options = build_validate_options(object_name, validate_options, options, data_csv)
+          end
+          
+          def build_validate_options(object_name, validate_options, options, data_csv)
+            %w{rules messages}.each do |option|
+              validate_options[option].keys.each do |key|
+                validate_options[option]["#{object_name}[#{key}]"] = validate_options[option].delete(key)
+              end
             end
             
-            [object, rules, csv_options]
+            validate_options['options']  = options unless options.empty?
+            validate_options['data-csv'] = data_csv
+            validate_options
           end
           
-          def convert_csv_options_to_json(csv_options)
+          def convert_options_to_json(options)
             json = []
-            csv_options.each do |k, v|
+            options.each do |k, v|
               json << %{#{k}:#{v}}
             end
             %{{#{json.join(',')}}}
           end
           
-          def csv_get_object_and_validation_rules(record_or_name_or_array)
+          def rules_and_messages(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
+              record_or_name_or_array.to_s.camelize.constantize.new.validate_options
             when Array
-              object, rules = csv_get_object_and_validation_rules(record_or_name_or_array.last)
+              rules_and_messages(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
+              record_or_name_or_array.validate_options
+            end
+          end
+          
+          def get_data_csv(object)
+            case object
+            when String, Symbol
+              object.to_s
+            when Array
+              get_data_csv(object.last)
+            when Class
+              object.to_s.underscore
+            else
+              dom_id(object)
+            end
+          end
+          
+          def get_object_name(object)
+            case object
+            when String, Symbol
+              object.to_s
+            when Array
+              get_object_name(object.last)
+            when Class
+              get_object_name(object.new)
+            else
+              ActionController::RecordIdentifier.singular_class_name(object)
             end
-            
-            [object, rules]
           end
         end # BaseMethods
         

data/lib/client_side_validations/adapters/active_model.rb

@@ -5,7 +5,7 @@ module DNCLabs
     module Adapters
       class ActiveModel < ORMBase
 
-        def validation_to_hash(attr)
+        def validations_to_hash(attr)
           base._validators[attr.to_sym].inject({}) do |hash, validation|
             hash.merge!(build_validation_hash(validation.clone))
           end
@@ -48,7 +48,9 @@ module DNCLabs
           when :format
             I18n.translate(i18n_prefix + 'errors.messages.invalid')
           when :length
-            if count = validation.options[:minimum]
+            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)

data/lib/client_side_validations/adapters/orm_base.rb

@@ -8,7 +8,7 @@ module DNCLabs
           self.base = base
         end
         
-        def validation_to_hash(attr)
+        def validations_to_hash(attr)
         end
         
         def validation_fields

data/lib/client_side_validations/orm.rb

@@ -1,15 +1,138 @@
 module DNCLabs
   module ClientSideValidations
-    def validations_to_json
-      hash = Hash.new { |h, field| h[field] = {} }
+    def validate_options
+      rules    = Hash.new { |h, field| h[field] = {} }
+      messages = Hash.new { |h, field| h[field] = {} }
       validation_fields.each do |field|
-        hash[field].merge!(validation_to_hash(field))
+        validations = validations_to_hash(field)
+        rules[field.to_s].merge!(extract_rules(validations, field))
+        messages[field.to_s].merge!(extract_messages(validations))
       end
-      hash.to_json
+      {"rules" => rules, "messages" => messages}
     end
     
-    def validation_to_hash(field)
-      dnc_csv_adapter.validation_to_hash(field)
+    def validations_to_hash(field)
+      dnc_csv_adapter.validations_to_hash(field)
+    end
+    
+    private
+    
+    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'
+        end
+      when 'uniqueness'
+        'remote'
+      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 = {}
+          else
+            data = { "#{self.class.to_s.underscore}[id]" => self.id}
+          end
+          {'url' => '/validations/uniqueness.json', 'data' => data}
+        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
+            
+            rules[k] = special_rule
+          end
+        end
+
+        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
+
+            messages[k] = options[special_message]
+          end
+        end
+
+        if required?(kind, options)
+          unless messages['required']
+            messages['required'] = options['message']
+          end
+        end
+      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')
+      end
     end
     
     def validation_fields

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: client_side_validations
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 2
   - 6
-  - 2
-  version: 2.6.2
+  - 3
+  version: 2.6.3
 platform: ruby
 authors: 
 - Brian Cardarella
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-22 00:00:00 -04:00
+date: 2010-07-25 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency