hamster 0.4.3 → 1.0.0

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

@@ -0,0 +1,48 @@
+require "spec_helper"
+require "hamster/list"
+require "atomic"
+
+describe Hamster::List do
+  it "ensures each node of a lazy list will only be realized on ONE thread, even when accessed by multiple threads" do
+    counter = Atomic.new(0)
+    list = Hamster.list(*1..10000).map { |x| counter.update { |count| count + 1 }; x * 2 }
+
+    threads = 10.times.collect do
+      Thread.new do
+        node = list
+        node = node.tail until node.empty?
+      end
+    end
+    threads.each(&:join)
+
+    counter.get.should == 10000
+    list.sum.should == 100010000
+  end
+
+  it "doesn't go into an infinite loop if lazy list block raises an exception" do
+    list = Hamster.list(*1..10).map { raise "Oops!" }
+
+    threads = 10.times.collect do
+      Thread.new do
+        -> { list.head }.should raise_error
+      end
+    end
+    threads.each(&:join)
+  end
+
+  it "doesn't give horrendously bad performance if thread realizing the list sleeps" do
+    start = Time.now
+    list = Hamster.list(*1..100).map { |x| sleep(0.001); x * 2 }
+
+    threads = 10.times.collect do
+      Thread.new do
+        node = list
+        node = node.tail until node.empty?
+      end
+    end
+    threads.each(&:join)
+
+    elapsed = Time.now - start
+    elapsed.should_not > 0.3
+  end
+end

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

@@ -1,63 +1,40 @@
-require 'spec_helper'
-
-require 'hamster/list'
+require "spec_helper"
+require "hamster/list"
 
 describe Hamster::List do
-
   describe "#none?" 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
-        lambda { @list.none? { false } }.should_not raise_error
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).none? { 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 true" do
-        @list.none? {}.should == true
+        Hamster.list.none? {}.should == true
       end
 
       it "with no block returns true" do
-        @list.none?.should == true
+        Hamster.list.none?.should == true
       end
-
     end
 
-    describe "when not empty" do
-
-      describe "with a block" do
-
-        before do
-          @list = Hamster.list("A", "B", "C", nil)
-        end
+    context "when not empty" do
+      context "with a block" do
+        let(:list) { Hamster.list("A", "B", "C", nil) }
 
         ["A", "B", "C", nil].each do |value|
-
           it "returns false if the block ever returns true (#{value.inspect})" do
-            @list.none? { |item| item == value }.should == false
+            list.none? { |item| item == value }.should == false
           end
-
         end
 
         it "returns true if the block always returns false" do
-          @list.none? { |item| item == "D" }.should == true
+          list.none? { |item| item == "D" }.should == true
         end
-
       end
 
-      describe "with no block" do
-
+      context "with no block" do
         it "returns false if any value is truthy" do
           Hamster.list(nil, false, true, "A").none?.should == false
         end
@@ -65,11 +42,7 @@ describe Hamster::List do
         it "returns true if all values are falsey" do
           Hamster.list(nil, false).none?.should == true
         end
-
       end
-
     end
-
   end
-
-end
+end

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

@@ -1,63 +1,42 @@
-require 'spec_helper'
-
-require 'hamster/list'
+require "spec_helper"
+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
-        lambda { @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
@@ -65,11 +44,7 @@ describe Hamster::List do
         it "returns true if only one value is truthy" do
           Hamster.list(nil, true, false).one?.should == true
         end
-
       end
-
     end
-
   end
-
-end
+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/lib/hamster/list/pop_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  let(:list) { Hamster.list(*values) }
+
+  describe "#pop" do
+    let(:pop) { list.pop }
+
+    context "with an empty list" do
+      let(:values) { [] }
+
+      it "returns an empty list" do
+        expect(pop).to eq(Hamster.list)
+      end
+    end
+
+    context "with a list with a few items" do
+      let(:values) { %w[a b c] }
+
+      it "removes the last item" do
+        expect(pop).to eq(Hamster.list("a", "b"))
+      end
+    end
+  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