dm-validations 1.1.0 → 1.2.0.rc1

data/lib/dm-validations/auto_validate.rb

@@ -1,38 +1,53 @@
 module DataMapper
-  class Property
-    # for options_with_message
-    accept_options :message, :messages, :set, :validates, :auto_validation, :format
-  end
+  # for options_with_message
+  Property.accept_options :message, :messages, :set, :validates, :auto_validation, :format
 
   module Validations
     module AutoValidations
-      @disable_auto_validations = false
 
-      # adds message for validator
-      def options_with_message(base_options, property, validator_name)
-        options = base_options.clone
-        opts    = property.options
-
-        if opts.key?(:messages)
-          options[:message] = opts[:messages][validator_name]
-        elsif opts.key?(:message)
-          options[:message] = opts[:message]
+      module ModelExtension
+        # @api private
+        def property(*)
+          property = super
+          AutoValidations.generate_for_property(property)
+          # FIXME: explicit return needed for YARD to parse this properly
+          return property
         end
 
-        options
-      end
+        Model.append_extensions self
+      end # module ModelExtension
+
 
+      # TODO: why are there 3 entry points to this ivar?
+      # #disable_auto_validations, #disabled_auto_validations?, #auto_validations_disabled?
       attr_reader :disable_auto_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
+      #
+      # @api semipublic
+      def disabled_auto_validations?
+        @disable_auto_validations || false
+      end
+
+      # TODO: deprecate all but one of these 3 variants
+      alias_method :auto_validations_disabled?, :disabled_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
+      #
+      # @api public
+      def without_auto_validations
+        previous, @disable_auto_validations = @disable_auto_validations, true
+        yield
+      ensure
+        @disable_auto_validations = previous
       end
 
-      ##
       # Auto-generate validations for a given property. This will only occur
       # if the option :auto_validation is either true or left undefined.
       #
@@ -46,8 +61,9 @@ module DataMapper
       #   :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
+      #       value is a Integer the validation will set :maximum => value
+      #       if the value is a Range the validation will set
+      #       :within => value
       #
       #   :format => :predefined / lambda / Proc
       #       Setting the :format option causes a validates_format_of
@@ -81,8 +97,10 @@ module DataMapper
       #   :message => "Some message"
       #       It is just shortcut if only one validation option is set
       #
-      def auto_generate_validations(property)
-        return if disabled_auto_validations? || skip_auto_validation_for?(property)
+      # @api private
+      def self.generate_for_property(property)
+        return if (property.model.disabled_auto_validations? ||
+                   skip_auto_validation_for?(property))
 
         # all auto-validations (aside from presence) should skip
         # validation when the value is nil
@@ -98,39 +116,41 @@ module DataMapper
         infer_uniqueness_validation_for(property, opts.dup)
         infer_within_validation_for(property, opts.dup)
         infer_type_validation_for(property, opts.dup)
-      end # auto_generate_validations
+      end # generate_for_property
 
-      # 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_method :auto_validations_disabled?, :disabled_auto_validations?
+    private
 
       # 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.key?(:auto_validation) && !property.options[:auto_validation]
+      #   true for properties with :auto_validation option that has
+      #   positive value
+      #
+      # @api private
+      def self.skip_auto_validation_for?(property)
+        (property.options.key?(:auto_validation) &&
+         !property.options[:auto_validation])
       end
 
-      def infer_presence_validation_for(property, options)
+      # @api private
+      def self.infer_presence_validation_for(property, options)
         return if skip_presence_validation?(property)
 
-        validates_presence_of property.name, options_with_message(options, property, :presence)
+        validation_options = options_with_message(options, property, :presence)
+        property.model.validates_presence_of property.name, validation_options
+      end
+
+      # @api private
+      def self.skip_presence_validation?(property)
+        property.allow_blank? || property.serial?
       end
 
-      def infer_length_validation_for(property, options)
-        return unless [ DataMapper::Property::String, DataMapper::Property::Text ].any? { |klass| property.kind_of?(klass) }
+      # @api private
+      def self.infer_length_validation_for(property, options)
+        return unless (property.kind_of?(DataMapper::Property::String) ||
+                       property.kind_of?(DataMapper::Property::Text))
 
         length = property.options.fetch(:length, DataMapper::Property::String::DEFAULT_LENGTH)
 
@@ -142,39 +162,48 @@ module DataMapper
           options[:maximum] = length
         end
 
-        validates_length_of property.name, options_with_message(options, property, :length)
+        validation_options = options_with_message(options, property, :length)
+        property.model.validates_length_of property.name, validation_options
       end
 
-      def infer_format_validation_for(property, options)
+      # @api private
+      def self.infer_format_validation_for(property, options)
         return unless property.options.key?(:format)
 
         options[:with] = property.options[:format]
 
-        validates_format_of property.name, options_with_message(options, property, :format)
+        validation_options = options_with_message(options, property, :format)
+        property.model.validates_format_of property.name, validation_options
       end
 
-      def infer_uniqueness_validation_for(property, options)
+      # @api private
+      def self.infer_uniqueness_validation_for(property, options)
         return unless property.options.key?(:unique)
 
         case value = property.options[:unique]
           when Array, Symbol
             options[:scope] = Array(value)
 
-            validates_uniqueness_of property.name, options_with_message(options, property, :is_unique)
+            validation_options = options_with_message(options, property, :is_unique)
+            property.model.validates_uniqueness_of property.name, validation_options
           when TrueClass
-            validates_uniqueness_of property.name, options_with_message(options, property, :is_unique)
+            validation_options = options_with_message(options, property, :is_unique)
+            property.model.validates_uniqueness_of property.name, validation_options
         end
       end
 
-      def infer_within_validation_for(property, options)
+      # @api private
+      def self.infer_within_validation_for(property, options)
         return unless property.options.key?(:set)
 
         options[:set] = property.options[:set]
 
-        validates_within property.name, options_with_message(options, property, :within)
+        validation_options = options_with_message(options, property, :within)
+        property.model.validates_within property.name, validation_options
       end
 
-      def infer_type_validation_for(property, options)
+      # @api private
+      def self.infer_type_validation_for(property, options)
         return if property.respond_to?(:custom?) && property.custom?
 
         if property.kind_of?(Property::Numeric)
@@ -185,24 +214,38 @@ module DataMapper
         if Integer == property.primitive
           options[:integer_only] = true
 
-          validates_numericality_of property.name, options_with_message(options, property, :is_number)
-        elsif BigDecimal == property.primitive || Float == property.primitive
+          validation_options = options_with_message(options, property, :is_number)
+          property.model.validates_numericality_of property.name, validation_options
+        elsif (BigDecimal == property.primitive ||
+               Float == property.primitive)
           options[:precision] = property.precision
           options[:scale]     = property.scale
 
-          validates_numericality_of property.name, options_with_message(options, property, :is_number)
+          validation_options = options_with_message(options, property, :is_number)
+          property.model.validates_numericality_of property.name, validation_options
         else
           # We only need this in the case we don't already
           # have a numeric validator, because otherwise
           # it will cause duplicate validation errors
-          validates_primitive_type_of property.name, options_with_message(options, property, :is_primitive)
+          validation_options = options_with_message(options, property, :is_primitive)
+          property.model.validates_primitive_type_of property.name, validation_options
         end
       end
 
-      private
+      # adds message for validator
+      #
+      # @api private
+      def self.options_with_message(base_options, property, validator_name)
+        options = base_options.clone
+        opts    = property.options
 
-      def skip_presence_validation?(property)
-        property.allow_blank? || property.serial?
+        if opts.key?(:messages)
+          options[:message] = opts[:messages][validator_name]
+        elsif opts.key?(:message)
+          options[:message] = opts[:message]
+        end
+
+        options
       end
     end # module AutoValidations
   end # module Validations

data/lib/dm-validations/context.rb

@@ -0,0 +1,66 @@
+module DataMapper
+  module Validations
+    # Module with validation context functionality.
+    #
+    # Contexts are implemented using a thread-local array-based stack.
+    #
+    module Context
+      # Execute a block of code within a specific validation context
+      #
+      # @param [Symbol] context
+      #   the context to execute the block of code within
+      #
+      # @api semipublic
+      def self.in_context(context)
+        stack << context
+        yield
+      ensure
+        stack.pop
+      end
+
+      # Get the current validation context or nil (if no context is on the stack).
+      #
+      # @return [Symbol, NilClass]
+      #   The current validation context (for the current thread),
+      #   or nil if no current context is on the stack
+      def self.current
+        stack.last
+      end
+
+      # Are there any contexts on the stack?
+      #
+      # @return [Boolean]
+      #   true/false whether there are any contexts on the context stack
+      #
+      # @api semipublic
+      def self.any?(&block)
+        stack.any?(&block)
+      end
+
+      # The (thread-local) validation context stack
+      # This allows object graphs to be saved within potentially nested contexts
+      # without having to pass the validation context throughout
+      #
+      # @api private
+      def self.stack
+        Thread.current[:dm_validations_context_stack] ||= []
+      end
+
+      # The default validation context for this Resource.
+      # This Resource's default context can be overridden by implementing
+      # #default_validation_context
+      #
+      # @return [Symbol]
+      #   the current validation context from the context stack
+      #   (if valid for this model), or :default
+      #
+      # @api semipublic
+      def default_validation_context
+        model.validators.current_context || :default
+      end
+
+    end # module Context
+
+    include Context
+  end # module Validations
+end # module DataMapper

data/lib/dm-validations/contextual_validators.rb

@@ -2,8 +2,6 @@ require 'forwardable'
 
 module DataMapper
   module Validations
-
-    ##
     #
     # @author Guy van den Berg
     # @since  0.9
@@ -15,12 +13,15 @@ module DataMapper
       #
 
       def_delegators :@contexts, :empty?, :each
+      def_delegators :@attributes, :[]
       include Enumerable
 
-      attr_reader :contexts
+      attr_reader :contexts, :attributes
 
-      def initialize
-        @contexts = {}
+      def initialize(model = nil)
+        @model      = model
+        @contexts   = {}
+        @attributes = {}
       end
 
       #
@@ -30,78 +31,188 @@ module DataMapper
       # Return an array of validators for a named context
       #
       # @param  [String]
-      #   Context name for which return validators
+      #   Context name for which to return validators
       # @return [Array<DataMapper::Validations::GenericValidator>]
-      #   An array of validators
+      #   An array of validators bound to the given context
       def context(name)
-        contexts[name] ||= []
+        contexts[name] ||= OrderedSet.new
+      end
+
+      # Return an array of validators for a named property
+      #
+      # @param [Symbol]
+      #   Property name for which to return validators
+      # @return [Array<DataMapper::Validations::GenericValidator>]
+      #   An array of validators bound to the given property
+      def attribute(name)
+        attributes[name] ||= OrderedSet.new
       end
 
       # Clear all named context validators off of the resource
       #
       def clear!
         contexts.clear
+        attributes.clear
       end
 
-      # Execute all validators in the named context against the target.  Load
-      # together any properties that are designated lazy but are not yet loaded.
-      # Optionally only validate dirty properties.
+      # Create a new validator of the given klazz and push it onto the
+      # requested context for each of the attributes in +attributes+
+      #
+      # @param [DataMapper::Validations::GenericValidator] validator_class
+      #    Validator class, example: DataMapper::Validations::LengthValidator
+      #
+      # @param [Array<Symbol>] attributes
+      #    Attribute names given to validation macro, example:
+      #    [:first_name, :last_name] in validates_presence_of :first_name, :last_name
+      #
+      # @param [Hash] options
+      #    Options supplied to validation macro, example:
+      #    {:context=>:default, :maximum=>50, :allow_nil=>true, :message=>nil}
+      #
+      # @option [Symbol] :context
+      #   the context in which the new validator should be run
+      # @option [Boolean] :allow_nil
+      #   whether or not the new validator should allow nil values
+      # @option [Boolean] :message
+      #   the error message the new validator will provide on validation failure
+      def add(validator_class, *attributes)
+        options = attributes.last.kind_of?(Hash) ? attributes.pop.dup : {}
+        normalize_options(options)
+        validator_options = DataMapper::Ext::Hash.except(options, :context)
+
+        attributes.each do |attribute|
+          # TODO: is :context part of the Validator state (ie, intrinsic),
+          # or is it just membership in a collection?
+          validator = validator_class.new(attribute, validator_options)
+          attribute_validators = self.attribute(attribute)
+          attribute_validators << validator unless attribute_validators.include?(validator)
+
+          options[:context].each do |context|
+            context_validators = self.context(context)
+            next if context_validators.include?(validator)
+            context_validators << validator
+            # TODO: eliminate this, then eliminate the @model ivar entirely
+            Validations::ClassMethods.create_context_instance_methods(@model, context) if @model
+          end
+        end
+      end
+
+      # Clean up the argument list and return a opts hash, including the
+      # merging of any default opts. Set the context to default if none is
+      # provided. Also allow :context to be aliased to :on, :when & :group
+      #
+      # @param [Hash] options
+      #   the options to be normalized
+      # @param [NilClass, Hash] defaults
+      #   default keys/values to set on normalized options
+      #
+      # @return [Hash]
+      #   the normalized options
+      #
+      # @api private
+      def normalize_options(options, defaults = nil)
+        context = [
+          options.delete(:group),
+          options.delete(:on),
+          options.delete(:when),
+          options.delete(:context)
+        ].compact.first
+
+        options[:context] = Array(context || :default)
+        options.update(defaults) unless defaults.nil?
+        options
+      end
+
+      # Returns the current validation context on the stack if valid for this model,
+      # nil if no contexts are defined for the model (and no contexts are on
+      # the validation stack), or :default if the current context is invalid for
+      # this model or no contexts have been defined for this model and
+      # no context is on the stack.
+      #
+      # @return [Symbol]
+      #   the current validation context from the stack (if valid for this model),
+      #   nil if no context is on the stack and no contexts are defined for this model,
+      #   or :default if the context on the stack is invalid for this model or
+      #   no context is on the stack and this model has at least one validation context
+      #
+      # @api private
+      #
+      # TODO: simplify the semantics of #current_context, #valid?
+      def current_context
+        context = Validations::Context.current
+        valid_context?(context) ? context : :default
+      end
+
+      # Test if the context is valid for the model
+      #
+      # @param [Symbol] context
+      #   the context to test
       #
-      # @param [Symbol]
-      #   named_context the context we are validating against
-      # @param [Object]
-      #   target        the resource that we are validating
+      # @return [Boolean]
+      #   true if the context is valid for the model
+      #
+      # @api private
+      #
+      # TODO: investigate removing the `contexts.empty?` test here.
+      def valid_context?(context)
+        contexts.empty? || contexts.include?(context)
+      end
+
+      # Assert that the given 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
+      #
+      # TODO: is this method actually needed?
+      def assert_valid(context)
+        unless valid_context?(context)
+          raise InvalidContextError, "#{context} is an invalid context, known contexts are #{contexts.keys.inspect}"
+        end
+      end
+
+      # Execute all validators in the named context against the target.
+      # Load together any properties that are designated lazy but are not
+      # yet loaded.
+      #
+      # @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)
         target.errors.clear!
 
-        runnable_validators = context(named_context).select{ |validator| validator.execute?(target) }
-        validators = runnable_validators.dup
+        available_validators  = context(named_context)
+        executable_validators = available_validators.select { |v| v.execute?(target) }
 
-        # By default we start the list with the full set of runnable validators.
-        #
         # In the case of a new Resource or regular ruby class instance,
         # everything needs to be validated completely, and no eager-loading
         # logic should apply.
         #
-        # In the case of a DM::Resource that isn't new, we optimize:
-        #
-        #   1. Eager-load all lazy, not-yet-loaded properties that need
-        #      validation, all at once.
-        #
-        #   2. Limit run validators to
-        #      - those applied to dirty attributes only,
-        #      - those that should always run (presence/absence)
-        #      - those that don't reference any real properties (field-less
-        #        block validators, validations in virtual attributes)
         if target.kind_of?(DataMapper::Resource) && !target.new?
-          attrs       = target.attributes.keys
-          dirty_attrs = target.dirty_attributes.keys.map{ |p| p.name }
-          validators  = runnable_validators.select{|v|
-            !attrs.include?(v.field_name) || dirty_attrs.include?(v.field_name)
-          }
-
-          # Load all lazy, not-yet-loaded properties that need validation,
-          # all at once.
-          fields_to_load = validators.map{|v|
-            target.class.properties[v.field_name]
-          }.compact.select {|p|
-            p.lazy? && !p.loaded?(target)
-          }
-
-          target.__send__(:eager_load, fields_to_load)
-
-          # Finally include any validators that should always run or don't
-          # reference any real properties (field-less block vaildators).
-          validators |= runnable_validators.select do |v|
-            [ MethodValidator, PresenceValidator, AbsenceValidator ].any? do |klass|
-              v.kind_of?(klass)
-            end
-          end
+          load_validated_properties(target, executable_validators)
         end
+        executable_validators.map { |validator| validator.call(target) }.all?
+      end
+
+      # Load all lazy, not-yet-loaded properties that need validation,
+      # all at once.
+      def load_validated_properties(resource, validators)
+        properties = resource.model.properties
+
+        properties_to_load = validators.map { |validator|
+          properties[validator.field_name]
+        }.compact.select { |property|
+          property.lazy? && !property.loaded?(resource)
+        }
 
-        validators.map { |validator| validator.call(target) }.all?
+        resource.__send__(:eager_load, properties_to_load)
       end
 
     end # module ContextualValidators