datamapper 0.1.1 → 0.2.0

data/lib/data_mapper/embedded_value.rb

@@ -0,0 +1,65 @@
+module DataMapper
+  
+  class EmbeddedValue
+    
+    def initialize(instance)
+      @instance = instance
+    end
+    
+    def self.property(name, type, options = {})
+      mapping = database.schema[containing_class].add_column(name, type, options)
+      define_property_getter(name, mapping)
+      define_property_setter(name, mapping)
+    end
+    
+    def self.define_property_getter(name, mapping)
+      class_eval <<-EOS
+        def #{name}
+          @instance.instance_variable_get(#{mapping.instance_variable_name.inspect})
+        end
+      EOS
+    end
+    
+    def self.define_property_setter(name, mapping)
+      class_eval <<-EOS
+        def #{name.to_s.sub(/\?$/, '')}=(value)
+          @instance.instance_variable_set(#{mapping.instance_variable_name.inspect}, value)
+        end
+      EOS
+    end
+    
+    def self.containing_class
+      @containing_class || @containing_class = begin
+        tree = name.split('::')
+        tree.pop
+        tree.inject(Object) { |klass, current| klass.const_get(current) }
+      end
+    end
+    
+    def self.define(container, class_or_name, &block)
+       embedded_class, embedded_class_name, accessor_name = nil
+
+      if class_or_name.kind_of?(Class)
+        embedded_class = class_or_name
+        embedded_class_name = class_or_name.name.split('::').last
+        accessor_name = Inflector.underscore(embedded_class_name)
+      else
+        accessor_name = class_or_name.to_s
+        embedded_class_name = Inflector.camelize(accessor_name)
+        embedded_class = Class.new(EmbeddedValue)
+        container.const_set(embedded_class_name, embedded_class) unless container.const_defined?(embedded_class_name)
+      end
+
+      embedded_class.instance_variable_set('@containing_class', container)
+      embedded_class.class_eval(&block) if block_given?
+
+      container.class_eval <<-EOS
+        def #{accessor_name}
+          #{embedded_class_name}.new(self)
+        end
+      EOS
+    end
+    
+  end
+  
+end # module DataMapper

data/lib/data_mapper/identity_map.rb

@@ -15,7 +15,7 @@ module DataMapper
     # Pass a Class and a key, and to retrieve an instance.
     # If the instance isn't found, nil is returned.
     def get(klass, key)
-      @cache[klass][key]
+      @cache[mapped_class(klass)][key]
     end
 
     # Pass an instance to add it to the IdentityMap.
@@ -23,13 +23,13 @@ module DataMapper
     def set(instance)
       instance_key = instance.key
       raise "Can't store an instance with a nil key in the IdentityMap" if instance_key.nil?
-        
-      @cache[instance.class][instance_key] = instance
+      
+      @cache[mapped_class(instance.class)][instance_key] = instance
     end
     
     # Remove an instance from the IdentityMap.
     def delete(instance)
-      @cache[instance.class].delete(instance.key)
+      @cache[mapped_class(instance.class)].delete(instance.key)
     end
     
     # Clears a particular set of classes from the IdentityMap.
@@ -37,5 +37,13 @@ module DataMapper
       @cache.delete(klass)
     end
     
+    private
+    def mapped_class(klass)      
+      if klass.superclass == DataMapper::Base
+        klass
+      else
+        mapped_class(klass.superclass)
+      end
+    end
   end
 end

data/lib/data_mapper/support/active_record_impersonation.rb

@@ -29,12 +29,16 @@ module DataMapper
           first(search_attributes) || create(search_attributes.merge(create_attributes))
         end
         
-        def all(options = {}, &b)
-          database.all(self, options, &b)
+        def all(options = {})
+          database.all(self, options)
         end
         
-        def first(*args, &b)
-          database.first(self, *args, &b)
+        def first(*args)
+          database.first(self, *args)
+        end
+        
+        def count(*args)
+          database.count(self, *args)
         end
         
         def delete_all
@@ -45,11 +49,11 @@ module DataMapper
           database.truncate(self)
         end
         
-        def find(type_or_id, options = {}, &b)
+        def find(type_or_id, options = {})
           case type_or_id
-            when :first then first(options, &b)
-            when :all then all(options, &b)
-            else first(type_or_id, options, &b)
+            when :first then first(options)
+            when :all then all(options)
+            else first(type_or_id, options)
           end
         end
         

data/lib/data_mapper/support/enumerable.rb

@@ -1,5 +1,13 @@
 module DataMapper
+  # The Support module adds functionality to Make Things Easier(tm):
+  # * grouping by attributes of objects in an array (returns a hash, see #DataMapper::Support::Enumerable)
+  # * adds symbols for operators like <= (lte), like, in, select, etc (see #DataMapper::Support::Symbol)
+  # * adds methods for strings, allowing us to ensure strings are wrapped with content (see #DataMapper::Support::String)
+  # * pulls in ActiveSupport's Inflector module
+  # * loads #DataMapper::Database and #DataMapper::Base
   module Support
+    
+    # Extends Array to include an instance method for grouping objects
     module Enumerable
       
       # Group a collection of elements into groups within a

data/lib/data_mapper/support/serialization.rb

@@ -0,0 +1,13 @@
+module DataMapper
+  module Support
+    module Serialization
+      
+      def to_yaml
+        document = {}
+        attributes.each_pair { |k,v| document[k.to_s] = v }
+        document.to_yaml
+      end
+      
+    end
+  end # module Support
+end # module DataMapper

data/lib/data_mapper/support/string.rb

@@ -35,16 +35,5 @@ module DataMapper
 end # module DataMapper
 
 class String #:nodoc:
-  include DataMapper::Support::String
-  
-  def self.fragile_underscore(camel_cased_word)
-    camel_cased_word.gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
-  end
-  
-  @underscore_cache = Hash.new { |h,k| h[k.freeze] = fragile_underscore(k) }
-  
-  def self.memoized_underscore(camel_cased_word)
-    @underscore_cache[camel_cased_word]
-  end
-  
+  include DataMapper::Support::String  
 end

data/lib/data_mapper/support/symbol.rb

@@ -1,5 +1,7 @@
 module DataMapper
   module Support
+    
+    # Extends 
     module Symbol
       
       class Operator
@@ -76,6 +78,7 @@ module DataMapper
       def avg
         Operator.new(self, :avg)
       end
+      
       alias average avg
   
       def min

data/lib/data_mapper/validations/unique_validator.rb

@@ -35,8 +35,7 @@ module DataMapper
           finder_options.merge! @options[:scope] => scope_value
         end
         
-        finder_options.merge!({ target.session.mappings[target.class].key.name.not => target.key }) unless target.new_record?
-        
+        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
       

data/lib/data_mapper/validations/validation_helper.rb

@@ -31,7 +31,24 @@ module DataMapper
       end
       
       def valid?(context = :general)
-        self.class.validations.execute(context, self)
+        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

data/performance.rb

@@ -1,11 +1,13 @@
+require 'benchmark'
 require 'active_record'
 
 ActiveRecord::Base.establish_connection :adapter => 'mysql',
-  :host     => 'localhost',
   :username => 'root',
   :password => '',
   :database => 'data_mapper_1'
-      
+
+ActiveRecord::Base.find_by_sql('SELECT 1')
+
 class ARAnimal < ActiveRecord::Base
   set_table_name 'animals'
 end
@@ -16,21 +18,16 @@ end
 
 require 'lib/data_mapper'
 
-log_path = File.dirname(__FILE__) + '/development.log'
-
-require 'fileutils'
-FileUtils::rm log_path if File.exists?(log_path)
-
-DataMapper::Database.setup do
-  adapter   'mysql'
-  database 'data_mapper_1'
-  username 'root'
-end
+DataMapper::Database.setup({
+  :adapter => 'mysql',
+  :database => 'data_mapper_1',
+  :username => 'root'
+})
 
 class DMAnimal < DataMapper::Base
   set_table_name 'animals'
   property :name, :string
-  property :notes, :string, :lazy => true
+  property :notes, :string
 end
 
 class DMPerson < DataMapper::Base
@@ -38,7 +35,11 @@ class DMPerson < DataMapper::Base
   property :name, :string
   property :age, :integer
   property :occupation, :string
-  property :notes, :text, :lazy => true
+  property :notes, :text
+  property :street, :string
+  property :city, :string
+  property :state, :string, :size => 2
+  property :zip_code, :string, :size => 10
 end
 
 class Exhibit < DataMapper::Base
@@ -63,42 +64,74 @@ 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) }
+    N.times { ARAnimal.find(1).name }
   end
   
   x.report('DataMapper:id') do
-    N.times { DMAnimal[1] }
+    N.times { DMAnimal[1].name }
+  end
+  
+  x.report('DataMapper:id:in-session') do
+    database do
+      N.times { DMAnimal[1].name }
+    end
   end
   
   x.report('ActiveRecord:all') do
-    N.times { ARAnimal.find(:all) }
+    N.times { ARAnimal.find(:all).each { |a| a.name } }
   end
   
   x.report('DataMapper:all') do
-    N.times { DMAnimal.all }
+    N.times { DMAnimal.all.each { |a| a.name } }
+  end
+  
+  x.report('DataMapper:all:in-session') do
+    database do
+      N.times { DMAnimal.all.each { |a| a.name } }
+    end
   end
   
   x.report('ActiveRecord:conditions') do
-    N.times { ARZoo.find(:first, :conditions => ['name = ?', 'Galveston']) }
+    N.times { ARZoo.find(:first, :conditions => ['name = ?', 'Galveston']).name }
   end
   
   x.report('DataMapper:conditions:short') do
-    N.times { Zoo[:name => 'Galveston'] }
+    N.times { Zoo[:name => 'Galveston'].name }
+  end
+  
+  x.report('DataMapper:conditions:short:in-session') do
+    database do
+      N.times { Zoo[:name => 'Galveston'].name }
+    end
   end
   
   x.report('DataMapper:conditions:long') do
-    N.times { Zoo.find(:first, :conditions => ['name = ?', 'Galveston']) }
+    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'],
-    ['Amy', 28, 'Business Analyst Manager'],
-    ['Scott', 25, 'Programmer'],
-    ['Josh', 23, 'Supervisor'],
-    ['Bob', 40, 'Peon']
+    ['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!
@@ -106,7 +139,7 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
   x.report('ActiveRecord:insert') do
     N.times do
       people.each do |a|
-        ARPerson::create(:name => a[0], :age => a[1], :occupation => a[2])
+        ARPerson::create(:name => a[0], :age => a[1], :occupation => a[2], :notes => a[3])
       end
     end
   end
@@ -116,7 +149,7 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
   x.report('DataMapper:insert') do
     N.times do
       people.each do |a|
-        DMPerson::create(:name => a[0], :age => a[1], :occupation => a[2])
+        DMPerson::create(:name => a[0], :age => a[1], :occupation => a[2], :notes => a[3])
       end
     end
   end
@@ -124,6 +157,7 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
   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
@@ -132,6 +166,7 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
   x.report('DataMapper:update') do
     N.times do
       bob = DMAnimal.first(:name => 'Elephant')
+      bob.name
       bob.notes = 'Updated by DataMapper'
       bob.save
     end
@@ -140,34 +175,74 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
   x.report('ActiveRecord:associations:lazy') do
     N.times do
       zoos = ARZoo.find(:all)
-      zoos.each { |zoo| zoo.exhibits.entries }
+      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.exhibits.entries }
+      zoos.each { |zoo| zoo.name; zoo.exhibits.entries }
     end
   end
   
   x.report('DataMapper:associations') do
     N.times do
-      database do
-        Zoo.all.each { |zoo| zoo.exhibits.entries }
+      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")
+      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")
+      database.query("SELECT * FROM zoos").each { |z| z.name }
+    end
+  end
+  
+  x.report('ActiveRecord:accessors') do
+    person = ARPerson.find(:first)
+      
+    N.times do
+      <<-VCARD
+        #{person.name} (#{person.age})
+        #{person.occupation}
+        
+        #{person.street}
+        #{person.city}, #{person.state} #{person.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.street}
+        #{person.city}, #{person.state} #{person.zip_code}
+        
+        #{person.notes}
+      VCARD
     end
   end
+    
+    
 end