immutable-ruby 0.0.1 → 0.1.0

data/spec/fixtures/io_spec.txt

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

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

@@ -1,13 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

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

@@ -1,23 +0,0 @@
-require "spec_helper"
-require "pp"
-require "stringio"
-
-describe Immutable::Deque do
-  describe "#pretty_print" do
-    let(:deque) { Immutable::Deque["AAAA", "BBBB", "CCCC"] }
-    let(:stringio) { StringIO.new }
-
-    it "prints the whole Deque on one line if it fits" do
-      PP.pp(deque, stringio, 80)
-      stringio.string.chomp.should == 'Immutable::Deque["AAAA", "BBBB", "CCCC"]'
-    end
-
-    it "prints each item on its own line, if not" do
-      PP.pp(deque, stringio, 10)
-      stringio.string.chomp.should == 'Immutable::Deque[
- "AAAA",
- "BBBB",
- "CCCC"]'
-    end
-  end
-end

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

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

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

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-describe Immutable::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 = Immutable::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/lib/immutable/deque/shift_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Deque do
-  describe "#shift" do
-    [
-      [[], []],
-      [["A"], []],
-      [%w[A B C], %w[B C]],
-    ].each do |values, expected|
-      context "on #{values.inspect}" do
-        let(:deque) { D.new(values) }
-
-        it "preserves the original" do
-          deque.shift
-          deque.should eql(D.new(values))
-        end
-
-        it "returns #{expected.inspect}" do
-          deque.shift.should eql(D.new(expected))
-        end
-
-
-        it "returns a frozen instance" do
-          deque.shift.should be_frozen
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Deque do
-  [:size, :length].each do |method|
-    describe "##{method}" do
-      [
-        [[], 0],
-        [["A"], 1],
-        [%w[A B C], 3],
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            D[*values].send(method).should == expected
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Deque do
-  [:to_a, :entries].each do |method|
-    describe "##{method}" do
-      [
-        [],
-        ["A"],
-        %w[A B C],
-      ].each do |values|
-        context "on #{values.inspect}" do
-          it "returns #{values.inspect}" do
-            D[*values].send(method).should == values
-          end
-
-          it "returns a mutable array" do
-            result = D[*values].send(method)
-            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/immutable/deque/to_ary_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Deque do
-  let(:deque) { D["A", "B", "C", "D"] }
-
-  describe "#to_ary" do
-    context "enables implicit conversion to" do
-      it "block parameters" do
-        def func(&block)
-          yield(deque)
-        end
-
-        func do |a, b, *c|
-          expect(a).to eq("A")
-          expect(b).to eq("B")
-          expect(c).to eq(%w[C D])
-        end
-      end
-
-      it "method arguments" do
-        def func(a, b, *c)
-          expect(a).to eq("A")
-          expect(b).to eq("B")
-          expect(c).to eq(%w[C D])
-        end
-        func(*deque)
-      end
-
-      it "works with splat" do
-        array = *deque
-        expect(array).to eq(%w[A B C D])
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Deque do
-  describe "#to_list" do
-    [
-      [],
-      ["A"],
-      %w[A B C],
-    ].each do |values|
-      context "on #{values.inspect}" do
-        it "returns a list containing #{values.inspect}" do
-          D[*values].to_list.should eql(L[*values])
-        end
-      end
-    end
-
-    context "after dedequeing an item from #{%w[A B C].inspect}" do
-      it "returns a list containing #{%w[B C].inspect}" do
-        list = D["A", "B", "C"].dequeue.to_list
-        list.should eql(L["B", "C"])
-      end
-    end
-  end
-end