dm-core 0.9.5 → 0.9.6

data/lib/dm-core/transaction.rb

@@ -13,12 +13,12 @@ module DataMapper
     # In fact, it just calls #link with the given arguments at the end of the
     # constructor.
     #
-    def initialize(*things, &block)
+    def initialize(*things)
       @transaction_primitives = {}
       @state = :none
       @adapters = {}
       link(*things)
-      commit(&block) if block_given?
+      commit { |*block_args| yield(*block_args) } if block_given?
     end
 
     #
@@ -39,7 +39,7 @@ module DataMapper
     #   within this transaction. The transaction will begin and commit around
     #   the block, and rollback if an exception is raised.
     #
-    def link(*things, &block)
+    def link(*things)
       raise "Illegal state for link: #{@state}" unless @state == :none
       things.each do |thing|
         if thing.is_a?(Array)
@@ -56,7 +56,7 @@ module DataMapper
           raise "Unknown argument to #{self}#link: #{thing.inspect}"
         end
       end
-      return commit(&block) if block_given?
+      return commit { |*block_args| yield(*block_args) } if block_given?
       return self
     end
 
@@ -83,12 +83,12 @@ module DataMapper
     #   If no block is given, it will simply commit any changes made since the
     #   Transaction did #begin.
     #
-    def commit(&block)
+    def commit
       if block_given?
         raise "Illegal state for commit with block: #{@state}" unless @state == :none
         begin
           self.begin
-          rval = within(&block)
+          rval = within { |*block_args| yield(*block_args) }
           self.commit if @state == :begin
           return rval
         rescue Exception => e
@@ -128,7 +128,7 @@ module DataMapper
     #   adapter it is associated with, and it will ensures that it will pop the
     #   Transaction away again after the block is finished.
     #
-    def within(&block)
+    def within
       raise "No block provided" unless block_given?
       raise "Illegal state for within: #{@state}" unless @state == :begin
       @adapters.each do |adapter, state|

data/lib/dm-core/version.rb

@@ -1,3 +1,3 @@
 module DataMapper
-  VERSION = '0.9.5' unless defined?(DataMapper::VERSION)
+  VERSION = '0.9.6' unless defined?(DataMapper::VERSION)
 end

data/script/performance.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core')
+require File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core', 'version')
 
 require 'rubygems'
 require 'ftools'
@@ -38,11 +39,11 @@ configuration_options[:socket] = socket_file unless socket_file.nil?
 log_dir = DataMapper.root / 'log'
 log_dir.mkdir unless log_dir.directory?
 
-DataMapper::Logger.new(log_dir / 'dm.log', :debug)
+DataMapper::Logger.new(log_dir / 'dm.log', :off)
 adapter = DataMapper.setup(:default, "mysql://root@localhost/data_mapper_1?socket=#{socket_file}")
 
 if configuration_options[:adapter]
-  sqlfile = File.join(File.dirname(__FILE__),'..','tmp','perf.sql')
+  sqlfile = File.join(File.dirname(__FILE__),'..','tmp','performance.sql')
   mysql_bin = %w[mysql mysql5].select{|bin| `which #{bin}`.length > 0 }
   mysqldump_bin = %w[mysqldump mysqldump5].select{|bin| `which #{bin}`.length > 0 }
 end
@@ -54,6 +55,15 @@ ActiveRecord::Base.establish_connection(configuration_options)
 
 class ARExhibit < ActiveRecord::Base #:nodoc:
   set_table_name 'exhibits'
+
+  belongs_to :user, :class_name => 'ARUser', :foreign_key => 'user_id'
+end
+
+class ARUser < ActiveRecord::Base #:nodoc:
+  set_table_name 'users'
+
+  has_many :exhibits, :foreign_key => 'user_id'
+
 end
 
 ARExhibit.find_by_sql('SELECT 1')
@@ -64,17 +74,39 @@ class Exhibit
   property :id,         Serial
   property :name,       String
   property :zoo_id,     Integer
+  property :user_id,    Integer
   property :notes,      Text, :lazy => true
   property :created_on, Date
+
+  belongs_to :user
 #  property :updated_at, DateTime
 end
 
+class User
+  include DataMapper::Resource
+
+  property :id,    Serial
+  property :name,  String
+  property :email, String
+  property :about, Text, :lazy => true
+  property :created_on, Date
+
+end
+
 touch_attributes = lambda do |exhibits|
   [*exhibits].each do |exhibit|
     exhibit.id
     exhibit.name
     exhibit.created_on
-#    exhibit.updated_at
+  end
+end
+
+touch_relationships = lambda do |exhibits|
+  [*exhibits].each do |exhibit|
+    exhibit.id
+    exhibit.name
+    exhibit.created_on
+    exhibit.user
   end
 end
 
@@ -87,27 +119,49 @@ if sqlfile && File.exists?(sqlfile)
   `#{mysql_bin} -u #{c[:username]} #{"-p#{c[:password]}" unless c[:password].blank?} #{c[:database]} < #{sqlfile}`
 else
 
+  puts "Generating data for benchmarking..."
+
+  User.auto_migrate!
   Exhibit.auto_migrate!
 
+  users = []
   exhibits = []
+
   # pre-compute the insert statements and fake data compilation,
   # so the benchmarks below show the actual runtime for the execute
   # method, minus the setup steps
-  10_000.times do
+
+  # Using the same paragraph for all exhibits because it is very slow
+  # to generate unique paragraphs for all exhibits.
+  paragraph = Faker::Lorem.paragraphs.join($/)
+
+  10_000.times do |i|
+    users << [
+      'INSERT INTO `users` (`name`,`email`,`created_on`) VALUES (?, ?, ?)',
+      Faker::Name.name,
+      Faker::Internet.email,
+      Date.today
+    ]
+
     exhibits << [
-      'INSERT INTO `exhibits` (`name`, `zoo_id`, `notes`, `created_on`) VALUES (?, ?, ?, ?)',
+      'INSERT INTO `exhibits` (`name`, `zoo_id`, `user_id`, `notes`, `created_on`) VALUES (?, ?, ?, ?, ?)',
       Faker::Company.name,
       rand(10).ceil,
-      Faker::Lorem.paragraphs.join($/),
+      i,
+      paragraph,#Faker::Lorem.paragraphs.join($/),
       Date.today
     ]
   end
+
+  puts "Inserting 10,000 users..."
+  10_000.times { |i| adapter.execute(*users.at(i)) }
+  puts "Inserting 10,000 exhibits..."
   10_000.times { |i| adapter.execute(*exhibits.at(i)) }
 
   if sqlfile
     answer = nil
     until answer && answer[/^$|y|yes|n|no/]
-      print("Would you like to dump data into tmp/perf.sql (for faster setup)? [Yn]");
+      print("Would you like to dump data into tmp/performance.sql (for faster setup)? [Yn]");
       STDOUT.flush
       answer = gets
     end
@@ -115,7 +169,7 @@ else
     if answer[/^$|y|yes/]
       File.makedirs(File.dirname(sqlfile))
       #adapter.execute("SELECT * INTO OUTFILE '#{sqlfile}' FROM exhibits;")
-      `#{mysqldump_bin} -u #{c[:username]} #{"-p#{c[:password]}" unless c[:password].blank?} #{c[:database]} exhibits > #{sqlfile}`
+      `#{mysqldump_bin} -u #{c[:username]} #{"-p#{c[:password]}" unless c[:password].blank?} #{c[:database]} exhibits users > #{sqlfile}`
       puts "File saved\n"
     end
   end
@@ -127,37 +181,63 @@ TIMES = ENV['x'] ? ENV['x'].to_i : 10_000
 puts "You can specify how many times you want to run the benchmarks with rake:perf x=(number)"
 puts "Some tasks will be run 10 and 1000 times less than (number)"
 puts "Benchmarks will now run #{TIMES} times"
+# Inform about slow benchmark
+# answer = nil
+# until answer && answer[/^$|y|yes|n|no/]
+#   print("A slow benchmark exposing problems with SEL is newly added. It takes approx. 20s\n");
+#   print("you have scheduled it to run #{TIMES / 100} times.\nWould you still include the particular benchmark? [Yn]")
+#   STDOUT.flush
+#   answer = gets
+# end
+# run_rel_bench = answer[/^$|y|yes/] ? true : false
+
 
 RBench.run(TIMES) do
 
   column :times
-  column :dm, :title => "DM 0.9.4"
   column :ar, :title => "AR 2.1"
-  column :diff, :compare => [:dm,:ar]
+  column :dm, :title => "DM #{DataMapper::VERSION}"
+  column :diff, :compare => [:ar,:dm]
+
+  report "Model.new (instantiation)" do
+    ar { ARExhibit.new }
+    dm { Exhibit.new }
+  end
+
+  report "Model.new (setting attributes)" do
+    attrs = {:name => 'sam', :zoo_id => 1}
+    ar { ARExhibit.new(attrs) }
+    dm { Exhibit.new(attrs) }
+  end
 
   report "Model.get specific (not cached)" do
-    dm { touch_attributes[Exhibit.get(1)] }
     ActiveRecord::Base.uncached { ar { touch_attributes[ARExhibit.find(1)] } }
+    dm { touch_attributes[Exhibit.get(1)] }
   end
 
   report "Model.get specific (cached)" do
-    Exhibit.repository(:default) { dm { touch_attributes[Exhibit.get(1)]    } }
     ActiveRecord::Base.cache    { ar { touch_attributes[ARExhibit.find(1)] } }
+    Exhibit.repository(:default) { dm { touch_attributes[Exhibit.get(1)] } }
   end
 
   report "Model.first" do
-    dm { touch_attributes[Exhibit.first]   }
     ar { touch_attributes[ARExhibit.first] }
+    dm { touch_attributes[Exhibit.first] }
   end
 
-  report "Model.all limit(100)", TIMES / 10 do
-    dm { touch_attributes[Exhibit.all(:limit => 100)] }
+  report "Model.all limit(100)", (TIMES / 10.0).ceil do
     ar { touch_attributes[ARExhibit.find(:all, :limit => 100)] }
+    dm { touch_attributes[Exhibit.all(:limit => 100)] }
   end
 
-  report "Model.all limit(10,000)", TIMES / 1000 do
-    dm { touch_attributes[Exhibit.all(:limit => 10_000)] }
+  report "Model.all limit(100) with relationship", (TIMES / 10.0).ceil do
+    ar { touch_relationships[ARExhibit.all(:limit => 100, :include => [:user])] }
+    dm { touch_relationships[Exhibit.all(:limit => 100)] }
+  end
+
+  report "Model.all limit(10,000)", (TIMES / 1000.0).ceil do
     ar { touch_attributes[ARExhibit.find(:all, :limit => 10_000)] }
+    dm { touch_attributes[Exhibit.all(:limit => 10_000)] }
   end
 
   create_exhibit = {
@@ -168,25 +248,37 @@ RBench.run(TIMES) do
   }
 
   report "Model.create" do
-    dm { Exhibit.create(create_exhibit)   }
     ar { ARExhibit.create(create_exhibit) }
+    dm { Exhibit.create(create_exhibit) }
+  end
+
+  report "Resource#attributes" do
+    attrs_first  = {:name => 'sam', :zoo_id => 1}
+    attrs_second = {:name => 'tom', :zoo_id => 1}
+    ar { e = ARExhibit.new(attrs_first); e.attributes = attrs_second }
+    dm { e = Exhibit.new(attrs_first); e.attributes = attrs_second }
   end
 
   report "Resource#update" do
-    dm { e = Exhibit.get(1); e.name = 'bob'; e.save   }
-    ar { e = ARExhibit.find(1); e.name = 'bob'; e.save  }
+    ar { e = ARExhibit.find(1); e.name = 'bob'; e.save }
+    dm { e = Exhibit.get(1); e.name = 'bob'; e.save }
   end
 
   report "Resource#destroy" do
-    dm { Exhibit.first.destroy }
     ar { ARExhibit.first.destroy }
+    dm { Exhibit.first.destroy }
   end
 
-  summary "Total"
+  report "Model.transaction" do
+    ar { ARExhibit.transaction { ARExhibit.new } }
+    dm { Exhibit.transaction { Exhibit.new } }
+  end
 
+  summary "Total"
 end
 
 connection = adapter.send(:create_connection)
 command = connection.create_command("DROP TABLE exhibits")
+command = connection.create_command("DROP TABLE users")
 command.execute_non_query rescue nil
 connection.close

data/spec/integration/association_spec.rb

@@ -302,6 +302,18 @@ if ADAPTER
         area.should respond_to(:machine=)
       end
 
+      it 'should create the foreign key property immediately' do
+        class Duck
+          include DataMapper::Resource
+          property :id, Serial
+          belongs_to :sky
+        end
+        Duck.properties.slice(:sky_id).compact.should_not be_empty
+        duck = Duck.new
+        duck.should respond_to(:sky_id)
+        duck.should respond_to(:sky_id=)
+      end
+
       it 'should load without the parent'
 
       it 'should allow substituting the parent' do
@@ -331,7 +343,7 @@ if ADAPTER
             end
           end
 
-          FlightlessBirds::Ostrich.properties.slice(:sky_id).should_not be_empty
+          FlightlessBirds::Ostrich.properties(ADAPTER).slice(:sky_id).compact.should_not be_empty
         end
       end
 
@@ -571,6 +583,15 @@ if ADAPTER
         machine.areas.size.should == 4
       end
 
+      it "#build should add exactly one instance of the built record" do
+        machine = Machine.create(:name => 'my machine')
+
+        original_size = machine.areas.size
+        machine.areas.build(:name => "an area", :machine => machine)
+
+        machine.areas.size.should == original_size + 1
+      end
+
       it '#<< should add default values for relationships that have conditions' do
         # it should add default values
         machine = Machine.new(:name => 'my machine')
@@ -1169,8 +1190,16 @@ if ADAPTER
       #
 
       it 'should join tables in the right order during has 1 => has n => has 1 queries' do
-        child = Sweets::Shop.first.children(:name => 'Snotling nr 3').booger(:name.like => 'ooger')
+        child = Sweets::Shop.first.children(:name => 'Snotling nr 3').booger(:name.like => 'Nasty booger')
         child.should_not be_nil
+        child.size.should eql(1)
+        child.first.name.should eql("Nasty booger")
+      end
+
+      it 'should join tables in the right order for belongs_to relations' do
+        wife = Sweets::Wife.first(Sweets::Wife.shop_owner.name => "Betsy", Sweets::Wife.shop_owner.shop.name => "Betsy's")
+        wife.should_not be_nil
+        wife.name.should eql("Barry")
       end
 
       it 'should raise exception if you try to change it' do

data/spec/integration/association_through_spec.rb

@@ -50,10 +50,12 @@ if ADAPTER
           has n, :relationships
           has n, :related_posts,
                  :through    => :relationships,
+                 :child_key => [:post_id],
                  :class_name => "Post"
 
           has n, :void_tags,
                  :through => :taggings,
+                 :child_key => [:post_id],
                  :class_name => "Tag",
                  :remote_relationship_name => :tag,
                  Post.taggings.tag.voided => true

data/spec/integration/associations/many_to_many_spec.rb

@@ -294,4 +294,156 @@ describe DataMapper::Associations::ManyToMany::Proxy do
     end
   end
 
+  describe "with renamed associations" do
+    before :all do
+      class Singer
+        include DataMapper::Resource
+
+        def self.default_repository_name; ADAPTER end
+
+        property :id, Serial
+        property :name, String
+
+        has n, :tunes, :through => Resource, :class_name => 'Song'
+      end
+
+      class Song
+        include DataMapper::Resource
+
+        def self.default_repository_name; ADAPTER end
+
+        property :id, Serial
+        property :title, String
+
+        has n, :performers, :through => Resource, :class_name => 'Singer'
+      end
+    end
+
+    before do
+      [ Singer, Song, SingerSong ].each { |k| k.auto_migrate! }
+
+      song_1 = Song.create(:title => "Dubliners")
+      song_2 = Song.create(:title => "Portrait of the Artist as a Young Man")
+      song_3 = Song.create(:title => "Ulysses")
+
+      singer_1 = Singer.create(:name => "Jon Doe")
+      singer_2 = Singer.create(:name => "Jane Doe")
+
+      SingerSong.create(:song => song_1, :singer => singer_1)
+      SingerSong.create(:song => song_2, :singer => singer_1)
+      SingerSong.create(:song => song_1, :singer => singer_2)
+
+      @parent      = song_3
+      @association = @parent.performers
+      @other       = [ singer_1 ]
+    end
+
+    it "should provide #replace" do
+      @association.should respond_to(:replace)
+    end
+
+    it "should correctly link records" do
+      Song.get(1).should have(2).performers
+      Song.get(2).should have(1).performers
+      Song.get(3).should have(0).performers
+      Singer.get(1).should have(2).tunes
+      Singer.get(2).should have(1).tunes
+    end
+
+    it "should be able to have associated objects manually added" do
+      song = Song.get(3)
+      song.should have(0).performers
+
+      be = SingerSong.new(:song_id => song.id, :singer_id => 2)
+      song.singer_songs << be
+      song.save
+
+      song.reload.should have(1).performers
+    end
+
+    it "should automatically added necessary through class" do
+      song = Song.get(3)
+      song.should have(0).performers
+
+      song.performers << Singer.get(1)
+      song.performers << Singer.new(:name => "Jimmy John")
+      song.save
+
+      song.reload.should have(2).performers
+    end
+
+    it "should react correctly to a new record" do
+      song = Song.new(:title => "Finnegan's Wake")
+      singer = Singer.get(2)
+      song.should have(0).performers
+      singer.should have(1).tunes
+
+      song.performers << singer
+      song.save
+
+      song.reload.should have(1).performers
+      singer.reload.should have(2).tunes
+    end
+
+    it "should be able to delete intermediate model" do
+      song = Song.get(1)
+      song.should have(2).singer_songs
+      song.should have(2).performers
+
+      be = SingerSong.get(1,1)
+      song.singer_songs.delete(be)
+      song.save
+
+      song.reload
+      song.should have(1).singer_songs
+      song.should have(1).performers
+    end
+
+    it "should be clearable" do
+      repository(ADAPTER) do
+        song = Song.get(2)
+        song.should have(1).singer_songs
+        song.should have(1).performers
+
+        song.performers.clear
+        song.save
+
+        song.reload
+        song.should have(0).singer_songs
+        song.should have(0).performers
+      end
+      repository(ADAPTER) do
+        Song.get(2).should have(0).performers
+      end
+    end
+
+    it "should be able to delete one object" do
+      song = Song.get(1)
+      song.should have(2).singer_songs
+      song.should have(2).performers
+
+      editor = song.performers.first
+      song.performers.delete(editor)
+      song.save
+
+      song.reload
+      song.should have(1).singer_songs
+      song.should have(1).performers
+      editor.reload.tunes.should_not include(song)
+    end
+
+    it "should be destroyable" do
+      pending "cannot destroy a collection yet" do
+        song = Song.get(2)
+        song.should have(1).performers
+
+        song.performers.destroy
+        song.save
+
+        song.reload
+        song.should have(0).performers
+      end
+    end
+  end
+
 end