datamapper 0.2.5 → 0.3.0

data/do_performance.rb

@@ -1,153 +0,0 @@
-require 'benchmark'
-require 'lib/data_mapper'
-
-DataMapper::Database.setup({
-  :adapter => 'do_mysql',
-  :database => 'data_mapper_1',
-  :username => 'root'
-})
-
-class DMAnimal < DataMapper::Base
-  set_table_name 'animals'
-  property :name, :string
-  property :notes, :string
-end
-
-class DMPerson < DataMapper::Base
-  set_table_name 'people'
-  property :name, :string
-  property :age, :integer
-  property :occupation, :string
-  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
-  property :name, :string
-  belongs_to :zoo
-end
-
-class Zoo < DataMapper::Base
-  property :name, :string
-  has_many :exhibits
-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('DataMapper:id') do
-    N.times { DMAnimal[1] }
-  end
-  
-  x.report('DataMapper:id:in-session') do
-    database do
-      N.times { DMAnimal[1] }
-    end
-  end
-  
-  x.report('DataMapper:all') do
-    N.times { DMAnimal.all }
-  end
-  
-  x.report('DataMapper:all:in-session') do
-    database do
-      N.times { DMAnimal.all }
-    end
-  end
-  
-  x.report('DataMapper:conditions:short') do
-    N.times { Zoo[:name => 'Galveston'] }
-  end
-  
-  x.report('DataMapper:conditions:short:in-session') do
-    database do
-      N.times { Zoo[:name => 'Galveston'] }
-    end
-  end
-  
-  x.report('DataMapper:conditions:long') do
-    N.times { Zoo.find(:first, :conditions => ['name = ?', 'Galveston']) }
-  end
-  
-  x.report('DataMapper:conditions:long:in-session') do
-    database do
-      N.times { Zoo.find(:first, :conditions => ['name = ?', 'Galveston']) }
-    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('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('DataMapper:update') do
-    N.times do
-      bob = DMAnimal.first(:name => 'Elephant')
-      bob.notes = 'Updated by DataMapper'
-      bob.save
-    end
-  end
-  
-  x.report('DataMapper:associations') do
-    N.times do
-      Zoo.all.each { |zoo| zoo.exhibits.entries }
-    end
-  end
-  
-  x.report('DataMapper:associations:in-session') do
-    database do
-      N.times do
-        Zoo.all.each { |zoo| zoo.exhibits.entries }
-      end
-    end
-  end
-  
-  x.report('DataMapper:find_by_sql') do
-    N.times do
-      database.query("SELECT * FROM zoos")
-    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

data/lib/data_mapper/support/active_record_impersonation.rb

@@ -1,103 +0,0 @@
-module DataMapper
-  module Support
-    
-    module ActiveRecordImpersonation
-      
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      def save
-        database_context.save(self)
-      end
-      
-      def reload!
-        database_context.first(self.class, key, :select => original_values.keys, :reload => true)
-        self.loaded_associations.each { |association| association.reload! }
-        self
-      end
-      
-      def reload
-        reload!
-      end
-      
-      def destroy!
-        database_context.destroy(self)
-      end
-      
-      module ClassMethods
-        
-        def find_or_create(search_attributes, create_attributes = {})
-          first(search_attributes) || create(search_attributes.merge(create_attributes))
-        end
-        
-        def all(options = {})
-          database.all(self, options)
-        end
-        
-        def each(options = {}, &b)
-          raise ArgumentError.new(":offset is not supported with the #each method") if options.has_key?(:offset)
-
-          offset = 0
-          limit = options[:limit] || (self::const_defined?('DEFAULT_LIMIT') ? self::DEFAULT_LIMIT : 500)
-
-          until (results = all(options.merge(:limit => limit, :offset => offset))).empty?
-            results.each(&b)
-            offset += limit
-          end
-        end
-        
-        def first(*args)
-          database.first(self, *args)
-        end
-        
-        def count(*args)
-          database.count(self, *args)
-        end
-        
-        def delete_all
-          database.delete_all(self)
-        end
-        
-        def truncate!
-          database.truncate(self)
-        end
-        
-        def find(type_or_id, options = {})
-          case type_or_id
-            when :first then first(options)
-            when :all then all(options)
-            else first(type_or_id, options)
-          end
-        end
-        
-        def find_by_sql(*args)
-          DataMapper::database.query(*args)
-        end
-        
-        def get(*keys)
-          database.get(self, keys)
-        end
-        
-        def [](*keys)
-          raise ArgumentError.new('Hash is not a valid key') if keys.size == 1 && keys.first.is_a?(Hash)
-          database.get(self, keys)
-        end
-        
-        def create(attributes)
-          instance = self.new(attributes)
-          instance.save
-          instance
-        end
-        
-        def create!(attributes)
-          instance = self.new(attributes)
-          instance.save
-          raise InvalidRecord.new(instance) if instance.new_record?
-          instance
-        end
-      end
-    end
-    
-  end
-end

data/lib/data_mapper/support/weak_hash.rb

@@ -1,46 +0,0 @@
-module DataMapper
-  module Support
-    class WeakHash
-      attr_reader :cache
-      def initialize( cache = Hash.new )
-        @cache = cache
-        @key_map = {}
-        @rev_cache = Hash.new{|h,k| h[k] = {}}
-        @reclaim_value = lambda do |value_id| 
-          if @rev_cache.has_key? value_id
-            @rev_cache[value_id].each_key{|key| @cache.delete key}
-            @rev_cache.delete value_id
-          end
-        end
-        @reclaim_key = lambda do |key_id|
-          if @key_map.has_key? key_id
-            @cache.delete @key_map[key_id]
-          end
-        end
-      end
-
-     def []( key )
-       value_id = @cache[key]
-       return ObjectSpace._id2ref(value_id) unless value_id.nil?
-       nil
-     rescue RangeError
-       nil
-     end
-
-     def []=( key, value )
-       case key
-       when Fixnum, Symbol, true, false
-         key2 = key
-       else
-         key2 = key.dup
-       end
-       @rev_cache[value.object_id][key2] = true
-       @cache[key2] = value.object_id
-       @key_map[key.object_id] = key2
-
-       ObjectSpace.define_finalizer(value, @reclaim_value)
-       ObjectSpace.define_finalizer(key, @reclaim_key)
-     end
-   end # class WeakHash
- end # module Support
-end # module DataMapper

data/spec/active_record_impersonation_spec.rb

@@ -1,129 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe DataMapper::Support::ActiveRecordImpersonation do
-  
-  before(:all) do
-    fixtures(:animals)
-    fixtures(:exhibits)
-  end
-  
-  describe 'A record' do
-    it 'should save and return true if validations pass' do
-      count = Exhibit.count
-      bugs_and_more_bugs = Exhibit.new(:name => 'Bugs And More Bugs')
-      bugs_and_more_bugs.save.should be_true
-      Exhibit.count.should == count + 1
-    end
-
-    it 'should return false on save if validations fail' do
-      count = Exhibit.count
-      bugs_and_more_bugs = Exhibit.new
-      bugs_and_more_bugs.save.should be_false
-      Exhibit.count.should == count
-    end
-
-    it 'should reload its attributes' do
-      frog = Animal.first(:name => 'Frog')
-      frog.name = 'MegaFrog'
-      frog.name.should == 'MegaFrog'
-      frog.reload!
-      frog.name.should == 'Frog'
-    end
-    
-    it "should prepare it's associations for reload" do
-      chippy = Animal.first(:name => 'Cup')
-      amazonia = Exhibit.first(:name => 'Amazonia')
-      amazonia.animals << chippy
-      amazonia.animals.should include(chippy)
-      amazonia.reload!
-      amazonia.animals.should_not include(chippy)
-    end
-
-    it 'should be destroyed!' do
-      capybara = Animal.create(:name => 'Capybara')
-      count = Animal.count
-      capybara.destroy!
-      Animal.first(:name => 'Capybara').should be_nil
-      Animal.count.should == count - 1
-    end
-  end
-
-  it 'should return the first match using find_or_create' do
-    count = Animal.count
-    frog = Animal.find_or_create(:name => 'Frog')
-    frog.name.should == 'Frog'
-    Animal.count.should == count
-  end
-
-  it 'should create a record if a match is not found with find_or_create' do
-    count = Animal.count
-    capybara = Animal.find_or_create(:name => 'Capybara')
-    capybara.name.should == 'Capybara'
-    Animal.count.should == count + 1
-  end
-
-  it 'should return all records' do
-    all_animals = Animal.all
-    all_animals.length.should == Animal.count
-    all_animals.each do |animal|
-      animal.class.should == Animal
-    end
-  end
-
-  it 'should return the first record' do
-    Animal.first.should == Animal.find(:first)
-  end
-
-  it 'should return a count of the records' do
-    Animal.count.should == Animal.find_by_sql("SELECT COUNT(*) FROM animals")[0]
-  end
-
-  it 'should delete all records' do
-    Animal.delete_all
-    Animal.count.should == 0
-
-    fixtures(:animals)
-  end
-
-  #it 'should be truncated' do
-  #  Animal.truncate!
-  #  Animal.count.should == 0
-  #
-  #  fixtures(:animals)
-  #end
-
-  it 'should find a matching record given an id' do
-    Animal.find(1).name.should == 'Frog'
-  end
-
-  it 'should find all records' do
-    Animal.find(:all).length.should == Animal.count
-  end
-
-  it 'should find all matching records given some condition' do
-    Animal.find(:all, :conditions => ["name = ?", "Frog"])[0].name.should == 'Frog'
-  end
-
-  it 'should find the first matching record' do
-    Animal.find(:first).name.should == 'Frog'
-  end
-
-  it 'should find the first matching record given some condition' do
-    Animal.find(:first, :conditions => ["name = ?", "Frog"]).name.should == 'Frog'
-  end
-
-  it 'should select records using the supplied sql fragment' do
-    Animal.find_by_sql("SELECT name FROM animals WHERE name='Frog'")[0].should == 'Frog'
-  end
-
-  it 'should retrieve the indexed element' do
-    Animal[1].id.should == 1
-  end
-
-  it 'should create a new record' do
-    count = Animal.count
-    capybara = Animal.create(:name => 'Capybara')
-    capybara.name.should == 'Capybara'
-    Animal.count.should == count + 1
-  end
-end

data/spec/associations_spec.rb

@@ -1,232 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe DataMapper::Associations::BelongsToAssociation do
-  before(:all) do
-    fixtures(:zoos)
-  end
-  
-  before(:each) do
-    @aviary = Exhibit.first(:name => 'Monkey Mayhem')
-  end
-  
-  it 'has a zoo association' do
-    @aviary.zoo.class.should == Zoo
-    Exhibit.new.zoo.should == nil
-  end
-  
-  it 'belongs to a zoo' do
-    @aviary.zoo.should == @aviary.database_context.first(Zoo, :name => 'San Diego')
-  end
-  
-  it "is assigned a zoo_id" do
-    zoo = Zoo.first
-    exhibit = Exhibit.new(:name => 'bob')
-    exhibit.zoo = zoo
-    exhibit.instance_variable_get("@zoo_id").should == zoo.id
-    
-    exhibit.save.should eql(true)
-    
-    zoo2 = Zoo.first
-    zoo2.exhibits.should include(exhibit)
-    
-    exhibit.destroy!
-    
-    zoo = Zoo.new(:name => 'bob')
-    bob = Exhibit.new(:name => 'bob')
-    zoo.exhibits << bob
-    zoo.save.should eql(true)
-    
-    zoo.exhibits.first.should_not be_a_new_record
-    
-    bob.destroy!
-    zoo.destroy!
-  end
-  
-  it 'can build its zoo' do
-    database do |db|
-      e = Exhibit.new({:name => 'Super Extra Crazy Monkey Cage'})
-      e.zoo.should == nil
-      e.build_zoo({:name => 'Monkey Zoo'})
-      e.zoo.class == Zoo
-      e.zoo.new_record?.should == true
-      
-      e.save
-    end
-  end
-  
-  it 'can build its zoo' do
-    database do |db|
-      e = Exhibit.new({:name => 'Super Extra Crazy Monkey Cage'})
-      e.zoo.should == nil
-      e.create_zoo({:name => 'Monkey Zoo'})
-      e.zoo.class == Zoo
-      e.zoo.new_record?.should == false
-      e.save
-    end
-  end
-  
-  after(:all) do
-    fixtures('zoos')
-    fixtures('exhibits')
-  end
-end
-
-describe DataMapper::Associations::HasAndBelongsToManyAssociation do
-
-  before(:all) do
-    fixtures(:animals)
-    fixtures(:exhibits)
-  end
-  
-  before(:each) do
-    @amazonia = Exhibit.first :name => 'Amazonia'
-  end
-  
-  it "should generate the SQL for a join statement" do
-    animals_association = database(:mock).schema[Exhibit].associations.find { |a| a.name == :animals }
-  
-    animals_association.to_sql.should == <<-EOS.compress_lines
-      JOIN `animals_exhibits` ON `animals_exhibits`.`exhibit_id` = `exhibits`.`id`
-      JOIN `animals` ON `animals`.`id` = `animals_exhibits`.`animal_id`
-    EOS
-  end
-  
-  it "should load associations" do
-    database do
-      froggy = Animal.first(:name => 'Frog')
-      froggy.exhibits.size.should == 1
-      froggy.exhibits.entries.first.should == Exhibit.first(:name => 'Amazonia')
-    end
-  end
-  
-  it 'has an animals association' do
-    [@amazonia, Exhibit.new].each do |exhibit|
-      exhibit.animals.class.should == DataMapper::Associations::HasAndBelongsToManyAssociation::Set
-    end
-  end
-  
-  it 'has many animals' do
-    @amazonia.animals.size.should == 1
-  end
-  
-  it 'should load associations magically' do
-    Exhibit.all.each do |exhibit|
-      exhibit.animals.each do |animal|
-        animal.exhibits.should include(exhibit)
-      end
-    end
-  end
-  
-  it 'should allow association of additional objects' do
-    @amazonia.animals << Animal.new(:name => "Buffalo")
-    @amazonia.animals.size.should == 2
-    @amazonia.reload
-  end
-  
-  it "should allow association of additional objects (CLEAN)" do
-    pending "http://wm.lighthouseapp.com/projects/4819-datamapper/tickets/92"
-    @amazonia.should_not be_dirty
-    
-    animal = Animal[2]
-    animal.should_not be_dirty
-    
-    @amazonia.animals << animal
-    @amazonia.animals.size.should == 2
-    @amazonia.reload
-  end
-  
-  it 'should allow you to fill and clear an association' do
-    marcy = Exhibit.create(:name => 'marcy')
-    
-    Animal.all.each do |animal|
-      marcy.animals << animal
-    end
-    
-    marcy.save.should eql(true)
-    marcy.should have(Animal.count).animals
-    
-    marcy.animals.clear
-    marcy.should have(0).animals
-    
-    marcy.save.should eql(true)
-    
-    marcys_stand_in = Exhibit[marcy.id]
-    marcys_stand_in.should have(0).animals
-    
-    marcy.destroy!    
-  end
-  
-  it 'should allow you to delete a specific association member' do
-    walter = Exhibit.create(:name => 'walter')
-
-    Animal.all.each do |animal|
-      walter.animals << animal
-    end
-    
-    walter.save.should eql(true)
-    walter.should have(Animal.count).animals
-    
-    delete_me = walter.animals.entries.first
-    walter.animals.delete(delete_me).should eql(delete_me)
-    walter.animals.delete(delete_me).should eql(nil)
-    
-    walter.should have(Animal.count - 1).animals
-    walter.save.should eql(true)
-    
-    walters_stand_in = Exhibit[walter.id]
-    walters_stand_in.animals.size.should eql(walter.animals.size)
-
-    walter.destroy!
-  end
-  
-  it "should allow updates to associations using association_ids[]" do
-    pending "Awaiting implementation of association_ids[]"
-    meerkat = Animal.new(:name => "Meerkat")
-    @amazonia.animals.size.should == 1
-    
-    @amazonia.animal_ids << meerkat.id
-    @amazonia.save
-    
-    @amazonia.animals.size.should == 2
-    @amazonia.animals.should include?(meerkat)
-  end
-  
-  it "Should handle setting complementary associations" do
-    pending("some borkage here")
-    u1 = User.create(:name => "u1")
-    u1.comments.should be_empty
-    
-    c1 = Comment.create(:comment => "c", :author => u1)
-    # p u1
-    # p c1
-    
-    u1.comments.should_not be_empty
-    u1.comments.should include(c1)
-    
-    u1.reload!
-    u1.comments.should_not be_empty
-    u1.comments.should include(c1)
-  end
-
-  it "should raise an error when attempting to associate an object not of the correct type (assuming added model doesn't inherit from the correct type)" do
-    pending("see: http://wm.lighthouseapp.com/projects/4819-datamapper/tickets/91")
-    @amazonia.animals.should_not be_empty
-    chuck = Person.new(:name => "Chuck")
-    
-    ## InvalidRecord isn't the error we should use here....needs to be changed
-    lambda { @amazonia.animals << chuck }.should raise_error(WrongType)
-    
-  end
-
-  it "should associate an object which has inherited from the correct type into an association" do
-    pending("see: http://wm.lighthouseapp.com/projects/4819-datamapper/tickets/91")
-    programmer = Career.first(:name => 'Programmer')
-    programmer.followers.should_not be_empty
-    
-    sales_person = SalesPerson.new(:name => 'Chuck')
-    
-    lambda { programmer.followers << sales_person }.should_not raise_error(WrongType)
-    
-  end
-
-end