sbf-dm-core 1.3.0.beta

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

@@ -0,0 +1,111 @@
+shared_examples 'A Collection supporting Strategic Eager Loading' do
+  describe 'using SEL when looping within a loop' do
+    before :all do
+      @many_to_many = @articles.kind_of?(DataMapper::Associations::ManyToMany::Collection)
+    end
+
+    before :all do
+      attributes = {}
+
+      unless @many_to_many
+        attributes[:author] = @author
+      end
+
+      @revision = @article.revisions.create(attributes.merge(:title => 'Revision'))
+
+      @new_article  = @article_model.create(attributes.merge(:title => 'Sample Article'))
+      @new_revision = @new_article.revisions.create(attributes.merge(:title => 'New Revision'))
+    end
+
+    before :all do
+      @original_adapter = @adapter
+
+      @adapter.singleton_class.class_eval do
+        def eql?(other)
+          super || self == other
+        end
+      end
+
+      @adapter = DataMapper::Repository.adapters[@adapter.name] = CounterAdapter.new(@adapter)
+      @repository.instance_variable_set(:@adapter, @adapter)
+      @articles.instance_variable_get(:@query).instance_variable_set(:@repository, @repository)
+    end
+
+    before :all do
+      @results = []
+
+      @articles.each do |article|
+        article.revisions.each do |revision|
+          @results << [ article, revision ]
+        end
+      end
+    end
+
+    after :all do
+      @adapter = @original_adapter
+    end
+
+    it "only executes the Adapter#read #{loaded ? 'once' : 'twice'}" do
+      expect(@adapter.counts[:read]).to eq (loaded ? 1 : 2)
+    end
+
+    it 'returns the expected results' do
+      # if the collection is already loaded, then when it iterates it will
+      # not know about the newly added articles and their revisions
+      if loaded
+        expect(@results).to eq [[@article, @revision]]
+      else
+        pending 'TODO: make m:m not kick when delegating to the relationship' if @many_to_many
+
+        expect(@results).to eq [[@article, @revision], [@new_article, @new_revision]]
+      end
+    end
+  end
+end
+
+shared_examples 'A Resource supporting Strategic Eager Loading' do
+  describe 'using SEL when inside a Collection' do
+    before :all do
+      @referrer = @user_model.create(:name => 'Referrer', :comment => @comment)
+
+      @user.update(:referrer => @referrer)
+
+      @new_user = @user_model.create(:name => 'Another User', :referrer => @referrer, :comment => @comment)
+    end
+
+    before :all do
+      @original_adapter = @adapter
+
+      @adapter.singleton_class.class_eval do
+        def eql?(other)
+          super || other == self
+        end
+      end
+
+      @adapter = DataMapper::Repository.adapters[@adapter.name] = CounterAdapter.new(@adapter)
+      @repository.instance_variable_set(:@adapter, @adapter)
+    end
+
+    before :all do
+      @results = @user_model.all.map do |user|
+        [ user, user.referrer ]
+      end
+
+      # some storage engines return the data in a different order
+      @results.sort!
+    end
+
+    after :all do
+      @adapter = @original_adapter
+    end
+
+    it 'only executes the Adapter#read twice' do
+      expect(@adapter.counts[:read]).to eq 2
+    end
+
+    it 'returns the expected results' do
+      # results are ordered alphabetically by the User name
+      expect(@results).to eq [[@new_user, @referrer], [@referrer, nil], [@user, @referrer]]
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+shared_examples 'A semipublic Property' do
+  before :all do
+    %w(@type @name @value @other_value).each do |ivar|
+      raise "+#{ivar}+ should be defined in before block" unless instance_variable_defined?(ivar)
+    end
+
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+        property :id, Serial
+      end
+    end
+
+    @model      = Blog::Article
+    @options  ||= {}
+    @property   = @type.new(@model, @name, @options)
+  end
+
+  describe '.new' do
+    describe 'when provided no options' do
+      it 'returns a Property' do
+        expect(@property).to be_kind_of(@type)
+      end
+
+      it 'sets the load_as' do
+        expect(@property.load_as).to be(@type.load_as)
+      end
+
+      it 'sets the model' do
+        expect(@property.model).to equal(@model)
+      end
+
+      it 'sets the options to the default' do
+        expect(@property.options).to eq @type.options.merge(@options)
+      end
+    end
+
+    %i(index unique_index unique lazy).each do |attribute|
+      [true, false, :title, [:title]].each do |value|
+        describe "when provided #{(options = {attribute => value}).inspect}" do
+          before :all do
+            @property = @type.new(@model, @name, @options.merge(options))
+          end
+
+          it 'returns a Property' do
+            expect(@property).to be_kind_of(@type)
+          end
+
+          it 'sets the model' do
+            expect(@property.model).to equal(@model)
+          end
+
+          it 'sets the load_as' do
+            expect(@property.load_as).to be(@type.load_as)
+          end
+
+          it "sets the options to #{options.inspect}" do
+            expect(@property.options).to eq @type.options.merge(@options.merge(options))
+          end
+        end
+      end
+
+      [[], nil].each do |value|
+        describe "when provided #{(invalid_options = {attribute => value}).inspect}" do
+          it 'raises an exception' do
+            expect {
+              @type.new(@model, @name, @options.merge(invalid_options))
+            }.to raise_error(ArgumentError, "options[#{attribute.inspect}] must be either true, false, a Symbol or an Array of Symbols")
+          end
+        end
+      end
+    end
+  end
+
+  describe '#load' do
+    subject { @property.load(@value) }
+
+    before do
+      expect(@property).to receive(:typecast).with(@value).and_return(@value)
+    end
+
+    it { is_expected.to eql(@value) }
+  end
+
+  describe '#typecast' do
+    describe "when is able to do typecasting on it's own" do
+      it 'delegates all the work to the type' do
+        return_value = double(@other_value)
+        expect(@property).to receive(:typecast_to_primitive).with(@invalid_value).and_return(return_value)
+        @property.typecast(@invalid_value)
+      end
+    end
+
+    describe 'when value is nil' do
+      it 'returns value unchanged' do
+        expect(@property.typecast(nil)).to be(nil)
+      end
+
+      describe 'when value is a Ruby primitive' do
+        it 'returns value unchanged' do
+          expect(@property.typecast(@value)).to eq @value
+        end
+      end
+    end
+  end
+
+  describe '#valid?' do
+    describe 'when provided a valid value' do
+      it 'returns true' do
+        expect(@property.valid?(@value)).to be(true)
+      end
+    end
+
+    describe 'when provide an invalid value' do
+      it 'returns false' do
+        expect(@property.valid?(@invalid_value)).to be(false)
+      end
+    end
+
+    describe 'when provide a nil value when required' do
+      it 'returns false' do
+        @property = @type.new(@model, @name, @options.merge(required: true))
+        expect(@property.valid?(nil)).to be(false)
+      end
+    end
+
+    describe 'when provide a nil value when not required' do
+      it 'returns false' do
+        @property = @type.new(@model, @name, @options.merge(required: false))
+        expect(@property.valid?(nil)).to be(true)
+      end
+    end
+  end
+
+  describe '#assert_valid_value' do
+    subject do
+      @property.assert_valid_value(value)
+    end
+
+    shared_examples 'assert_valid_value on invalid value' do
+      it 'raises DataMapper::Property::InvalidValueError' do
+        expect { subject }.to(raise_error(DataMapper::Property::InvalidValueError) do |error|
+          expect(error.property).to eq @property
+        end)
+      end
+    end
+
+    describe 'when provided a valid value' do
+      let(:value) { @value }
+
+      it 'returns true' do
+        expect(subject).to be(true)
+      end
+    end
+
+    describe 'when provide an invalid value' do
+      let(:value) { @invalid_value }
+
+      it_behaves_like 'assert_valid_value on invalid value'
+    end
+
+    describe 'when provide a nil value when required' do
+      before do
+        @property = @type.new(@model, @name, @options.merge(required: true))
+      end
+
+      let(:value) { nil }
+
+      it_behaves_like 'assert_valid_value on invalid value'
+    end
+
+    describe 'when provide a nil value when not required' do
+      before do
+        @property = @type.new(@model, @name, @options.merge(required: false))
+      end
+
+      let(:value) { nil }
+
+      it 'returns true' do
+        expect(subject).to be(true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,261 @@
+shared_examples '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 { expect(subject.class).to respond_to(:new) }
+
+  describe '.new' do
+    subject { @comparison.class.new(@property, @value) }
+
+    it { is_expected.to be_kind_of(@comparison.class) }
+
+    it { expect(subject.subject).to equal(@property) }
+
+    it { expect(subject.value).to eq @value }
+  end
+
+  it { expect(subject.class).to respond_to(:slug) }
+
+  describe '.slug' do
+    describe 'with no arguments' do
+      subject { @comparison.class.slug }
+
+      it { is_expected.to eq @slug }
+    end
+
+    describe 'with an argument' do
+      subject { @comparison.class.slug(:other) }
+
+      it { is_expected.to eq :other }
+
+      # reset the slug
+      after { @comparison.class.slug(@slug) }
+    end
+  end
+
+  it { is_expected.to 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 { is_expected.to be(true) }
+    end
+
+    describe 'when the other AbstractComparison is the same class' do
+      subject { @comparison == DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value) }
+
+      it { is_expected.to be(true) }
+    end
+
+    describe 'when the other AbstractComparison is a different class' do
+      subject { @comparison == DataMapper::Query::Conditions::Comparison.new(:other, @property, @value) }
+
+      it { is_expected.to 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 { is_expected.to 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 { is_expected.to be(false) }
+    end
+  end
+
+  it { is_expected.to 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 { is_expected.to 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 { is_expected.to 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 { is_expected.to 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 { is_expected.to 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 { is_expected.to be(false) }
+    end
+  end
+
+  it { is_expected.to respond_to(:hash) }
+
+  describe '#hash' do
+    subject { @comparison.hash }
+
+    it 'matches the same AbstractComparison with the same property and value' do
+      is_expected.to eq DataMapper::Query::Conditions::Comparison.new(@slug, @property, @value).hash
+    end
+
+    it 'does not match the same AbstractComparison with different property' do
+      is_expected.not_to eq DataMapper::Query::Conditions::Comparison.new(@slug, @other_property, @value).hash
+    end
+
+    it 'does not match the same AbstractComparison with different value' do
+      is_expected.not_to eq DataMapper::Query::Conditions::Comparison.new(@slug, @property, @other_value).hash
+    end
+
+    it 'does not match a different AbstractComparison with the same property and value' do
+      is_expected.not_to eq @other.hash
+    end
+
+    it 'does not match a different AbstractComparison with different property' do
+      is_expected.not_to eq @other.class.new(@other_property, @value).hash
+    end
+
+    it 'does not match a different AbstractComparison with different value' do
+      is_expected.not_to eq @other.class.new(@property, @other_value).hash
+    end
+  end
+
+  it { is_expected.to respond_to(:loaded_value) }
+
+  describe '#loaded_value' do
+    subject { @comparison.loaded_value }
+
+    it { is_expected.to eq @value }
+  end
+
+  it { is_expected.to respond_to(:parent) }
+
+  describe '#parent' do
+    subject { @comparison.parent }
+
+    describe 'is nil by default' do
+      it { is_expected.to be_nil }
+    end
+
+    describe 'relates to parent operation' do
+      before do
+        @operation = DataMapper::Query::Conditions::Operation.new(:and)
+        @comparison.parent = @operation
+      end
+
+      it { is_expected.to be_equal(@operation) }
+    end
+  end
+
+  it { is_expected.to respond_to(:parent=) }
+
+  describe '#parent=' do
+    before do
+      @operation = DataMapper::Query::Conditions::Operation.new(:and)
+    end
+
+    subject { @comparison.parent = @operation }
+
+    it { is_expected.to equal(@operation) }
+
+    it 'changes the parent' do
+      expect(method(:subject)).to change(@comparison, :parent)
+        .from(nil)
+        .to(@operation)
+    end
+  end
+
+  it { is_expected.to respond_to(:property?) }
+
+  describe '#property?' do
+    subject { @comparison.property? }
+
+    it { is_expected.to be(true) }
+  end
+
+  it { is_expected.to respond_to(:slug) }
+
+  describe '#slug' do
+    subject { @comparison.slug }
+
+    it { is_expected.to eq @slug }
+  end
+
+  it { is_expected.to respond_to(:subject) }
+
+  describe '#subject' do
+    subject { @comparison.subject }
+
+    it { is_expected.to be_equal(@property) }
+  end
+
+  it { is_expected.to respond_to(:valid?) }
+
+  describe '#valid?' do
+    subject { @comparison.valid? }
+
+    describe 'when the value is valid for the subject' do
+      it { is_expected.to 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 { is_expected.to be(false) }
+    end
+  end
+
+  it { is_expected.to respond_to(:value) }
+
+  describe '#value' do
+    subject { @comparison.value }
+
+    it { is_expected.to eq @value }
+  end
+end

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

@@ -0,0 +1,8 @@
+module DataMapper
+  module Assertions
+    def assert_kind_of(name, value, *klasses)
+      klasses.each { |k| return if value.kind_of?(k) }
+      raise ArgumentError, "+#{name}+ should be #{klasses.map { |k| k.name } * ' or '}, but was #{value.class.name}", caller(2)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module DataMapper
+  module Chainable
+
+    # @api private
+    def chainable(&block)
+      mod = Module.new(&block)
+      include mod
+      mod
+    end
+
+    # @api private
+    def extendable(&block)
+      mod = Module.new(&block)
+      extend mod
+      mod
+    end
+  end # module Chainable
+end # module DataMapper

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

@@ -0,0 +1,12 @@
+module DataMapper
+  module Deprecate
+    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.first})"
+          send(#{new_method.inspect}, *args, &block)
+        end
+      RUBY
+    end
+  end # module Deprecate
+end # module DataMapper

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

@@ -0,0 +1,89 @@
+module DataMapper
+  class DescendantSet
+    include Enumerable
+
+    # Initialize a DescendantSet instance
+    #
+    # @param [#to_ary] descendants
+    #   initialize with the descendants
+    #
+    # @api private
+    def initialize(descendants = [])
+      @descendants = SubjectSet.new(descendants)
+    end
+
+    # Copy a DescendantSet instance
+    #
+    # @param [DescendantSet] original
+    #   the original descendants
+    #
+    # @api private
+    def initialize_copy(original)
+      @descendants = @descendants.dup
+    end
+
+    # Add a descendant
+    #
+    # @param [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def <<(descendant)
+      @descendants << descendant
+      self
+    end
+
+    # Remove a descendant
+    #
+    # Also removes from all descendants
+    #
+    # @param [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def delete(descendant)
+      @descendants.delete(descendant)
+      each { |d| d.descendants.delete(descendant) }
+    end
+
+    # Iterate over each descendant
+    #
+    # @yield [descendant]
+    # @yieldparam [Module] descendant
+    #
+    # @return [DescendantSet]
+    #   self
+    #
+    # @api private
+    def each
+      @descendants.each do |descendant|
+        yield descendant
+        descendant.descendants.each { |dd| yield dd }
+      end
+      self
+    end
+
+    # Test if there are any descendants
+    #
+    # @return [Boolean]
+    #
+    # @api private
+    def empty?
+      @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