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

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

@@ -4,48 +4,40 @@ 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
+      context "on a really big list" do
+        let(:list) { Hamster.interval(0, STACK_OVERFLOW_DEPTH) }
 
         it "doesn't run out of stack" do
-          -> { @list.send(method) { false } }.should_not raise_error
+          -> { list.send(method) { 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.send(method) {}.should == false
+         Hamster.list.send(method) {}.should == false
         end
 
         it "with no block returns false" do
-          @list.send(method).should == false
+          Hamster.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
+      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 true if the block ever returns true (#{value.inspect})" do
-              @list.send(method) { |item| item == value }.should == true
+              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
+            list.send(method) { |item| item == "D" }.should == false
           end
         end
 
-        describe "with no block" do
+        context "with no block" do
           it "returns true if any value is truthy" do
             Hamster.list(nil, false, "A", true).send(method).should == true
           end

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

@@ -14,24 +14,23 @@ describe Hamster::List do
         [[], ["A"], ["A"]],
         [%w[A B], %w[C D], %w[A B C D]],
       ].each do |left_values, right_values, expected|
-
-        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
+        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) }
 
           it "preserves the left" do
-            @left.should == Hamster.list(*left_values)
+            result
+            left.should eql(Hamster.list(*left_values))
           end
 
           it "preserves the right" do
-            @right.should == Hamster.list(*right_values)
+            result
+            right.should eql(Hamster.list(*right_values))
           end
 
           it "returns #{expected.inspect}" do
-            @result.should == Hamster.list(*expected)
+            result.should eql(Hamster.list(*expected))
           end
         end
       end

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

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

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

@@ -0,0 +1,70 @@
+require "spec_helper"
+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|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        context "with a block" do
+          let(:result) { list.break { |item| item > 2 }}
+          let(:prefix) { result.first }
+          let(:remainder) { result.last }
+
+          it "preserves the original" do
+            result
+            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 prefix" do
+            prefix.should eql(Hamster.list(*expected_prefix))
+          end
+
+          it "correctly identifies the remainder" do
+            remainder.should eql(Hamster.list(*expected_remainder))
+          end
+        end
+
+        context "without a block" do
+          let(:result) { list.break }
+          let(:prefix) { result.first }
+          let(:remainder) { result.last }
+
+          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 "returns self as the prefix" do
+            prefix.should equal(list)
+          end
+
+          it "leaves the remainder empty" do
+            remainder.should be_empty
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,24 +17,21 @@ 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
 
-      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 == expected
+          list.send(method).should == expected
         end
       end
     end

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

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

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

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

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

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#combination" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.combination(2) }.should_not raise_error
+    end
+
+    [
+      [%w[A B C D], 1, [L["A"], L["B"], L["C"], L["D"]]],
+      [%w[A B C D], 2, [L["A","B"], L["A","C"], L["A","D"], L["B","C"], L["B","D"], L["C","D"]]],
+      [%w[A B C D], 3, [L["A","B","C"], L["A","B","D"], L["A","C","D"], L["B","C","D"]]],
+      [%w[A B C D], 4, [L["A", "B", "C", "D"]]],
+      [%w[A B C D], 0, [EmptyList]],
+      [%w[A B C D], 5, []],
+      [[], 0, [EmptyList]],
+      [[], 1, []],
+    ].each do |values, number, expected|
+      context "on #{values.inspect} in groups of #{number}" do
+        let(:list) { Hamster.list(*values) }
+
+        it "preserves the original" do
+          list.combination(number)
+          list.should eql(Hamster.list(*values))
+        end
+
+        it "returns #{expected.inspect}" do
+          list.combination(number).should eql(Hamster.list(*expected))
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,31 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#<=>" do
+    [
+      [[], [1]],
+      [[1], [2]],
+      [[1], [1, 2]],
+      [[2, 3, 4], [3, 4, 5]]
+    ].each do |items1, items2|
+      context "with #{items1} and #{items2}" do
+        it "returns -1" do
+          (Hamster.list(*items1) <=> Hamster.list(*items2)).should be(-1)
+        end
+      end
+
+      context "with #{items2} and #{items1}" do
+        it "returns 1" do
+          (Hamster.list(*items2) <=> Hamster.list(*items1)).should be(1)
+        end
+      end
+
+      context "with #{items1} and #{items1}" do
+        it "returns 0" do
+          (Hamster.list(*items1) <=> Hamster.list(*items1)).should be(0)
+        end
+      end
+    end
+  end
+end

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

@@ -4,26 +4,22 @@ require "hamster/list"
 describe Hamster::List do
   [:cons, :>>].each do |method|
     describe "##{method}" do
-
       [
         [[], "A", ["A"]],
         [["A"], "B", %w[B A]],
         [["A"], "A", %w[A A]],
         [%w[A B C], "D", %w[D A B C]],
       ].each do |values, new_value, expected|
-
-        describe "on #{values.inspect} with #{new_value.inspect}" do
-          before do
-            @original = Hamster.list(*values)
-            @result = @original.send(method, new_value)
-          end
+        context "on #{values.inspect} with #{new_value.inspect}" do
+          let(:list) { Hamster.list(*values) }
 
           it "preserves the original" do
-            @original.should == Hamster.list(*values)
+            list.send(method, new_value)
+            list.should eql(Hamster.list(*values))
           end
 
           it "returns #{expected.inspect}" do
-            @result.should == Hamster.list(*expected)
+            list.send(method, new_value).should eql(Hamster.list(*expected))
           end
         end
       end

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

@@ -0,0 +1,118 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster do
+  describe ".list" do
+    context "with no arguments" do
+      it "always returns the same instance" do
+        Hamster.list.should equal(Hamster.list)
+      end
+
+      it "returns an empty list" do
+        Hamster.list.should be_empty
+      end
+    end
+
+    context "with a number of items" do
+      it "always returns a different instance" do
+        Hamster.list("A", "B", "C").should_not equal(Hamster.list("A", "B", "C"))
+      end
+
+      it "is the same as repeatedly using #cons" do
+        Hamster.list("A", "B", "C").should eql(Hamster.list.cons("C").cons("B").cons("A"))
+      end
+    end
+  end
+
+  describe ".stream" do
+    context "with no block" do
+      it "returns an empty list" do
+        Hamster.stream.should eql(Hamster.list)
+      end
+    end
+
+    context "with a block" do
+      let(:list) { count = 0; Hamster.stream { count += 1 }}
+
+      it "repeatedly calls the block" do
+        list.take(5).should eql(Hamster.list(1, 2, 3, 4, 5))
+      end
+    end
+  end
+
+  [:interval, :range].each do |method|
+    describe ".#{method}" do
+      context "for numbers" do
+        it "is equivalent to a list with explicit values" do
+          Hamster.send(method, 98, 102).should eql(Hamster.list(98, 99, 100, 101, 102))
+        end
+      end
+
+      context "for strings" do
+        it "is equivalent to a list with explicit values" do
+          Hamster.send(method, "A", "AA").should eql(Hamster.list("A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA"))
+        end
+      end
+    end
+  end
+
+  describe ".repeat" do
+    it "returns an infinite list with specified value for each element" do
+      Hamster.repeat("A").take(5).should eql(Hamster.list("A", "A", "A", "A", "A"))
+    end
+  end
+
+  describe ".replicate" do
+    it "returns a list with the specified value repeated the specified number of times" do
+      Hamster.replicate(5, "A").should eql(Hamster.list("A", "A", "A", "A", "A"))
+    end
+  end
+
+  describe ".iterate" do
+    it "returns an infinite list where the first item is calculated by applying the block on the initial argument, the second item by applying the function on the previous result and so on" do
+      Hamster.iterate(1) { |item| item * 2 }.take(10).should eql(Hamster.list(1, 2, 4, 8, 16, 32, 64, 128, 256, 512))
+    end
+  end
+
+  describe ".enumerate" do
+    let(:counter) do
+      i = 0
+      -> { i += 1 }
+    end
+
+    let(:enum) do
+      Enumerator.new do |yielder|
+        yielder << 1
+        yielder << 2
+        yielder << 3
+        raise "list fully realized"
+      end
+    end
+
+    let(:list) { Hamster.enumerate(enum) }
+
+    it "returns a list based on the values yielded from the enumerator" do
+      expect(list.take(2)).to eq Hamster.list(1, 2)
+    end
+
+    it "realizes values as they are needed" do
+      # this example shows that Lists are not as lazy as they could be
+      # if Lists were fully lazy, you would have to take(4) to hit the exception
+      expect { list.take(3).to_a }.to raise_exception
+    end
+  end
+
+  describe "[]" do
+    it "takes a variable number of items and returns a list" do
+      list = Hamster::List[1,2,3]
+      list.should be_kind_of(Hamster::List)
+      list.size.should be(3)
+      list.to_a.should == [1,2,3]
+    end
+
+    it "returns an empty list when called without arguments" do
+      Hamster::List[].should be_kind_of(Hamster::List)
+      Hamster::List[].should be_empty
+    end
+  end
+end