hamster 1.0.1.pre.rc3 → 2.0.0

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

@@ -23,20 +23,20 @@ describe Hamster::Hash do
     end
 
     it "accepts an array as initializer" do
-      Hamster::Hash.new([['a', 'b'], ['c', 'd']]).should eql(Hamster.hash('a' => 'b', 'c' => 'd'))
+      H.new([['a', 'b'], ['c', 'd']]).should eql(H['a' => 'b', 'c' => 'd'])
     end
 
     it "returns a Hash which doesn't change even if initializer is mutated" do
       rbhash = {a: 1, b: 2}
-      hash = Hamster::Hash.new(rbhash)
+      hash = H.new(rbhash)
       rbhash[:a] = 'BAD'
-      hash.should eql(Hamster.hash(a: 1, b: 2))
+      hash.should eql(H[a: 1, b: 2])
     end
   end
 
   describe ".[]" do
     it "accepts a Ruby Hash as initializer" do
-      hash = Hamster::Hash[a: 1, b: 2]
+      hash = H[a: 1, b: 2]
       hash.class.should be(Hamster::Hash)
       hash.size.should == 2
       hash.key?(:a).should == true
@@ -44,7 +44,7 @@ describe Hamster::Hash do
     end
 
     it "accepts a Hamster::Hash as initializer" do
-      hash = Hamster::Hash[Hamster.hash(a: 1, b: 2)]
+      hash = H[H.new(a: 1, b: 2)]
       hash.class.should be(Hamster::Hash)
       hash.size.should == 2
       hash.key?(:a).should == true
@@ -52,7 +52,7 @@ describe Hamster::Hash do
     end
 
     it "accepts an array as initializer" do
-      hash = Hamster::Hash[[[:a, 1], [:b, 2]]]
+      hash = H[[[:a, 1], [:b, 2]]]
       hash.class.should be(Hamster::Hash)
       hash.size.should == 2
       hash.key?(:a).should == true

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

@@ -5,16 +5,16 @@ describe Hamster::Hash do
   describe "#none?" do
     context "when empty" do
       it "with a block returns true" do
-        Hamster.hash.none? {}.should == true
+        H.empty.none? {}.should == true
       end
 
       it "with no block returns true" do
-        Hamster.hash.none?.should == true
+        H.empty.none?.should == true
       end
     end
 
     context "when not empty" do
-      let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL") }
+      let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"] }
 
       context "with a block" do
         [

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  let(:hash) { Hamster.hash("a" => 1, "b" => 2, "c" => 3, "d" => 4) }
+  let(:hash) { H["a" => 1, "b" => 2, "c" => 3, "d" => 4] }
   let(:partition) { hash.partition { |k,v| v % 2 == 0 }}
 
   describe "#partition" do
@@ -21,7 +21,7 @@ describe Hamster::Hash do
 
     it "doesn't modify the original Hash" do
       partition
-      hash.should eql(Hamster.hash("a" => 1, "b" => 2, "c" => 3, "d" => 4))
+      hash.should eql(H["a" => 1, "b" => 2, "c" => 3, "d" => 4])
     end
 
     context "from a subclass" do

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

@@ -3,7 +3,7 @@ require "hamster/hash"
 
 describe Hamster::Hash do
   describe "#put" do
-    let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
 
     context "with a block" do
       it "passes the value to the block" do
@@ -37,11 +37,11 @@ describe Hamster::Hash do
 
       it "preserves the original" do
         result
-        hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+        hash.should eql(H["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"))
+        result.should eql(H["A" => "aye", "B" => "bee", "C" => "see", "D" => "dee"])
       end
     end
 
@@ -50,16 +50,38 @@ describe Hamster::Hash do
 
       it "preserves the original" do
         result
-        hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+        hash.should eql(H["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"))
+        result.should eql(H["A" => "aye", "B" => "bee", "C" => "sea"])
+      end
+    end
+
+    context "with duplicate key and identical value" do
+      let(:hash) { H["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) { H[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') }
+      let(:hash) { H[DeterministicHash.new('a', 1) => 'aye'] }
 
       it "stores and can retrieve both" do
         result = hash.put(DeterministicHash.new('b', 1), 'bee')
@@ -71,7 +93,7 @@ describe Hamster::Hash do
     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!')
+        hash = H.empty.put(string, 'a value!')
         string.upcase!
         hash['a string!'].should == 'a value!'
         hash['A STRING!'].should be_nil

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

@@ -2,16 +2,16 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  [:reduce, :inject, :fold, :foldr].each do |method|
+  [:reduce, :inject].each do |method|
     describe "##{method}" do
       context "when empty" do
         it "returns the memo" do
-          Hamster.hash.send(method, "ABC") {}.should == "ABC"
+          H.empty.send(method, "ABC") {}.should == "ABC"
         end
       end
 
       context "when not empty" do
-        let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+        let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
 
         context "with a block" do
           it "returns the final memo" do
@@ -20,7 +20,7 @@ describe Hamster::Hash do
         end
 
         context "with no block" do
-          let(:hash) { Hamster.hash(a: 1, b: 2) }
+          let(:hash) { H[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

data/spec/lib/hamster/hash/{remove_spec.rb → reject_spec.rb}

@@ -2,9 +2,9 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  [:remove, :reject, :delete_if].each do |method|
+  [:reject, :delete_if].each do |method|
     describe "##{method}" do
-      let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+      let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
 
       context "when nothing matches" do
         it "returns self" do
@@ -18,11 +18,11 @@ describe Hamster::Hash do
 
           it "preserves the original" do
             result
-            hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+            hash.should eql(H["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"))
+            result.should eql(H["B" => "bee", "C" => "see"])
           end
 
           it "yields entries in the same order as #each" do
@@ -38,14 +38,14 @@ describe Hamster::Hash 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)
+            hash.send(method).each { true }.should eql(H.empty)
           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)
+            hash  = H.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
@@ -53,7 +53,7 @@ describe Hamster::Hash do
               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] }))
+            hash.should eql(H.new(1000.times.collect { |n| [n, n] }))
           end
         end
       end

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+  let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
 
   describe "#reverse_each" do
     context "with a block" do

data/spec/lib/hamster/hash/{filter_spec.rb → select_spec.rb}

@@ -2,9 +2,9 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  [:filter, :select, :find_all, :keep_if].each do |method|
+  [:select, :find_all, :keep_if].each do |method|
     describe "##{method}" do
-      let(:original) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+      let(:original) { H["A" => "aye", "B" => "bee", "C" => "see"] }
 
       context "when everything matches" do
         it "returns self" do
@@ -17,11 +17,11 @@ describe Hamster::Hash 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"))
+            original.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
           end
 
           it "returns a set with the matching values" do
-            result.should eql(Hamster.hash("A" => "aye"))
+            result.should eql(H["A" => "aye"])
           end
         end
 
@@ -43,7 +43,7 @@ describe Hamster::Hash do
 
       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))
+        original = H.new(keys.zip(2..1001))
         25.times do
           threshold = rand(1000)
           result    = original.send(method) { |k,v| k <= threshold }
@@ -51,7 +51,7 @@ describe Hamster::Hash do
           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
+        original.should eql(H.new(keys.zip(2..1001))) # shouldn't have changed
       end
     end
   end

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

@@ -11,7 +11,7 @@ describe Hamster::Hash do
       ].each do |values, result|
 
         it "returns #{result} for #{values.inspect}" do
-          Hamster.hash(*values).send(method).should == result
+          H[*values].send(method).should == result
         end
       end
 
@@ -20,7 +20,7 @@ describe Hamster::Hash do
       random_things = (lots + lots).sort_by { |x|rand }
 
       it "has the correct size after adding lots of things with colliding keys and such" do
-        h = Hamster.hash
+        h = H.empty
         random_things.each do |thing|
           h = h.put(thing, thing * 2)
         end
@@ -37,7 +37,7 @@ describe Hamster::Hash do
         h
       end.size
       it "has the correct size after lots of addings and removings" do
-        h = Hamster.hash
+        h = H.empty
         random_actions.each do |(act, ob)|
           if act == :add
             h = h.put(ob, ob * 3)

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  let(:hash) { Hamster::Hash.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL") }
+  let(:hash) { H.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL") }
 
   describe "#slice" do
     let(:slice) { hash.slice(*values) }
@@ -16,7 +16,7 @@ describe Hamster::Hash do
 
       it "doesn't modify the original Hash" do
         slice
-        hash.should eql(Hamster::Hash.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"))
+        hash.should eql(H.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"))
       end
     end
 
@@ -29,12 +29,12 @@ describe Hamster::Hash do
 
       it "doesn't modify the original Hash" do
         slice
-        hash.should eql(Hamster::Hash.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"))
+        hash.should eql(H.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(:hash) { H.new('A' => 'aye', 'B' => 'bee') { 'nothing' }}
       let(:values) { ["B", nil] }
 
       it "maintains the default block" do

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  let(:hash) { Hamster.hash(a: 3, b: 2, c: 1) }
+  let(:hash) { H[a: 3, b: 2, c: 1] }
 
   describe "#sort" do
     it "returns a Vector of sorted key/val pairs" do
@@ -11,7 +11,7 @@ describe Hamster::Hash do
 
     it "works on large hashes" do
       array = (1..1000).map { |n| [n,n] }
-      Hamster::Hash.new(array.shuffle).sort.should eql(Hamster::Vector.new(array))
+      H.new(array.shuffle).sort.should eql(V.new(array))
     end
 
     it "uses block as comparator to sort if passed a block" do

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

@@ -3,18 +3,18 @@ require "hamster/hash"
 
 describe Hamster::Hash do
   describe "#store" do
-    let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
 
     context "with a unique key" do
       let(:result) { hash.store("D", "dee") }
 
       it "preserves the original" do
         result
-        hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+        hash.should eql(H["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"))
+        result.should eql(H["A" => "aye", "B" => "bee", "C" => "see", "D" => "dee"])
       end
     end
 
@@ -23,16 +23,38 @@ describe Hamster::Hash do
 
       it "preserves the original" do
         result
-        hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+        hash.should eql(H["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"))
+        result.should eql(H["A" => "aye", "B" => "bee", "C" => "sea"])
+      end
+    end
+
+    context "with duplicate key and identical value" do
+      let(:hash) { H["X" => 1, "Y" => 2] }
+      let(:result) { hash.store("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) { H[keys.zip(values)] }
+
+        it "returns the original hash unmodified for all changes" do
+          keys.each_with_index do |key, index|
+            result = hash.store(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') }
+      let(:hash) { H[DeterministicHash.new('a', 1) => 'aye'] }
 
       it "stores and can retrieve both" do
         result = hash.store(DeterministicHash.new('b', 1), 'bee')
@@ -44,7 +66,7 @@ describe Hamster::Hash do
     context "when a String is inserted as key and then mutated" do
       it "is not affected" do
         string = "a string!"
-        hash = Hamster.hash.store(string, 'a value!')
+        hash = H.empty.store(string, 'a value!')
         string.upcase!
         hash['a string!'].should == 'a value!'
         hash['A STRING!'].should be_nil

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+  let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
 
   describe "#take" do
     it "returns the first N key/val pairs from hash" do
@@ -29,7 +29,7 @@ describe Hamster::Hash do
 
     it "passes all elements if the block never returns nil/false" do
       passed = []
-      hash.take_while { |pair| passed << pair; true }.should == hash.to_a
+      hash.take_while { |k,v| passed << [k, v]; true }.should == hash.to_a
       passed.sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
     end
   end