hamster 1.0.0 → 1.0.1.pre.rc.1

data/spec/hamster/list/any_spec.rb

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

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

@@ -1,9 +1,13 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
-  [:append, :concat, :+].each do |method|
+
+  [:append, :concat, :cat, :+].each do |method|
+
     describe "##{method}" do
+
       it "is lazy" do
         -> { Hamster.stream { fail }.append(Hamster.stream { fail }) }.should_not raise_error
       end
@@ -14,26 +18,33 @@ describe Hamster::List do
         [[], ["A"], ["A"]],
         [%w[A B], %w[C D], %w[A B C D]],
       ].each do |left_values, right_values, expected|
-        context "on #{left_values.inspect} and #{right_values.inspect}" do
-          let(:left) { Hamster.list(*left_values) }
-          let(:right) { Hamster.list(*right_values) }
-          let(:result) { left.append(right) }
+
+        describe "on #{left_values.inspect} and #{right_values.inspect}" do
+
+          before do
+            @left = Hamster.list(*left_values)
+            @right = Hamster.list(*right_values)
+            @result = @left.append(@right)
+          end
 
           it "preserves the left" do
-            result
-            left.should eql(Hamster.list(*left_values))
+            @left.should == Hamster.list(*left_values)
           end
 
           it "preserves the right" do
-            result
-            right.should eql(Hamster.list(*right_values))
+            @right.should == Hamster.list(*right_values)
           end
 
           it "returns #{expected.inspect}" do
-            result.should eql(Hamster.list(*expected))
+            @result.should == Hamster.list(*expected)
           end
+
         end
+
       end
+
     end
+
   end
-end
+
+end

data/spec/hamster/list/at_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+require "hamster/list"
+
+describe Hamster::List do
+
+  [:at, :[]].each do |method|
+
+    describe "##{method}" 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.send(method, STACK_OVERFLOW_DEPTH) }.should_not raise_error
+        end
+
+      end
+
+      [
+        [[], 10, nil],
+        [["A"], 10, nil],
+        [%w[A B C], 0, "A"],
+        [%w[A B C], 2, "C"],
+      ].each do |values, number, expected|
+
+        describe "#{values.inspect} with #{number}" do
+
+          before do
+            @original = Hamster.list(*values)
+            @result = @original.send(method, number)
+          end
+
+          it "returns #{expected.inspect}" do
+            @result.should == expected
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/list/break_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+require "hamster/tuple"
+require "hamster/list"
+
+describe Hamster::List do
+
+  describe "#break" do
+
+    it "is lazy" do
+      -> { Hamster.stream { fail }.break { |item| false } }.should_not raise_error
+    end
+
+    [
+      [[], [], []],
+      [[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 "on #{values.inspect}" do
+
+        before do
+          @original = Hamster.list(*values)
+        end
+
+        describe "with a block" do
+
+          before do
+            @result = @original.break { |item| item > 2 }
+            @prefix = @result.first
+            @remainder = @result.last
+          end
+
+          it "preserves the original" do
+            @original.should == Hamster.list(*values)
+          end
+
+          it "returns a tuple with two items" do
+            @result.is_a?(Hamster::Tuple).should == true
+          end
+
+          it "correctly identifies the prefix" do
+            @prefix.should == Hamster.list(*expected_prefix)
+          end
+
+          it "correctly identifies the remainder" do
+            @remainder.should == Hamster.list(*expected_remainder)
+          end
+
+        end
+
+        describe "without a block" do
+
+          before do
+            @result = @original.break
+            @prefix = @result.first
+            @remainder = @result.last
+          end
+
+          it "returns a tuple with two items" do
+            @result.is_a?(Hamster::Tuple).should == true
+          end
+
+          it "returns self as the prefix" do
+            @prefix.should equal(@original)
+          end
+
+          it "leaves the remainder empty" do
+            @remainder.should be_empty
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,7 +1,9 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
+
   [
     [[], :car, nil],
     [["A"], :car, "A"],
@@ -17,23 +19,32 @@ describe Hamster::List do
     [%w[A B C], :cdddr, Hamster.list],
     [%w[A B C], :cddddr, Hamster.list],
   ].each do |values, method, expected|
+
     describe "##{method}" do
+
       it "is responded to" do
         Hamster.list.respond_to?(method).should == true
       end
 
-      context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+      describe "on #{values.inspect}" do
+
+        before do
+          @original = Hamster.list(*values)
+          @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.inspect}" do
-          list.send(method).should == expected
+          @result.should == expected
         end
+
       end
+
     end
+
   end
-end
+
+end

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

@@ -1,8 +1,11 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
+
   describe "#chunk" do
+
     it "is lazy" do
       -> { Hamster.stream { fail }.chunk(2) }.should_not raise_error
     end
@@ -12,18 +15,26 @@ describe Hamster::List do
       [["A"], [Hamster.list("A")]],
       [%w[A B C], [Hamster.list("A", "B"), Hamster.list("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)
+          @result = @original.chunk(2)
+        end
 
         it "preserves the original" do
-          list.chunk(2)
-          list.should eql(Hamster.list(*values))
+          @original.should == Hamster.list(*values)
         end
 
         it "returns #{expected.inspect}" do
-          list.chunk(2).should eql(Hamster.list(*expected))
+          @result.should == Hamster.list(*expected)
         end
+
       end
+
     end
+
   end
-end
+
+end

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

@@ -1,25 +1,36 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
+
   describe "#clear" do
+
     [
       [],
       ["A"],
       %w[A B C],
     ].each do |values|
+
       describe "on #{values}" do
-        let(:list) { Hamster.list(*values) }
+
+        before do
+          @original = Hamster.list(*values)
+          @result = @original.clear
+        end
 
         it "preserves the original" do
-          list.clear
-          list.should eql(Hamster.list(*values))
+          @original.should == Hamster.list(*values)
         end
 
         it "returns an empty list" do
-          list.clear.should equal(Hamster.list)
+          @result.should equal(Hamster.list)
         end
+
       end
+
     end
+
   end
-end
+
+end

data/spec/hamster/list/combinations_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+require "hamster/list"
+
+describe Hamster::List do
+
+  [:combinations, :combination].each do |method|
+
+    describe "##{method}" do
+
+      it "is lazy" do
+        -> { Hamster.stream { fail }.combinations(2) }.should_not raise_error
+      end
+
+      [
+        [%w[A B C D], 1, [["A"], ["B"], ["C"], ["D"]]],
+        [%w[A B C D], 2, [%w[A B], %w[A C], %w[A D], %w[B C], %w[B D], %w[C D]]],
+        [%w[A B C D], 3, [%w[A B C], %w[A B D], %w[A C D], %w[B C D]]],
+        [%w[A B C D], 4, [%w[A B C D]]],
+        [%w[A B C D], 0, [[]]],
+        [%w[A B C D], 5, []],
+        [[], 0, [[]]],
+        [[], 1, []],
+      ].each do |values, number, expected|
+
+        expected = expected.map { |x| Hamster.list(*x) }
+
+        describe "on #{values.inspect} in groups of #{number}" do
+
+          before do
+            @original = Hamster.list(*values)
+            @result = @original.send(method, number)
+          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
+
+end