validatious-on-rails 0.4.6 → 0.4.7

data/generators/validatious/templates/v2.rails.js

@@ -20,7 +20,14 @@ v2.blank = function blank(value) {
 */
 v2.bool = function bool(value) {
   value += '';
-  return (value === true) || (value === 'true');
+  return value === 'true' || +value > 0;
+};
+
+/**
+* Checks if a string is null/undefined.
+*/
+v2.present = function present(value) {
+  return !(typeof value === 'undefined' || value === null);
 };
 
 /**
@@ -44,54 +51,57 @@ v2.trimField = function trimField(field) {
 /**
  *  Generic validator that acts as a client-side validator/helper for remote validator responses.
  */
-v2.Validator.add({acceptEmpty: true, fn: function(field, value, params) { return !!params[0]; }, message: null, name: 'remote-client'});
+v2.Validator.add({acceptEmpty: false, fn: function(field, value, params) { return !!params[0]; }, message: null, name: 'remote-client'});
 
 /**
  *  Perform a remote validation on a given field the Validatious way, slightly modified
  */
-v2.Rails.performRemoteValidation = function performRemoteValidation(name, field, value, params, message) {
-  var field_element = field.__elements[0];
-  var url = v2.Rails.remoteValidationUrlFor(name, field_element, value, params);
-
-  v2.Rails.initializeLastResult(name, field_element.id);
-
-  var xmlHttpRequest = new XMLHttpRequest;
-  xmlHttpRequest.open('GET', url, true);
-  xmlHttpRequest.onreadystatechange = function() {
-    if (this.readyState == XMLHttpRequest.DONE) {
-      var validationResult = (this.responseText == 'true' || this.responseText == '1') ? true : false;
-      v2.Rails.lastRemoteValidationResult[name][field_element.id] = validationResult;
-      /* console.log('Validation result: ' + validationResult); */
-
-      /* Get all validators for this field, except the current validator. */
-      var fieldClasses = field_element.getAttribute('class').replace(new RegExp(name + '\w*'), '').replace(/^\s+|\s+$/g, '');
-      var theOtherValidators = v2.html.validatorsFromString(fieldClasses);
-
-      /* Make remote-client validator trigger validation failure or not. */
-      var thisValidator = field_element.id.is('remote-client', validationResult).explain(message);
-      v2.html.applyValidators(theOtherValidators, thisValidator);
-      thisValidator.item.validate();
-    };
-  };
-  xmlHttpRequest.send(null);
-  return v2.Rails.lastRemoteValidationResult[name][field_element.id];
-};
+ v2.Rails.performRemoteValidation = function performRemoteValidation(name, field, value, params, message) {
+   var field_element = field.__elements[0];
+   var url = v2.Rails.remoteValidationUrlFor(name, field_element, value, []);
+
+   v2.Rails.initializeLastResult(name, field_element.id);
+
+   console.log(v2.Rails.lastRemoteValidationResult[name][field_element.id]);
+
+   var xmlHttpRequest = new XMLHttpRequest;
+   xmlHttpRequest.open('GET', url, true);
+   xmlHttpRequest.onreadystatechange = function() {
+     if (this.readyState == XMLHttpRequest.DONE) {
+       var validationResult = v2.bool(this.responseText);
+       v2.Rails.lastRemoteValidationResult[name][field_element.id] = validationResult;
+
+       /* Get all validators for this field, except the current validator. */
+       var fieldClasses = v2.trim(field_element.getAttribute('class').replace(new RegExp(name + '\w*'), ''));
+       var theOtherValidators = v2.html.validatorsFromString(fieldClasses);
+
+       /* Make remote-client validator trigger validation failure or not. */
+       var thisValidator = field_element.id.is('remote-client', validationResult).explain(message);
+       v2.html.applyValidators(theOtherValidators, thisValidator);
+
+       /* Trigger validation. */
+       thisValidator.item.validate();
+     };
+   };
+   xmlHttpRequest.send(null);
+   return v2.Rails.lastRemoteValidationResult[name][field_element.id];
+ };
 
 /**
  *  Initialize data structure for holding info about last remote AJAX validation result.
  *  We need this to make Validatious play well with remote validations.
  */
-v2.Rails.initializeLastResult = function initializeLastResult(validator_name, field_id) {
-  if (typeof v2.Rails.lastRemoteValidationResult == 'undefined') {
-    v2.Rails.lastRemoteValidationResult = new Array();
-  }
-  if (typeof v2.Rails.lastRemoteValidationResult[validator_name] == 'undefined') {
-    v2.Rails.lastRemoteValidationResult[validator_name] = new Array();
-  };
-  if (typeof v2.Rails.lastRemoteValidationResult[validator_name][field_id] == 'undefined') {
-    v2.Rails.lastRemoteValidationResult[validator_name][field_id] = false;
-  };
-};
+ v2.Rails.initializeLastResult = function initializeLastResult(validator_name, field_id) {
+   if (!v2.present(v2.Rails.lastRemoteValidationResult)) {
+     v2.Rails.lastRemoteValidationResult = new Array();
+   };
+   if (!v2.present(v2.Rails.lastRemoteValidationResult[validator_name])) {
+     v2.Rails.lastRemoteValidationResult[validator_name] = new Array();
+   };
+   if (!v2.present(v2.Rails.lastRemoteValidationResult[validator_name][field_id])) {
+     v2.Rails.lastRemoteValidationResult[validator_name][field_id] = false;
+   };
+ };
 
 /** 
  *  Generate a remote validation poll URL the validatious-on-rails-way,
@@ -112,11 +122,11 @@ v2.Rails.remoteValidationUrlFor = function remoteValidationUrlFor(name, field, v
               [
                 ['model', escape(modelName)].join('='),
                 ['attribute', escape(attributeName)].join('='),
-                ['id', recordId].join('='),
+                (v2.blank(recordId) ? null : ['id', recordId].join('=')),
                 ['value', escape(value)].join('='),
                 paramsString.join('&')
               ].join('&')
-            ].join('').replace(/\&$/, '');
+            ].join('').replace(/\&\&/, '&').replace(/\&$/, '');
   return url;
 };
 

data/lib/validatious-on-rails/model_validations.rb

@@ -11,316 +11,314 @@ require File.join(File.dirname(__FILE__), *%w[validatious validators])
 # Validatious-Rails validation translator.
 #
 module ValidatiousOnRails
-  class ModelValidations
-
-    CORE_VALIDATIONS = [
-        :acceptance_of,
-        :associated,
-        :confirmation_of,
-        :exclusion_of,
-        :format_of,
-        :inclusion_of,
-        :length_of,
-        :numericality_of,
-        :presence_of,
-        :uniqueness_of
-      ].freeze
-    SUPPORTED_VALIDATIONS = CORE_VALIDATIONS
-
-    class << self
-
-      # References:
-      #   http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html
-      #   http://github.com/rails/rails/blob/13fb26b714dec0874303f51cc125ff62f65a2729/activerecord/lib/active_record/validations.rb
-
-      # Generates form field helper options for a specified object-attribute to
-      # reflect on it's validations.
-      #
-      # Input may be an ActiveRecord class, a class name (string), or an object
-      # name along with a method/field.
-      #
-      def options_for(object_name, attribute_method, options = {}, existing_validators = nil)
-        # Handle Nested form.
-        object_name = options[:object].present? ? options[:object].class.name : object_name
-        
-        validators = self.from_active_record(object_name, attribute_method)
-        validator_classes, validator_js = [options[:class]], []
-
-        # Only attach validators that are not already attached.
-        validators.flatten.compact.uniq.each do |v|
-          validator_js << v.to_js unless existing_validators.present? && /#{v.name}/ =~ existing_validators
-          validator_classes << v.to_class
+  module ModelValidations
+
+    extend self
+
+    IGNORED_VALIDATIONS = [:each, :associated]
+
+    def validation_methods
+      ::ActiveRecord::Base.methods.sort.collect do |m|
+        $1.to_s.to_sym if (m.to_s =~ /^validates_(.*)/)
+      end.compact - IGNORED_VALIDATIONS
+    end
+
+    CORE_VALIDATIONS = self.validation_methods
+
+    # References:
+    #   http://api.rubyonrails.org/classes/ActiveRecord/Validations/ClassMethods.html
+    #   http://github.com/rails/rails/blob/13fb26b714dec0874303f51cc125ff62f65a2729/activerecord/lib/active_record/validations.rb
+
+    # Generates form field helper options for a specified object-attribute to
+    # reflect on it's validations.
+    #
+    # Input may be an ActiveRecord class, a class name (string), or an object
+    # name along with a method/field.
+    #
+    def options_for(object_name, attribute_method, options = {}, existing_validators = nil)
+      # Handle Nested form.
+      object_name = options[:object].present? ? options[:object].class.name : object_name
+
+      validators = self.from_active_record(object_name, attribute_method)
+      validator_classes, validator_js = [options[:class]], []
+
+      # Only attach validators that are not already attached.
+      validators.flatten.compact.uniq.each do |v|
+        validator_js << v.to_js unless existing_validators.present? && /#{v.name}/ =~ existing_validators
+        validator_classes << v.to_class
+      end
+      classes = validator_classes.compact.join(' ').strip
+      js = validator_js.compact.join("\n").strip
+      options.merge!(:class => (classes unless classes.blank?), :js => (js unless js.blank?))
+    end
+
+    # Groks Rails validations, and is able to convert a rails validation to
+    # a Validatious 2.0 compatible class string, and a Validatous validator
+    # for more complex validations. Even some of the Rails core validations
+    # with certain options requires this.
+    #
+    # Input may be an ActiveRecord class, a class name (string), or an object
+    # name along with a method/field.
+    #
+    # Returns a string that will be recognized by Validatious as a class name in
+    # form markup.
+    #
+    def from_active_record(object_or_class, attribute_method)
+      validators = []
+      begin
+        klass = if [::String, ::Symbol].any? { |c| object_or_class.is_a?(c) }
+        object_or_class.to_s.classify.constantize
+        elsif object_or_class.is_a?(::Object)
+          object_or_class.class
+        else
+          object_or_class
         end
-        classes = validator_classes.compact.join(' ').strip
-        js = validator_js.compact.join("\n").strip
-        options.merge!(:class => (classes unless classes.blank?), :js => (js unless js.blank?))
+        return validators unless klass.respond_to?(:reflect_on_validations_for)
+      rescue
+        ::ValidatiousOnRails.log "Missing constant: #{object_or_class}", :debug
+        return validators
       end
 
-      # Groks Rails validations, and is able to convert a rails validation to
-      # a Validatious 2.0 compatible class string, and a Validatous validator
-      # for more complex validations. Even some of the Rails core validations
-      # with certain options requires this.
-      #
-      # Input may be an ActiveRecord class, a class name (string), or an object
-      # name along with a method/field.
-      #
-      # Returns a string that will be recognized by Validatious as a class name in
-      # form markup.
-      #
-      def from_active_record(object_or_class, attribute_method)
-        validators = []
-        begin
-          klass = if [::String, ::Symbol].any? { |c| object_or_class.is_a?(c) }
-                    object_or_class.to_s.classify.constantize
-                  elsif object_or_class.is_a?(::Object)
-                    object_or_class.class
-                  else
-                    object_or_class
-                  end
-          return validators unless klass.respond_to?(:reflect_on_validations_for)
-        rescue
-          ::ValidatiousOnRails.log "Missing constant: #{object_or_class}", :debug
-          return validators
+      # Iterate thorugh the validations for the current class,
+      # and collect validation options.
+      klass.reflect_on_validations_for(attribute_method.to_sym).each do |validation|
+        validates_type = validation.macro.to_s.sub(/^validates?_/, '')
+        if validation.options[:client_side].nil?
+          validation.options[:client_side] = ::ValidatiousOnRails.client_side_validations_by_default
         end
 
-        # Iterate thorugh the validations for the current class,
-        # and collect validation options.
-        klass.reflect_on_validations_for(attribute_method.to_sym).each do |validation|
-          validates_type = validation.macro.to_s.sub(/^validates?_/, '')
+        # Skip "confirmation_of"-validation info for the attribute that
+        # needs to be confirmed. Validatious expects this validation rule
+        # on the confirmation field. *
+        unless validates_type =~ /^confirmation_of$/
+          validators << self.send(validates_type.to_sym, validation) if validation.options[:client_side]
+        end
+      end
+
+      # Special case for "confirmation_of"-validation (see * above).
+      if attribute_method.to_s =~ /(.+)_confirmation$/
+        confirm_attribute_method = $1
+        # Check if validates_confirmation_of(:hello) actually exists,
+        # if :hello_confirmation field exists - just to be safe.
+        klass.reflect_on_validations_for(confirm_attribute_method.to_sym).each do |validation|
           if validation.options[:client_side].nil?
             validation.options[:client_side] = ::ValidatiousOnRails.client_side_validations_by_default
           end
 
-          # Skip "confirmation_of"-validation info for the attribute that
-          # needs to be confirmed. Validatious expects this validation rule
-          # on the confirmation field. *
-          unless validates_type =~ /^confirmation_of$/
-            validators << self.send(validates_type.to_sym, validation) if validation.options[:client_side]
-          end
-        end
-
-        # Special case for "confirmation_of"-validation (see * above).
-        if attribute_method.to_s =~ /(.+)_confirmation$/
-          confirm_attribute_method = $1
-          # Check if validates_confirmation_of(:hello) actually exists,
-          # if :hello_confirmation field exists - just to be safe.
-          klass.reflect_on_validations_for(confirm_attribute_method.to_sym).each do |validation|
-            if validation.options[:client_side].nil?
-              validation.options[:client_side] = ::ValidatiousOnRails.client_side_validations_by_default
-            end
-
-            if validation.macro.to_s =~ /^validates_confirmation_of$/
-              validators << self.confirmation_of(validation) if validation.options[:client_side]
-              break
-            end
+          if validation.macro.to_s =~ /^validates_confirmation_of$/
+            validators << self.confirmation_of(validation) if validation.options[:client_side]
+            break
           end
         end
-        validators.flatten.compact
       end
+      validators.flatten.compact
+    end
 
-      # Resolve validation from validates_acceptance_of.
-      #
-      # Alias, but might change: acceptance_of <=> presence_of
-      #
-      # NOTE: Not supported:
-      #   * :on - TODO.
-      #   * :if/:unless - hard to port all to client-side JavaScript
-      #                   (impossible: procs, unaccessible valiables, etc.).
-      #
-      def acceptance_of(validation)
-        validators = []
-        validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
-        validation.options[:accept] ||= '1' # Rails default.
-        validators << Validatious::AcceptanceAcceptValidator.new(validation.options[:accept],
-          validation.options[:allow_nil])
-      end
+    # Resolve validation from validates_acceptance_of.
+    #
+    # Alias, but might change: acceptance_of <=> presence_of
+    #
+    # NOTE: Not supported:
+    #   * :on - TODO.
+    #   * :if/:unless - hard to port all to client-side JavaScript
+    #                   (impossible: procs, unaccessible valiables, etc.).
+    #
+    def acceptance_of(validation)
+      validators = []
+      validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
+      validation.options[:accept] ||= '1' # Rails default.
+      validators << Validatious::AcceptanceAcceptValidator.new(validation.options[:accept],
+                                                               validation.options[:allow_nil])
+    end
 
-      # Resolve validation from validates_associated.
-      #
-      # NOTE: Not supported - low prio.
-      #
-      def associated(validation)
-        nil
-      end
+    # Resolve validation from validates_associated.
+    #
+    # NOTE: Not supported - low prio.
+    #
+    def associated(validation)
+      nil
+    end
 
-      # Resolve validation from validates_confirmation_of.
-      # This validation is treated a bit differently in compare
-      # to the other validations. See "from_active_record".
-      #
-      # NOTE: Not supported:
-      #   * :on - TODO.
-      #   * :if/:unless - hard to port all to client-side JavaScript
-      #                   (impossible: procs, unaccessible valiables, etc.).
-      #
-      def confirmation_of(validation)
-        validators = []
-        field_id = unless validation.active_record.present?
-          "#{validation.active_record.name.tableize.singularize.gsub('/', '_')}_#{validation.name}"
-        else
-          "#{validation.name}"
-        end
-        validators << Validatious::ConfirmationOfValidator.new(field_id)
+    # Resolve validation from validates_confirmation_of.
+    # This validation is treated a bit differently in compare
+    # to the other validations. See "from_active_record".
+    #
+    # NOTE: Not supported:
+    #   * :on - TODO.
+    #   * :if/:unless - hard to port all to client-side JavaScript
+    #                   (impossible: procs, unaccessible valiables, etc.).
+    #
+    def confirmation_of(validation)
+      validators = []
+      field_id = unless validation.active_record.present?
+      "#{validation.active_record.name.tableize.singularize.gsub('/', '_')}_#{validation.name}"
+      else
+        "#{validation.name}"
       end
+      validators << Validatious::ConfirmationOfValidator.new(field_id)
+    end
 
-      # Resolve validation from validates_exclusion_of.
-      #
-      # Attaching custom validator - with a unique name based on the exclusion values.
-      #
-      # NOTE: Not supported:
-      #   * :on - TODO.
-      #   * :if/:unless - hard to port all to client-side JavaScript
-      #                   (impossible: procs, unaccessible valiables, etc.).
-      #
-      def exclusion_of(validation)
-        validators = []
-        validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
-        validation.options[:allow_blank] = false if validation.options[:allow_blank].nil?
-        validators << Validatious::ExclusionInValidator.new(validation.options[:in],
-          validation.options[:allow_nil], validation.options[:allow_blank])
-      end
+    # Resolve validation from validates_exclusion_of.
+    #
+    # Attaching custom validator - with a unique name based on the exclusion values.
+    #
+    # NOTE: Not supported:
+    #   * :on - TODO.
+    #   * :if/:unless - hard to port all to client-side JavaScript
+    #                   (impossible: procs, unaccessible valiables, etc.).
+    #
+    def exclusion_of(validation)
+      validators = []
+      validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
+      validation.options[:allow_blank] = false if validation.options[:allow_blank].nil?
+      validators << Validatious::ExclusionInValidator.new(validation.options[:in],
+                                                          validation.options[:allow_nil], validation.options[:allow_blank])
+    end
 
-      # Resolve validation from validates_format_of.
-      #
-      # Attaching custom validator, with a unique name based on the regular expression.
-      # Needs regexp.inspect to get it right.
-      #
-      # NOTE: Not supported:
-      #   * :on - TODO.
-      #   * :if/:unless - hard to port all to client-side JavaScript
-      #                   (impossible: procs, unaccessible valiables, etc.).
-      #
-      def format_of(validation)
-        validators = []
-        validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
-        validation.options[:allow_blank] = false if validation.options[:allow_blank].nil?
-        validators << Validatious::FormatWithValidator.new(validation.options[:with],
-          validation.options[:allow_nil], validation.options[:allow_blank])
-      end
+    # Resolve validation from validates_format_of.
+    #
+    # Attaching custom validator, with a unique name based on the regular expression.
+    # Needs regexp.inspect to get it right.
+    #
+    # NOTE: Not supported:
+    #   * :on - TODO.
+    #   * :if/:unless - hard to port all to client-side JavaScript
+    #                   (impossible: procs, unaccessible valiables, etc.).
+    #
+    def format_of(validation)
+      validators = []
+      validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
+      validation.options[:allow_blank] = false if validation.options[:allow_blank].nil?
+      validators << Validatious::FormatWithValidator.new(validation.options[:with],
+                                                         validation.options[:allow_nil], validation.options[:allow_blank])
+    end
 
-      # Resolve validation from validates_inclusion_of.
-      #
-      # Attaching custom validator - with a unique name based on the inclusion values.
-      #
-      # NOTE: Not supported:
-      #   * :on - TODO.
-      #   * :if/:unless - hard to port all to client-side JavaScript
-      #                   (impossible: procs, unaccessible valiables, etc.).
-      #
-      def inclusion_of(validation)
-        validators = []
-        validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
-        validation.options[:allow_blank] = false if validation.options[:allow_blank].nil?
-        validators << Validatious::InclusionInValidator.new(validation.options[:in],
-          validation.options[:allow_nil], validation.options[:allow_blank])
-      end
+    # Resolve validation from validates_inclusion_of.
+    #
+    # Attaching custom validator - with a unique name based on the inclusion values.
+    #
+    # NOTE: Not supported:
+    #   * :on - TODO.
+    #   * :if/:unless - hard to port all to client-side JavaScript
+    #                   (impossible: procs, unaccessible valiables, etc.).
+    #
+    def inclusion_of(validation)
+      validators = []
+      validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
+      validation.options[:allow_blank] = false if validation.options[:allow_blank].nil?
+      validators << Validatious::InclusionInValidator.new(validation.options[:in],
+                                                          validation.options[:allow_nil], validation.options[:allow_blank])
+    end
 
-      # Resolve validation from validates_length_of.
-      #
-      # Example (of generated field classes):
-      #   length-is_5, length-maximum_2, length-minimum_2, etc.
-      #
-      # NOTE: Not supported:
-      #   * :tokenizer - see: :if/:unless
-      #   * :on - TODO.
-      #   * :if/:unless - hard to port all to client-side JavaScript
-      #                   (impossible: procs, unaccessible valiables, etc.).
-      #
-      def length_of(validation)
-        validators = []
-        validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
-        validation.options[:allow_blank] = false if validation.options[:allow_blank].nil?
-
-        if validation.options[:is].present?
-          validators << Validatious::Length::IsValidator.new(validation.options[:is],
-            (validation.options[:allow_nil] || false),
-            (validation.options[:allow_blank] || false))
-        elsif [:in, :within, :minimum, :maximum].any? { |k| validation.options[k].present? }
-          validation.options[:within] ||= validation.options[:in]
-          validation.options[:minimum] ||= validation.options[:within].min rescue nil
-          validation.options[:maximum] ||= validation.options[:within].max rescue nil
-
-          if validation.options[:minimum].present?
-            validators << Validatious::Length::MinimumValidator.new(validation.options[:minimum],
-              (validation.options[:allow_nil] || false),
-              (validation.options[:allow_blank] || false))
-          end
+    # Resolve validation from validates_length_of.
+    #
+    # Example (of generated field classes):
+    #   length-is_5, length-maximum_2, length-minimum_2, etc.
+    #
+    # NOTE: Not supported:
+    #   * :tokenizer - see: :if/:unless
+    #   * :on - TODO.
+    #   * :if/:unless - hard to port all to client-side JavaScript
+    #                   (impossible: procs, unaccessible valiables, etc.).
+    #
+    def length_of(validation)
+      validators = []
+      validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
+      validation.options[:allow_blank] = false if validation.options[:allow_blank].nil?
 
-          if validation.options[:maximum].present?
-            validators << Validatious::Length::MaximumValidator.new(validation.options[:maximum],
-              (validation.options[:allow_nil] || false),
-              (validation.options[:allow_blank] || false))
-          end
-        end
-        validators
-      end
-      alias :size_of :length_of
-
-      # Resolve validation from validates_numericality_of.
-      #
-      # Example (of generated field classes):
-      #   numericality-odd, numericality-only-integer, numericality-equal-to_5, etc.
-      #
-      # NOTE: Not supported:
-      #   * :on - TODO.en
-      #   * :if/:unless - hard to port all to client-side JavaScript
-      #                   (impossible: procs, unaccessible valiables, etc.).
-      #
-      def numericality_of(validation)
-        validators = []
-        validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
-
-        if validation.options[:odd] && !validation.options[:even]
-          validators << Validatious::Numericality::OddValidator.new(validation.options[:allow_nil])
-        end
+      if validation.options[:is].present?
+        validators << Validatious::Length::IsValidator.new(validation.options[:is],
+                                                           (validation.options[:allow_nil] || false),
+                                                           (validation.options[:allow_blank] || false))
+      elsif [:in, :within, :minimum, :maximum].any? { |k| validation.options[k].present? }
+        validation.options[:within] ||= validation.options[:in]
+        validation.options[:minimum] ||= validation.options[:within].min rescue nil
+        validation.options[:maximum] ||= validation.options[:within].max rescue nil
 
-        if validation.options[:even] && !validation.options[:odd]
-          validators << Validatious::Numericality::EvenValidator.new(validation.options[:allow_nil])
+        if validation.options[:minimum].present?
+          validators << Validatious::Length::MinimumValidator.new(validation.options[:minimum],
+                                                                  (validation.options[:allow_nil] || false),
+                                                                  (validation.options[:allow_blank] || false))
         end
 
-        if validation.options[:only_integer]
-          validators << Validatious::Numericality::OnlyIntegerValidator.new(validation.options[:allow_nil])
+        if validation.options[:maximum].present?
+          validators << Validatious::Length::MaximumValidator.new(validation.options[:maximum],
+                                                                  (validation.options[:allow_nil] || false),
+                                                                  (validation.options[:allow_blank] || false))
         end
-
-        (validation.options.keys & [:equal_to, :less_than, :less_than_or_equal_to,
-          :greater_than, :greater_than_or_equal_to]).each { |name|
-            validator_klass = "::ValidatiousOnRails::Validatious::Numericality::#{name.to_s.classify}Validator".constantize
-            value = validation.options[name]
-            if value.is_a?(::Numeric)
-              validators << validator_klass.new(validation.options[name], validation.options[:allow_nil])
-            end
-          }
-        validators
       end
+      validators
+    end
+    alias :size_of :length_of
 
-      # Resolve validation from validates_presence_of.
-      #
-      # Alias, but might change: acceptance_of <=> presence_of
-      #
-      # NOTE: Not supported:
-      #   * :on - TODO.
-      #   * :if/:unless - hard to port all to client-side JavaScript
-      #                   (impossible: procs, unaccessible valiables, etc.).
-      #
-      def presence_of(validation)
-        validators = []
-        validators << Validatious::PresenceValidator.new
+    # Resolve validation from validates_numericality_of.
+    #
+    # Example (of generated field classes):
+    #   numericality-odd, numericality-only-integer, numericality-equal-to_5, etc.
+    #
+    # NOTE: Not supported:
+    #   * :on - TODO.en
+    #   * :if/:unless - hard to port all to client-side JavaScript
+    #                   (impossible: procs, unaccessible valiables, etc.).
+    #
+    def numericality_of(validation)
+      validators = []
+      validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
+
+      if validation.options[:odd] && !validation.options[:even]
+        validators << Validatious::Numericality::OddValidator.new(validation.options[:allow_nil])
       end
 
-      # Resolve validation from validates_uniqueness_of.
-      #
-      def uniqueness_of(validation)
-        validators = []
-        validators << Validatious::UniquenessValidator.new
+      if validation.options[:even] && !validation.options[:odd]
+        validators << Validatious::Numericality::EvenValidator.new(validation.options[:allow_nil])
       end
 
-      # Unknown validations - if no matching custom validator is found/registered.
-      #
-      def method_missing(sym, *args, &block)
-        ::ValidatiousOnRails.log "Unknown validation: #{sym}." <<
-          " No custom Validatious validator found for this validation makro. ", :warn
-        nil
+      if validation.options[:only_integer]
+        validators << Validatious::Numericality::OnlyIntegerValidator.new(validation.options[:allow_nil])
       end
 
+      (validation.options.keys & [:equal_to, :less_than, :less_than_or_equal_to,
+      :greater_than, :greater_than_or_equal_to]).each { |name|
+        validator_klass = "::ValidatiousOnRails::Validatious::Numericality::#{name.to_s.classify}Validator".constantize
+        value = validation.options[name]
+        if value.is_a?(::Numeric)
+          validators << validator_klass.new(validation.options[name], validation.options[:allow_nil])
+        end
+      }
+      validators
+    end
+
+    # Resolve validation from validates_presence_of.
+    #
+    # Alias, but might change: acceptance_of <=> presence_of
+    #
+    # NOTE: Not supported:
+    #   * :on - TODO.
+    #   * :if/:unless - hard to port all to client-side JavaScript
+    #                   (impossible: procs, unaccessible valiables, etc.).
+    #
+    def presence_of(validation)
+      validators = []
+      validators << Validatious::PresenceValidator.new
+    end
+
+    # Resolve validation from validates_uniqueness_of.
+    #
+    def uniqueness_of(validation)
+      validators = []
+      validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
+      validation.options[:allow_blank] = false if validation.options[:allow_blank].nil?
+      validators << Validatious::UniquenessValidator.new(validation.options[:allow_nil], validation.options[:allow_blank])
     end
+
+    # Unknown validations - if no matching custom validator is found/registered.
+    #
+    def method_missing(sym, *args, &block)
+      ::ValidatiousOnRails.log "Unknown validation: #{sym}." <<
+      " No custom Validatious validator found for this validation makro. ", :warn
+      nil
+    end
+
+    #end
   end
 end

data/lib/validatious-on-rails/validatious/remote_validator.rb

@@ -17,7 +17,10 @@ module ValidatiousOnRails
       def fn
         self.class.truncate_whitespace(@fn ||= %{
             function(field, value, params) {
-              return !!v2.Rails.performRemoteValidation('#{self.name}', field, value, params, '#{self.message}');
+              value += '';
+              #{self.class.handle_nil(0)}
+              #{self.class.handle_blank(1)}
+              return v2.Rails.performRemoteValidation(#{self.name.to_json}, field, value, params, #{self.message.to_json});
             }
           })
       end

data/lib/validatious-on-rails/validatious/validator.rb

@@ -168,7 +168,7 @@ module ValidatiousOnRails
 
         def handle_nil(index = 1)
           %{
-            if (v2.bool(params[#{index}]) && v2.empty(value)) {
+            if (v2.present(params[#{index}]) && v2.bool(params[#{index}]) && v2.empty(value)) {
               return true;
             };
           }
@@ -176,10 +176,10 @@ module ValidatiousOnRails
 
         def handle_blank(index = 2)
           %{
-            if (v2.bool(params[#{index}]) && v2.blank(value)) {
+            if (v2.present(params[#{index}]) && v2.bool(params[#{index}]) && v2.blank(value)) {
               return true;
             };
-            if (!v2.bool(params[#{index}])) {
+            if (v2.present(params[#{index}]) && !v2.bool(params[#{index}])) {
               v2.trimField(field);
               value = v2.trim(value);
             };

data/lib/validatious-on-rails/validatious/validators/uniqueness_validator.rb

@@ -7,8 +7,7 @@ module ValidatiousOnRails
 
       def initialize(*args)
         super
-        self.params = %w[]
-        self.message = self.class.generate_message(:blank)
+        self.message = self.class.generate_message(:taken)
       end
 
     end

data/test/validatious_on_rails/controller_test.rb

@@ -64,23 +64,22 @@ class ControllerTest < ::ActionController::TestCase
             #   assert_response 405
             #   assert_equal 'false', @response.body
             # end
-            
-             # test ":value is allowed to be blank - should succeed" do
-             #   get :uniqueness_of, :model => 'bogus_item', :attribute => 'name'
-             #   assert_response 200
-             #   assert_equal 'true', @response.body
-             # end
+            # 
+            # test ":value is allowed to be blank - should succeed" do
+            #   get :uniqueness_of, :model => 'bogus_item', :attribute => 'name'
+            #   assert_response 200
+            #   assert_equal 'true', @response.body
+            # end
           end
           
           context "with :value" do
-            # FIXME: Fails, but why? Works "in practice".
             test "invalid value - should fail" do
               @existing_bogus_item = ::BogusItem.new(:name => 'carrot')
               @existing_bogus_item.save(false)
               
               get :uniqueness_of, :model => 'bogus_item', :attribute => 'name', :value => 'carrot' 
               assert_response 200
-              assert_equal 'true', @response.body
+              assert_equal 'false', @response.body
             end
             
             test "valid :value - should succeed" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: validatious-on-rails
 version: !ruby/object:Gem::Version 
-  version: 0.4.6
+  version: 0.4.7
 platform: ruby
 authors: 
 - Jonas Grimfelt
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-29 00:00:00 +01:00
+date: 2009-10-31 00:00:00 +01:00
 default_executable: 
 dependencies: []