hamster 1.0.1.pre.rc2 → 1.0.1.pre.rc3

data/spec/{hamster → lib/hamster}/list/split_at_spec.rb

@@ -1,5 +1,4 @@
 require "spec_helper"
-require "hamster/tuple"
 require "hamster/list"
 
 describe Hamster::List do
@@ -15,29 +14,29 @@ describe Hamster::List do
       [[1, 2, 3], [1, 2], [3]],
       [[1, 2, 3, 4], [1, 2], [3, 4]],
     ].each do |values, expected_prefix, expected_remainder|
-
-      describe "on #{values.inspect}" do
-        before do
-          @original = Hamster.list(*values)
-          @result = @original.split_at(2)
-          @prefix = @result.first
-          @remainder = @result.last
-        end
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+        let(:result) { list.split_at(2) }
+        let(:prefix) { result.first }
+        let(:remainder) { result.last }
 
         it "preserves the original" do
-          @original.should == Hamster.list(*values)
+          result
+          list.should eql(Hamster.list(*values))
         end
 
-        it "returns a tuple with two items" do
-          @result.is_a?(Hamster::Tuple).should == true
+        it "returns a frozen array with two items" do
+          result.class.should be(Array)
+          result.should be_frozen
+          result.size.should be(2)
         end
 
         it "correctly identifies the matches" do
-          @prefix.should == Hamster.list(*expected_prefix)
+          prefix.should eql(Hamster.list(*expected_prefix))
         end
 
         it "correctly identifies the remainder" do
-          @remainder.should == Hamster.list(*expected_remainder)
+          remainder.should eql(Hamster.list(*expected_remainder))
         end
       end
     end

data/spec/lib/hamster/list/subsequences_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#subsequences" do
+    let(:list) { Hamster.list(1,2,3,4,5) }
+
+    it "yields all sublists with 1 or more consecutive items" do
+      result = []
+      list.subsequences { |l| result << l }
+      result.size.should == (5 + 4 + 3 + 2 + 1)
+      result.sort.should == [[1], [1,2], [1,2,3], [1,2,3,4], [1,2,3,4,5],
+        [2], [2,3], [2,3,4], [2,3,4,5], [3], [3,4], [3,4,5], [4], [4,5], [5]]
+    end
+
+    context "with no block" do
+      it "returns an Enumerator" do
+        list.subsequences.class.should be(Enumerator)
+        list.subsequences.to_a.sort.should == [[1], [1,2], [1,2,3], [1,2,3,4], [1,2,3,4,5],
+        [2], [2,3], [2,3,4], [2,3,4,5], [3], [3,4], [3,4,5], [4], [4,5], [5]]
+      end
+    end
+  end
+end

data/spec/lib/hamster/list/sum_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#sum" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).sum }.should_not raise_error
+      end
+    end
+
+    [
+      [[], 0],
+      [[2], 2],
+      [[1, 3, 5, 7, 11], 27],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          Hamster.list(*values).sum.should == expected
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/list/tail_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#tail" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).filter(&:nil?).tail }.should_not raise_error
+      end
+    end
+
+    [
+      [[], []],
+      [["A"], []],
+      [%w[A B C], %w[B C]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        it "preserves the original" do
+          list.tail
+          list.should eql(Hamster.list(*values))
+        end
+
+        it "returns #{expected.inspect}" do
+          list.tail.should eql(Hamster.list(*expected))
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/list/tails_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#tails" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.tails }.should_not raise_error
+    end
+
+    [
+      [[], []],
+      [["A"], [L["A"]]],
+      [%w[A B C], [L["A", "B", "C"], L["B", "C"], L["C"]]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        it "preserves the original" do
+          list.tails
+          list.should eql(Hamster.list(*values))
+        end
+
+        it "returns #{expected.inspect}" do
+          list.tails.should eql(Hamster.list(*expected))
+        end
+      end
+    end
+  end
+end

data/spec/{hamster → lib/hamster}/list/take_spec.rb

@@ -14,19 +14,16 @@ describe Hamster::List do
       [%w[A B C], 0, []],
       [%w[A B C], 2, %w[A B]],
     ].each do |values, number, expected|
-
-      describe "#{number} from #{values.inspect}" do
-        before do
-          @original = Hamster.list(*values)
-          @result = @original.take(number)
-        end
+      context "#{number} from #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
 
         it "preserves the original" do
-          @original.should == Hamster.list(*values)
+          list.take(number)
+          list.should eql(Hamster.list(*values))
         end
 
         it "returns #{expected.inspect}" do
-          @result.should == Hamster.list(*expected)
+          list.take(number).should eql(Hamster.list(*expected))
         end
       end
     end

data/spec/{hamster → lib/hamster}/list/take_while_spec.rb

@@ -12,25 +12,22 @@ describe Hamster::List do
       [["A"], ["A"]],
       [%w[A B C], %w[A B]],
     ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
 
-      describe "on #{values.inspect}" do
-        before do
-          @original = Hamster.list(*values)
-          @result = @original.take_while { |item| item < "C" }
-        end
-
-        describe "with a block" do
+        context "with a block" do
           it "returns #{expected.inspect}" do
-            @result.should == Hamster.list(*expected)
+            list.take_while { |item| item < "C" }.should eql(Hamster.list(*expected))
           end
 
           it "preserves the original" do
-            @original.should == Hamster.list(*values)
+            list.take_while { |item| item < "C" }
+            list.should eql(Hamster.list(*values))
           end
 
           it "is lazy" do
             count = 0
-            @original.take_while do |item|
+            list.take_while do |item|
               count += 1
               true
             end
@@ -38,13 +35,10 @@ describe Hamster::List do
           end
         end
 
-        describe "without a block" do
-          before do
-            @result = @original.take_while
-          end
-
-          it "returns self" do
-            @result.should equal(@original)
+        context "without a block" do
+          it "returns an Enumerator" do
+            list.take_while.class.should be(Enumerator)
+            list.take_while.each { |item| item < "C" }.should eql(Hamster.list(*expected))
           end
         end
       end

data/spec/lib/hamster/list/to_a_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  [:to_a, :entries].each do |method|
+    describe "##{method}" do
+      context "on a really big list" do
+        it "doesn't run out of stack" do
+          -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).to_a }.should_not raise_error
+        end
+      end
+
+      [
+        [],
+        ["A"],
+        %w[A B C],
+      ].each do |values|
+        context "on #{values.inspect}" do
+          let(:list) { Hamster.list(*values) }
+
+          it "returns #{values.inspect}" do
+            list.send(method).should == values
+          end
+
+          it "leaves the original unchanged" do
+            list.send(method)
+            list.should eql(Hamster.list(*values))
+          end
+
+          it "returns a mutable array" do
+            result = list.send(method)
+            expect(result.last).to_not eq("The End")
+            result << "The End"
+            result.last.should == "The End"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/{hamster → lib/hamster}/list/to_ary_spec.rb

@@ -6,10 +6,8 @@ describe Hamster::List do
 
   describe "#to_ary" do
     context "on a really big list" do
-      let(:list) { Hamster.interval(0, STACK_OVERFLOW_DEPTH) }
-
       it "doesn't run out of stack" do
-        -> { list.to_ary }.should_not raise_error
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).to_ary }.should_not raise_error
       end
     end
 

data/spec/{hamster → lib/hamster}/list/to_list_spec.rb

@@ -8,15 +8,11 @@ describe Hamster::List do
       ["A"],
       %w[A B C],
     ].each do |values|
-
-      describe "on #{values.inspect}" do
-        before do
-          @original = Hamster.list(*values)
-          @result = @original.to_list
-        end
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
 
         it "returns self" do
-          @result.should equal(@original)
+          list.to_list.should equal(list)
         end
       end
     end

data/spec/{hamster → lib/hamster}/list/to_set_spec.rb

@@ -4,22 +4,14 @@ require "hamster/set"
 
 describe Hamster::List do
   describe "#to_set" do
-
     [
       [],
       ["A"],
       %w[A B C],
     ].each do |values|
-
-      describe "on #{values.inspect}" do
-
-        before do
-          original = Hamster.list(*values)
-          @result = original.to_set
-        end
-
+      context "on #{values.inspect}" do
         it "returns a set with the same values" do
-          @result.should == Hamster.set(*values)
+          Hamster.list(*values).to_set.should eql(Hamster.set(*values))
         end
       end
     end

data/spec/lib/hamster/list/transpose_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#transpose" do
+    it "takes a list of lists and returns a list of all the first elements, all the 2nd elements, and so on" do
+      L[L[1, 'a'], L[2, 'b'], L[3, 'c']].transpose.should eql(L[L[1, 2, 3], L["a", "b", "c"]])
+      L[L[1, 2, 3], L["a", "b", "c"]].transpose.should eql(L[L[1, 'a'], L[2, 'b'], L[3, 'c']])
+      L[].transpose.should eql(L[])
+      L[L[]].transpose.should eql(L[])
+      L[L[], L[]].transpose.should eql(L[])
+      L[L[0]].transpose.should eql(L[L[0]])
+      L[L[0], L[1]].transpose.should eql(L[L[0, 1]])
+    end
+
+    it "only goes as far as the shortest list" do
+      L[L[1,2,3], L[2]].transpose.should eql(L[L[1,2]])
+    end
+  end
+end

data/spec/{hamster → lib/hamster}/list/union_spec.rb

@@ -14,23 +14,16 @@ describe Hamster::List do
         [%w[A B C], [], %w[A B C]],
         [%w[A A], ["A"], ["A"]],
       ].each do |a, b, expected|
-
-        describe "returns #{expected.inspect}" do
-          before do
-            @a = Hamster.list(*a)
-            @b = Hamster.list(*b)
-          end
+        context "returns #{expected.inspect}" do
+          let(:list_a) { Hamster.list(*a) }
+          let(:list_b) { Hamster.list(*b) }
 
           it "for #{a.inspect} and #{b.inspect}"  do
-            @result = @a.send(method, @b)
+            list_a.send(method, list_b).should eql(Hamster.list(*expected))
           end
 
           it "for #{b.inspect} and #{a.inspect}"  do
-            @result = @b.send(method, @a)
-          end
-
-          after  do
-            @result.should == Hamster.list(*expected)
+            list_b.send(method, list_a).should eql(Hamster.list(*expected))
           end
         end
       end

data/spec/{hamster → lib/hamster}/list/uniq_spec.rb

@@ -14,19 +14,16 @@ describe Hamster::List do
         [%w[A B C], %w[A B C]],
         [%w[A B A C C], %w[A B C]],
       ].each do |values, expected|
-
-        describe "on #{values.inspect}" do
-          before do
-            @original = Hamster.list(*values)
-            @result = @original.send(method)
-          end
+        context "on #{values.inspect}" do
+          let(:list) { Hamster.list(*values) }
 
           it "preserves the original" do
-            @original.should == Hamster.list(*values)
+            list.send(method)
+            list.should eql(Hamster.list(*values))
           end
 
           it "returns #{expected.inspect}" do
-            @result.should == Hamster.list(*expected)
+            list.send(method).should eql(Hamster.list(*expected))
           end
         end
       end

data/spec/{hamster → lib/hamster}/list/zip_spec.rb

@@ -14,16 +14,9 @@ describe Hamster::List do
       [[], ["A"], [Hamster.list(nil, "A")]],
       [%w[A B C], %w[aye bee see], [Hamster.list("A", "aye"), Hamster.list("B", "bee"), Hamster.list("C", "see")]],
     ].each do |left, right, expected|
-
-      describe "on #{left.inspect} and #{right.inspect}" do
-        before do
-          @left = Hamster.list(*left)
-          @right = Hamster.list(*right)
-          @result = @left.zip(@right)
-        end
-
+      context "on #{left.inspect} and #{right.inspect}" do
         it "returns #{expected.inspect}" do
-          @result.should == Hamster.list(*expected)
+          Hamster.list(*left).zip(Hamster.list(*right)).should eql(Hamster.list(*expected))
         end
       end
     end

data/spec/lib/hamster/set/add_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  let(:original) { Hamster.set("A", "B", "C") }
+
+  [:add, :<<].each do |method|
+    describe "##{method}" do
+      context "with a unique value" do
+        let(:result) { original.send(method, "D") }
+
+        it "preserves the original" do
+          result
+          original.should eql(Hamster.set("A", "B", "C"))
+        end
+
+        it "returns a copy with the superset of values" do
+          result.should eql(Hamster.set("A", "B", "C", "D"))
+        end
+      end
+
+      context "with a duplicate value" do
+        let(:result) { original.send(method, "C") }
+
+        it "preserves the original values" do
+          result
+          original.should eql(Hamster.set("A", "B", "C"))
+        end
+
+        it "returns self" do
+          result.should equal(original)
+        end
+      end
+
+      it "can add nil to a set" do
+        original.add(nil).should eql(Hamster.set("A", "B", "C", nil))
+      end
+
+      it "works on large sets, with many combinations of input" do
+        50.times do
+          array = (1..500).to_a.sample(100)
+          set = Hamster::Set.new(array)
+          to_add = 1000 + rand(1000)
+          set.add(to_add).size.should == 101
+          set.add(to_add).include?(to_add).should == true
+        end
+      end
+    end
+  end
+
+  describe "#add?" do
+    context "with a unique value" do
+      let(:result) { original.add?("D") }
+
+      it "preserves the original" do
+        original.should eql(Hamster.set("A", "B", "C"))
+      end
+
+      it "returns a copy with the superset of values" do
+        result.should eql(Hamster.set("A", "B", "C", "D"))
+      end
+    end
+
+    context "with a duplicate value" do
+      let(:result) { original.add?("C") }
+
+      it "preserves the original values" do
+        original.should eql(Hamster.set("A", "B", "C"))
+      end
+
+      it "returns false" do
+        result.should equal(false)
+      end
+    end
+  end
+end