dm-validations 0.10.1 → 0.10.2

data/lib/dm-validations/exceptions.rb

@@ -1,3 +1,5 @@
 module DataMapper
-    class ValidationError < StandardError; end
+  class ValidationError < StandardError; end
+
+  class InvalidContextError < StandardError; end
 end

data/lib/dm-validations/support/context.rb

@@ -24,6 +24,7 @@ module DataMapper
       #
       # @api private
       def validation_context(context = default_validation_context)
+        assert_valid_context(context)
         validation_context_stack << context
         begin
           yield
@@ -43,9 +44,47 @@ module DataMapper
       # Returns the current validation context or nil if none has been pushed
       # @api private
       def current_validation_context
-        validation_context_stack.last
+        context = validation_context_stack.last
+        valid_context?(context) ? context : :default
       end
 
+      # Return the contexts for the model
+      #
+      # @return [Hash]
+      #   the hash of contexts for the model
+      #
+      # @api private
+      def contexts
+        model.validators.contexts
+      end
+
+      # Test if the context is valid for the model
+      #
+      # @param [Symbol] context
+      #   the context to test
+      #
+      # @return [Boolean]
+      #   true if the context is valid for the model
+      #
+      # @api private
+      def valid_context?(context)
+        contexts.empty? || contexts.key?(context)
+      end
+
+      # Assert that the context is valid for this model
+      #
+      # @param [Symbol] context
+      #   the context to test
+      #
+      # @raise [InvalidContextError]
+      #   raised if the context is not valid for this model
+      #
+      # @api private
+      def assert_valid_context(context)
+        unless valid_context?(context)
+          raise InvalidContextError, "#{context} is an invalid context, known contexts are #{contexts.keys.inspect}"
+        end
+      end
     end
 
     include Context

data/lib/dm-validations/validation_errors.rb

@@ -48,7 +48,7 @@ module DataMapper
 
       def initialize(resource)
         @resource = resource
-        @errors   = Dictionary.new
+        @errors   = Dictionary.new { |h,k| h[k] = [] }
       end
 
       # Clear existing validation errors.
@@ -84,17 +84,6 @@ module DataMapper
         end
       end
 
-      # Return validation errors for a particular field name or an empty array
-      #
-      # This method is a necessary requirement for active_model compatibility.
-      #
-      # @param [Symbol] field_name the name of the field you want an error for
-      # @return [Array<Array<String>>]
-      #   array of validation errors or empty array, if there are no errors on given field
-      def [](field_name)
-        errors[field_name] ||= []
-      end
-
       # Return validation errors for a particular field_name.
       #
       # @param [Symbol] field_name the name of the field you want an error for
@@ -113,7 +102,7 @@ module DataMapper
       end
 
       def empty?
-        @errors.empty?
+        @errors.all? { |property_name, errors| errors.empty? }
       end
 
       def method_missing(meth, *args, &block)

data/lib/dm-validations/validators/absent_field_validator.rb

@@ -7,12 +7,12 @@ module DataMapper
     # @since  0.9
     class AbsentFieldValidator < GenericValidator
       def call(target)
-        return true if target.send(self.field_name).blank?
+        return true if target.validation_property_value(field_name).blank?
 
         error_message = self.options[:message] || ValidationErrors.default_error_message(:absent, field_name)
         add_error(target, error_message, field_name)
 
-        return false
+        false
       end
     end # class AbsentFieldValidator
 

data/lib/dm-validations/validators/acceptance_validator.rb

@@ -10,30 +10,28 @@ module DataMapper
       def initialize(field_name, options = {})
         super
 
-        # ||= true makes value true if it used to be false
-        @options[:allow_nil] = true unless(options.include?(:allow_nil) && [false, nil, "false", "f"].include?(options[:allow_nil]))
-        @options[:accept]    ||= ["1", 1, "true", true, "t"]
+        @options[:allow_nil] = true unless @options.key?(:allow_nil)
+
+        @options[:accept] ||= [ '1', 1, 'true', true, 't' ]
         @options[:accept] = Array(@options[:accept])
       end
 
       def call(target)
-        unless valid?(target)
-          error_message = @options[:message] || ValidationErrors.default_error_message(:accepted, field_name)
-          add_error(target, error_message, field_name)
-          return false
-        end
+        return true if valid?(target)
+
+        error_message = @options[:message] || ValidationErrors.default_error_message(:accepted, field_name)
+        add_error(target, error_message, field_name)
 
-        return true
+        false
       end
 
-      def valid?(target)
-        field_value = target.validation_property_value(field_name)
-        # Allow empty values
-        return true if @options[:allow_nil] && field_value.blank?
+      private
 
-        @options[:accept].include?(field_value)
+      def valid?(target)
+        value = target.validation_property_value(field_name)
+        return true if allow_nil?(value)
+        @options[:accept].include?(value)
       end
-
     end # class AcceptanceValidator
 
     module ValidatesIsAccepted
@@ -41,7 +39,7 @@ module DataMapper
       ##
       # Validates that the attributes's value is in the set of accepted values.
       #
-      # @option :allow_nil<Boolean> true if nil is allowed, false if nil is not
+      # @option :allow_nil<Boolean> true if nil is allowed, false if not
       #                             allowed. Default is true.
       # @option :accept<Array>      a list of accepted values.
       #                             Default are ["1", 1, "true", true, "t"]).

data/lib/dm-validations/validators/confirmation_validator.rb

@@ -10,33 +10,34 @@ module DataMapper
 
       def initialize(field_name, options = {})
         super
+
+        set_optional_by_default
+
         @confirm_field_name  = (options[:confirm] || "#{field_name}_confirmation").to_sym
-        @options[:allow_nil] = true unless @options.has_key?(:allow_nil)
       end
 
       def call(target)
-        unless valid?(target)
-          error_message = @options[:message] || ValidationErrors.default_error_message(:confirmation, field_name)
-          add_error(target, error_message, field_name)
-          return false
-        end
+        return true if valid?(target)
 
-        return true
+        error_message = @options[:message] || ValidationErrors.default_error_message(:confirmation, field_name)
+        add_error(target, error_message, field_name)
+
+        false
       end
 
+      private
+
       def valid?(target)
-        field_value = target.send(field_name)
-        return true if @options[:allow_nil] && field_value.blank?
-        return false if !@options[:allow_nil] && field_value.blank?
+        value = target.validation_property_value(field_name)
+        return true if optional?(value)
 
         if target.model.properties.named?(field_name)
           return true unless target.attribute_dirty?(field_name)
         end
 
         confirm_value = target.instance_variable_get("@#{@confirm_field_name}")
-        field_value == confirm_value
+        value == confirm_value
       end
-
     end # class ConfirmationValidator
 
     module ValidatesIsConfirmed
@@ -47,9 +48,10 @@ module DataMapper
       # password, for which you use both password and password_confirmation
       # attributes.
       #
-      # @option :allow_nil<Boolean> true/false (default is true)
-      # @option :confirm<Symbol>    the attribute that you want to validate
-      #                             against (default is firstattr_confirmation)
+      # @option :allow_nil<Boolean>   true/false (default is true)
+      # @option :allow_blank<Boolean> true/false (default is true)
+      # @option :confirm<Symbol>      the attribute that you want to validate
+      #                               against (default is firstattr_confirmation)
       #
       # @example [Usage]
       #   require 'dm-validations'

data/lib/dm-validations/validators/format_validator.rb

@@ -20,31 +20,37 @@ module DataMapper
       def initialize(field_name, options = {})
         super
 
-        @options[:allow_nil] = true unless @options.include?(:allow_nil)
+        set_optional_by_default
       end
 
       def call(target)
+        return true if valid?(target)
+
+        value = target.validation_property_value(field_name)
+
+        error_message = @options[:message] || ValidationErrors.default_error_message(:invalid, field_name)
+        add_error(target, error_message.try_call(humanized_field_name, value), field_name)
+
+        false
+      end
+
+      private
+
+      def valid?(target)
         value = target.validation_property_value(field_name)
-        return true if @options[:allow_nil] && value.blank?
+        return true if optional?(value)
 
         validation = @options[:as] || @options[:with]
 
         raise "No such predefined format '#{validation}'" if validation.is_a?(Symbol) && !FORMATS.has_key?(validation)
         validator = validation.is_a?(Symbol) ? FORMATS[validation][0] : validation
 
-        valid = case validator
+        case validator
           when Proc   then validator.call(value)
-          when Regexp then (value.is_a?(Fixnum) ? value.to_s : value) =~ validator
+          when Regexp then (value.kind_of?(Numeric) ? value.to_s : value) =~ validator
           else
             raise UnknownValidationFormat, "Can't determine how to validate #{target.class}##{field_name} with #{validator.inspect}"
         end
-
-        return true if valid
-
-        error_message = @options[:message] || ValidationErrors.default_error_message(:invalid, field_name)
-        add_error(target, error_message.try_call(humanized_field_name, value), field_name)
-
-        false
       end
     end # class FormatValidator
 
@@ -58,6 +64,7 @@ module DataMapper
       # via a Proc or Regexp passed to the the :as or :with options.
       #
       # @option :allow_nil<Boolean>         true/false (default is true)
+      # @option :allow_blank<Boolean>       true/false (default is true)
       # @option :as<Format, Proc, Regexp>   the pre-defined format, Proc or Regexp to validate against
       # @option :with<Format, Proc, Regexp> an alias for :as
       #

data/lib/dm-validations/validators/generic_validator.rb

@@ -29,10 +29,10 @@ module DataMapper
       # that is sub-classing this GenericValidator
       #
       def initialize(field_name, options = {})
-        @if_clause     = options.delete(:if)
-        @unless_clause = options.delete(:unless)
-
-        @field_name, @options = field_name, options
+        @field_name           = field_name
+        @options              = options.except(:if, :unless)
+        @if_clause            = options[:if]
+        @unless_clause        = options[:unless]
         @humanized_field_name = Extlib::Inflection.humanize(@field_name)
       end
 
@@ -57,7 +57,7 @@ module DataMapper
       #                         against
       # @return <Boolean> true if valid, otherwise false
       def call(target)
-        raise NotImplementedError, "DataMapper::Validate::GenericValidator::call must be overriden in a subclass"
+        raise NotImplementedError, "#{self.class}#call must be implemented"
       end
 
       # Determines if this validator should be run against the
@@ -68,24 +68,54 @@ module DataMapper
       # @return <Boolean> true if should be run, otherwise false
       def execute?(target)
         if unless_clause = self.unless_clause
-          if unless_clause.is_a?(Symbol)
-            return false if target.send(unless_clause)
-          elsif unless_clause.respond_to?(:call)
-            return false if unless_clause.call(target)
-          end
+          return !target.__send__(unless_clause) if unless_clause.kind_of?(Symbol)
+          return !unless_clause.call(target)     if unless_clause.respond_to?(:call)
         end
 
         if if_clause = self.if_clause
-          if if_clause.is_a?(Symbol)
-            return target.send(if_clause)
-          elsif if_clause.respond_to?(:call)
-            return if_clause.call(target)
-          end
+          return target.__send__(if_clause) if if_clause.kind_of?(Symbol)
+          return if_clause.call(target)     if if_clause.respond_to?(:call)
         end
 
         true
       end
 
+      # Set the default value for allow_nil and allow_blank
+      #
+      # @param [Boolean] default value
+      # @return <undefined>
+      def set_optional_by_default(default = true)
+        [ :allow_nil, :allow_blank ].each do |key|
+          @options[key] = true unless options.key?(key)
+        end
+      end
+
+      # Test the value to see if it is blank or nil, and if it is allowed
+      #
+      # @param <Object> value to test
+      # @return <Boolean> true if blank/nil is allowed, and the value is blank/nil
+      def optional?(value)
+        return allow_nil?(value)   if value.nil?
+        return allow_blank?(value) if value.blank?
+        false
+      end
+
+      # Test if the value is nil and is allowed
+      #
+      # @param <Object> value to test
+      # @return <Boolean> true if nil is allowed and value is nil
+      def allow_nil?(value)
+        @options[:allow_nil] if value.nil?
+      end
+
+      # Test if the value is blank and is allowed
+      #
+      # @param <Object> value to test
+      # @return <Boolean> true if blank is allowed and value is blank
+      def allow_blank?(value)
+        @options[:allow_blank] if value.blank?
+      end
+
       # Returns true if validators are equal
       #
       # Note that this intentionally do

data/lib/dm-validations/validators/length_validator.rb

@@ -43,7 +43,7 @@ module DataMapper
       # @api semipublic
       def call(target)
         value = target.validation_property_value(field_name)
-        return true if allow_nil? && value.blank?
+        return true if optional?(value)
 
         return true unless error_message = error_message_for(value)
 
@@ -54,16 +54,6 @@ module DataMapper
 
       private
 
-      # Return if the validation allows nil values
-      #
-      # @return [Boolean]
-      #   true if the validation allows nil, false if not
-      #
-      # @api private
-      def allow_nil?
-        options.fetch(:allow_nil, false)
-      end
-
       # Return the error messages for the value if it is invalid
       #
       # @param [#to_s] value
@@ -172,6 +162,7 @@ module DataMapper
       # you specify).
       #
       # @option :allow_nil<Boolean> true/false (default is true)
+      # @option :allow_blank<Boolean> true/false (default is true)
       # @option :minimum    ensures that the attribute's length is greater than
       #   or equal to the supplied value
       # @option :min        alias for :minimum

data/lib/dm-validations/validators/method_validator.rb

@@ -9,11 +9,11 @@ module DataMapper
 
       def initialize(field_name, options={})
         super
-        @options[:method] = @field_name unless @options.has_key?(:method)
+        @options[:method] = @field_name unless @options.key?(:method)
       end
 
       def call(target)
-        result, message = target.send(@options[:method])
+        result, message = target.__send__(@options[:method])
         add_error(target, message, field_name) unless result
         result
       end

data/lib/dm-validations/validators/numeric_validator.rb

@@ -8,8 +8,8 @@ module DataMapper
     class NumericValidator < GenericValidator
 
       def call(target)
-        value = target.send(field_name)
-        return true if allow_nil? && value.blank?
+        value = target.validation_property_value(field_name)
+        return true if optional?(value)
 
         errors = []
 
@@ -31,10 +31,6 @@ module DataMapper
 
       private
 
-      def allow_nil?
-        options.fetch(:allow_nil, false)
-      end
-
       def integer_only?
         options.fetch(:integer_only, false)
       end
@@ -131,6 +127,12 @@ module DataMapper
       #
       # Options are:
       #
+      # :allow_nil => true | false
+      #   true if number can be nil, false if not
+      #
+      # :allow_blank => true | false
+      #   true if number can be blank, false if not
+      #
       # :message => "Error message for %s"
       #   Custom error message, also can be a callable object that takes
       #   an object (for pure Ruby objects) or object and property (for DM resources)