ardm-validations 1.2.0

data/lib/dm-validations/auto_validate.rb

@@ -0,0 +1,252 @@
+module DataMapper
+  # for options_with_message
+  Property.accept_options :message, :messages, :set, :validates, :auto_validation, :format
+
+  module Validations
+    module AutoValidations
+
+      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
+
+        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
+      #
+      # @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.
+      #
+      #   Triggers that generate validator creation
+      #
+      #   :required => true
+      #       Setting the option :required to true causes a
+      #       validates_presence_of validator to be automatically created on
+      #       the property
+      #
+      #   :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
+      #
+      #   :format => :predefined / lambda / Proc
+      #       Setting the :format option causes a validates_format_of
+      #       validator to be automatically created on the property
+      #
+      #   :set => ["foo", "bar", "baz"]
+      #       Setting the :set option causes a validates_within
+      #       validator to be automatically created on the property
+      #
+      #   Integer type
+      #       Using a Integer type causes a validates_numericality_of
+      #       validator to be created for the property.  integer_only
+      #       is set to true
+      #
+      #   BigDecimal or Float type
+      #       Using a Integer type causes a validates_numericality_of
+      #       validator to be created for the property.  integer_only
+      #       is set to false, and precision/scale match the property
+      #
+      #
+      #   Messages
+      #
+      #   :messages => {..}
+      #       Setting :messages hash replaces standard error messages
+      #       with custom ones. For instance:
+      #       :messages => {:presence => "Field is required",
+      #                     :format => "Field has invalid format"}
+      #       Hash keys are: :presence, :format, :length, :is_unique,
+      #                      :is_number, :is_primitive
+      #
+      #   :message => "Some message"
+      #       It is just shortcut if only one validation option is set
+      #
+      # @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
+        opts = { :allow_nil => true }
+
+        if property.options.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_type_validation_for(property, opts.dup)
+      end # generate_for_property
+
+    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
+      #
+      # @api private
+      def self.skip_auto_validation_for?(property)
+        (property.options.key?(:auto_validation) &&
+         !property.options[:auto_validation])
+      end
+
+      # @api private
+      def self.infer_presence_validation_for(property, options)
+        return if skip_presence_validation?(property)
+
+        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
+
+      # @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)
+
+
+        if length.is_a?(Range)
+          raise ArgumentError, "Infinity is no valid upper bound for a length range" if length.last == Infinity
+          options[:within]  = length
+        else
+          options[:maximum] = length
+        end
+
+        validation_options = options_with_message(options, property, :length)
+        property.model.validates_length_of property.name, validation_options
+      end
+
+      # @api private
+      def self.infer_format_validation_for(property, options)
+        return unless property.options.key?(:format)
+
+        options[:with] = property.options[:format]
+
+        validation_options = options_with_message(options, property, :format)
+        property.model.validates_format_of property.name, validation_options
+      end
+
+      # @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)
+
+            validation_options = options_with_message(options, property, :is_unique)
+            property.model.validates_uniqueness_of property.name, validation_options
+          when TrueClass
+            validation_options = options_with_message(options, property, :is_unique)
+            property.model.validates_uniqueness_of property.name, validation_options
+        end
+      end
+
+      # @api private
+      def self.infer_within_validation_for(property, options)
+        return unless property.options.key?(:set)
+
+        options[:set] = property.options[:set]
+
+        validation_options = options_with_message(options, property, :within)
+        property.model.validates_within property.name, validation_options
+      end
+
+      # @api private
+      def self.infer_type_validation_for(property, options)
+        return if property.respond_to?(:custom?) && property.custom?
+
+        if property.kind_of?(Property::Numeric)
+          options[:gte] = property.min if property.min
+          options[:lte] = property.max if property.max
+        end
+
+        if Integer == property.primitive
+          options[:integer_only] = true
+
+          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
+
+          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
+          validation_options = options_with_message(options, property, :is_primitive)
+          property.model.validates_primitive_type_of property.name, validation_options
+        end
+      end
+
+      # adds message for validator
+      #
+      # @api private
+      def self.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]
+        end
+
+        options
+      end
+    end # module AutoValidations
+  end # module Validations
+end # module DataMapper

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

@@ -0,0 +1,220 @@
+require 'forwardable'
+
+module DataMapper
+  module Validations
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class ContextualValidators
+      extend Forwardable
+
+      #
+      # Delegators
+      #
+
+      def_delegators :@contexts, :empty?, :each
+      def_delegators :@attributes, :[]
+      include Enumerable
+
+      attr_reader :contexts, :attributes
+
+      def initialize(model = nil)
+        @model      = model
+        @contexts   = {}
+        @attributes = {}
+      end
+
+      #
+      # API
+      #
+
+      # Return an array of validators for a named context
+      #
+      # @param  [String]
+      #   Context name for which to return validators
+      # @return [Array<DataMapper::Validations::GenericValidator>]
+      #   An array of validators bound to the given context
+      def context(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
+
+      # 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
+      #
+      # @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!
+
+        available_validators  = context(named_context)
+        executable_validators = available_validators.select { |v| v.execute?(target) }
+
+        # 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.
+        #
+        if target.kind_of?(DataMapper::Resource) && !target.new?
+          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)
+        }
+
+        resource.__send__(:eager_load, properties_to_load)
+      end
+
+    end # module ContextualValidators
+  end # module Validations
+end # module DataMapper