dm-validations 0.9.11 → 0.10.0

data/lib/dm-validations/auto_validate.rb

@@ -1,29 +1,36 @@
 module DataMapper
   class Property
     # for options_with_message
-    PROPERTY_OPTIONS << :message << :messages << :set
+    OPTIONS << :message << :messages << :set
   end
 
   module Validate
     module AutoValidate
+      @disable_auto_validations = false
+
       # adds message for validator
       def options_with_message(base_options, property, validator_name)
         options = base_options.clone
-        opts = property.options
-        options[:message] = if opts[:messages]
-          if opts[:messages].is_a?(Hash) and msg = opts[:messages][validator_name]
-            msg
-          else
-            nil
-          end
-        elsif opts[:message]
-          opts[:message]
-        else
-          nil
+        opts    = property.options
+
+        if opts.key?(:messages)
+          options[:message] = opts[:messages][validator_name]
+        elsif opts.key?(:message)
+          options[:message] = opts[:message]
         end
+
         options
       end
 
+      attr_reader :disable_auto_validations
+
+      # disables generation of validations for
+      # duration of given block
+      def without_auto_validations(&block)
+        @disable_auto_validations = true
+        block.call
+        @disable_auto_validations = false
+      end
 
       ##
       # Auto-generate validations for a given property. This will only occur
@@ -37,8 +44,8 @@ module DataMapper
       #       validates_presence_of validator to be automatically created on
       #       the property
       #
-      #   :size => 20 or :length => 20
-      #       Setting the option :size or :length causes a validates_length_of
+      #   :length => 20
+      #       Setting the option :length causes a validates_length_of
       #       validator to be automatically created on the property. If the
       #       value is a Integer the validation will set :maximum => value if
       #       the value is a Range the validation will set :within => value
@@ -76,78 +83,113 @@ module DataMapper
       #       It is just shortcut if only one validation option is set
       #
       def auto_generate_validations(property)
-        property.options[:auto_validation] = true unless property.options.has_key?(:auto_validation)
-        return unless property.options[:auto_validation]
+        return if disabled_auto_validations? || skip_auto_validation_for?(property)
+
+        # all auto-validations (aside from presence) should skip
+        # validation when the value is nil
+        opts = { :allow_nil => true }
 
-        # a serial property is allowed to be nil too, because the
-        # value is set by the storage system
-        opts = { :allow_nil => property.nullable? || property.serial? }
-        opts[:context] = property.options[:validates] if property.options.has_key?(:validates)
+        if property.options.has_key?(:validates)
+          opts[:context] = property.options[:validates]
+        end
+
+        infer_presence_validation_for(property, opts.dup)
+        infer_length_validation_for(property, opts.dup)
+        infer_format_validation_for(property, opts.dup)
+        infer_uniqueness_validation_for(property, opts.dup)
+        infer_within_validation_for(property, opts.dup)
+        infer_numeric_validation_for(property, opts.dup)
+      end # auto_generate_validations
+
+      # Checks whether auto validations are currently
+      # disabled (see +disable_auto_validations+ method
+      # that takes a block)
+      #
+      # @return [TrueClass, FalseClass]
+      #   true if auto validation is currently disabled
+      #
+      def disabled_auto_validations?
+        @disable_auto_validations || false
+      end
+      alias auto_validations_disabled? disabled_auto_validations?
 
-        # presence
-        unless opts[:allow_nil]
+
+      # Checks whether or not property should be auto validated.
+      # It is the case for properties with :auto_validation option
+      # given and it's value evaluates to true
+      #
+      # @return [TrueClass, FalseClass]
+      #   true for properties with :auto_validation option that has positive value
+      def skip_auto_validation_for?(property)
+        property.options.has_key?(:auto_validation) && !property.options[:auto_validation]
+      end
+
+      def infer_presence_validation_for(property, options)
+        unless allow_nil?(property)
           # validates_present property.name, opts
-          validates_present property.name, options_with_message(opts, property, :presence)
+          validates_present property.name, options_with_message(options, property, :presence)
         end
+      end
 
-        # length
-        if property.type == String
-          #len = property.length  # XXX: maybe length should always return a Range, with the min defaulting to 1
-          len = property.options.fetch(:length, property.options.fetch(:size, DataMapper::Property::DEFAULT_LENGTH))
-          if len.is_a?(Range)
-            opts[:within] = len
-          else
-            opts[:maximum] = len
+      def infer_length_validation_for(property, options)
+        if [ String, DataMapper::Types::Text ].include?(property.type)
+          case length = property.options.fetch(:length, DataMapper::Property::DEFAULT_LENGTH)
+            when Range then options[:within]  = length
+            else            options[:maximum] = length
           end
-          # validates_length property.name, opts
-          validates_length property.name, options_with_message(opts, property, :length)
+
+          validates_length property.name, options_with_message(options, property, :length)
         end
+      end
 
-        # format
+      def infer_format_validation_for(property, options)
         if property.options.has_key?(:format)
-          opts[:with] = property.options[:format]
-          # validates_format property.name, opts
-          validates_format property.name, options_with_message(opts, property, :format)
+          options[:with] = property.options[:format]
+          validates_format property.name, options_with_message(options, property, :format)
         end
+      end
 
-        # uniqueness validator
+      def infer_uniqueness_validation_for(property, options)
         if property.options.has_key?(:unique)
           value = property.options[:unique]
           if value.is_a?(Array) || value.is_a?(Symbol)
-            # validates_is_unique property.name, :scope => Array(value)
             validates_is_unique property.name, options_with_message({:scope => Array(value)}, property, :is_unique)
           elsif value.is_a?(TrueClass)
-            # validates_is_unique property.name
             validates_is_unique property.name, options_with_message({}, property, :is_unique)
           end
         end
+      end
 
-        # within validator
-        if property.options.has_key?(:set)
-          validates_within property.name, options_with_message({:set => property.options[:set]}, property, :within)
-        end
+      def infer_within_validation_for(property, options)
+        validates_within property.name, options_with_message({:set => property.options[:set]}, property, :within) if property.options.has_key?(:set)
+      end
+
+      def infer_numeric_validation_for(property, options)
+        options[:gte] = property.min if property.min
+        options[:lte] = property.max if property.max
 
-        # numeric validator
         if Integer == property.type
-          opts[:integer_only] = true
-          # validates_is_number property.name, opts
-          validates_is_number property.name, options_with_message(opts, property, :is_number)
+          options[:integer_only] = true
+
+          validates_is_number property.name, options_with_message(options, property, :is_number)
         elsif BigDecimal == property.type || Float == property.type
-          opts[:precision] = property.precision
-          opts[:scale]     = property.scale
-          # validates_is_number property.name, opts
-          validates_is_number property.name, options_with_message(opts, property, :is_number)
+          options[:precision] = property.precision
+          options[:scale]     = property.scale
+
+          validates_is_number property.name, options_with_message(options, property, :is_number)
         else
           # We only need this in the case we don't already
           # have a numeric validator, because otherwise
           # it will cause duplicate validation errors
-          unless property.custom?
-            # validates_is_primitive property.name, opts
-            validates_is_primitive property.name, options_with_message(opts, property, :is_primitive)
-          end
+          validates_is_primitive property.name, options_with_message(options, property, :is_primitive) unless property.custom?
         end
       end
 
+      private
+
+      def allow_nil?(property)
+        property.nullable? || property.serial?
+      end
     end # module AutoValidate
   end # module Validate
 end # module DataMapper

data/lib/dm-validations/contextual_validators.rb

@@ -1,3 +1,5 @@
+require "forwardable"
+
 module DataMapper
   module Validate
 
@@ -6,23 +8,38 @@ module DataMapper
     # @author Guy van den Berg
     # @since  0.9
     class ContextualValidators
+      extend Forwardable
+
+      #
+      # Delegators
+      #
+
+      def_delegators :@contexts, :empty?, :each
+      include Enumerable
+
+      attr_reader :contexts
+
+      def initialize
+        @contexts = {}
+      end
+
+      #
+      # API
+      #
 
       def dump
         contexts.each_pair do |key, context|
           puts "Key=#{key} Context: #{context}"
         end
       end
-
-      # Get a hash of named context validators for the resource
-      #
-      # @return <Hash> a hash of validators <GenericValidator>
-      def contexts
-        @contexts ||= {}
-      end
+      alias_method :inspect, :dump
 
       # Return an array of validators for a named context
       #
-      # @return <Array> An array of validators
+      # @param  [String]
+      #   Context name for which return validators
+      # @return [Array<DataMapper::Validate::GenericValidator>]
+      #   An array of validators
       def context(name)
         contexts[name] ||= []
       end
@@ -35,18 +52,24 @@ module DataMapper
 
       # Execute all validators in the named context against the target
       #
-      # @param <Symbol> named_context the context we are validating against
-      # @param <Object> target        the resource that we are validating
-      # @return <Boolean> true if all are valid, otherwise false
+      # @param [Symbol]
+      #   named_context the context we are validating against
+      # @param [Object]
+      #   target        the resource that we are validating
+      # @return [Boolean]
+      #   true if all are valid, otherwise false
       def execute(named_context, target)
-        raise(ArgumentError, 'invalid context specified') if !named_context || (contexts.length > 0 && !contexts[named_context])
+        raise(ArgumentError, "validation context #{named_context} doesn't seem to be defined. Known contexts are #{contexts.keys.inspect}") if !named_context || (contexts.length > 0 && !contexts[named_context])
         target.errors.clear!
         result = true
-        context(named_context).each do |validator|
-          next unless validator.execute?(target)
+        # note that all? and any? stop iteration on first negative or positive result,
+        # so we really have to use each here to make sure all validators are
+        # executed
+        context(named_context).select { |validator| validator.execute?(target) }.each do |validator|
           result = false unless validator.call(target)
         end
 
+
         result
       end
 

data/lib/dm-validations/exceptions.rb

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

data/lib/dm-validations/formats/url.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module DataMapper
   module Validate
     module Format
@@ -11,7 +13,7 @@ module DataMapper
 
         Url = begin
           # Regex from http://www.igvita.com/2006/09/07/validating-url-in-ruby-on-rails/
-          /(^$)|(^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$)/ix
+          /(^$)|(^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}((\:[0-9]{1,5})?\/?.*)?$)/ix
         end
 
       end # module Url

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

@@ -0,0 +1,54 @@
+module DataMapper
+  module Validate
+
+    # Module with validation context functionality.
+    #
+    # Contexts are implemented using a simple array based
+    # stack that is thread local. The default context can be
+    # altered by overwriting default_validation_context or
+    # will default to :default
+    #
+    module Context
+
+      # TODO: document
+      # @api private
+      def default_validation_context
+        current_validation_context || :default
+      end
+
+      protected
+
+      # Pushes given context on top of context stack and yields
+      # given block, then pops the stack. During block execution
+      # contexts previously pushed onto the stack have no effect.
+      #
+      # @api private
+      def validation_context(context = default_validation_context)
+        validation_context_stack << context
+        begin
+          yield
+        ensure
+          validation_context_stack.pop
+        end
+      end
+
+      private
+
+      # Initializes (if necessary) and returns current scope stack
+      # @api private
+      def validation_context_stack
+        Thread.current[:dm_validations_context_stack] ||= []
+      end
+
+      # Returns the current validation context or nil if none has been pushed
+      # @api private
+      def current_validation_context
+        validation_context_stack.last
+      end
+
+    end
+
+    include Context
+
+  end
+end

data/lib/dm-validations/validation_errors.rb

@@ -1,3 +1,5 @@
+require 'extlib/dictionary'
+
 module DataMapper
   module Validate
 
@@ -10,27 +12,28 @@ module DataMapper
       include Enumerable
 
       @@default_error_messages = {
-        :absent => '%s must be absent',
-        :inclusion => '%s must be one of [%s]',
-        :invalid => '%s has an invalid format',
-        :confirmation => '%s does not match the confirmation',
-        :accepted  => "%s is not accepted",
-        :nil => '%s must not be nil',
-        :blank => '%s must not be blank',
-        :length_between => '%s must be between %s and %s characters long',
-        :too_long => '%s must be less than %s characters long',
-        :too_short => '%s must be more than %s characters long',
-        :wrong_length => '%s must be %s characters long',
-        :taken => '%s is already taken',
-        :not_a_number => '%s must be a number',
-        :not_an_integer => '%s must be an integer',
-        :greater_than => '%s must be greater than %s',
-        :greater_than_or_equal_to => "%s must be greater than or equal to %s",
-        :equal_to => "%s must be equal to %s",
-        :less_than => '%s must be less than %s',
-        :less_than_or_equal_to => "%s must be less than or equal to %s",
-        :value_between => '%s must be between %s and %s',
-        :primitive => '%s must be of type %s'
+        :absent                   => '%s must be absent',
+        :inclusion                => '%s must be one of %s',
+        :invalid                  => '%s has an invalid format',
+        :confirmation             => '%s does not match the confirmation',
+        :accepted                 => '%s is not accepted',
+        :nil                      => '%s must not be nil',
+        :blank                    => '%s must not be blank',
+        :length_between           => '%s must be between %s and %s characters long',
+        :too_long                 => '%s must be at most %s characters long',
+        :too_short                => '%s must be at least %s characters long',
+        :wrong_length             => '%s must be %s characters long',
+        :taken                    => '%s is already taken',
+        :not_a_number             => '%s must be a number',
+        :not_an_integer           => '%s must be an integer',
+        :greater_than             => '%s must be greater than %s',
+        :greater_than_or_equal_to => '%s must be greater than or equal to %s',
+        :equal_to                 => '%s must be equal to %s',
+        :not_equal_to             => '%s must not be equal to %s',
+        :less_than                => '%s must be less than %s',
+        :less_than_or_equal_to    => '%s must be less than or equal to %s',
+        :value_between            => '%s must be between %s and %s',
+        :primitive                => '%s must be of type %s'
       }
 
       # Holds a hash with all the default error messages that can be replaced by your own copy or localizations.
@@ -41,6 +44,13 @@ module DataMapper
         @@default_error_messages[key] % [field, *values].flatten
       end
 
+      attr_reader :resource
+
+      def initialize(resource)
+        @resource = resource
+        @errors   = Dictionary.new
+      end
+
       # Clear existing validation errors.
       def clear!
         errors.clear
@@ -49,9 +59,21 @@ module DataMapper
       # Add a validation error. Use the field_name :general if the errors does
       # not apply to a specific field of the Resource.
       #
-      # @param <Symbol> field_name the name of the field that caused the error
-      # @param <String> message    the message to add
+      # @param [Symbol] field_name the name of the field that caused the error
+      # @param [String] message    the message to add
       def add(field_name, message)
+        # see 6abe8fff in extlib, but don't enforce
+        # it unless Edge version is installed
+        if message.respond_to?(:try_call)
+
+          # DM resource
+          message = if resource.respond_to?(:model) && resource.model.respond_to?(:properties)
+            message.try_call(resource, resource.model.properties[field_name])
+          else
+            # pure Ruby object
+            message.try_call(resource)
+          end
+        end
         (errors[field_name] ||= []) << message
       end
 
@@ -64,10 +86,12 @@ module DataMapper
 
       # Return validation errors for a particular field_name.
       #
-      # @param <Symbol> field_name the name of the field you want an error for
+      # @param [Symbol] field_name the name of the field you want an error for
+      # @return [Array<DataMapper::Validate::Error>]
+      #   array of validation errors or empty array, if there are no errors on given field
       def on(field_name)
         errors_for_field = errors[field_name]
-        errors_for_field.blank? ? nil : errors_for_field
+        errors_for_field.blank? ? nil : errors_for_field.uniq
       end
 
       def each
@@ -78,7 +102,7 @@ module DataMapper
       end
 
       def empty?
-        entries.empty?
+        @errors.empty?
       end
 
       def method_missing(meth, *args, &block)
@@ -87,7 +111,7 @@ module DataMapper
 
       private
       def errors
-        @errors ||= {}
+        @errors
       end
 
     end # class ValidationErrors