immutable-ruby 0.0.4 → 0.1.0

data/lib/immutable/core_ext/struct.rb

@@ -1,9 +0,0 @@
-class Struct
-  # Implement Struct#to_h for Ruby interpreters which don't have it
-  # (such as MRI 1.9.3 and lower)
-  unless method_defined?(:to_h)
-    def to_h
-      Hash[each_pair.to_a]
-    end
-  end
-end

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 empty 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/rotate_spec.rb

@@ -1,68 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Deque do
-
-  # Deques can have items distributed differently between the 'front' and 'rear' lists
-  #   and still be equivalent
-  # Since the implementation of #rotate depends on how items are distributed between the
-  #   two lists, we need to test both the case where most items are on the 'front' and
-  #   where most are on the 'rear'
-  big_front = D.alloc(L.from_enum([1, 2, 3]), L.from_enum([5, 4]))
-  big_rear  = D.alloc(L.from_enum([1, 2]), L.from_enum([5, 4, 3]))
-
-  describe "#rotate" do
-    [
-      [[], 9999, []],
-      [['A'], -1, ['A']],
-      [['A', 'B', 'C'], -1, ['B', 'C', 'A']],
-      [['A', 'B', 'C', 'D'], 0, ['A', 'B', 'C', 'D']],
-      [%w[A B C D], 2, %w[C D A B]],
-    ].each do |values, rotation, expected|
-      context "on #{values.inspect}" do
-        let(:deque) { D[*values] }
-
-        it "preserves the original" do
-          deque.rotate(rotation)
-          deque.should eql(D[*values])
-        end
-
-        it "returns #{expected.inspect}" do
-          deque.rotate(rotation).should eql(D[*expected])
-        end
-
-        it "returns a frozen instance" do
-          deque.rotate(rotation).should be_frozen
-        end
-      end
-    end
-
-    context "on a Deque with most items on 'front' list" do
-      it "works with a small rotation" do
-        big_front.rotate(2).should eql(D[4, 5, 1, 2, 3])
-      end
-
-      it "works with a larger rotation" do
-        big_front.rotate(4).should eql(D[2, 3, 4, 5, 1])
-      end
-    end
-
-    context "on a Deque with most items on 'rear' list" do
-      it "works with a small rotation" do
-        big_rear.rotate(2).should eql(D[4, 5, 1, 2, 3])
-      end
-
-      it "works with a larger rotation" do
-        big_rear.rotate(4).should eql(D[2, 3, 4, 5, 1])
-      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.rotate(1).class.should be subclass
-        empty_instance.rotate(-1).class.should be subclass
-      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