hamster 0.4.3 → 1.0.0

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

@@ -0,0 +1,43 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#except" do
+    let(:hash) { Hamster.hash("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(Hamster.hash("A" => "aye", "C" => "see"))
+      end
+
+      it "doesn't change the original Hash" do
+        hash.except("B", nil)
+        hash.should eql(Hamster.hash("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(Hamster.hash("C" => "see", nil => "NIL"))
+      end
+
+      it "doesn't change the original Hash" do
+        hash.except("B", "A", 3)
+        hash.should eql(Hamster.hash("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 = Hamster::Hash.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(Hamster::Hash.new(keys.zip(2..1001))) # shouldn't have changed
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::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
+          Hamster.hash("A" => "aye").fetch("A").should == "aye"
+        end
+      end
+
+      context "when the key does not exist" do
+        it "raises a KeyError" do
+          -> { Hamster.hash("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
+          Hamster.hash("A" => "aye").fetch("A", "default").should == "aye"
+        end
+      end
+
+      context "when the key does not exist" do
+        it "returns the default value" do
+          Hamster.hash("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
+          Hamster.hash("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
+          Hamster.hash("A" => "aye").fetch("B") { |key| key.should == "B" }
+          Hamster.hash("A" => "aye").fetch("B") { "default".upcase }.should == "DEFAULT"
+        end
+      end
+    end
+
+    it "gives precedence to default block over default argument if passed both" do
+      Hamster.hash("A" => "aye").fetch("B", 'one') { 'two' }.should == 'two'
+    end
+
+    it "raises an ArgumentError when not passed one or 2 arguments" do
+      -> { Hamster.hash.fetch }.should raise_error(ArgumentError)
+      -> { Hamster.hash.fetch(1, 2, 3) }.should raise_error(ArgumentError)
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  [:find, :detect].each do |method|
+    describe "##{method}" do
+      [
+        [[], "A", nil],
+        [[], nil, nil],
+        [["A" => "aye"], "A", ["A", "aye"]],
+        [["A" => "aye"], "B", nil],
+        [["A" => "aye"], nil, nil],
+        [["A" => "aye", "B" => "bee", nil => "NIL"], "A", ["A", "aye"]],
+        [["A" => "aye", "B" => "bee", nil => "NIL"], "B", ["B", "bee"]],
+        [["A" => "aye", "B" => "bee", nil => "NIL"], nil, [nil, "NIL"]],
+        [["A" => "aye", "B" => "bee", nil => "NIL"], "C", nil],
+      ].each do |values, key, expected|
+        describe "on #{values.inspect}" do
+          let(:hash) { Hamster.hash(*values) }
+
+          describe "with a block" do
+            it "returns #{expected.inspect}" do
+              hash.send(method) { |k, v| k == key }.should == expected
+            end
+          end
+
+          describe "without a block" do
+            it "returns an Enumerator" do
+              result = hash.send(method)
+              result.class.should be(Enumerator)
+              result.each { |k,v| k == key }.should == expected
+            end
+          end
+        end
+      end
+
+      it "stops iterating when the block returns true" do
+        yielded = []
+        Hamster.hash(a: 1, b: 2).find { |k,v| yielded << k; true }
+        yielded.size.should == 1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+
+  describe "#flat_map" do
+    it "yields each key/val pair" do
+      passed = []
+      hash.flat_map { |pair| passed << pair }
+      passed.sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
+    end
+
+    it "returns the concatenation of block return values" do
+      hash.flat_map { |k,v| [k,v] }.sort.should == ['A', 'B', 'C', 'aye', 'bee', 'see']
+      hash.flat_map { |k,v| Hamster.list(k,v) }.sort.should == ['A', 'B', 'C', 'aye', 'bee', 'see']
+      hash.flat_map { |k,v| Hamster.vector(k,v) }.sort.should == ['A', 'B', 'C', 'aye', 'bee', 'see']
+    end
+
+    it "doesn't change the receiver" do
+      hash.flat_map { |k,v| [k,v] }
+      hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+    end
+
+    context "with no block" do
+      it "returns an Enumerator" do
+        hash.flat_map.class.should be(Enumerator)
+        hash.flat_map.each { |k,v| [k] }.sort.should == ['A', 'B', 'C']
+      end
+    end
+
+    it "returns an empty array if only empty arrays are returned by block" do
+      hash.flat_map { [] }.should eql([])
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#flatten" do
+    context "with flatten depth of zero" do
+      it "returns a vector of keys/value" do
+        hash = Hamster.hash(a: 1, b: 2)
+        hash.flatten(0).sort.should eql(V[[:a, 1], [:b, 2]])
+      end
+    end
+
+    context "without array keys or values" do
+      it "returns a vector of keys and values" do
+        hash = Hamster.hash(a: 1, b: 2, c: 3)
+        possibilities = [[:a, 1, :b, 2, :c, 3],
+         [:a, 1, :c, 3, :b, 2],
+         [:b, 2, :a, 1, :c, 3],
+         [:b, 2, :c, 3, :a, 1],
+         [:c, 3, :a, 1, :b, 2],
+         [:c, 3, :b, 2, :a, 1]]
+        possibilities.include?(hash.flatten).should == true
+        possibilities.include?(hash.flatten(1)).should == true
+        possibilities.include?(hash.flatten(2)).should == true
+        hash.flatten(2).class.should be(Hamster::Vector)
+        possibilities.include?(hash.flatten(10)).should == true
+      end
+
+      it "doesn't modify the receiver" do
+        hash = Hamster.hash(a: 1, b: 2, c: 3)
+        hash.flatten(1)
+        hash.flatten(2)
+        hash.should eql(Hamster.hash(a: 1, b: 2, c: 3))
+      end
+    end
+
+    context "on an empty Hash" do
+      it "returns an empty Vector" do
+        Hamster.hash.flatten.should eql(V[])
+      end
+    end
+
+    context "with array keys" do
+      it "flattens array keys into returned vector if flatten depth is sufficient" do
+        hash = Hamster.hash([1, 2] => 3, [4, 5] => 6)
+        [[[1, 2], 3, [4, 5], 6], [[4, 5], 6, [1, 2], 3]].include?(hash.flatten(1)).should == true
+        [[[1, 2], 3, [4, 5], 6], [[4, 5], 6, [1, 2], 3]].include?(hash.flatten).should == true
+        hash.flatten(1).class.should be(Hamster::Vector)
+        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(2)).should == true
+        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(3)).should == true
+      end
+
+      it "doesn't modify the receiver (or its contents)" do
+        hash = Hamster.hash([1, 2] => 3, [4, 5] => 6)
+        hash.flatten(1)
+        hash.flatten(2)
+        hash.should eql(Hamster.hash([1, 2] => 3, [4, 5] => 6))
+      end
+    end
+
+    context "with array values" do
+      it "flattens array values into returned vector if flatten depth is sufficient" do
+        hash = Hamster.hash(1 => [2, 3], 4 => [5, 6])
+        [[1, [2, 3], 4, [5, 6]], [4, [5, 6], 1, [2, 3]]].include?(hash.flatten(1)).should == true
+        [[1, [2, 3], 4, [5, 6]], [4, [5, 6], 1, [2, 3]]].include?(hash.flatten).should == true
+        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(2)).should == true
+        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(3)).should == true
+        hash.flatten(3).class.should be(Hamster::Vector)
+      end
+
+      it "doesn't modify the receiver (or its contents)" do
+        hash = Hamster.hash(1 => [2, 3], 4 => [5, 6])
+        hash.flatten(1)
+        hash.flatten(2)
+        hash.should eql(Hamster.hash(1 => [2, 3], 4 => [5, 6]))
+      end
+    end
+
+    context "with vector keys" do
+      it "flattens vector keys into returned vector if flatten depth is sufficient" do
+        hash = Hamster.hash(V[1, 2] => 3, V[4, 5] => 6)
+        [[V[1, 2], 3, V[4, 5], 6], [V[4, 5], 6, V[1, 2], 3]].include?(hash.flatten).should == true
+        [[V[1, 2], 3, V[4, 5], 6], [V[4, 5], 6, V[1, 2], 3]].include?(hash.flatten(1)).should == true
+        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(2)).should == true
+        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(3)).should == true
+      end
+    end
+
+    context "with vector values" do
+      it "flattens vector values into returned vector if flatten depth is sufficient" do
+        hash = Hamster.hash(1 => V[2, 3], 4 => V[5, 6])
+        [[1, V[2, 3], 4, V[5, 6]], [4, V[5, 6], 1, V[2, 3]]].include?(hash.flatten(1)).should == true
+        [[1, V[2, 3], 4, V[5, 6]], [4, V[5, 6], 1, V[2, 3]]].include?(hash.flatten).should == true
+        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(2)).should == true
+        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(3)).should == true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  [:get, :[]].each do |method|
+    describe "##{method}" do
+      context "with a default block" do
+        let(:hash) { Hamster.hash("A" => "aye") { |key| fail }}
+
+        context "when the key exists" do
+          it "returns the value associated with the key" do
+            hash.send(method, "A").should == "aye"
+          end
+
+          it "does not call the default block even if the key is 'nil'" do
+            Hamster.hash(nil => 'something') { fail }.send(method, nil)
+          end
+        end
+
+        context "when the key does not exist" do
+          let(:hash) do
+            Hamster.hash("A" => "aye") do |key|
+              expect(key).to eq("B")
+              "bee"
+            end
+          end
+
+          it "returns the value from the default block" do
+            hash.send(method, "B").should == "bee"
+          end
+        end
+      end
+
+      context "with no default block" do
+        let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL") }
+
+        [
+          %w[A aye],
+          %w[B bee],
+          %w[C see],
+          [nil, "NIL"]
+        ].each do |key, value|
+          it "returns the value (#{value.inspect}) for an existing key (#{key.inspect})" do
+            hash.send(method, key).should == value
+          end
+        end
+
+        it "returns nil for a non-existing key" do
+          hash.send(method, "D").should be_nil
+        end
+      end
+
+      it "uses #hash to look up keys" do
+        x = double('0')
+        x.should_receive(:hash).and_return(0)
+        Hamster.hash(foo: :bar).send(method, x).should be_nil
+      end
+
+      it "uses #eql? to compare keys with the same hash code" do
+        x = double('x', hash: 42)
+        x.should_not_receive(:eql?)
+
+        y = double('y', hash: 42)
+        y.should_receive(:eql?).and_return(true)
+
+        Hamster.hash(y => 1)[x].should == 1
+      end
+
+      it "does not use #eql? to compare keys with different hash codes" do
+        x = double('x', hash: 0)
+        x.should_not_receive(:eql?)
+
+        y = double('y', hash: 1)
+        y.should_not_receive(:eql?)
+
+        Hamster.hash(y => 1)[x].should be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  [:key?, :has_key?, :include?, :member?].each do |method|
+    describe "##{method}" do
+      let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL", 2.0 => "two") }
+
+      ["A", "B", "C", nil, 2.0].each do |key|
+        it "returns true for an existing key (#{key.inspect})" do
+          hash.send(method, key).should == true
+        end
+      end
+
+      it "returns false for a non-existing key" do
+        hash.send(method, "D").should == false
+      end
+
+      it "uses #eql? for equality" do
+        hash.send(method, 2).should == false
+      end
+
+      it "returns true if the key is found and maps to nil" do
+        Hamster.hash("A" => nil).send(method, "A").should == true
+      end
+
+      it "returns true if the key is found and maps to false" do
+        Hamster.hash("A" => false).send(method, "A").should == true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash(toast: 'buttered', jam: 'strawberry') }
+
+  [:value?, :has_value?].each do |method|
+    describe "##{method}" do
+      it "returns true if any key/val pair in Hash has the same value" do
+        hash.send(method, 'strawberry').should == true
+      end
+
+      it "returns false if no key/val pair in Hash has the same value" do
+        hash.send(method, 'marmalade').should == false
+      end
+
+      it "uses #== to check equality" do
+        Hamster.hash(a: EqualNotEql.new).send(method, EqualNotEql.new).should == true
+        Hamster.hash(a: EqlNotEqual.new).send(method, EqlNotEqual.new).should == false
+      end
+
+      it "works on a large hash" do
+        large = Hamster::Hash.new((1..1000).zip(2..1001))
+        [2, 100, 200, 500, 900, 1000, 1001].each { |n| large.value?(n).should == true }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#hash" do
+    it "values are sufficiently distributed" do
+      (1..4000).each_slice(4).map { |ka, va, kb, vb| Hamster.hash(ka => va, kb => vb).hash }.uniq.size.should == 1000
+    end
+
+    it "differs given the same keys and different values" do
+      Hamster.hash("ka" => "va").hash.should_not == Hamster.hash("ka" => "vb").hash
+    end
+
+    it "differs given the same values and different keys" do
+      Hamster.hash("ka" => "va").hash.should_not == Hamster.hash("kb" => "va").hash
+    end
+
+    it "generates the same hash value for a hash regardless of the order things were added to it" do
+      key1 = DeterministicHash.new('abc', 1)
+      key2 = DeterministicHash.new('xyz', 1)
+      Hamster.hash.put(key1, nil).put(key2, nil).hash.should == Hamster.hash.put(key2, nil).put(key1, nil).hash
+    end
+
+    describe "on an empty hash" do
+      it "returns 0" do
+        Hamster.hash.hash.should == 0
+      end
+    end
+  end
+end