hamster 1.0.0 → 1.0.1.pre.rc.1

data/spec/hamster/list/to_a_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+require "hamster/list"
+
+describe Hamster::List do
+
+  [:to_a, :entries].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.to_a }.should_not raise_error
+        end
+
+      end
+
+      [
+        [],
+        ["A"],
+        %w[A B C],
+      ].each do |values|
+
+        describe "on #{values.inspect}" do
+
+          before do
+            @list = Hamster.list(*values)
+            @result = @list.send(method)
+          end
+
+          it "returns #{values.inspect}" do
+            @result.should == values
+          end
+
+          it "returns a mutable array" do
+            expect(@result.last).to_not eq("The End")
+            @result << "The End"
+            @result.last.should == "The End"
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,4 +1,5 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
@@ -6,8 +7,10 @@ describe Hamster::List do
 
   describe "#to_ary" do
     context "on a really big list" do
+      let(:list) { Hamster.interval(0, STACK_OVERFLOW_DEPTH) }
+
       it "doesn't run out of stack" do
-        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).to_ary }.should_not raise_error
+        -> { list.to_ary }.should_not raise_error
       end
     end
 

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

@@ -1,20 +1,32 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
+
   describe "#to_list" do
+
     [
       [],
       ["A"],
       %w[A B C],
     ].each do |values|
-      context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+
+      describe "on #{values.inspect}" do
+
+        before do
+          @original = Hamster.list(*values)
+          @result = @original.to_list
+        end
 
         it "returns self" do
-          list.to_list.should equal(list)
+          @result.should equal(@original)
         end
+
       end
+
     end
+
   end
-end
+
+end

data/spec/hamster/list/to_set_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+require "hamster/list"
+require "hamster/set"
+
+describe Hamster::List do
+
+  describe "#to_set" do
+
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+
+      describe "on #{values.inspect}" do
+
+        before do
+          original = Hamster.list(*values)
+          @result = original.to_set
+        end
+
+        it "returns self" do
+          @result.should == Hamster.set(*values)
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,9 +1,13 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
+
   [:union, :|].each do |method|
+
     describe "##{method}" do
+
       it "is lazy" do
         -> { Hamster.stream { fail }.union(Hamster.stream { fail }) }.should_not raise_error
       end
@@ -14,19 +18,32 @@ describe Hamster::List do
         [%w[A B C], [], %w[A B C]],
         [%w[A A], ["A"], ["A"]],
       ].each do |a, b, expected|
-        context "returns #{expected.inspect}" do
-          let(:list_a) { Hamster.list(*a) }
-          let(:list_b) { Hamster.list(*b) }
+
+        describe "returns #{expected.inspect}" do
+
+          before do
+            @a = Hamster.list(*a)
+            @b = Hamster.list(*b)
+          end
 
           it "for #{a.inspect} and #{b.inspect}"  do
-            list_a.send(method, list_b).should eql(Hamster.list(*expected))
+            @result = @a.send(method, @b)
           end
 
           it "for #{b.inspect} and #{a.inspect}"  do
-            list_b.send(method, list_a).should eql(Hamster.list(*expected))
+            @result = @b.send(method, @a)
           end
+
+          after  do
+            @result.should == Hamster.list(*expected)
+          end
+
         end
+
       end
+
     end
+
   end
-end
+
+end

data/spec/hamster/list/uniq_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+require "hamster/list"
+
+describe Hamster::List do
+
+  [:uniq, :nub, :remove_duplicates].each do |method|
+
+    describe "##{method}" do
+
+      it "is lazy" do
+        -> { Hamster.stream { fail }.uniq }.should_not raise_error
+      end
+
+      [
+        [[], []],
+        [["A"], ["A"]],
+        [%w[A B C], %w[A B C]],
+        [%w[A B A C C], %w[A B C]],
+      ].each do |values, expected|
+
+        describe "on #{values.inspect}" do
+
+          before do
+            @original = Hamster.list(*values)
+            @result = @original.send(method)
+          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

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

@@ -14,9 +14,16 @@ describe Hamster::List do
       [[], ["A"], [Hamster.list(nil, "A")]],
       [%w[A B C], %w[aye bee see], [Hamster.list("A", "aye"), Hamster.list("B", "bee"), Hamster.list("C", "see")]],
     ].each do |left, right, expected|
-      context "on #{left.inspect} and #{right.inspect}" do
+
+      describe "on #{left.inspect} and #{right.inspect}" do
+        before do
+          @left = Hamster.list(*left)
+          @right = Hamster.list(*right)
+          @result = @left.zip(@right)
+        end
+
         it "returns #{expected.inspect}" do
-          Hamster.list(*left).zip(Hamster.list(*right)).should eql(Hamster.list(*expected))
+          @result.should == Hamster.list(*expected)
         end
       end
     end

data/spec/hamster/queue/clear_spec.rb

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

data/spec/hamster/queue/construction_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+require "hamster/queue"
+
+describe Hamster do
+
+  describe ".queue" do
+
+    describe "with no arguments" do
+
+      before do
+        @queue = Hamster.queue
+      end
+
+      it "always returns the same instance" do
+        @queue.should equal(Hamster.queue)
+      end
+
+      it "returns an empty queue" do
+        @queue.should be_empty
+      end
+
+    end
+
+    describe "with a number of items" do
+
+      before do
+        @queue = Hamster.queue("A", "B", "C")
+      end
+
+      it "always returns a different instance" do
+        @queue.should_not equal(Hamster.queue("A", "B", "C"))
+      end
+
+      it "is the same as repeatedly using #enqueue" do
+        @queue.should == Hamster.queue.enqueue("A").enqueue("B").enqueue("C")
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/queue/dequeue_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+require "hamster/queue"
+
+describe Hamster::Queue do
+
+  [:dequeue, :tail].each do |method|
+
+    describe "##{method}" do
+
+      [
+        [[], []],
+        [["A"], []],
+        [%w[A B C], %w[B C]],
+      ].each do |values, expected|
+
+        describe "on #{values.inspect}" do
+
+          before do
+            @original = Hamster.queue(*values)
+            @result = @original.send(method)
+          end
+
+          it "preserves the original" do
+            @original.should == Hamster.queue(*values)
+          end
+
+          it "returns #{expected.inspect}" do
+            @result.should == Hamster.queue(*expected)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/queue/empty_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+require "hamster/queue"
+
+describe Hamster::Queue do
+
+  [:empty?, :null?].each do |method|
+
+    describe "##{method}" do
+
+      [
+        [[], true],
+        [["A"], false],
+        [%w[A B C], false],
+      ].each do |values, expected|
+
+        describe "on #{values.inspect}" do
+
+          before do
+            @result = Hamster.queue(*values).send(method)
+          end
+
+          it "returns #{expected.inspect}" do
+            @result.should == expected
+          end
+
+        end
+
+      end
+
+    end
+
+    describe "after dequeueing an item from #{%w[A B C].inspect}" do
+
+      before do
+        @result = Hamster.queue("A", "B", "C").dequeue
+      end
+
+      it "returns false" do
+        @result.should_not be_empty
+      end
+
+    end
+
+  end
+
+end

data/spec/{lib/hamster/deque → hamster/queue}/enqueue_spec.rb

@@ -1,28 +1,41 @@
 require "spec_helper"
-require "hamster/deque"
 
-describe Hamster::Deque do
-  [:enqueue, :push].each do |method|
+require "hamster/queue"
+
+describe Hamster::Queue do
+
+  [:enqueue, :<<, :add].each do |method|
+
     describe "##{method}" do
+
       [
         [[], "A", ["A"]],
         [["A"], "B", %w[A B]],
         [["A"], "A", %w[A A]],
         [%w[A B C], "D", %w[A B C D]],
       ].each do |values, new_value, expected|
+
         describe "on #{values.inspect} with #{new_value.inspect}" do
-          let(:deque) { Hamster.deque(*values) }
+
+          before do
+            @original = Hamster.queue(*values)
+            @result = @original.send(method, new_value)
+          end
 
           it "preserves the original" do
-            deque.send(method, new_value)
-            deque.should eql(Hamster.deque(*values))
+            @original.should == Hamster.queue(*values)
           end
 
           it "returns #{expected.inspect}" do
-            deque.send(method, new_value).should eql(Hamster.deque(*expected))
+            @result.should == Hamster.queue(*expected)
           end
+
         end
+
       end
+
     end
+
   end
-end
+
+end