immutable-ruby 0.0.1

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

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe ".hash" do
+    context "with nothing" do
+      it "returns the canonical empty hash" do
+        H.empty.should be_empty
+        H.empty.should equal(Immutable::EmptyHash)
+      end
+    end
+
+    context "with an implicit hash" do
+      let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
+
+      it "is equivalent to repeatedly using #put" do
+        hash.should eql(H.empty.put("A", "aye").put("B", "bee").put("C", "see"))
+        hash.size.should == 3
+      end
+    end
+
+    context "with an array of pairs" do
+      let(:hash) { H[[[:a, 1], [:b, 2]]] }
+
+      it "initializes a new Hash" do
+        hash.should eql(H[a: 1, b: 2])
+      end
+    end
+
+    context "with an Immutable::Hash" do
+      let(:hash) { H[a: 1, b: 2] }
+      let(:other) { H[hash] }
+
+      it "initializes an equivalent Hash" do
+        hash.should eql(other)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
+
+  [:dup, :clone].each do |method|
+    describe "##{method}" do
+      it "returns self" do
+        hash.send(method).should equal(hash)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#default_proc" do
+    let(:hash) { H.new(1 => 2, 2 => 4) { |k| k * 2 } }
+
+    it "returns the default block given when the Hash was created" do
+      hash.default_proc.class.should be(Proc)
+      hash.default_proc.call(3).should == 6
+    end
+
+    it "returns nil if no default block was given" do
+      H.empty.default_proc.should be_nil
+    end
+
+    context "after a key/val pair are inserted" do
+      it "doesn't change" do
+        other = hash.put(3, 6)
+        other.default_proc.should be(hash.default_proc)
+        other.default_proc.call(4).should == 8
+      end
+    end
+
+    context "after all key/val pairs are filtered out" do
+      it "doesn't change" do
+        other = hash.reject { true }
+        other.default_proc.should be(hash.default_proc)
+        other.default_proc.call(4).should == 8
+      end
+    end
+
+    context "after Hash is inverted" do
+      it "doesn't change" do
+        other = hash.invert
+        other.default_proc.should be(hash.default_proc)
+        other.default_proc.call(4).should == 8
+      end
+    end
+
+    context "when a slice is taken" do
+      it "doesn't change" do
+        other = hash.slice(1)
+        other.default_proc.should be(hash.default_proc)
+        other.default_proc.call(5).should == 10
+      end
+    end
+
+    context "when keys are removed with #except" do
+      it "doesn't change" do
+        other = hash.except(1, 2)
+        other.default_proc.should be(hash.default_proc)
+        other.default_proc.call(5).should == 10
+      end
+    end
+
+    context "when Hash is mapped" do
+      it "doesn't change" do
+        other = hash.map { |k,v| [k + 10, v] }
+        other.default_proc.should be(hash.default_proc)
+        other.default_proc.call(5).should == 10
+      end
+    end
+
+    context "when another Hash is merged in" do
+      it "doesn't change" do
+        other = hash.merge(3 => 6, 4 => 8)
+        other.default_proc.should be(hash.default_proc)
+        other.default_proc.call(5).should == 10
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#delete" do
+    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
+
+    context "with an existing key" do
+      let(:result) { hash.delete("B") }
+
+      it "preserves the original" do
+        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
+      end
+
+      it "returns a copy with the remaining key/value pairs" do
+        result.should eql(H["A" => "aye", "C" => "see"])
+      end
+    end
+
+    context "with a non-existing key" do
+      let(:result) { hash.delete("D") }
+
+      it "preserves the original values" do
+        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
+      end
+
+      it "returns self" do
+        result.should equal(hash)
+      end
+    end
+
+    context "when removing the last key" do
+      context "from a Hash with no default block" do
+        it "returns the canonical empty Hash" do
+          hash.delete('A').delete('B').delete('C').should be(Immutable::EmptyHash)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
+
+  [:each, :each_pair].each do |method|
+    describe "##{method}" do
+      context "with a block (internal iteration)" do
+        it "returns self" do
+          hash.send(method) {}.should be(hash)
+        end
+
+        it "yields all key/value pairs" do
+          actual_pairs = {}
+          hash.send(method) { |key, value| actual_pairs[key] = value }
+          actual_pairs.should == { "A" => "aye", "B" => "bee", "C" => "see" }
+        end
+
+        it "yields key/value pairs in the same order as #each_key and #each_value" do
+          hash.each.to_a.should eql(hash.each_key.zip(hash.each_value))
+        end
+
+        it "yields both of a pair of colliding keys" do
+          yielded = []
+          hash = H[DeterministicHash.new('a', 1) => 1, DeterministicHash.new('b', 1) => 1]
+          hash.each { |k,v| yielded << k }
+          yielded.size.should == 2
+          yielded.map { |x| x.value }.sort.should == ['a', 'b']
+        end
+
+        it "yields only the key to a block expecting |key,|" do
+          keys = []
+          hash.each { |key,| keys << key }
+          keys.sort.should == ["A", "B", "C"]
+        end
+      end
+
+      context "with no block" do
+        it "returns an Enumerator" do
+          @result = hash.send(method)
+          @result.class.should be(Enumerator)
+          @result.to_a.should == hash.to_a
+        end
+      end
+    end
+  end
+
+  describe "#each_key" do
+    it "yields all keys" do
+      keys = []
+      hash.each_key { |k| keys << k }
+      keys.sort.should == ['A', 'B', 'C']
+    end
+
+    context "with no block" do
+      it "returns an Enumerator" do
+        hash.each_key.class.should be(Enumerator)
+        hash.each_key.to_a.sort.should == ['A', 'B', 'C']
+      end
+    end
+  end
+
+  describe "#each_value" do
+    it "yields all values" do
+      values = []
+      hash.each_value { |v| values << v }
+      values.sort.should == ['aye', 'bee', 'see']
+    end
+
+    context "with no block" do
+      it "returns an Enumerator" do
+        hash.each_value.class.should be(Enumerator)
+        hash.each_value.to_a.sort.should == ['aye', 'bee', 'see']
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#each_with_index" do
+    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
+
+    describe "with a block (internal iteration)" do
+      it "returns self" do
+        hash.each_with_index {}.should be(hash)
+      end
+
+      it "yields all key/value pairs with numeric indexes" do
+        actual_pairs = {}
+        indexes = []
+        hash.each_with_index { |(key, value), index| actual_pairs[key] = value; indexes << index }
+        actual_pairs.should == { "A" => "aye", "B" => "bee", "C" => "see" }
+        indexes.sort.should == [0, 1, 2]
+      end
+    end
+
+    describe "with no block" do
+      it "returns an Enumerator" do
+        hash.each_with_index.should be_kind_of(Enumerator)
+        hash.each_with_index.to_a.map(&:first).sort.should eql([["A", "aye"], ["B", "bee"], ["C", "see"]])
+        hash.each_with_index.to_a.map(&:last).should eql([0,1,2])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#empty?" do
+    [
+      [[], true],
+      [["A" => "aye"], false],
+      [["A" => "aye", "B" => "bee", "C" => "see"], false],
+    ].each do |pairs, result|
+      it "returns #{result} for #{pairs.inspect}" do
+        H[*pairs].empty?.should == result
+      end
+    end
+
+    it "returns true for empty hashes which have a default block" do
+      H.new { 'default' }.empty?.should == true
+    end
+  end
+
+  describe ".empty" do
+    it "returns the canonical empty Hash" do
+      H.empty.should be_empty
+      H.empty.should be(Immutable::EmptyHash)
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Immutable::Hash)
+        subclass.empty.class.should be subclass
+        subclass.empty.should be_empty
+      end
+
+      it "calls overridden #initialize when creating empty Hash" do
+        subclass = Class.new(Immutable::Hash) do
+          def initialize
+            @variable = 'value'
+          end
+        end
+        subclass.empty.instance_variable_get(:@variable).should == 'value'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
+
+  describe "#eql?" do
+    it "returns false when comparing with a standard hash" do
+      hash.eql?("A" => "aye", "B" => "bee", "C" => "see").should == false
+    end
+
+    it "returns false when comparing with an arbitrary object" do
+      hash.eql?(Object.new).should == false
+    end
+
+    it "returns false when comparing with a subclass of Immutable::Hash" do
+      subclass = Class.new(Immutable::Hash)
+      instance = subclass.new("A" => "aye", "B" => "bee", "C" => "see")
+      hash.eql?(instance).should == false
+    end
+  end
+
+  describe "#==" do
+    it "returns true when comparing with a standard hash" do
+      (hash == {"A" => "aye", "B" => "bee", "C" => "see"}).should == true
+    end
+
+    it "returns false when comparing with an arbitrary object" do
+      (hash == Object.new).should == false
+    end
+
+    it "returns true when comparing with a subclass of Immutable::Hash" do
+      subclass = Class.new(Immutable::Hash)
+      instance = subclass.new("A" => "aye", "B" => "bee", "C" => "see")
+      (hash == instance).should == true
+    end
+  end
+
+  [:eql?, :==].each do |method|
+    describe "##{method}" do
+      [
+        [{}, {}, true],
+        [{ "A" => "aye" }, {}, false],
+        [{}, { "A" => "aye" }, false],
+        [{ "A" => "aye" }, { "A" => "aye" }, true],
+        [{ "A" => "aye" }, { "B" => "bee" }, false],
+        [{ "A" => "aye", "B" => "bee" }, { "A" => "aye" }, false],
+        [{ "A" => "aye" }, { "A" => "aye", "B" => "bee" }, false],
+        [{ "A" => "aye", "B" => "bee", "C" => "see" }, { "A" => "aye", "B" => "bee", "C" => "see" }, true],
+        [{ "C" => "see", "A" => "aye", "B" => "bee" }, { "A" => "aye", "B" => "bee", "C" => "see" }, true],
+      ].each do |a, b, expected|
+        describe "returns #{expected.inspect}" do
+          it "for #{a.inspect} and #{b.inspect}" do
+            H[a].send(method, H[b]).should == expected
+          end
+
+          it "for #{b.inspect} and #{a.inspect}" do
+            H[b].send(method, H[a]).should == expected
+          end
+        end
+      end
+    end
+  end
+
+  it "returns true on a large hash which is modified and then modified back again" do
+    hash = H.new((1..1000).zip(2..1001))
+    hash.put('a', 1).delete('a').should == hash
+    hash.put('b', 2).delete('b').should eql(hash)
+  end
+end

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

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#except" do
+    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"] }
+
+    context "with only keys that the Hash has" do
+      it "returns a Hash without those values" do
+        hash.except("B", nil).should eql(H["A" => "aye", "C" => "see"])
+      end
+
+      it "doesn't change the original Hash" do
+        hash.except("B", nil)
+        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"])
+      end
+    end
+
+    context "with keys that the Hash doesn't have" do
+      it "returns a Hash without the values that it had keys for" do
+        hash.except("B", "A", 3).should eql(H["C" => "see", nil => "NIL"])
+      end
+
+      it "doesn't change the original Hash" do
+        hash.except("B", "A", 3)
+        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"])
+      end
+    end
+
+    it "works on a large Hash, with many combinations of input" do
+      keys = (1..1000).to_a
+      original = H.new(keys.zip(2..1001))
+      100.times do
+        to_remove = rand(100).times.collect { keys.sample }
+        result    = original.except(*to_remove)
+        result.size.should == original.size - to_remove.uniq.size
+        to_remove.each { |key| result.key?(key).should == false }
+        (keys.sample(100) - to_remove).each { |key| result.key?(key).should == true }
+      end
+      original.should eql(H.new(keys.zip(2..1001))) # shouldn't have changed
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#fetch" do
+    context "with no default provided" do
+      context "when the key exists" do
+        it "returns the value associated with the key" do
+          H["A" => "aye"].fetch("A").should == "aye"
+        end
+      end
+
+      context "when the key does not exist" do
+        it "raises a KeyError" do
+          -> { H["A" => "aye"].fetch("B") }.should raise_error(KeyError)
+        end
+      end
+    end
+
+    context "with a default value" do
+      context "when the key exists" do
+        it "returns the value associated with the key" do
+          H["A" => "aye"].fetch("A", "default").should == "aye"
+        end
+      end
+
+      context "when the key does not exist" do
+        it "returns the default value" do
+          H["A" => "aye"].fetch("B", "default").should == "default"
+        end
+      end
+    end
+
+    context "with a default block" do
+      context "when the key exists" do
+        it "returns the value associated with the key" do
+          H["A" => "aye"].fetch("A") { "default".upcase }.should == "aye"
+        end
+      end
+
+      context "when the key does not exist" do
+        it "invokes the default block with the missing key as paramter" do
+          H["A" => "aye"].fetch("B") { |key| key.should == "B" }
+          H["A" => "aye"].fetch("B") { "default".upcase }.should == "DEFAULT"
+        end
+      end
+    end
+
+    it "gives precedence to default block over default argument if passed both" do
+      H["A" => "aye"].fetch("B", 'one') { 'two' }.should == 'two'
+    end
+
+    it "raises an ArgumentError when not passed one or 2 arguments" do
+      -> { H.empty.fetch }.should raise_error(ArgumentError)
+      -> { H.empty.fetch(1, 2, 3) }.should raise_error(ArgumentError)
+    end
+  end
+end