compo 0.1.5 → 0.2.0

data/spec/hash_composite_shared_examples.rb

@@ -0,0 +1,208 @@
+require 'compo'
+require 'composite_shared_examples'
+
+shared_examples 'a hash composite' do
+  it_behaves_like 'a composite'
+
+  let(:child1) { double(:child1) }
+  let(:child2) { double(:child2) }
+  let(:child3) { double(:child3) }
+
+  before(:each) do
+    allow(child1).to receive(:update_parent)
+    allow(child2).to receive(:update_parent)
+    allow(child3).to receive(:update_parent)
+  end
+
+  describe '#add' do
+    context 'when the ID is occupied' do
+      before(:each) { subject.add(:a, child1) }
+      it 'returns the new child' do
+        expect(subject.add(:a, child2)).to eq(child2)
+      end
+
+      it 'replaces the old child in the child hash' do
+        expect(subject.children).to eq(a: child1)
+
+        subject.add(:a, child2)
+        expect(subject.children).to eq(a: child2)
+      end
+
+      it 'calls #update_parent on the new child with itself and an ID proc' do
+        expect(child2).to receive(:update_parent).once do |parent, proc|
+          expect(parent).to eq(subject)
+          expect(proc.call).to eq(:a)
+        end
+        subject.add(:a, child2)
+      end
+
+      it 'calls #update_parent on the old child with a Parentless' do
+        expect(child1).to receive(:update_parent).once do |parent, _|
+          expect(parent).to be_a(Compo::Parentless)
+        end
+        subject.add(:a, child2)
+      end
+
+      it 'calls #update_parent on the old child with nil-returning ID proc' do
+        expect(child1).to receive(:update_parent).once do |_, idp|
+          expect(idp.call).to be_nil
+        end
+        subject.add(:a, child2)
+      end
+    end
+
+    context 'when the ID is not occupied' do
+      it 'returns the child' do
+        expect(subject.add(:a, child1)).to eq(child1)
+        expect(subject.add(:b, child2)).to eq(child2)
+        expect(subject.add(:c, child3)).to eq(child3)
+      end
+
+      it 'adds to the child hash' do
+        expect(subject.children).to eq({})
+
+        subject.add(:a, child1)
+        expect(subject.children).to eq(a: child1)
+
+        subject.add(:b, child2)
+        expect(subject.children).to eq(a: child1, b: child2)
+
+        subject.add(:c, child3)
+        expect(subject.children).to eq(a: child1, b: child2, c: child3)
+      end
+
+      it 'calls #update_parent on the child with itself and an ID proc' do
+        expect(child1).to receive(:update_parent) do |parent, proc|
+          expect(parent).to eq(subject)
+          expect(proc.call).to eq(:a)
+        end
+        subject.add(:a, child1)
+      end
+    end
+  end
+
+  describe '#remove' do
+    context 'when the child exists in the hash' do
+      before(:each) { subject.add(:a, child1) }
+
+      it 'returns the child' do
+        expect(subject.remove(child1)).to eq(child1)
+      end
+
+      it 'calls #update_parent on the child with a Parentless' do
+        expect(child1).to receive(:update_parent).once do |parent, _|
+          expect(parent).to be_a(Compo::Parentless)
+        end
+        subject.remove(child1)
+      end
+
+      it 'calls #update_parent on the child with a nil-returning ID proc' do
+        expect(child1).to receive(:update_parent).once do |_, idp|
+          expect(idp.call).to be_nil
+        end
+        subject.remove(child1)
+      end
+
+      it 'removes the child, and only the child, from the children hash' do
+        subject.add(:b, child2)
+        subject.add(:c, child3)
+        expect(subject.children).to eq(a: child1, b: child2, c: child3)
+        subject.remove(child2)
+        expect(subject.children).to eq(a: child1, c: child3)
+      end
+    end
+
+    context 'when the child does not exist in the hash' do
+      specify { expect(subject.remove(child1)).to be_nil }
+
+      it 'does not change the children' do
+        expect(subject.children).to eq({})
+        subject.remove(child1)
+        expect(subject.children).to eq({})
+
+        subject.add(:a, child1)
+        subject.add(:b, child2)
+        expect(subject.children).to eq(a: child1, b: child2)
+        subject.remove(child3)
+        expect(subject.children).to eq(a: child1, b: child2)
+      end
+    end
+  end
+
+  describe '#remove_id' do
+    context 'when the ID exists' do
+      before(:each) { subject.add(:a, child1) }
+
+      it 'returns the child' do
+        expect(subject.remove_id(:a)).to eq(child1)
+      end
+
+      it 'calls #update_parent on the child with a Parentless' do
+        expect(child1).to receive(:update_parent).once do |parent, _|
+          expect(parent).to be_a(Compo::Parentless)
+        end
+        subject.remove_id(:a)
+      end
+
+      it 'calls #update_parent on the child with a nil-returning ID proc' do
+        expect(child1).to receive(:update_parent).once do |_, idp|
+          expect(idp.call).to be_nil
+        end
+        subject.remove_id(:a)
+      end
+
+      it 'does not change the IDs of other children' do
+        subject.add(:b, child2)
+        subject.add(:c, child3)
+        expect(subject.children).to eq(a: child1, b: child2, c: child3)
+        subject.remove_id(:b)
+        expect(subject.children).to eq(a: child1, c: child3)
+      end
+    end
+
+    context 'when the ID does not exist' do
+      specify { expect(subject.remove_id(:a)).to be_nil }
+
+      it 'does not change the children' do
+        expect(subject.children).to eq({})
+        subject.remove_id(:a)
+        expect(subject.children).to eq({})
+
+        subject.add(:a, child1)
+        subject.add(:b, child2)
+        expect(subject.children).to eq(a: child1, b: child2)
+        subject.remove_id(:c)
+        expect(subject.children).to eq(a: child1, b: child2)
+      end
+    end
+  end
+
+  describe '#children' do
+    context 'when the hash has no children' do
+      it 'returns the empty hash' do
+        expect(subject.children).to eq({})
+      end
+    end
+
+    context 'when the hash has children' do
+      it 'returns the current hash' do
+        expect(subject.children).to eq({})
+
+        subject.add(:a, child1)
+        expect(subject.children).to eq(a: child1)
+
+        subject.add(:b, child2)
+        expect(subject.children).to eq(a: child1, b: child2)
+
+        subject.add(:c, child3)
+        expect(subject.children).to eq(a: child1, b: child2, c: child3)
+
+        subject.remove(child2)
+        expect(subject.children).to eq(a: child1, c: child3)
+
+        subject.add(:a, child2)
+        expect(subject.children).to eq(a: child2, c: child3)
+      end
+    end
+  end
+end

data/spec/hash_composite_spec.rb

@@ -1,184 +1,7 @@
 require 'spec_helper'
 require 'compo'
+require 'hash_composite_shared_examples'
 
 describe Compo::HashComposite do
-  let(:child1) { double(:child1) }
-  let(:child2) { double(:child2) }
-  let(:child3) { double(:child3) }
-
-  before(:each) do
-    allow(child1).to receive(:update_parent)
-    allow(child1).to receive(:remove_parent)
-
-    allow(child2).to receive(:update_parent)
-    allow(child2).to receive(:remove_parent)
-
-    allow(child3).to receive(:update_parent)
-    allow(child3).to receive(:remove_parent)
-  end
-
-  describe '#add' do
-    context 'when the ID is occupied' do
-      before(:each) { subject.add(:a, child1) }
-      it 'returns the new child' do
-        expect(subject.add(:a, child2)).to eq(child2)
-      end
-
-      it 'replaces the old child in the child hash' do
-        expect(subject.children).to eq(a: child1)
-
-        subject.add(:a, child2)
-        expect(subject.children).to eq(a: child2)
-      end
-
-      it 'calls #update_parent on the new child with itself and an ID proc' do
-        expect(child2).to receive(:update_parent).once do |parent, proc|
-          expect(parent).to eq(subject)
-          expect(proc.call).to eq(:a)
-        end
-        subject.add(:a, child2)
-      end
-
-      it 'calls #remove_parent on the old child' do
-        expect(child1).to receive(:remove_parent).once.with(no_args)
-        subject.add(:a, child2)
-      end
-    end
-
-    context 'when the ID is not occupied' do
-      it 'returns the child' do
-        expect(subject.add(:a, child1)).to eq(child1)
-        expect(subject.add(:b, child2)).to eq(child2)
-        expect(subject.add(:c, child3)).to eq(child3)
-      end
-
-      it 'adds to the child hash' do
-        expect(subject.children).to eq({})
-
-        subject.add(:a, child1)
-        expect(subject.children).to eq(a: child1)
-
-        subject.add(:b, child2)
-        expect(subject.children).to eq(a: child1, b: child2)
-
-        subject.add(:c, child3)
-        expect(subject.children).to eq(a: child1, b: child2, c: child3)
-      end
-
-      it 'calls #update_parent on the child with itself and an ID proc' do
-        expect(child1).to receive(:update_parent) do |parent, proc|
-          expect(parent).to eq(subject)
-          expect(proc.call).to eq(:a)
-        end
-        subject.add(:a, child1)
-      end
-    end
-  end
-
-  describe '#remove' do
-    context 'when the child exists in the hash' do
-      before(:each) { subject.add(:a, child1) }
-
-      it 'returns the child' do
-        expect(subject.remove(child1)).to eq(child1)
-      end
-
-      it 'calls #remove_parent on the child' do
-        expect(child1).to receive(:remove_parent).once.with(no_args)
-        subject.remove(child1)
-      end
-
-      it 'removes the child, and only the child, from the children hash' do
-        subject.add(:b, child2)
-        subject.add(:c, child3)
-        expect(subject.children).to eq(a: child1, b: child2, c: child3)
-        subject.remove(child2)
-        expect(subject.children).to eq(a: child1, c: child3)
-      end
-    end
-
-    context 'when the child does not exist in the hash' do
-      specify { expect(subject.remove(child1)).to be_nil }
-
-      it 'does not change the children' do
-        expect(subject.children).to eq({})
-        subject.remove(child1)
-        expect(subject.children).to eq({})
-
-        subject.add(:a, child1)
-        subject.add(:b, child2)
-        expect(subject.children).to eq(a: child1, b: child2)
-        subject.remove(child3)
-        expect(subject.children).to eq(a: child1, b: child2)
-      end
-    end
-  end
-
-  describe '#remove_id' do
-    context 'when the ID exists' do
-      before(:each) { subject.add(:a, child1) }
-
-      it 'returns the child' do
-        expect(subject.remove_id(:a)).to eq(child1)
-      end
-
-      it 'calls #remove_parent on the child' do
-        expect(child1).to receive(:remove_parent).once.with(no_args)
-        subject.remove_id(:a)
-      end
-
-      it 'does not change the IDs of other children' do
-        subject.add(:b, child2)
-        subject.add(:c, child3)
-        expect(subject.children).to eq(a: child1, b: child2, c: child3)
-        subject.remove_id(:b)
-        expect(subject.children).to eq(a: child1, c: child3)
-      end
-    end
-
-    context 'when the ID does not exist' do
-      specify { expect(subject.remove_id(:a)).to be_nil }
-
-      it 'does not change the children' do
-        expect(subject.children).to eq({})
-        subject.remove_id(:a)
-        expect(subject.children).to eq({})
-
-        subject.add(:a, child1)
-        subject.add(:b, child2)
-        expect(subject.children).to eq(a: child1, b: child2)
-        subject.remove_id(:c)
-        expect(subject.children).to eq(a: child1, b: child2)
-      end
-    end
-  end
-
-  describe '#children' do
-    context 'when the hash has no children' do
-      it 'returns the empty hash' do
-        expect(subject.children).to eq({})
-      end
-    end
-
-    context 'when the hash has children' do
-      it 'returns the current hash' do
-        expect(subject.children).to eq({})
-
-        subject.add(:a, child1)
-        expect(subject.children).to eq(a: child1)
-
-        subject.add(:b, child2)
-        expect(subject.children).to eq(a: child1, b: child2)
-
-        subject.add(:c, child3)
-        expect(subject.children).to eq(a: child1, b: child2, c: child3)
-
-        subject.remove(child2)
-        expect(subject.children).to eq(a: child1, c: child3)
-
-        subject.add(:a, child2)
-        expect(subject.children).to eq(a: child2, c: child3)
-      end
-    end
-  end
+  it_behaves_like 'a hash composite'
 end

data/spec/leaf_spec.rb

@@ -1,30 +1,9 @@
 require 'spec_helper'
 require 'compo'
+require 'branch_shared_examples'
+require 'null_composite_shared_examples'
 
 describe Compo::Leaf do
-  describe '#initialize' do
-    it 'initialises with no parent' do
-      expect(subject.parent).to be_nil
-    end
-
-    it 'initialises with an ID function returning nil' do
-      expect(subject.id).to be_nil
-    end
-  end
-
-  describe '#url' do
-    context 'when the Leaf has no parent' do
-      it 'returns the empty string' do
-        expect(subject.url).to eq('')
-      end
-    end
-    context 'when the Leaf is the child of a root' do
-      let(:parent) { Compo::HashBranch.new }
-      before(:each) { subject.move_to(parent, :id) }
-
-      it 'returns /ID, where ID is the ID of the Leaf' do
-        expect(subject.url).to eq('/id')
-      end
-    end
-  end
+  it_behaves_like 'a branch'
+  it_behaves_like 'a null composite'
 end

data/spec/movable_shared_examples.rb

@@ -0,0 +1,154 @@
+require 'compo'
+
+shared_examples 'a normal call to #move_to' do
+  it 'returns itself' do
+    expect(subject.move_to(to, :test)).to eq(subject)
+  end
+
+  it 'calls #parent' do
+    expect(subject).to receive(:parent)
+    subject.move_to(to, :test)
+  end
+end
+
+shared_examples 'a removal from the old parent' do
+  it 'calls #remove on the old parent with the Movable' do
+    expect(from).to receive(:remove).once.with(subject)
+    subject.move_to(to, :test)
+  end
+end
+
+shared_examples 'an addition to the new parent' do
+  it 'calls #add on the new parent with the ID and Movable' do
+    expect(to).to_not be_nil
+    expect(to).to receive(:add).once.with(:test, subject)
+    subject.move_to(to, :test)
+  end
+end
+
+shared_examples 'a movable object' do
+  let(:old_parent)    { double(:old_parent) }
+  let(:new_parent)    { double(:new_parent) }
+  let(:remove_result) { subject }
+  let(:add_result)    { subject }
+
+  before(:each) do
+    allow(subject).to receive(:parent).and_return(old_parent)
+    allow(old_parent).to receive(:remove).and_return(remove_result)
+
+    unless new_parent.nil?
+      allow(new_parent).to receive(:add).and_return(add_result)
+    end
+  end
+
+  describe '#move_to' do
+    context 'when the receiving parent is nil' do
+      let(:new_parent) { nil }
+
+      context 'and the Movable has no parent' do
+        let(:old_parent) { Compo::Parentless.new }
+
+        it_behaves_like 'a normal call to #move_to' do
+          let(:to) { new_parent }
+        end
+      end
+
+      context 'and the Movable has a parent' do
+        it_behaves_like 'a normal call to #move_to' do
+          let(:to) { new_parent }
+        end
+
+        it_behaves_like 'a removal from the old parent' do
+          let(:to) { new_parent }
+          let(:from) { old_parent }
+        end
+      end
+    end
+
+    context 'when the receiving parent refuses to add the Movable' do
+      let(:add_result) { nil }
+
+      context 'and the Movable has no parent' do
+        let(:old_parent) { Compo::Parentless.new }
+
+        it_behaves_like 'a normal call to #move_to' do
+          let(:to) { new_parent }
+        end
+
+        it_behaves_like 'an addition to the new parent' do
+          let(:to) { new_parent }
+        end
+      end
+
+      context 'and the Movable has a parent that refuses to remove it' do
+        let(:remove_result) { nil }
+
+        it_behaves_like 'a normal call to #move_to' do
+          let(:to) { new_parent }
+        end
+
+        it_behaves_like 'a removal from the old parent' do
+          let(:to) { new_parent }
+          let(:from) { old_parent }
+        end
+      end
+
+      context 'and the Movable has a parent that allows it to be removed' do
+        it_behaves_like 'a normal call to #move_to' do
+          let(:to) { new_parent }
+        end
+
+        it_behaves_like 'a removal from the old parent' do
+          let(:to) { new_parent }
+          let(:from) { old_parent }
+        end
+
+        it_behaves_like 'an addition to the new parent' do
+          let(:to) { new_parent }
+        end
+      end
+    end
+
+    context 'when the receiving parent allows the Movable to be added' do
+      context 'and the Movable has no parent' do
+        let(:old_parent) { Compo::Parentless.new }
+
+        it_behaves_like 'a normal call to #move_to' do
+          let(:to) { new_parent }
+        end
+
+        it_behaves_like 'an addition to the new parent' do
+          let(:to) { new_parent }
+        end
+      end
+
+      context 'and the Movable has a parent that refuses to remove it' do
+        let(:remove_result) { nil }
+
+        it_behaves_like 'a normal call to #move_to' do
+          let(:to) { new_parent }
+        end
+
+        it_behaves_like 'a removal from the old parent' do
+          let(:to) { new_parent }
+          let(:from) { old_parent }
+        end
+      end
+
+      context 'and the Movable has a parent that allows it to be removed' do
+        it_behaves_like 'a normal call to #move_to' do
+          let(:to) { new_parent }
+        end
+
+        it_behaves_like 'a removal from the old parent' do
+          let(:to) { new_parent }
+          let(:from) { old_parent }
+        end
+
+        it_behaves_like 'an addition to the new parent' do
+          let(:to) { new_parent }
+        end
+      end
+    end
+  end
+end