hamster 1.0.1.pre.rc3 → 2.0.0

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

@@ -5,7 +5,7 @@ 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 }}
+        let(:hash) { H.new("A" => "aye") { |key| fail }}
 
         context "when the key exists" do
           it "returns the value associated with the key" do
@@ -13,13 +13,13 @@ describe Hamster::Hash do
           end
 
           it "does not call the default block even if the key is 'nil'" do
-            Hamster.hash(nil => 'something') { fail }.send(method, nil)
+            H.new(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|
+            H.new("A" => "aye") do |key|
               expect(key).to eq("B")
               "bee"
             end
@@ -32,7 +32,7 @@ describe Hamster::Hash do
       end
 
       context "with no default block" do
-        let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL") }
+        let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"] }
 
         [
           %w[A aye],
@@ -53,7 +53,7 @@ describe Hamster::Hash do
       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
+        H[foo: :bar].send(method, x).should be_nil
       end
 
       it "uses #eql? to compare keys with the same hash code" do
@@ -63,7 +63,7 @@ describe Hamster::Hash do
         y = double('y', hash: 42)
         y.should_receive(:eql?).and_return(true)
 
-        Hamster.hash(y => 1)[x].should == 1
+        H[y => 1][x].should == 1
       end
 
       it "does not use #eql? to compare keys with different hash codes" do
@@ -73,7 +73,7 @@ describe Hamster::Hash do
         y = double('y', hash: 1)
         y.should_not_receive(:eql?)
 
-        Hamster.hash(y => 1)[x].should be_nil
+        H[y => 1][x].should be_nil
       end
     end
   end

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

@@ -4,7 +4,7 @@ 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") }
+      let(:hash) { H["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
@@ -21,11 +21,11 @@ describe Hamster::Hash do
       end
 
       it "returns true if the key is found and maps to nil" do
-        Hamster.hash("A" => nil).send(method, "A").should == true
+        H["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
+        H["A" => false].send(method, "A").should == true
       end
     end
   end

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  let(:hash) { Hamster.hash(toast: 'buttered', jam: 'strawberry') }
+  let(:hash) { H[toast: 'buttered', jam: 'strawberry'] }
 
   [:value?, :has_value?].each do |method|
     describe "##{method}" do
@@ -15,12 +15,12 @@ describe Hamster::Hash do
       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
+        H[a: EqualNotEql.new].send(method, EqualNotEql.new).should == true
+        H[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))
+        large = H.new((1..1000).zip(2..1001))
         [2, 100, 200, 500, 900, 1000, 1001].each { |n| large.value?(n).should == true }
       end
     end

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

@@ -4,26 +4,26 @@ 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
+      (1..4000).each_slice(4).map { |ka, va, kb, vb| H[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
+      H["ka" => "va"].hash.should_not == H["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
+      H["ka" => "va"].hash.should_not == H["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
+      H.empty.put(key1, nil).put(key2, nil).hash.should == H.empty.put(key2, nil).put(key1, nil).hash
     end
 
     describe "on an empty hash" do
       it "returns 0" do
-        Hamster.hash.hash.should == 0
+        H.empty.hash.should == 0
       end
     end
   end

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

@@ -10,7 +10,7 @@ describe Hamster::Hash do
     ].each do |values, expected|
       describe "on #{values.inspect}" do
         it "returns #{expected.inspect}" do
-          Hamster.hash(*values).inspect.should == expected
+          H[*values].inspect.should == expected
         end
       end
     end
@@ -22,7 +22,7 @@ describe Hamster::Hash do
     ].each do |values|
       describe "on #{values.inspect}" do
         it "returns a string which can be eval'd to get an equivalent object" do
-          original = Hamster::Hash.new(values)
+          original = H.new(values)
           eval(original.inspect).should eql(original)
         end
       end

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

@@ -3,21 +3,21 @@ require "hamster/hash"
 
 describe Hamster::Hash do
   describe "#invert" do
-    let(:hash) { Hamster.hash(a: 3, b: 2, c: 1) }
+    let(:hash) { H[a: 3, b: 2, c: 1] }
 
     it "uses the existing keys as values and values as keys" do
-      hash.invert.should eql(Hamster.hash(3 => :a, 2 => :b, 1 => :c))
+      hash.invert.should eql(H[3 => :a, 2 => :b, 1 => :c])
     end
 
     it "will select one key/value pair among multiple which have same value" do
-      [Hamster.hash(1 => :a),
-       Hamster.hash(1 => :b),
-       Hamster.hash(1 => :c)].include?(Hamster.hash(a: 1, b: 1, c: 1).invert).should == true
+      [H[1 => :a],
+       H[1 => :b],
+       H[1 => :c]].include?(H[a: 1, b: 1, c: 1].invert).should == true
     end
 
     it "doesn't change the original Hash" do
       hash.invert
-      hash.should eql(Hamster.hash(a: 3, b: 2, c: 1))
+      hash.should eql(H[a: 3, b: 2, c: 1])
     end
 
     context "from a subclass of Hash" do

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

@@ -3,7 +3,7 @@ require "hamster/hash"
 
 describe Hamster::Hash do
   describe "#key" do
-    let(:hash) { Hamster.hash(a: 1, b: 1, c: 2, d: 3) }
+    let(:hash) { H[a: 1, b: 1, c: 2, d: 3] }
 
     it "returns a key associated with the given value, if there is one" do
       [:a, :b].include?(hash.key(1)).should == true
@@ -22,7 +22,7 @@ describe Hamster::Hash do
     end
 
     it "doesn't use default block if value is not found" do
-      Hamster.hash(a: 1) { fail }.key(2).should be_nil
+      H.new(a: 1) { fail }.key(2).should be_nil
     end
   end
 end

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

@@ -4,10 +4,10 @@ require "hamster/set"
 
 describe Hamster::Hash do
   describe "#keys" do
-    let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
 
     it "returns the keys as a set" do
-      hash.keys.should eql(Hamster.set("A", "B", "C"))
+      hash.keys.should eql(S["A", "B", "C"])
     end
 
     it "returns frozen String keys" do

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

@@ -6,23 +6,23 @@ describe Hamster::Hash do
     describe "##{method}" do
       context "when empty" do
         it "returns self" do
-          Hamster.hash.send(method) {}.should equal(Hamster.hash)
+          H.empty.send(method) {}.should equal(H.empty)
         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
           let(:mapped) { hash.send(method) { |key, value| [key.downcase, value.upcase] }}
 
           it "preserves the original values" do
             mapped
-            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 new hash with the mapped values" do
-            mapped.should eql(Hamster.hash("a" => "AYE", "b"  => "BEE", "c" => "SEE"))
+            mapped.should eql(H["a" => "AYE", "b"  => "BEE", "c" => "SEE"])
           end
         end
 

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

@@ -7,7 +7,7 @@ describe Hamster::Hash do
       File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
     end
     let(:child_cmd) do
-      %Q|#{ruby} -I lib -r hamster -e 'dict = Hamster.hash existing_key: 42, other_thing: "data"; $stdout.write(Marshal.dump(dict))'|
+      %Q|#{ruby} -I lib -r hamster -e 'dict = Hamster::Hash[existing_key: 42, other_thing: "data"]; $stdout.write(Marshal.dump(dict))'|
     end
 
     let(:reloaded_hash) do
@@ -19,7 +19,7 @@ describe Hamster::Hash do
     end
 
     it "can survive dumping and loading into a new process" do
-      expect(reloaded_hash).to eql(Hamster.hash(existing_key: 42, other_thing: "data"))
+      expect(reloaded_hash).to eql(H[existing_key: 42, other_thing: "data"])
     end
 
     it "is still possible to find items by key after loading" do

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

@@ -2,76 +2,82 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  [:merge, :+].each do |method|
-    describe "##{method}" do
-      [
-        [{}, {}, {}],
-        [{"A" => "aye"}, {}, {"A" => "aye"}],
-        [{"A" => "aye"}, {"A" => "bee"}, {"A" => "bee"}],
-        [{"A" => "aye"}, {"B" => "bee"}, {"A" => "aye", "B" => "bee"}],
-        [(1..300).zip(1..300), (150..450).zip(150..450), (1..450).zip(1..450)]
-      ].each do |a, b, expected|
-        context "for #{a.inspect} and #{b.inspect}" do
-          let(:hash_a) { Hamster.hash(a) }
-          let(:hash_b) { Hamster.hash(b) }
-          let(:result) { hash_a.send(method, hash_b) }
+  describe "#merge" do
+    [
+      [{}, {}, {}],
+      [{"A" => "aye"}, {}, {"A" => "aye"}],
+      [{"A" => "aye"}, {"A" => "bee"}, {"A" => "bee"}],
+      [{"A" => "aye"}, {"B" => "bee"}, {"A" => "aye", "B" => "bee"}],
+      [(1..300).zip(1..300), (150..450).zip(150..450), (1..450).zip(1..450)]
+    ].each do |a, b, expected|
+      context "for #{a.inspect} and #{b.inspect}" do
+        let(:hash_a) { H[a] }
+        let(:hash_b) { H[b] }
+        let(:result) { hash_a.merge(hash_b) }
 
-          it "returns #{expected.inspect} when passed a Hamster::Hash"  do
-            result.should eql(Hamster.hash(expected))
-          end
+        it "returns #{expected.inspect} when passed a Hamster::Hash"  do
+          result.should eql(H[expected])
+        end
 
-          it "returns #{expected.inspect} when passed a Ruby Hash" do
-            Hamster.hash(a).send(method, ::Hash[b]).should eql(Hamster.hash(expected))
-          end
+        it "returns #{expected.inspect} when passed a Ruby Hash" do
+          H[a].merge(::Hash[b]).should eql(H[expected])
+        end
 
-          it "doesn't change the original Hashes" do
-            result
-            hash_a.should eql(Hamster.hash(a))
-            hash_b.should eql(Hamster.hash(b))
-          end
+        it "doesn't change the original Hashes" do
+          result
+          hash_a.should eql(H[a])
+          hash_b.should eql(H[b])
         end
       end
+    end
 
-      context "when merging with an empty Hash" do
-        it "returns self" do
-          hash = Hamster.hash(a: 1, b: 2)
-          hash.send(method, Hamster.hash).should be(hash)
-        end
+    context "when merging with an empty Hash" do
+      it "returns self" do
+        hash = H[a: 1, b: 2]
+        hash.merge(H.empty).should be(hash)
       end
+    end
 
-      context "when called on a subclass" do
-        it "returns an instance of the subclass" do
-          subclass = Class.new(Hamster::Hash)
-          instance = subclass.new(a: 1, b: 2)
-          instance.merge(c: 3, d: 4).class.should be(subclass)
-        end
+    context "when merging with subset Hash" do
+      it "returns self" do
+        big_hash   = H[(1..300).zip(1..300)]
+        small_hash = H[(1..200).zip(1..200)]
+        big_hash.merge(small_hash).should be(big_hash)
       end
+    end
 
-      it "sets any duplicate key to the value of block if passed a block" do
-        h1 = Hamster.hash(:a => 2, :b => 1, :d => 5)
-        h2 = Hamster.hash(:a => -2, :b => 4, :c => -3)
-        r = h1.merge(h2) { |k,x,y| nil }
-        r.should eql(Hamster.hash(:a => nil, :b => nil, :c => -3, :d => 5))
+    context "when called on a subclass" do
+      it "returns an instance of the subclass" do
+        subclass = Class.new(Hamster::Hash)
+        instance = subclass.new(a: 1, b: 2)
+        instance.merge(c: 3, d: 4).class.should be(subclass)
+      end
+    end
 
-        r = h1.merge(h2) { |k,x,y| "#{k}:#{x+2*y}" }
-        r.should eql(Hamster.hash(:a => "a:-2", :b => "b:9", :c => -3, :d => 5))
+    it "sets any duplicate key to the value of block if passed a block" do
+      h1 = H[a: 2, b: 1, d: 5]
+      h2 = H[a: -2, b: 4, c: -3]
+      r = h1.merge(h2) { |k,x,y| nil }
+      r.should eql(H[a: nil, b: nil, c: -3, d: 5])
 
-        lambda {
-          h1.merge(h2) { |k, x, y| raise(IndexError) }
-        }.should raise_error(IndexError)
+      r = h1.merge(h2) { |k,x,y| "#{k}:#{x+2*y}" }
+      r.should eql(H[a: "a:-2", b: "b:9", c: -3, d: 5])
 
-        r = h1.merge(h1) { |k,x,y| :x }
-        r.should eql(Hamster.hash(:a => :x, :b => :x, :d => :x))
-      end
+      lambda {
+        h1.merge(h2) { |k, x, y| raise(IndexError) }
+      }.should raise_error(IndexError)
 
-      it "yields key/value pairs in the same order as #each" do
-        hash = Hamster.hash(a: 1, b: 2, c: 3)
-        each_pairs = []
-        merge_pairs = []
-        hash.each { |k, v| each_pairs << [k, v] }
-        hash.merge(hash) { |k, v1, v2| merge_pairs << [k, v1] }
-        each_pairs.should == merge_pairs
-      end
+      r = h1.merge(h1) { |k,x,y| :x }
+      r.should eql(H[a: :x, b: :x, d: :x])
+    end
+
+    it "yields key/value pairs in the same order as #each" do
+      hash = H[a: 1, b: 2, c: 3]
+      each_pairs = []
+      merge_pairs = []
+      hash.each { |k, v| each_pairs << [k, v] }
+      hash.merge(hash) { |k, v1, v2| merge_pairs << [k, v1] }
+      each_pairs.should == merge_pairs
     end
   end
 end

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

@@ -2,21 +2,17 @@ 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] }
 
-  [:min, :minimum].each do |method|
-    describe "##{method}" do
-      it "returns the smallest key/val pair" do
-        hash.send(method).should == ["a", 3]
-      end
+  describe "#min" do
+    it "returns the smallest key/val pair" do
+      hash.min.should == ["a", 3]
     end
   end
 
-  [:max, :maximum].each do |method|
-    describe "##{method}" do
-      it "returns the largest key/val pair" do
-        hash.send(method).should == ["c", 1]
-      end
+  describe "#max" do
+    it "returns the largest key/val pair" do
+      hash.max.should == ["c", 1]
     end
   end
 
@@ -30,7 +26,7 @@ describe Hamster::Hash do
     end
 
     it "returns nil if the hash is empty" do
-      Hamster.hash.min_by { |k,v| v }.should be_nil
+      H.empty.min_by { |k,v| v }.should be_nil
     end
   end
 
@@ -44,7 +40,7 @@ describe Hamster::Hash do
     end
 
     it "returns nil if the hash is empty" do
-      Hamster.hash.max_by { |k,v| v }.should be_nil
+      H.empty.max_by { |k,v| v }.should be_nil
     end
   end
 end