immutable-ruby 0.0.1

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

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

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

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

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

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

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

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

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

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

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

data/spec/lib/immutable/hash/all_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  let(:hash) { H[values] }
+
+  describe "#all?" do
+    context "when empty" do
+      let(:values) { H.new }
+
+      context "without a block" do
+        it "returns true" do
+          hash.all?.should == true
+        end
+      end
+
+      context "with a block" do
+        it "returns true" do
+          hash.all? { false }.should == true
+        end
+      end
+    end
+
+    context "when not empty" do
+      let(:values) { { "A" => 1, "B" => 2, "C" => 3 } }
+
+      context "without a block" do
+        it "returns true" do
+          hash.all?.should == true
+        end
+      end
+
+      context "with a block" do
+        it "returns true if the block always returns true" do
+          hash.all? { true }.should == true
+        end
+
+        it "returns false if the block ever returns false" do
+          hash.all? { |k,v| k != 'C' }.should == false
+        end
+
+        it "propagates an exception from the block" do
+          -> { hash.all? { |k,v| raise "help" } }.should raise_error(RuntimeError)
+        end
+
+        it "stops iterating as soon as the block returns false" do
+          yielded = []
+          hash.all? { |k,v| yielded << k; false }
+          yielded.size.should == 1
+        end
+      end
+    end
+  end
+end

data/spec/lib/immutable/hash/any_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#any?" do
+    context "when empty" do
+      it "with a block returns false" do
+        H.empty.any? {}.should == false
+      end
+
+      it "with no block returns false" do
+        H.empty.any?.should == false
+      end
+    end
+
+    context "when not empty" do
+      let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"] }
+
+      context "with a block" do
+        [
+          %w[A aye],
+          %w[B bee],
+          %w[C see],
+          [nil, "NIL"],
+        ].each do |pair|
+
+          it "returns true if the block ever returns true (#{pair.inspect})" do
+            hash.any? { |key, value| key == pair.first && value == pair.last }.should == true
+          end
+
+          it "returns false if the block always returns false" do
+            hash.any? { |key, value| key == "D" && value == "dee" }.should == false
+          end
+        end
+
+        it "propagates exceptions raised in the block" do
+          -> { hash.any? { |k,v| raise "help" } }.should raise_error(RuntimeError)
+        end
+
+        it "stops iterating as soon as the block returns true" do
+          yielded = []
+          hash.any? { |k,v| yielded << k; true }
+          yielded.size.should == 1
+        end
+      end
+
+      context "with no block" do
+        it "returns true" do
+          hash.any?.should == true
+        end
+      end
+    end
+  end
+end

data/spec/lib/immutable/hash/assoc_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  let(:hash) { H[a: 3, b: 2, c: 1] }
+
+  describe "#assoc" do
+    it "searches for a key/val pair with a given key" do
+      hash.assoc(:a).should == [:a, 3]
+      hash.assoc(:b).should == [:b, 2]
+      hash.assoc(:c).should == [:c, 1]
+    end
+
+    it "returns nil if a matching key is not found" do
+      hash.assoc(:d).should be_nil
+      hash.assoc(nil).should be_nil
+      hash.assoc(0).should be_nil
+    end
+
+    it "returns nil even if there is a default" do
+      H.new(a: 1, b: 2) { fail }.assoc(:c).should be_nil
+    end
+
+    it "uses #== to compare keys with provided object" do
+      hash.assoc(EqualNotEql.new).should_not be_nil
+      hash.assoc(EqlNotEqual.new).should be_nil
+    end
+  end
+
+  describe "#rassoc" do
+    it "searches for a key/val pair with a given value" do
+      hash.rassoc(1).should == [:c, 1]
+      hash.rassoc(2).should == [:b, 2]
+      hash.rassoc(3).should == [:a, 3]
+    end
+
+    it "returns nil if a matching value is not found" do
+      hash.rassoc(0).should be_nil
+      hash.rassoc(4).should be_nil
+      hash.rassoc(nil).should be_nil
+    end
+
+    it "returns nil even if there is a default" do
+      H.new(a: 1, b: 2) { fail }.rassoc(3).should be_nil
+    end
+
+    it "uses #== to compare values with provided object" do
+      hash.rassoc(EqualNotEql.new).should_not be_nil
+      hash.rassoc(EqlNotEqual.new).should be_nil
+    end
+  end
+end

data/spec/lib/immutable/hash/clear_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#clear" do
+    [
+      [],
+      ["A" => "aye"],
+      ["A" => "aye", "B" => "bee", "C" => "see"],
+    ].each do |values|
+      context "on #{values}" do
+        let(:original) { H[*values] }
+        let(:result)   { original.clear }
+
+        it "preserves the original" do
+          result
+          original.should eql(H[*values])
+        end
+
+        it "returns an empty hash" do
+          result.should equal(H.empty)
+          result.should be_empty
+        end
+      end
+    end
+
+    it "maintains the default Proc, if there is one" do
+      hash = H.new(a: 1) { 1 }
+      hash.clear[:b].should == 1
+      hash.clear[:c].should == 1
+      hash.clear.default_proc.should_not be_nil
+    end
+
+    context "on a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Immutable::Hash)
+        instance = subclass.new(a: 1, b: 2)
+        instance.clear.class.should be(subclass)
+        instance.clear.should be_empty
+      end
+    end
+  end
+end