hamster 1.0.0 → 1.0.1.pre.rc.1

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

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

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

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

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

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

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

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

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

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