dm-validations 0.9.2

data/lib/dm-validations/acceptance_validator.rb

@@ -0,0 +1,76 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Martin Kihlgren
+    # @since  0.9
+    class AcceptanceValidator < GenericValidator
+
+      def self.default_message_for_field(field_name)
+        '%s is not accepted'.t(Extlib::Inflection.humanize(field_name))
+      end
+
+      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"]
+        @options[:accept] = Array(@options[:accept])
+      end
+
+      def call(target)
+        unless valid?(target)
+          error_message = @options[:message] || DataMapper::Validate::AcceptanceValidator.default_message_for_field(@field_name)
+          add_error(target, error_message , @field_name)
+          return false
+        end
+
+        return true
+      end
+
+      def valid?(target)
+        field_value = target.instance_variable_get("@#{@field_name}")
+        return true if @options[:allow_nil] && field_value.nil?
+        return false if !@options[:allow_nil] && field_value.nil?
+
+        @options[:accept].include?(field_value)
+      end
+
+    end # class AcceptanceValidator
+
+    module ValidatesIsAccepted
+
+      ##
+      # Validates that the attributes's value is in the set of accepted values.
+      #
+      # @option :allow_nil<Boolean> true if nil is allowed, false if nil is not
+      #                             allowed. Default is true.
+      # @option :accept<Array>      a list of accepted values.
+      #                             Default are ["1",1,"true",true,"t"]).
+      #
+      # @example [Usage]
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property :license_agreement_accepted, String
+      #     property :terms_accepted, String
+      #     validates_is_accepted :license_agreement, :accept => "1"
+      #     validates_is_accepted :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)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::AcceptanceValidator)
+      end
+
+    end # module ValidatesIsAccepted
+  end # module Validate
+end # module DataMapper

data/lib/dm-validations/auto_validate.rb

@@ -0,0 +1,98 @@
+module DataMapper
+  module Validate
+    module AutoValidate
+
+      ##
+      # Auto-generate validations for a given property. This will only occur
+      # if the option :auto_validation is either true or left undefined.
+      #
+      # @details [Triggers]
+      #   Triggers that generate validator creation
+      #
+      #   :nullable => false
+      #       Setting the option :nullable to false causes a
+      #       validates_presence_of validator to be automatically created on
+      #       the property
+      #
+      #   :size => 20 or :length => 20
+      #       Setting the option :size or :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
+      #
+      #   Integer type
+      #       Using a Integer type causes a validates_is_number
+      #       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
+      #       validator to be created for the property.  integer_only
+      #       is set to false, and precision/scale match the property
+      def auto_generate_validations(property)
+        property.options[:auto_validation] = true unless property.options.has_key?(:auto_validation)
+        return unless property.options[:auto_validation]
+
+        # a serial property is allowed to be nil too, because the
+        # value is set by the storage system
+        opts = { :allow_nil => property.nullable? || property.serial? }
+        opts[:context] = property.options[:validates] if property.options.has_key?(:validates)
+
+        # presence
+        unless opts[:allow_nil]
+          validates_present property.name, opts
+        end
+
+        # length
+        if property.type == String
+          #len = property.length  # XXX: maybe length should always return a Range, with the min defaulting to 1
+          len = property.options.fetch(:length, property.options.fetch(:size, DataMapper::Property::DEFAULT_LENGTH))
+          if len.is_a?(Range)
+            opts[:within] = len
+          else
+            opts[:maximum] = len
+          end
+          validates_length property.name, opts
+        end
+
+        # format
+        if property.options.has_key?(:format)
+          opts[:with] = property.options[:format]
+          validates_format property.name, opts
+        end
+
+        # uniqueness validator
+        if property.options.has_key?(:unique)
+          value = property.options[:unique]
+          if value.is_a?(Array) || value.is_a?(Symbol)
+            validates_is_unique property.name, :scope => Array(value)
+          elsif value.is_a?(TrueClass)
+            validates_is_unique property.name
+          end
+        end
+
+        # numeric validator
+        if Integer == property.type
+          opts[:integer_only] = true
+          validates_is_number property.name, opts
+        elsif BigDecimal == property.type || Float == property.type
+          opts[:precision] = property.precision
+          opts[:scale]     = property.scale
+          validates_is_number property.name, opts
+        else
+          # We only need this in the case we don't already
+          # have a numeric validator, because otherwise
+          # it will cause duplicate validation errors
+          unless property.custom?
+            validates_is_primitive property.name, opts
+          end
+        end
+      end
+
+    end # module AutoValidate
+  end # module Validate
+end # module DataMapper

data/lib/dm-validations/confirmation_validator.rb

@@ -0,0 +1,76 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class ConfirmationValidator < GenericValidator
+
+      def initialize(field_name, options = {})
+        super
+        @options = options
+        @field_name, @confirm_field_name = field_name, (options[:confirm] || "#{field_name}_confirmation").to_sym
+        @options[:allow_nil] = true unless @options.has_key?(:allow_nil)
+      end
+
+      def call(target)
+        unless valid?(target)
+          error_message = @options[:message] || '%s does not match the confirmation'.t(Extlib::Inflection.humanize(@field_name))
+          add_error(target, error_message , @field_name)
+          return false
+        end
+
+        return true
+      end
+
+      def valid?(target)
+        field_value = target.instance_variable_get("@#{@field_name}")
+        return true if @options[:allow_nil] && field_value.nil?
+        return false if !@options[:allow_nil] && field_value.nil?
+
+        confirm_value = target.instance_variable_get("@#{@confirm_field_name}")
+        field_value == confirm_value
+      end
+
+    end # class ConfirmationValidator
+
+    module ValidatesIsConfirmed
+
+      ##
+      # 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 :allow_nil<Boolean> true/false (default is true)
+      # @option :confirm<Symbol>    the attribute that you want to validate
+      #                             against (default is firstattr_confirmation)
+      #
+      # @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_is_confirmed :password
+      #     validates_is_confirmed :email, :confirm => :email_repeated
+      #
+      #     # a call to valid? will return false unless:
+      #     # password == password_confirmation
+      #     # and
+      #     # email == email_repeated
+      #
+      def validates_is_confirmed(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::ConfirmationValidator)
+      end
+
+    end # module ValidatesIsConfirmed
+  end # module Validate
+end # module DataMapper

data/lib/dm-validations/contextual_validators.rb

@@ -0,0 +1,56 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class ContextualValidators
+
+      def dump
+        contexts.each_pair do |key,context|
+          puts "Key=#{key} Context: #{context}"
+        end
+      end
+
+      # Get a hash of named context validators for the resource
+      #
+      # @return <Hash> a hash of validators <GenericValidator>
+      def contexts
+        @contexts ||= @contexts = {}
+      end
+
+      # Return an array of validators for a named context
+      #
+      # @return <Array> An array of validators
+      def context(name)
+        contexts[name] = [] unless contexts.has_key?(name)
+        contexts[name]
+      end
+
+      # Clear all named context validators off of the resource
+      #
+      def clear!
+        contexts.clear
+      end
+
+      # Execute all validators in the named context against the target
+      #
+      # @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)
+        raise(ArgumentError, 'invalid context specified') if !named_context || (contexts.length > 0 && !contexts[named_context])
+        target.errors.clear!
+        result = true
+        context(named_context).each do |validator|
+          if validator.execute?(target)
+            result = false if !validator.call(target)
+          end
+        end
+        return result
+      end
+
+    end # module ContextualValidators
+  end # module Validate
+end # module DataMapper

data/lib/dm-validations/custom_validator.rb

@@ -0,0 +1,72 @@
+#require File.dirname(__FILE__) + '/formats/email'
+
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class CustomValidator < GenericValidator
+
+      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)
+      end
+
+      def call(target)
+        #field_value = target.instance_variable_get("@#{@field_name}")
+        #return true if @options[:allow_nil] && field_value.nil?
+
+        #validation = (@options[:as] || @options[:with])
+        #error_message = nil
+
+        # Figure out what to use as the actual validator.
+        # If a symbol is passed to :as, look up
+        # the canned validation in FORMATS.
+        #
+        #validator = if validation.is_a? Symbol
+        #  if FORMATS[validation].is_a? Array
+        #    error_message = FORMATS[validation][1]
+        #    FORMATS[validation][0]
+        #  else
+        #    FORMATS[validation] || validation
+        #  end
+        #else
+        #  validation
+        #end
+
+        #valid = case validator
+        #when Proc then validator.call(field_value)
+        #when Regexp then validator =~ field_value
+        #else raise UnknownValidationFormat, "Can't determine how to validate #{target.class}##{@field_name} with #{validator.inspect}"
+        #end
+
+        #unless valid
+        #  field = Inflector.humanize(@field_name)
+        #  value = field_value
+        #
+        #  error_message = @options[:message] || error_message || '%s is invalid'.t(field)
+        #  error_message = error_message.call(field, value) if Proc === error_message
+        #
+        #  add_error(target, error_message , @field_name)
+        #end
+
+        #return valid
+      end
+
+      #class UnknownValidationFormat < StandardError; end
+
+    end # class CustomValidator
+
+    module ValidatesFormatOf
+
+      #def validates_format_of(*fields)
+        #opts = opts_from_validator_args(fields)
+        #add_validator_to_context(opts, fields, DataMapper::Validate::FormatValidator)
+      #end
+
+    end # module ValidatesFormatOf
+  end # module Validate
+end # module DataMapper

data/lib/dm-validations/format_validator.rb

@@ -0,0 +1,94 @@
+#require File.dirname(__FILE__) + '/formats/email'
+
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path + 'formats/email'
+
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class FormatValidator < GenericValidator
+
+      FORMATS = {}
+      include DataMapper::Validate::Format::Email
+
+      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)
+      end
+
+      def call(target)
+        value = target.validation_property_value(@field_name)
+        return true if @options[:allow_nil] && value.nil?
+
+        validation = (@options[:as] || @options[:with])
+
+        raise "No such predefined format '#{validation}'" if validation.is_a?(Symbol) && !FORMATS.has_key?(validation)
+        validator = validation.is_a?(Symbol) ? FORMATS[validation][0] : validation
+
+        field = Extlib::Inflection.humanize(@field_name)
+        error_message = @options[:message] || '%s has an invalid format'.t(field)
+
+        valid = case validator
+        when Proc   then validator.call(value)
+        when Regexp then validator =~ value
+        else raise UnknownValidationFormat, "Can't determine how to validate #{target.class}##{@field_name} with #{validator.inspect}"
+        end
+
+        unless valid
+          error_message = @options[:message] || error_message || '%s is invalid'.t(field)
+          error_message = error_message.call(field, value) if Proc === error_message
+          add_error(target, error_message , @field_name)
+        end
+
+        return valid
+      end
+
+      #class UnknownValidationFormat < StandardError; end
+
+    end # class FormatValidator
+
+    module ValidatesFormat
+
+      ##
+      # 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 :allow_nil<Boolean>         true/false (default is true)
+      # @option :as<Format, Proc, Regexp>   the pre-defined format, Proc or Regexp to validate against
+      # @option :with<Format, Proc, Regexp> an alias for :as
+      #
+      # @details [Pre-defined Formats]
+      #   :email_address (format is specified in DataMapper::Validate::Format::Email)
+      #
+      # @example [Usage]
+      #   require 'dm-validations'
+      #
+      #   class Page
+      #     include DataMapper::Resource
+      #
+      #     property :email, String
+      #     property :zip_code, String
+      #
+      #     validates_format :email, :as => :email_address
+      #     validates_format :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(*fields)
+        opts = opts_from_validator_args(fields)
+        add_validator_to_context(opts, fields, DataMapper::Validate::FormatValidator)
+      end
+
+    end # module ValidatesFormat
+  end # module Validate
+end # module DataMapper