hamster 0.4.3 → 1.0.0

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

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash(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
+      Hamster::Hash.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
+      Hamster::Hash.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/hamster/hash/clear_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#clear" do
+    [
+      [],
+      ["A" => "aye"],
+      ["A" => "aye", "B" => "bee", "C" => "see"],
+    ].each do |values|
+      context "on #{values}" do
+        let(:original) { Hamster.hash(*values) }
+        let(:result)   { original.clear }
+
+        it "preserves the original" do
+          result
+          original.should eql(Hamster.hash(*values))
+        end
+
+        it "returns an empty hash" do
+          result.should equal(Hamster.hash)
+          result.should be_empty
+        end
+      end
+    end
+
+    it "maintains the default Proc, if there is one" do
+      hash = Hamster::Hash.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(Hamster::Hash)
+        instance = subclass.new(a: 1, b: 2)
+        instance.clear.class.should be(subclass)
+        instance.clear.should be_empty
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash("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/hamster/hash/default_proc_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#default_proc" do
+    let(:hash) { Hamster::Hash.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
+      Hamster.hash.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/hamster/hash/delete_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#delete" do
+    let(:hash) { Hamster.hash("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(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+      end
+
+      it "returns a copy with the remaining key/value pairs" do
+        result.should eql(Hamster.hash("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(Hamster.hash("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(Hamster::EmptyHash)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash("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 = Hamster.hash(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/hamster/hash/each_with_index_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#each_with_index" do
+    let(:hash) { Hamster.hash("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/hamster/hash/empty_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::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
+        Hamster.hash(*pairs).empty?.should == result
+      end
+    end
+
+    it "returns true for empty hashes which have a default block" do
+      Hamster::Hash.new { 'default' }.empty?.should == true
+    end
+  end
+
+  describe ".empty" do
+    it "returns the canonical empty Hash" do
+      Hamster::Hash.empty.should be_empty
+      Hamster::Hash.empty.should be(Hamster::EmptyHash)
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Hamster::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(Hamster::Hash) do
+          def initialize
+            @variable = 'value'
+          end
+        end
+        subclass.empty.instance_variable_get(:@variable).should == 'value'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash("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 Hamster::Hash" do
+      subclass = Class.new(Hamster::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 Hamster::Hash" do
+      subclass = Class.new(Hamster::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
+            Hamster.hash(a).send(method, Hamster.hash(b)).should == expected
+          end
+
+          it "for #{b.inspect} and #{a.inspect}" do
+            Hamster.hash(b).send(method, Hamster.hash(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 = Hamster::Hash.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