hamster 1.0.0 → 1.0.1.pre.rc.1

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

@@ -1,12 +1,16 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
+
   [
     [:sort, ->(left, right) { left.length <=> right.length }],
     [:sort_by, ->(item) { item.length }],
   ].each do |method, comparator|
+
     describe "##{method}" do
+
       it "is lazy" do
         -> { Hamster.stream { fail }.send(method, &comparator) }.should_not raise_error
       end
@@ -16,32 +20,51 @@ describe Hamster::List do
         [["A"], ["A"]],
         [%w[Ichi Ni San], %w[Ni San Ichi]],
       ].each do |values, expected|
-        context "on #{values.inspect}" do
-          let(:list) { Hamster.list(*values) }
 
-          context "with a block" do
+        describe "on #{values.inspect}" do
+
+          before do
+            @original = Hamster.list(*values)
+          end
+
+          describe "with a block" do
+
+            before do
+              @result = @original.send(method, &comparator)
+            end
+
             it "preserves the original" do
-              list.send(method, &comparator)
-              list.should == Hamster.list(*values)
+              @original.should == Hamster.list(*values)
             end
 
             it "returns #{expected.inspect}" do
-              list.send(method, &comparator).should == Hamster.list(*expected)
+              @result.should == Hamster.list(*expected)
             end
+
           end
 
-          context "without a block" do
+          describe "without a block" do
+
+            before do
+              @result = @original.send(method)
+            end
+
             it "preserves the original" do
-              list.send(method)
-              list.should eql(Hamster.list(*values))
+              @original.should == Hamster.list(*values)
             end
 
             it "returns #{expected.sort.inspect}" do
-              list.send(method).should == Hamster.list(*expected.sort)
+              @result.should == Hamster.list(*expected.sort)
             end
+
           end
+
         end
+
       end
+
     end
+
   end
-end
+
+end

data/spec/hamster/list/span_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+require "hamster/list"
+
+describe "Hamster.list#span" do
+
+  it "is lazy" do
+    -> { Hamster.stream { |item| fail }.span { true } }.should_not raise_error
+  end
+
+  describe <<-DESC do
+given a predicate (in the form of a block), splits the list into two lists
+  (returned as a tuple) such that elements in the first list (the prefix) are
+  taken from the head of the list while the predicate is satisfied, and elements
+  in the second list (the remainder) are the remaining elements from the list
+  once the predicate is not satisfied. For example:
+DESC
+
+    [
+      [[], [], []],
+      [[1], [1], []],
+      [[1, 2], [1, 2], []],
+      [[1, 2, 3], [1, 2], [3]],
+      [[1, 2, 3, 4], [1, 2], [3, 4]],
+      [[2, 3, 4], [2], [3, 4]],
+      [[3, 4], [], [3, 4]],
+      [[4], [], [4]],
+    ].each do |values, expected_prefix, expected_remainder|
+
+      describe "given the list #{values.inspect}" do
+
+        before do
+          @original = Hamster.list(*values)
+        end
+
+        describe "and a predicate that returns true for values <= 2" do
+
+          before do
+            @result = @original.span { |item| item <= 2 }
+            @prefix = @result.first
+            @remainder = @result.last
+          end
+
+          it "preserves the original" do
+            @original.should == Hamster.list(*values)
+          end
+
+          it "returns the prefix as #{expected_prefix.inspect}" do
+            @prefix.should == Hamster.list(*expected_prefix)
+          end
+
+          it "returns the remainder as #{expected_remainder.inspect}" do
+            @remainder.should == Hamster.list(*expected_remainder)
+          end
+
+        end
+
+        describe "without a predicate" do
+
+          before do
+            @result = @original.span
+            @prefix = @result.first
+            @remainder = @result.last
+          end
+
+          it "returns a tuple" do
+            @result.is_a?(Hamster::Tuple).should == true
+          end
+
+          it "returns self as the prefix" do
+            @prefix.should equal(@original)
+          end
+
+          it "returns an empty list as the remainder" do
+            @remainder.should be_empty
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,8 +1,12 @@
 require "spec_helper"
+
+require "hamster/tuple"
 require "hamster/list"
 
 describe Hamster::List do
+
   describe "#split_at" do
+
     it "is lazy" do
       -> { Hamster.stream { fail }.split_at(1) }.should_not raise_error
     end
@@ -14,31 +18,36 @@ 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|
-      context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
-        let(:result) { list.split_at(2) }
-        let(:prefix) { result.first }
-        let(:remainder) { result.last }
+
+      describe "on #{values.inspect}" do
+
+        before do
+          @original = Hamster.list(*values)
+          @result = @original.split_at(2)
+          @prefix = @result.first
+          @remainder = @result.last
+        end
 
         it "preserves the original" do
-          result
-          list.should eql(Hamster.list(*values))
+          @original.should == 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)
+        it "returns a tuple with two items" do
+          @result.is_a?(Hamster::Tuple).should == true
         end
 
         it "correctly identifies the matches" do
-          prefix.should eql(Hamster.list(*expected_prefix))
+          @prefix.should == Hamster.list(*expected_prefix)
         end
 
         it "correctly identifies the remainder" do
-          remainder.should eql(Hamster.list(*expected_remainder))
+          @remainder.should == Hamster.list(*expected_remainder)
         end
+
       end
+
     end
+
   end
-end
+
+end

data/spec/hamster/list/sum_spec.rb

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

data/spec/hamster/list/tail_spec.rb

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

data/spec/hamster/list/tails_spec.rb

@@ -0,0 +1,42 @@
+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"], [["A"], []]],
+      [%w[A B C], [%w[A B C], %w[B C], ["C"], []]],
+    ].each do |values, expected|
+
+      expected = expected.map { |x| Hamster.list(*x) }
+
+      describe "on #{values.inspect}" do
+
+        before do
+          @original = Hamster.list(*values)
+          @result = @original.tails
+        end
+
+        it "preserves the original" do
+          @original.should == Hamster.list(*values)
+        end
+
+        it "returns #{expected.inspect}" do
+          @result.should == Hamster.list(*expected)
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,8 +1,11 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
+
   describe "#take" do
+
     it "is lazy" do
       -> { Hamster.stream { fail }.take(1) }.should_not raise_error
     end
@@ -14,18 +17,26 @@ describe Hamster::List do
       [%w[A B C], 0, []],
       [%w[A B C], 2, %w[A B]],
     ].each do |values, number, expected|
-      context "#{number} from #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+
+      describe "#{number} from #{values.inspect}" do
+
+        before do
+          @original = Hamster.list(*values)
+          @result = @original.take(number)
+        end
 
         it "preserves the original" do
-          list.take(number)
-          list.should eql(Hamster.list(*values))
+          @original.should == Hamster.list(*values)
         end
 
         it "returns #{expected.inspect}" do
-          list.take(number).should eql(Hamster.list(*expected))
+          @result.should == Hamster.list(*expected)
         end
+
       end
+
     end
+
   end
-end
+
+end

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

@@ -1,4 +1,5 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
@@ -12,22 +13,25 @@ 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) }
 
-        context "with a block" do
+      describe "on #{values.inspect}" do
+        before do
+          @original = Hamster.list(*values)
+          @result = @original.take_while { |item| item < "C" }
+        end
+
+        describe "with a block" do
           it "returns #{expected.inspect}" do
-            list.take_while { |item| item < "C" }.should eql(Hamster.list(*expected))
+            @result.should == Hamster.list(*expected)
           end
 
           it "preserves the original" do
-            list.take_while { |item| item < "C" }
-            list.should eql(Hamster.list(*values))
+            @original.should == Hamster.list(*values)
           end
 
           it "is lazy" do
             count = 0
-            list.take_while do |item|
+            @original.take_while do |item|
               count += 1
               true
             end
@@ -35,10 +39,13 @@ describe Hamster::List do
           end
         end
 
-        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))
+        describe "without a block" do
+          before do
+            @result = @original.take_while
+          end
+
+          it "returns self" do
+            @result.should equal(@original)
           end
         end
       end