hamster 1.0.1.pre.rc3 → 2.0.0

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

@@ -0,0 +1,175 @@
+require "spec_helper"
+require "hamster/vector"
+
+describe Hamster::Vector do
+  let(:vector) { V[*values] }
+
+  describe "#put" do
+    context "when empty" do
+      let(:vector) { V.empty }
+
+      it "raises an error for index -1" do
+        expect { vector.put(-1, :a) }.to raise_error
+      end
+
+      it "allows indexes 0 and 1 to be put" do
+        vector.put(0, :a).should eql(V[:a])
+        vector.put(1, :a).should eql(V[nil, :a])
+      end
+    end
+
+    context "when not empty" do
+      let(:vector) { V["A", "B", "C"] }
+
+      context "with a block" do
+        context "and a positive index" do
+          context "within the absolute bounds of the vector" do
+            it "passes the current value to the block" do
+              vector.put(1) { |value| value.should == "B" }
+            end
+
+            it "replaces the value with the result of the block" do
+              result = vector.put(1) { |value| "FLIBBLE" }
+              result.should eql(V["A", "FLIBBLE", "C"])
+            end
+
+            it "supports to_proc methods" do
+              result = vector.put(1, &:downcase)
+              result.should eql(V["A", "b", "C"])
+            end
+          end
+
+          context "just past the end of the vector" do
+            it "passes nil to the block and adds a new value" do
+              result = vector.put(3) { |value| value.should be_nil; "D" }
+              result.should eql(V["A", "B", "C", "D"])
+            end
+          end
+
+          context "further outside the bounds of the vector" do
+            it "passes nil to the block, fills up missing nils, and adds a new value" do
+              result = vector.put(5) { |value| value.should be_nil; "D" }
+              result.should eql(V["A", "B", "C", nil, nil, "D"])
+            end
+          end
+        end
+
+        context "and a negative index" do
+          context "within the absolute bounds of the vector" do
+            it "passes the current value to the block" do
+              vector.put(-2) { |value| value.should == "B" }
+            end
+
+            it "replaces the value with the result of the block" do
+              result = vector.put(-2) { |value| "FLIBBLE" }
+              result.should eql(V["A", "FLIBBLE", "C"])
+            end
+
+            it "supports to_proc methods" do
+              result = vector.put(-2, &:downcase)
+              result.should eql(V["A", "b", "C"])
+            end
+          end
+
+          context "outside the absolute bounds of the vector" do
+            it "raises an error" do
+              expect { vector.put(-vector.size.next) {} }.to raise_error
+            end
+          end
+        end
+      end
+
+      context "with a value" do
+        context "and a positive index" do
+          context "within the absolute bounds of the vector" do
+            let(:put) { vector.put(1, "FLIBBLE") }
+
+            it "preserves the original" do
+              vector.should eql(V["A", "B", "C"])
+            end
+
+            it "puts the new value at the specified index" do
+              put.should eql(V["A", "FLIBBLE", "C"])
+            end
+          end
+
+          context "just past the end of the vector" do
+            it "adds a new value" do
+              result = vector.put(3, "FLIBBLE")
+              result.should eql(V["A", "B", "C", "FLIBBLE"])
+            end
+          end
+
+          context "outside the absolute bounds of the vector" do
+            it "fills up with nils" do
+              result = vector.put(5, "FLIBBLE")
+              result.should eql(V["A", "B", "C", nil, nil, "FLIBBLE"])
+            end
+          end
+        end
+
+        context "with a negative index" do
+          let(:put) { vector.put(-2, "FLIBBLE") }
+
+          it "preserves the original" do
+            put
+            vector.should eql(V["A", "B", "C"])
+          end
+
+          it "puts the new value at the specified index" do
+            put.should eql(V["A", "FLIBBLE", "C"])
+          end
+        end
+
+        context "outside the absolute bounds of the vector" do
+          it "raises an error" do
+            expect { vector.put(-vector.size.next, "FLIBBLE") }.to raise_error
+          end
+        end
+      end
+    end
+
+    context "from a subclass" do
+      it "returns an instance of the subclass" do
+        subclass = Class.new(Hamster::Vector)
+        instance = subclass[1,2,3]
+        instance.put(1, 2.5).class.should be(subclass)
+      end
+    end
+
+    [10, 31, 32, 33, 1000, 1023, 1024, 1025, 2000].each do |size|
+      context "on a #{size}-item vector" do
+        it "works correctly" do
+          array = (1..size).to_a
+          vector = V.new(array)
+
+          [0, 1, 10, 31, 32, 33, 100, 500, 1000, 1023, 1024, 1025, 1998, 1999].select { |n| n < size }.each do |i|
+            value = rand(10000)
+            array[i] = value
+            vector = vector.put(i, value)
+            vector[i].should be(value)
+          end
+
+          0.upto(size-1) do |i|
+            vector.get(i).should == array[i]
+          end
+        end
+      end
+    end
+
+    context "with an identical value to an existing item" do
+      [1, 2, 5, 31,32, 33, 100, 200].each do |size|
+        context "on a #{size}-item vector" do
+          let(:array) { (0...size).map { |x| x * x} }
+          let(:vector) { V.new(array) }
+
+          it "returns self" do
+            (0...size).each do |index|
+              vector.put(index, index * index).should equal(vector)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  [:reduce, :inject, :fold].each do |method|
+  [:reduce, :inject].each do |method|
     describe "##{method}" do
       [
         [[], 10, 10],
@@ -10,7 +10,7 @@ describe Hamster::Vector do
         [[1, 2, 3], 10, 4],
       ].each do |values, initial, expected|
         describe "on #{values.inspect}" do
-          let(:vector) { Hamster.vector(*values) }
+          let(:vector) { V[*values] }
 
           describe "with an initial value of #{initial}" do
             describe "and a block" do
@@ -28,7 +28,7 @@ describe Hamster::Vector do
         [[1, 2, 3], -4],
       ].each do |values, expected|
         describe "on #{values.inspect}" do
-          let(:vector) { Hamster.vector(*values) }
+          let(:vector) { V[*values] }
 
           describe "with no initial value" do
             describe "and a block" do
@@ -42,67 +42,15 @@ describe Hamster::Vector do
 
       describe "with no block and a symbol argument" do
         it "uses the symbol as the name of a method to reduce with" do
-          Hamster.vector(1, 2, 3).send(method, :+).should == 6
+          V[1, 2, 3].send(method, :+).should == 6
         end
       end
 
       describe "with no block and a string argument" do
         it "uses the string as the name of a method to reduce with" do
-          Hamster.vector(1, 2, 3).send(method, '+').should == 6
+          V[1, 2, 3].send(method, '+').should == 6
         end
       end
     end
   end
-
-    describe "#foldr" do
-    [
-      [[], 10, 10],
-      [[1], 10, 9],
-      [[1, 2, 3], 10, 4],
-    ].each do |values, initial, expected|
-
-      describe "on #{values.inspect}" do
-        let(:vector) { Hamster.vector(*values) }
-
-        describe "with an initial value of #{initial}" do
-          describe "and a block" do
-            it "returns #{expected.inspect}" do
-              vector.foldr(initial) { |memo, item| memo - item }.should == expected
-            end
-          end
-        end
-      end
-    end
-
-    [
-      [[], nil],
-      [[1], 1],
-      [[1, 2, 3], 0],
-      [[1, 2, 3, 4], -2]
-    ].each do |values, expected|
-      describe "on #{values.inspect}" do
-        let(:vector) { Hamster.vector(*values) }
-
-        describe "with no initial value" do
-          describe "and a block" do
-            it "returns #{expected.inspect}" do
-              vector.foldr { |memo, item| memo - item }.should == expected
-            end
-          end
-        end
-      end
-    end
-
-    describe "with no block and a symbol argument" do
-      it "uses the symbol as the name of a method to reduce with" do
-        Hamster.vector(1, 2, 3).foldr(:+).should == 6
-      end
-    end
-
-    describe "with no block and a string argument" do
-      it "uses the string as the name of a method to reduce with" do
-        Hamster.vector(1, 2, 3).foldr('+').should == 6
-      end
-    end
-  end
 end

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  [:remove, :reject, :delete_if].each do |method|
+  [:reject, :delete_if].each do |method|
     describe "##{method}" do
       [
         [[], []],
@@ -12,18 +12,18 @@ describe Hamster::Vector do
         [%w[a b c], []],
       ].each do |values, expected|
         describe "on #{values.inspect}" do
-          let(:vector) { Hamster.vector(*values) }
+          let(:vector) { V[*values] }
 
           context "with a block" do
             it "returns #{expected.inspect}" do
-              vector.send(method) { |item| item == item.downcase }.should eql(Hamster.vector(*expected))
+              vector.send(method) { |item| item == item.downcase }.should eql(V[*expected])
             end
           end
 
           context "without a block" do
             it "returns an Enumerator" do
               vector.send(method).class.should be(Enumerator)
-              vector.send(method).each { |item| item == item.downcase }.should eql(Hamster.vector(*expected))
+              vector.send(method).each { |item| item == item.downcase }.should eql(V[*expected])
             end
           end
         end

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

@@ -3,7 +3,7 @@ require "hamster/vector"
 
 describe Hamster::Vector do
   describe "#repeated_combination" do
-    let(:vector) { Hamster.vector(1,2,3,4) }
+    let(:vector) { V[1,2,3,4] }
 
     context "with no block" do
       it "returns an Enumerator" do
@@ -44,7 +44,7 @@ describe Hamster::Vector do
     context "on an empty vector, with an argument greater than zero" do
       it "yields nothing" do
         result = []
-        Hamster.vector.repeated_combination(1) { |obj| result << obj }
+        V.empty.repeated_combination(1) { |obj| result << obj }
         result.should eql([])
       end
     end
@@ -55,14 +55,14 @@ describe Hamster::Vector do
         vector.repeated_combination(3).to_a.should == [[1,1,1], [1,1,2], [1,1,3], [1,1,4],
           [1,2,2], [1,2,3], [1,2,4], [1,3,3], [1,3,4], [1,4,4], [2,2,2], [2,2,3],
           [2,2,4], [2,3,3], [2,3,4], [2,4,4], [3,3,3], [3,3,4], [3,4,4], [4,4,4]]
-        Hamster.vector(1,2,3).repeated_combination(3).to_a.should == [[1,1,1], [1,1,2],
+        V[1,2,3].repeated_combination(3).to_a.should == [[1,1,1], [1,1,2],
           [1,1,3], [1,2,2], [1,2,3], [1,3,3], [2,2,2], [2,2,3], [2,3,3], [3,3,3]]
       end
     end
 
     it "leaves the original unmodified" do
       vector.repeated_combination(2) {}
-      vector.should eql(Hamster.vector(1,2,3,4))
+      vector.should eql(V[1,2,3,4])
     end
 
     it "behaves like Array#repeated_combination" do

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

@@ -3,7 +3,7 @@ require "hamster/vector"
 
 describe Hamster::Vector do
   describe "#repeated_permutation" do
-    let(:vector) { Hamster.vector(1,2,3,4) }
+    let(:vector) { V[1,2,3,4] }
 
     context "without a block" do
       context "and without argument" do
@@ -31,7 +31,7 @@ describe Hamster::Vector do
       context "on an empty vector" do
         it "yields the empty permutation" do
           yielded = []
-          Hamster.vector.repeated_permutation { |obj| yielded << obj }
+          V.empty.repeated_permutation { |obj| yielded << obj }
           yielded.should eql([[]])
         end
       end
@@ -47,7 +47,7 @@ describe Hamster::Vector do
       context "with no argument" do
         it "yields all repeated permutations" do
           yielded = []
-          Hamster.vector(1,2,3).repeated_permutation { |obj| yielded << obj }
+          V[1,2,3].repeated_permutation { |obj| yielded << obj }
           yielded.sort.should eql([[1,1,1], [1,1,2], [1,1,3], [1,2,1], [1,2,2],
             [1,2,3], [1,3,1], [1,3,2], [1,3,3], [2,1,1], [2,1,2], [2,1,3], [2,2,1],
             [2,2,2], [2,2,3], [2,3,1], [2,3,2], [2,3,3], [3,1,1], [3,1,2], [3,1,3],
@@ -66,12 +66,12 @@ describe Hamster::Vector do
     end
 
     it "handles duplicate elements correctly" do
-    Hamster.vector(10,11,10).repeated_permutation(2).sort.should eql([[10, 10], [10, 10],
+    V[10,11,10].repeated_permutation(2).sort.should eql([[10, 10], [10, 10],
       [10, 10], [10, 10], [10, 11], [10, 11], [11, 10], [11, 10], [11, 11]])
     end
 
     it "allows permutations larger than the number of elements" do
-      Hamster.vector(1,2).repeated_permutation(3).sort.should eql(
+      V[1,2].repeated_permutation(3).sort.should eql(
         [[1, 1, 1], [1, 1, 2], [1, 2, 1],
          [1, 2, 2], [2, 1, 1], [2, 1, 2],
          [2, 2, 1], [2, 2, 2]])
@@ -79,7 +79,7 @@ describe Hamster::Vector do
 
     it "leaves the original unmodified" do
       vector.repeated_permutation(2) {}
-      vector.should eql(Hamster.vector(1,2,3,4))
+      vector.should eql(V[1,2,3,4])
     end
 
     it "behaves like Array#repeated_permutation" do

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

@@ -5,7 +5,7 @@ describe Hamster::Vector do
   describe "#reverse_each" do
     [2, 31, 32, 33, 1000, 1024, 1025, 2000].each do |size|
       context "on a #{size}-item vector" do
-        let(:vector) { Hamster.vector(1..size) }
+        let(:vector) { V[1..size] }
 
         context "with a block (internal iteration)" do
           it "returns self" do

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

@@ -14,7 +14,7 @@ describe Hamster::Vector do
     ].each do |initial, expected|
       describe "on #{initial}" do
         it "returns #{expected}" do
-          Hamster::Vector.new(initial).reverse.should eql(Hamster::Vector.new(expected))
+          V.new(initial).reverse.should eql(V.new(expected))
         end
       end
     end

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

@@ -3,7 +3,7 @@ require "hamster/vector"
 
 describe Hamster::Vector do
   describe "#rindex" do
-    let(:vector) { Hamster.vector(1,2,3,3,2,1) }
+    let(:vector) { V[1,2,3,3,2,1] }
 
     context "when passed an object present in the vector" do
       it "returns the last index where the object is present" do

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

@@ -3,27 +3,27 @@ require "hamster/vector"
 
 describe Hamster::Vector do
   describe "#rotate" do
-    let(:vector) { Hamster.vector(1,2,3,4,5) }
+    let(:vector) { V[1,2,3,4,5] }
 
     context "when passed no argument" do
       it "returns a new vector with the first element moved to the end" do
-        vector.rotate.should eql(Hamster.vector(2,3,4,5,1))
+        vector.rotate.should eql(V[2,3,4,5,1])
       end
     end
 
     context "with an integral argument n" do
       it "returns a new vector with the first (n % size) elements moved to the end" do
-        vector.rotate(2).should eql(Hamster.vector(3,4,5,1,2))
-        vector.rotate(3).should eql(Hamster.vector(4,5,1,2,3))
-        vector.rotate(4).should eql(Hamster.vector(5,1,2,3,4))
-        vector.rotate(5).should eql(Hamster.vector(1,2,3,4,5))
-        vector.rotate(-1).should eql(Hamster.vector(5,1,2,3,4))
+        vector.rotate(2).should eql(V[3,4,5,1,2])
+        vector.rotate(3).should eql(V[4,5,1,2,3])
+        vector.rotate(4).should eql(V[5,1,2,3,4])
+        vector.rotate(5).should eql(V[1,2,3,4,5])
+        vector.rotate(-1).should eql(V[5,1,2,3,4])
       end
     end
 
     context "with a floating-point argument n" do
       it "coerces the argument to integer using to_int" do
-        vector.rotate(2.1).should eql(Hamster.vector(3,4,5,1,2))
+        vector.rotate(2.1).should eql(V[3,4,5,1,2])
       end
     end
 
@@ -68,7 +68,7 @@ describe Hamster::Vector do
 
     it "leaves the original unmodified" do
       vector.rotate(3)
-      vector.should eql(Hamster.vector(1,2,3,4,5))
+      vector.should eql(V[1,2,3,4,5])
     end
   end
 end