ardm-validations 1.2.0

data/lib/dm-validations/validation_errors.rb

@@ -0,0 +1,137 @@
+module DataMapper
+  module Validations
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class ValidationErrors
+
+      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 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.
+      def self.default_error_messages=(default_error_messages)
+        @@default_error_messages = default_error_messages
+      end
+
+      def self.default_error_message(key, field, *values)
+        field = DataMapper::Inflector.humanize(field)
+        @@default_error_messages[key] % [field, *values].flatten
+      end
+
+      attr_reader :resource
+
+      def initialize(resource)
+        @resource = resource
+        @errors   = DataMapper::Validations::OrderedHash.new { |h,k| h[k] = [] }
+      end
+
+      # Clear existing validation errors.
+      def clear!
+        errors.clear
+      end
+
+      # 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
+      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
+
+      # Collect all errors into a single list.
+      def full_messages
+        errors.inject([]) do |list, pair|
+          list += pair.last
+        end
+      end
+
+      # 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::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]
+        DataMapper::Ext.blank?(errors_for_field) ? nil : errors_for_field.uniq
+      end
+
+      def each
+        errors.each_value do |v|
+          yield(v) unless DataMapper::Ext.blank?(v)
+        end
+      end
+
+      def empty?
+        @errors.all? { |property_name, errors| errors.empty? }
+      end
+
+      def method_missing(meth, *args, &block)
+        errors.send(meth, *args, &block)
+      end
+
+      def respond_to?(method)
+        super || errors.respond_to?(method)
+      end
+
+      def [](property_name)
+        if (property_errors = errors[property_name.to_sym])
+          property_errors
+        end
+      end
+
+      private
+
+      def errors
+        @errors
+      end
+
+    end # class ValidationErrors
+  end # module Validations
+end # module DataMapper

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

@@ -0,0 +1,58 @@
+module DataMapper
+  module Validations
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class AbsenceValidator < GenericValidator
+
+      def call(target)
+        value = target.validation_property_value(field_name)
+        return true if DataMapper::Ext.blank?(value)
+
+        error_message = (
+          self.options[:message] || ValidationErrors.default_error_message(
+            :absent, field_name
+          )
+        )
+
+        add_error(target, error_message, field_name)
+        false
+      end
+
+    end # class AbsenceValidator
+
+    module ValidatesAbsence
+      extend Deprecate
+
+      # Validates that the specified attribute is "blank" via the
+      # attribute's #blank? method.
+      #
+      # @note
+      #   dm-core's support lib adds the #blank? method to many classes,
+      # @see lib/dm-core/support/blank.rb (dm-core) for more information.
+      #
+      # @example [Usage]
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property :unwanted_attribute, String
+      #     property :another_unwanted, String
+      #     property :yet_again, String
+      #
+      #     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_absence_of(*fields)
+        validators.add(AbsenceValidator, *fields)
+      end
+
+      deprecate :validates_absent, :validates_absence_of
+    end # module ValidatesAbsent
+  end # module Validations
+end # module DataMapper

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

@@ -0,0 +1,79 @@
+module DataMapper
+  module Validations
+    # @author Martin Kihlgren
+    # @since  0.9
+    class AcceptanceValidator < GenericValidator
+
+      def initialize(field_name, options = {})
+        super
+
+        @options[:allow_nil] = true unless @options.key?(:allow_nil)
+
+        @options[:accept] ||= [ '1', 1, 'true', true, 't' ]
+        @options[:accept] = Array(@options[:accept])
+      end
+
+      def call(target)
+        return true if valid?(target)
+
+        error_message = (
+          @options[:message] || ValidationErrors.default_error_message(
+            :accepted, field_name
+          )
+        )
+        add_error(target, error_message, field_name)
+
+        false
+      end
+
+      private
+
+      def valid?(target)
+        value = target.validation_property_value(field_name)
+        return true if allow_nil?(value)
+        @options[:accept].include?(value)
+      end
+
+      def allow_nil?(value)
+        @options[:allow_nil] && value.nil?
+      end
+
+    end # class AcceptanceValidator
+
+    module ValidatesAcceptance
+      extend Deprecate
+
+      # Validates that the attributes's value is in the set of accepted
+      # values.
+      #
+      # @option [Boolean] :allow_nil (true)
+      #   true if nil is allowed, false if not allowed.
+      #
+      # @option [Array] :accept (["1", 1, "true", true, "t"])
+      #   A list of accepted values.
+      #
+      # @example Usage
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property :license_agreement_accepted, String
+      #     property :terms_accepted, String
+      #     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_acceptance_of(*fields)
+        validators.add(AcceptanceValidator, *fields)
+      end
+
+      deprecate :validates_is_accepted, :validates_acceptance_of
+
+    end # module ValidatesIsAccepted
+  end # module Validations
+end # module DataMapper

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

@@ -0,0 +1,61 @@
+module DataMapper
+  module Validations
+    # @author teamon
+    # @since  0.9
+    module ValidatesWithBlock
+      # Validate using the given block. The block given needs to return:
+      # [result::<Boolean>, Error Message::<String>]
+      #
+      # @example [Usage]
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property :zip_code, String
+      #
+      #     validates_with_block do
+      #       if @zip_code == "94301"
+      #         true
+      #       else
+      #         [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"
+      #
+      #     # You can also specify field:
+      #
+      #     validates_with_block :zip_code do
+      #       if @zip_code == "94301"
+      #         true
+      #       else
+      #         [false, "You're in the wrong zip code"]
+      #       end
+      #     end
+      #
+      #     # it will add returned error message to :zip_code field
+      #
+      def validates_with_block(*fields, &block)
+        @__validates_with_block_count ||= 0
+        @__validates_with_block_count += 1
+
+        # create method and pass it to MethodValidator
+        unless block_given?
+          raise ArgumentError, 'You need to pass a block to validates_with_block method'
+        end
+
+        method_name = "__validates_with_block_#{@__validates_with_block_count}".to_sym
+        define_method(method_name, &block)
+
+        options = fields.last.is_a?(Hash) ? fields.last.pop.dup : {}
+        options[:method] = method_name
+        fields = [method_name] if fields.empty?
+
+        validators.add(MethodValidator, *fields + [options])
+      end
+    end # module ValidatesWithMethod
+  end # module Validations
+end # module DataMapper

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

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+module DataMapper
+  module Validations
+    # @author Guy van den Berg
+    # @since  0.9
+    class ConfirmationValidator < GenericValidator
+
+      def initialize(field_name, options = {})
+        super
+
+        set_optional_by_default
+
+        @confirm_field_name = (
+          options[:confirm] || "#{field_name}_confirmation"
+        ).to_sym
+      end
+
+      def call(target)
+        return true if valid?(target)
+
+        error_message = (
+          @options[:message] || ValidationErrors.default_error_message(
+            :confirmation, field_name
+          )
+        )
+        add_error(target, error_message, field_name)
+
+        false
+      end
+
+      private
+
+      def valid?(target)
+        value = target.validation_property_value(field_name)
+        return true if optional?(value)
+
+        if target.model.properties.named?(field_name)
+          return true unless target.attribute_dirty?(field_name)
+        end
+
+        confirm_value = target.instance_variable_get("@#{@confirm_field_name}")
+        value == confirm_value
+      end
+
+    end # class ConfirmationValidator
+
+    module ValidatesConfirmation
+      extend Deprecate
+
+      ##
+      # 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.
+      #
+      # @option [Boolean] :allow_nil (true)
+      #   true or false.
+      #
+      # @option [Boolean] :allow_blank (true)
+      #   true or false.
+      #
+      # @option [Symbol] :confirm (firstattr_confirmation)
+      #   The attribute that you want to validate against.
+      #
+      # @example Usage
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property :password, String
+      #     property :email, String
+      #     attr_accessor :password_confirmation
+      #     attr_accessor :email_repeated
+      #
+      #     validates_confirmation_of :password
+      #     validates_confirmation_of :email, :confirm => :email_repeated
+      #
+      #     # a call to valid? will return false unless:
+      #     # password == password_confirmation
+      #     # and
+      #     # email == email_repeated
+      #
+      def validates_confirmation_of(*fields)
+        validators.add(ConfirmationValidator, *fields)
+      end
+
+      deprecate :validates_is_confirmed, :validates_confirmation_of
+
+    end # module ValidatesIsConfirmed
+  end # module Validations
+end # module DataMapper

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

@@ -0,0 +1,124 @@
+#require File.dirname(__FILE__) + '/formats/email'
+
+require 'pathname'
+require 'dm-validations/formats/email'
+require 'dm-validations/formats/url'
+
+module DataMapper
+  module Validations
+    class UnknownValidationFormat < ::ArgumentError; end
+
+    # @author Guy van den Berg
+    # @since  0.9
+    class FormatValidator < GenericValidator
+
+      FORMATS = {}
+
+      include DataMapper::Validations::Format::Email
+      include DataMapper::Validations::Format::Url
+
+      def initialize(field_name, options = {})
+        super
+
+        set_optional_by_default
+      end
+
+      def call(target)
+        return true if valid?(target)
+
+        value = target.validation_property_value(field_name)
+
+        error_message = (
+          @options[:message] || ValidationErrors.default_error_message(
+            :invalid, field_name
+          )
+        )
+
+        add_error(
+          target,
+          error_message.try_call(humanized_field_name, value),
+          field_name
+        )
+        false
+      end
+
+      private
+
+      def valid?(target)
+        value = target.validation_property_value(field_name)
+        return true if optional?(value)
+
+        validation = @options[:as] || @options[:with]
+
+        if validation.is_a?(Symbol) && !FORMATS.has_key?(validation)
+          raise("No such predefined format '#{validation}'")
+        end
+
+        validator = if validation.is_a?(Symbol)
+                      FORMATS[validation][0]
+                    else
+                      validation
+                    end
+
+        case validator
+          when Proc   then validator.call(value)
+          when Regexp then value ? value.to_s =~ validator : false
+          else
+            raise(UnknownValidationFormat, "Can't determine how to validate #{target.class}##{field_name} with #{validator.inspect}")
+        end
+      rescue Encoding::CompatibilityError
+        # This is to work around a bug in jruby - see formats/email.rb
+        false
+      end
+
+    end # class FormatValidator
+
+    module ValidatesFormat
+      extend Deprecate
+
+      # Validates that the attribute is in the specified format. You may
+      # use the :as (or :with, it's an alias) option to specify the
+      # pre-defined format that you want to validate against. You may also
+      # specify your own format via a Proc or Regexp passed to the the :as
+      # or :with options.
+      #
+      # @option [Boolean] :allow_nil (true)
+      #   true or false.
+      #
+      # @option [Boolean] :allow_blank (true)
+      #   true or false.
+      #
+      # @option [Format, Proc, Regexp] :as
+      #   The pre-defined format, Proc or Regexp to validate against.
+      #
+      # @option [Format, Proc, Regexp] :with
+      #   An alias for :as.
+      #
+      #   :email_address (format is specified in DataMapper::Validations::Format::Email - note that unicode emails will *not* be matched under MRI1.8.7)
+      #   :url (format is specified in DataMapper::Validations::Format::Url)
+      #
+      # @example Usage
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property :email, String
+      #     property :zip_code, String
+      #
+      #     validates_format_of :email, :as => :email_address
+      #     validates_format_of :zip_code, :with => /^\d{5}$/
+      #
+      #     # a call to valid? will return false unless:
+      #     # email is formatted like an email address
+      #     # and
+      #     # zip_code is a string of 5 digits
+      #
+      def validates_format_of(*fields)
+        validators.add(FormatValidator, *fields)
+      end
+
+      deprecate :validates_format, :validates_format_of
+    end # module ValidatesFormat
+  end # module Validations
+end # module DataMapper