wordlist 0.1.1 → 1.0.1

data/spec/list_methods_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+require 'wordlist/list_methods'
+
+describe Wordlist::ListMethods do
+  module TestWordlist
+    class TestListMethods
+      include Wordlist::ListMethods
+    end
+  end
+
+  subject { TestWordlist::TestListMethods.new }
+
+  let(:other) { double(:other_list) }
+
+  describe "#concat" do
+    it "must return an Operators::Concat object with the list and the other list" do
+      expect(Operators::Concat).to receive(:new).with(subject,other)
+
+      subject.concat(other)
+    end
+  end
+
+  describe "#subtract" do
+    it "must return an Operators::Subtract object with the list and the other list" do
+      expect(Operators::Subtract).to receive(:new).with(subject,other)
+
+      subject.subtract(other)
+    end
+  end
+
+  describe "#product" do
+    it "must return an Operators::Product object with the list and the other list" do
+      expect(Operators::Product).to receive(:new).with(subject,other)
+
+      subject.product(other)
+    end
+  end
+
+  describe "#power" do
+    let(:exponent) { 3 }
+
+    it "must return an Operators::Power object with the list and an exponent" do
+      expect(Operators::Power).to receive(:new).with(subject,exponent)
+
+      subject.power(exponent)
+    end
+  end
+
+  describe "#intersect" do
+    it "must return an Operators::Intersect object with the list and the other list" do
+      expect(Operators::Intersect).to receive(:new).with(subject,other)
+
+      subject.intersect(other)
+    end
+  end
+
+  describe "#union" do
+    it "must return an Operators::Union object with the list and the other list" do
+      expect(Operators::Union).to receive(:new).with(subject,other)
+
+      subject.union(other)
+    end
+  end
+
+  describe "#uniq" do
+    it "must return an Operators::Uniq object with the list" do
+      expect(Operators::Unique).to receive(:new).with(subject)
+
+      subject.uniq
+    end
+  end
+
+  describe "#tr" do
+    let(:chars)   { double(:chars)   }
+    let(:replace) { double(:replace) }
+
+    it "must return an Modifiers::Tr object with the list, chars, and replace" do
+      expect(Modifiers::Tr).to receive(:new).with(subject,chars,replace)
+
+      subject.tr(chars,replace)
+    end
+  end
+
+  describe "#sub" do
+    let(:pattern) { double(:pattern)   }
+    let(:replace) { double(:replace) }
+
+    it "must return an Modifiers::Sub object with the list, pattern, and replace" do
+      expect(Modifiers::Sub).to receive(:new).with(subject,pattern,replace)
+
+      subject.sub(pattern,replace)
+    end
+
+    context "when replace is nil and a block is given" do
+      let(:replace) { nil }
+      let(:block)   { ->(match) { '0' } }
+
+      it "must return an Modifiers::Sub object with the list, pattern, and block" do
+        expect(Modifiers::Sub).to receive(:new).with(subject,pattern)
+
+        subject.sub(pattern,replace)
+      end
+    end
+  end
+
+  describe "#gsub" do
+    let(:pattern) { double(:pattern)   }
+    let(:replace) { double(:replace) }
+
+    it "must return an Modifiers::Gsub object with the list, pattern, and replace" do
+      expect(Modifiers::Gsub).to receive(:new).with(subject,pattern,replace)
+
+      subject.gsub(pattern,replace)
+    end
+
+    context "when replace is nil and a block is given" do
+      let(:replace) { nil }
+      let(:block)   { ->(match) { '0' } }
+
+      it "must return an Modifiers::Gsub object with the list, pattern, and block" do
+        expect(Modifiers::Gsub).to receive(:new).with(subject,pattern)
+
+        subject.gsub(pattern,replace)
+      end
+    end
+  end
+
+  describe "#capitalize" do
+    it "must return an Modifiers::Capitalize object with the list" do
+      expect(Modifiers::Capitalize).to receive(:new).with(subject)
+
+      subject.capitalize
+    end
+  end
+
+  describe "#upcase" do
+    it "must return an Modifiers::Upcase object with the list" do
+      expect(Modifiers::Upcase).to receive(:new).with(subject)
+
+      subject.upcase
+    end
+  end
+
+  describe "#downcase" do
+    it "must return an Modifiers::Downcase object with the list" do
+      expect(Modifiers::Downcase).to receive(:new).with(subject)
+
+      subject.downcase
+    end
+  end
+
+  describe "#mutate" do
+    let(:pattern) { double(:pattern) }
+    let(:replace) { double(:replace) }
+
+    it "must return an Modifiers::Mutate object with the list, pattern, and replace" do
+      expect(Modifiers::Mutate).to receive(:new).with(subject,pattern,replace)
+
+      subject.mutate(pattern,replace)
+    end
+
+    context "when replace is nil and a block is given" do
+      let(:replace) { nil }
+      let(:block)   { ->(match) { '0' } }
+
+      it "must return an Modifiers::Mutate object with the list, pattern, and block" do
+        expect(Modifiers::Mutate).to receive(:new).with(subject,pattern)
+
+        subject.mutate(pattern,replace)
+      end
+    end
+  end
+
+  describe "#mutate_case" do
+    it "must return an Modifiers::MutateCase object with the list" do
+      expect(Modifiers::MutateCase).to receive(:new).with(subject)
+
+      subject.mutate_case
+    end
+  end
+end

data/spec/modifiers/capitalize_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'wordlist/modifiers/capitalize'
+
+describe Wordlist::Modifiers::Capitalize do
+  let(:wordlist) { %w[foo bar baz] }
+
+  subject { described_class.new(wordlist) }
+
+  describe "#each" do
+    let(:expected_words) { wordlist.map(&:capitalize) }
+
+    context "when given a block" do
+      it "must capitalize each word" 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 object for #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/modifiers/downcase_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'wordlist/modifiers/downcase'
+
+describe Wordlist::Modifiers::Downcase do
+  let(:wordlist) { %w[Foo BAR baz] }
+
+  subject { described_class.new(wordlist) }
+
+  describe "#each" do
+    let(:expected_words) { wordlist.map(&:downcase) }
+
+    context "when given a block" do
+      it "must downcase each word" 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 object for #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/modifiers/gsub_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'wordlist/modifiers/gsub'
+
+describe Wordlist::Modifiers::Gsub do
+  let(:wordlist) { %w[foo bar baz] }
+
+  let(:pattern) { /o/ }
+  let(:replace) { '0' }
+
+  subject { described_class.new(wordlist,pattern,replace) }
+
+  describe "#each" do
+    context "when initialized with a replacement String" do
+      let(:expected_words) do
+        wordlist.map { |word| word.gsub(pattern,replace) }
+      end
+
+      context "when given a block" do
+        it "must call #gsub on each word" 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 object for #each" do
+          expect(subject.each).to be_kind_of(Enumerator)
+          expect(subject.each.to_a).to eq(expected_words)
+        end
+      end
+    end
+
+    context "when initialized with a replacement block" do
+      let(:block) { ->(word) { '0' } }
+
+      subject { described_class.new(wordlist,pattern,&block) }
+
+      let(:expected_words) do
+        wordlist.map { |word| word.gsub(pattern,&block) }
+      end
+
+      context "when given a block" do
+        it "must call #gsub on each word" 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 object for #each" do
+          expect(subject.each).to be_kind_of(Enumerator)
+          expect(subject.each.to_a).to eq(expected_words)
+        end
+      end
+    end
+  end
+end

data/spec/modifiers/modifier_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'wordlist/modifiers/modifier'
+
+describe Wordlist::Modifiers::Modifier do
+  let(:wordlist) { %w[foo bar baz] }
+
+  subject { described_class.new(wordlist) }
+
+  it do
+    expect(described_class).to include(Enumerable)
+  end
+
+  describe "#each" do
+    it do
+      expect {
+        subject.each
+      }.to raise_error(NotImplementedError,"#{described_class}#each was not implemented")
+    end
+  end
+end

data/spec/modifiers/mutate_case_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'wordlist/modifiers/mutate_case'
+
+describe Wordlist::Modifiers::MutateCase do
+  let(:wordlist) { %w[foo BaR] }
+
+  subject { described_class.new(wordlist) }
+
+  describe "#each" do
+    let(:expected_words) do
+      %w[
+        foo
+        Foo
+        fOo
+        foO
+        FOo
+        FoO
+        fOO
+        FOO
+        BaR
+        baR
+        BAR
+        Bar
+        bAR
+        bar
+        BAr
+        bAr
+      ]
+    end
+
+    context "when given a block" do
+      it "must enumerate through every possible uppercase/lowercase combination" 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 object for #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/modifiers/mutate_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'wordlist/modifiers/mutate'
+
+describe Wordlist::Modifiers::Mutate do
+  let(:wordlist) { %w[foo bar] }
+
+  let(:pattern) { /[oa]/ }
+  let(:replace) { {'o' => '0', 'a' => '@'} }
+
+  subject { described_class.new(wordlist,pattern,replace) }
+
+  describe "#each" do
+    let(:expected_words) do
+      %w[
+        foo
+        f0o
+        fo0
+        f00
+        bar
+        b@r
+      ]
+    end
+
+    context "when given a block" do
+      it "must enumerate through every possible string substitution combination" 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 object for #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/modifiers/sub_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'wordlist/modifiers/sub'
+
+describe Wordlist::Modifiers::Sub do
+  let(:wordlist) { %w[foo bar baz] }
+
+  let(:pattern) { /o/ }
+  let(:replace) { '0' }
+
+  let(:block) do
+    proc { |match| match.swapcase }
+  end
+
+  subject { described_class.new(wordlist,pattern,replace) }
+
+  describe "#initialize" do
+    it "must set #wordlist" do
+      expect(subject.wordlist).to eq(wordlist)
+    end
+
+    it "must set #pattern" do
+      expect(subject.pattern).to eq(pattern)
+    end
+
+    it "must set #replace" do
+      expect(subject.replace).to eq(replace)
+    end
+
+    it "must default #block to nil" do
+      expect(subject.block).to be(nil)
+    end
+
+    context "when the replacement value is a String" do
+      it "must set #replace" do
+        expect(subject.replace).to eq(replace)
+      end
+    end
+
+    context "when the replacement value is a Hash" do
+      let(:replace) { {'o' => '0', 'e' => '3', 'a' => '@'} }
+
+      it "must set #replace" do
+        expect(subject.replace).to eq(replace)
+      end
+    end
+
+    context "when the replacement value is nil" do
+      let(:replace) { nil }
+
+      it "must not set #replace" do
+        expect(subject.replace).to be(nil)
+      end
+    end
+
+    context "when a block is given" do
+      subject { described_class.new(wordlist,pattern,&block) }
+
+      it "must set #block" do
+        expect(subject.block).to eq(block)
+      end
+    end
+  end
+
+  describe "#each" do
+    let(:expected_words) do
+      wordlist.map { |word| word.sub(pattern,replace) }
+    end
+
+    context "when given a block" do
+      it "must call #sub on each word" do
+        expect { |b|
+          subject.each(&b)
+        }.to yield_successive_args(*expected_words)
+      end
+
+      context "when initialized with no replacement String but with a block" do
+        subject { described_class.new(wordlist,pattern,&block) }
+
+        let(:expected_words) do
+          wordlist.map { |word| word.sub(pattern,&block) }
+        end
+
+        it "must pass the block to #sub" do
+          expect { |b|
+            subject.each(&b)
+          }.to yield_successive_args(*expected_words)
+        end
+      end
+    end
+
+    context "when not given a block" do
+      it "must return an Enumerator object for #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/modifiers/tr_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'wordlist/modifiers/tr'
+
+describe Wordlist::Modifiers::Tr do
+  let(:wordlist) { %w[foo bar baz] }
+
+  let(:chars)   { 'oa' }
+  let(:replace) { '0@' }
+
+  subject { described_class.new(wordlist,chars,replace) }
+
+  describe "#initialize" do
+    it "must set #wordlist" do
+      expect(subject.wordlist).to eq(wordlist)
+    end
+
+    it "must set #chars" do
+      expect(subject.chars).to eq(chars)
+    end
+
+    it "must set #replace" do
+      expect(subject.replace).to eq(replace)
+    end
+  end
+
+  describe "#each" do
+    let(:expected_words) do
+      wordlist.map { |word| word.tr(chars,replace) }
+    end
+
+    context "when given a block" do
+      it "must call #gsub on each word" 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 object for #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/modifiers/upcase_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'wordlist/modifiers/upcase'
+
+describe Wordlist::Modifiers::Upcase do
+  let(:wordlist) { %w[Foo BAR baz] }
+
+  subject { described_class.new(wordlist) }
+
+  describe "#each" do
+    let(:expected_words) { wordlist.map(&:upcase) }
+
+    context "when given a block" do
+      it "must downcase each word" 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 object for #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/binary_operator_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'wordlist/operators/binary_operator'
+
+describe Wordlist::Operators::BinaryOperator do
+  let(:left)  { %w[foo bar] }
+  let(:right) { %w[baz qux] }
+
+  subject { described_class.new(left,right) }
+
+  describe "#initialize" do
+    it "must set #left" do
+      expect(subject.left).to eq(left)
+    end
+
+    it "must set #right" do
+      expect(subject.right).to eq(right)
+    end
+  end
+end

data/spec/operators/concat_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'wordlist/operators/concat'
+
+describe Wordlist::Operators::Concat do
+  let(:left)  { %w[foo bar] }
+  let(:right) { %w[baz qux] }
+
+  subject { described_class.new(left,right) }
+
+  describe "#each" do
+    context "when given a block" do
+      it "must yield each word from both wordlists" do
+        expect { |b|
+          subject.each(&b)
+        }.to yield_successive_args(*(left + right))
+      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/intersect_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'wordlist/operators/intersect'
+
+describe Wordlist::Operators::Intersect 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 exist in both 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 not yield any words" do
+          expect { |b|
+            subject.each(&b)
+          }.to_not yield_control
+        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/operator_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'wordlist/operators/operator'
+
+describe Wordlist::Operators::Operator do
+  it do
+    expect(described_class).to include(Enumerable)
+  end
+
+  describe "#each" do
+    it do
+      expect {
+        subject.each
+      }.to raise_error(NotImplementedError,"#{described_class}#each was not implemented")
+    end
+  end
+end