gaddag 0.1.1

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Node, '#final_path?' do
+  subject { GADDAG::Node.new }
+  let(:letters) { %w[A B C D] }
+
+  context 'when a final path exists for the given list of letters' do
+    before { subject.create_final_path(letters) }
+
+    it 'returns true' do
+      expect(subject.final_path?(letters)).to eq(true)
+    end
+  end
+
+  context 'when a final path does not exist for the given list of letters' do
+    it 'returns false' do
+      expect(subject.final_path?(letters)).to eq(false)
+    end
+
+    context 'when the list of letters is empty' do
+      let(:letters) { [] }
+
+      it 'returns false' do
+        expect(subject.final_path?(letters)).to eq(false)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Node, '#final_paths' do
+  subject { GADDAG::Node.new }
+  let(:final_paths) { subject.final_paths }
+
+  context 'when no paths have been created' do
+    it 'returns an empty list' do
+      expect(final_paths).to be_empty
+    end
+  end
+
+  context 'when some paths have been created' do
+    context 'when none of the paths are final' do
+      before { subject.create_path(%w[K A E R B]) }
+      before { subject.create_path(%w[A B C D]) }
+
+      it 'returns an empty list' do
+        expect(final_paths).to be_empty
+      end
+    end
+
+    context 'when some of the paths are final' do
+      before { subject.create_path(%w[K A E R B]) }
+      before { subject.create_final_path(%w[A B C D]) }
+
+      it 'returns the paths that are final' do
+        expect(final_paths).to eq([GADDAG::Path.new(%w[A B C D])])
+      end
+    end
+
+    context 'when two final paths exist with the same prefix' do
+      before do
+        subject.create_final_path(%w[F I N D])
+        subject.create_final_path(%w[F I N D E R])
+      end
+
+      it 'returns both paths' do
+        expect(final_paths).to match_array([
+          GADDAG::Path.new(%w[F I N D]),
+          GADDAG::Path.new(%w[F I N D E R]),
+        ])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Node, '#follow_arc' do
+  subject { GADDAG::Node.new }
+
+  let(:letter) { 'L' }
+  let(:destination) { GADDAG::Node.new }
+
+  context 'when the arc for the given letter exists' do
+    before { subject.create_arc(letter, destination) }
+
+    it 'returns the destination node that the arc points to' do
+      expect(subject.follow_arc(letter)).to equal(destination)
+    end
+  end
+
+  context 'when the arc for the given letter does not exist' do
+    it 'raises an error indicating that no such arc exists' do
+      expect { subject.follow_arc(letter) }.to raise_error(KeyError)
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Node, '#follow_path' do
+  subject { GADDAG::Node.new }
+
+  let(:letter) { 'L' }
+  let(:destinations) { GADDAG::Node.new }
+
+  context 'when the path for the given letters exists' do
+    context 'when given an empty path of letters' do
+      let(:letters) { [] }
+      before { subject.create_path(letters) }
+
+      it 'returns itself' do
+        expect(subject.follow_path(letters)).to equal(subject)
+      end
+    end
+
+    context 'when given a path of letters' do
+      let(:letters) { %w[A B C D] }
+      let(:destinations) { 4.times.map { GADDAG::Node.new } }
+      before { subject.create_path(letters, destinations) }
+
+      it 'returns the destination node that the path of letters leads to' do
+        expect(subject.follow_path(letters)).to equal(destinations.last)
+      end
+    end
+  end
+
+  context 'when the path for the given letters does not exist' do
+    let(:letters) { %w[A B C D] }
+    let(:other_letters) { %w[A X Y D] }
+    before { subject.create_path(letters) }
+
+    it 'raises an error indicating that no such path exists' do
+      expect { subject.follow_path(other_letters) }.to raise_error(KeyError)
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Node, '#path?' do
+  subject { GADDAG::Node.new }
+  let(:letters) { %w[A B C D] }
+
+  context 'when a path exists for the given list of letters' do
+    before { subject.create_path(letters) }
+
+    it 'returns true' do
+      expect(subject.path?(letters)).to eq(true)
+    end
+  end
+
+  context 'when a path does not exist for the given list of letters' do
+    it 'returns false' do
+      expect(subject.path?(letters)).to eq(false)
+    end
+
+    context 'when the list of letters is empty' do
+      let(:letters) { [] }
+
+      it 'returns true' do
+        expect(subject.path?(letters)).to eq(true)
+      end
+    end
+  end
+end

data/spec/unit/gaddag/path/equal_value_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Path, '#==' do
+  context 'when two paths have the same letters' do
+    let(:path) { GADDAG::Path.new(%w[B ♢ R E A K]) }
+    let(:other_path) { GADDAG::Path.new(%w[B ♢ R E A K]) }
+    specify { expect(path).to eq(other_path) }
+  end
+
+  context 'when two paths have different letters' do
+    let(:path) { GADDAG::Path.new(%w[B ♢ R E A K]) }
+    let(:other_path) { GADDAG::Path.new(%w[C ♢ A R E]) }
+    specify { expect(path).to_not eq(other_path) }
+  end
+end

data/spec/unit/gaddag/path/include_delimiter_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Path, '#include_delimiter?' do
+  context 'when the path includes a delimiter' do
+    subject { GADDAG::Path.new(%w[R B] + [GADDAG::Path::DELIMITER] + %w[E A K]) }
+    specify { expect(subject.include_delimiter?).to be_true }
+  end
+
+  context 'when the path does not include a delimiter' do
+    subject { GADDAG::Path.new(%w[K A E R B]) }
+    specify { expect(subject.include_delimiter?).to be_false }
+  end
+end

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

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Path, '#initialize' do
+  let(:letters) { %w[B ♢ R E A K] }
+  subject { GADDAG::Path.new(letters) }
+
+  it 'stores the list of letters' do
+    expect(subject.letters).to equal(letters)
+  end
+end

data/spec/unit/gaddag/path/reversed_prefix_letters_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Path, '#reversed_prefix_letters' do
+  context 'when the path is empty' do
+    subject { GADDAG::Path.new([]) }
+    specify { expect(subject.reversed_prefix_letters).to be_empty }
+  end
+
+  context 'when the path includes a delimiter' do
+    subject { GADDAG::Path.new(%w[R B] + [GADDAG::Path::DELIMITER] + %w[E A K]) }
+
+    it 'returns an ordered list of letters that occur before the delimiter' do
+      expect(subject.reversed_prefix_letters).to eq(%w[R B])
+    end
+  end
+
+  context 'when the path ends with a delimiter' do
+    subject { GADDAG::Path.new(%w[K A E R B] + [GADDAG::Path::DELIMITER]) }
+
+    it 'returns an ordered list of all the letters within the path' do
+      expect(subject.reversed_prefix_letters).to eq(%w[K A E R B])
+    end
+  end
+
+  context 'when the path does not include a delimiter' do
+    subject { GADDAG::Path.new(%w[K A E R B]) }
+
+    it 'returns an ordered list of all the letters within the path' do
+      expect(subject.reversed_prefix_letters).to eq(%w[K A E R B])
+    end
+  end
+end

data/spec/unit/gaddag/path/start_with_spec.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Path, '#start_with?' do
+  let(:letters) { %w[H E L] }
+
+  context 'when a path starts with the given letters' do
+    subject { GADDAG::Path.new(%w[H E L L O]) }
+
+    it 'returns true' do
+      expect(subject.start_with?(letters)).to eq(true)
+    end
+  end
+
+  context 'when a path does not start with the given letters' do
+    subject { GADDAG::Path.new(%w[B R E A K]) }
+
+    it 'returns false' do
+      expect(subject.start_with?(letters)).to eq(false)
+    end
+
+    context 'when the list of letters consists of nil values' do
+      let(:letters) { [nil, nil, nil] }
+
+      it 'returns true' do
+        expect(subject.start_with?(letters)).to eq(true)
+      end
+    end
+
+    context 'when the list of letters is empty' do
+      let(:letters) { [] }
+
+      it 'returns true' do
+        expect(subject.start_with?(letters)).to eq(true)
+      end
+    end
+  end
+end

data/spec/unit/gaddag/path/suffix_letters_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Path, '#suffix_letters' do
+  context 'when the path is empty' do
+    subject { GADDAG::Path.new([]) }
+    specify { expect(subject.to_s).to be_empty }
+  end
+
+  context 'when the path includes a delimiter' do
+    subject { GADDAG::Path.new(%w[R B] + [GADDAG::Path::DELIMITER] + %w[E A K]) }
+
+    it 'returns an ordered list of letters that occur after the delimiter' do
+      expect(subject.suffix_letters).to eq(%w[E A K])
+    end
+  end
+
+  context 'when the path ends with a delimiter' do
+    subject { GADDAG::Path.new(%w[K A E R B] + [GADDAG::Path::DELIMITER]) }
+
+    it 'returns an empty list' do
+      expect(subject.suffix_letters).to be_empty
+    end
+  end
+
+  context 'when the path does not include a delimiter' do
+    subject { GADDAG::Path.new(%w[K A E R B]) }
+
+    it 'returns an empty list' do
+      expect(subject.suffix_letters).to be_empty
+    end
+  end
+end

data/spec/unit/gaddag/path/to_ary_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Path, '#to_ary' do
+  subject { GADDAG::Path.new(%w[B ♢ R E A K]) }
+
+  it 'is implemented' do
+    expect(subject).to respond_to(:to_ary)
+  end
+
+  it 'returns its letter list' do
+    expect(subject.to_ary).to eq(subject.letters)
+  end
+end

data/spec/unit/gaddag/path/to_s_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Path, '#to_s' do
+  context 'when the path is empty' do
+    subject { GADDAG::Path.new([]) }
+    specify { expect(subject.to_s).to be_empty }
+  end
+
+  context 'when the path is not empty' do
+    subject { GADDAG::Path.new(%w[B ♢ R E A K]) }
+
+    it 'concatenates the letters in this path, delimited by \' > \'' do
+      expect(subject.to_s).to eq('B > ♢ > R > E > A > K')
+    end
+  end
+end

data/spec/unit/gaddag/path/to_word_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Path, '#to_word' do
+  context 'when the path is empty' do
+    subject { GADDAG::Path.new([]) }
+
+    it 'returns an empty word' do
+      expect(subject.to_word).to eq(GADDAG::Word.new([]))
+    end
+  end
+
+  context 'when the path includes a delimiter' do
+    subject { GADDAG::Path.new(%w[R B] + [GADDAG::Path::DELIMITER] + %w[E A K]) }
+
+    it 'returns a word with the letters in the correct order' do
+      expect(subject.to_word).to eq(GADDAG::Word.new(%w[B R E A K]))
+    end
+  end
+
+  context 'when the path ends with a delimiter' do
+    subject { GADDAG::Path.new(%w[K A E R B] + [GADDAG::Path::DELIMITER]) }
+
+    it 'returns a word with the letters in the correct order' do
+      expect(subject.to_word).to eq(GADDAG::Word.new(%w[B R E A K]))
+    end
+  end
+
+  context 'when the path does not include a delimiter' do
+    subject { GADDAG::Path.new(%w[K A E R B]) }
+
+    it 'returns a word with the letters in the correct order' do
+      expect(subject.to_word).to eq(GADDAG::Word.new(%w[B R E A K]))
+    end
+  end
+end

data/spec/unit/gaddag/word/equal_value_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Word, '#==' do
+  context 'when two words have the same letters' do
+    let(:word) { GADDAG::Word.new(%w[B R E A K]) }
+    let(:other_word) { GADDAG::Word.new(%w[B R E A K]) }
+    specify { expect(word).to eq(other_word) }
+  end
+
+  context 'when two words have different letters' do
+    let(:word) { GADDAG::Word.new(%w[B R E A K]) }
+    let(:other_word) { GADDAG::Word.new(%w[C A R E]) }
+    specify { expect(word).to_not eq(other_word) }
+  end
+end

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

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'gaddag'
+
+describe GADDAG::Word, '#initialize' do
+  let(:letters) { %w[B R E A K] }
+  subject { GADDAG::Word.new(letters) }
+
+  it 'stores the list of letters' do
+    expect(subject.letters).to equal(letters)
+  end
+end