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

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

@@ -3,50 +3,40 @@ require "hamster/list"
 
 describe Hamster::List do
   describe "#one?" do
-    describe "on a really big list" do
-      before do
-        @list = Hamster.interval(0, STACK_OVERFLOW_DEPTH)
-      end
-
+    context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { @list.one? { false } }.should_not raise_error
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).one? { false } }.should_not raise_error
       end
     end
 
-    describe "when empty" do
-      before do
-        @list = Hamster.list
-      end
-
+    context "when empty" do
       it "with a block returns false" do
-        @list.one? {}.should == false
+        Hamster.list.one? {}.should == false
       end
 
       it "with no block returns false" do
-        @list.one?.should == false
+        Hamster.list.one?.should == false
       end
     end
 
-    describe "when not empty" do
-      describe "with a block" do
-        before do
-          @list = Hamster.list("A", "B", "C")
-        end
+    context "when not empty" do
+      context "with a block" do
+        let(:list) { Hamster.list("A", "B", "C") }
 
         it "returns false if the block returns true more than once" do
-          @list.one? { |item| true }.should == false
+          list.one? { |item| true }.should == false
         end
 
         it "returns false if the block never returns true" do
-          @list.one? { |item| false }.should == false
+          list.one? { |item| false }.should == false
         end
 
         it "returns true if the block only returns true once" do
-          @list.one? { |item| item == "A" }.should == true
+          list.one? { |item| item == "A" }.should == true
         end
       end
 
-      describe "with no block" do
+      context "with no block" do
         it "returns false if more than one value is truthy" do
           Hamster.list(nil, true, "A").one?.should == false
         end

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

@@ -0,0 +1,116 @@
+require "spec_helper"
+require "hamster/list"
+require "thread"
+
+describe Hamster::List do
+  describe "#partition" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.partition }.should_not raise_error
+    end
+
+    it "calls the passed block only once for each item" do
+      count = 0
+      a,b = Hamster.list(1, 2, 3).partition { |item| count += 1; item.odd? }
+      (a.size + b.size).should be(3) # force realization of lazy lists
+      count.should be(3)
+    end
+
+    # note: Lists are not as lazy as they could be!
+    # they always realize elements a bit ahead of the current one
+
+    it "returns a lazy list of items for which predicate is true" do
+      count = 0
+      a,b = Hamster.list(1, 2, 3, 4).partition { |item| count += 1; item.odd? }
+      a.take(1).should == [1]
+      count.should be(3) # would be 1 if lists were lazier
+      a.take(2).should == [1, 3]
+      count.should be(4) # would be 3 if lists were lazier
+    end
+
+    it "returns a lazy list of items for which predicate is false" do
+      count = 0
+      a,b = Hamster.list(1, 2, 3, 4).partition { |item| count += 1; item.odd? }
+      b.take(1).should == [2]
+      count.should be(4) # would be 2 if lists were lazier
+      b.take(2).should == [2, 4]
+      count.should be(4)
+    end
+
+    it "calls the passed block only once for each item, even with multiple threads" do
+      mutex = Mutex.new
+      yielded = [] # record all the numbers yielded to the block, to make sure each is yielded only once
+      list = Hamster.iterate(0) do |n|
+        sleep(rand / 500) # give another thread a chance to get in
+        mutex.synchronize { yielded << n }
+        sleep(rand / 500)
+        n + 1
+      end
+      left, right = list.partition(&:odd?)
+
+      10.times.collect do |i|
+        Thread.new do
+          # half of the threads will consume the "left" lazy list, while half consume
+          # the "right" lazy list
+          # make sure that only one thread will run the above "iterate" block at a
+          # time, regardless
+          if i % 2 == 0
+            left.take(100).sum.should == 10000
+          else
+            right.take(100).sum.should == 9900
+          end
+        end
+      end.each(&:join)
+
+      # if no threads "stepped on" each other, the following should be true
+      # make some allowance for "lazy" lists which actually realize a little bit ahead:
+      (200..203).include?(yielded.size).should == true
+      yielded.should == (0..(yielded.size-1)).to_a
+    end
+
+    [
+      [[], [], []],
+      [[1], [1], []],
+      [[1, 2], [1], [2]],
+      [[1, 2, 3], [1, 3], [2]],
+      [[1, 2, 3, 4], [1, 3], [2, 4]],
+      [[2, 3, 4], [3], [2, 4]],
+      [[3, 4], [3], [4]],
+      [[4], [], [4]],
+    ].each do |values, expected_matches, expected_remainder|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        context "with a block" do
+          let(:result)  { list.partition(&:odd?) }
+          let(:matches) { result.first }
+          let(:remainder) { result.last }
+
+          it "preserves the original" do
+            list.should eql(Hamster.list(*values))
+          end
+
+          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
+            matches.should eql(Hamster.list(*expected_matches))
+          end
+
+          it "correctly identifies the remainder" do
+            remainder.should eql(Hamster.list(*expected_remainder))
+          end
+        end
+
+        context "without a block" do
+          it "returns an Enumerator" do
+            list.partition.class.should be(Enumerator)
+            list.partition.each(&:odd?).should eql([Hamster.list(*expected_matches), Hamster.list(*expected_remainder)])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#permutation" do
+    let(:list) { Hamster.list(1,2,3,4,5) }
+
+    context "with no block" do
+      it "returns an Enumerator" do
+        list.permutation.class.should be(Enumerator)
+        list.permutation.to_a.sort.should == [1,2,3,4,5].permutation.to_a.sort
+      end
+    end
+
+    context "with no argument" do
+      it "yields all permutations of the list" do
+        perms = list.permutation.to_a
+        perms.size.should be(120)
+        perms.sort.should == [1,2,3,4,5].permutation.to_a.sort
+        perms.each { |item| item.should be_kind_of(Hamster::List) }
+      end
+    end
+
+    context "with a length argument" do
+      it "yields all N-size permutations of the list" do
+        perms = list.permutation(3).to_a
+        perms.size.should be(60)
+        perms.sort.should == [1,2,3,4,5].permutation(3).to_a.sort
+        perms.each { |item| item.should be_kind_of(Hamster::List) }
+      end
+    end
+
+    context "with a length argument greater than length of list" do
+      it "yields nothing" do
+        list.permutation(6).to_a.should be_empty
+      end
+    end
+
+    context "with a length argument of 0" do
+      it "yields an empty list" do
+        perms = list.permutation(0).to_a
+        perms.size.should be(1)
+        perms[0].should be_kind_of(Hamster::List)
+        perms[0].should be_empty
+      end
+    end
+
+    context "with a block" do
+      it "returns the original list" do
+        list.permutation(0) {}.should be(list)
+        list.permutation(1) {}.should be(list)
+        list.permutation {}.should be(list)
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ describe Hamster::List do
     context "with a list with a few items" do
       let(:values) { %w[a b c] }
 
-      it "should remove the last item" do
+      it "removes the last item" do
         expect(pop).to eq(Hamster.list("a", "b"))
       end
     end

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

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

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

@@ -0,0 +1,97 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  [:reduce, :inject, :fold].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).send(method, &:+) }.should_not raise_error
+        end
+      end
+
+      [
+        [[], 10, 10],
+        [[1], 10, 9],
+        [[1, 2, 3], 10, 4],
+      ].each do |values, initial, expected|
+        context "on #{values.inspect}" do
+          context "with an initial value of #{initial} and a block" do
+            it "returns #{expected.inspect}" do
+              Hamster.list(*values).send(method, initial) { |memo, item| memo - item }.should == expected
+            end
+          end
+        end
+      end
+
+      [
+        [[], nil],
+        [[1], 1],
+        [[1, 2, 3], -4],
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          context "with no initial value and a block" do
+            it "returns #{expected.inspect}" do
+              Hamster.list(*values).send(method) { |memo, item| memo - item }.should == expected
+            end
+          end
+        end
+      end
+
+      context "with no block and a symbol argument" do
+        it "uses the symbol as the name of a method to reduce with" do
+          Hamster.list(1, 2, 3).send(method, :+).should == 6
+        end
+      end
+
+      context "with no block and a string argument" do
+        it "uses the string as the name of a method to reduce with" do
+          Hamster.list(1, 2, 3).send(method, '+').should == 6
+        end
+      end
+    end
+  end
+
+  describe "#foldr" do
+    [
+      [[], 10, 10],
+      [[1], 10, 9],
+      [[1, 2, 3], 10, 4],
+    ].each do |values, initial, expected|
+      context "on #{values.inspect}" do
+        context "with an initial value of #{initial} and a block" do
+          it "returns #{expected.inspect}" do
+            Hamster.list(*values).foldr(initial) { |memo, item| memo - item }.should == expected
+          end
+        end
+      end
+    end
+
+    [
+      [[], nil],
+      [[1], 1],
+      [[1, 2, 3], 0],
+      [[1, 2, 3, 4], -2]
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        context "with no initial value and a block" do
+          it "returns #{expected.inspect}" do
+            Hamster.list(*values).foldr { |memo, item| memo - item }.should == expected
+          end
+        end
+      end
+    end
+
+    context "with no block and a symbol argument" do
+      it "uses the symbol as the name of a method to reduce with" do
+        Hamster.list(1, 2, 3).foldr(:+).should == 6
+      end
+    end
+
+    context "with no block and a string argument" do
+      it "uses the string as the name of a method to reduce with" do
+        Hamster.list(1, 2, 3).foldr('+').should == 6
+      end
+    end
+  end
+end

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

@@ -15,24 +15,17 @@ describe Hamster::List do
         [%w[A b C], %w[A C]],
         [%w[a b c], []],
       ].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)
-          end
-
-          describe "with a block" do
-            before do
-              @result = @original.send(method) { |item| item == item.downcase }
-            end
-
+          context "with a block" do
             it "returns #{expected.inspect}" do
-              @result.should == Hamster.list(*expected)
+              list.send(method) { |item| item == item.downcase }.should eql(Hamster.list(*expected))
             end
 
             it "is lazy" do
               count = 0
-              @original.send(method) do |item|
+              list.send(method) do |item|
                 count += 1
                 false
               end
@@ -40,13 +33,10 @@ describe Hamster::List do
             end
           end
 
-          describe "without a block" do
-            before do
-              @result = @original.send(method)
-            end
-
-            it "returns self" do
-              @result.should equal(@original)
+          context "without a block" do
+            it "returns an Enumerator" do
+              list.send(method).class.should be(Enumerator)
+              list.send(method).each { |item| item == item.downcase }.should eql(Hamster.list(*expected))
             end
           end
         end

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

@@ -3,13 +3,9 @@ require "hamster/list"
 
 describe Hamster::List do
   describe "#reverse" do
-    describe "on a really big list" do
-      before do
-        @list = Hamster.interval(0, STACK_OVERFLOW_DEPTH)
-      end
-
+    context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { @list.reverse }.should_not raise_error
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).reverse }.should_not raise_error
       end
     end
 
@@ -22,19 +18,16 @@ describe Hamster::List do
       [["A"], ["A"]],
       [%w[A B C], %w[C B A]],
     ].each do |values, expected|
-
-      describe "on #{values.inspect}" do
-        before do
-          @original = Hamster.list(*values)
-          @result = @original.reverse { |item| item.downcase }
-        end
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
 
         it "preserves the original" do
-          @original.should == Hamster.list(*values)
+          list.reverse { |item| item.downcase }
+          list.should eql(Hamster.list(*values))
         end
 
         it "returns #{expected.inspect}" do
-          @result.should == Hamster.list(*expected)
+          list.reverse { |item| item.downcase }.should == Hamster.list(*expected)
         end
       end
     end