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

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

@@ -8,15 +8,11 @@ describe Hamster::List do
       ["A"],
       %w[A B C],
     ].each do |values|
-
-      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 "returns self" do
-          @result.should equal(@original)
+          list.send(method).should equal(list)
         end
       end
     end

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

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#count" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).count }.should_not raise_error
+      end
+    end
+
+    [
+      [[], 0],
+      [[1], 1],
+      [[1, 2], 1],
+      [[1, 2, 3], 2],
+      [[1, 2, 3, 4], 2],
+      [[1, 2, 3, 4, 5], 3],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        context "with a block" do
+          it "returns #{expected.inspect}" do
+            list.count(&:odd?).should == expected
+          end
+        end
+
+        context "without a block" do
+          it "returns length" do
+            list.count.should == list.length
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster do
+  describe "#cycle" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.cycle }.should_not raise_error
+    end
+
+    context "with an empty list" do
+      it "returns an empty list" do
+        Hamster.list.cycle.should be_empty
+      end
+    end
+
+    context "with a non-empty list" do
+      let(:list) { Hamster.list("A", "B", "C") }
+
+      it "preserves the original" do
+        list.cycle
+        list.should == Hamster.list("A", "B", "C")
+      end
+
+      it "infinitely cycles through all values" do
+        list.cycle.take(7).should == Hamster.list("A", "B", "C", "A", "B", "C", "A")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#delete_at" do
+    let(:list) { Hamster.list(1,2,3,4,5) }
+
+    it "removes the element at the specified index" do
+      list.delete_at(0).should eql(Hamster.list(2,3,4,5))
+      list.delete_at(2).should eql(Hamster.list(1,2,4,5))
+      list.delete_at(-1).should eql(Hamster.list(1,2,3,4))
+    end
+
+    it "makes no modification if the index is out of range" do
+      list.delete_at(5).should eql(list)
+      list.delete_at(-6).should eql(list)
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#delete" do
+    it "removes elements that are #== to the argument" do
+      L[1,2,3].delete(1).should eql(L[2,3])
+      L[1,2,3].delete(2).should eql(L[1,3])
+      L[1,2,3].delete(3).should eql(L[1,2])
+      L[1,2,3].delete(0).should eql(L[1,2,3])
+      L['a','b','a','c','a','a','d'].delete('a').should eql(L['b','c','d'])
+
+      L[EqualNotEql.new, EqualNotEql.new].delete(:something).should eql(L[])
+      L[EqlNotEqual.new, EqlNotEqual.new].delete(:something).should_not be_empty
+    end
+  end
+end

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

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

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

@@ -0,0 +1,39 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#drop_while" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.drop_while { false } }.should_not raise_error
+    end
+
+    [
+      [[], []],
+      [["A"], []],
+      [%w[A B C], ["C"]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        context "with a block" do
+          it "preserves the original" do
+            list.drop_while { |item| item < "C" }
+            list.should eql(Hamster.list(*values))
+          end
+
+          it "returns #{expected.inspect}" do
+            list.drop_while { |item| item < "C" }.should eql(Hamster.list(*expected))
+          end
+        end
+
+        context "without a block" do
+          it "returns an Enumerator" do
+            list.drop_while.class.should be(Enumerator)
+            list.drop_while.each { false }.should eql(list)
+            list.drop_while.each { true  }.should be_empty
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  [:each_chunk, :each_slice].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, 1) { |item| } }.should_not raise_error
+        end
+      end
+
+      [
+        [[], []],
+        [["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) }
+
+          context "with a block" do
+            it "preserves the original" do
+              list.should eql(Hamster.list(*values))
+            end
+
+            it "iterates over the items in order" do
+              yielded = []
+              list.send(method, 2) { |item| yielded << item }
+              yielded.should eql(expected)
+            end
+
+            it "returns self" do
+              list.send(method, 2) { |item| item }.should be(list)
+            end
+          end
+
+          context "without a block" do
+            it "preserves the original" do
+              list.send(method, 2)
+              list.should eql(Hamster.list(*values))
+            end
+
+            it "returns an Enumerator" do
+              list.send(method, 2).class.should be(Enumerator)
+              list.send(method, 2).to_a.should eql(expected)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  [:each, :foreach].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) { |item| } }.should_not raise_error
+        end
+      end
+
+      [
+        [],
+        ["A"],
+        %w[A B C],
+      ].each do |values|
+        context "on #{values.inspect}" do
+          let(:list) { Hamster.list(*values) }
+
+          context "with a block" do
+            it "iterates over the items in order" do
+              yielded = []
+              list.send(method) { |item| yielded << item }
+              yielded.should == values
+            end
+
+            it "returns nil" do
+              list.send(method) { |item| item }.should be_nil
+            end
+          end
+
+          context "without a block" do
+            it "returns an Enumerator" do
+              list.send(method).class.should be(Enumerator)
+              list.send(method).to_list.should eql(list)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#each_with_index" do
+    context "with no block" do
+      let(:list) { Hamster.list("A", "B", "C") }
+
+      it "returns an Enumerator" do
+        list.each_with_index.class.should be(Enumerator)
+        list.each_with_index.to_a.should == [['A', 0], ['B', 1], ['C', 2]]
+      end
+    end
+
+    context "with a block" do
+      let(:list) { Hamster.interval(1, 1025) }
+
+      it "returns self" do
+        list.each_with_index { |item, index| item }.should be(list)
+      end
+
+      it "iterates over the items in order, yielding item and index" do
+        yielded = []
+        list.each_with_index { |item, index| yielded << [item, index] }
+        yielded.should == (1..list.size).zip(0..list.size.pred)
+      end
+    end
+  end
+end

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

@@ -4,13 +4,9 @@ require "hamster/list"
 describe Hamster::List do
   [:elem_index, :index].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
         it "doesn't run out of stack" do
-          -> { @list.send(method, nil) }.should_not raise_error
+          -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).send(method, nil) }.should_not raise_error
         end
       end
 
@@ -29,15 +25,9 @@ describe Hamster::List do
         [[2.0], 2.0, 0],
         [[2.0], 2, 0],
       ].each do |values, item, expected|
-
-        describe "looking for #{item.inspect} in #{values.inspect}" do
-          before do
-            list = Hamster.list(*values)
-            @result = list.send(method, item)
-          end
-
+        context "looking for #{item.inspect} in #{values.inspect}" do
           it "returns #{expected.inspect}" do
-            @result.should == expected
+            Hamster.list(*values).send(method, item).should == expected
           end
         end
       end

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

@@ -5,7 +5,9 @@ describe Hamster::List do
   [:elem_indices, :indices].each do |method|
     describe "##{method}" do
       it "is lazy" do
-        -> { Hamster.stream { fail }.send(method, nil) }.should_not raise_error
+        count = 0
+        Hamster.stream { count += 1 }.send(method, nil)
+        count.should <= 1
       end
 
       [
@@ -18,15 +20,9 @@ describe Hamster::List do
         [[2.0], 2.0, [0]],
         [[2.0], 2, [0]],
       ].each do |values, item, expected|
-
-        describe "looking for #{item.inspect} in #{values.inspect}" do
-          before do
-            list = Hamster.list(*values)
-            @result = list.send(method, item)
-          end
-
+        context "looking for #{item.inspect} in #{values.inspect}" do
           it "returns #{expected.inspect}" do
-            @result.should == Hamster.list(*expected)
+            Hamster.list(*values).send(method, item).should eql(Hamster.list(*expected))
           end
         end
       end

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

@@ -4,13 +4,9 @@ require "hamster/list"
 describe Hamster::List do
   [:empty?, :null?].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
         it "doesn't run out of stack" do
-          -> { @list.filter(&:nil?).empty? }.should_not raise_error
+          -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).filter(&:nil?).empty? }.should_not raise_error
         end
       end
 
@@ -19,14 +15,9 @@ describe Hamster::List do
         [["A"], false],
         [%w[A B C], false],
       ].each do |values, expected|
-
-        describe "on #{values.inspect}" do
-          before do
-            @result = Hamster.list(*values).send(method)
-          end
-
+        context "on #{values.inspect}" do
           it "returns #{expected.inspect}" do
-            @result.should == expected
+            Hamster.list(*values).send(method).should == expected
           end
         end
       end

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

@@ -3,15 +3,9 @@ require "hamster/list"
 
 describe Hamster::List do
   describe "#eql?" do
-    describe "on a really big list" do
-
-      before do
-        @a = Hamster.interval(0, STACK_OVERFLOW_DEPTH)
-        @b = Hamster.interval(0, STACK_OVERFLOW_DEPTH)
-      end
-
+    context "on a really big list" do
       it "doesn't run out of stack" do
-        -> { @a.eql?(@b) }.should_not raise_error
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).eql?(Hamster.interval(0, STACK_OVERFLOW_DEPTH)) }.should_not raise_error
       end
     end
   end

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

@@ -0,0 +1,50 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#fill" do
+    let(:list) { Hamster.list(1, 2, 3, 4, 5, 6) }
+
+    it "can replace a range of items at the beginning of a list" do
+      list.fill(:a, 0, 3).should eql(Hamster.list(:a, :a, :a, 4, 5, 6))
+    end
+
+    it "can replace a range of items in the middle of a list" do
+      list.fill(:a, 3, 2).should eql(Hamster.list(1, 2, 3, :a, :a, 6))
+    end
+
+    it "can replace a range of items at the end of a list" do
+      list.fill(:a, 4, 2).should eql(Hamster.list(1, 2, 3, 4, :a, :a))
+    end
+
+    it "can replace all the items in a list" do
+      list.fill(:a, 0, 6).should eql(Hamster.list(:a, :a, :a, :a, :a, :a))
+    end
+
+    it "can fill past the end of the list" do
+      list.fill(:a, 3, 6).should eql(Hamster.list(1, 2, 3, :a, :a, :a, :a, :a, :a))
+    end
+
+    context "with 1 argument" do
+      it "replaces all the items in the list by default" do
+        list.fill(:a).should eql(Hamster.list(:a, :a, :a, :a, :a, :a))
+      end
+    end
+
+    context "with 2 arguments" do
+      it "replaces up to the end of the list by default" do
+        list.fill(:a, 4).should eql(Hamster.list(1, 2, 3, 4, :a, :a))
+      end
+    end
+
+    context "when index and length are 0" do
+      it "leaves the list unmodified" do
+        list.fill(:a, 0, 0).should eql(list)
+      end
+    end
+
+    it "is lazy" do
+      -> { Hamster.stream { fail }.fill(:a, 0, 1) }.should_not raise_error
+    end
+  end
+end