hamster 1.0.1.pre.rc2 → 1.0.1.pre.rc3

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, :foreach, :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,46 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  [:empty?, :null?].each do |method|
+    describe "##{method}" 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).send(method).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
+  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

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/filter_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  [:filter, :select, :find_all, :keep_if].each do |method|
+    describe "##{method}" do
+      let(:original) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+
+      context "when everything matches" do
+        it "returns self" do
+          original.send(method) { |key, value| true }.should equal(original)
+        end
+      end
+
+      context "when only some things match" do
+        context "with a block" do
+          let(:result) { original.send(method) { |key, value| key == "A" && value == "aye" }}
+
+          it "preserves the original" do
+            original.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+          end
+
+          it "returns a set with the matching values" do
+            result.should eql(Hamster.hash("A" => "aye"))
+          end
+        end
+
+        it "yields entries as [key, value] pairs" do
+          original.send(method) do |e|
+            e.should be_kind_of(Array)
+            ["A", "B", "C"].include?(e[0]).should == true
+            ["aye", "bee", "see"].include?(e[1]).should == true
+          end
+        end
+
+        context "with no block" do
+          it "returns an Enumerator" do
+            original.send(method).class.should be(Enumerator)
+            original.send(method).to_a.sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
+          end
+        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))
+        25.times do
+          threshold = rand(1000)
+          result    = original.send(method) { |k,v| k <= threshold }
+          result.size.should == threshold
+          result.each_key { |k| k.should <= threshold }
+          (threshold+1).upto(1000) { |k| result.key?(k).should == false }
+        end
+        original.should eql(Hamster::Hash.new(keys.zip(2..1001))) # shouldn't have changed
+      end
+    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