validatious-on-rails 0.4.5 → 0.4.6

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

@@ -4,8 +4,43 @@
  
 if (typeof v2.Rails === 'undefined' || v2.Rails === null) {
   v2.Rails = {};
+  v2.Rails.params = {};
+  v2.Rails.messages = {};
 }
 
+/**
+* Checks if a string is blank (or undefined).
+*/
+v2.blank = function blank(value) {
+  return v2.empty(value) || /^[\s\t\n]*$/.test(value);
+};
+
+/**
+* Checks if a string is blank (or undefined).
+*/
+v2.bool = function bool(value) {
+  value += '';
+  return (value === true) || (value === 'true');
+};
+
+/**
+* Trim value - fast implementation.
+*/
+v2.trim = function trim(value) {
+  var str = value.replace(/^\s\s*/, ''), ws = /\s/, i = str.length;
+  while (ws.test(str.charAt(--i)));
+  return str.slice(0, i + 1);
+};
+
+/**
+* Trim Field elements and their values.
+*/
+v2.trimField = function trimField(field) {
+  for (var i = 0; i < field.__elements.length; i++) {
+    field.__elements[i].value = v2.trim(field.__elements[i].value);
+  };
+};
+
 /**
  *  Generic validator that acts as a client-side validator/helper for remote validator responses.
  */

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

@@ -129,8 +129,10 @@ module ValidatiousOnRails
       #
       def acceptance_of(validation)
         validators = []
+        validation.options[:allow_nil] = false if validation.options[:allow_nil].nil?
         validation.options[:accept] ||= '1' # Rails default.
-        validators << Validatious::AcceptanceValidator.new(validation, validation.options[:accept])
+        validators << Validatious::AcceptanceAcceptValidator.new(validation.options[:accept],
+          validation.options[:allow_nil])
       end
 
       # Resolve validation from validates_associated.
@@ -145,22 +147,19 @@ module ValidatiousOnRails
       # This validation is treated a bit differently in compare
       # to the other validations. See "from_active_record".
       #
-      # TODO: Message should be Rails I18n message, not Validatious.
-      #
       # NOTE: Not supported:
-      #   * :message - TODO: Explicit or Rails I18n/default message.
       #   * :on - TODO.
       #   * :if/:unless - hard to port all to client-side JavaScript
       #                   (impossible: procs, unaccessible valiables, etc.).
       #
       def confirmation_of(validation)
         validators = []
-        arg = unless validation.active_record.present?
+        field_id = unless validation.active_record.present?
           "#{validation.active_record.name.tableize.singularize.gsub('/', '_')}_#{validation.name}"
         else
           "#{validation.name}"
         end
-        validators << Validatious::ConfirmationValidator.new(validation, arg)
+        validators << Validatious::ConfirmationOfValidator.new(field_id)
       end
 
       # Resolve validation from validates_exclusion_of.
@@ -174,7 +173,10 @@ module ValidatiousOnRails
       #
       def exclusion_of(validation)
         validators = []
-        validators << Validatious::ExclusionValidator.new(validation)
+        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.
@@ -189,7 +191,10 @@ module ValidatiousOnRails
       #
       def format_of(validation)
         validators = []
-        validators << Validatious::FormatValidator.new(validation)
+        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.
@@ -203,7 +208,10 @@ module ValidatiousOnRails
       #
       def inclusion_of(validation)
         validators = []
-        validators << Validatious::InclusionValidator.new(validation)
+        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.
@@ -219,23 +227,30 @@ module ValidatiousOnRails
       #
       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, validation.options[:is])
+          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, validation.options[:minimum])
+            validators << Validatious::Length::MinimumValidator.new(validation.options[:minimum],
+              (validation.options[:allow_nil] || false),
+              (validation.options[:allow_blank] || false))
           end
 
           if validation.options[:maximum].present?
-            validators << Validatious::Length::MaximumValidator.new(validation, validation.options[:maximum])
+            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
@@ -252,22 +267,28 @@ module ValidatiousOnRails
       #
       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)
+          validators << Validatious::Numericality::OddValidator.new(validation.options[:allow_nil])
         end
 
         if validation.options[:even] && !validation.options[:odd]
-          validators << Validatious::Numericality::EvenValidator.new(validation)
+          validators << Validatious::Numericality::EvenValidator.new(validation.options[:allow_nil])
         end
 
-        (validation.options.keys & [:only_integer, :equal_to, :less_than, :less_than_or_equal_to,
-          :greater_than, :greater_than_or_equal_to]).each { |v|
-            validator_klass = "::ValidatiousOnRails::Validatious::Numericality::#{v.to_s.classify}Validator".constantize
-            value = validation.options[v] if validation.options[v].is_a?(::Numeric)
-            validators << validator_klass.new(validation, value)
-          }
+        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
 
@@ -282,32 +303,24 @@ module ValidatiousOnRails
       #
       def presence_of(validation)
         validators = []
-        validators << Validatious::PresenceValidator.new(validation)
+        validators << Validatious::PresenceValidator.new
       end
 
       # Resolve validation from validates_uniqueness_of.
       #
-      # TODO: Implement using RemoteValidator.
-      #
       def uniqueness_of(validation)
         validators = []
-        validators << Validatious::UniquenessValidator.new(validation)
+        validators << Validatious::UniquenessValidator.new
       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. " <<
-          "Maybe you forgot to register you custom validation using: " <<
-          "ValidatiousOnRails::ModelValidations.add(<CustomValidationClass>)", :warn
+          " No custom Validatious validator found for this validation makro. ", :warn
         nil
       end
 
-      # TODO: Include custom validations here...
-      #
-      # @custom_validators.each { |validator_class| ... }
-
     end
   end
 end

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

@@ -5,7 +5,7 @@ module ValidatiousOnRails
   module Validatious
     class ClientSideValidator < Validator
 
-      def initialize(name, *args)
+      def initialize(*args)
         super
       end
 

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

@@ -5,16 +5,14 @@ module ValidatiousOnRails
   module Validatious
     class RemoteValidator < Validator
 
-      def initialize(validation, *args)
-        name = self.class.name.split('::').last.underscore.gsub(/_validator$/, '')
-        super name, *args
-        self.message = self.class.generate_message(validation)
+      def initialize(*args)
+        super
       end
 
       # Override default Validator-fn, with default a RemoteValidator-fn.
       #
       #   1. Perform AJAX request (dependencies: validatious-on-rails.js, XMLHttpRequest.js).
-      #   2. Always return true, callback-function should perform the actual client side validation.
+      #   2. Always return last result, callback-function should perform the actual client side validation.
       #
       def fn
         self.class.truncate_whitespace(@fn ||= %{
@@ -43,7 +41,7 @@ module ValidatiousOnRails
             return true if record.errors[attribute_name.to_sym].blank?
 
             # TODO: Refactor this when "the better" namin convention is used (see TODO).
-            validation_macro = ("validates_%s" % self.name.split('::').last.underscore.gsub(/_validator$/, ''))
+            validation_macro = ("validates_%s" % self.generic_name)
             validation = record.class.reflect_on_validations_for(attribute_name.to_sym).select { |v|
                 v.macro.to_s == validation_macro || v.macro.to_s == "#{validation_macro}_of"
               }.first

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

@@ -30,15 +30,16 @@ module ValidatiousOnRails
                     :aliases,
                     :accept_empty,
                     :fn,
-                    :args
-                    
-      def initialize(name, *args)
-        raise ValidatorError, "Parameter :name is required for an Validatious validator" unless name.present?
-        self.name = name
+                    :args,
+                    :data
+
+      def initialize(*args)
+        self.name = self.class.generic_name
         options = args.extract_options!
         options.each do |attr, value|
           self.send(:"#{attr}=", value) if value.present?
         end
+        self.accept_empty = false
         self.args = args
       end
 
@@ -85,16 +86,21 @@ module ValidatiousOnRails
         @aliases ||= []
       end
 
-      
       # Decides if the validator should pass (return true) when the value is empty.
       # This is usually a good idea because you can leave it up to the required validator
       # to specifically check for emptiness. One benefit of this approach is more 
       # fine grained error reporting, helping the user.
       #
-      # Default value is: true.
+      # Default value is: false. Rails default (:allow_nil).
       #
       def accept_empty
-        @accept_empty.nil? ? true : @accept_empty
+        @accept_empty.nil? ? false : @accept_empty
+      end
+
+      # TODO: Doc.
+      #
+      def data
+        @data ||= ''
       end
 
       # This is the method that performs the validation. It receives three arguments,
@@ -139,9 +145,10 @@ module ValidatiousOnRails
         # - hash ordered by key only 1.9. ='(
         js_options = options.keys.collect(&:to_s).sort.collect { |k|
             v = options[k.to_sym]
-            ("#{k}: #{k.to_sym == :fn ? v : v.to_json}" if [false, true].include?(v) || v.present?)
+            (("#{k}: #{k.to_sym == :fn ? v : v.to_json}") unless v.blank? && v != false)
           }.compact.join(',')
-        self.class.truncate_whitespace("v2.Validator.add({#{js_options}});")
+        js = self.class.truncate_whitespace(self.data)
+        js << self.class.truncate_whitespace("\nv2.Validator.add({#{js_options}});")
       end
       alias :to_s :to_js
 
@@ -159,15 +166,26 @@ module ValidatiousOnRails
           string.gsub(/[\n]+[\s]+/, '')
         end
 
-        def validate_blank(allow_blank)
+        def handle_nil(index = 1)
           %{
-            var isBlank = /^[#{'\s\t\n'}]*$/.test(value);
-            if (#{allow_blank == true} && isBlank) {
+            if (v2.bool(params[#{index}]) && v2.empty(value)) {
               return true;
             };
           }
         end
 
+        def handle_blank(index = 2)
+          %{
+            if (v2.bool(params[#{index}]) && v2.blank(value)) {
+              return true;
+            };
+            if (!v2.bool(params[#{index}])) {
+              v2.trimField(field);
+              value = v2.trim(value);
+            };
+          }
+        end
+
         # Generate a unique valdiator ID to avoid clashes.
         # Note: Ruby #hash is way faster than SHA1 (etc.) - just replace any negative sign.
         #
@@ -175,58 +193,33 @@ module ValidatiousOnRails
           value.to_s.hash.to_s.tr('-', '1')
         end
 
-        # Any named specified for this custom validation?
-        # E.g. validates_format_of :name, :with => /\d{6}-\d{4}/, :name => 'ssn-se'
-        #
-        # If not, create one that's uniqe based on validation and what to validate based on,
-        # e.g. validates_format_of :name, :with => /\d{6}-\d{4}/ # => :name => "format_with_#{hash-of-:with-value}"
-        #
-        def generate_name(validation, id_key, id_value = nil)
-          # Avoiding duplicates...
-          identifier = "-#{id_value}" if id_value.present?
-          validator_id = "#{validation.macro.to_s.sub(/^validates_/, '').sub(/_of/, '')}_#{id_key}#{identifier}"
-          name = validation.options[:name].present? ? validation.options[:name] : validator_id
-          # "_" is not allowed in name/alias(es) - used to seperate validator-id from it's args/params.
-          [name, validator_id].collect! { |v| v.tr('_', '-') }
-        end
-
         # Generate proper error message using explicit message, or I18n-lookup.
         # Core validations gets treated by Rails - unless explicit message is set that is.
         #
-        def generate_message(*args)
-          options = args.extract_options!
-          validation = args.shift if args.first.is_a?(::ActiveRecord::Reflection::MacroReflection)
-          explicit_message = validation.options[:message] if validation
-          key = options.delete(:key) || (explicit_message if explicit_message.is_a?(::Symbol))
-
-          message = if key.present?
-            ::I18n.t(key, options.merge(:scope => :'activerecord.errors.messages',
-              :default => "activerecord.errors.messages.#{key}"))
-          elsif explicit_message.is_a?(::String)
-            explicit_message
-          elsif validation.present?
-            unless ::ValidatiousOnRails::ModelValidations::CORE_VALIDATIONS.include?(validation.macro.to_sym)
-              # No core validation, try to make up a descent I18n lookup path using conventions.
-              key ||= validation.macro.to_s.tr('-', '_').gsub(/^validates?_/, '').gsub(/_of/, '').to_sym
-              ::I18n.t(key, options.merge(:scope => :'activerecord.errors.messages',
-                :default => "activerecord.errors.messages.#{key}"))
-            else
-              # Nothing - let Rails rails handle the core validation message translations (I18n).
-            end
-          end
+        def generate_message(key_or_value, options = {})
+          message = case true
+                    when key_or_value.is_a?(::String)
+                      # Explicit message.
+                      key_or_value
+                    when key_or_value.is_a?(::Symbol)
+                      # Lookup message with I18n key.
+                      ::I18n.t(key_or_value, options.merge(:scope => :'activerecord.errors.messages',
+                        :default => "activerecord.errors.messages.#{key_or_value}"))
+                    end
           # Rails I18n interpolations => Validatious interpolations
           # Example: {{count}} => ${count}
-          message.gsub(/\{\{/, '${').gsub(/\}\}/, '}')
+          message.to_s.gsub(/\{\{/, '${').gsub(/\}\}/, '}')
         end
 
-      end
-
-      protected
-        
         def generic_name
-          self.class.name.split('::').last.underscore.gsub(/_validator$/, '')
+          namespace = self.name.split('::')
+          name = []
+          name.unshift(namespace.pop) until namespace.blank? || namespace.last == 'Validatious'
+          name.join('-').underscore.gsub(/_validator$/, '').tr('_', '-')
         end
 
+      end
+
     end
   end
 end

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. validator]))
+
+module ValidatiousOnRails
+  module Validatious
+    class AcceptanceAcceptValidator < ClientSideValidator
+
+      def initialize(*args)
+        super
+        self.message = self.class.generate_message(:accepted)
+        self.params = %w[accept allow_nil]
+        self.fn = %{
+          #{self.class.handle_nil(1)}
+          var accept_value = params[0] + '';
+          if (accept_value == 'true' || accept_value == 'false') {
+            accept_value = v2.bool(accept_value)
+          };
+          return value == accept_value;
+        }
+      end
+
+    end
+  end
+end