dm-core 1.0.2 → 1.1.0.rc1

data/lib/dm-core/spec/shared/resource_spec.rb

@@ -916,7 +916,7 @@ share_examples_for 'A public Resource' do
         end
 
         it 'should succesfully save the dependency' do
-          @user.attributes.should == @user_model.get(*@user.key).attributes
+          @user.name.should == @user_model.get(*@user.key).name
         end
       end
 

data/lib/dm-core/spec/shared/semipublic/property_spec.rb

@@ -11,9 +11,9 @@ share_examples_for 'A semipublic Property' do
       end
     end
 
-    @model = Blog::Article
-    @property = @type.new(@model, @name)
-    DataMapper.finalize
+    @model      = Blog::Article
+    @options  ||= {}
+    @property   = @type.new(@model, @name, @options)
   end
 
   describe '.new' do
@@ -31,7 +31,7 @@ share_examples_for 'A semipublic Property' do
       end
 
       it 'should set the options to the default' do
-        @property.options.should == @type.options
+        @property.options.should == @options.merge(@type.options)
       end
     end
 
@@ -39,7 +39,7 @@ share_examples_for 'A semipublic Property' do
       [ true, false, :title, [ :title ] ].each do |value|
         describe "when provided #{(options = { attribute => value }).inspect}" do
           before :all do
-            @property = @type.new(@model, @name, options)
+            @property = @type.new(@model, @name, @options.merge(options))
           end
 
           it 'should return a Property' do
@@ -55,7 +55,7 @@ share_examples_for 'A semipublic Property' do
           end
 
           it "should set the options to #{options.inspect}" do
-            @property.options.should == @type.options.merge(options)
+            @property.options.should == @type.options.merge(@options.merge(options))
           end
         end
       end
@@ -64,7 +64,7 @@ share_examples_for 'A semipublic Property' do
         describe "when provided #{(invalid_options = { attribute => value }).inspect}" do
           it 'should raise an exception' do
             lambda {
-              @type.new(@model, @name, invalid_options)
+              @type.new(@model, @name, @options.merge(invalid_options))
             }.should raise_error(ArgumentError, "options[#{attribute.inspect}] must be either true, false, a Symbol or an Array of Symbols")
           end
         end
@@ -125,14 +125,14 @@ share_examples_for 'A semipublic Property' do
 
     describe 'when provide a nil value when required' do
       it 'should return false' do
-        @property = @type.new(@model, @name, :required => true)
+        @property = @type.new(@model, @name, @options.merge(:required => true))
         @property.valid?(nil).should be(false)
       end
     end
 
     describe 'when provide a nil value when not required' do
       it 'should return false' do
-        @property = @type.new(@model, @name, :required => false)
+        @property = @type.new(@model, @name, @options.merge(:required => false))
         @property.valid?(nil).should be(true)
       end
     end

data/lib/dm-core/spec/shared/semipublic/query/conditions/abstract_comparison_spec.rb

@@ -0,0 +1,261 @@
+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

data/lib/dm-core/support/deprecate.rb

@@ -3,7 +3,7 @@ module DataMapper
     def deprecate(old_method, new_method)
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{old_method}(*args, &block)
-          warn "\#{self.class}##{old_method} is deprecated, use \#{self.class}##{new_method} instead (\#{caller[0]})"
+          warn "\#{self.class}##{old_method} is deprecated, use \#{self.class}##{new_method} instead (\#{caller.first})"
           send(#{new_method.inspect}, *args, &block)
         end
       RUBY

data/lib/dm-core/support/descendant_set.rb

@@ -1,3 +1,5 @@
+require 'dm-core/support/subject_set'
+
 module DataMapper
   class DescendantSet
     include Enumerable
@@ -7,11 +9,9 @@ module DataMapper
     # @param [#to_ary] descendants
     #   initialize with the descendants
     #
-    # @return [undefined]
-    #
     # @api private
     def initialize(descendants = [])
-      @descendants = descendants.to_ary
+      @descendants = SubjectSet.new(descendants)
     end
 
     # Copy a DescendantSet instance
@@ -19,8 +19,6 @@ module DataMapper
     # @param [DescendantSet] original
     #   the original descendants
     #
-    # @return [undefined]
-    #
     # @api private
     def initialize_copy(original)
       @descendants = @descendants.dup
@@ -80,5 +78,14 @@ module DataMapper
       @descendants.empty?
     end
 
+    # Removes all entries and returns self
+    #
+    # @return [DescendantSet] self
+    #
+    # @api private
+    def clear
+      @descendants.clear
+    end
+
   end # class DescendantSet
 end # module DataMapper

data/lib/dm-core/support/ordered_set.rb

@@ -0,0 +1,382 @@
+require 'dm-core/support/equalizer'
+
+module DataMapper
+
+  # An ordered set of things
+  #
+  # {OrderedSet} implements set behavior and keeps
+  # track of the order in which entries were added.
+  #
+  # {OrderedSet} allows to inject a class that implements
+  # {OrderedSet::Cache::API} at construction time, and will
+  # use that cache implementation to enforce set semantics
+  # and perform internal caching of insertion order.
+  #
+  # @see OrderedSet::Cache::API
+  # @see OrderedSet::Cache
+  # @see SubjectSet::NameCache
+  #
+  # @api private
+  class OrderedSet
+
+    # The default cache used by {OrderedSet}
+    #
+    # Uses a {Hash} as internal storage and enforces set semantics
+    # by calling #eql? and #hash on the set's entries.
+    #
+    # @api private
+    class Cache
+
+      # The default implementation of the {API} that {OrderedSet} expects from
+      # the cache object that it uses to
+      #
+      #     1. keep track of insertion order
+      #     2. enforce set semantics.
+      #
+      # Classes including {API} must customize the behavior of the cache in 2 ways:
+      #
+      # They must determine the value to use as cache key and thus set discriminator,
+      # by implementing the {#key_for} method. The {#key_for} method accepts an arbitrary
+      # object as param and the method is free to return whatever value from that method.
+      # Obviously this will most likely be some attribute or value otherwise derived from
+      # the object that got passed in.
+      #
+      # They must determine which objects are valid set entries by overwriting the
+      # {#valid?} method. The {#valid?} method accepts an arbitrary object as param and
+      # the overwriting method must return either true or false.
+      #
+      # The motivation behind this is that set semantics cannot always be enforced
+      # by calling {#eql?} and {#hash} on the set's entries. For example, two entries
+      # might be considered unique wrt the set if their names are the same, but other
+      # internal state differs. This is exactly the case for {DataMapper::Property} and
+      # {DataMapper::Associations::Relationship} objects.
+      #
+      # @see DataMapper::SubjectSet::NameCache
+      #
+      # @api private
+      module API
+
+        # Initialize a new Cache
+        #
+        # @api private
+        def initialize
+          @cache = {}
+        end
+
+        # Tests if the given entry qualifies to be added to the cache
+        #
+        # @param [Object] entry
+        #   the entry to be checked
+        #
+        # @return [Boolean]
+        #   true if the entry qualifies to be added to the cache
+        #
+        # @api private
+        def valid?(entry)
+          raise NotImplementedError, "#{self}#valid? must be implemented"
+        end
+
+        # Given an entry, return the key to be used in the cache
+        #
+        # @param [Object] entry
+        #   the entry to get the key for
+        #
+        # @return [Object, nil]
+        #   a value derived from the entry that is used as key in the cache
+        #
+        # @api private
+        def key_for(entry)
+          raise NotImplementedError, "#{self}#key_for must be implemented"
+        end
+
+        # Check if the entry exists in the cache
+        #
+        # @param [Object] entry
+        #   the entry to test for
+        #
+        # @return [Boolean]
+        #   true if entry is included in the cache
+        #
+        # @api private
+        def include?(entry)
+          @cache.has_key?(key_for(entry))
+        end
+
+        # Return the index for the entry in the cache
+        #
+        # @param [Object] entry
+        #   the entry to get the index for
+        #
+        # @return [Integer, nil]
+        #   the index for the entry, or nil if it does not exist
+        #
+        # @api private
+        def [](entry)
+          @cache[key_for(entry)]
+        end
+
+        # Set the index for the entry in the cache
+        #
+        # @param [Object] entry
+        #   the entry to set the index for
+        # @param [Integer] index
+        #   the index to assign to the given entry
+        #
+        # @return [Integer]
+        #   the given index for the entry
+        #
+        # @api private
+        def []=(entry, index)
+          if valid?(entry)
+            @cache[key_for(entry)] = index
+          end
+        end
+
+        # Delete an entry from the cache
+        #
+        # @param [Object] entry
+        #   the entry to delete from the cache
+        #
+        # @return [API] self
+        #
+        # @api private
+        def delete(entry)
+          deleted_index = @cache.delete(key_for(entry))
+          if deleted_index
+            @cache.each do |key, index|
+              @cache[key] -= 1 if index > deleted_index
+            end
+          end
+          deleted_index
+        end
+
+        # Removes all entries and returns self
+        #
+        # @return [API] self
+        #
+        # @api private
+        def clear
+          @cache.clear
+          self
+        end
+
+      end # module API
+
+      include API
+
+      # Tests if the given entry qualifies to be added to the cache
+      #
+      # @param [Object] entry
+      #   the entry to be checked
+      #
+      # @return [true] true
+      #
+      # @api private
+      def valid?(entry)
+        true
+      end
+
+      # Given an entry, return the key to be used in the cache
+      #
+      # @param [Object] entry
+      #   the entry to get the key for
+      #
+      # @return [Object]
+      #   the passed in entry
+      #
+      # @api private
+      def key_for(entry)
+        entry
+      end
+
+    end # class Cache
+
+    include Enumerable
+    extend  Equalizer
+
+    # This set's entries
+    #
+    # The order in this Array is not guaranteed
+    # to be the order in which the entries were
+    # inserted. Use #each to access the entries
+    # in insertion order.
+    #
+    # @return [Array]
+    #  this set's entries
+    #
+    # @api private
+    attr_reader :entries
+
+    equalize :entries
+
+    # Initialize an OrderedSet
+    #
+    # @param [#each] entries
+    #   the entries to initialize this set with
+    # @param [Class<Cache::API>] cache
+    #   the cache implementation to use
+    #
+    # @api private
+    def initialize(entries = [], cache = Cache)
+      @cache   = cache.new
+      @entries = []
+      merge(entries.to_ary)
+    end
+
+    # Initialize a copy of OrderedSet
+    #
+    # @api private
+    def initialize_copy(*)
+      @cache   = @cache.dup
+      @entries = @entries.dup
+    end
+
+    # Get the entry at the given index
+    #
+    # @param [Integer] index
+    #   the index of the desired entry
+    #
+    # @return [Object, nil]
+    #   the entry at the given index, or nil if no entry is present
+    #
+    # @api private
+    def [](index)
+      entries[index]
+    end
+
+    # Add or update an entry in the set
+    #
+    # If the entry to add isn't part of the set already,
+    # it will be added. If an entry with the same cache
+    # key as the entry to add is part of the set already,
+    # it will be replaced with the given entry.
+    #
+    # @param [Object] entry
+    #   the entry to be added
+    #
+    # @return [OrderedSet] self
+    #
+    # @api private
+    def <<(entry)
+      if index = @cache[entry]
+        entries[index] = entry
+      else
+        @cache[entry] = size
+        entries << entry
+      end
+      self
+    end
+
+    # Merge with another Enumerable object
+    #
+    # @param [#each] other
+    #   the Enumerable to merge with this OrderedSet
+    #
+    # @return [OrderedSet] self
+    #
+    # @api private
+    def merge(other)
+      other.each { |entry| self << entry }
+      self
+    end
+
+    # Delete an entry from this OrderedSet
+    #
+    # @param [Object] entry
+    #   the entry to delete
+    #
+    # @return [Object, nil]
+    #   the deleted entry or nil
+    #
+    # @api private
+    def delete(entry)
+      if index = @cache.delete(entry)
+        entries.delete_at(index)
+      end
+    end
+
+    # Removes all entries and returns self
+    #
+    # @return [OrderedSet] self
+    #
+    # @api private
+    def clear
+      @cache.clear
+      entries.clear
+      self
+    end
+
+    # Iterate over each entry in the set
+    #
+    # @yield [entry]
+    #   all entries in the set
+    #
+    # @yieldparam [Object] entry
+    #   an entry in the set
+    #
+    # @return [OrderedSet] self
+    #
+    # @api private
+    def each
+      entries.each { |entry| yield(entry) }
+      self
+    end
+
+    # The number of entries
+    #
+    # @return [Integer]
+    #   the number of entries
+    #
+    # @api private
+    def size
+      entries.size
+    end
+
+    # Check if there are any entries
+    #
+    # @return [Boolean]
+    #   true if the set is empty
+    #
+    # @api private
+    def empty?
+      entries.empty?
+    end
+
+    # Check if the entry exists in the set
+    #
+    # @param [Object] entry
+    #   the entry to test for
+    #
+    # @return [Boolean]
+    #   true if entry is included in the set
+    #
+    # @api private
+    def include?(entry)
+      entries.include?(entry)
+    end
+
+    # Return the index for the entry in the set
+    #
+    # @param [Object] entry
+    #   the entry to check the set for
+    #
+    # @return [Integer, nil]
+    #   the index for the entry, or nil if it does not exist
+    #
+    # @api private
+    def index(entry)
+      @cache[entry]
+    end
+
+    # Convert the OrderedSet into an Array
+    #
+    # @return [Array]
+    #   an array containing all the OrderedSet's entries
+    #
+    # @api private
+    def to_ary
+      entries
+    end
+
+  end # class OrderedSet
+end # module DataMapper