mongoid-siblings 0.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Douwe Maan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+# mongoid-siblings
+
+mongoid-siblings adds methods to enable you to easily access your Mongoid 
+document's siblings.
+
+## Requirements
+
+* mongoid (~> 3.0)
+
+## Installation
+
+Add the following to your Gemfile:
+
+```ruby
+gem "mongoid-siblings"
+```
+
+And tell Bundler to install the new gem:
+
+```
+bundle install
+```
+
+## Usage
+
+Include the `Mongoid::Siblings` module in your document class:
+
+```ruby
+class Book
+  include Mongoid::Document
+  include Mongoid::Siblings
+
+  belongs_to :publisher
+  belongs_to :author
+
+  ...
+end
+```
+
+You will now have access to the following methods:
+
+```ruby
+# Find all books by this book's author, not including this book.
+book.siblings(scope: :author)
+
+# Find all books by this book's author.
+book.siblings_and_self(scope: :author)
+
+# Check whether a certain book was published by the same publisher as this book.
+book.sibling_of?(other_book, scope: :publisher)
+
+# Make this book a sibling of a book with another author and publisher.
+# This will set this books author and publisher to match that of the other book.
+book.sibling_of!(other_book, scope: [:author, :publisher])
+```
+
+## Full documentation
+See [this project's RubyDoc.info page](http://rubydoc.info/github/DouweM/mongoid-siblings/master/frames).
+
+## Known issues
+See [the GitHub Issues page](https://github.com/DouweM/mongoid-siblings/issues).
+
+## License
+Copyright (c) 2012 Douwe Maan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,17 @@
+require "rspec/core/rake_task"
+
+spec = Gem::Specification.load("mongoid-siblings.gemspec")
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+desc "Build the .gem file"
+task :build do
+  system "gem build #{spec.name}.gemspec"
+end
+
+desc "Push the .gem file to rubygems.org"
+task release: :build do
+  system "gem push #{spec.name}-#{spec.version}.gem"
+end

data/lib/mongoid/siblings.rb

@@ -0,0 +1,202 @@
+module Mongoid
+
+  # Adds methods to easily access your document's siblings.
+  module Siblings
+    extend ActiveSupport::Concern
+    
+    included do
+      cattr_accessor :default_sibling_scope
+    end
+
+    # Returns this document's siblings.
+    #
+    # @example Retrieve document's siblings
+    #   book.siblings
+    #
+    # @see {#siblings_and_self}
+    def siblings(options = {})
+      self.siblings_and_self(options).excludes(id: self.id)
+    end
+    
+    # Returns this document's siblings and itself.
+    #
+    # @example Retrieve document's siblings and itself within a certain scope.
+    #   book.siblings_and_self(scope: :author)
+    #
+    # @example Retrieve what would be document's siblings if it had another scope value.
+    #   
+    #   book.siblings_and_self(
+    #     scope:        :author, 
+    #     scope_values: { 
+    #       author: other_author 
+    #     }
+    #   )
+    #
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ Array<Symbol>, Symbol ] scope One or more relations or 
+    #   attributes that siblings of this object need to have in common.
+    # @option options [ Hash<Symbol, Object> ] scope_values Optional alternative
+    #   values to use to determine siblingship.
+    #
+    # @return [ Mongoid::Criteria ] Criteria to retrieve the document's siblings.
+    def siblings_and_self(options = {})
+      scopes        = options[:scope]         || self.default_sibling_scope
+      scope_values  = options[:scope_values]  || {}
+
+      scopes = Array.wrap(scopes).compact
+
+      
+      criteria = base_document_class.all
+
+      detail_scopes = []
+
+      # Find out what scope determines the root criteria. This can be 
+      # [klass].all or self.[relation].
+      # It is assumed that for `scopes: [:rel1, :rel2]`, sibling objects always
+      # have the same `rel1` *and* `rel2`, and that two objects with the same
+      # `rel1` will always have the same `rel2`.
+      scopes.reverse_each do |scope|
+        scope_value = scope_values.fetch(scope) { self.send(scope) }
+        
+        relation_metadata = self.reflect_on_association(scope)
+        if relation_metadata && scope_value
+          proxy = self.siblings_through_relation(scope, scope_value)
+          next if proxy.nil?
+          criteria = proxy.criteria
+        else
+          detail_scopes << scope
+        end
+      end
+
+      # Apply detail criteria, to make sure siblings share every simple 
+      # attribute or nil-relation. 
+      detail_scopes.each do |scope|
+        scope_value = scope_values.fetch(scope) { self.send(scope) }
+
+        relation_metadata = self.reflect_on_association(scope)
+        scope_key = relation_metadata ? relation_metadata.key : scope
+
+        criteria = criteria.where(scope_key => scope_value)
+      end
+
+      criteria
+    end
+    
+    # Is this document a sibling of the other document?
+    #
+    # @example Is this document a sibling of the other document?
+    #   book.sibling_of?(other_book, scope: :author)
+    #
+    # @param [ Document ] other The document to check against.
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ Array<Symbol>, Symbol ] scope One or more relations and 
+    #   attributes that siblings of this object need to have in common.
+    # @option options [ Hash<Symbol, Object> ] scope_values Optional alternative
+    #   values for this document to use to determine siblings.
+    # @option options [ Hash<Symbol, Object> ] other_scope_values Optional 
+    #   alternative values for the other document to use to determine 
+    #   siblingship.
+    #
+    # @return [ Boolean ] True if the document is a sibling of the other 
+    #   document.
+    def sibling_of?(other, options = {})
+      scopes              = options[:scope]               || self.default_sibling_scope
+      scope_values        = options[:scope_values]        || {}
+      other_scope_values  = options[:other_scope_values]  || {}
+
+      scopes = Array.wrap(scopes).compact
+
+
+      return false if base_document_class != base_document_class(other)
+
+      scopes.each do |scope|
+        scope_value       = scope_values.fetch(scope)       { self.send(scope) }
+        other_scope_value = other_scope_values.fetch(scope) { other.send(scope) }
+
+        return false if scope_value != other_scope_value
+      end
+      
+      true
+    end
+    
+    # Makes this document a sibling of the other document.
+    #
+    # This is done by copying over the values used to determine siblingship 
+    # from the other document.
+    #
+    # @example Make document a sibling of the other document.
+    #   book.sibling_of!(book_of_other_author, scope: :author)
+    #
+    # @param [ Document ] other The document to become a sibling of.
+    # @param [ Hash ] options The options.
+    #
+    # @option options [ Array<Symbol>, Symbol ] scope One or more relations and 
+    #   attributes that siblings of this object need to have in common.
+    # @option options [ Hash<Symbol, Object> ] other_scope_values Optional 
+    #   alternative values to use to determine siblingship.
+    #
+    # @return [ Boolean ] True if the document was made a sibling of the other 
+    #   document.
+    def sibling_of!(other, options = {})
+      return true if self.sibling_of?(other, options)
+
+      scopes              = options[:scope]               || self.default_sibling_scope
+      other_scope_values  = options[:other_scope_values]  || {}
+
+      scopes = Array.wrap(scopes).compact
+
+
+      return false if base_document_class != base_document_class(other)
+
+      scopes.each do |scope|
+        other_scope_value = other_scope_values.fetch(scope) { other.send(scope) }
+
+        relation_metadata = self.reflect_on_association(scope)
+        if relation_metadata && other_scope_value
+          other.siblings_through_relation(scope, other_scope_value) << self
+        else
+          self.send("#{scope}=", other_scope_value)
+        end
+      end
+
+      self.save!
+    end
+
+    protected
+
+      def siblings_through_relation(name, other = nil)
+        other ||= self.send(name)
+
+        relation_metadata = self.reflect_on_association(name)
+        inverses = relation_metadata.inverses(other)
+        
+        return nil if inverses.nil? || inverses.empty?
+        
+        if inverses.length == 1
+          inverse = inverses.first
+        elsif relation_metadata.polymorphic?
+          inverse = inverses.find { |inverse| 
+            inverse == self.send(relation_metadata.inverse_of_field) 
+          }
+        else
+          inverse = inverses.find { |inverse| 
+            other.send(inverse).include?(self) 
+          }
+        end
+          
+        return nil if inverse.nil?
+        
+        other.send(inverse)
+      end
+
+      def base_document_class(doc = self)
+        base_document_klass = doc.class
+        while base_document_klass.superclass.include?(Mongoid::Document)
+          base_document_klass = base_document_klass.superclass
+        end
+        base_document_klass
+      end
+  end
+end

data/spec/mongoid/siblings_spec.rb

@@ -0,0 +1,679 @@
+require "spec_helper.rb"
+
+describe Mongoid::Siblings do
+  
+  let(:parent) { DummyParentDocument.create }
+  
+  describe "#siblings" do
+    
+    context "when using a fallback scope" do
+      
+      let(:super_parent)      { DummySuperParentDocument.create }
+      let(:parent)            { DummyParentDocument.create }
+      subject                 { DummyReferencedChildDocument.create }
+      let!(:main_sibling)     { DummyReferencedChildDocument.create(parent: parent, super_parent: super_parent) }
+      let!(:fallback_sibling) { DummyReferencedChildDocument.create(super_parent: super_parent) }
+      let!(:ultimate_sibling) { DummyReferencedChildDocument.create }
+      
+      context "when providing scope values" do
+      
+        let(:old_super_parent)  { DummySuperParentDocument.create }
+        let(:old_parent)        { DummyParentDocument.create }
+        
+        before(:each) do
+          subject.parent = parent
+          subject.super_parent = super_parent
+          subject.save
+        end
+        
+        context "when providing one scope value" do
+
+          let!(:old_main_sibling) { DummyReferencedChildDocument.create(parent: old_parent, super_parent: super_parent) }
+        
+          it "returns the subject's siblings" do
+            subject.siblings( 
+              scope:        [:parent, :super_parent], 
+              scope_values: { 
+                parent: old_parent 
+              }
+            ).to_a.should eq([old_main_sibling])
+          end
+        end
+        
+        context "when providing multiple scope values" do
+        
+          let!(:old_main_sibling)     { DummyReferencedChildDocument.create(parent: old_parent, super_parent: old_super_parent) }
+          let!(:old_fallback_sibling) { DummyReferencedChildDocument.create(super_parent: old_super_parent) }
+
+          context "when the main sibling value was nil" do
+
+            it "returns the subject's siblings" do
+              subject.siblings( 
+                scope:        [:parent, :super_parent], 
+                scope_values: { 
+                  parent:       nil, 
+                  super_parent: old_super_parent
+                }
+              ).to_a.should eq([old_fallback_sibling])
+            end
+          end
+          
+          context "when the main sibling value wasn't nil" do
+
+            it "returns the subject's siblings" do
+              subject.siblings( 
+                scope:        [:parent, :super_parent], 
+                scope_values: { 
+                  parent:       old_parent, 
+                  super_parent: old_super_parent 
+                }
+              ).to_a.should eq([old_main_sibling])
+            end
+          end
+        end
+      end
+      
+      context "when not providing scope values" do
+      
+        context "when the document has a main scope document" do
+        
+          before(:each) do
+            subject.parent = parent
+            subject.super_parent = super_parent
+            subject.save
+          end
+    
+          it "returns the subject's siblings" do
+            subject.siblings(scope: [:parent, :super_parent]).to_a.should eq([main_sibling])
+          end
+        end
+      
+        context "when the document has a fallback scope document but not a main scope document" do
+        
+          before(:each) do
+            subject.super_parent = super_parent
+            subject.save
+          end
+    
+          it "returns the subject's siblings" do
+            subject.siblings(scope: [:parent, :super_parent]).to_a.should eq([fallback_sibling])
+          end
+        end
+      
+        context "when the document has neither a main scope document or a fallback scope document" do
+    
+          it "returns the subject's siblings" do
+            subject.siblings(scope: [:parent, :super_parent]).to_a.should eq([ultimate_sibling])
+          end
+        end
+      end
+    end
+    
+    context "when using a single scope" do
+      
+      context "when providing a scope value" do
+      
+        let(:old_parent)    { DummyParentDocument.create }
+        subject             { DummyReferencedChildDocument.create(parent: parent) }
+        let!(:old_sibling)  { DummyReferencedChildDocument.create(parent: old_parent) }
+        let!(:sibling)      { DummyReferencedChildDocument.create(parent: parent) }
+        
+        it "returns the subject's siblings" do
+          subject.siblings(scope: :parent, scope_values: { parent: old_parent }).to_a.should eq([old_sibling])
+        end
+      end
+      
+      context "when not providing a scope value" do
+      
+        context "when using a referenced relation" do
+        
+          subject { DummyReferencedChildDocument.create }
+    
+          context "when using a non-polymorphic relation" do
+      
+            let!(:sibling) { DummyReferencedChildDocument.create(parent: parent) }
+      
+            before(:each) do
+              subject.parent = parent
+              subject.save
+            end
+      
+            it "returns the subject's siblings" do
+              subject.siblings(scope: :parent).to_a.should eq([sibling])
+            end
+          end
+    
+          context "when using multiple polymorphic relations" do
+      
+            let!(:sibling) { DummyReferencedChildDocument.create.tap { |doc| parent.referenced_polymorphic_children1 << doc} }
+      
+            before(:each) do
+              parent.referenced_polymorphic_children1 << subject
+              subject.save
+            end
+      
+            it "returns the subject's siblings" do
+              subject.siblings(scope: :polymorphic_parent).to_a.should eq([sibling])
+            end
+          end
+        end
+      
+        context "when using an embedded relation" do
+    
+          context "when using a non-polymorphic relation" do
+
+            subject         { DummyEmbeddedChildDocument.create(parent: parent) }
+            let!(:sibling)  { DummyEmbeddedChildDocument.create(parent: parent) }
+      
+            it "returns the subject's siblings" do
+              subject.siblings(scope: :parent).to_a.should eq([sibling])
+            end
+          end
+    
+          context "when using a polymorphic relation" do
+      
+            subject         { DummyPolymorphicEmbeddedChildDocument.create(parent: parent) }
+            let!(:sibling)  { DummyPolymorphicEmbeddedChildDocument.create(parent: parent) }
+      
+            it "returns the subject's siblings" do
+              subject.siblings(scope: :parent).to_a.should eq([sibling])
+            end
+          end
+        end
+
+        context "when using a simple attribute" do
+        
+          subject         { DummyReferencedChildDocument.create(parent: parent) }          
+          let!(:sibling)  { DummyReferencedChildDocument.create(parent: parent) }
+    
+          it "returns the subject's siblings" do
+            subject.siblings(scope: :parent_id).to_a.should eq([sibling])
+          end
+        end
+      end
+    end
+    
+    context "when not using a scope" do
+      
+      context "when a default sibling scope is set" do
+        
+        before(:each) do
+          DummyReferencedChildDocument.default_sibling_scope = :parent
+        end
+        
+        after(:each) do
+          DummyReferencedChildDocument.default_sibling_scope = nil
+        end
+        
+        subject         { DummyReferencedChildDocument.create(parent: parent) }
+        let!(:sibling)  { DummyReferencedChildDocument.create(parent: parent) }
+  
+        it "returns the subject's siblings through the default sibling scope" do
+          subject.siblings.to_a.should eq([sibling])
+        end
+      end
+      
+      context "when no default sibling scope is set" do
+      
+        subject         { DummyReferencedChildDocument.create }
+        let!(:sibling)  { DummyReferencedChildDocument.create }
+      
+        it "returns all other documents of the subject's type" do
+          subject.siblings.to_a.should eq([sibling])
+        end
+      end
+    end
+  end
+  
+  describe "#siblings_and_self" do
+      
+    subject         { DummyReferencedChildDocument.create(parent: parent) }
+    let!(:sibling)  { DummyReferencedChildDocument.create(parent: parent) }
+
+    it "returns the subject's siblings and the subject itself" do
+      subject.siblings_and_self(scope: :parent).to_a.sort.should eq([subject, sibling].sort)
+    end
+  end
+
+  describe "#sibling_of?" do
+    
+    context "when using a fallback scope" do
+      
+      let(:super_parent)      { DummySuperParentDocument.create }
+      let(:parent)            { DummyParentDocument.create }
+      subject                 { DummyReferencedChildDocument.create }
+      let!(:main_sibling)     { DummyReferencedChildDocument.create(parent: parent, super_parent: super_parent) }
+      let!(:fallback_sibling) { DummyReferencedChildDocument.create(super_parent: super_parent) }
+      let!(:ultimate_sibling) { DummyReferencedChildDocument.create }
+      
+      context "when providing scope values" do
+      
+        let(:old_super_parent)  { DummySuperParentDocument.create }
+        let(:old_parent)        { DummyParentDocument.create }
+        
+        before(:each) do
+          subject.parent = parent
+          subject.super_parent = super_parent
+          subject.save
+        end
+        
+        context "when providing one scope value" do
+
+          let!(:old_main_sibling) { DummyReferencedChildDocument.create(parent: old_parent, super_parent: super_parent) }
+        
+          context "when called with a sibling" do
+    
+            it "returns true" do
+              subject.should be_sibling_of(
+                old_main_sibling, 
+                scope:        [:parent, :super_parent], 
+                scope_values: {
+                  parent: old_parent
+                }
+              )
+            end
+          end
+        
+          context "when not called with a sibling" do
+    
+            it "returns false" do
+              subject.should_not be_sibling_of(
+                main_sibling,      
+                scope:        [:parent, :super_parent], 
+                scope_values: {
+                  parent: old_parent
+                }
+              )
+              subject.should_not be_sibling_of(
+                fallback_sibling,  
+                scope:        [:parent, :super_parent], 
+                scope_values: {
+                  parent: old_parent
+                }
+              )
+              subject.should_not be_sibling_of(
+                ultimate_sibling,  
+                scope:        [:parent, :super_parent], 
+                scope_values: {
+                  parent: old_parent
+                }
+              )
+            end
+          end
+        end
+        
+        context "when providing multiple scope values" do
+        
+          let!(:old_main_sibling)     { DummyReferencedChildDocument.create(parent: old_parent, super_parent: old_super_parent) }
+          let!(:old_fallback_sibling) { DummyReferencedChildDocument.create(super_parent: old_super_parent) }
+          
+          context "when the main sibling value was nil" do
+
+            context "when called with a sibling" do
+    
+              it "returns true" do
+                subject.should be_sibling_of(
+                  old_fallback_sibling, 
+                  scope:        [:parent, :super_parent], 
+                  scope_values: {
+                    parent:       nil, 
+                    super_parent: old_super_parent
+                  }
+                )
+              end
+            end
+        
+            context "when not called with a sibling" do
+    
+              it "returns false" do
+                subject.should_not be_sibling_of(
+                  old_main_sibling,  
+                  scope:        [:parent, :super_parent], 
+                  scope_values: {
+                    parent:       nil, 
+                    super_parent: old_super_parent
+                  }
+                )
+                subject.should_not be_sibling_of(
+                  main_sibling,      
+                  scope:        [:parent, :super_parent], 
+                  scope_values: {
+                    parent:       nil, 
+                    super_parent: old_super_parent
+                  }
+                )
+                subject.should_not be_sibling_of(
+                  fallback_sibling,  
+                  scope:        [:parent, :super_parent], 
+                  scope_values: {
+                    parent:       nil, 
+                    super_parent: old_super_parent
+                  }
+                )
+                subject.should_not be_sibling_of(
+                  ultimate_sibling,  
+                  scope:        [:parent, :super_parent], 
+                  scope_values: {
+                    parent:       nil, 
+                    super_parent: old_super_parent
+                  }
+                )
+              end
+            end
+          end
+          
+          context "when the main sibling value was not nil" do
+
+            context "when called with a sibling" do
+    
+              it "returns true" do
+                subject.should be_sibling_of(
+                  old_main_sibling, 
+                  scope:        [:parent, :super_parent], 
+                  scope_values: {
+                    parent:       old_parent, 
+                    super_parent: old_super_parent
+                  }
+                )
+              end
+            end
+        
+            context "when not called with a sibling" do
+    
+              it "returns false" do
+                subject.should_not be_sibling_of(
+                  old_fallback_sibling,  
+                  scope:        [:parent, :super_parent], 
+                  scope_values: {
+                    parent:       old_parent, 
+                    super_parent: old_super_parent
+                  }
+                )
+                subject.should_not be_sibling_of(
+                  main_sibling,          
+                  scope:        [:parent, :super_parent], 
+                  scope_values: {
+                    parent:       old_parent, 
+                    super_parent: old_super_parent
+                  }
+                )
+                subject.should_not be_sibling_of(
+                  fallback_sibling,      
+                  scope:        [:parent, :super_parent], 
+                  scope_values: {
+                    parent:       old_parent, 
+                    super_parent: old_super_parent
+                  }
+                )
+                subject.should_not be_sibling_of(
+                  ultimate_sibling,      
+                  scope:        [:parent, :super_parent], 
+                  scope_values: {
+                    parent:       old_parent, 
+                    super_parent: old_super_parent
+                  }
+                )
+              end
+            end
+          end
+        end
+      end
+      
+      context "when providing other scope values" do
+      
+        let(:old_super_parent)  { DummySuperParentDocument.create }
+        let(:old_parent)        { DummyParentDocument.create }
+        
+        before(:each) do
+          subject.parent = parent
+          subject.super_parent = super_parent
+          subject.save
+        end
+        
+        context "when providing one other scope value" do
+
+          let!(:old_main_sibling) { DummyReferencedChildDocument.create(parent: old_parent, super_parent: super_parent) }
+        
+          context "when called with a sibling" do
+    
+            it "returns true" do
+              subject.should be_sibling_of(
+                old_main_sibling, 
+                scope:              [:parent, :super_parent], 
+                other_scope_values: {
+                  parent: parent
+                }
+              )
+            end
+          end
+        end
+        
+        context "when providing multiple other scope values" do
+        
+          let!(:old_main_sibling)     { DummyReferencedChildDocument.create(parent: old_parent, super_parent: old_super_parent) }
+          let!(:old_fallback_sibling) { DummyReferencedChildDocument.create(super_parent: old_super_parent) }
+          
+          context "when the other main sibling value was nil" do
+            
+            before(:each) do
+              subject.parent = nil
+              subject.save
+            end
+
+            context "when called with a sibling" do
+    
+              it "returns true" do
+                subject.should be_sibling_of(
+                  old_fallback_sibling, 
+                  scope:              [:parent, :super_parent], 
+                  other_scope_values: {
+                    parent:       nil, 
+                    super_parent: super_parent
+                  }
+                )
+              end
+            end
+          end
+          
+          context "when the other main sibling value was not nil" do
+
+            context "when called with a sibling" do
+    
+              it "returns true" do
+                subject.should be_sibling_of(
+                  old_main_sibling, 
+                  scope:              [:parent, :super_parent], 
+                  other_scope_values: {
+                    parent:       parent, 
+                    super_parent: super_parent
+                  }
+                )
+              end
+            end
+          end
+        end
+      end
+      
+      context "when not providing scope values" do
+
+        context "when the document has a main scope document" do
+        
+          before(:each) do
+            subject.parent = parent
+            subject.super_parent = super_parent
+            subject.save
+          end
+        
+          context "when called with a sibling" do
+    
+            it "returns true" do
+              subject.should be_sibling_of(main_sibling, scope: [:parent, :super_parent])
+            end
+          end
+        
+          context "when not called with a sibling" do
+    
+            it "returns false" do
+              subject.should_not be_sibling_of(fallback_sibling, scope: [:parent, :super_parent])
+              subject.should_not be_sibling_of(ultimate_sibling, scope: [:parent, :super_parent])
+            end
+          end
+        end
+      
+        context "when the document has a fallback scope document but not a main scope document" do
+        
+          before(:each) do
+            subject.super_parent = super_parent
+            subject.save
+          end
+        
+          context "when called with a sibling" do
+    
+            it "returns true" do
+              subject.should be_sibling_of(fallback_sibling, scope: [:parent, :super_parent])
+            end
+          end
+        
+          context "when not called with a sibling" do
+    
+            it "returns false" do
+              subject.should_not be_sibling_of(main_sibling,      scope: [:parent, :super_parent])
+              subject.should_not be_sibling_of(ultimate_sibling,  scope: [:parent, :super_parent])
+            end
+          end
+        end
+      
+        context "when the document has neither a main scope document or a fallback scope document" do
+        
+          context "when called with a sibling" do
+    
+            it "returns true" do
+              subject.should be_sibling_of(ultimate_sibling, scope: [:parent, :super_parent])
+            end
+          end
+        
+          context "when not called with a sibling" do
+    
+            it "returns false" do
+              subject.should_not be_sibling_of(main_sibling,      scope: [:parent, :super_parent])
+              subject.should_not be_sibling_of(fallback_sibling,  scope: [:parent, :super_parent])
+            end
+          end
+        end
+      end
+    end
+    
+    context "when using a scope" do
+      
+      context "when called with a sibling" do
+        
+        subject       { DummyReferencedChildDocument.create(parent: parent) }
+        let(:sibling) { DummyReferencedChildDocument.create(parent: parent) }
+      
+        it "returns true" do
+          subject.should be_sibling_of(sibling, scope: :parent)
+        end
+      end
+      
+      context "when not called with a sibling" do
+        
+        subject             { DummyReferencedChildDocument.create(parent: parent) }
+        let(:other_parent)  { DummyParentDocument.create }
+        let(:non_sibling)   { DummyReferencedChildDocument.create(parent: other_parent) }
+      
+        it "returns false" do
+          subject.should_not be_sibling_of(non_sibling, scope: :parent)
+        end
+      end
+    end
+    
+    context "when not using a scope" do
+      
+      context "when called with a sibling" do
+        
+        subject       { DummyReferencedChildDocument.create }
+        let(:sibling) { DummyReferencedChildDocument.create }
+      
+        it "returns true" do
+          subject.should be_sibling_of(sibling)
+        end
+      end
+      
+      context "when not called with a sibling" do
+        
+        subject { DummyReferencedChildDocument.create }
+      
+        it "returns false" do
+          subject.should_not be_sibling_of(parent)
+        end
+      end
+    end
+  end
+
+  describe "#sibling_of!" do
+
+    context "when called with a sibling" do
+      
+      let(:parent)    { DummyParentDocument.create }
+      subject         { DummyReferencedChildDocument.create(parent: parent) }
+      let!(:sibling)  { DummyReferencedChildDocument.create(parent: parent) }
+
+      it "returns true" do
+        subject.sibling_of!(sibling, scope: :parent).should be_true
+      end
+
+      it "doesn't save the subject" do
+        subject.should_not_receive(:save!)
+
+        subject.sibling_of!(sibling, scope: :parent)
+      end
+    end
+
+    context "when not called with a sibling" do
+
+      context "when called with an object that can never be a sibling" do
+
+        let(:parent)        { DummyParentDocument.create }
+        subject             { DummyReferencedChildDocument.create(parent: parent) }
+        let!(:non_sibling)  { DummyParentDocument.create }
+
+        it "returns false" do
+          subject.sibling_of!(non_sibling, scope: :parent).should be_false
+        end
+      end
+
+      context "when called with an object that could be a sibling" do
+
+        let(:super_parent)  { DummySuperParentDocument.create }
+        let(:parent)        { DummyParentDocument.create }
+        subject             { DummyReferencedChildDocument.create }
+        let!(:new_sibling)  { DummyReferencedChildDocument.create(parent_id: parent.id, super_parent: super_parent) }
+
+        let(:options)       { [new_sibling, scope: [:parent_id, :super_parent]] }
+
+        it "copies the scope values from the object to the subject" do
+          subject.sibling_of!(*options)
+
+          subject.parent_id.should eq(new_sibling.parent_id)
+          subject.super_parent.should eq(new_sibling.super_parent)
+        end
+
+        it "saves the subject" do
+          subject.should_receive(:save!)
+
+          subject.sibling_of!(*options)
+        end
+
+        it "returns true" do
+          subject.sibling_of!(*options).should be_true
+        end
+
+        it "makes the subject a sibling of the object" do
+          subject.sibling_of!(*options).should be_true
+
+          subject.should be_sibling_of(*options)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require "rubygems"
+require "bundler/setup"
+
+require "mongoid"
+require "mongoid/siblings"
+
+require "rspec"
+
+Mongoid.configure do |config|
+  config.connect_to "mongoid_siblings_test"
+end
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.after :each do
+    Mongoid::Config.purge!
+  end
+end

data/spec/support/models.rb

@@ -0,0 +1,49 @@
+class DummySuperParentDocument
+  include Mongoid::Document
+  
+  has_many :children, class_name: "DummyReferencedChildDocument",
+                      inverse_of: :super_parent
+end
+
+class DummyParentDocument
+  include Mongoid::Document
+  
+  has_many :referenced_children,              class_name: "DummyReferencedChildDocument",
+                                              inverse_of: :parent
+  has_many :referenced_polymorphic_children1, class_name: "DummyReferencedChildDocument",
+                                              as:         :polymorphic_parent
+  has_many :referenced_polymorphic_children2, class_name: "DummyReferencedChildDocument",
+                                              as:         :polymorphic_parent
+
+  embeds_many :embedded_children,             class_name: "DummyEmbeddedChildDocument",
+                                              inverse_of: :parent
+  embeds_many :embedded_polymorphic_children, class_name: "DummyPolymorphicEmbeddedChildDocument",
+                                              as:         :parent
+end
+
+class DummyReferencedChildDocument
+  include Mongoid::Document
+  include Mongoid::Siblings
+  
+  belongs_to :super_parent, class_name: DummySuperParentDocument.to_s,
+                            inverse_of: :children
+  
+  belongs_to :parent, class_name: DummyParentDocument.to_s,
+                      inverse_of: :referenced_children
+  belongs_to :polymorphic_parent, polymorphic: true
+end
+
+class DummyEmbeddedChildDocument
+  include Mongoid::Document
+  include Mongoid::Siblings
+  
+  embedded_in :parent,  class_name: DummyParentDocument.to_s,
+                        inverse_of: :embedded_children
+end
+
+class DummyPolymorphicEmbeddedChildDocument
+  include Mongoid::Document
+  include Mongoid::Siblings
+  
+  embedded_in :parent, polymorphic: true
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-siblings
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Douwe Maan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: &70235283618700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70235283618700
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70235283618220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70235283618220
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70235283617640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70235283617640
+description: mongoid-siblings adds methods to enable you to easily access your Mongoid
+  document's siblings.
+email: douwe@selenight.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mongoid/siblings.rb
+- LICENSE
+- README.md
+- Rakefile
+- Gemfile
+- spec/mongoid/siblings_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+homepage: https://github.com/DouweM/mongoid-siblings
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1413753754356574329
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1413753754356574329
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Easy access to your Mongoid document's siblings.
+test_files:
+- spec/mongoid/siblings_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb