datamapper 0.2.4 → 0.2.5

data/lib/data_mapper/support/active_record_impersonation.rb

@@ -35,6 +35,18 @@ module DataMapper
           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
@@ -63,8 +75,13 @@ module DataMapper
           DataMapper::database.query(*args)
         end
         
-        def [](id_or_hash)
-          first(id_or_hash)
+        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)
@@ -75,7 +92,8 @@ module DataMapper
         
         def create!(attributes)
           instance = self.new(attributes)
-          raise InvalidRecord.new(instance) unless instance.save
+          instance.save
+          raise InvalidRecord.new(instance) if instance.new_record?
           instance
         end
       end

data/lib/data_mapper/support/errors.rb

@@ -2,4 +2,6 @@ module DataMapper
   
   class InvalidRecord < StandardError; end
   
+  class MaterializationError < StandardError; end
+  
 end

data/lib/data_mapper/support/serialization.rb

@@ -16,7 +16,7 @@ module DataMapper
           out.map(nil, to_yaml_style ) do |map|
             database_context.table(self).columns.each do |column|
               lazy_load!(column.name) if column.lazy?
-              value = instance_variable_get(column.instance_variable_name)
+              value = get_value_for_column(column)
               map.add(column.to_s, value.is_a?(Class) ? value.to_s : value)
             end
             (self.instance_variable_get("@yaml_added") || []).each do |k,v|
@@ -48,9 +48,9 @@ module DataMapper
         
         table.columns.each do |column|
           next if column.key?
-          value = send(column.name)
+          value = get_value_for_column(column)
           node = root.add_element(column.to_s)
-          node << REXML::Text.new(copy_frozen_value(value).to_s) unless value.nil?
+          node << REXML::Text.new(value.to_s) unless value.nil?
         end
         
         doc
@@ -62,20 +62,17 @@ module DataMapper
         result = '{ '
         
         result << table.columns.map do |column|
-          "#{column.name.to_json}: #{copy_frozen_value(send(column.name)).to_json(*a)}"
+          "#{column.name.to_json}: #{get_value_for_column(column).to_json(*a)}"
         end.join(', ')
         
         result << ' }'
         result
       end
       
-      def copy_frozen_value(value)
-        case value
-        when Date, DateTime, Time, String then value.dup
-        when Fixnum, Class then value
-        else value
-        end
+      def get_value_for_column(column)
+        send(column.type == :boolean ? column.name.to_s.ensure_ends_with('?') : column.name)
       end
+
     end
   end # module Support
 end # module DataMapper

data/lib/data_mapper/support/struct.rb

@@ -0,0 +1,7 @@
+class Struct
+  def attributes
+    h = {}
+    each_pair { |k,v| h[k] = v }
+    h
+  end
+end

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

@@ -20,9 +20,16 @@ module Validatable
         { self.attribute.like => value }
       end
       
-      if scope
-        scope_value = instance.send(scope)
-        finder_options.merge! scope => scope_value
+      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?
@@ -30,4 +37,4 @@ module Validatable
     end  
   end
   
-end
+end

data/performance.rb

@@ -43,11 +43,25 @@ class DMPerson < DataMapper::Base #:nodoc:
   property :name, :string
   property :age, :integer
   property :occupation, :string
+  property :type, :class
   property :notes, :text
-  property :street, :string
-  property :city, :string
-  property :state, :string, :size => 2
-  property :zip_code, :string, :size => 10
+  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:
@@ -115,12 +129,12 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
   end
   
   x.report('DataMapper:conditions:short') do
-    N.times { Zoo[:name => 'Galveston'].name }
+    N.times { Zoo.first(:name => 'Galveston').name }
   end
   
   x.report('DataMapper:conditions:short:in-session') do
     database do
-      N.times { Zoo[:name => 'Galveston'].name }
+      N.times { Zoo.first(:name => 'Galveston').name }
     end
   end
   
@@ -241,8 +255,8 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
         #{person.name} (#{person.age})
         #{person.occupation}
         
-        #{person.street}
-        #{person.city}, #{person.state} #{person.zip_code}
+        #{person.address_street}
+        #{person.address_city}, #{person.address_state} #{person.address_zip_code}
         
         #{person.notes}
       VCARD
@@ -257,8 +271,7 @@ Benchmark::send(ENV['BM'] || :bmbm, 40) do |x|
         #{person.name} (#{person.age})
         #{person.occupation}
         
-        #{person.street}
-        #{person.city}, #{person.state} #{person.zip_code}
+        #{person.address}
         
         #{person.notes}
       VCARD

data/rakefile.rb

@@ -38,7 +38,7 @@ namespace :dm do
 
 end
 
-PACKAGE_VERSION = '0.2.4'
+PACKAGE_VERSION = '0.2.5'
 
 PACKAGE_FILES = FileList[
   'README',

data/spec/active_record_impersonation_spec.rb

@@ -23,7 +23,7 @@ describe DataMapper::Support::ActiveRecordImpersonation do
     end
 
     it 'should reload its attributes' do
-      frog = Animal[:name => 'Frog']
+      frog = Animal.first(:name => 'Frog')
       frog.name = 'MegaFrog'
       frog.name.should == 'MegaFrog'
       frog.reload!
@@ -43,7 +43,7 @@ describe DataMapper::Support::ActiveRecordImpersonation do
       capybara = Animal.create(:name => 'Capybara')
       count = Animal.count
       capybara.destroy!
-      Animal[:name => 'Capybara'].should be_nil
+      Animal.first(:name => 'Capybara').should be_nil
       Animal.count.should == count - 1
     end
   end
@@ -120,10 +120,6 @@ describe DataMapper::Support::ActiveRecordImpersonation do
     Animal[1].id.should == 1
   end
 
-  it 'should retrieve the indexed element using a hash condition' do
-    Animal[:name => 'Frog'].name.should == 'Frog'
-  end
-
   it 'should create a new record' do
     count = Animal.count
     capybara = Animal.create(:name => 'Capybara')

data/spec/acts_as_tree_spec.rb

@@ -3,7 +3,9 @@ require File.dirname(__FILE__) + "/spec_helper"
 describe('A tree') do
   
   before(:all) do
-    class Node < DataMapper::Base
+    class Node
+      include DataMapper::Persistence
+
       property :name, :string
 
       belongs_to :parent, :class => 'Node'

data/spec/associations_spec.rb

@@ -6,7 +6,7 @@ describe DataMapper::Associations::BelongsToAssociation do
   end
   
   before(:each) do
-    @aviary = Exhibit[:name => 'Monkey Mayhem']
+    @aviary = Exhibit.first(:name => 'Monkey Mayhem')
   end
   
   it 'has a zoo association' do
@@ -71,160 +71,6 @@ describe DataMapper::Associations::BelongsToAssociation do
   end
 end
 
-describe DataMapper::Associations::HasManyAssociation do
-  
-  before(:all) do
-    fixtures(:zoos)
-    fixtures(:exhibits)
-  end
-
-  before(:each) do
-    @zoo = Zoo.new(:name => "ZOO")
-    @zoo.save 
-  end
-  
-  after(:each) do
-    @zoo.destroy!
-  end
-  
-  it "should return an empty Enumerable for new objects" do
-    project = Project.new
-    project.sections.should be_a_kind_of(Enumerable)
-    project.sections.should be_empty
-  end
-  
-  it "should display correctly when inspected" do
-    Zoo.first(:name => 'Dallas').exhibits.inspect.should match(/\#\<Exhibit\:0x.{7}/)
-  end
-  
-  it 'should lazily-load the association when Enumerable methods are called' do
-    database do |db|
-      san_diego = Zoo[:name => 'San Diego']
-      san_diego.exhibits.size.should == 2
-      san_diego.exhibits.should include(Exhibit[:name => 'Monkey Mayhem'])
-    end
-  end
-  
-  it 'should eager-load associations for an entire set' do
-    database do
-      zoos = Zoo.all
-      zoos.each do |zoo|
-        zoo.exhibits.each do |exhibit|
-          exhibit.zoo.should == zoo
-        end
-      end
-    end
-  end
-  
-  it "should be dirty even when clean objects are associated" do
-    zoo = Zoo[:name => 'New York']
-    zoo.exhibits << Exhibit.first
-    zoo.should be_dirty
-  end
-  
-  it "should proxy associations on the associated type" do
-    Zoo[:name => 'Miami'].exhibits.animals.size.should == 1
-  end
-  
-  it "should have a valid zoo setup for testing" do
-    @zoo.should be_valid
-    @zoo.should_not be_a_new_record
-    @zoo.id.should_not be_nil
-  end  
-  
-  it "should generate the SQL for a join statement" do
-    exhibits_association = database(:mock).schema[Zoo].associations.find { |a| a.name == :exhibits }
-  
-    exhibits_association.to_sql.should == <<-EOS.compress_lines
-      JOIN `exhibits` ON `exhibits`.`zoo_id` = `zoos`.`id`
-    EOS
-  end
-
-  it "should add an item to an association" do
-    bear = Exhibit.new( :name => "Bear")
-    @zoo.exhibits << bear
-    @zoo.exhibits.should include(bear)
-  end
-  
-  it "should build a new item" do
-    bear = @zoo.exhibits.build( :name => "Bear" )
-    bear.should be_kind_of(Exhibit)
-    @zoo.exhibits.should include(bear)
-  end
-
-  it "should not save the item when building" do
-    bear = @zoo.exhibits.build( :name => "Bear" )
-    bear.should be_new_record
-  end
-  
-  it "should create a new item" do
-    bear = @zoo.exhibits.create( :name => "Bear" )
-    bear.should be_kind_of(Exhibit)
-    @zoo.exhibits.should include(bear)
-  end
-
-  it "should save the item when creating" do
-    bear = @zoo.exhibits.create( :name => "Bear" )
-    bear.should_not be_new_record
-  end
-
-  it "should set the association to a saved target when added with <<" do    
-    pirahna = Exhibit.new(:name => "Pirahna")
-    pirahna.zoo_id.should be_nil
-    
-    @zoo.exhibits << pirahna
-    pirahna.zoo.should == @zoo
-  end
-  
-  it "should set the association to a non-saved target when added with <<" do
-    zoo = Zoo.new(:name => "My Zoo")
-    kangaroo = Exhibit.new(:name => "Kangaroo")
-    zoo.exhibits << kangaroo
-    kangaroo.zoo.should == zoo
-  end
-  
-  it "should set the id of the exhibit when the associated zoo is saved" do
-    snake = Exhibit.new(:name => "Snake")
-    @zoo.exhibits << snake
-    @zoo.save
-    @zoo.id.should == snake.zoo_id
-  end
-  
-  it "should set the id of an already saved exibit if it's added to a different zoo" do
-    beaver = Exhibit.new(:name => "Beaver")
-    beaver.save
-    beaver.should_not be_a_new_record
-    @zoo.exhibits << beaver
-    @zoo.save
-    beaver.zoo.should == @zoo
-    beaver.zoo_id.should == @zoo.id    
-  end
-  
-  it "should set the size of the assocation" do
-    @zoo.exhibits << Exhibit.new(:name => "anonymous")
-    @zoo.exhibits.size.should == 1
-  end
-  
-  it "should give the association when an inspect is done on it" do
-    whale = Exhibit.new(:name => "Whale")
-    @zoo.exhibits << whale
-    @zoo.exhibits.should_not == "nil"
-    @zoo.exhibits.inspect.should_not be_nil
-  end
-end
-
-describe DataMapper::Associations::HasOneAssociation do
-  
-  it "should generate the SQL for a join statement" do
-    fruit_association = database(:mock).schema[Animal].associations.find { |a| a.name == :favourite_fruit }
-  
-    fruit_association.to_sql.should == <<-EOS.compress_lines
-      JOIN `fruit` ON `fruit`.`devourer_id` = `animals`.`id`
-    EOS
-  end
-
-end
-
 describe DataMapper::Associations::HasAndBelongsToManyAssociation do
 
   before(:all) do
@@ -233,7 +79,7 @@ describe DataMapper::Associations::HasAndBelongsToManyAssociation do
   end
   
   before(:each) do
-    @amazonia = Exhibit[:name => 'Amazonia']
+    @amazonia = Exhibit.first :name => 'Amazonia'
   end
   
   it "should generate the SQL for a join statement" do
@@ -247,9 +93,9 @@ describe DataMapper::Associations::HasAndBelongsToManyAssociation do
   
   it "should load associations" do
     database do
-      froggy = Animal[:name => 'Frog']
+      froggy = Animal.first(:name => 'Frog')
       froggy.exhibits.size.should == 1
-      froggy.exhibits.entries.first.should == Exhibit[:name => 'Amazonia']
+      froggy.exhibits.entries.first.should == Exhibit.first(:name => 'Amazonia')
     end
   end
   
@@ -277,6 +123,18 @@ describe DataMapper::Associations::HasAndBelongsToManyAssociation do
     @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')
     
@@ -334,12 +192,13 @@ describe DataMapper::Associations::HasAndBelongsToManyAssociation do
   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
+    # p u1
+    # p c1
     
     u1.comments.should_not be_empty
     u1.comments.should include(c1)
@@ -349,4 +208,25 @@ describe DataMapper::Associations::HasAndBelongsToManyAssociation do
     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