dm-core 1.0.2 → 1.1.0.rc1

data/spec/semipublic/property/lookup_spec.rb

@@ -1,20 +1,23 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../..', 'spec_helper'))
+require 'spec_helper'
 require 'dm-core/property/lookup'
 
 describe DataMapper::Property::Lookup do
   supported_by :all do
-    before(:all) do
+    before :all do
+      Object.send(:remove_const, :Foo) if defined?(Foo)
       @klass = Class.new { extend DataMapper::Model }
 
-      DataMapper::Types::LegacyType = Class.new(DataMapper::Types::Text)
+      module Foo
+        class OtherProperty < DataMapper::Property::String; end
+      end
     end
 
     it "should provide access to Property classes" do
       @klass::Serial.should == DataMapper::Property::Serial
     end
 
-    it "should provide access to legacy Types" do
-      @klass::LegacyType.should be(DataMapper::Types::LegacyType)
+    it "should provide access to Property classes from outside of the Property namespace" do
+      @klass::OtherProperty.should be(Foo::OtherProperty)
     end
 
     it "should not provide access to unknown Property classes" do

data/spec/semipublic/property/serial_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../..', 'spec_helper'))
+require 'spec_helper'
 
 describe DataMapper::Property::Serial do
   before :all do

data/spec/semipublic/property/string_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../..', 'spec_helper'))
+require 'spec_helper'
 
 describe DataMapper::Property::String do
   before :all do

data/spec/semipublic/property/text_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../..', 'spec_helper'))
+require 'spec_helper'
 
 describe DataMapper::Property::Text do
   before :all do

data/spec/semipublic/property/time_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '../..', 'spec_helper'))
+require 'spec_helper'
 
 describe DataMapper::Property::Time do
   before :all do

data/spec/semipublic/property_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require 'spec_helper'
 
 # instance methods
 describe DataMapper::Property do
@@ -21,12 +21,15 @@ describe DataMapper::Property do
       end
     end
 
-    describe "with custom types" do
+    describe "with property subclasses" do
       before :all do
+        Object.send(:remove_const, :CustomProps) if Object.const_defined?(:CustomProps)
+
         module ::CustomProps
-          class Property
-            class Hash  < DataMapper::Property::Object; end
-            class Other < DataMapper::Property::Object; end
+          module Property
+            class Hash   < DataMapper::Property::Object; end
+            class Other  < DataMapper::Property::Object; end
+            class Serial < DataMapper::Property::Object; end
           end
         end
       end
@@ -42,6 +45,28 @@ describe DataMapper::Property do
 
         it { subject.should be(::CustomProps::Property::Other) }
       end
+
+      describe "should always use the DM property when a built-in is referenced indirectly" do
+        subject do
+          Class.new do
+            extend ::DataMapper::Model
+          end
+        end
+
+        it { subject::Serial.should be(::DataMapper::Property::Serial) }
+      end
+
+      describe "should always use the custom property when an overridden built-in is directly attached to the model" do
+        subject do
+          Class.new do
+            extend ::DataMapper::Model
+            include ::CustomProps::Property
+          end
+        end
+
+        it { subject::Serial.should be(::CustomProps::Property::Serial) }
+      end
+
     end
   end
 
@@ -53,7 +78,7 @@ describe DataMapper::Property do
         property :id,         Integer, :key => true
         property :name,       String
         property :rating,     Float
-        property :rate,       Decimal
+        property :rate,       Decimal, :precision => 5, :scale => 2
         property :type,       Class
         property :alias,      String
         property :active,     Boolean
@@ -68,7 +93,7 @@ describe DataMapper::Property do
   end
 
   describe 'override property definition in other repository' do
-    before(:all) do
+    before :all do
       module ::Blog
         class Author
           repository(:other) do

data/spec/semipublic/query/conditions/comparison_spec.rb

@@ -1,267 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper'))
-
-shared_examples_for 'DataMapper::Query::Conditions::AbstractComparison' do
-  before :all do
-    module ::Blog
-      class Article
-        include DataMapper::Resource
-
-        property :id,    Serial
-        property :title, String, :required => true
-
-        belongs_to :parent, self, :required => false
-        has n, :children, self, :inverse => :parent
-      end
-    end
-
-    DataMapper.finalize
-
-    @model = Blog::Article
-  end
-
-  before do
-    class ::OtherComparison < DataMapper::Query::Conditions::AbstractComparison
-      slug :other
-    end
-  end
-
-  before do
-    @relationship = @model.relationships[:parent]
-  end
-
-  it { subject.class.should respond_to(:new) }
-
-  describe '.new' do
-    subject { @comparison.class.new(@property, @value) }
-
-    it { should be_kind_of(@comparison.class) }
-
-    it { subject.subject.should equal(@property) }
-
-    it { subject.value.should == @value }
-  end
-
-  it { subject.class.should respond_to(:slug) }
-
-  describe '.slug' do
-    describe 'with no arguments' do
-      subject { @comparison.class.slug }
-
-      it { should == @slug }
-    end
-
-    describe 'with an argument' do
-      subject { @comparison.class.slug(:other) }
-
-      it { should == :other }
-
-      # reset the slug
-      after { @comparison.class.slug(@slug) }
-    end
-  end
-
-  it { should respond_to(:==) }
-
-  describe '#==' do
-    describe 'when the other AbstractComparison is equal' do
-      # artificially modify the object so #== will throw an
-      # exception if the equal? branch is not followed when heckling
-      before { @comparison.singleton_class.send(:undef_method, :slug) }
-
-      subject { @comparison == @comparison }
-
-      it { should be(true) }
-    end
-
-    describe 'when the other AbstractComparison is the same class' do
-      subject { @comparison == DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value) }
-
-      it { should be(true) }
-    end
-
-    describe 'when the other AbstractComparison is a different class' do
-      subject { @comparison == DataMapper::Query::Conditions::Comparison.new(:other, @property, @value) }
-
-      it { should be(false) }
-    end
-
-    describe 'when the other AbstractComparison is the same class, with different property' do
-      subject { @comparison == DataMapper::Query::Conditions::Comparison.new(@slug, @other_property, @value) }
-
-      it { should be(false) }
-    end
-
-    describe 'when the other AbstractComparison is the same class, with different value' do
-      subject { @comparison == DataMapper::Query::Conditions::Comparison.new(@slug, @property, @other_value) }
-
-      it { should be(false) }
-    end
-  end
-
-  it { should respond_to(:eql?) }
-
-  describe '#eql?' do
-    describe 'when the other AbstractComparison is equal' do
-      # artificially modify the object so #eql? will throw an
-      # exception if the equal? branch is not followed when heckling
-      before { @comparison.singleton_class.send(:undef_method, :slug) }
-
-      subject { @comparison.eql?(@comparison) }
-
-      it { should be(true) }
-    end
-
-    describe 'when the other AbstractComparison is the same class' do
-      subject { @comparison.eql?(DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value)) }
-
-      it { should be(true) }
-    end
-
-    describe 'when the other AbstractComparison is a different class' do
-      subject { @comparison.eql?(DataMapper::Query::Conditions::Comparison.new(:other, @property, @value)) }
-
-      it { should be(false) }
-    end
-
-    describe 'when the other AbstractComparison is the same class, with different property' do
-      subject { @comparison.eql?(DataMapper::Query::Conditions::Comparison.new(@slug, @other_property, @value)) }
-
-      it { should be(false) }
-    end
-
-    describe 'when the other AbstractComparison is the same class, with different value' do
-      subject { @comparison.eql?(DataMapper::Query::Conditions::Comparison.new(@slug, @property, @other_value)) }
-
-      it { should be(false) }
-    end
-  end
-
-  it { should respond_to(:hash) }
-
-  describe '#hash' do
-    subject { @comparison.hash }
-
-    it 'should match the same AbstractComparison with the same property and value' do
-      should == DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value).hash
-    end
-
-    it 'should not match the same AbstractComparison with different property' do
-      should_not == DataMapper::Query::Conditions::Comparison.new(@slug, @other_property, @value).hash
-    end
-
-    it 'should not match the same AbstractComparison with different value' do
-      should_not == DataMapper::Query::Conditions::Comparison.new(@slug, @property, @other_value).hash
-    end
-
-    it 'should not match a different AbstractComparison with the same property and value' do
-      should_not == @other.hash
-    end
-
-    it 'should not match a different AbstractComparison with different property' do
-      should_not == @other.class.new(@other_property, @value).hash
-    end
-
-    it 'should not match a different AbstractComparison with different value' do
-      should_not == @other.class.new(@property, @other_value).hash
-    end
-  end
-
-  it { should respond_to(:loaded_value) }
-
-  describe '#loaded_value' do
-    subject { @comparison.loaded_value }
-
-    it { should == @value }
-  end
-
-  it { should respond_to(:parent) }
-
-  describe '#parent' do
-    subject { @comparison.parent }
-
-    describe 'should be nil by default' do
-      it { should be_nil }
-    end
-
-    describe 'should relate to parent operation' do
-      before do
-        @operation = DataMapper::Query::Conditions::Operation.new(:and)
-        @comparison.parent = @operation
-      end
-
-      it { should be_equal(@operation) }
-    end
-  end
-
-  it { should respond_to(:parent=) }
-
-  describe '#parent=' do
-    before do
-      @operation = DataMapper::Query::Conditions::Operation.new(:and)
-    end
-
-    subject { @comparison.parent = @operation }
-
-    it { should equal(@operation) }
-
-    it 'should change the parent' do
-      method(:subject).should change(@comparison, :parent).
-        from(nil).
-        to(@operation)
-    end
-  end
-
-  it { should respond_to(:property?) }
-
-  describe '#property?' do
-    subject { @comparison.property? }
-
-    it { should be(true) }
-  end
-
-  it { should respond_to(:slug) }
-
-  describe '#slug' do
-    subject { @comparison.slug }
-
-    it { should == @slug }
-  end
-
-  it { should respond_to(:subject) }
-
-  describe '#subject' do
-    subject { @comparison.subject }
-
-    it { should be_equal(@property) }
-  end
-
-  it { should respond_to(:valid?) }
-
-  describe '#valid?' do
-    subject { @comparison.valid? }
-
-    describe 'when the value is valid for the subject' do
-      it { should be(true) }
-    end
-
-    describe 'when the value is not valid for the subject' do
-      before do
-        @comparison = DataMapper::Query::Conditions::Comparison.new(@slug, @property, nil)
-      end
-
-      it { should be(false) }
-    end
-  end
-
-  it { should respond_to(:value) }
-
-  describe '#value' do
-    subject { @comparison.value }
-
-    it { should == @value }
-  end
-end
-
+require 'spec_helper'
 describe DataMapper::Query::Conditions::Comparison do
   before :all do
     module ::Blog

data/spec/semipublic/query/conditions/operation_spec.rb

@@ -1,5 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'spec_helper'))
-
+require 'spec_helper'
 module OperationMatchers
   class HaveValidParent
     def matches?(target)

data/spec/semipublic/query/path_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require 'spec_helper'
 
 # class methods
 describe DataMapper::Query::Path do
@@ -427,6 +427,32 @@ describe DataMapper::Query::Path do
     end
   end
 
+  describe 'ordering' do
+    before do
+      @path = Article.author.title
+    end
+
+    describe '#desc' do
+      before do
+        @return = @path.desc
+      end
+
+      it 'returns a :desc operator from the path' do
+        @return.should == DataMapper::Query::Operator.new(@path.property, :desc)
+      end
+    end
+
+    describe '#asc' do
+      before do
+        @return = @path.asc
+      end
+
+      it 'returns a :desc operator from the path' do
+        @return.should == DataMapper::Query::Operator.new(@path.property, :asc)
+      end
+    end
+  end
+
   ((DataMapper::Query::Conditions::Comparison.slugs | [ :not ]) - [ :eql, :in ]).each do |slug|
     describe "##{slug}" do
       before do

data/spec/semipublic/query_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+require 'spec_helper'
 
 require 'ostruct'
 
@@ -18,7 +18,7 @@ describe DataMapper::Query do
 
       property :name,     String,   :key => true
       property :password, Password
-      property :balance,  Decimal
+      property :balance,  Decimal, :precision => 5, :scale => 2
 
       belongs_to :referrer, self, :required => false
       has n, :referrals, self, :inverse => :referrer
@@ -637,7 +637,7 @@ describe DataMapper::Query do
           end
         end
 
-        describe 'with a custom Property' do
+        describe 'with a Property subclass' do
           before :all do
             @options[:conditions] = { :password => 'password' }
             @return = DataMapper::Query.new(@repository, @model, @options.freeze)
@@ -787,6 +787,29 @@ describe DataMapper::Query do
         end
       end
 
+      describe 'that is a Hash with a String key that is a Path and not for a Relationship in the model' do
+        it 'should raise an exception' do
+          lambda {
+            DataMapper::Query.new(@repository, @model, @options.update(:conditions => { 'unknown.id' => 1 }))
+          }.should raise_error(ArgumentError, "condition \"unknown.id\" does not map to a relationship in #{@model}")
+        end
+      end
+
+      describe 'that is a Hash with a Property that does not belong to the model' do
+        before do
+          Object.send(:remove_const, :Alternate) if Object.const_defined?(:Alternate)
+          @alternate_model = DataMapper::Model.new('Alternate') do
+            property :id, DataMapper::Property::Serial
+          end
+        end
+
+        it 'should raise an exception' do
+          lambda {
+            DataMapper::Query.new(@repository, @model, @options.update(:conditions => { @alternate_model.properties[:id] => 1 }))
+          }.should raise_error(ArgumentError, "condition :id does not map to a property in #{@model}, but belongs to #{@alternate_model}")
+        end
+      end
+
       describe 'that is a Hash with a Query::Operator key that is not for a Property in the model' do
         it 'should raise an exception' do
           lambda {
@@ -935,6 +958,41 @@ describe DataMapper::Query do
           @return.order.should == [ DataMapper::Query::Direction.new(@model.properties[:name]) ]
         end
       end
+
+      describe 'that contains a Query::Direction with a property that is not part of the model' do
+        before :all do
+          @property = DataMapper::Property::String.new(@model, :unknown)
+          @direction = DataMapper::Query::Direction.new(@property, :desc)
+          @return = DataMapper::Query.new(@repository, @model, @options.update(:order => [ @direction ]))
+        end
+
+        it 'should set the order, since it may map to a joined model' do
+          @return.order.should == [ @direction ]
+        end
+      end
+
+      describe 'that contains a Property that is not part of the model' do
+        before :all do
+          @property = DataMapper::Property::String.new(@model, :unknown)
+          @return = DataMapper::Query.new(@repository, @model, @options.update(:order => [ @property ]))
+        end
+
+        it 'should set the order, since it may map to a joined model' do
+          @return.order.should == [ DataMapper::Query::Direction.new(@property) ]
+        end
+      end
+
+      describe 'that contains a Query::Path to a property on a linked model' do
+        before :all do
+          @property = @model.referrer.name
+          @return = DataMapper::Query.new(@repository, @model, @options.update(:order => [ @property ]))
+        end
+
+        it 'should set the order' do
+          @return.order.should == [ DataMapper::Query::Direction.new(@model.properties[:name]) ]
+        end
+      end
+
       describe 'that is an Array containing a Symbol' do
         before :all do
           @return = DataMapper::Query.new(@repository, @model, @options.freeze)
@@ -1079,19 +1137,6 @@ describe DataMapper::Query do
         end
       end
 
-      describe 'that contains a Query::Direction with a property that is not part of the model' do
-        before :all do
-          @property = DataMapper::Property::String.new(@model, :unknown)
-          @direction = DataMapper::Query::Direction.new(@property, :desc)
-        end
-
-        it 'should raise an exception' do
-          lambda {
-            DataMapper::Query.new(@repository, @model, @options.update(:order => [ @direction ]))
-          }.should raise_error(ArgumentError, "+options[:order]+ entry :unknown does not map to a property in #{@model}")
-        end
-      end
-
       describe 'that contains a Query::Operator with a target that is not part of the model' do
         it 'should raise an exception' do
           lambda {
@@ -1108,18 +1153,6 @@ describe DataMapper::Query do
         end
       end
 
-      describe 'that contains a Property that is not part of the model' do
-        before :all do
-          @property = DataMapper::Property::String.new(@model, :unknown)
-        end
-
-        it 'should raise an exception' do
-          lambda {
-            DataMapper::Query.new(@repository, @model, @options.update(:order => [ @property ]))
-          }.should raise_error(ArgumentError, "+options[:order]+ entry :unknown does not map to a property in #{@model}")
-        end
-      end
-
       describe 'that contains a Symbol that is not for a Property in the model' do
         it 'should raise an exception' do
           lambda {
@@ -1960,7 +1993,15 @@ describe DataMapper::Query do
           end
         end
 
-        subject { @query.send(method, @other) }
+        subject do
+          result = @query.send(method, @other)
+
+          if @another
+            result = result.send(method, @another)
+          end
+
+          result
+        end
 
         describe 'with equivalent query' do
           before { @other = @query.dup }
@@ -1995,8 +2036,9 @@ describe DataMapper::Query do
 
         describe 'with self matching everything' do
           before do
-            @query = DataMapper::Query.new(@repository, @model)
-            @other = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @query   = DataMapper::Query.new(@repository, @model)
+            @other   = DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
+            @another = DataMapper::Query.new(@repository, @model, :citizenship => 'US')
           end
 
           it { should be_kind_of(DataMapper::Query) }
@@ -2005,10 +2047,10 @@ describe DataMapper::Query do
 
           it { should_not equal(@other) }
 
+          it { should_not equal(@another) }
+
           it 'should factor out the operation matching everything' do
-            pending 'TODO: compress Query#conditions for proper comparison' do
-              should == DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb')
-            end
+            should == DataMapper::Query.new(@repository, @model, :name => 'Dan Kubb', :citizenship => 'US')
           end
         end
 
@@ -3430,15 +3472,24 @@ describe DataMapper::Query do
       it { should_not be_unique }
     end
 
-    describe 'when links are provided, but unique is not specified' do
+    describe 'when 1..n links are provided, but unique is not specified' do
       before :all do
         @query.should_not be_unique
-        @query.update(:links => [ :referrer ])
+        @query.update(:links => [ :referrals ])
       end
 
       it { should be_unique }
     end
 
+    describe 'when 0..1 links are provided, but unique is not specified' do
+      before :all do
+        @query.should_not be_unique
+        @query.update(:links => [ :referrer ])
+      end
+
+      it { should_not be_unique }
+    end
+
     describe 'when links are provided, but unique is false' do
       before :all do
         @query.should_not be_unique