immutable-ruby 0.0.1

data/lib/immutable/version.rb

@@ -0,0 +1,5 @@
+module Immutable
+  # Current released gem version. Note that master will often have the same
+  # value as a release gem but with different code.
+  VERSION = "0.0.1"
+end

data/spec/fixtures/io_spec.txt

@@ -0,0 +1,3 @@
+A
+B
+C

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

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

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+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(L["A", "B", "C"])
+    end
+
+    it "works on Ranges" do
+      expect((1..3).to_list).to eq(L[1, 2, 3])
+    end
+  end
+end

data/spec/lib/immutable/core_ext/io_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe IO do
+  describe "#to_list" do
+    let(:list) { L["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/immutable/deque/clear_spec.rb

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

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

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

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

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

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

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Immutable::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) { D[*values] }
+
+          it "preserves the original" do
+            deque.send(method)
+            deque.should eql(D[*values])
+          end
+
+          it "returns #{expected.inspect}" do
+            deque.send(method).should eql(D[*expected])
+          end
+        end
+      end
+    end
+
+    context "on empty subclass" do
+      let(:subclass) { Class.new(Immutable::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/immutable/deque/empty_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Immutable::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
+          D[*values].empty?.should == expected
+        end
+      end
+    end
+
+    context "after dedequeing an item from #{%w[A B C].inspect}" do
+      it "returns false" do
+        D["A", "B", "C"].dequeue.should_not be_empty
+      end
+    end
+  end
+
+  describe ".empty" do
+    it "returns the canonical empty deque" do
+      D.empty.size.should be(0)
+      D.empty.class.should be(Immutable::Deque)
+      D.empty.object_id.should be(Immutable::EmptyDeque.object_id)
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Immutable::Deque)
+        subclass.empty.class.should be(subclass)
+        subclass.empty.should be_empty
+      end
+    end
+  end
+end

data/spec/lib/immutable/deque/enqueue_spec.rb

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

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

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Immutable::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
+          D[*values].first.should == expected
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Immutable::Deque do
+  describe "#inspect" do
+    [
+      [[], 'Immutable::Deque[]'],
+      [["A"], 'Immutable::Deque["A"]'],
+      [%w[A B C], 'Immutable::Deque["A", "B", "C"]']
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:deque) { D[*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/immutable/deque/last_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Immutable::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
+          D[*values].last.should eql(expected)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Immutable::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 immutable -e 'deque = Immutable::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(D[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(D[5, 10, 15, 20])
+      expect(reloaded_deque.pop).to eql(D[5, 10])
+      expect(reloaded_deque.unshift(1)).to eql(D[1, 5, 10, 15])
+      expect(reloaded_deque.shift).to eql(D[10, 15])
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Immutable::Deque do
+  describe ".new" do
+    it "accepts a single enumerable argument and creates a new deque" do
+      deque = Immutable::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 < Immutable::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(Immutable::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 = Immutable::Deque['a', 'b']
+      deque.size.should be(2)
+      deque.first.should == 'a'
+      deque.dequeue.first.should == 'b'
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Immutable::Deque do
+  describe "#pop" do
+    [
+      [[], []],
+      [["A"], []],
+      [%w[A B C], %w[A B]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:deque) { D[*values] }
+
+        it "preserves the original" do
+          deque.pop
+          deque.should eql(D[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          deque.pop.should eql(D[*expected])
+        end
+
+        it "returns a frozen instance" do
+          deque.pop.should be_frozen
+        end
+      end
+    end
+
+    context "on empty subclass" do
+      let(:subclass) { Class.new(Immutable::Deque) }
+      let(:empty_instance) { subclass.new }
+      it "returns an empty object of the same class" do
+        empty_instance.pop.class.should be subclass
+      end
+    end
+  end
+end