dm-validations 0.9.9 → 0.9.10

data/History.txt

@@ -1,3 +1,18 @@
+=== 0.9.10 / 2009-01-19
+
+* 1 major enhancement:
+
+  * Major spec refactoring
+
+* 2 minor enhancements:
+
+  * Moved all error messages into ValidationErrors.default_error_messages
+  * Added :allow_nil option to validates_within
+
+* 1 bug fix:
+
+  * Fixed error messages and specs for within_validator
+
 === 0.9.9 / 2009-01-04
 
 * No changes this version

data/Manifest.txt

@@ -35,11 +35,30 @@ spec/integration/contextual_validators_spec.rb
 spec/integration/custom_validator_spec.rb
 spec/integration/format_validator_spec.rb
 spec/integration/generic_validator_spec.rb
-spec/integration/length_validator_spec.rb
+spec/integration/length_validator/error_message_spec.rb
+spec/integration/length_validator/maximum_spec.rb
+spec/integration/length_validator/minimum_spec.rb
+spec/integration/length_validator/range_spec.rb
+spec/integration/length_validator/spec_helper.rb
+spec/integration/length_validator/valid_objects_spec.rb
 spec/integration/method_validator_spec.rb
+spec/integration/numeric_validator/float_type_spec.rb
+spec/integration/numeric_validator/integer_only_true_spec.rb
+spec/integration/numeric_validator/integer_type_spec.rb
+spec/integration/numeric_validator/spec_helper.rb
 spec/integration/numeric_validator_spec.rb
 spec/integration/primitive_validator_spec.rb
-spec/integration/required_field_validator_spec.rb
+spec/integration/required_field_validator/association_spec.rb
+spec/integration/required_field_validator/boolean_type_value_spec.rb
+spec/integration/required_field_validator/date_type_value_spec.rb
+spec/integration/required_field_validator/datetime_type_value_spec.rb
+spec/integration/required_field_validator/float_type_value_spec.rb
+spec/integration/required_field_validator/integer_type_value_spec.rb
+spec/integration/required_field_validator/plain_old_ruby_object_spec.rb
+spec/integration/required_field_validator/shared_examples.rb
+spec/integration/required_field_validator/spec_helper.rb
+spec/integration/required_field_validator/string_type_value_spec.rb
+spec/integration/required_field_validator/text_type_value_spec.rb
 spec/integration/uniqueness_validator_spec.rb
 spec/integration/validation_errors_spec.rb
 spec/integration/validation_spec.rb

data/lib/dm-validations.rb

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'pathname'
 
-gem 'dm-core', '~>0.9.9'
+gem 'dm-core', '~>0.9.10'
 require 'dm-core'
 
 dir = Pathname(__FILE__).dirname.expand_path / 'dm-validations'
@@ -76,7 +76,7 @@ module DataMapper
     # resource we can check if they respond to validatable? before trying to
     # recursivly validate them
     #
-    def validatable?()
+    def validatable?
       true
     end
 
@@ -89,13 +89,13 @@ module DataMapper
     # Check if a resource is valid in a given context
     #
     def valid?(context = :default)
-      self.class.validators.execute(context,self)
+      self.class.validators.execute(context, self)
     end
 
     # Begin a recursive walk of the model checking validity
     #
     def all_valid?(context = :default)
-      recursive_valid?(self,context,true)
+      recursive_valid?(self, context, true)
     end
 
     # Do recursive validity checking
@@ -105,11 +105,11 @@ module DataMapper
       target.instance_variables.each do |ivar|
         ivar_value = target.instance_variable_get(ivar)
         if ivar_value.validatable?
-          valid = valid && recursive_valid?(ivar_value,context,valid)
+          valid = valid && recursive_valid?(ivar_value, context, valid)
         elsif ivar_value.respond_to?(:each)
           ivar_value.each do |item|
             if item.validatable?
-              valid = valid && recursive_valid?(item,context,valid)
+              valid = valid && recursive_valid?(item, context, valid)
             end
           end
         end
@@ -186,21 +186,21 @@ module DataMapper
       # if it does not already exist
       #
       def create_context_instance_methods(context)
-        name = "valid_for_#{context.to_s}?"
+        name = "valid_for_#{context.to_s}?"           # valid_for_signup?
         if !self.instance_methods.include?(name)
           class_eval <<-EOS, __FILE__, __LINE__
-            def #{name}
-              valid?('#{context.to_s}'.to_sym)
-            end
+            def #{name}                               # def valid_for_signup?
+              valid?('#{context.to_s}'.to_sym)        #   valid?('signup'.to_sym)
+            end                                       # end
           EOS
         end
 
-        all = "all_valid_for_#{context.to_s}?"
+        all = "all_valid_for_#{context.to_s}?"        # all_valid_for_signup?
         if !self.instance_methods.include?(all)
           class_eval <<-EOS, __FILE__, __LINE__
-            def #{all}
-              all_valid?('#{context.to_s}'.to_sym)
-            end
+            def #{all}                                # def all_valid_for_signup?
+              all_valid?('#{context.to_s}'.to_sym)    #   all_valid?('signup'.to_sym)
+            end                                       # end
           EOS
         end
       end

data/lib/dm-validations/absent_field_validator.rb

@@ -13,11 +13,10 @@ module DataMapper
       end
 
       def call(target)
-        field_value = target.send(field_name).blank?
-        return true if field_value
+        return true if target.send(field_name).blank?
 
-        error_message = @options[:message] || "%s must be absent".t(Extlib::Inflection.humanize(@field_name))
-        add_error(target, error_message , @field_name)
+        error_message = @options[:message] || ValidationErrors.default_error_message(:absent, field_name)
+        add_error(target, error_message, field_name)
 
         return false
       end

data/lib/dm-validations/acceptance_validator.rb

@@ -7,23 +7,19 @@ module DataMapper
     # @since  0.9
     class AcceptanceValidator < GenericValidator
 
-      def self.default_message_for_field(field_name)
-        '%s is not accepted'.t(Extlib::Inflection.humanize(field_name))
-      end
-
       def initialize(field_name, options = {})
         super
         @options = options
         @field_name = field_name
         @options[:allow_nil] = true unless @options.include?(:allow_nil)
-        @options[:accept] ||= ["1",1,"true",true,"t"]
+        @options[:accept] ||= ["1", 1, "true", true, "t"]
         @options[:accept] = Array(@options[:accept])
       end
 
       def call(target)
         unless valid?(target)
-          error_message = @options[:message] || DataMapper::Validate::AcceptanceValidator.default_message_for_field(@field_name)
-          add_error(target, error_message , @field_name)
+          error_message = @options[:message] || ValidationErrors.default_error_message(:accepted, field_name)
+          add_error(target, error_message, field_name)
           return false
         end
 
@@ -31,7 +27,7 @@ module DataMapper
       end
 
       def valid?(target)
-        field_value = target.instance_variable_get("@#{@field_name}")
+        field_value = target.send(field_name)
         return true if @options[:allow_nil] && field_value.nil?
         return false if !@options[:allow_nil] && field_value.nil?
 
@@ -48,7 +44,7 @@ module DataMapper
       # @option :allow_nil<Boolean> true if nil is allowed, false if nil is not
       #                             allowed. Default is true.
       # @option :accept<Array>      a list of accepted values.
-      #                             Default are ["1",1,"true",true,"t"]).
+      #                             Default are ["1", 1, "true", true, "t"]).
       #
       # @example [Usage]
       #   require 'dm-validations'
@@ -64,7 +60,7 @@ module DataMapper
       #     # a call to valid? will return false unless:
       #     # license_agreement is nil or "1"
       #     # and
-      #     # terms_accepted is one of ["1",1,"true",true,"t"]
+      #     # terms_accepted is one of ["1", 1, "true", true, "t"]
       #
       def validates_is_accepted(*fields)
         opts = opts_from_validator_args(fields)

data/lib/dm-validations/confirmation_validator.rb

@@ -16,8 +16,8 @@ module DataMapper
 
       def call(target)
         unless valid?(target)
-          error_message = @options[:message] || '%s does not match the confirmation'.t(Extlib::Inflection.humanize(@field_name))
-          add_error(target, error_message , @field_name)
+          error_message = @options[:message] || ValidationErrors.default_error_message(:confirmation, field_name)
+          add_error(target, error_message, field_name)
           return false
         end
 
@@ -25,12 +25,12 @@ module DataMapper
       end
 
       def valid?(target)
-        field_value = target.instance_variable_get("@#{@field_name}")
+        field_value = target.send(field_name)
         return true if @options[:allow_nil] && field_value.nil?
         return false if !@options[:allow_nil] && field_value.nil?
 
-        if target.class.properties.has_property?(@field_name)
-          return true unless target.attribute_dirty?(@field_name)
+        if target.class.properties.has_property?(field_name)
+          return true unless target.attribute_dirty?(field_name)
         end
 
         confirm_value = target.instance_variable_get("@#{@confirm_field_name}")

data/lib/dm-validations/contextual_validators.rb

@@ -8,7 +8,7 @@ module DataMapper
     class ContextualValidators
 
       def dump
-        contexts.each_pair do |key,context|
+        contexts.each_pair do |key, context|
           puts "Key=#{key} Context: #{context}"
         end
       end

data/lib/dm-validations/custom_validator.rb

@@ -50,7 +50,7 @@ module DataMapper
         #  error_message = @options[:message] || error_message || '%s is invalid'.t(field)
         #  error_message = error_message.call(field, value) if Proc === error_message
         #
-        #  add_error(target, error_message , @field_name)
+        #  add_error(target, error_message, @field_name)
         #end
 
         #return valid

data/lib/dm-validations/format_validator.rb

@@ -24,7 +24,7 @@ module DataMapper
       end
 
       def call(target)
-        value = target.validation_property_value(@field_name)
+        value = target.validation_property_value(field_name)
         return true if @options[:allow_nil] && value.nil?
 
         validation = @options[:as] || @options[:with]
@@ -36,16 +36,17 @@ module DataMapper
           when Proc   then validator.call(value)
           when Regexp then value =~ validator
           else
-            raise UnknownValidationFormat, "Can't determine how to validate #{target.class}##{@field_name} with #{validator.inspect}"
+            raise UnknownValidationFormat, "Can't determine how to validate #{target.class}##{field_name} with #{validator.inspect}"
         end
 
         return true if valid
 
-        field = Extlib::Inflection.humanize(@field_name)
-        error_message = @options[:message] || '%s has an invalid format'.t(field)
+        error_message = @options[:message] || ValidationErrors.default_error_message(:invalid, field_name)
+
+        field = Extlib::Inflection.humanize(field_name)
         error_message = error_message.call(field, value) if error_message.respond_to?(:call)
 
-        add_error(target, error_message, @field_name)
+        add_error(target, error_message, field_name)
 
         false
       end

data/lib/dm-validations/generic_validator.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 module DataMapper
   module Validate
 
@@ -13,8 +14,8 @@ module DataMapper
     # @since  0.9
     class GenericValidator
 
-      attr_accessor :if_clause
-      attr_accessor :unless_clause
+      attr_accessor :if_clause, :unless_clause
+      attr_reader :field_name
 
       # Construct a validator. Capture the :if and :unless clauses when present.
       #
@@ -28,8 +29,8 @@ module DataMapper
       # that is sub-classing this GenericValidator
       #
       def initialize(field, opts = {})
-        @if_clause = opts.has_key?(:if) ? opts[:if] : nil
-        @unless_clause = opts.has_key?(:unless) ? opts[:unless] : nil
+        @if_clause     = opts.delete(:if)
+        @unless_clause = opts.delete(:unless)
       end
 
       # Add an error message to a target resource. If the error corresponds to a
@@ -43,7 +44,7 @@ module DataMapper
       # TODO - should the field_name for a general message be :default???
       #
       def add_error(target, message, field_name = :general)
-        target.errors.add(field_name,message)
+        target.errors.add(field_name, message)
       end
 
       # Call the validator. "call" is used so the operation is BoundMethod and
@@ -53,11 +54,7 @@ module DataMapper
       #                         against
       # @return <Boolean> true if valid, otherwise false
       def call(target)
-        raise "DataMapper::Validate::GenericValidator::call must be overriden in #{self.class.to_s}"
-      end
-
-      def field_name
-        @field_name
+        raise NotImplementedError, "DataMapper::Validate::GenericValidator::call must be overriden in a subclass"
       end
 
       # Determines if this validator should be run against the

data/lib/dm-validations/length_validator.rb

@@ -24,14 +24,14 @@ module DataMapper
       end
 
       def call(target)
-        field_value = target.validation_property_value(@field_name)
+        field_value = target.validation_property_value(field_name)
         return true if @options[:allow_nil] && field_value.nil?
 
         field_value = '' if field_value.nil?
 
         # XXX: HACK seems hacky to do this on every validation, probably should
         #      do this elsewhere?
-        field = Extlib::Inflection.humanize(@field_name)
+        field = Extlib::Inflection.humanize(field_name)
         min = @range ? @range.min : @min
         max = @range ? @range.max : @max
         equal = @equal
@@ -39,25 +39,25 @@ module DataMapper
         case @validation_method
         when :range then
           unless valid = @range.include?(field_value.size)
-            error_message = '%s must be between %s and %s characters long'.t(field, min, max)
+            error_message = ValidationErrors.default_error_message(:length_between, field, min, max)
           end
         when :min then
           unless valid = field_value.size >= min
-            error_message = '%s must be more than %s characters long'.t(field, min)
+            error_message = ValidationErrors.default_error_message(:too_short, field, min)
           end
         when :max then
           unless valid = field_value.size <= max
-            error_message = '%s must be less than %s characters long'.t(field, max)
+            error_message = ValidationErrors.default_error_message(:too_long, field, max)
           end
         when :equals then
           unless valid = field_value.size == equal
-            error_message = '%s must be %s characters long'.t(field, equal)
+            error_message = ValidationErrors.default_error_message(:wrong_length, field, equal)
           end
         end
 
         error_message = @options[:message] || error_message
 
-        add_error(target, error_message, @field_name) unless valid
+        add_error(target, error_message, field_name) unless valid
 
         return valid
       end

data/lib/dm-validations/method_validator.rb

@@ -14,8 +14,8 @@ module DataMapper
       end
 
       def call(target)
-        result,message = target.send(@options[:method])
-        add_error(target,message,@field_name) if !result
+        result, message = target.send(@options[:method])
+        add_error(target, message, field_name) unless result
         result
       end
 

data/lib/dm-validations/numeric_validator.rb

@@ -25,7 +25,7 @@ module DataMapper
 
         if @options[:integer_only]
           return true if value =~ /\A[+-]?\d+\z/
-          error_message ||= '%s must be an integer'.t(Extlib::Inflection.humanize(@field_name))
+          error_message ||= ValidationErrors.default_error_message(:not_an_integer, field_name)
         else
           # FIXME: if precision and scale are not specified, can we assume that it is an integer?
           #        probably not, as floating point numbers don't have hard
@@ -51,17 +51,17 @@ module DataMapper
             # for floats, if scale is not set
 
             #total number of digits is less or equal precision
-            return true if value.gsub(/[^\d]/,'').length <= precision
+            return true if value.gsub(/[^\d]/, '').length <= precision
 
             #number of digits before decimal == precision, and the number is x.0. same as scale = 0
             return true if value =~ /\A[+-]?(?:\d{1,#{precision}}(?:\.0)?)\z/
           else
             return true if value =~ /\A[+-]?(?:\d+|\d*\.\d+)\z/
           end
-          error_message ||= '%s must be a number'.t(Extlib::Inflection.humanize(@field_name))
+          error_message ||= ValidationErrors.default_error_message(:not_a_number, field_name)
         end
 
-        add_error(target, error_message, @field_name)
+        add_error(target, error_message, field_name)
 
         # TODO: check the gt, gte, lt, lte, and eq options
 

data/lib/dm-validations/primitive_validator.rb

@@ -13,12 +13,12 @@ module DataMapper
       end
 
       def call(target)
-        value = target.validation_property_value(@field_name)
-        property = target.validation_property(@field_name)
+        value = target.validation_property_value(field_name)
+        property = target.validation_property(field_name)
         return true if value.nil? || value.kind_of?(property.primitive) || property.primitive == TrueClass && value.kind_of?(FalseClass)
 
         error_message = @options[:message] || default_error(property)
-        add_error(target, error_message, @field_name)
+        add_error(target, error_message, field_name)
 
         false
       end
@@ -26,7 +26,7 @@ module DataMapper
       protected
 
       def default_error(property)
-        "%s must be of type %s".t(Extlib::Inflection.humanize(@field_name), property.primitive)
+        ValidationErrors.default_error_message(:primitive, field_name, property.primitive)
       end
 
     end # class PrimitiveValidator

data/lib/dm-validations/required_field_validator.rb

@@ -13,12 +13,12 @@ module DataMapper
       end
 
       def call(target)
-        value = target.validation_property_value(@field_name)
-        property = target.validation_property(@field_name)
+        value = target.validation_property_value(field_name)
+        property = target.validation_property(field_name)
         return true if present?(value, property)
 
         error_message = @options[:message] || default_error(property)
-        add_error(target, error_message, @field_name)
+        add_error(target, error_message, field_name)
 
         false
       end
@@ -33,8 +33,8 @@ module DataMapper
       end
 
       def default_error(property)
-        actual = boolean_type?(property) ? "nil".t : "blank".t
-        "%s must not be %s".t(Extlib::Inflection.humanize(@field_name), actual)
+        actual = boolean_type?(property) ? :nil : :blank
+        ValidationErrors.default_error_message(actual, field_name)
       end
 
       # Is +property+ a boolean property?