dm-core 0.10.0 → 0.10.1

data/spec/public/property_spec.rb

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
+# instance methods
 describe DataMapper::Property do
 
   # define the model prior to supported_by
@@ -21,19 +22,8 @@ describe DataMapper::Property do
       property :md5hash,      String, :key => true, :length => 32
       property :title,        String, :nullable => false, :unique => true
       property :description,  Text,   :length => 1..1024, :lazy => [ :detail ]
-
       property :format,       String, :default => 'jpeg'
-      # WxH, stored as a dumped Ruby pair
-      property :size,         Object
-      property :filesize,     Float
-      property :width,        Integer
-      property :quality,      BigDecimal
-
-      property :taken_on,     Date
-      property :taken_at,     Time, :default => lambda { |resource, property| Time.now }
-      property :retouched_at, DateTime
-      property :type,         Class
-      property :visible,      Boolean, :default => true
+      property :taken_at,     Time,   :default => proc { Time.now }
     end
   end
 
@@ -335,10 +325,9 @@ describe DataMapper::Property do
       it 'triggers lazy loading for given resource'
 
       it 'type casts given value' do
-        # set it to a float
-        @property.set(@image, 1.0)
-        # get a string that has been typecasted
-        @image.title.should == '1.0'
+        @property.set(@image, Addressable::URI.parse('http://test.example/'))
+        # get a string that has been typecasted using #to_str
+        @image.title.should == 'http://test.example/'
       end
 
       it 'stores original value' do
@@ -367,413 +356,6 @@ describe DataMapper::Property do
       end
     end
 
-    describe '#typecast' do
-      describe "when type is able to do typecasting on it's own" do
-        it 'delegates all the work to the type'
-      end
-
-      describe 'when value is nil' do
-        it 'returns value unchanged' do
-          Image.properties[:size].typecast(nil).should be(nil)
-        end
-      end
-
-      describe 'when value is a Ruby primitive' do
-        it 'returns value unchanged' do
-          Image.properties[:size].typecast([3200, 2400]).should == [3200, 2400]
-        end
-      end
-
-      describe 'when type primitive is a String' do
-        before :all do
-          @property = Image.properties[:title]
-        end
-
-        it 'returns same value if a string' do
-          @value = '1.0'
-          @property.typecast(@value).should equal(@value)
-        end
-
-        it 'returns string representation of the new value' do
-          @property.typecast(1.0).should eql('1.0')
-        end
-      end
-
-      describe 'when type primitive is a Float' do
-        before :all do
-          @property = Image.properties[:filesize]
-        end
-
-        it 'returns same value if a float' do
-          @value = 24.0
-          @property.typecast(@value).should equal(@value)
-        end
-
-        it 'returns float representation of a zero string integer' do
-          @property.typecast('0').should eql(0.0)
-        end
-
-        it 'returns float representation of a positive string integer' do
-          @property.typecast('24').should eql(24.0)
-        end
-
-        it 'returns float representation of a negative string integer' do
-          @property.typecast('-24').should eql(-24.0)
-        end
-
-        it 'returns float representation of a zero string float' do
-          @property.typecast('0.0').should eql(0.0)
-        end
-
-        it 'returns float representation of a positive string float' do
-          @property.typecast('24.35').should eql(24.35)
-        end
-
-        it 'returns float representation of a negative string float' do
-          @property.typecast('-24.35').should eql(-24.35)
-        end
-
-        it 'returns float representation of a zero string float, with no leading digits' do
-          @property.typecast('.0').should eql(0.0)
-        end
-
-        it 'returns float representation of a positive string float, with no leading digits' do
-          @property.typecast('.41').should eql(0.41)
-        end
-
-        it 'returns float representation of a zero integer' do
-          @property.typecast(0).should eql(0.0)
-        end
-
-        it 'returns float representation of a positive integer' do
-          @property.typecast(24).should eql(24.0)
-        end
-
-        it 'returns float representation of a negative integer' do
-          @property.typecast(-24).should eql(-24.0)
-        end
-
-        it 'returns float representation of a zero decimal' do
-          @property.typecast(BigDecimal('0.0')).should eql(0.0)
-        end
-
-        it 'returns float representation of a positive decimal' do
-          @property.typecast(BigDecimal('24.35')).should eql(24.35)
-        end
-
-        it 'returns float representation of a negative decimal' do
-          @property.typecast(BigDecimal('-24.35')).should eql(-24.35)
-        end
-
-        [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |value|
-          it "does not typecast non-numeric value #{value.inspect}" do
-            @property.typecast(value).should equal(value)
-          end
-        end
-      end
-
-      describe 'when type primitive is a Integer' do
-        before :all do
-          @property = Image.properties[:width]
-        end
-
-        it 'returns same value if an integer' do
-          @value = 24
-          @property.typecast(@value).should equal(@value)
-        end
-
-        it 'returns integer representation of a zero string integer' do
-          @property.typecast('0').should eql(0)
-        end
-
-        it 'returns integer representation of a positive string integer' do
-          @property.typecast('24').should eql(24)
-        end
-
-        it 'returns integer representation of a negative string integer' do
-          @property.typecast('-24').should eql(-24)
-        end
-
-        it 'returns integer representation of a zero string float' do
-          @property.typecast('0.0').should eql(0)
-        end
-
-        it 'returns integer representation of a positive string float' do
-          @property.typecast('24.35').should eql(24)
-        end
-
-        it 'returns integer representation of a negative string float' do
-          @property.typecast('-24.35').should eql(-24)
-        end
-
-        it 'returns integer representation of a zero string float, with no leading digits' do
-          @property.typecast('.0').should eql(0)
-        end
-
-        it 'returns integer representation of a positive string float, with no leading digits' do
-          @property.typecast('.41').should eql(0)
-        end
-
-        it 'returns integer representation of a zero float' do
-          @property.typecast(0.0).should eql(0)
-        end
-
-        it 'returns integer representation of a positive float' do
-          @property.typecast(24.35).should eql(24)
-        end
-
-        it 'returns integer representation of a negative float' do
-          @property.typecast(-24.35).should eql(-24)
-        end
-
-        it 'returns integer representation of a zero decimal' do
-          @property.typecast(BigDecimal('0.0')).should eql(0)
-        end
-
-        it 'returns integer representation of a positive decimal' do
-          @property.typecast(BigDecimal('24.35')).should eql(24)
-        end
-
-        it 'returns integer representation of a negative decimal' do
-          @property.typecast(BigDecimal('-24.35')).should eql(-24)
-        end
-
-        [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |value|
-          it "does not typecast non-numeric value #{value.inspect}" do
-            @property.typecast(value).should equal(value)
-          end
-        end
-      end
-
-      describe 'when type primitive is a BigDecimal' do
-        before :all do
-          @property = Image.properties[:quality]
-        end
-
-        it 'returns same value if a decimal' do
-          @value = BigDecimal('24.0')
-          @property.typecast(@value).should equal(@value)
-        end
-
-        it 'returns decimal representation of a zero string integer' do
-          @property.typecast('0').should eql(BigDecimal('0.0'))
-        end
-
-        it 'returns decimal representation of a positive string integer' do
-          @property.typecast('24').should eql(BigDecimal('24.0'))
-        end
-
-        it 'returns decimal representation of a negative string integer' do
-          @property.typecast('-24').should eql(BigDecimal('-24.0'))
-        end
-
-        it 'returns decimal representation of a zero string float' do
-          @property.typecast('0.0').should eql(BigDecimal('0.0'))
-        end
-
-        it 'returns decimal representation of a positive string float' do
-          @property.typecast('24.35').should eql(BigDecimal('24.35'))
-        end
-
-        it 'returns decimal representation of a negative string float' do
-          @property.typecast('-24.35').should eql(BigDecimal('-24.35'))
-        end
-
-        it 'returns decimal representation of a zero string float, with no leading digits' do
-          @property.typecast('.0').should eql(BigDecimal('0.0'))
-        end
-
-        it 'returns decimal representation of a positive string float, with no leading digits' do
-          @property.typecast('.41').should eql(BigDecimal('0.41'))
-        end
-
-        it 'returns decimal representation of a zero integer' do
-          @property.typecast(0).should eql(BigDecimal('0.0'))
-        end
-
-        it 'returns decimal representation of a positive integer' do
-          @property.typecast(24).should eql(BigDecimal('24.0'))
-        end
-
-        it 'returns decimal representation of a negative integer' do
-          @property.typecast(-24).should eql(BigDecimal('-24.0'))
-        end
-
-        it 'returns decimal representation of a zero float' do
-          @property.typecast(0.0).should eql(BigDecimal('0.0'))
-        end
-
-        it 'returns decimal representation of a positive float' do
-          @property.typecast(24.35).should eql(BigDecimal('24.35'))
-        end
-
-        it 'returns decimal representation of a negative float' do
-          @property.typecast(-24.35).should eql(BigDecimal('-24.35'))
-        end
-
-        [ Object.new, true, '00.0', '0.', '-.0', 'string' ].each do |value|
-          it "does not typecast non-numeric value #{value.inspect}" do
-            @property.typecast(value).should equal(value)
-          end
-        end
-      end
-
-      describe 'when type primitive is a DateTime' do
-        before do
-          @property = Image.properties[:retouched_at]
-        end
-
-        describe 'and value given as a hash with keys like :year, :month, etc' do
-          it 'builds a DateTime instance from hash values' do
-            result = @property.typecast(
-              'year'  => '2006',
-              'month' => '11',
-              'day'   => '23',
-              'hour'  => '12',
-              'min'   => '0',
-              'sec'   => '0'
-            )
-
-            result.should be_kind_of(DateTime)
-            result.year.should eql(2006)
-            result.month.should eql(11)
-            result.day.should eql(23)
-            result.hour.should eql(12)
-            result.min.should eql(0)
-            result.sec.should eql(0)
-          end
-        end
-
-        describe 'and value is a string' do
-          it 'parses the string' do
-            Image.properties[:retouched_at].typecast('Dec, 2006').month.should == 12
-          end
-        end
-
-        it 'does not typecast non-datetime values' do
-          @property.typecast('not-datetime').should eql('not-datetime')
-        end
-      end
-
-      describe 'when type primitive is a Date' do
-        before do
-          @property = Image.properties[:taken_on]
-        end
-
-        describe 'and value given as a hash with keys like :year, :month, etc' do
-          it 'builds a Date instance from hash values' do
-            result = @property.typecast(
-              'year'  => '2007',
-              'month' => '3',
-              'day'   => '25'
-            )
-
-            result.should be_kind_of(Date)
-            result.year.should eql(2007)
-            result.month.should eql(3)
-            result.day.should eql(25)
-          end
-        end
-
-        describe 'and value is a string' do
-          it 'parses the string' do
-            result = @property.typecast('Dec 20th, 2006')
-            result.month.should == 12
-            result.day.should == 20
-            result.year.should == 2006
-          end
-        end
-
-        it 'does not typecast non-date values' do
-          @property.typecast('not-date').should eql('not-date')
-        end
-      end
-
-      describe 'when type primitive is a Time' do
-        before do
-          @property = Image.properties[:taken_at]
-        end
-
-        describe 'and value given as a hash with keys like :year, :month, etc' do
-          it 'builds a Time instance from hash values' do
-            result = @property.typecast(
-              'year'  => '2006',
-              'month' => '11',
-              'day'   => '23',
-              'hour'  => '12',
-              'min'   => '0',
-              'sec'   => '0'
-            )
-
-            result.should be_kind_of(Time)
-            result.year.should  eql(2006)
-            result.month.should eql(11)
-            result.day.should   eql(23)
-            result.hour.should  eql(12)
-            result.min.should   eql(0)
-            result.sec.should   eql(0)
-          end
-        end
-
-        describe 'and value is a string' do
-          it 'parses the string' do
-            result = @property.typecast('22:24')
-            result.hour.should eql(22)
-            result.min.should eql(24)
-          end
-        end
-
-        it 'does not typecast non-time values' do
-          pending 'Time#parse is too permissive' do
-            @property.typecast('not-time').should eql('not-time')
-          end
-        end
-      end
-
-      describe 'when type primitive is a Class' do
-        before do
-          @property = Image.properties[:type]
-        end
-
-        it 'returns same value if a class' do
-          @value = Image
-          @property.typecast(@value).should equal(@value)
-        end
-
-        it 'returns the class if found' do
-          @property.typecast('Image').should eql(Image)
-        end
-
-        it 'does not typecast non-class values' do
-          @property.typecast('NoClass').should eql('NoClass')
-        end
-      end
-
-      describe 'when type primitive is a Boolean' do
-        before do
-          @property = Image.properties[:visible]
-        end
-
-        [ true, 'true', 'TRUE', '1', 1, 't', 'T' ].each do |value|
-          it "returns true when value is #{value.inspect}" do
-            @property.typecast(value).should be_true
-          end
-        end
-
-        [ false, 'false', 'FALSE', '0', 0, 'f', 'F' ].each do |value|
-          it "returns false when value is #{value.inspect}" do
-            @property.typecast(value).should be_false
-          end
-        end
-
-        [ 'string', 2, 1.0, BigDecimal('1.0'), DateTime.now, Time.now, Date.today, Class, Object.new, ].each do |value|
-          it "does not typecast value #{value.inspect}" do
-            @property.typecast(value).should equal(value)
-          end
-        end
-      end
-    end # #typecase
-
     describe '#unique?' do
       it 'is true for fields that explicitly given uniq index' do
         Track.properties[:musicbrainz_hash].unique?.should be_true
@@ -799,31 +381,5 @@ describe DataMapper::Property do
         Image.properties[:title].unique_index.should be_nil
       end
     end
-
-    describe '#valid?' do
-      describe 'when type primitive is a Boolean' do
-        before do
-          @property = Image.properties[:visible]
-        end
-
-        [ true, false ].each do |value|
-          it "returns true when value is #{value.inspect}" do
-            @property.valid?(value).should be_true
-          end
-        end
-
-        [ 'true', 'TRUE', '1', 1, 't', 'T', 'false', 'FALSE', '0', 0, 'f', 'F' ].each do |value|
-          it "returns false for #{value.inspect}" do
-            @property.valid?(value).should be_false
-          end
-        end
-      end
-    end
-
-    describe '#value' do
-      it 'returns value for core types'
-
-      it 'triggers dump operation for custom types'
-    end
   end
 end # DataMapper::Property

data/spec/public/sel_spec.rb

@@ -15,8 +15,8 @@ describe 'SEL', 'with different key types' do
       class Article
         include DataMapper::Resource
 
-        property :id,      Serial
-        property :title,   String, :nullable => false
+        property :id,    Serial
+        property :title, String, :nullable => false
 
         property :author_id, String  # different type
 
@@ -42,3 +42,53 @@ describe 'SEL', 'with different key types' do
     end
   end
 end
+
+describe 'SEL', 'with STI subclasses' do
+  before :all do
+    module ::Blog
+      class Author
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :name, String
+
+        has n, :messages
+      end
+
+      class Message
+        include DataMapper::Resource
+
+        property :id,    Serial
+        property :type,  Discriminator
+        property :title, String, :nullable => false
+
+        belongs_to :author
+      end
+
+      class Article < Message; end
+      class Comment < Message; end
+    end
+
+    @author_model  = Blog::Author
+    @message_model = Blog::Message
+    @article_model = Blog::Article
+    @comment_model = Blog::Comment
+  end
+
+  supported_by :all do
+    before :all do
+      author1 = @author_model.create(:name => 'Dan Kubb')
+      author2 = @author_model.create(:name => 'Sindre Aarsaether')
+
+      @article_model.create(:title => 'SEL',               :author => author1)
+      @article_model.create(:title => 'STI',               :author => author1)
+      @comment_model.create(:title => 'SEL and STI error', :author => author2)
+    end
+
+    it 'should allow STI loading of mixed relationships' do
+      lambda {
+        @message_model.all.each { |message| message.author }
+      }.should_not raise_error(ArgumentError)
+    end
+  end
+end

data/spec/public/shared/collection_shared_spec.rb

@@ -618,24 +618,52 @@ share_examples_for 'A public Collection' do
   describe '#pop' do
     before :all do
       @new = @articles.create(:title => 'Sample Article')  # TODO: freeze @new
-
-      @return = @resource = @articles.pop
     end
 
-    it 'should return a Resource' do
-      @return.should be_kind_of(DataMapper::Resource)
-    end
+    describe 'with no arguments' do
+      before :all do
+        @return = @articles.pop
+      end
 
-    it 'should be the last Resource in the Collection' do
-      @resource.should == @new
-    end
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
+
+      it 'should be the last Resource in the Collection' do
+        @return.should == @new
+      end
 
-    it 'should remove the Resource from the Collection' do
-      @articles.should_not be_include(@resource)
+      it 'should remove the Resource from the Collection' do
+        @articles.should_not be_include(@new)
+      end
+
+      it 'should orphan the Resource' do
+        @return.collection.should_not equal(@articles)
+      end
     end
 
-    it 'should orphan the Resource' do
-      @resource.collection.should_not equal(@articles)
+    if RUBY_VERSION >= '1.8.7'
+      describe 'with a limit specified' do
+        before :all do
+          @return = @articles.pop(1)
+        end
+
+        it 'should return an Array' do
+          @return.should be_kind_of(Array)
+        end
+
+        it 'should return the expected Resources' do
+          @return.should == [ @new ]
+        end
+
+        it 'should remove the Resource from the Collection' do
+          @articles.should_not be_include(@new)
+        end
+
+        it 'should orphan the Resource' do
+          @return.each { |resource| resource.collection.should_not equal(@articles) }
+        end
+      end
     end
   end
 
@@ -941,26 +969,51 @@ share_examples_for 'A public Collection' do
   it { @articles.should respond_to(:shift) }
 
   describe '#shift' do
-    before :all do
-      @new = @articles.create(:title => 'Sample Article')
+    describe 'with no arguments' do
+      before :all do
+        @return = @articles.shift
+      end
 
-      @return = @resource = @articles.shift
-    end
+      it 'should return a Resource' do
+        @return.should be_kind_of(DataMapper::Resource)
+      end
 
-    it 'should return a Resource' do
-      @return.should be_kind_of(DataMapper::Resource)
-    end
+      it 'should be the first Resource in the Collection' do
+        @return.key.should == @article.key
+      end
 
-    it 'should be the first Resource in the Collection' do
-      @resource.key.should == @article.key
-    end
+      it 'should remove the Resource from the Collection' do
+        @articles.should_not be_include(@return)
+      end
 
-    it 'should remove the Resource from the Collection' do
-      @articles.should_not be_include(@resource)
+      it 'should orphan the Resource' do
+        @return.collection.should_not equal(@articles)
+      end
     end
 
-    it 'should orphan the Resource' do
-      @resource.collection.should_not equal(@articles)
+    if RUBY_VERSION >= '1.8.7'
+      describe 'with a limit specified' do
+        before :all do
+          @return = @articles.shift(1)
+        end
+
+        it 'should return an Array' do
+          @return.should be_kind_of(Array)
+        end
+
+        it 'should return the expected Resources' do
+          @return.size.should == 1
+          @return.first.key.should == @article.key
+        end
+
+        it 'should remove the Resource from the Collection' do
+          @articles.should_not be_include(@article)
+        end
+
+        it 'should orphan the Resource' do
+          @return.each { |resource| resource.collection.should_not equal(@articles) }
+        end
+      end
     end
   end