datamapper 0.3.2 → 0.9.3

data/lib/data_mapper/validatable_extensions/errors.rb

@@ -1,12 +0,0 @@
-module Validatable
-  class Errors
-    def on(attribute)
-      raw(attribute)
-    end
-  
-    def full_messages
-      errors.values.flatten.compact
-    end
-
-  end
-end

data/lib/data_mapper/validatable_extensions/macros.rb

@@ -1,7 +0,0 @@
-module Validatable
-  module Macros
-    def validates_uniqueness_of(*args)
-      add_validations(args, ValidatesUniquenessOf)
-    end
-  end
-end

data/lib/data_mapper/validatable_extensions/validatable_instance_methods.rb

@@ -1,62 +0,0 @@
-# = Validations
-# DataMapper uses the 'Validatable' gem to validate models.
-# 
-# Example:
-#   class Person < DataMapper::Base
-#     property :name, :string
-#     property :email, :string
-#     property :password, :string
-#
-#     validates_presence_of :name, :email
-#     validates_length_of :password, :minimum => 6, :on => :create
-#     validates_format_of :email, :with => :email_address, :message => 'Please provide a valid email address.'
-#   end
-#
-#   p = Person.new
-#   p.valid? #=> false
-#   p.errors.full_messages #=> ["Email must not be blank", "Please provide a valid email address.", "Name must not be blank"]
-#
-#   p.save #=> false
-#   p.errors.full_messages #=> ["Password must be more than 5 characters long", "Email must not be blank", 
-#                                  "Please provide a valid email address.", "Name must not be blank"]
-#   
-#
-
-module Validatable
-  alias_method :valid_in_all_cases?, :valid? #:nodoc:
-
-  # Returns true if no errors were added otherwise false. Only executes validations that have no :groups option specified
-  def valid?(event = :validate)
-    validate_recursively(event, Set.new)
-  end
-  
-  #TODO should callbacks really affect the flow? shouldn't validations themselves do that?
-  def validate_recursively(event, cleared) #:nodoc:
-    return true if cleared.include?(self)
-    cleared << self
-    
-    self.class.callbacks.execute(:before_validation, self)
-
-    # Validatable clears the errors list when running valid_for_some_group?, so we save general errors
-    # and then merge them back in after we've validated for events
-    generally_valid = valid_for_group?(nil)
-    general_errors = self.errors.errors.dup
-    
-    if respond_to?(:"valid_for_#{event}?")
-      valid_for_events = send(:"valid_for_#{event}?")
-      self.errors.errors.merge!(general_errors) {|key, val1, val2| val1+val2 }
-      return false unless generally_valid && valid_for_events
-    end
-    
-    return false unless generally_valid
-    
-    if self.respond_to?(:loaded_associations)
-      return false unless self.loaded_associations.all? do |association|
-        association.validate_recursively(event, cleared)
-      end
-    end
-    
-    self.class.callbacks.execute(:after_validation, self)
-    return true
-  end
-end

data/lib/data_mapper/validatable_extensions/validation_base.rb

@@ -1,18 +0,0 @@
-module Validatable
-  class ValidationBase
-    alias_method :old_init, :initialize
-  
-    DEFAULT_EVENTS = [:validate, :create, :save, :update]
-
-    def initialize(klass, attribute, options={})
-      events = [options.delete(:on)].flatten.compact + [options.delete(:event)].flatten.compact
-      raise ArgumentError.new("Events must be one of #{DEFAULT_EVENTS.inspect}") unless (events & DEFAULT_EVENTS).size == events.size
-      options[:groups] ||= events unless events.empty? ### <- Danger will robinson
-      old_init(klass, attribute, options)
-    end
-  
-    def humanized_attribute
-      @humanized_attribute ||= Inflector.humanize(self.attribute.to_s)
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-module Validatable
-  module Helpers #:nodoc:
-    module Formats #:nodoc:
-      
-      # Allows you to validate fields as email addresses
-      #   validates_format_of :email_field, :with => :email_address
-
-      module Email
-          
-          def self.included(base)
-            base::FORMATS.merge!( :email_address => [ EmailAddress, 
-                                  lambda { |attribute| lambda { "%s is not a valid email address".t(self.send(attribute)) } }] )
-          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
-    end
-  end
-end

data/lib/data_mapper/validatable_extensions/validations/validates_acceptance_of.rb

@@ -1,7 +0,0 @@
-module Validatable
-  class ValidatesAcceptanceOf < ValidationBase
-    def message(instance)
-      super || '%s must be accepted'.t(humanized_attribute)
-    end
-  end
-end

data/lib/data_mapper/validatable_extensions/validations/validates_confirmation_of.rb

@@ -1,7 +0,0 @@
-module Validatable
-  class ValidatesConfirmationOf < ValidationBase
-    def message(instance)
-      super || "%s does not match the confirmation".t(humanized_attribute)
-    end
-  end
-end

data/lib/data_mapper/validatable_extensions/validations/validates_each.rb

@@ -1,7 +0,0 @@
-module Validatable
-  class ValidatesEach < ValidationBase
-    def message(instance)
-      super || '%s is invalid'.t(humanized_attribute)
-    end
-  end
-end

data/lib/data_mapper/validatable_extensions/validations/validates_format_of.rb

@@ -1,28 +0,0 @@
-require File.dirname(__FILE__) + '/formats/email.rb'
-
-module Validatable
-  
-  class ValidatesFormatOf < ValidationBase
-    FORMATS = {}
-    
-    include Validatable::Helpers::Formats::Email
-
-    def initialize(klass, attribute, options={})
-      super
-      if with.is_a? Symbol
-        self.with = if FORMATS[with].is_a? Array
-          @message = (FORMATS[with][1].respond_to?(:call) ? FORMATS[with][1].call(attribute) : FORMATS[with][1]) unless @message
-          FORMATS[with][0]
-        else
-          FORMATS[with]
-        end
-      end
-    end
-    
-    def message(instance)
-      super || '%s is invalid'.t(humanized_attribute)
-    end
-
-  end
-
-end

data/lib/data_mapper/validatable_extensions/validations/validates_length_of.rb

@@ -1,15 +0,0 @@
-module Validatable
-  class ValidatesLengthOf < ValidationBase
-     def message(instance)
-       super || unless minimum.nil?
-         '%s must be more than %d characters long'.t(humanized_attribute, minimum-1)
-       else unless maximum.nil?
-         '%s must be less than %d characters long'.t(humanized_attribute, maximum+1)
-       else unless is.nil?
-         '%s must be %d characters long'.t(humanized_attribute, is)
-       else unless within.nil?
-         '%s must be between %d and %d characters long'.t(humanized_attribute, within.first, within.last)
-       end;end;end;end
-     end
-   end
- end

data/lib/data_mapper/validatable_extensions/validations/validates_numericality_of.rb

@@ -1,7 +0,0 @@
-module Validatable
-  class ValidatesNumericalityOf < ValidationBase
-    def message(instance)
-      super || '%s must be a number'.t(humanized_attribute)
-    end
-  end
-end

data/lib/data_mapper/validatable_extensions/validations/validates_presence_of.rb

@@ -1,7 +0,0 @@
-module Validatable
-  class ValidatesPresenceOf < ValidationBase
-    def message(instance)
-      super || "%s must not be blank".t(humanized_attribute)
-    end
-  end
-end

data/lib/data_mapper/validatable_extensions/validations/validates_true_for.rb

@@ -1,7 +0,0 @@
-module Validatable
-  class ValidatesTrueFor < ValidationBase
-    def message(instance)
-      super || '%s must be true'.t(humanized_attribute)
-    end
-  end
-end

data/lib/data_mapper/validatable_extensions/validations/validates_uniqueness_of.rb

@@ -1,40 +0,0 @@
-module Validatable
-  class ValidatesUniquenessOf < ValidationBase
-    option :scope, :allow_nil, :case_sensitive
-
-    def message(instance)
-      super || '%s has already been taken'.t(humanized_attribute)
-    end
-    
-    def case_sensitive?
-      case_sensitive
-    end
-    
-    def valid?(instance)
-      value = instance.send(self.attribute)
-      return true if allow_nil && value.nil?
-      
-      finder_options = if case_sensitive?
-        { self.attribute => value }
-      else
-        { self.attribute.like => value }
-      end
-      
-      if scope 
-        if scope.kind_of?(Array) # if scope is larger than just one property, check them all
-          scope.each do |scope_property|
-            scope_value = instance.send(scope_property)
-            finder_options.merge! scope_property => scope_value
-          end
-        else
-          scope_value = instance.send(scope)
-          finder_options.merge! scope => scope_value
-        end
-      end
-      
-      finder_options.merge!({ instance.database_context.table(instance.class).key.name.not => instance.key }) unless instance.new_record?
-      instance.database_context.first(instance.class, finder_options).nil?
-    end  
-  end
-  
-end

data/lib/data_mapper/validations.rb

@@ -1,20 +0,0 @@
-Dir[File.dirname(__FILE__) + "/validatable_extensions/**/*.rb"].each do |path|
-  require path
-end
-
-#--
-# TODO:
-#   implement alias_option method for all validations (so we can set :with == :as)
-#   make validations orthogonal with allow_nil default to true
-#
-module DataMapper
-  module Validations
-      
-    def self.included(base) #:nodoc:
-      base.class_eval do
-        include Validatable
-      end
-    end
-    
-  end
-end

data/lib/data_mapper/validations/number_validator.rb

@@ -1,40 +0,0 @@
-require 'data_mapper/validations/validator'
-
-module DataMapper 
-  module Validations 
-    class NumberValidator < Validator
-      def <(max)
-        @max_excl = max
-      end
-
-      def <=(max)
-        @max_incl = max
-      end
-
-      def >(min)
-        @min_excl = min
-      end
-
-      def >=(min)
-        @min_incl = min
-      end
-
-      def between(range)
-        @range = range
-      end
-
-      def errors_for(target)
-        errors = []
-        error = nil
-
-        errors << Validator::Error.new(@max_excl, target) if @max_excl && target >= @max_excl
-        errors << Validator::Error.new(@max_incl, target) if @max_incl && target > @max_incl
-        errors << Validator::Error.new(@min_excl, target) if @min_excl && target <= @min_excl
-        errors << Validator::Error.new(@min_incl, target) if @min_incl && target < @min_incl
-        errors << Validator::Error.new(@range, target) if @range && ! @range.include?(target)
-
-        errors
-      end
-    end
-  end
-end

data/lib/data_mapper/validations/string_validator.rb

@@ -1,20 +0,0 @@
-require 'data_mapper/validations/validator'
-
-module DataMapper 
-  module Validations 
-    class StringValidator < Validator
-      def matches(regexp)
-        @regexp = regexp
-      end
-
-      def errors_for(target)
-        errors = []
-
-        errors << Validator::Error.new(@regexp, target) if @regexp && @regexp.match(target)
-
-        errors
-      end
-    end
-  end
-end
-

data/lib/data_mapper/validations/validator.rb

@@ -1,13 +0,0 @@
-module DataMapper 
-  module Validations 
-    class Validator
-      Error = Struct.new(:expected, :got)
-
-      def errors_for(target)
-        raise NotImplementedError.new
-      end
-    end
-  end
-end
-
-

data/performance.rb

@@ -1,307 +0,0 @@
-require 'benchmark'
-require 'active_record'
-
-socket_file = [
-  "/opt/local/var/run/mysql5/mysqld.sock",
-  "tmp/mysqld.sock",
-  "tmp/mysql.sock"
-].find { |path| File.exists?(path) }
-
-configuration_options = {
-  :adapter => 'mysql',
-  :username => 'root',
-  :password => '',
-  :database => 'data_mapper_1'
-}
-
-configuration_options[:socket] = socket_file unless socket_file.nil?
-
-ActiveRecord::Base.establish_connection(configuration_options)
-
-ActiveRecord::Base.find_by_sql('SELECT 1')
-
-class ARAnimal < ActiveRecord::Base #:nodoc:
-  set_table_name 'animals'
-end
-
-class ARPerson < ActiveRecord::Base #:nodoc:
-  set_table_name 'people'
-end
-
-require 'lib/data_mapper'
-
-DataMapper::Database.setup(configuration_options)
-
-class DMAnimal < DataMapper::Base #:nodoc:
-  set_table_name 'animals'
-  property :name, :string
-  property :notes, :text
-end
-
-class DMPerson < DataMapper::Base #:nodoc:
-  set_table_name 'people'
-  property :name, :string
-  property :age, :integer
-  property :occupation, :string
-  property :type, :class
-  property :notes, :text
-  property :date_of_birth, :date
-  
-  embed :address, :prefix => true do
-    property :street, :string
-    property :city, :string
-    property :state, :string, :size => 2
-    property :zip_code, :string, :size => 10
-    
-    def city_state_zip_code
-      "#{city}, #{state} #{zip_code}"
-    end
-    
-    def to_s
-      "#{street}\n#{city_state_zip_code}"
-    end
-  end
-  
-end
-
-class Exhibit < DataMapper::Base #:nodoc:
-  property :name, :string
-  belongs_to :zoo
-end
-
-class Zoo < DataMapper::Base #:nodoc:
-  property :name, :string
-  property :notes, :text
-  has_many :exhibits
-end
-
-class ARZoo < ActiveRecord::Base #:nodoc:
-  set_table_name 'zoos'
-  has_many :exhibits, :class_name => 'ARExhibit', :foreign_key => 'zoo_id'
-end
-
-class ARExhibit < ActiveRecord::Base #:nodoc:
-  set_table_name 'exhibits'
-  belongs_to :zoo, :class_name => 'ARZoo', :foreign_key => 'zoo_id'
-end
-
-N = (ENV['N'] || 1000).to_i
-
-# 4.times do
-#   [DMAnimal, Zoo, Exhibit].each do |klass|
-#     klass.all.each do |instance|
-#       klass.create(instance.attributes.reject { |k,v| k == :id })
-#     end
-#   end
-# end
-
-Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
-  
-  x.report('ActiveRecord:id') do
-    N.times { ARAnimal.find(1).name }
-  end
-  
-  x.report('ActiveRecord:id:raw_result-set') do
-    connection = ARAnimal.connection
-    
-    N.times do
-      result = connection.execute("SELECT name FROM animals WHERE id = 1")
-      result.each do |row|
-        nil
-      end
-      result.free if result.respond_to?(:free)
-    end
-  end
-  
-  x.report('DataMapper:id') do
-    N.times { DMAnimal[1].name }
-  end
-  
-  x.report('DataMapper:id:in-session') do
-    database do
-      N.times { DMAnimal[1].name }
-    end
-  end
-    
-  x.report('DataMapper:id:raw-result-set') do
-    database.adapter.connection do |db|
-      N.times do
-        command = db.create_command("SELECT name FROM animals WHERE id = 1")
-
-        command.execute_reader do |reader|          
-          reader.each { reader.current_row }
-        end
-      end
-    end
-  end
-  
-  x.report('ActiveRecord:all') do
-    N.times { ARZoo.find(:all).each { |a| a.name } }
-  end
-  
-  x.report('DataMapper:all') do
-    N.times { Zoo.all.each { |a| a.name } }
-  end
-  
-  x.report('DataMapper:all:in-session') do
-    database do
-      N.times { Zoo.all.each { |a| a.name } }
-    end
-  end
-  
-  x.report('ActiveRecord:conditions') do
-    N.times { ARZoo.find(:first, :conditions => ['name = ?', 'Galveston']).name }
-  end
-  
-  x.report('DataMapper:conditions:short') do
-    N.times { Zoo.first(:name => 'Galveston').name }
-  end
-  
-  x.report('DataMapper:conditions:short:in-session') do
-    database do
-      N.times { Zoo.first(:name => 'Galveston').name }
-    end
-  end
-  
-  x.report('DataMapper:conditions:long') do
-    N.times { Zoo.find(:first, :conditions => ['name = ?', 'Galveston']).name }
-  end
-  
-  x.report('DataMapper:conditions:long:in-session') do
-    database do
-      N.times { Zoo.find(:first, :conditions => ['name = ?', 'Galveston']).name }
-    end
-  end
-  
-  people = [
-    ['Sam', 29, 'Programmer', 'A slow text field'],
-    ['Amy', 28, 'Business Analyst Manager', 'A slow text field'],
-    ['Scott', 25, 'Programmer', 'A slow text field'],
-    ['Josh', 23, 'Supervisor', 'A slow text field'],
-    ['Bob', 40, 'Peon', 'A slow text field']
-    ]
-
-  DMPerson.truncate!
-  
-  x.report('ActiveRecord:insert') do
-    N.times do
-      people.each do |a|
-        ARPerson::create(:name => a[0], :age => a[1], :occupation => a[2], :notes => a[3])
-      end
-    end
-  end
-  
-  DMPerson.truncate!
-  
-  x.report('DataMapper:insert') do
-    N.times do
-      people.each do |a|
-        DMPerson::create(:name => a[0], :age => a[1], :occupation => a[2], :notes => a[3])
-      end
-    end
-  end
-  
-  x.report('ActiveRecord:update') do
-    N.times do
-      bob = ARAnimal.find(:first, :conditions => ["name = ?", 'Elephant'])
-      bob.name
-      bob.notes = 'Updated by ActiveRecord'
-      bob.save
-    end
-  end
-  
-  x.report('DataMapper:update') do
-    N.times do
-      bob = DMAnimal.first(:name => 'Elephant')
-      bob.name
-      bob.notes = 'Updated by DataMapper'
-      bob.save
-    end
-  end
-  
-  x.report('ActiveRecord:associations:lazy') do
-    N.times do
-      zoos = ARZoo.find(:all)
-      zoos.each { |zoo| zoo.name; zoo.exhibits.entries }
-    end
-  end
-  
-  x.report('ActiveRecord:associations:included') do
-    N.times do
-      zoos = ARZoo.find(:all, :include => [:exhibits])
-      zoos.each { |zoo| zoo.name; zoo.exhibits.entries }
-    end
-  end
-  
-  x.report('DataMapper:associations') do
-    N.times do
-      Zoo.all.each { |zoo| zoo.name; zoo.exhibits.entries }
-    end
-  end
-  
-  x.report('DataMapper:associations:in-session') do
-    database do
-      N.times do
-        Zoo.all.each { |zoo| zoo.name; zoo.exhibits.entries }
-      end
-    end
-  end
-  
-  x.report('ActiveRecord:find_by_sql') do
-    N.times do
-      ARZoo.find_by_sql("SELECT * FROM zoos").each { |z| z.name }
-    end
-  end
-  
-  x.report('DataMapper:find_by_sql') do
-    N.times do
-      database.query("SELECT * FROM zoos").each { |z| z.name }
-    end
-  end
-  
-  x.report('DataMapper:raw-query') do
-    N.times do
-      database.adapter.connection do |db|
-        
-        command = db.create_command("SELECT * FROM zoos")
-      
-        command.execute_reader do |reader|          
-          reader.each { reader.current_row }
-        end
-      end
-    end
-  end
-  
-  x.report('ActiveRecord:accessors') do
-    person = ARPerson.find(:first)
-      
-    N.times do
-      <<-VCARD
-        #{person.name} (#{person.age})
-        #{person.occupation}
-        
-        #{person.address_street}
-        #{person.address_city}, #{person.address_state} #{person.address_zip_code}
-        
-        #{person.notes}
-      VCARD
-    end
-  end
-  
-  x.report('DataMapper:accessors') do
-    person = DMPerson.first
-      
-    N.times do
-      <<-VCARD
-        #{person.name} (#{person.age})
-        #{person.occupation}
-        
-        #{person.address}
-        
-        #{person.notes}
-      VCARD
-    end
-  end
-    
-    
-end