mack-data_mapper 0.8.1 → 0.8.2

data/lib/gems/dm-validations-0.9.7/lib/dm-validations/block_validator.rb

@@ -0,0 +1,60 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @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
+        raise ArgumentError.new('You need to pass a block to validates_with_block method') unless block_given?
+        method_name = "__validates_with_block_#{@__validates_with_block_count}".to_sym
+        define_method(method_name, block)
+        opts = opts_from_validator_args(fields)
+        opts[:method] = method_name
+        add_validator_to_context(opts, fields.empty? ? [method_name] : fields, DataMapper::Validate::MethodValidator)
+      end
+
+    end # module ValidatesWithMethod
+  end # module Validate
+end # module DataMapper

data/lib/gems/dm-validations-0.9.7/lib/dm-validations/confirmation_validator.rb

@@ -0,0 +1,80 @@
+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?
+
+        if target.class.properties.has_property?(@field_name)
+          return true unless target.attribute_dirty?(@field_name)
+        end
+
+        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/gems/dm-validations-0.9.7/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|
+          next unless validator.execute?(target)
+          result = false unless validator.call(target)
+        end
+
+        result
+      end
+
+    end # module ContextualValidators
+  end # module Validate
+end # module DataMapper

data/lib/gems/dm-validations-0.9.7/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/gems/dm-validations-0.9.7/lib/dm-validations/format_validator.rb

@@ -0,0 +1,97 @@
+#require File.dirname(__FILE__) + '/formats/email'
+
+require 'pathname'
+require Pathname(__FILE__).dirname.expand_path + 'formats/email'
+require Pathname(__FILE__).dirname.expand_path + 'formats/url'
+
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class FormatValidator < GenericValidator
+
+      FORMATS = {}
+      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)
+      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
+
+        valid = case validator
+          when Proc   then validator.call(value)
+          when Regexp then value =~ validator
+          else
+            raise UnknownValidationFormat, "Can't determine how to validate #{target.class}##{@field_name} with #{validator.inspect}"
+        end
+
+        return true if valid
+
+        field = Extlib::Inflection.humanize(@field_name)
+        error_message = @options[:message] || '%s has an invalid format'.t(field)
+        error_message = error_message.call(field, value) if error_message.respond_to?(:call)
+
+        add_error(target, error_message, @field_name)
+
+        false
+      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)
+      #   :url (format is specified in DataMapper::Validate::Format::Url)
+      #
+      # @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

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

@@ -0,0 +1,40 @@
+module DataMapper
+  module Validate
+    module Format
+      module Email
+
+        def self.included(base)
+          DataMapper::Validate::FormatValidator::FORMATS.merge!(
+            :email_address => [ EmailAddress, lambda { |field, value| '%s is not a valid email address'.t(value) }]
+          )
+        end
+
+        EmailAddress = begin
+            alpha = "a-zA-Z"
+            digit = "0-9"
+            atext = "[#{alpha}#{digit}\!\#\$\%\&\'\*+\/\=\?\^\_\`\{\|\}\~\-]"
+            dot_atom_text = "#{atext}+([.]#{atext}*)*"
+            dot_atom = "#{dot_atom_text}"
+            qtext = '[^\\x0d\\x22\\x5c\\x80-\\xff]'
+            text = "[\\x01-\\x09\\x11\\x12\\x14-\\x7f]"
+            quoted_pair = "(\\x5c#{text})"
+            qcontent = "(?:#{qtext}|#{quoted_pair})"
+            quoted_string = "[\"]#{qcontent}+[\"]"
+            atom = "#{atext}+"
+            word = "(?:#{atom}|#{quoted_string})"
+            obs_local_part = "#{word}([.]#{word})*"
+            local_part = "(?:#{dot_atom}|#{quoted_string}|#{obs_local_part})"
+            no_ws_ctl = "\\x01-\\x08\\x11\\x12\\x14-\\x1f\\x7f"
+            dtext = "[#{no_ws_ctl}\\x21-\\x5a\\x5e-\\x7e]"
+            dcontent = "(?:#{dtext}|#{quoted_pair})"
+            domain_literal = "\\[#{dcontent}+\\]"
+            obs_domain = "#{atom}([.]#{atom})*"
+            domain = "(?:#{dot_atom}|#{domain_literal}|#{obs_domain})"
+            addr_spec = "#{local_part}\@#{domain}"
+            pattern = /^#{addr_spec}$/
+        end
+
+      end # module Email
+    end # module Format
+  end # module Validate
+end # module DataMapper

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

@@ -0,0 +1,20 @@
+module DataMapper
+  module Validate
+    module Format
+      module Url
+
+        def self.included(base)
+          DataMapper::Validate::FormatValidator::FORMATS.merge!(
+            :url => [ Url, lambda { |field, value| '%s is not a valid URL'.t(value) }]
+          )
+        end
+
+        Url = begin
+          # Regex from http://www.igvita.com/2006/09/07/validating-url-in-ruby-on-rails/
+          /(^$)|(^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$)/ix
+        end
+
+      end # module Url
+    end # module Format
+  end # module Validate
+end # module DataMapper

data/lib/gems/dm-validations-0.9.7/lib/dm-validations/generic_validator.rb

@@ -0,0 +1,100 @@
+module DataMapper
+  module Validate
+
+    # All validators extend this base class. Validators must:
+    #
+    # * Implement the initialize method to capture its parameters, also calling
+    #   super to have this parent class capture the optional, general :if and
+    #   :unless parameters.
+    # * Implement the call method, returning true or false. The call method
+    #   provides the validation logic.
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class GenericValidator
+
+      attr_accessor :if_clause
+      attr_accessor :unless_clause
+
+      # Construct a validator. Capture the :if and :unless clauses when present.
+      #
+      # @param field<String, Symbol> The property specified for validation
+      #
+      # @option :if<Symbol, Proc>   The name of a method or a Proc to call to
+      #                     determine if the validation should occur.
+      # @option :unless<Symbol, Proc> The name of a method or a Proc to call to
+      #                         determine if the validation should not occur
+      # All additional key/value pairs are passed through to the validator
+      # that is sub-classing this GenericValidator
+      #
+      def initialize(field, opts = {})
+        @if_clause = opts.has_key?(:if) ? opts[:if] : nil
+        @unless_clause = opts.has_key?(:unless) ? opts[:unless] : nil
+      end
+
+      # Add an error message to a target resource. If the error corresponds to a
+      # specific field of the resource, add it to that field, otherwise add it
+      # as a :general message.
+      #
+      # @param <Object> target the resource that has the error
+      # @param <String> message the message to add
+      # @param <Symbol> field_name the name of the field that caused the error
+      #
+      # TODO - should the field_name for a general message be :default???
+      #
+      def add_error(target, message, field_name = :general)
+        target.errors.add(field_name,message)
+      end
+
+      # Call the validator. "call" is used so the operation is BoundMethod and
+      # Block compatible. This must be implemented in all concrete classes.
+      #
+      # @param <Object> target  the resource that the validator must be called
+      #                         against
+      # @return <Boolean> true if valid, otherwise false
+      def call(target)
+        raise "DataMapper::Validate::GenericValidator::call must be overriden in #{self.class.to_s}"
+      end
+
+      def field_name
+        @field_name
+      end
+
+      # Determines if this validator should be run against the
+      # target by evaluating the :if and :unless clauses
+      # optionally passed while specifying any validator.
+      #
+      # @param <Object> target the resource that we check against
+      # @return <Boolean> true if should be run, otherwise false
+      def execute?(target)
+        if unless_clause = self.unless_clause
+          if unless_clause.is_a?(Symbol)
+            return false if target.send(unless_clause)
+          elsif unless_clause.respond_to?(:call)
+            return false if unless_clause.call(target)
+          end
+        end
+
+        if if_clause = self.if_clause
+          if if_clause.is_a?(Symbol)
+            return target.send(if_clause)
+          elsif if_clause.respond_to?(:call)
+            return if_clause.call(target)
+          end
+        end
+
+        true
+      end
+
+      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
+
+    end # class GenericValidator
+  end # module Validate
+end # module DataMapper

data/lib/gems/dm-validations-0.9.7/lib/dm-validations/length_validator.rb

@@ -0,0 +1,113 @@
+module DataMapper
+  module Validate
+
+    ##
+    #
+    # @author Guy van den Berg
+    # @since  0.9
+    class LengthValidator < GenericValidator
+
+      def initialize(field_name, options)
+        super
+        @field_name = field_name
+        @options = options
+
+        @min = options[:minimum] || options[:min]
+        @max = options[:maximum] || options[:max]
+        @equal = options[:is] || options[:equals]
+        @range = options[:within] || options[:in]
+
+        @validation_method ||= :range if @range
+        @validation_method ||= :min if @min && @max.nil?
+        @validation_method ||= :max if @max && @min.nil?
+        @validation_method ||= :equals unless @equal.nil?
+      end
+
+      def call(target)
+        field_value = target.validation_property_value(@field_name)
+        return true if @options[:allow_nil] && field_value.nil?
+
+        field_value = '' if field_value.nil?
+
+        # XXX: HACK seems hacky to do this on every validation, probably should
+        #      do this elsewhere?
+        field = Extlib::Inflection.humanize(@field_name)
+        min = @range ? @range.min : @min
+        max = @range ? @range.max : @max
+        equal = @equal
+
+        case @validation_method
+        when :range then
+          unless valid = @range.include?(field_value.size)
+            error_message = '%s must be between %s and %s characters long'.t(field, min, max)
+          end
+        when :min then
+          unless valid = field_value.size >= min
+            error_message = '%s must be more than %s characters long'.t(field, min)
+          end
+        when :max then
+          unless valid = field_value.size <= max
+            error_message = '%s must be less than %s characters long'.t(field, max)
+          end
+        when :equals then
+          unless valid = field_value.size == equal
+            error_message = '%s must be %s characters long'.t(field, equal)
+          end
+        end
+
+        error_message = @options[:message] || error_message
+
+        add_error(target, error_message, @field_name) unless valid
+
+        return valid
+      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