hamster 1.0.1.pre.rc3 → 2.0.0

data/spec/lib/hamster/hash/assoc_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 "#assoc" do
     it "searches for a key/val pair with a given key" do
@@ -18,7 +18,7 @@ describe Hamster::Hash do
     end
 
     it "returns nil even if there is a default" do
-      Hamster::Hash.new(a: 1, b: 2) { fail }.assoc(:c).should be_nil
+      H.new(a: 1, b: 2) { fail }.assoc(:c).should be_nil
     end
 
     it "uses #== to compare keys with provided object" do
@@ -41,7 +41,7 @@ describe Hamster::Hash do
     end
 
     it "returns nil even if there is a default" do
-      Hamster::Hash.new(a: 1, b: 2) { fail }.rassoc(3).should be_nil
+      H.new(a: 1, b: 2) { fail }.rassoc(3).should be_nil
     end
 
     it "uses #== to compare values with provided object" do

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

@@ -9,23 +9,23 @@ describe Hamster::Hash do
       ["A" => "aye", "B" => "bee", "C" => "see"],
     ].each do |values|
       context "on #{values}" do
-        let(:original) { Hamster.hash(*values) }
+        let(:original) { H[*values] }
         let(:result)   { original.clear }
 
         it "preserves the original" do
           result
-          original.should eql(Hamster.hash(*values))
+          original.should eql(H[*values])
         end
 
         it "returns an empty hash" do
-          result.should equal(Hamster.hash)
+          result.should equal(H.empty)
           result.should be_empty
         end
       end
     end
 
     it "maintains the default Proc, if there is one" do
-      hash = Hamster::Hash.new(a: 1) { 1 }
+      hash = H.new(a: 1) { 1 }
       hash.clear[:b].should == 1
       hash.clear[:c].should == 1
       hash.clear.default_proc.should_not be_nil

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

@@ -5,31 +5,31 @@ describe Hamster::Hash do
   describe ".hash" do
     context "with nothing" do
       it "returns the canonical empty hash" do
-        Hamster.hash.should be_empty
-        Hamster.hash.should equal(Hamster::EmptyHash)
+        H.empty.should be_empty
+        H.empty.should equal(Hamster::EmptyHash)
       end
     end
 
     context "with an implicit hash" do
-      let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+      let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
 
       it "is equivalent to repeatedly using #put" do
-        hash.should eql(Hamster.hash.put("A", "aye").put("B", "bee").put("C", "see"))
+        hash.should eql(H.empty.put("A", "aye").put("B", "bee").put("C", "see"))
         hash.size.should == 3
       end
     end
 
     context "with an array of pairs" do
-      let(:hash) { Hamster.hash([[:a, 1], [:b, 2]]) }
+      let(:hash) { H[[[:a, 1], [:b, 2]]] }
 
       it "initializes a new Hash" do
-        hash.should eql(Hamster.hash(a: 1, b: 2))
+        hash.should eql(H[a: 1, b: 2])
       end
     end
 
     context "with a Hamster::Hash" do
-      let(:hash) { Hamster.hash(a: 1, b: 2) }
-      let(:other) { Hamster.hash(hash) }
+      let(:hash) { H[a: 1, b: 2] }
+      let(:other) { H[hash] }
 
       it "initializes an equivalent Hash" do
         hash.should eql(other)

data/spec/lib/hamster/hash/copying_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"] }
 
   [:dup, :clone].each do |method|
     describe "##{method}" do

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

@@ -3,7 +3,7 @@ require "hamster/hash"
 
 describe Hamster::Hash do
   describe "#default_proc" do
-    let(:hash) { Hamster::Hash.new(1 => 2, 2 => 4) { |k| k * 2 } }
+    let(:hash) { H.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)
@@ -11,7 +11,7 @@ describe Hamster::Hash do
     end
 
     it "returns nil if no default block was given" do
-      Hamster.hash.default_proc.should be_nil
+      H.empty.default_proc.should be_nil
     end
 
     context "after a key/val pair are inserted" do
@@ -24,7 +24,7 @@ describe Hamster::Hash do
 
     context "after all key/val pairs are filtered out" do
       it "doesn't change" do
-        other = hash.remove { true }
+        other = hash.reject { true }
         other.default_proc.should be(hash.default_proc)
         other.default_proc.call(4).should == 8
       end

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

@@ -3,17 +3,17 @@ require "hamster/hash"
 
 describe Hamster::Hash do
   describe "#delete" do
-    let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+    let(:hash) { H["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"))
+        hash.should eql(H["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"))
+        result.should eql(H["A" => "aye", "C" => "see"])
       end
     end
 
@@ -21,7 +21,7 @@ describe Hamster::Hash do
       let(:result) { hash.delete("D") }
 
       it "preserves the original values" do
-        hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
       end
 
       it "returns self" do

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

@@ -2,9 +2,9 @@ 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"] }
 
-  [:each, :foreach, :each_pair].each do |method|
+  [:each, :each_pair].each do |method|
     describe "##{method}" do
       context "with a block (internal iteration)" do
         it "returns self" do
@@ -23,7 +23,7 @@ describe Hamster::Hash do
 
         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 = H[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']

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

@@ -3,7 +3,7 @@ require "hamster/hash"
 
 describe Hamster::Hash do
   describe "#each_with_index" do
-    let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
 
     describe "with a block (internal iteration)" do
       it "returns self" do

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

@@ -2,28 +2,26 @@ 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
+  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
+        H[*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
+    it "returns true for empty hashes which have a default block" do
+      H.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)
+      H.empty.should be_empty
+      H.empty.should be(Hamster::EmptyHash)
     end
 
     context "from a subclass" do

data/spec/lib/hamster/hash/eql_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 "#eql?" do
     it "returns false when comparing with a standard hash" do
@@ -51,11 +51,11 @@ describe Hamster::Hash do
       ].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
+            H[a].send(method, H[b]).should == expected
           end
 
           it "for #{b.inspect} and #{a.inspect}" do
-            Hamster.hash(b).send(method, Hamster.hash(a)).should == expected
+            H[b].send(method, H[a]).should == expected
           end
         end
       end
@@ -63,7 +63,7 @@ describe Hamster::Hash do
   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 = H.new((1..1000).zip(2..1001))
     hash.put('a', 1).delete('a').should == hash
     hash.put('b', 2).delete('b').should eql(hash)
   end

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

@@ -3,33 +3,33 @@ require "hamster/hash"
 
 describe Hamster::Hash do
   describe "#except" 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 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"))
+        hash.except("B", nil).should eql(H["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"))
+        hash.should eql(H["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"))
+        hash.except("B", "A", 3).should eql(H["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"))
+        hash.should eql(H["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))
+      original = H.new(keys.zip(2..1001))
       100.times do
         to_remove = rand(100).times.collect { keys.sample }
         result    = original.except(*to_remove)
@@ -37,7 +37,7 @@ describe Hamster::Hash do
         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
+      original.should eql(H.new(keys.zip(2..1001))) # shouldn't have changed
     end
   end
 end

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

@@ -6,13 +6,13 @@ describe Hamster::Hash 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"
+          H["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)
+          -> { H["A" => "aye"].fetch("B") }.should raise_error(KeyError)
         end
       end
     end
@@ -20,13 +20,13 @@ describe Hamster::Hash do
     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"
+          H["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"
+          H["A" => "aye"].fetch("B", "default").should == "default"
         end
       end
     end
@@ -34,25 +34,25 @@ describe Hamster::Hash do
     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"
+          H["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"
+          H["A" => "aye"].fetch("B") { |key| key.should == "B" }
+          H["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'
+      H["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)
+      -> { H.empty.fetch }.should raise_error(ArgumentError)
+      -> { H.empty.fetch(1, 2, 3) }.should raise_error(ArgumentError)
     end
   end
 end

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

@@ -16,7 +16,7 @@ describe Hamster::Hash do
         [["A" => "aye", "B" => "bee", nil => "NIL"], "C", nil],
       ].each do |values, key, expected|
         describe "on #{values.inspect}" do
-          let(:hash) { Hamster.hash(*values) }
+          let(:hash) { H[*values] }
 
           describe "with a block" do
             it "returns #{expected.inspect}" do
@@ -36,7 +36,7 @@ describe Hamster::Hash do
 
       it "stops iterating when the block returns true" do
         yielded = []
-        Hamster.hash(a: 1, b: 2).find { |k,v| yielded << k; true }
+        H[a: 1, b: 2].find { |k,v| yielded << k; true }
         yielded.size.should == 1
       end
     end

data/spec/lib/hamster/hash/flat_map_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 "#flat_map" do
     it "yields each key/val pair" do
@@ -13,13 +13,13 @@ describe Hamster::Hash do
 
     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']
+      hash.flat_map { |k,v| L[k,v] }.sort.should == ['A', 'B', 'C', 'aye', 'bee', 'see']
+      hash.flat_map { |k,v| V[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"))
+      hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
     end
 
     context "with no block" do

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

@@ -5,14 +5,14 @@ describe Hamster::Hash do
   describe "#flatten" do
     context "with flatten depth of zero" do
       it "returns a vector of keys/value" do
-        hash = Hamster.hash(a: 1, b: 2)
+        hash = H[a: 1, b: 2]
         hash.flatten(0).sort.should eql(V[[:a, 1], [:b, 2]])
       end
     end
 
     context "without array keys or values" do
       it "returns a vector of keys and values" do
-        hash = Hamster.hash(a: 1, b: 2, c: 3)
+        hash = H[a: 1, b: 2, c: 3]
         possibilities = [[:a, 1, :b, 2, :c, 3],
          [:a, 1, :c, 3, :b, 2],
          [:b, 2, :a, 1, :c, 3],
@@ -27,22 +27,22 @@ describe Hamster::Hash do
       end
 
       it "doesn't modify the receiver" do
-        hash = Hamster.hash(a: 1, b: 2, c: 3)
+        hash = H[a: 1, b: 2, c: 3]
         hash.flatten(1)
         hash.flatten(2)
-        hash.should eql(Hamster.hash(a: 1, b: 2, c: 3))
+        hash.should eql(H[a: 1, b: 2, c: 3])
       end
     end
 
     context "on an empty Hash" do
       it "returns an empty Vector" do
-        Hamster.hash.flatten.should eql(V[])
+        H.empty.flatten.should eql(V.empty)
       end
     end
 
     context "with array keys" do
       it "flattens array keys into returned vector if flatten depth is sufficient" do
-        hash = Hamster.hash([1, 2] => 3, [4, 5] => 6)
+        hash = H[[1, 2] => 3, [4, 5] => 6]
         [[[1, 2], 3, [4, 5], 6], [[4, 5], 6, [1, 2], 3]].include?(hash.flatten(1)).should == true
         [[[1, 2], 3, [4, 5], 6], [[4, 5], 6, [1, 2], 3]].include?(hash.flatten).should == true
         hash.flatten(1).class.should be(Hamster::Vector)
@@ -51,16 +51,16 @@ describe Hamster::Hash do
       end
 
       it "doesn't modify the receiver (or its contents)" do
-        hash = Hamster.hash([1, 2] => 3, [4, 5] => 6)
+        hash = H[[1, 2] => 3, [4, 5] => 6]
         hash.flatten(1)
         hash.flatten(2)
-        hash.should eql(Hamster.hash([1, 2] => 3, [4, 5] => 6))
+        hash.should eql(H[[1, 2] => 3, [4, 5] => 6])
       end
     end
 
     context "with array values" do
       it "flattens array values into returned vector if flatten depth is sufficient" do
-        hash = Hamster.hash(1 => [2, 3], 4 => [5, 6])
+        hash = H[1 => [2, 3], 4 => [5, 6]]
         [[1, [2, 3], 4, [5, 6]], [4, [5, 6], 1, [2, 3]]].include?(hash.flatten(1)).should == true
         [[1, [2, 3], 4, [5, 6]], [4, [5, 6], 1, [2, 3]]].include?(hash.flatten).should == true
         [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(2)).should == true
@@ -69,16 +69,16 @@ describe Hamster::Hash do
       end
 
       it "doesn't modify the receiver (or its contents)" do
-        hash = Hamster.hash(1 => [2, 3], 4 => [5, 6])
+        hash = H[1 => [2, 3], 4 => [5, 6]]
         hash.flatten(1)
         hash.flatten(2)
-        hash.should eql(Hamster.hash(1 => [2, 3], 4 => [5, 6]))
+        hash.should eql(H[1 => [2, 3], 4 => [5, 6]])
       end
     end
 
     context "with vector keys" do
       it "flattens vector keys into returned vector if flatten depth is sufficient" do
-        hash = Hamster.hash(V[1, 2] => 3, V[4, 5] => 6)
+        hash = H[V[1, 2] => 3, V[4, 5] => 6]
         [[V[1, 2], 3, V[4, 5], 6], [V[4, 5], 6, V[1, 2], 3]].include?(hash.flatten).should == true
         [[V[1, 2], 3, V[4, 5], 6], [V[4, 5], 6, V[1, 2], 3]].include?(hash.flatten(1)).should == true
         [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(2)).should == true
@@ -88,7 +88,7 @@ describe Hamster::Hash do
 
     context "with vector values" do
       it "flattens vector values into returned vector if flatten depth is sufficient" do
-        hash = Hamster.hash(1 => V[2, 3], 4 => V[5, 6])
+        hash = H[1 => V[2, 3], 4 => V[5, 6]]
         [[1, V[2, 3], 4, V[5, 6]], [4, V[5, 6], 1, V[2, 3]]].include?(hash.flatten(1)).should == true
         [[1, V[2, 3], 4, V[5, 6]], [4, V[5, 6], 1, V[2, 3]]].include?(hash.flatten).should == true
         [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(2)).should == true