dm-validations 0.10.2 → 1.0.0.rc1

data/lib/dm-validations.rb

@@ -1,3 +1,50 @@
+require 'dm-core'
+
+begin
+
+  require 'active_support/core_ext/class/attribute_accessors'
+  require 'active_support/core_ext/object/blank'
+  require 'active_support/ordered_hash'
+
+  class Object
+    # If receiver is callable, calls it and
+    # returns result. If not, just returns receiver
+    # itself
+    #
+    # @return [Object]
+    def try_call(*args)
+      if self.respond_to?(:call)
+        self.call(*args)
+      else
+        self
+      end
+    end
+  end
+
+rescue LoadError
+
+  require 'extlib/class'
+  require 'extlib/dictionary'
+  require 'extlib/blank'
+  require 'extlib/try_dup'
+  require 'extlib/object'
+
+  module ActiveSupport
+    OrderedHash = Dictionary
+  end
+
+end
+
+module DataMapper
+  class Property
+    def self.new(model, name, options = {}, type = nil)
+      property = super
+      property.model.auto_generate_validations(property)
+      property
+    end
+  end
+end
+
 require 'dm-validations/exceptions'
 require 'dm-validations/validation_errors'
 require 'dm-validations/contextual_validators'
@@ -21,7 +68,8 @@ require 'dm-validations/support/context'
 require 'dm-validations/support/object'
 
 module DataMapper
-  module Validate
+  module Validations
+
     Model.append_inclusions self
 
     extend Chainable
@@ -57,7 +105,7 @@ module DataMapper
 
     chainable do
       def save_self(*)
-        return false unless validation_context_stack.empty? || valid?(current_validation_context)
+        return false unless !dirty_self? || validation_context_stack.empty? || valid?(current_validation_context)
         super
       end
     end
@@ -104,19 +152,19 @@ module DataMapper
     end
 
     module ClassMethods
-      include DataMapper::Validate::ValidatesPresent
-      include DataMapper::Validate::ValidatesAbsent
-      include DataMapper::Validate::ValidatesIsConfirmed
-      include DataMapper::Validate::ValidatesIsPrimitive
-      include DataMapper::Validate::ValidatesIsAccepted
-      include DataMapper::Validate::ValidatesFormat
-      include DataMapper::Validate::ValidatesLength
-      include DataMapper::Validate::ValidatesWithin
-      include DataMapper::Validate::ValidatesIsNumber
-      include DataMapper::Validate::ValidatesWithMethod
-      include DataMapper::Validate::ValidatesWithBlock
-      include DataMapper::Validate::ValidatesIsUnique
-      include DataMapper::Validate::AutoValidate
+      include DataMapper::Validations::ValidatesPresence
+      include DataMapper::Validations::ValidatesAbsence
+      include DataMapper::Validations::ValidatesConfirmation
+      include DataMapper::Validations::ValidatesPrimitiveType
+      include DataMapper::Validations::ValidatesAcceptance
+      include DataMapper::Validations::ValidatesFormat
+      include DataMapper::Validations::ValidatesLength
+      include DataMapper::Validations::ValidatesWithin
+      include DataMapper::Validations::ValidatesNumericality
+      include DataMapper::Validations::ValidatesWithMethod
+      include DataMapper::Validations::ValidatesWithBlock
+      include DataMapper::Validations::ValidatesUniqueness
+      include DataMapper::Validations::AutoValidations
 
       # Return the set of contextual validators or create a new one
       #
@@ -124,6 +172,13 @@ module DataMapper
         @validators ||= ContextualValidators.new
       end
 
+      def inherited(base)
+        super
+        validators.contexts.each do |context, validators|
+          base.validators.context(context).concat(validators)
+        end
+      end
+
       private
 
       # Clean up the argument list and return a opts hash, including the
@@ -161,10 +216,10 @@ module DataMapper
       #
       # @param [Array<Symbol>] fields
       #    Fields given to validation macro, example:
-      #    [:first_name, :last_name] in validates_present :first_name, :last_name
+      #    [:first_name, :last_name] in validates_presence_of :first_name, :last_name
       #
       # @param [Class] klazz
-      #    Validator class, example: DataMapper::Validate::LengthValidator
+      #    Validator class, example: DataMapper::Validations::LengthValidator
       def add_validator_to_context(opts, fields, validator_class)
         fields.each do |field|
           validator = validator_class.new(field, opts.dup)
@@ -178,5 +233,10 @@ module DataMapper
         end
       end
     end # module ClassMethods
-  end # module Validate
+  end # module Validations
+
+  # Provide a const alias for backward compatibility with plugins
+  # This is scheduled to go away though, definitely before 1.0
+  Validate = Validations
+
 end # module DataMapper

data/lib/dm-validations/auto_validate.rb

@@ -1,11 +1,11 @@
 module DataMapper
   class Property
     # for options_with_message
-    OPTIONS << :message << :messages << :set
+    accept_options :message, :messages, :set, :validates, :auto_validation, :format
   end
 
-  module Validate
-    module AutoValidate
+  module Validations
+    module AutoValidations
       @disable_auto_validations = false
 
       # adds message for validator
@@ -41,7 +41,7 @@ module DataMapper
       #
       #   :required => true
       #       Setting the option :required to true causes a
-      #       validates_present validator to be automatically created on
+      #       validates_presence_of validator to be automatically created on
       #       the property
       #
       #   :length => 20
@@ -59,12 +59,12 @@ module DataMapper
       #       validator to be automatically created on the property
       #
       #   Integer type
-      #       Using a Integer type causes a validates_is_number
+      #       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_is_number
+      #       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
       #
@@ -127,18 +127,18 @@ module DataMapper
       def infer_presence_validation_for(property, options)
         return if skip_presence_validation?(property)
 
-        validates_present property.name, options_with_message(options, property, :presence)
+        validates_presence_of property.name, options_with_message(options, property, :presence)
       end
 
       def infer_length_validation_for(property, options)
-        return unless [ String, DataMapper::Types::Text ].include?(property.type)
+        return unless [ DataMapper::Property::String, DataMapper::Property::Text ].include?(property.class)
 
-        case length = property.options.fetch(:length, DataMapper::Property::DEFAULT_LENGTH)
+        case length = property.options.fetch(:length, DataMapper::Property::String::DEFAULT_LENGTH)
           when Range then options[:within]  = length
           else            options[:maximum] = length
         end
 
-        validates_length property.name, options_with_message(options, property, :length)
+        validates_length_of property.name, options_with_message(options, property, :length)
       end
 
       def infer_format_validation_for(property, options)
@@ -146,7 +146,7 @@ module DataMapper
 
         options[:with] = property.options[:format]
 
-        validates_format property.name, options_with_message(options, property, :format)
+        validates_format_of property.name, options_with_message(options, property, :format)
       end
 
       def infer_uniqueness_validation_for(property, options)
@@ -156,9 +156,9 @@ module DataMapper
           when Array, Symbol
             options[:scope] = Array(value)
 
-            validates_is_unique property.name, options_with_message(options, property, :is_unique)
+            validates_uniqueness_of property.name, options_with_message(options, property, :is_unique)
           when TrueClass
-            validates_is_unique property.name, options_with_message(options, property, :is_unique)
+            validates_uniqueness_of property.name, options_with_message(options, property, :is_unique)
         end
       end
 
@@ -171,23 +171,27 @@ module DataMapper
       end
 
       def infer_type_validation_for(property, options)
-        options[:gte] = property.min if property.min
-        options[:lte] = property.max if property.max
+        return if property.custom?
 
-        if Integer == property.type
+        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
 
-          validates_is_number property.name, options_with_message(options, property, :is_number)
-        elsif BigDecimal == property.type || Float == property.type
+          validates_numericality_of property.name, options_with_message(options, property, :is_number)
+        elsif BigDecimal == property.primitive || Float == property.primitive
           options[:precision] = property.precision
           options[:scale]     = property.scale
 
-          validates_is_number property.name, options_with_message(options, property, :is_number)
-        elsif !property.custom?
+          validates_numericality_of 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
-          validates_is_primitive property.name, options_with_message(options, property, :is_primitive)
+          validates_primitive_type_of property.name, options_with_message(options, property, :is_primitive)
         end
       end
 
@@ -196,6 +200,6 @@ module DataMapper
       def skip_presence_validation?(property)
         property.allow_blank? || property.serial?
       end
-    end # module AutoValidate
-  end # module Validate
+    end # module AutoValidations
+  end # module Validations
 end # module DataMapper

data/lib/dm-validations/contextual_validators.rb

@@ -1,7 +1,7 @@
 require 'forwardable'
 
 module DataMapper
-  module Validate
+  module Validations
 
     ##
     #
@@ -31,7 +31,7 @@ module DataMapper
       #
       # @param  [String]
       #   Context name for which return validators
-      # @return [Array<DataMapper::Validate::GenericValidator>]
+      # @return [Array<DataMapper::Validations::GenericValidator>]
       #   An array of validators
       def context(name)
         contexts[name] ||= []
@@ -60,5 +60,5 @@ module DataMapper
       end
 
     end # module ContextualValidators
-  end # module Validate
+  end # module Validations
 end # module DataMapper

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

@@ -1,12 +1,12 @@
 # encoding: binary
 
 module DataMapper
-  module Validate
+  module Validations
     module Format
       module Email
 
         def self.included(base)
-          DataMapper::Validate::FormatValidator::FORMATS.merge!(
+          DataMapper::Validations::FormatValidator::FORMATS.merge!(
             :email_address => [ EmailAddress, lambda { |field, value| '%s is not a valid email address'.t(value) }]
           )
         end
@@ -39,5 +39,5 @@ module DataMapper
 
       end # module Email
     end # module Format
-  end # module Validate
+  end # module Validations
 end # module DataMapper

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

@@ -1,12 +1,12 @@
 # encoding: utf-8
 
 module DataMapper
-  module Validate
+  module Validations
     module Format
       module Url
 
         def self.included(base)
-          DataMapper::Validate::FormatValidator::FORMATS.merge!(
+          DataMapper::Validations::FormatValidator::FORMATS.merge!(
             :url => [ Url, lambda { |field, value| '%s is not a valid URL'.t(value) }]
           )
         end
@@ -18,5 +18,5 @@ module DataMapper
 
       end # module Url
     end # module Format
-  end # module Validate
+  end # module Validations
 end # module DataMapper

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

@@ -1,5 +1,5 @@
 module DataMapper
-  module Validate
+  module Validations
 
     # Module with validation context functionality.
     #

data/lib/dm-validations/validation_errors.rb

@@ -1,7 +1,5 @@
-require 'extlib/dictionary'
-
 module DataMapper
-  module Validate
+  module Validations
 
     ##
     #
@@ -40,7 +38,7 @@ module DataMapper
       cattr_writer :default_error_messages
 
       def self.default_error_message(key, field, *values)
-        field = Extlib::Inflection.humanize(field)
+        field = ActiveSupport::Inflector.humanize(field)
         @@default_error_messages[key] % [field, *values].flatten
       end
 
@@ -48,7 +46,7 @@ module DataMapper
 
       def initialize(resource)
         @resource = resource
-        @errors   = Dictionary.new { |h,k| h[k] = [] }
+        @errors   = ActiveSupport::OrderedHash.new { |h,k| h[k] = [] }
       end
 
       # Clear existing validation errors.
@@ -87,7 +85,7 @@ module DataMapper
       # Return validation errors for a particular field_name.
       #
       # @param [Symbol] field_name the name of the field you want an error for
-      # @return [Array<DataMapper::Validate::Error>]
+      # @return [Array<DataMapper::Validations::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]
@@ -115,5 +113,5 @@ module DataMapper
       end
 
     end # class ValidationErrors
-  end # module Validate
+  end # module Validations
 end # module DataMapper

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

@@ -1,11 +1,11 @@
 module DataMapper
-  module Validate
+  module Validations
 
     ##
     #
     # @author Guy van den Berg
     # @since  0.9
-    class AbsentFieldValidator < GenericValidator
+    class AbsenceValidator < GenericValidator
       def call(target)
         return true if target.validation_property_value(field_name).blank?
 
@@ -14,9 +14,11 @@ module DataMapper
 
         false
       end
-    end # class AbsentFieldValidator
+    end # class AbsenceValidator
 
-    module ValidatesAbsent
+    module ValidatesAbsence
+
+      extend Deprecate
 
       ##
       # Validates that the specified attribute is "blank" via the attribute's
@@ -36,18 +38,20 @@ module DataMapper
       #     property :another_unwanted, String
       #     property :yet_again, String
       #
-      #     validates_absent :unwanted_attribute
-      #     validates_absent :another_unwanted, :yet_again
+      #     validates_absence_of :unwanted_attribute
+      #     validates_absence_of :another_unwanted, :yet_again
       #
       #     # a call to valid? will return false unless
       #     # all three attributes are blank
       #   end
       #
-      def validates_absent(*fields)
+      def validates_absence_of(*fields)
         opts = opts_from_validator_args(fields)
-        add_validator_to_context(opts, fields, DataMapper::Validate::AbsentFieldValidator)
+        add_validator_to_context(opts, fields, DataMapper::Validations::AbsenceValidator)
       end
 
+      deprecate :validates_absent, :validates_absence_of
+
     end # module ValidatesAbsent
-  end # module Validate
+  end # module Validations
 end # module DataMapper

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

@@ -1,5 +1,5 @@
 module DataMapper
-  module Validate
+  module Validations
 
     ##
     #
@@ -34,7 +34,8 @@ module DataMapper
       end
     end # class AcceptanceValidator
 
-    module ValidatesIsAccepted
+    module ValidatesAcceptance
+      extend Deprecate
 
       ##
       # Validates that the attributes's value is in the set of accepted values.
@@ -52,19 +53,21 @@ module DataMapper
       #
       #     property :license_agreement_accepted, String
       #     property :terms_accepted, String
-      #     validates_is_accepted :license_agreement, :accept => "1"
-      #     validates_is_accepted :terms_accepted, :allow_nil => false
+      #     validates_acceptance_of :license_agreement, :accept => "1"
+      #     validates_acceptance_of :terms_accepted, :allow_nil => false
       #
       #     # 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"]
       #
-      def validates_is_accepted(*fields)
+      def validates_acceptance_of(*fields)
         opts = opts_from_validator_args(fields)
-        add_validator_to_context(opts, fields, DataMapper::Validate::AcceptanceValidator)
+        add_validator_to_context(opts, fields, DataMapper::Validations::AcceptanceValidator)
       end
 
+      deprecate :validates_is_accepted, :validates_acceptance_of
+
     end # module ValidatesIsAccepted
-  end # module Validate
+  end # module Validations
 end # module DataMapper