hamster 0.4.3 → 1.0.0

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

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash("a" => 1, "b" => 2, "c" => 3, "d" => 4) }
+  let(:partition) { hash.partition { |k,v| v % 2 == 0 }}
+
+  describe "#partition" do
+    it "returns a pair of Hamster::Hashes" do
+      partition.each { |h| h.class.should be(Hamster::Hash) }
+      partition.should be_frozen
+    end
+
+    it "returns key/val pairs for which predicate is true in first Hash" do
+      partition[0].should == {"b" => 2, "d" => 4}
+    end
+
+    it "returns key/val pairs for which predicate is false in second Hash" do
+      partition[1].should == {"a" => 1, "c" => 3}
+    end
+
+    it "doesn't modify the original Hash" do
+      partition
+      hash.should eql(Hamster.hash("a" => 1, "b" => 2, "c" => 3, "d" => 4))
+    end
+
+    context "from a subclass" do
+      it "should return instances of the subclass" do
+        subclass  = Class.new(Hamster::Hash)
+        instance  = subclass.new("a" => 1, "b" => 2, "c" => 3, "d" => 4)
+        partition = instance.partition { |k,v| v % 2 == 0 }
+        partition.each { |h| h.class.should be(subclass) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "spec_helper"
+require "hamster/hash"
+require "pp"
+require "stringio"
+
+describe Hamster::Hash do
+  describe "#pretty_print" do
+    let(:hash) { Hamster::Hash.new(DeterministicHash.new(1,1) => "tin", DeterministicHash.new(2,2) => "earwax", DeterministicHash.new(3,3) => "neanderthal") }
+    let(:stringio) { StringIO.new }
+
+
+    it "prints the whole Hash on one line if it fits" do
+      PP.pp(hash, stringio, 80)
+      stringio.string.chomp.should == 'Hamster::Hash[1 => "tin", 2 => "earwax", 3 => "neanderthal"]'
+    end
+
+    it "prints each key/val pair on its own line, if not" do
+      PP.pp(hash, stringio, 20)
+      stringio.string.chomp.should == 'Hamster::Hash[
+ 1 => "tin",
+ 2 => "earwax",
+ 3 => "neanderthal"]'
+    end
+
+    it "prints keys and vals on separate lines, if space is very tight" do
+      PP.pp(hash, stringio, 15)
+      # the trailing space after "3 =>" below is needed, don't remove it
+      stringio.string.chomp.should == 'Hamster::Hash[
+ 1 => "tin",
+ 2 => "earwax",
+ 3 => 
+  "neanderthal"]'
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#put" do
+    let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+
+    context "with a block" do
+      it "passes the value to the block" do
+        hash.put("A") { |value| value.should == "aye" }
+      end
+
+      it "replaces the value with the result of the block" do
+        result = hash.put("A") { |value| "FLIBBLE" }
+        result.get("A").should == "FLIBBLE"
+      end
+
+      it "supports to_proc methods" do
+        result = hash.put("A", &:upcase)
+        result.get("A").should == "AYE"
+      end
+
+      context "if there is no existing association" do
+        it "passes nil to the block" do
+          hash.put("D") { |value| value.should be_nil }
+        end
+
+        it "stores the result of the block as the new value" do
+          result = hash.put("D") { |value| "FLIBBLE" }
+          result.get("D").should == "FLIBBLE"
+        end
+      end
+    end
+
+    context "with a unique key" do
+      let(:result) { hash.put("D", "dee") }
+
+      it "preserves the original" do
+        result
+        hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+      end
+
+      it "returns a copy with the superset of key/value pairs" do
+        result.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", "D" => "dee"))
+      end
+    end
+
+    context "with a duplicate key" do
+      let(:result) { hash.put("C", "sea") }
+
+      it "preserves the original" do
+        result
+        hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+      end
+
+      it "returns a copy with the superset of key/value pairs" do
+        result.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "sea"))
+      end
+    end
+
+    context "with duplicate key and identical value" do
+      let(:hash) { Hamster::Hash["X" => 1, "Y" => 2] }
+      let(:result) { hash.put("X", 1) }
+
+      it "returns the original hash unmodified" do
+        result.should be(hash)
+      end
+
+      context "with big hash (force nested tries)" do
+        let(:keys) { (0..99).map(&:to_s) }
+        let(:values) { (100..199).to_a }
+        let(:hash) { Hamster::Hash[keys.zip(values)] }
+
+        it "returns the original hash unmodified for all changes" do
+          keys.each_with_index do |key, index|
+            result = hash.put(key, values[index])
+            result.should be(hash)
+          end
+        end
+      end
+    end
+
+    context "with unequal keys which hash to the same value" do
+      let(:hash) { Hamster.hash(DeterministicHash.new('a', 1) => 'aye') }
+
+      it "stores and can retrieve both" do
+        result = hash.put(DeterministicHash.new('b', 1), 'bee')
+        result.get(DeterministicHash.new('a', 1)).should eql('aye')
+        result.get(DeterministicHash.new('b', 1)).should eql('bee')
+      end
+    end
+
+    context "when a String is inserted as key and then mutated" do
+      it "is not affected" do
+        string = "a string!"
+        hash = Hamster.hash.put(string, 'a value!')
+        string.upcase!
+        hash['a string!'].should == 'a value!'
+        hash['A STRING!'].should be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  [:reduce, :inject].each do |method|
+    describe "##{method}" do
+      context "when empty" do
+        it "returns the memo" do
+          Hamster.hash.send(method, "ABC") {}.should == "ABC"
+        end
+      end
+
+      context "when not empty" do
+        let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+
+        context "with a block" do
+          it "returns the final memo" do
+            hash.send(method, 0) { |memo, key, value| memo + 1 }.should == 3
+          end
+        end
+
+        context "with no block" do
+          let(:hash) { Hamster.hash(a: 1, b: 2) }
+
+          it "uses a passed string as the name of a method to use instead" do
+            [[:a, 1, :b, 2], [:b, 2, :a, 1]].include?(hash.send(method, "+")).should == true
+          end
+
+          it "uses a passed symbol as the name of a method to use instead" do
+            [[:a, 1, :b, 2], [:b, 2, :a, 1]].include?(hash.send(method, :+)).should == true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  [:reject, :delete_if].each do |method|
+    describe "##{method}" do
+      let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+
+      context "when nothing matches" do
+        it "returns self" do
+          hash.send(method) { |key, value| false }.should equal(hash)
+        end
+      end
+
+      context "when only some things match" do
+        context "with a block" do
+          let(:result) { hash.send(method) { |key, value| key == "A" && value == "aye" }}
+
+          it "preserves the original" do
+            result
+            hash.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("B" => "bee", "C" => "see"))
+          end
+
+          it "yields entries in the same order as #each" do
+            each_pairs = []
+            remove_pairs = []
+            hash.each_pair { |k,v| each_pairs << [k,v] }
+            hash.send(method) { |k,v| remove_pairs << [k,v] }
+            each_pairs.should == remove_pairs
+          end
+        end
+
+        context "with no block" do
+          it "returns an Enumerator" do
+            hash.send(method).class.should be(Enumerator)
+            hash.send(method).to_a.sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
+            hash.send(method).each { true }.should eql(Hamster.hash)
+          end
+        end
+
+        context "on a large hash, with many combinations of input" do
+          it "still works" do
+            array = 1000.times.collect { |n| [n, n] }
+            hash  = Hamster::Hash.new(array)
+            [0, 10, 100, 200, 500, 800, 900, 999, 1000].each do |threshold|
+              result = hash.send(method) { |k,v| k >= threshold}
+              result.size.should == threshold
+              0.upto(threshold-1) { |n| result.key?(n).should == true }
+              threshold.upto(1000) { |n| result.key?(n).should == false }
+            end
+            # shouldn't have changed
+            hash.should eql(Hamster::Hash.new(1000.times.collect { |n| [n, n] }))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+
+  describe "#reverse_each" do
+    context "with a block" do
+      it "returns self" do
+        hash.reverse_each {}.should be(hash)
+      end
+
+      it "yields all key/value pairs in the opposite order as #each" do
+        result = []
+        hash.reverse_each { |entry| result << entry }
+        result.should eql(hash.to_a.reverse)
+      end
+    end
+
+    context "with no block" do
+      it "returns an Enumerator" do
+        result = hash.reverse_each
+        result.class.should be(Enumerator)
+        result.to_a.should eql(hash.to_a.reverse)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#sample" do
+    let(:hash) { Hamster::Hash.new((:a..:z).zip(1..26)) }
+
+    it "returns a randomly chosen item" do
+      chosen = 250.times.map { hash.sample }.sort.uniq
+      chosen.each { |item| hash.include?(item[0]).should == true }
+      hash.each { |item| chosen.include?(item).should == true }
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  [: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/{hamster → lib/hamster}/hash/size_spec.rb

@@ -1,13 +1,9 @@
-require 'spec_helper'
-
-require 'hamster/hash'
+require "spec_helper"
+require "hamster/hash"
 
 describe Hamster::Hash do
-
   [:size, :length].each do |method|
-
     describe "##{method}" do
-
       [
         [[], 0],
         [["A" => "aye"], 1],
@@ -17,23 +13,21 @@ describe Hamster::Hash do
         it "returns #{result} for #{values.inspect}" do
           Hamster.hash(*values).send(method).should == result
         end
-
       end
 
-      lots = (1..10842).to_a
-      srand 89533474
-      random_things = (lots + lots).sort_by{|x|rand}
+      lots = (1..10_842).to_a
+      srand 89_533_474
+      random_things = (lots + lots).sort_by { |x|rand }
 
-      it "should have the correct size after adding lots of things with colliding keys and such" do
+      it "has the correct size after adding lots of things with colliding keys and such" do
         h = Hamster.hash
         random_things.each do |thing|
           h = h.put(thing, thing * 2)
         end
-        h.size.should == 10842
+        h.size.should == 10_842
       end
 
-      random_actions = (lots.map{|x|[:add, x]} + lots.map{|x|[:add, x]} + lots.map{|x|[:remove, x]}).
-        sort_by{|x|rand}
+      random_actions = (lots.map { |x|[:add, x] } + lots.map { |x|[:add, x] } + lots.map { |x|[:remove, x] }).sort_by { |x|rand }
       ending_size = random_actions.reduce({}) do |h, (act, ob)|
         if act == :add
           h[ob] = 1
@@ -42,7 +36,7 @@ describe Hamster::Hash do
         end
         h
       end.size
-      it "should have the correct size after lots of addings and removings" do
+      it "has the correct size after lots of addings and removings" do
         h = Hamster.hash
         random_actions.each do |(act, ob)|
           if act == :add
@@ -53,9 +47,6 @@ describe Hamster::Hash do
         end
         h.size.should == ending_size
       end
-
     end
-
   end
-
 end

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

@@ -0,0 +1,45 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster::Hash.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL") }
+
+  describe "#slice" do
+    let(:slice) { hash.slice(*values) }
+
+    context "with all keys present in the Hash" do
+      let(:values) { ["B", nil] }
+
+      it "returns the sliced values" do
+        expect(slice).to eq(described_class.new("B" => "bee", nil => "NIL"))
+      end
+
+      it "doesn't modify the original Hash" do
+        slice
+        hash.should eql(Hamster::Hash.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"))
+      end
+    end
+
+    context "with keys aren't present in the Hash" do
+      let(:values) { ["B", "A", 3] }
+
+      it "returns the sliced values of the matching keys" do
+        expect(slice).to eq(described_class.new("A" => "aye", "B" => "bee"))
+      end
+
+      it "doesn't modify the original Hash" do
+        slice
+        hash.should eql(Hamster::Hash.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"))
+      end
+    end
+
+    context "on a Hash with a default block" do
+      let(:hash) { Hamster.hash('A' => 'aye', 'B' => 'bee') { 'nothing' }}
+      let(:values) { ["B", nil] }
+
+      it "maintains the default block" do
+        expect(slice['C']).to eq('nothing')
+      end
+    end
+  end
+end