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

data/lib/hamster/version.rb

@@ -1,3 +1,3 @@
 module Hamster
-  VERSION = "1.0.1-rc2"
+  VERSION = "1.0.1-rc3"
 end

data/spec/{hamster → lib/hamster}/core_ext/array_spec.rb

@@ -7,7 +7,7 @@ describe Array do
   describe "#to_list" do
     let(:to_list) { array.to_list }
 
-    it "should be an equivalent hamster list" do
+    it "returns an equivalent hamster list" do
       expect(to_list).to eq(Hamster.list("A", "B", "C"))
     end
   end

data/spec/{hamster → lib/hamster}/core_ext/enumerable_spec.rb

@@ -22,5 +22,9 @@ describe Enumerable do
     it "returns an equivalent list" do
       expect(to_list).to eq(Hamster.list("A", "B", "C"))
     end
+
+    it "works on Ranges" do
+      expect((1..3).to_list).to eq(Hamster.list(1, 2, 3))
+    end
   end
 end

data/spec/lib/hamster/deque/clear_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "#clear" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      context "on #{values}" do
+        let(:deque) { Hamster.deque(*values) }
+
+        it "preserves the original" do
+          deque.clear
+          deque.should eql(Hamster.deque(*values))
+        end
+
+        it "returns an empty deque" do
+          deque.clear.should equal(Hamster.deque)
+        end
+      end
+    end
+  end
+
+  context "from a subclass" do
+    it "returns an instance of the subclass" do
+      subclass = Class.new(Hamster::Deque)
+      instance = subclass.new([1,2])
+      instance.clear.should be_empty
+      instance.clear.class.should be(subclass)
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe ".deque" do
+    context "with no arguments" do
+      it "always returns the same instance" do
+        Hamster.deque.class.should be(Hamster::Deque)
+        Hamster.deque.should equal(Hamster.deque)
+      end
+
+      it "returns an empty, frozen deque" do
+        Hamster.deque.should be_empty
+        Hamster.deque.should be_frozen
+      end
+    end
+
+    context "with a number of items" do
+      let(:deque) { Hamster.deque("A", "B", "C") }
+
+      it "always returns a different instance" do
+        deque.should_not equal(Hamster.deque("A", "B", "C"))
+      end
+
+      it "is the same as repeatedly using #endeque" do
+        deque.should eql(Hamster.deque.enqueue("A").enqueue("B").enqueue("C"))
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/copying_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  [:dup, :clone].each do |method|
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      context "on #{values.inspect}" do
+        let(:deque) { Hamster.deque(*values) }
+
+        it "returns self" do
+          deque.send(method).should equal(deque)
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/dequeue_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  [:dequeue, :tail, :shift].each do |method|
+    describe "##{method}" do
+      [
+        [[], []],
+        [["A"], []],
+        [%w[A B C], %w[B C]],
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          let(:deque) { Hamster.deque(*values) }
+
+          it "preserves the original" do
+            deque.send(method)
+            deque.should eql(Hamster.deque(*values))
+          end
+
+          it "returns #{expected.inspect}" do
+            deque.send(method).should eql(Hamster.deque(*expected))
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/empty_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  [:empty?, :null?].each do |method|
+    describe "##{method}" do
+      [
+        [[], true],
+        [["A"], false],
+        [%w[A B C], false],
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            Hamster.deque(*values).send(method).should == expected
+          end
+        end
+      end
+    end
+
+    context "after dedequeing an item from #{%w[A B C].inspect}" do
+      it "returns false" do
+        Hamster.deque("A", "B", "C").dequeue.should_not be_empty
+      end
+    end
+  end
+
+  describe ".empty" do
+    it "returns the canonical empty vector" do
+      Hamster::Deque.empty.size.should be(0)
+      Hamster::Deque.empty.class.should be(Hamster::Deque)
+      Hamster::Deque.empty.object_id.should be(Hamster::EmptyDeque.object_id)
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Hamster::Deque)
+        subclass.empty.class.should be(subclass)
+        subclass.empty.should be_empty
+      end
+    end
+  end
+end

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

@@ -1,8 +1,8 @@
 require "spec_helper"
-require "hamster/queue"
+require "hamster/deque"
 
-describe Hamster::Queue do
-  [:enqueue, :<<, :add].each do |method|
+describe Hamster::Deque do
+  [:enqueue, :<<, :add, :conj, :conjoin, :push].each do |method|
     describe "##{method}" do
       [
         [[], "A", ["A"]],
@@ -10,19 +10,16 @@ describe Hamster::Queue do
         [["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
-          before do
-            @original = Hamster.queue(*values)
-            @result = @original.send(method, new_value)
-          end
+          let(:deque) { Hamster.deque(*values) }
 
           it "preserves the original" do
-            @original.should == Hamster.queue(*values)
+            deque.send(method, new_value)
+            deque.should eql(Hamster.deque(*values))
           end
 
           it "returns #{expected.inspect}" do
-            @result.should == Hamster.queue(*expected)
+            deque.send(method, new_value).should eql(Hamster.deque(*expected))
           end
         end
       end

data/spec/lib/hamster/deque/head_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  [:head, :first, :front].each do |method|
+    describe "##{method}" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[A B C], "A"],
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            Hamster.deque(*values).send(method).should == expected
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/inspect_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "#inspect" do
+    [
+      [[], 'Hamster::Deque[]'],
+      [["A"], 'Hamster::Deque["A"]'],
+      [%w[A B C], 'Hamster::Deque["A", "B", "C"]']
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:deque) { Hamster.deque(*values) }
+
+        it "returns #{expected.inspect}" do
+          deque.inspect.should == expected
+        end
+
+        it "returns a string which can be eval'd to get an equivalent object" do
+          eval(deque.inspect).should eql(deque)
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/last_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  [:last, :peek].each do |method|
+    describe "##{method}" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[A B C], "C"],
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            Hamster.deque(*values).send(method).should eql(expected)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/marshal_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "#marshal_dump/#marshal_load" do
+    let(:ruby) do
+      File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
+    end
+    let(:child_cmd) do
+      %Q|#{ruby} -I lib -r hamster -e 'deque = Hamster.deque(5, 10, 15); $stdout.write(Marshal.dump(deque))'|
+    end
+
+    let(:reloaded_deque) do
+      IO.popen(child_cmd, "r+") do |child|
+        reloaded_deque = Marshal.load(child)
+        child.close
+        reloaded_deque
+      end
+    end
+
+    it "can survive dumping and loading into a new process" do
+      expect(reloaded_deque).to eql(Hamster.deque(5, 10, 15))
+    end
+
+    it "is still possible to push and pop items after loading" do
+      expect(reloaded_deque.first).to eq(5)
+      expect(reloaded_deque.last).to eq(15)
+      expect(reloaded_deque.push(20)).to eql(Hamster.deque(5, 10, 15, 20))
+      expect(reloaded_deque.pop).to eql(Hamster.deque(5, 10))
+      expect(reloaded_deque.unshift(1)).to eql(Hamster.deque(1, 5, 10, 15))
+      expect(reloaded_deque.shift).to eql(Hamster.deque(10, 15))
+    end
+  end
+end

data/spec/lib/hamster/deque/new_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe ".new" do
+    it "accepts a single enumerable argument and creates a new deque" do
+      deque = Hamster::Deque.new([1,2,3])
+      deque.size.should be(3)
+      deque.head.should be(1)
+      deque.dequeue.head.should be(2)
+      deque.dequeue.dequeue.head.should be(3)
+    end
+
+    it "is amenable to overriding of #initialize" do
+      class SnazzyDeque < Hamster::Deque
+        def initialize
+          super(['SNAZZY!!!'])
+        end
+      end
+
+      deque = SnazzyDeque.new
+      deque.size.should be(1)
+      deque.to_a.should == ['SNAZZY!!!']
+    end
+
+    context "from a subclass" do
+      it "returns a frozen instance of the subclass" do
+        subclass = Class.new(Hamster::Deque)
+        instance = subclass.new(["some", "values"])
+        instance.class.should be subclass
+        instance.frozen?.should be true
+      end
+    end
+  end
+
+  describe ".[]" do
+    it "accepts a variable number of items and creates a new deque" do
+      deque = Hamster::Deque['a', 'b']
+      deque.size.should be(2)
+      deque.head.should == 'a'
+      deque.dequeue.head.should == 'b'
+    end
+  end
+end

data/spec/lib/hamster/deque/pop_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "#pop" do
+    [
+      [[], []],
+      [["A"], []],
+      [%w[A B C], %w[A B]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:deque) { Hamster.deque(*values) }
+
+        it "preserves the original" do
+          deque.pop
+          deque.should eql(Hamster.deque(*values))
+        end
+
+        it "returns #{expected.inspect}" do
+          deque.pop.should eql(Hamster.deque(*expected))
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/random_modification_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "modification (using #push, #pop, #shift, and #unshift)" do
+    it "works when applied in many random combinations" do
+      array = [1,2,3]
+      deque = Hamster::Deque.new(array)
+      1000.times do
+        case [:push, :pop, :shift, :unshift].sample
+        when :push
+          value = rand(10000)
+          array.push(value)
+          deque = deque.push(value)
+        when :pop
+          array.pop
+          deque = deque.pop
+        when :shift
+          array.shift
+          deque = deque.shift
+        when :unshift
+          value = rand(10000)
+          array.unshift(value)
+          deque = deque.unshift(value)
+        end
+
+        deque.to_a.should eql(array)
+        deque.size.should == array.size
+        deque.first.should == array.first
+        deque.last.should == array.last
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 require "spec_helper"
-require "hamster/queue"
+require "hamster/deque"
 
-describe Hamster::Queue do
+describe Hamster::Deque do
   [:size, :length].each do |method|
     describe "##{method}" do
       [
@@ -9,14 +9,9 @@ describe Hamster::Queue do
         [["A"], 1],
         [%w[A B C], 3],
       ].each do |values, expected|
-
-        describe "on #{values.inspect}" do
-          before do
-            @queue = Hamster.queue(*values)
-          end
-
+        context "on #{values.inspect}" do
           it "returns #{expected.inspect}" do
-            @queue.send(method).should == expected
+            Hamster.deque(*values).send(method).should == expected
           end
         end
       end