wordlist 0.1.1 → 1.0.0

data/spec/operators/power_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'wordlist/operators/power'
+
+describe Wordlist::Operators::Power do
+  let(:wordlist)  { %w[foo bar] }
+  let(:exponent)  { 3 }
+
+  subject { described_class.new(wordlist,exponent) }
+
+  let(:expected_words) do
+    %w[
+      foofoofoo
+      foofoobar
+      foobarfoo
+      foobarbar
+      barfoofoo
+      barfoobar
+      barbarfoo
+      barbarbar
+    ]
+  end
+
+  describe "#initialize" do
+    it "must set #wordlist to a #{Operators::Product} object" do
+      expect(subject.wordlists).to be_kind_of(Operators::Product)
+      expect(subject.wordlists.left).to eq(wordlist)
+      expect(subject.wordlists.right).to be_kind_of(Operators::Product)
+      expect(subject.wordlists.right.left).to eq(wordlist)
+      expect(subject.wordlists.right.right).to eq(wordlist)
+    end
+
+    context "when the exponent is 1" do
+      let(:exponent) { 1 }
+
+      it "must set #wordlists to the given wordlist" do
+        expect(subject.wordlists).to eq(wordlist)
+      end
+    end
+  end
+
+  describe "#each" do
+    context "when given a block" do
+      it "must yield words from the left-hand wordlist with the right-hand" do
+        expect { |b|
+          subject.each(&b)
+        }.to yield_successive_args(*expected_words)
+      end
+    end
+
+    context "when not given a block" do
+      it "must return an Enumerator for the #each" do
+        expect(subject.each).to be_kind_of(Enumerator)
+        expect(subject.each.to_a).to eq(expected_words)
+      end
+    end
+  end
+end

data/spec/operators/product_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'wordlist/operators/product'
+
+describe Wordlist::Operators::Product do
+  let(:left)  { %w[foo bar baz qux] }
+  let(:right) { %w[abc xyz] }
+
+  subject { described_class.new(left,right) }
+
+  let(:expected_words) do
+    %w[
+        fooabc
+        fooxyz
+        barabc
+        barxyz
+        bazabc
+        bazxyz
+        quxabc
+        quxxyz
+    ]
+  end
+
+  describe "#each" do
+    context "when given a block" do
+      it "must yield words from the left-hand wordlist with the right-hand" do
+        expect { |b|
+          subject.each(&b)
+        }.to yield_successive_args(*expected_words)
+      end
+    end
+
+    context "when not given a block" do
+      it "must return an Enumerator for the #each" do
+        expect(subject.each).to be_kind_of(Enumerator)
+        expect(subject.each.to_a).to eq(expected_words)
+      end
+    end
+  end
+end

data/spec/operators/subtract_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'wordlist/operators/subtract'
+
+describe Wordlist::Operators::Subtract do
+  let(:left)  { %w[foo bar] }
+  let(:right) { %w[bar baz] }
+
+  subject { described_class.new(left,right) }
+
+  describe "#each" do
+    context "when given a block" do
+      it "must yield the words which do not exist in other wordlists" do
+        expect { |b|
+          subject.each(&b)
+        }.to yield_successive_args(*(left - right))
+      end
+
+      context "when the wordlists do not have any common words" do
+        let(:left)  { %w[foo bar] }
+        let(:right) { %w[baz qux] }
+
+        it "must yield the left-hand operand's words" do
+          expect { |b|
+            subject.each(&b)
+          }.to yield_successive_args(*left)
+        end
+      end
+    end
+
+    context "when not given a block" do
+      it "must return an Enumerator for the #each" do
+        expect(subject.each).to be_kind_of(Enumerator)
+        expect(subject.each.to_a).to eq(left - right)
+      end
+    end
+  end
+end

data/spec/operators/union_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'wordlist/operators/union'
+
+describe Wordlist::Operators::Union do
+  let(:left)  { %w[foo bar] }
+  let(:right) { %w[bar baz] }
+
+  subject { described_class.new(left,right) }
+
+  describe "#each" do
+    context "when given a block" do
+      it "must yield the words from both wordlists, without duplicates" do
+        expect { |b|
+          subject.each(&b)
+        }.to yield_successive_args(*(left | right))
+      end
+
+      context "when the wordlists do not have any common words" do
+        let(:left)  { %w[foo bar] }
+        let(:right) { %w[baz qux] }
+
+        it "must yield words from both wordlists" do
+          expect { |b|
+            subject.each(&b)
+          }.to yield_successive_args(*(left + right))
+        end
+      end
+    end
+
+    context "when not given a block" do
+      it "must return an Enumerator for the #each" do
+        expect(subject.each).to be_kind_of(Enumerator)
+        expect(subject.each.to_a).to eq(left | right)
+      end
+    end
+  end
+end

data/spec/operators/unique_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'wordlist/operators/unique'
+
+describe Wordlist::Operators::Unique do
+  let(:wordlist)  { %w[foo bar bar baz foo qux] }
+
+  subject { described_class.new(wordlist) }
+
+  describe "#each" do
+    context "when given a block" do
+      it "must yield the unique words from the wordlist" do
+        expect { |b|
+          subject.each(&b)
+        }.to yield_successive_args(*wordlist.uniq)
+      end
+    end
+
+    context "when not given a block" do
+      it "must return an Enumerator for the #each" do
+        expect(subject.each).to be_kind_of(Enumerator)
+        expect(subject.each.to_a).to eq(wordlist.uniq)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
-gem 'rspec', '~> 2.4'
 require 'rspec'
+require 'simplecov'
+SimpleCov.start
 
 require 'wordlist/version'
 include Wordlist

data/spec/unique_filter_spec.rb

@@ -1,34 +1,124 @@
+require 'spec_helper'
 require 'wordlist/unique_filter'
 
-require 'spec_helper'
+describe Wordlist::UniqueFilter do
+  describe "#initialize" do
+    it "must initialize #hashes to an empty Set" do
+      expect(subject.hashes).to be_kind_of(Set)
+      expect(subject.hashes).to be_empty
+    end
+  end
+
+  describe "#add" do
+    let(:word) { "foo" }
+
+    before { subject.add(word) }
 
-describe UniqueFilter do
-  before(:each) do
-    @filter = UniqueFilter.new
+    it "must add the String's hash to #hashes" do
+      expect(subject.hashes.include?(word.hash)).to be(true)
+    end
+
+    context "when the same word is added twice" do
+      before do
+        subject.add(word)
+        subject.add(word)
+      end
+
+      it "must add the String's hash to #hashes only once" do
+        expect(subject.hashes).to eq(Set[word.hash])
+      end
+    end
   end
 
-  it "should have seen words" do
-    @filter.saw!('cat')
+  describe "#include?" do
+    let(:word) { "foo" }
+
+    before { subject.add(word) }
+
+    context "when the unique filter contains the String's hash" do
+      it "must return true" do
+        expect(subject.include?(word)).to be(true)
+      end
+    end
 
-    @filter.seen?('cat').should == true
-    @filter.seen?('dog').should == false
+    context "when the unqiue filter does not contain the String's hash" do
+      it "must return false" do
+        expect(subject.include?("XXX")).to be(false)
+      end
+    end
   end
 
-  it "should only see a unique word once" do
-    @filter.saw!('cat').should == true
-    @filter.saw!('cat').should == false
+  describe "#add?" do
+    let(:word) { "foo" }
+
+    before { subject.add(word) }
+
+    context "when the unique filter contains the String's hash" do
+      it "must return nil" do
+        expect(subject.add?(word)).to be(false)
+      end
+    end
+
+    context "when the unqiue filter does not contain the String's hash" do
+      let(:new_word) { "bar" }
+
+      it "must return nil" do
+        expect(subject.add?(new_word)).to be(true)
+      end
+    end
   end
 
-  it "should pass only unique words through the filter" do
-    input = ['dog', 'cat', 'dog']
-    output = []
+  describe "#empty?" do
+    context "when no words have been added to the unique filter" do
+      it "must return true" do
+        expect(subject.empty?).to be(true)
+      end
+    end
 
-    input.each do |word|
-      @filter.pass(word) do |result|
-        output << result
+    context "when words have been added to the unique filter" do
+      let(:word) { 'foo' }
+
+      before { subject.add(word) }
+
+      it "must return false" do
+        expect(subject.empty?).to be(false)
       end
     end
+  end
+
+  describe "#clear" do
+    let(:word1) { 'foo' }
+    let(:word2) { 'bar' }
+
+    before do
+      subject.add(word1)
+      subject.clear
+      subject.add(word2)
+    end
+
+    it "must clear the unique filter of any words" do
+      expect(subject.include?(word1)).to be(false)
+      expect(subject.include?(word2)).to be(true)
+    end
+  end
+
+  describe "#size" do
+    it "must return 0 by default" do
+      expect(subject.size).to eq(0)
+    end
 
-    output.should == ['dog', 'cat']
+    context "when the unique filter has been populated" do
+      let(:words) { %w[foo bar baz] }
+
+      before do
+        words.each do |word|
+          subject.add(word)
+        end
+      end
+
+      it "must return the number of unique words added to the filter" do
+        expect(subject.size).to eq(words.length)
+      end
+    end
   end
 end

data/spec/wordlist_spec.rb

@@ -1,9 +1,61 @@
-require 'wordlist/version'
-
 require 'spec_helper'
+require 'wordlist'
 
 describe Wordlist do
   it "should have a VERSION constant" do
-    Wordlist.const_defined?('VERSION').should == true
+    expect(Wordlist.const_defined?('VERSION')).to be(true)
+  end
+
+  describe ".[]" do
+    let(:words) { %w[foo bar baz] }
+
+    subject { described_class[*words] }
+
+    it "must return a Wordlist::Words object with the given words" do
+      expect(subject).to be_kind_of(Wordlist::Words)
+      expect(subject.words).to eq(words)
+    end
+  end
+
+  let(:fixtures_dir) { ::File.join(__dir__,'fixtures') }
+
+  describe ".open" do
+    let(:path) { ::File.join(fixtures_dir,'wordlist.txt') }
+
+    subject { described_class.open(path) }
+
+    it "must return a Wordlist::File object using the given path" do
+      expect(subject).to be_kind_of(Wordlist::File)
+      expect(subject.path).to eq(path)
+    end
+
+    context "when given a block" do
+      it "must yield the Wordlist::File object" do
+        expect { |b|
+          described_class.open(path,&b)
+        }.to yield_with_args(Wordlist::File)
+      end
+    end
+  end
+
+  describe ".build" do
+    let(:path) { ::File.join(fixtures_dir,'new_wordlist.txt') }
+
+    subject { described_class.build(path) }
+
+    it "must return a Wordlist::Builder object using the given path" do
+      expect(subject).to be_kind_of(Wordlist::Builder)
+      expect(subject.path).to eq(path)
+    end
+
+    context "when given a block" do
+      it "must yield the Wordlist::Builder object" do
+        expect { |b|
+          described_class.build(path,&b)
+        }.to yield_with_args(Wordlist::Builder)
+      end
+    end
+
+    after { ::FileUtils.rm_f(path) }
   end
 end

data/spec/words_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'wordlist/words'
+
+describe Wordlist::Words do
+  let(:words) { %w[foo bar baz] }
+
+  subject { described_class.new(words) }
+
+  describe "#initialize" do
+    it "must set #words" do
+      expect(subject.words).to eq(words)
+    end
+  end
+
+  describe ".[]" do
+    subject { described_class[*words] }
+
+    it "must return a new #{described_class}" do
+      expect(subject).to be_kind_of(described_class)
+    end
+
+    it "must initialize the wordlist with the given words" do
+      expect(subject.words).to eq(words)
+    end
+  end
+
+  describe "#each" do
+    context "when a block is given" do
+      it "must yield each word" do
+        expect { |b| subject.each(&b) }.to yield_successive_args(*words)
+      end
+    end
+
+    context "when no block is given" do
+      it "must return an Enumerator for the words" do
+        expect(subject.each).to be_kind_of(Enumerator)
+        expect(subject.each.to_a).to eq(words)
+      end
+    end
+  end
+end