compo 0.1.0

data/spec/array_composite_spec.rb

@@ -0,0 +1,225 @@
+require 'spec_helper'
+require 'compo'
+
+describe Compo::ArrayComposite 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 not Numeric' do
+      specify { expect(subject.add(:mr_flibble, child1)).to be_nil }
+
+      it 'does not add to the list of children' do
+        subject.add(:rimmer, child1)
+        expect(subject.children).to eq({})
+
+        subject.add(0, child1)
+        subject.add(:lister, child2)
+        expect(subject.children).to eq(0 => child1)
+
+        subject.add(1, child2)
+        subject.add(:cat, child3)
+        expect(subject.children).to eq(0 => child1, 1 => child2)
+      end
+    end
+    context 'when the ID is Numeric' do
+      context 'and is equal to the number of children' do
+        it 'returns the child' do
+          expect(subject.add(0, child1)).to eq(child1)
+          expect(subject.add(1, child2)).to eq(child2)
+          expect(subject.add(2, child3)).to eq(child3)
+        end
+
+        it 'adds to the end of the list of children' do
+          expect(subject.children).to eq({})
+
+          subject.add(0, child1)
+          expect(subject.children).to eq(0 => child1)
+
+          subject.add(1, child2)
+          expect(subject.children).to eq(0 => child1, 1 => child2)
+
+          subject.add(2, child3)
+          expect(subject.children).to eq(0 => child1, 1 => child2, 2 => 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(0)
+          end
+          subject.add(0, child1)
+        end
+      end
+
+      context 'and is greater than the number of children' do
+        it 'returns nil' do
+          expect(subject.add(1, child1)).to be_nil
+          subject.add(0, child1)
+          expect(subject.add(2, child2)).to be_nil
+          subject.add(1, child2)
+          expect(subject.add(3, child3)).to be_nil
+        end
+
+        it 'does not add to the list of children' do
+          subject.add(1, child1)
+          expect(subject.children).to eq({})
+
+          subject.add(0, child1)
+          subject.add(2, child2)
+          expect(subject.children).to eq(0 => child1)
+
+          subject.add(1, child2)
+          subject.add(3, child3)
+          expect(subject.children).to eq(0 => child1, 1 => child2)
+        end
+      end
+
+      context 'and is less than the number of children' do
+        it 'returns the child' do
+          subject.add(0, child1)
+          expect(subject.add(0, child2)).to eq(child2)
+          expect(subject.add(1, child3)).to eq(child3)
+        end
+
+        it 'adds to the list of children at the correct position' do
+          expect(subject.children).to eq({})
+          subject.add(0, child1)
+          expect(subject.children).to eq(0 => child1)
+          subject.add(0, child2)
+          expect(subject.children).to eq(0 => child2, 1 => child1)
+          subject.add(1, child3)
+          expect(subject.children).to eq(0 => child2, 1 => child3, 2 => child1)
+        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(0)
+          end
+          subject.add(0, child2)
+          subject.add(0, child1)
+        end
+      end
+    end
+  end
+
+  describe '#remove' do
+    context 'when the child exists in the list' do
+      before(:each) { subject.add(0, 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 'moves succeeding IDs down by one' do
+        subject.add(1, child2)
+        subject.add(2, child3)
+        expect(subject.children).to eq(0 => child1, 1 => child2, 2 => child3)
+        subject.remove(child2)
+        expect(subject.children).to eq(0 => child1, 1 => child3)
+      end
+    end
+
+    context 'when the child does not exist in the list' 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(0, child1)
+        subject.add(1, child2)
+        expect(subject.children).to eq(0 => child1, 1 => child2)
+        subject.remove(child3)
+        expect(subject.children).to eq(0 => child1, 1 => child2)
+      end
+    end
+  end
+
+  describe '#remove_id' do
+    context 'when the ID exists' do
+      before(:each) { subject.add(0, child1) }
+
+      it 'returns the child' do
+        expect(subject.remove_id(0)).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(0)
+      end
+
+      it 'moves succeeding IDs down by one' do
+        subject.add(1, child2)
+        subject.add(2, child3)
+        expect(subject.children).to eq(0 => child1, 1 => child2, 2 => child3)
+        subject.remove_id(1)
+        expect(subject.children).to eq(0 => child1, 1 => child3)
+      end
+    end
+
+    context 'when the ID does not exist' do
+      specify { expect(subject.remove_id(0)).to be_nil }
+
+      it 'does not change the children' do
+        expect(subject.children).to eq({})
+        subject.remove_id(0)
+        expect(subject.children).to eq({})
+
+        subject.add(0, child1)
+        subject.add(1, child2)
+        expect(subject.children).to eq(0 => child1, 1 => child2)
+        subject.remove_id(2)
+        expect(subject.children).to eq(0 => child1, 1 => child2)
+      end
+    end
+  end
+
+  describe '#children' do
+    context 'when the list has no children' do
+      it 'returns the empty hash' do
+        expect(subject.children).to eq({})
+      end
+    end
+
+    context 'when the list has children' do
+      it 'returns a hash mapping their current indices to themselves' do
+        expect(subject.children).to eq({})
+
+        subject.add(0, child1)
+        expect(subject.children).to eq(0 => child1)
+
+        subject.add(1, child2)
+        expect(subject.children).to eq(0 => child1, 1 => child2)
+
+        subject.add(2, child3)
+        expect(subject.children).to eq(0 => child1, 1 => child2, 2 => child3)
+
+        subject.remove(child2)
+        expect(subject.children).to eq(0 => child1, 1 => child3)
+
+        subject.add(0, child2)
+        expect(subject.children).to eq(0 => child2, 1 => child1, 2 => child3)
+      end
+    end
+  end
+end

data/spec/composite_spec.rb

@@ -0,0 +1,249 @@
+require 'spec_helper'
+require 'compo'
+
+# Mock implementation of a Composite
+class MockComposite
+  include Compo::Composite
+end
+
+describe MockComposite do
+  let(:id) { double(:id) }
+  let(:child) { double(:child) }
+
+  describe '#add' do
+    before(:each) { allow(subject).to receive(:add!) }
+
+    context 'when #add! returns nil' do
+      before(:each) { allow(subject).to receive(:add!).and_return(nil) }
+
+      specify { expect(subject.add(id, child)).to be_nil }
+
+      it 'calls #add! with the ID and child given' do
+        expect(subject).to receive(:add!).once.with(id, child)
+        subject.add(id, child)
+      end
+    end
+
+    context 'when #add! returns the child' do
+      before(:each) do
+        allow(subject).to receive(:add!).and_return(child)
+        allow(subject).to receive(:id_function)
+        allow(child).to receive(:update_parent)
+      end
+
+      it 'calls #add! with the ID and child given' do
+        expect(subject).to receive(:add!).once.with(id, child)
+        subject.add(id, child)
+      end
+
+      it 'calls #id_function with the child given' do
+        expect(subject).to receive(:id_function).once.with(child)
+        subject.add(id, child)
+      end
+
+      it 'calls #update_parent on the child with the parent and ID function' do
+        idf = double(:id_function)
+        allow(subject).to receive(:id_function).and_return(idf)
+        expect(child).to receive(:update_parent).once.with(subject, idf)
+        subject.add(id, child)
+      end
+
+      it 'returns the given child' do
+        expect(subject.add(id, child)).to eq(child)
+      end
+    end
+  end
+
+  describe '#remove' do
+    context 'when #remove! is defined' do
+      before(:each) { allow(subject).to receive(:remove!) }
+
+      context 'when #remove! returns nil' do
+        before(:each) { allow(subject).to receive(:remove!).and_return(nil) }
+
+        specify { expect(subject.remove(child)).to be_nil }
+
+        it 'calls #remove! with the child given' do
+          expect(subject).to receive(:remove!).once.with(child)
+          subject.remove(child)
+        end
+      end
+
+      context 'when #remove! returns the child' do
+        before(:each) do
+          allow(subject).to receive(:remove!).and_return(child)
+          allow(child).to receive(:remove_parent)
+        end
+
+        it 'calls #remove! with the child given' do
+          expect(subject).to receive(:remove!).once.with(child)
+          subject.remove(child)
+        end
+
+        it 'calls #remove_parent on the child with no arguments' do
+          expect(child).to receive(:remove_parent).once.with(no_args)
+          subject.remove(child)
+        end
+
+        it 'returns the given child' do
+          expect(subject.remove(child)).to eq(child)
+        end
+      end
+    end
+
+    context 'when #remove_id! is defined but #remove! is not' do
+      before(:each) do
+        allow(subject).to receive(:remove_id!)
+        allow(subject).to receive(:children).and_return(id => child)
+      end
+
+      context 'when #remove_id! returns nil' do
+        before(:each) do
+          allow(subject).to receive(:remove_id!).and_return(nil)
+        end
+
+        specify { expect(subject.remove(child)).to be_nil }
+
+        it 'calls #remove! with the child given' do
+          expect(subject).to receive(:remove!).once.with(child)
+          subject.remove(child)
+        end
+
+        it 'calls #remove_id! with the ID of the child' do
+          expect(subject).to receive(:remove_id!).once.with(id)
+          subject.remove(child)
+        end
+
+        it 'calls #children' do
+          expect(subject).to receive(:children).once
+          subject.remove(child)
+        end
+      end
+
+      context 'when #remove_id! returns the child' do
+        before(:each) do
+          allow(subject).to receive(:remove_id!).and_return(child)
+          allow(child).to receive(:remove_parent)
+        end
+
+        it 'calls #remove_id! with the child given' do
+          expect(subject).to receive(:remove!).once.with(child)
+          subject.remove(child)
+        end
+
+        it 'calls #remove_parent on the child with no arguments' do
+          expect(child).to receive(:remove_parent).once.with(no_args)
+          subject.remove(child)
+        end
+
+        it 'returns the given child' do
+          expect(subject.remove(child)).to eq(child)
+        end
+      end
+    end
+  end
+
+  describe '#remove_id' do
+    let(:id) { double(:id) }
+
+    context 'when #remove_id! is defined' do
+      before(:each) { allow(subject).to receive(:remove_id!) }
+
+      context 'and #remove_id! returns nil' do
+        before(:each) do
+          allow(subject).to receive(:remove_id!).and_return(nil)
+        end
+
+        specify { expect(subject.remove_id(id)).to be_nil }
+
+        it 'calls #remove_id! with the ID given' do
+          expect(subject).to receive(:remove_id!).once.with(id)
+          subject.remove_id(id)
+        end
+      end
+
+      context 'and #remove_id! returns the child' do
+        before(:each) do
+          allow(subject).to receive(:remove_id!).and_return(child)
+          allow(child).to receive(:remove_parent)
+        end
+
+        it 'calls #remove_id! with the ID given' do
+          expect(subject).to receive(:remove_id!).once.with(id)
+          subject.remove_id(id)
+        end
+
+        it 'calls #remove_parent on the child with no arguments' do
+          expect(child).to receive(:remove_parent).once.with(no_args)
+          subject.remove_id(id)
+        end
+
+        it 'returns the child' do
+          expect(subject.remove_id(id)).to eq(child)
+        end
+      end
+    end
+
+    context 'when #remove! is defined but #remove_id! is not' do
+      before(:each) { allow(subject).to receive(:remove!) }
+
+      context 'and #remove! returns nil' do
+        before(:each) do
+          allow(subject).to receive(:remove!).and_return(nil)
+          allow(subject).to receive(:get_child).and_return(child)
+        end
+
+        specify { expect(subject.remove_id(id)).to be_nil }
+
+        it 'calls #remove_id! with the ID given' do
+          expect(subject).to receive(:remove_id!).once.with(id)
+          subject.remove_id(id)
+        end
+
+        it 'calls #get_child with the ID given' do
+          expect(subject).to receive(:get_child).once.with(id)
+          subject.remove_id(id)
+        end
+
+        it 'calls #remove! with the child given' do
+          expect(subject).to receive(:remove!).once.with(child)
+          subject.remove_id(id)
+        end
+      end
+
+      context 'and #remove! returns the child' do
+        before(:each) do
+          allow(subject).to receive(:remove!).and_return(child)
+          allow(subject).to receive(:get_child).and_return(child)
+          allow(child).to receive(:remove_parent)
+        end
+
+        it 'calls #remove! with the child given' do
+          expect(subject).to receive(:remove!).once.with(child)
+          subject.remove_id(id)
+        end
+
+        it 'calls #remove_parent on the child with no arguments' do
+          expect(child).to receive(:remove_parent).once.with(no_args)
+          subject.remove_id(id)
+        end
+
+        it 'returns the given child' do
+          expect(subject.remove_id(id)).to eq(child)
+        end
+      end
+    end
+  end
+
+  describe '#each' do
+    it 'delegates to the #each implementation of the hash from #children' do
+      children = double(:children)
+
+      allow(subject).to receive(:children).and_return(children)
+      expect(subject).to receive(:children).once.with(no_args)
+      expect(children).to receive(:each).once
+
+      subject.each
+    end
+  end
+end

data/spec/hash_composite_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+require 'compo'
+
+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
+end

data/spec/leaf_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'compo'
+
+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
+end