hamster 0.4.3 → 1.0.0

data/lib/hamster/version.rb

@@ -1,5 +1,3 @@
 module Hamster
-
-  VERSION = "0.4.3".freeze
-
+  VERSION = "1.0.0"
 end

data/spec/lib/hamster/core_ext/array_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "hamster/core_ext/enumerable"
+
+describe Array do
+  let(:array) { %w[A B C] }
+
+  describe "#to_list" do
+    let(:to_list) { array.to_list }
+
+    it "returns an equivalent hamster list" do
+      expect(to_list).to eq(Hamster.list("A", "B", "C"))
+    end
+  end
+end

data/spec/lib/hamster/core_ext/enumerable_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+require "hamster/core_ext/enumerable"
+
+describe Enumerable do
+  class TestEnumerable
+    include Enumerable
+
+    def initialize(*values)
+      @values = values
+    end
+
+    def each(&block)
+      @values.each(&block)
+    end
+  end
+
+  let(:enumerable) { TestEnumerable.new("A", "B", "C") }
+
+  describe "#to_list" do
+    let(:to_list) { enumerable.to_list }
+
+    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/core_ext/io_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+require "hamster/core_ext/io"
+
+describe IO do
+  describe "#to_list" do
+    let(:list) { Hamster.list("A\n", "B\n", "C\n") }
+    let(:to_list) { io.to_list }
+
+    after(:each) do
+      io.close
+    end
+
+    context "with a File" do
+      let(:io) { File.new(fixture_path("io_spec.txt")) }
+
+      it "returns an equivalent list" do
+        expect(to_list).to eq(list)
+      end
+    end
+
+    context "with a StringIO" do
+      let(:io) { StringIO.new(fixture("io_spec.txt")) }
+
+      it "returns an equivalent list" do
+        expect(to_list).to eq(list)
+      end
+    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,35 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  [:dequeue, :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
+
+    context "on empty subclass" do
+      let(:subclass) { Class.new(Hamster::Deque) }
+      let(:empty_instance) { subclass.new }
+      it "returns emtpy object of same class" do
+        empty_instance.send(method).class.should be subclass
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "#empty?" 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).empty?.should == expected
+        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/lib/hamster/deque/enqueue_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  [:enqueue, :push].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) }
+
+          it "preserves the original" do
+            deque.send(method, new_value)
+            deque.should eql(Hamster.deque(*values))
+          end
+
+          it "returns #{expected.inspect}" do
+            deque.send(method, new_value).should eql(Hamster.deque(*expected))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "#first" 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).first.should == expected
+        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,18 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "#last" 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).last.should eql(expected)
+        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.first.should be(1)
+      deque.dequeue.first.should be(2)
+      deque.dequeue.dequeue.first.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.first.should == 'a'
+      deque.dequeue.first.should == 'b'
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+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
+
+    context "on empty subclass" do
+      let(:subclass) { Class.new(Hamster::Deque) }
+      let(:empty_instance) { subclass.new }
+      it "returns emtpy object of same class" do
+        empty_instance.pop.class.should be subclass
+      end
+    end
+  end
+end