dm-validations 0.9.11 → 0.10.0

data/lib/dm-validations/{absent_field_validator.rb → validators/absent_field_validator.rb}

@@ -6,16 +6,10 @@ module DataMapper
     # @author Guy van den Berg
     # @since  0.9
     class AbsentFieldValidator < GenericValidator
-
-      def initialize(field_name, options={})
-        super
-        @field_name, @options = field_name, options
-      end
-
       def call(target)
-        return true if target.send(field_name).blank?
+        return true if target.send(self.field_name).blank?
 
-        error_message = @options[:message] || ValidationErrors.default_error_message(:absent, field_name)
+        error_message = self.options[:message] || ValidationErrors.default_error_message(:absent, field_name)
         add_error(target, error_message, field_name)
 
         return false

data/lib/dm-validations/{acceptance_validator.rb → validators/acceptance_validator.rb}

@@ -9,10 +9,10 @@ module DataMapper
 
       def initialize(field_name, options = {})
         super
-        @options = options
-        @field_name = field_name
-        @options[:allow_nil] = true unless @options.include?(:allow_nil)
-        @options[:accept] ||= ["1", 1, "true", true, "t"]
+
+        # ||= 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[:accept] = Array(@options[:accept])
       end
 
@@ -27,9 +27,9 @@ module DataMapper
       end
 
       def valid?(target)
-        field_value = target.send(field_name)
-        return true if @options[:allow_nil] && field_value.nil?
-        return false if !@options[:allow_nil] && field_value.nil?
+        field_value = target.validation_property_value(field_name)
+        # Allow empty values
+        return true if @options[:allow_nil] && field_value.blank?
 
         @options[:accept].include?(field_value)
       end

data/lib/dm-validations/{confirmation_validator.rb → validators/confirmation_validator.rb}

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 module DataMapper
   module Validate
 
@@ -9,8 +10,7 @@ module DataMapper
 
       def initialize(field_name, options = {})
         super
-        @options = options
-        @field_name, @confirm_field_name = field_name, (options[:confirm] || "#{field_name}_confirmation").to_sym
+        @confirm_field_name  = (options[:confirm] || "#{field_name}_confirmation").to_sym
         @options[:allow_nil] = true unless @options.has_key?(:allow_nil)
       end
 
@@ -26,10 +26,10 @@ module DataMapper
 
       def valid?(target)
         field_value = target.send(field_name)
-        return true if @options[:allow_nil] && field_value.nil?
-        return false if !@options[:allow_nil] && field_value.nil?
+        return true if @options[:allow_nil] && field_value.blank?
+        return false if !@options[:allow_nil] && field_value.blank?
 
-        if target.class.properties.has_property?(field_name)
+        if target.model.properties.named?(field_name)
           return true unless target.attribute_dirty?(field_name)
         end
 
@@ -44,8 +44,8 @@ module DataMapper
       ##
       # Validates that the given attribute is confirmed by another attribute.
       # A common use case scenario is when you require a user to confirm their
-      # password, for which you use both password and password_confirmation
-      # attributes.
+      # 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

data/lib/dm-validations/{format_validator.rb → validators/format_validator.rb}

@@ -1,8 +1,8 @@
 #require File.dirname(__FILE__) + '/formats/email'
 
 require 'pathname'
-require Pathname(__FILE__).dirname.expand_path + 'formats/email'
-require Pathname(__FILE__).dirname.expand_path + 'formats/url'
+require Pathname(__FILE__).dirname.expand_path + ".." + 'formats/email'
+require Pathname(__FILE__).dirname.expand_path + ".." + 'formats/url'
 
 module DataMapper
   module Validate
@@ -17,15 +17,15 @@ module DataMapper
       include DataMapper::Validate::Format::Email
       include DataMapper::Validate::Format::Url
 
-      def initialize(field_name, options = {}, &b)
-        super(field_name, options)
-        @field_name, @options = field_name, options
-        @options[:allow_nil] = false unless @options.has_key?(:allow_nil)
+      def initialize(field_name, options = {})
+        super
+
+        @options[:allow_nil] = true unless @options.include?(:allow_nil)
       end
 
       def call(target)
         value = target.validation_property_value(field_name)
-        return true if @options[:allow_nil] && value.nil?
+        return true if @options[:allow_nil] && value.blank?
 
         validation = @options[:as] || @options[:with]
 
@@ -34,7 +34,7 @@ module DataMapper
 
         valid = case validator
           when Proc   then validator.call(value)
-          when Regexp then value =~ validator
+          when Regexp then (value.is_a?(Fixnum) ? value.to_s : value) =~ validator
           else
             raise UnknownValidationFormat, "Can't determine how to validate #{target.class}##{field_name} with #{validator.inspect}"
         end
@@ -42,19 +42,13 @@ module DataMapper
         return true if valid
 
         error_message = @options[:message] || ValidationErrors.default_error_message(:invalid, field_name)
-
-        field = Extlib::Inflection.humanize(field_name)
-        error_message = error_message.call(field, value) if error_message.respond_to?(:call)
-
-        add_error(target, error_message, field_name)
+        add_error(target, error_message.try_call(humanized_field_name, value), field_name)
 
         false
       end
-
-      #class UnknownValidationFormat < StandardError; end
-
     end # class FormatValidator
 
+
     module ValidatesFormat
 
       ##

data/lib/dm-validations/{generic_validator.rb → validators/generic_validator.rb}

@@ -15,7 +15,7 @@ module DataMapper
     class GenericValidator
 
       attr_accessor :if_clause, :unless_clause
-      attr_reader :field_name
+      attr_reader   :field_name, :options, :humanized_field_name
 
       # Construct a validator. Capture the :if and :unless clauses when present.
       #
@@ -28,9 +28,12 @@ module DataMapper
       # All additional key/value pairs are passed through to the validator
       # that is sub-classing this GenericValidator
       #
-      def initialize(field, opts = {})
-        @if_clause     = opts.delete(:if)
-        @unless_clause = opts.delete(:unless)
+      def initialize(field_name, options = {})
+        @if_clause     = options.delete(:if)
+        @unless_clause = options.delete(:unless)
+
+        @field_name, @options = field_name, options
+        @humanized_field_name = Extlib::Inflection.humanize(@field_name)
       end
 
       # Add an error message to a target resource. If the error corresponds to a
@@ -83,15 +86,34 @@ module DataMapper
         true
       end
 
+      # Returns true if validators are equal
+      #
+      # Note that this intentionally do
+      # validate options equality
+      #
+      # even though it is hard to imagine a situation
+      # when multiple validations will be used
+      # on the same field with the same conditions
+      # but different options,
+      # it happens to be the case every once in a while
+      # with inferred validations for strings/text and
+      # explicitly given validations with different option
+      # (usually as Range vs. max limit for inferred validation)
+      #
+      # @semipublic
       def ==(other)
         self.class == other.class &&
         self.field_name == other.field_name &&
-        self.class == other.class &&
         self.if_clause == other.if_clause &&
         self.unless_clause == other.unless_clause &&
         self.instance_variable_get(:@options) == other.instance_variable_get(:@options)
       end
 
+      def inspect
+        "<##{self.class.name} @field_name='#{@field_name}' @if_clause=#{@if_clause.inspect} @unless_clause=#{@unless_clause.inspect} @options=#{@options.inspect}>"
+      end
+
+      alias to_s inspect
     end # class GenericValidator
   end # module Validate
-end # module DataMapper
+end # module DataMapper

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

@@ -0,0 +1,214 @@
+module DataMapper
+  module Validate
+    class LengthValidator < GenericValidator
+
+      # Initialize a length validator
+      #
+      # @param [Symbol] field_name
+      #   the name of the field to validate
+      # @param [Hash] options
+      #   the validator options
+      #
+      # @return [undefined]
+      #
+      # @api semipublic
+      def initialize(field_name, options)
+        super
+
+        @equal = options[:is]      || options[:equals]
+        @range = options[:within]  || options[:in]
+        @min   = options[:minimum] || options[:min]
+        @max   = options[:maximum] || options[:max]
+
+        if @min && @max
+          @range ||= @min..@max
+        end
+      end
+
+      # Test the resource field for validity
+      #
+      # @example when the resource field is valid
+      #   validator.call(valid_resource)  # => true
+      #
+      # @example when the resource field is not valid
+      #   validator.call(invalid_resource)  # => false
+      #
+      #
+      # @param [Resource] target
+      #   the Resource to test
+      #
+      # @return [Boolean]
+      #   true if the field is valid, false if not
+      #
+      # @api semipublic
+      def call(target)
+        value = target.validation_property_value(field_name)
+        return true if allow_nil? && value.blank?
+
+        return true unless error_message = error_message_for(value)
+
+        add_error(target, error_message, field_name)
+
+        false
+      end
+
+      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
+      #   the value to test
+      #
+      # @return [String, nil]
+      #   the error message if invalid, nil if not
+      #
+      # @api private
+      def error_message_for(value)
+        if error_message = send(validation_method, value_length(value.to_s))
+          @options.fetch(:message, error_message)
+        end
+      end
+
+      # Return the method to validate the value with
+      #
+      # @return [Symbol]
+      #   the validation method
+      #
+      # @api private
+      def validation_method
+        @validation_method ||=
+          if    @equal then :validate_equals
+          elsif @range then :validate_range
+          elsif @min   then :validate_min
+          elsif @max   then :validate_max
+          end
+      end
+
+      # Return the length in characters
+      #
+      # @param [#to_str] value
+      #   the string to get the number of characters for
+      #
+      # @return [Integer]
+      #   the number of characters in the string
+      #
+      # @api private
+      def value_length(value)
+        value.to_str.split(//).size
+      end
+
+      # Validate the value length is equal to the expected length
+      #
+      # @param [Integer] length
+      #   the value length
+      #
+      # @return [String, nil]
+      #   the error message if invalid, nil if not
+      #
+      # @api private
+      def validate_equals(length)
+        return if length == @equal
+        ValidationErrors.default_error_message(:wrong_length, humanized_field_name, @equal)
+      end
+
+      # Validate the value length is within expected range
+      #
+      # @param [Integer] length
+      #   the value length
+      #
+      # @return [String, nil]
+      #   the error message if invalid, nil if not
+      #
+      # @api private
+      def validate_range(length)
+        return if @range.include?(length)
+        ValidationErrors.default_error_message(:length_between, humanized_field_name, @range.min, @range.max)
+      end
+
+      # Validate the minimum expected value length
+      #
+      # @param [Integer] length
+      #   the value length
+      #
+      # @return [String, nil]
+      #   the error message if invalid, nil if not
+      #
+      # @api private
+      def validate_min(length)
+        return if length >= @min
+        ValidationErrors.default_error_message(:too_short, humanized_field_name, @min)
+      end
+
+      # Validate the maximum expected value length
+      #
+      # @param [Integer] length
+      #   the value length
+      #
+      # @return [String, nil]
+      #   the error message if invalid, nil if not
+      #
+      # @api private
+      def validate_max(length)
+        return if length <= @max
+        ValidationErrors.default_error_message(:too_long, humanized_field_name, @max)
+      end
+
+    end # class LengthValidator
+
+    module ValidatesLength
+
+      # Validates that the length of the attribute is equal to, less than,
+      # greater than or within a certain range (depending upon the options
+      # you specify).
+      #
+      # @option :allow_nil<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
+      # @option :maximum    ensures the attribute's length is less than or equal
+      #   to the supplied value
+      # @option :max        alias for :maximum
+      # @option :equals     ensures the attribute's length is equal to the
+      #   supplied value
+      # @option :is         alias for :equals
+      # @option :in<Range>  given a Range, ensures that the attributes length is
+      #   include?'ed in the Range
+      # @option :within<Range>  alias for :in
+      #
+      # @example [Usage]
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property high, Integer
+      #     property low, Integer
+      #     property just_right, Integer
+      #
+      #     validates_length :high, :min => 100000000000
+      #     validates_length :low, :equals => 0
+      #     validates_length :just_right, :within => 1..10
+      #
+      #     # a call to valid? will return false unless:
+      #     # high is greater than or equal to 100000000000
+      #     # low is equal to 0
+      #     # just_right is between 1 and 10 (inclusive of both 1 and 10)
+      #
+      def validates_length(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::LengthValidator)
+      end
+
+    end # module ValidatesLength
+  end # module Validate
+end # module DataMapper

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

@@ -0,0 +1,68 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class MethodValidator < GenericValidator
+
+      def initialize(field_name, options={})
+        super
+        @options[:method] = @field_name unless @options.has_key?(:method)
+      end
+
+      def call(target)
+        result, message = target.send(@options[:method])
+        add_error(target, message, field_name) unless result
+        result
+      end
+
+      def ==(other)
+        @options[:method] == other.instance_variable_get(:@options)[:method] && super
+      end
+    end # class MethodValidator
+
+    module ValidatesWithMethod
+
+      ##
+      # Validate using method called on validated object. The method must to return
+      # either true, or a pair of [false, error message string], and is specified
+      # as a symbol passed with :method option.
+      #
+      # This validator does support multiple fields being specified at a time,
+      # but we encourage you to use it with one property/method at a time.
+      #
+      # Real world experience shows that method validation is often useful when
+      # attribute needs to be virtual and not a property name.
+      #
+      # @example [Usage]
+      #   require 'dm-validations'
+      #
+      #  class Page
+      #    include DataMapper::Resource
+      #
+      #    property :zip_code, String
+      #
+      #    validates_with_method :zip_code, :method => :in_the_right_location?
+      #
+      #    def in_the_right_location?
+      #      if @zip_code == "94301"
+      #        return true
+      #      else
+      #        return [false, "You're in the wrong zip code"]
+      #      end
+      #    end
+      #
+      #    # A call to valid? will return false and
+      #    # populate the object's errors with "You're in the
+      #    # wrong zip code" unless zip_code == "94301"
+      #  end
+      def validates_with_method(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::MethodValidator)
+      end
+
+    end # module ValidatesWithMethod
+  end # module Validate
+end # module DataMapper