gaddag 0.1.1

data/spec/shared/unit/gaddag/node/create_arc_behaviour.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+shared_examples 'GADDAG::Node#create_arc/behaviour' do
+  subject { GADDAG::Node.new }
+
+  let(:letter) { 'L' }
+  let(:destination) { GADDAG::Node.new }
+
+  let(:create_arc) { ->(*args) { subject.create_arc(*args) } }
+
+  let(:arc) { create_arc.call(letter) }
+  let(:another_arc) { create_arc.call(letter) }
+
+  let(:arc_with_destination) { create_arc.call(letter, destination) }
+
+  it 'returns the newly created arc' do
+    expect(arc).to be_an_instance_of(GADDAG::Arc)
+  end
+
+  it 'adds the arc to the mapping of outgoing arcs' do
+    expect(subject.outgoing_arcs).to include(letter.to_sym => arc)
+  end
+
+  context 'when not provided with a destination node' do
+    it 'points the arc to a newly created destination node' do
+      expect(arc.destination).to eq(GADDAG::Node.new)
+    end
+  end
+
+  context 'when provided with a destination node' do
+    it 'points the arc to the given destination node' do
+      expect(arc_with_destination.destination).to equal(destination)
+    end
+  end
+
+  context 'when created again for the same letter' do
+    it 'returns the original arc' do
+      expect(another_arc).to equal(arc)
+    end
+  end
+end

data/spec/shared/unit/gaddag/node/create_final_path_behaviour.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+shared_examples 'GADDAG::Node#create_final_path/behaviour' do
+  include_context 'GADDAG::Node#create_path/context'
+
+  let!(:final_node) { subject.create_final_path(letters) }
+
+  let(:letters_without_last_one) { letters[0..-2] }
+  let(:letters_without_last_two) { letters[0..-3]}
+
+  let(:last_letter) { letters[-1] }
+  let(:second_last_letter) { letters[-2] }
+
+  it 'creates the path for the given letters up till the second last letter' do
+    expect { subject.follow_path(letters_without_last_one) }.to_not raise_error
+  end
+
+  it 'does not create an arc for the last letter' do
+    expect { subject.follow_path(letters) }.to raise_error(KeyError)
+  end
+
+  it 'adds the last letter to the last arc as final letter' do
+    expect(subject.follow_path(letters_without_last_two).outgoing_arcs).to eq({
+      second_last_letter.to_sym => GADDAG::Arc.new(GADDAG::Node.new).tap do |arc|
+        arc.add_final_letter(last_letter)
+      end
+    })
+  end
+
+  it 'returns the last created node' do
+    expect(final_node).to equal(subject.follow_path(letters_without_last_one))
+  end
+end

data/spec/shared/unit/gaddag/node/create_path_behaviour.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+shared_examples 'GADDAG::Node#create_path/behaviour' do
+  include_context 'GADDAG::Node#create_path/context'
+
+  let!(:final_node) { subject.create_path(letters) }
+
+  it 'creates the path for the given letters' do
+    expect { subject.follow_path(letters) }.to_not raise_error
+  end
+
+  it 'returns the last created node' do
+    expect(final_node).to equal(subject.follow_path(letters))
+  end
+end

data/spec/shared/unit/gaddag/node/create_path_context.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+
+shared_context 'GADDAG::Node#create_path/context' do
+  subject { GADDAG::Node.new }
+  let(:letters) { %w[B ♢ R E A K] }
+end

data/spec/unit/gaddag/add_spec.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG, '#add' do
+  subject { GADDAG.new }
+  let(:path_delimiter) { GADDAG::Path::DELIMITER }
+
+  it 'returns itself' do
+    expect(subject.add('ANYTHING')).to equal(subject)
+  end
+
+  context 'given that the word BREAK is added' do
+    before { subject.add('BREAK') }
+
+    it 'creates a final path for K-A-E-R-B-♢' do
+      final_node = subject.root.follow_path(%w[K A E R])
+      expect(final_node.outgoing_arcs).to have_key(:B)
+      expect(final_node.outgoing_arcs[:B].final_letters).to eq([path_delimiter].to_set)
+    end
+
+    it 'creates a final path for B-♢-R-E-A-K' do
+      final_node = subject.root.follow_path(%w[B] + [path_delimiter] + %w[R E])
+      expect(final_node.outgoing_arcs).to have_key(:A)
+      expect(final_node.outgoing_arcs[:A].final_letters).to eq(['K'].to_set)
+    end
+
+    it 'creates a final path for R-B-♢-E-A-K' do
+      final_node = subject.root.follow_path(%w[R B] + [path_delimiter] + %w[E])
+      expect(final_node.outgoing_arcs).to have_key(:A)
+      expect(final_node.outgoing_arcs[:A].final_letters).to eq(['K'].to_set)
+    end
+
+    it 'creates a final path for E-R-B-♢-A-K' do
+      final_node = subject.root.follow_path(%w[E R B] + [path_delimiter])
+      expect(final_node.outgoing_arcs).to have_key(:A)
+      expect(final_node.outgoing_arcs[:A].final_letters).to eq(['K'].to_set)
+    end
+
+    it 'creates a final path for A-E-R-B-♢-K' do
+      final_node = subject.root.follow_path(%w[A E R B])
+      expect(final_node.outgoing_arcs).to have_key(path_delimiter.to_sym)
+      expect(final_node.outgoing_arcs[path_delimiter.to_sym].final_letters).to eq(['K'].to_set)
+    end
+  end
+end

data/spec/unit/gaddag/arc/add_final_letter_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'gaddag'
+require 'shared/unit/gaddag/arc_context'
+
+describe GADDAG::Arc, '#add_final_letter' do
+  include_context 'GADDAG::Arc/context'
+
+  context 'when adding a final letter' do
+    before { subject.add_final_letter('K') }
+
+    it 'is added' do
+      expect(subject.final_letters).to eq(%w[K].to_set)
+    end
+  end
+
+  context 'when adding a final letter twice' do
+    before { 2.times { subject.add_final_letter('L') } }
+
+    it 'is only added once' do
+      expect(subject.final_letters).to eq(%w[L].to_set)
+    end
+  end
+end

data/spec/unit/gaddag/arc/final_paths_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'gaddag'
+require 'shared/unit/gaddag/arc_context'
+
+describe GADDAG::Arc, '#final_paths' do
+  include_context 'GADDAG::Arc/context'
+
+  let(:first_final_path) { GADDAG::Path.new(%w[A B C]) }
+  let(:second_final_path) { GADDAG::Path.new(%w[D E F]) }
+
+  context 'when the arc includes no final letters' do
+    context 'when the destination node has no final paths' do
+      specify { expect(subject.final_paths).to be_empty }
+    end
+
+    context 'when the destination node has final paths' do
+      before { destination.create_final_path(first_final_path.letters) }
+      before { destination.create_final_path(second_final_path.letters) }
+
+      specify { expect(subject.final_paths).to include(first_final_path) }
+      specify { expect(subject.final_paths).to include(second_final_path) }
+      specify { expect(subject.final_paths.count).to eq(2) }
+    end
+  end
+
+  context 'when the arc does include final letters' do
+    before { %w(X Y).each { |l| subject.add_final_letter(l) } }
+
+    context 'when the destination node has no final paths' do
+      specify { expect(subject.final_paths).to include(GADDAG::Path.new(%w[X])) }
+      specify { expect(subject.final_paths).to include(GADDAG::Path.new(%w[Y])) }
+      specify { expect(subject.final_paths.count).to eq(2) }
+    end
+
+    context 'when the destination node has final paths' do
+      before { destination.create_final_path(first_final_path.letters) }
+      before { destination.create_final_path(second_final_path.letters) }
+
+      specify { expect(subject.final_paths).to include(GADDAG::Path.new(%w[X])) }
+      specify { expect(subject.final_paths).to include(GADDAG::Path.new(%w[Y])) }
+
+      specify { expect(subject.final_paths).to include(first_final_path) }
+      specify { expect(subject.final_paths).to include(second_final_path) }
+
+      specify { expect(subject.final_paths.count).to eq(4) }
+    end
+  end
+end

data/spec/unit/gaddag/arc/initialize_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'gaddag'
+require 'shared/unit/gaddag/arc_context'
+
+describe GADDAG::Arc, '#initialize' do
+  include_context 'GADDAG::Arc/context'
+
+  it 'initializes an empty set of final letters' do
+    expect(subject.final_letters).to be_empty
+  end
+
+  it 'stores the destination node' do
+    expect(subject.destination).to equal(destination)
+  end
+end

data/spec/unit/gaddag/find_spec.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG, '#find' do
+  subject { GADDAG.new }
+
+  context 'given that the words BREAK and AKIN are added' do
+    before { subject.add('BREAK') }
+    before { subject.add('AKIN') }
+
+    context 'when searching for any word or substring that has not been added' do
+      it 'yields no results' do
+        expect(subject.find('ZOMBIES')).to be_empty
+      end
+    end
+
+    context 'when searching for an empty substring' do
+      let(:results) { subject.find('') }
+
+      it 'yields all words that have been added' do
+        expect(results).to eq(['BREAK', 'AKIN'])
+      end
+    end
+
+    context 'when searching for the letter E' do
+      let(:results) { subject.find('E') }
+
+      it 'yields one result, namely BREAK' do
+        expect(results).to eq(['BREAK'])
+      end
+    end
+
+    context 'when searching for the word BREAK' do
+      let(:results) { subject.find('BREAK') }
+
+      it 'yields one result, namely BREAK' do
+        expect(results).to eq(['BREAK'])
+      end
+    end
+
+    context 'when searching for the substring BREA' do
+      let(:results) { subject.find('BREA') }
+
+      it 'yields one result, namely BREAK' do
+        expect(results).to eq(['BREAK'])
+      end
+    end
+
+    context 'when searching for the substring REAK' do
+      let(:results) { subject.find('REAK') }
+
+      it 'yields one result, namely BREAK' do
+        expect(results).to eq(['BREAK'])
+      end
+    end
+
+    context 'when searching for the substring AK' do
+      let(:results) { subject.find('AK') }
+
+      it 'yields two results, namely BREAK and AKIN' do
+        expect(results).to eq(['BREAK', 'AKIN'])
+      end
+    end
+  end
+end

data/spec/unit/gaddag/initialize_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG, '#initialize' do
+  subject { GADDAG.new }
+
+  it 'sets the root node the a new, empty node' do
+    expect(subject.root).to eq(GADDAG::Node.new)
+  end
+end

data/spec/unit/gaddag/node/arc_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Node, '#arc?' do
+  subject { GADDAG::Node.new }
+
+  let(:letter) { 'L' }
+
+  context 'when the arc for the given letter exists' do
+    before { subject.create_arc(letter) }
+
+    it 'returns true' do
+      expect(subject.arc?(letter)).to eq(true)
+    end
+  end
+
+  context 'when the arc for the given letter does not exist' do
+    it 'returns false' do
+      expect(subject.arc?(letter)).to eq(false)
+    end
+  end
+end

data/spec/unit/gaddag/node/create_arc_spec.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+require 'gaddag'
+require 'shared/unit/gaddag/node/create_arc_behaviour'
+
+describe GADDAG::Node, '#create_arc' do
+  it_behaves_like 'GADDAG::Node#create_arc/behaviour'
+end

data/spec/unit/gaddag/node/create_final_arc_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'gaddag'
+require 'shared/unit/gaddag/node/create_arc_behaviour'
+
+describe GADDAG::Node, '#create_final_arc' do
+  it_behaves_like 'GADDAG::Node#create_arc/behaviour' do
+    let(:final_letter) { 'Z' }
+
+    let(:create_arc) do
+      ->(*args) { subject.create_final_arc(*args.insert(1, final_letter)) }
+    end
+
+    it 'adds the final letter to the arc' do
+      expect(arc.final_letters).to include(final_letter)
+    end
+  end
+end

data/spec/unit/gaddag/node/create_final_path_spec.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'gaddag'
+require 'shared/unit/gaddag/node/create_path_context'
+require 'shared/unit/gaddag/node/create_final_path_behaviour'
+
+describe GADDAG::Node, '#create_final_path' do
+  context 'when not given a list of destination nodes' do
+    it_behaves_like 'GADDAG::Node#create_final_path/behaviour'
+  end
+
+  context 'when given a list of destination nodes' do
+    it_behaves_like 'GADDAG::Node#create_final_path/behaviour' do
+      let(:letters) { %w[B ♢ R E A K] }
+
+      let!(:destinations) { 6.times.map { GADDAG::Node.new } }
+      let!(:final_node) { subject.create_final_path(letters, destinations) }
+
+      it 'creates the path for the given letters through the given destination nodes' do
+        expect(subject.follow_path(%w[B])).to equal(destinations[0])
+        expect(subject.follow_path(%w[B ♢])).to equal(destinations[1])
+        expect(subject.follow_path(%w[B ♢ R])).to equal(destinations[2])
+        expect(subject.follow_path(%w[B ♢ R E])).to equal(destinations[3])
+        expect(subject.follow_path(%w[B ♢ R E A])).to equal(destinations[4])
+      end
+    end
+  end
+
+  context 'when given a shortened list of destination nodes' do
+    it_behaves_like 'GADDAG::Node#create_final_path/behaviour' do
+      let(:letters) { %w[B ♢ R E A K] }
+
+      let(:destinations) { 3.times.map { GADDAG::Node.new } }
+      let!(:final_node) { subject.create_final_path(letters, destinations) }
+
+      it 'creates a path through the shortened list of destination nodes' do
+        expect(subject.follow_path(%w[B])).to equal(destinations[0])
+        expect(subject.follow_path(%w[B ♢])).to equal(destinations[1])
+        expect(subject.follow_path(%w[B ♢ R])).to equal(destinations[2])
+      end
+    end
+  end
+end

data/spec/unit/gaddag/node/create_path_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'gaddag'
+require 'shared/unit/gaddag/node/create_path_context'
+require 'shared/unit/gaddag/node/create_path_behaviour'
+
+describe GADDAG::Node, '#create_path' do
+  context 'when not given a list of destination nodes' do
+    it_behaves_like 'GADDAG::Node#create_path/behaviour'
+  end
+
+  context 'when given a list of destination nodes' do
+    it_behaves_like 'GADDAG::Node#create_path/behaviour' do
+      let(:letters) { %w[B ♢ R E A K] }
+
+      let(:destinations) { 6.times.map { GADDAG::Node.new } }
+      let!(:final_node) { subject.create_path(letters, destinations) }
+
+      it 'creates a path through the given destination nodes' do
+        expect(subject.follow_path(%w[B])).to equal(destinations[0])
+        expect(subject.follow_path(%w[B ♢])).to equal(destinations[1])
+        expect(subject.follow_path(%w[B ♢ R])).to equal(destinations[2])
+        expect(subject.follow_path(%w[B ♢ R E])).to equal(destinations[3])
+        expect(subject.follow_path(%w[B ♢ R E A])).to equal(destinations[4])
+        expect(subject.follow_path(%w[B ♢ R E A K])).to equal(destinations[5])
+      end
+    end
+  end
+
+  context 'when given a shortened list of destination nodes' do
+    it_behaves_like 'GADDAG::Node#create_path/behaviour' do
+      let(:letters) { %w[B ♢ R E A K] }
+
+      let(:destinations) { 3.times.map { GADDAG::Node.new } }
+      let!(:final_node) { subject.create_path(letters, destinations) }
+
+      it 'creates a path through the shortened list of destination nodes' do
+        expect(subject.follow_path(%w[B])).to equal(destinations[0])
+        expect(subject.follow_path(%w[B ♢])).to equal(destinations[1])
+        expect(subject.follow_path(%w[B ♢ R])).to equal(destinations[2])
+      end
+    end
+  end
+end