hamster 1.0.1.pre.rc3 → 2.0.0

data/spec/lib/hamster/vector/include_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  [:include?, :member?, :contains?, :elem?].each do |method|
+  [:include?, :member?].each do |method|
     describe "##{method}" do
       [
         [[], "A", false],
@@ -22,7 +22,7 @@ describe Hamster::Vector do
       ].each do |values, item, expected|
         describe "on #{values.inspect}" do
           it "returns #{expected.inspect}" do
-            Hamster.vector(*values).send(method, item).should == expected
+            V[*values].send(method, item).should == expected
           end
         end
       end

data/spec/lib/hamster/vector/insert_spec.rb

@@ -4,7 +4,7 @@ require 'pry'
 
 describe Hamster::Vector do
   describe "#insert" do
-    let(:original) { Hamster.vector(1, 2, 3) }
+    let(:original) { V[1, 2, 3] }
 
     it "can add items at the beginning of a vector" do
       vector = original.insert(0, :a, :b)
@@ -48,7 +48,7 @@ describe Hamster::Vector do
     end
 
     it "works when adding to an empty Vector" do
-      Hamster.vector.insert(0, :a).should eql(Hamster.vector(:a))
+      V.empty.insert(0, :a).should eql(V[:a])
     end
 
     it "has the right size and contents after many insertions" do

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  let(:vector) { Hamster.vector(*values) }
+  let(:vector) { V[*values] }
 
   describe "#inspect" do
     let(:inspect) { vector.inspect }

data/spec/lib/hamster/vector/join_spec.rb

@@ -10,11 +10,11 @@ describe Hamster::Vector do
         [[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)], "A|B|C"]
       ].each do |values, expected|
         describe "on #{values.inspect}" do
-          let(:vector) { Hamster.vector(*values) }
+          let(:vector) { V[*values] }
 
           it "preserves the original" do
             vector.join("|")
-            vector.should eql(Hamster.vector(*values))
+            vector.should eql(V[*values])
           end
 
           it "returns #{expected.inspect}" do
@@ -31,11 +31,11 @@ describe Hamster::Vector do
         [[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)], "ABC"]
       ].each do |values, expected|
         describe "on #{values.inspect}" do
-          let(:vector) { Hamster.vector(*values) }
+          let(:vector) { V[*values] }
 
           it "preserves the original" do
             vector.join
-            vector.should eql(Hamster.vector(*values))
+            vector.should eql(V[*values])
           end
 
           it "returns #{expected.inspect}" do
@@ -51,7 +51,7 @@ describe Hamster::Vector do
 
       describe 'on ["A", "B", "C"]' do
         it 'returns "A**B**C"' do
-          Hamster::Vector["A", "B", "C"].join.should == "A**B**C"
+          V["A", "B", "C"].join.should == "A**B**C"
         end
       end
     end

data/spec/lib/hamster/vector/last_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  let(:vector) { Hamster.vector(*values) }
+  let(:vector) { V[*values] }
 
   describe "#last" do
     let(:last) { vector.last }

data/spec/lib/hamster/vector/length_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  let(:vector) { Hamster.vector(*values) }
+  let(:vector) { V[*values] }
 
   describe "#length" do
     let(:length) { vector.length }

data/spec/lib/hamster/vector/ltlt_spec.rb

@@ -2,13 +2,13 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  let(:vector) { Hamster.vector(*values) }
+  let(:vector) { V[*values] }
 
   describe "#<<" do
     let(:ltlt) { vector << added_value }
 
     shared_examples "checking adding values" do
-      let(:added_vector) { Hamster.vector(*added_values) }
+      let(:added_vector) { V[*added_values] }
 
       it "preserves the original" do
         original = vector

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

@@ -5,7 +5,7 @@ describe Hamster::Vector do
   [:map, :collect].each do |method|
     describe "##{method}" do
       context "when empty" do
-        let(:vector) { Hamster.vector }
+        let(:vector) { V.empty }
 
         it "returns self" do
           vector.send(method) {}.should equal(vector)
@@ -13,23 +13,23 @@ describe Hamster::Vector do
       end
 
       context "when not empty" do
-        let(:vector) { Hamster.vector("A", "B", "C") }
+        let(:vector) { V["A", "B", "C"] }
 
         context "with a block" do
           it "preserves the original values" do
             vector.send(method, &:downcase)
-            vector.should eql(Hamster.vector("A", "B", "C"))
+            vector.should eql(V["A", "B", "C"])
           end
 
           it "returns a new vector with the mapped values" do
-            vector.send(method, &:downcase).should eql(Hamster.vector("a", "b", "c"))
+            vector.send(method, &:downcase).should eql(V["a", "b", "c"])
           end
         end
 
         context "with no block" do
           it "returns an Enumerator" do
             vector.send(method).class.should be(Enumerator)
-            vector.send(method).each(&:downcase).should eql(Hamster.vector('a', 'b', 'c'))
+            vector.send(method).each(&:downcase).should eql(V['a', 'b', 'c'])
           end
         end
       end

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

@@ -7,7 +7,7 @@ describe Hamster::Vector do
       File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
     end
     let(:child_cmd) do
-      %Q|#{ruby} -I lib -r hamster -e 'vector = Hamster.vector(5, 10, 15); $stdout.write(Marshal.dump(vector))'|
+      %Q|#{ruby} -I lib -r hamster -e 'vector = Hamster::Vector[5, 10, 15]; $stdout.write(Marshal.dump(vector))'|
     end
 
     let(:reloaded_vector) do
@@ -19,7 +19,7 @@ describe Hamster::Vector do
     end
 
     it "can survive dumping and loading into a new process" do
-      expect(reloaded_vector).to eql(Hamster.vector(5, 10, 15))
+      expect(reloaded_vector).to eql(V[5, 10, 15])
     end
 
     it "is still possible to find items by index after loading" do

data/spec/lib/hamster/vector/maximum_spec.rb

@@ -2,32 +2,30 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  [:maximum, :max].each do |method|
-    describe "##{method}" do
-      context "with a block" do
-        [
-          [[], nil],
-          [["A"], "A"],
-          [%w[Ichi Ni San], "Ichi"],
-        ].each do |values, expected|
-          describe "on #{values.inspect}" do
-            it "returns #{expected.inspect}" do
-              Hamster.vector(*values).send(method) { |maximum, item| maximum.length <=> item.length }.should == expected
-            end
+  describe "#max" do
+    context "with a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "Ichi"],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            V[*values].max { |maximum, item| maximum.length <=> item.length }.should == expected
           end
         end
       end
+    end
 
-      context "without a block" do
-        [
-          [[], nil],
-          [["A"], "A"],
-          [%w[Ichi Ni San], "San"],
-        ].each do |values, expected|
-          describe "on #{values.inspect}" do
-            it "returns #{expected.inspect}" do
-              Hamster.vector(*values).send(method).should == expected
-            end
+    context "without a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "San"],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            V[*values].max.should == expected
           end
         end
       end

data/spec/lib/hamster/vector/minimum_spec.rb

@@ -2,32 +2,30 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  [:minimum, :min].each do |method|
-    describe "##{method}" do
-      context "with a block" do
-        [
-          [[], nil],
-          [["A"], "A"],
-          [%w[Ichi Ni San], "Ni"],
-        ].each do |values, expected|
-          describe "on #{values.inspect}" do
-            it "returns #{expected.inspect}" do
-              Hamster.vector(*values).send(method) { |minimum, item| minimum.length <=> item.length }.should == expected
-            end
+  describe "#min" do
+    context "with a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "Ni"],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            V[*values].min { |minimum, item| minimum.length <=> item.length }.should == expected
           end
         end
       end
+    end
 
-      context "without a block" do
-        [
-          [[], nil],
-          [["A"], "A"],
-          [%w[Ichi Ni San], "Ichi"],
-        ].each do |values, expected|
-          describe "on #{values.inspect}" do
-            it "returns #{expected.inspect}" do
-              Hamster.vector(*values).send(method).should == expected
-            end
+    context "without a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "Ichi"],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            V[*values].min.should == expected
           end
         end
       end

data/spec/lib/hamster/vector/multiply_spec.rb

@@ -3,7 +3,7 @@ require "hamster/vector"
 
 describe Hamster::Vector do
   describe "#*" do
-    let(:vector) { Hamster.vector(1, 2, 3) }
+    let(:vector) { V[1, 2, 3] }
 
     context "with a String argument" do
       it "acts just like #join" do
@@ -13,10 +13,10 @@ describe Hamster::Vector do
 
     context "with an Integer argument" do
       it "concatenates n copies of the array" do
-        (vector * 0).should eql(Hamster.vector)
+        (vector * 0).should eql(V.empty)
         (vector * 1).should eql(vector)
-        (vector * 2).should eql(Hamster.vector(1,2,3,1,2,3))
-        (vector * 3).should eql(Hamster.vector(1,2,3,1,2,3,1,2,3))
+        (vector * 2).should eql(V[1,2,3,1,2,3])
+        (vector * 3).should eql(V[1,2,3,1,2,3,1,2,3])
       end
 
       it "raises an ArgumentError if integer is negative" do

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

@@ -14,7 +14,7 @@ describe Hamster::Vector do
       [[4], [], [4]],
     ].each do |values, expected_matches, expected_remainder|
       describe "on #{values.inspect}" do
-        let(:vector) { Hamster.vector(*values) }
+        let(:vector) { V[*values] }
 
         describe "with a block" do
           let(:result)    { vector.partition(&:odd?) }
@@ -23,7 +23,7 @@ describe Hamster::Vector do
 
           it "preserves the original" do
             result
-            vector.should eql(Hamster.vector(*values))
+            vector.should eql(V[*values])
           end
 
           it "returns a frozen array with two items" do
@@ -33,18 +33,18 @@ describe Hamster::Vector do
           end
 
           it "correctly identifies the matches" do
-            matches.should eql(Hamster.vector(*expected_matches))
+            matches.should eql(V[*expected_matches])
           end
 
           it "correctly identifies the remainder" do
-            remainder.should eql(Hamster.vector(*expected_remainder))
+            remainder.should eql(V[*expected_remainder])
           end
         end
 
         describe "without a block" do
           it "returns an Enumerator" do
             vector.partition.class.should be(Enumerator)
-            vector.partition.each(&:odd?).should eql([Hamster::Vector.new(expected_matches), Hamster::Vector.new(expected_remainder)])
+            vector.partition.each(&:odd?).should eql([V.new(expected_matches), V.new(expected_remainder)])
           end
         end
       end

data/spec/lib/hamster/vector/permutation_spec.rb

@@ -3,7 +3,7 @@ require "hamster/vector"
 
 describe Hamster::Vector do
   describe "#permutation" do
-    let(:vector) { Hamster.vector(1,2,3,4) }
+    let(:vector) { V[1,2,3,4] }
 
     context "without a block or arguments" do
       it "returns an Enumerator of all permutations" do
@@ -51,7 +51,7 @@ describe Hamster::Vector do
     context "on an empty vector" do
       it "yields the empty permutation" do
         yielded = []
-        Hamster.vector.permutation { |obj| yielded << obj }
+        V.empty.permutation { |obj| yielded << obj }
         yielded.should eql([[]])
       end
     end
@@ -71,13 +71,13 @@ describe Hamster::Vector do
     end
 
     it "handles duplicate elements correctly" do
-      Hamster.vector(1,2,3,1).permutation(2).sort.should eql([[1,1], [1,1], [1,2], [1,2],
+      V[1,2,3,1].permutation(2).sort.should eql([[1,1], [1,1], [1,2], [1,2],
         [1,3], [1,3], [2,1],[2,1],[2,3], [3,1],[3,1],[3,2]])
     end
 
     it "leaves the original unmodified" do
       vector.permutation(2) {}
-      vector.should eql(Hamster.vector(1,2,3,4))
+      vector.should eql(V[1,2,3,4])
     end
 
     it "behaves like Array#permutation" do

data/spec/lib/hamster/vector/pop_spec.rb

@@ -11,15 +11,15 @@ describe Hamster::Vector do
       [1..33, 1..32]
     ].each do |values, expected|
       context "on #{values.inspect}" do
-        let(:vector) { Hamster.vector(*values) }
+        let(:vector) { V[*values] }
 
         it "preserves the original" do
           vector.pop
-          vector.should eql(Hamster.vector(*values))
+          vector.should eql(V[*values])
         end
 
         it "returns #{expected.inspect}" do
-          vector.pop.should eql(Hamster.vector(*expected))
+          vector.pop.should eql(V[*expected])
         end
       end
     end

data/spec/lib/hamster/vector/product_spec.rb

@@ -10,13 +10,13 @@ describe Hamster::Vector do
           [[2], 2],
           [[1, 3, 5, 7, 11], 1155],
         ].each do |values, expected|
-          Hamster.vector(*values).product.should == expected
+          V[*values].product.should == expected
         end
       end
     end
 
     context "when passed one or more vectors" do
-      let(:vector) { Hamster.vector(1,2,3) }
+      let(:vector) { V[1,2,3] }
 
       context "when passed a block" do
         it "yields an array for each combination of items from the vectors" do
@@ -25,7 +25,7 @@ describe Hamster::Vector do
           yielded.should eql([[1,1], [1,2], [1,3], [2,1], [2,2], [2,3], [3,1], [3,2], [3,3]])
 
           yielded = []
-          vector.product(Hamster.vector(3,4,5), Hamster.vector(6,8)) { |obj| yielded << obj }
+          vector.product(V[3,4,5], V[6,8]) { |obj| yielded << obj }
           yielded.should eql(
             [[1, 3, 6], [1, 3, 8], [1, 4, 6], [1, 4, 8], [1, 5, 6], [1, 5, 8],
              [2, 3, 6], [2, 3, 8], [2, 4, 6], [2, 4, 8], [2, 5, 6], [2, 5, 8],
@@ -33,15 +33,15 @@ describe Hamster::Vector do
         end
 
         it "returns self" do
-          vector.product(Hamster.vector) {}.should be(vector)
-          vector.product(Hamster.vector(1,2), Hamster.vector(3)) {}.should be(vector)
-          Hamster.vector.product(vector) {}.should be(Hamster.vector)
+          vector.product(V.empty) {}.should be(vector)
+          vector.product(V[1,2], V[3]) {}.should be(vector)
+          V.empty.product(vector) {}.should be(V.empty)
         end
       end
 
       context "when not passed a block" do
         it "returns the cartesian product in an array" do
-          Hamster.vector(1,2).product(Hamster.vector(3,4,5), Hamster.vector(6,8)).should eql(
+          V[1,2].product(V[3,4,5], V[6,8]).should eql(
             [[1, 3, 6], [1, 3, 8], [1, 4, 6], [1, 4, 8], [1, 5, 6], [1, 5, 8],
             [2, 3, 6], [2, 3, 8], [2, 4, 6], [2, 4, 8], [2, 5, 6], [2, 5, 8]])
         end
@@ -49,20 +49,20 @@ describe Hamster::Vector do
 
       context "when one of the arguments is empty" do
         it "returns an empty array" do
-          vector.product(Hamster.vector, Hamster.vector(4,5,6)).should eql([])
+          vector.product(V.empty, V[4,5,6]).should eql([])
         end
       end
 
       context "when the receiver is empty" do
         it "returns an empty array" do
-          Hamster.vector.product(vector, Hamster.vector(4,5,6)).should eql([])
+          V.empty.product(vector, V[4,5,6]).should eql([])
         end
       end
     end
 
     context "when passed one or more Arrays" do
       it "also calculates the cartesian product correctly" do
-        Hamster.vector(1,2).product([3,4,5], [6,8]).should eql(
+        V[1,2].product([3,4,5], [6,8]).should eql(
           [[1, 3, 6], [1, 3, 8], [1, 4, 6], [1, 4, 8], [1, 5, 6], [1, 5, 8],
           [2, 3, 6], [2, 3, 8], [2, 4, 6], [2, 4, 8], [2, 5, 6], [2, 5, 8]])
       end