datamapper 0.2.3 → 0.2.4

data/lib/data_mapper/validations/contextual_validations.rb

@@ -1,50 +0,0 @@
-module DataMapper
-  
-  class ContextualValidations
-    
-    # This will be raised when you try to access
-    # a context that's not a member of the DEFAULT_CONTEXTS array.
-    class UnknownContextError < StandardError
-    end
-    
-    # Add your custom contexts here.
-    DEFAULT_CONTEXTS = [
-        :general, :create, :save, :update
-      ]
-      
-    def initialize
-      @contexts = Hash.new { |h,k| h[k.to_sym] = [] }
-    end
-    
-    # Retrieves a context by symbol.
-    # Raises an exception if the symbol isn't a member of DEFAULT_CONTEXTS.
-    # This isn't to keep you from adding your own contexts, it's just to
-    # prevent errors due to typos. When adding your own contexts just
-    # remember to add it to DEFAULT_CONTEXTS first.
-    def context(name)
-      raise UnknownContextError.new(name) unless DEFAULT_CONTEXTS.include?(name)
-      @contexts[name]
-    end
-    
-    # Clear out all the currently defined validators.
-    # This makes testing easier.
-    def clear!
-      @contexts.clear
-    end
-    
-    # Execute all validations against an instance for a specified context,
-    # including the "always-on" :general context.
-    def execute(context_name, target)
-      target.errors.clear!
-      
-      validations = context(context_name)
-      validations += context(:general) unless context_name == :general
-      
-      validations.inject(true) do |result, validator|
-        result & validator.call(target)
-      end
-    end
-      
-  end
-  
-end

data/lib/data_mapper/validations/format_validator.rb

@@ -1,85 +0,0 @@
-require File.dirname(__FILE__) + '/formats/email'
-
-module DataMapper
-  module Validations
-    
-    class FormatValidator < GenericValidator
-      
-      # Seems to me that all this email garbage belongs somewhere else...  Where's the best
-      # place to stick it?
-      include DataMapper::Validations::Helpers::Email
-            
-      FORMATS = {
-        :email_address => [lambda { |email_address| email_address =~ DataMapper::Validations::Helpers::Email::RFC2822::EmailAddress }, :invalid_email]
-      }
-      
-      def initialize(field_name, options = {}, &b)
-        @field_name, @options = field_name, options
-      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])
-        message_key = :invalid
-        
-        # 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
-            message_key = FORMATS[validation][1] || :invalid
-            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 = target.instance_variable_get("@#{@field_name}")
-          
-          error_message = if message_key == :invalid
-            '%s is invalid'.t(field)
-          else
-            '%s is not a valid email address'.t(value)
-          end
-          
-          add_error(target, error_message , @field_name)
-        end
-        
-        return valid
-      end
-      
-      class UnknownValidationFormat < StandardError
-      end
-      
-    end
-    
-    module ValidatesFormatOf
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      module ClassMethods
-        # No bueno?
-        DEFAULT_OPTIONS = { :on => :save }
-        
-        def validates_format_of(field, options = {})
-          opts = retrieve_options_from_arguments_for_validators([options], DEFAULT_OPTIONS)
-          validations.context(opts[:context]) << Validations::FormatValidator.new(field, opts)
-        end
-
-      end
-    end
-    
-  end  
-end

data/lib/data_mapper/validations/formats/email.rb

@@ -1,78 +0,0 @@
-# http://www.faqs.org/rfcs/rfc2822.html
-module DataMapper
-  module Validations
-    module Helpers
-      module Email
-        
-        module RFC2822
-          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
-        
-      end
-    end
-  end
-end
-
-=begin
-addresses = [
-  '-- dave --@example.com', # (spaces are invalid unless enclosed in quotation marks)
-  '[dave]@example.com', # (square brackets are invalid, unless contained within quotation marks)
-  '.dave@example.com', # (the local part of a domain name cannot start with a period)
-  'Max@Job 3:14', 
-  'Job@Book of Job',
-  'J. P. \'s-Gravezande, a.k.a. The Hacker!@example.com',
-  ]
-addresses.each do |address|
-  if address =~ RFC2822::EmailAddress
-    puts "#{address} deveria ter sido rejeitado, ERRO"
-  else
-    puts "#{address} rejeitado, OK"
-  end
-end
-
-
-addresses = [
-  '+1~1+@example.com',
-  '{_dave_}@example.com',
-  '"[[ dave ]]"@example.com',
-  'dave."dave"@example.com',
-  'test@localhost',
-  'test@example.com', 
-  'test@example.co.uk',
-  'test@example.com.br',
-  '"J. P. \'s-Gravezande, a.k.a. The Hacker!"@example.com',
-  'me@[187.223.45.119]',
-  'someone@123.com',
-  'simon&garfunkel@songs.com'
-  ]
-addresses.each do |address|
-  if address =~ RFC2822::EmailAddress
-    puts "#{address} aceito, OK"
-  else
-    puts "#{address} deveria ser aceito, ERRO"
-  end
-end
-=end

data/lib/data_mapper/validations/generic_validator.rb

@@ -1,22 +0,0 @@
-module DataMapper
-  module Validations
-    
-    # All Validators should inherit from the GenericValidator.
-    class GenericValidator
-    
-      # Adds an error message to the target class.
-      def add_error(target, message, attribute = :base)
-        target.errors.add(attribute, message)
-      end
-      
-      # Call the validator. We use "call" so the operation
-      # is BoundMethod and Block compatible.
-      # The result should always be TRUE or FALSE.
-      def call(target)
-        raise 'You must overwrite this method'
-      end
-      
-    end
-        
-  end
-end

data/lib/data_mapper/validations/length_validator.rb

@@ -1,76 +0,0 @@
-module DataMapper
-  module Validations
-    
-    class LengthValidator < GenericValidator
-      
-      def initialize(field_name, options)
-        @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.instance_variable_get("@#{@field_name}").to_s
-        return true if @options[:allow_nil] && field_value.nil?
-        
-        # HACK seems hacky to do this on every validation, probably should do this elsewhere?
-        field = Inflector.humanize(@field_name)
-        min = @range ? @range.min : @min
-        max = @range ? @range.max : @max
-        equal = @equal
-
-        error_message = nil
-        
-        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
-        
-        add_error(target, error_message, @field_name) unless valid
-
-        return valid
-      end
-
-    end
-    
-    module ValidatesLengthOf
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      module ClassMethods
-        DEFAULT_VALIDATES_LENGTH_OF_OPTIONS = { :on => :save }
-
-        def validates_length_of(field, options = {})
-          opts = retrieve_options_from_arguments_for_validators([options], DEFAULT_VALIDATES_LENGTH_OF_OPTIONS)
-          validations.context(opts[:context]) << Validations::LengthValidator.new(field, opts)
-        end
-
-      end
-    end
-    
-  end  
-end

data/lib/data_mapper/validations/required_field_validator.rb

@@ -1,41 +0,0 @@
-module DataMapper
-  module Validations
-    
-    class RequiredFieldValidator < GenericValidator
-
-      def initialize(field_name)
-        @field_name = field_name
-      end
-      
-      def call(target)
-        field_value = !target.instance_variable_get("@#{@field_name}").nil?
-        return true if field_value
-        
-        error_message = "%s must not be blank".t(Inflector.humanize(@field_name))
-        add_error(target, error_message , @field_name)
-        
-        return false
-      end
-      
-    end
-    
-    module ValidatesPresenceOf
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      module ClassMethods
-
-        def validates_presence_of(*fields)
-          options = retrieve_options_from_arguments_for_validators(fields)
-          
-          fields.each do |field|
-            validations.context(options[:context]) << Validations::RequiredFieldValidator.new(field)
-          end
-        end
-
-      end
-    end
-    
-  end  
-end

data/lib/data_mapper/validations/unique_validator.rb

@@ -1,56 +0,0 @@
-module DataMapper
-  module Validations
-    
-    class UniqueValidator < GenericValidator
-      
-      def initialize(field_name, options = {})
-        @options = options
-        @field_name = field_name.to_sym
-      end
-      
-      def call(target)
-        unless valid?(target)
-          error_message = '%s has already been taken'.t(Inflector.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?
-        
-        finder_options = { @field_name => field_value }
-        
-        if @options[:scope]
-          scope_value = target.instance_variable_get("@#{@options[:scope]}")
-          finder_options.merge! @options[:scope] => scope_value
-        end
-        
-        finder_options.merge!({ target.session.table(target.class).key.name.not => target.key }) unless target.new_record?
-        target.session.first(target.class, finder_options).nil?
-      end
-      
-    end
-    
-    module ValidatesUniquenessOf
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      module ClassMethods
-        # No bueno?
-        DEFAULT_OPTIONS = { :on => :save }
-
-        def validates_uniqueness_of(field, options = {})
-          opts = retrieve_options_from_arguments_for_validators([options], DEFAULT_OPTIONS)
-          validations.context(opts[:context]) << Validations::UniqueValidator.new(field, opts)
-        end
-
-      end
-    end
-    
-  end  
-end

data/lib/data_mapper/validations/validation_errors.rb

@@ -1,37 +0,0 @@
-module DataMapper
-  
-  class ValidationErrors
-  
-    def initialize
-      @errors = Hash.new { |h,k| h[k.to_sym] = [] }
-    end
-    
-    # Clear existing validation errors.
-    def clear!
-      @errors.clear
-    end
-    
-    # Add a validation error. Use the attribute :general if
-    # the error doesn't apply to a specific attribute.
-    def add(attribute, message)
-      @errors[attribute] << message
-    end
-    
-    # Collect all errors into a single list.
-    def full_messages
-      @errors.inject([]) do |list,pair|
-        list += pair.last
-      end
-    end
-    
-    def on(attribute)
-      @errors[attribute]
-    end
-    
-    def method_missing(meth, *args)
-      @errors.send(meth, *args)
-    end
-   
-  end
-  
-end

data/lib/data_mapper/validations/validation_helper.rb

@@ -1,77 +0,0 @@
-dirname = File.dirname(__FILE__)
-
-require dirname + '/validation_errors'
-require dirname + '/contextual_validations'
-require dirname + '/generic_validator'
-
-Dir[dirname + '/*_validator.rb'].reject do |path|
-  path =~ /\/generic_validator/
-end.each do |validator|
-  load validator
-end
-
-module DataMapper
-  module Validations
-    
-    module ValidationHelper
-      
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.class_eval do
-          include DataMapper::Validations::ValidatesPresenceOf
-          include DataMapper::Validations::ValidatesLengthOf
-          include DataMapper::Validations::ValidatesConfirmationOf
-          include DataMapper::Validations::ValidatesUniquenessOf
-          include DataMapper::Validations::ValidatesFormatOf
-        end
-      end
-      
-      def errors
-        @errors ||= ValidationErrors.new
-      end
-      
-      def valid?(context = :general)
-        validate_excluding_association(nil, context)
-      end
-      
-      def validate_excluding_association(associated, context = :general)
-        return false unless self.class.callbacks.execute(:before_validation, self)
-        return false unless self.class.validations.execute(context, self)
-        if self.respond_to?(:loaded_associations)
-          return false unless self.loaded_associations.all? do |association|
-            if association != associated && association.respond_to?(:validate_excluding_association)
-              association.validate_excluding_association(self, context)
-            else
-              true
-            end
-          end
-        end
-
-        return false unless self.class.callbacks.execute(:after_validation, self)
-        return true
-      end
-      
-      module ClassMethods
-        
-        def validations
-          @validations ||= ContextualValidations.new
-        end
-        
-        def retrieve_options_from_arguments_for_validators(args, defaults = nil)
-          options = args.last.kind_of?(Hash) ? args.pop : {}
-          
-          context = :general
-          context = options[:context] if options.has_key?(:context)
-          context = options.delete(:on) if options.has_key?(:on)
-          options[:context] = context
-          
-          options.merge!(defaults) unless defaults.nil?
-          return options
-        end
-                
-      end
-      
-    end    
-    
-  end
-end

data/plugins/dataobjects/REVISION

@@ -1 +0,0 @@
-18

data/plugins/dataobjects/Rakefile

@@ -1,9 +0,0 @@
-require 'spec/rake/spectask'
-
-task :default => 'specs'
-
-desc "Run all specs"
-Spec::Rake::SpecTask.new('specs') do |t|
-  t.spec_opts = ["--format", "specdoc", "--colour"]
-  t.spec_files = Dir['spec/*_spec.rb'].sort
-end