hamster 1.0.1.pre.rc2 → 1.0.1.pre.rc3

data/spec/{hamster → lib/hamster}/vector/last_spec.rb

@@ -13,25 +13,34 @@ describe Hamster::Vector do
       end
     end
 
-    context "with an empty array" do
+    context "with an empty vector" do
       let(:last_item) { nil }
       let(:values) { [] }
 
       include_examples "checking values"
     end
 
-    context "with a single item array" do
+    context "with a single item vector" do
       let(:last_item) { "A" }
       let(:values) { %w[A] }
 
       include_examples "checking values"
     end
 
-    context "with a multi-item array" do
+    context "with a multi-item vector" do
       let(:last_item) { "B" }
       let(:values) { %w[A B] }
 
       include_examples "checking values"
     end
+
+    [31, 32, 33, 1023, 1024, 1025].each do |size|
+      context "with a #{size}-item vector" do
+        let(:last_item) { size }
+        let(:values) { (1..size).to_a }
+
+        include_examples "checking values"
+      end
+    end
   end
 end

data/spec/{hamster → lib/hamster}/vector/length_spec.rb

@@ -13,25 +13,34 @@ describe Hamster::Vector do
       end
     end
 
-    context "with an empty array" do
+    context "with an empty vector" do
       let(:values) { [] }
       let(:size) { 0 }
 
       include_examples "checking size"
     end
 
-    context "with a single item array" do
+    context "with a single item vector" do
       let(:values) { %w[A] }
       let(:size) { 1 }
 
       include_examples "checking size"
     end
 
-    context "with a multi-item array" do
+    context "with a multi-item vector" do
       let(:values) { %w[A B] }
       let(:size) { 2 }
 
       include_examples "checking size"
     end
+
+    [31, 32, 33, 1023, 1024, 1025].each do |size|
+      context "with a #{size}-item vector" do
+        let(:values) { (1..size).to_a }
+        let(:size) { size }
+
+        include_examples "checking size"
+      end
+    end
   end
 end

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

@@ -11,9 +11,9 @@ describe Hamster::Vector do
       let(:added_vector) { Hamster.vector(*added_values) }
 
       it "preserves the original" do
-        orignal = vector
+        original = vector
         vector << added_value
-        expect(orignal).to eq(vector)
+        expect(original).to eq(vector)
       end
 
       it "ltlts the item to the vector" do
@@ -44,5 +44,23 @@ describe Hamster::Vector do
 
       include_examples "checking adding values"
     end
+
+    [31, 32, 33, 1023, 1024, 1025].each do |size|
+      context "with a #{size}-item vector adding a different item" do
+        let(:values) { (1..size).to_a }
+        let(:added_value) { size+1 }
+        let(:added_values) { (1..(size+1)).to_a }
+
+        include_examples "checking adding values"
+      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 << 4).class.should be(subclass)
+      end
+    end
   end
 end

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

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "hamster/vector"
+
+describe Hamster::Vector do
+  [:map, :collect].each do |method|
+    describe "##{method}" do
+      context "when empty" do
+        let(:vector) { Hamster.vector }
+
+        it "returns self" do
+          vector.send(method) {}.should equal(vector)
+        end
+      end
+
+      context "when not empty" do
+        let(:vector) { Hamster.vector("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"))
+          end
+
+          it "returns a new vector with the mapped values" do
+            vector.send(method, &:downcase).should eql(Hamster.vector("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'))
+          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.map { |x| x + 1 }.class.should be(subclass)
+        end
+      end
+
+      context "on a large vector" do
+        it "works" do
+          V.new(1..2000).map { |x| x * 2 }.should eql(V.new((1..2000).map { |x| x * 2}))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require "spec_helper"
+require "hamster/vector"
+
+describe Hamster::Vector do
+  describe "#marshal_dump/#marshal_load" do
+    let(:ruby) 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))'|
+    end
+
+    let(:reloaded_vector) do
+      IO.popen(child_cmd, "r+") do |child|
+        reloaded_vector = Marshal.load(child)
+        child.close
+        reloaded_vector
+      end
+    end
+
+    it "can survive dumping and loading into a new process" do
+      expect(reloaded_vector).to eql(Hamster.vector(5, 10, 15))
+    end
+
+    it "is still possible to find items by index after loading" do
+      expect(reloaded_vector[0]).to eq(5)
+      expect(reloaded_vector[1]).to eq(10)
+      expect(reloaded_vector[2]).to eq(15)
+      expect(reloaded_vector.size).to eq(3)
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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
+          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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+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
+          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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require "spec_helper"
+require "hamster/vector"
+
+describe Hamster::Vector do
+  describe "#*" do
+    let(:vector) { Hamster.vector(1, 2, 3) }
+
+    context "with a String argument" do
+      it "acts just like #join" do
+        (vector * 'boo').should eql(vector.join('boo'))
+      end
+    end
+
+    context "with an Integer argument" do
+      it "concatenates n copies of the array" do
+        (vector * 0).should eql(Hamster.vector)
+        (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))
+      end
+
+      it "raises an ArgumentError if integer is negative" do
+        -> { vector * -1 }.should raise_error(ArgumentError)
+      end
+
+      it "works on large vectors" do
+        array = (1..50).to_a
+        (V.new(array) * 25).should eql(V.new(array * 25))
+      end
+    end
+
+    context "with a subclass of Vector" do
+      it "returns an instance of the subclass" do
+        subclass = Class.new(Hamster::Vector)
+        instance = subclass.new([1,2,3])
+        (instance * 10).class.should be(subclass)
+      end
+    end
+
+    it "raises a TypeError if passed nil" do
+      -> { vector * nil }.should raise_error(TypeError)
+    end
+
+    it "raises an ArgumentError if passed no arguments" do
+      -> { vector.* }.should raise_error(ArgumentError)
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require "spec_helper"
+require "hamster/vector"
+
+describe Hamster::Vector do
+  describe ".new" do
+    it "accepts a single enumerable argument and creates a new vector" do
+      vector = Hamster::Vector.new([1,2,3])
+      vector.size.should be(3)
+      vector[0].should be(1)
+      vector[1].should be(2)
+      vector[2].should be(3)
+    end
+
+    it "makes a defensive copy of a non-frozen mutable Array passed in" do
+      array = [1,2,3]
+      vector = Hamster::Vector.new(array)
+      array[0] = 'changed'
+      vector[0].should be(1)
+    end
+
+    it "is amenable to overriding of #initialize" do
+      class SnazzyVector < Hamster::Vector
+        def initialize
+          super(['SNAZZY!!!'])
+        end
+      end
+
+      vector = SnazzyVector.new
+      vector.size.should be(1)
+      vector.should == ['SNAZZY!!!']
+    end
+
+    context "from a subclass" do
+      it "returns a frozen instance of the subclass" do
+        subclass = Class.new(Hamster::Vector)
+        instance = subclass.new(["some", "values"])
+        instance.class.should be subclass
+        instance.frozen?.should be true
+      end
+    end
+  end
+
+  describe ".[]" do
+    it "accepts a variable number of items and creates a new vector" do
+      vector = Hamster::Vector['a', 'b']
+      vector.size.should be(2)
+      vector[0].should == 'a'
+      vector[1].should == 'b'
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require "spec_helper"
+require "hamster/vector"
+
+describe Hamster::Vector do
+  describe "#partition" do
+    [
+      [[], [], []],
+      [[1], [1], []],
+      [[1, 2], [1], [2]],
+      [[1, 2, 3], [1, 3], [2]],
+      [[1, 2, 3, 4], [1, 3], [2, 4]],
+      [[2, 3, 4], [3], [2, 4]],
+      [[3, 4], [3], [4]],
+      [[4], [], [4]],
+    ].each do |values, expected_matches, expected_remainder|
+      describe "on #{values.inspect}" do
+        let(:vector) { Hamster.vector(*values) }
+
+        describe "with a block" do
+          let(:result)    { vector.partition(&:odd?) }
+          let(:matches)   { result.first }
+          let(:remainder) { result.last }
+
+          it "preserves the original" do
+            result
+            vector.should eql(Hamster.vector(*values))
+          end
+
+          it "returns a frozen array with two items" do
+            result.class.should be(Array)
+            result.should be_frozen
+            result.size.should be(2)
+          end
+
+          it "correctly identifies the matches" do
+            matches.should eql(Hamster.vector(*expected_matches))
+          end
+
+          it "correctly identifies the remainder" do
+            remainder.should eql(Hamster.vector(*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)])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+require "spec_helper"
+require "hamster/vector"
+
+describe Hamster::Vector do
+  describe "#permutation" do
+    let(:vector) { Hamster.vector(1,2,3,4) }
+
+    context "without a block or arguments" do
+      it "returns an Enumerator of all permutations" do
+        vector.permutation.class.should be(Enumerator)
+        vector.permutation.to_a.should eql(vector.to_a.permutation.to_a)
+      end
+    end
+
+    context "without a block, but with integral argument" do
+      it "returns an Enumerator of all permutations of given length" do
+        vector.permutation(2).class.should be(Enumerator)
+        vector.permutation(2).to_a.should eql(vector.to_a.permutation(2).to_a)
+        vector.permutation(3).class.should be(Enumerator)
+        vector.permutation(3).to_a.should eql(vector.to_a.permutation(3).to_a)
+      end
+    end
+
+    context "with a block" do
+      it "returns self" do
+        vector.permutation {}.should be(vector)
+      end
+
+      context "and no argument" do
+        it "yields all permutations" do
+          yielded = []
+          vector.permutation { |obj| yielded << obj }
+          yielded.sort.should eql([[1,2,3,4], [1,2,4,3], [1,3,2,4], [1,3,4,2],
+            [1,4,2,3], [1,4,3,2], [2,1,3,4], [2,1,4,3], [2,3,1,4], [2,3,4,1],
+            [2,4,1,3], [2,4,3,1], [3,1,2,4], [3,1,4,2], [3,2,1,4], [3,2,4,1],
+            [3,4,1,2], [3,4,2,1], [4,1,2,3], [4,1,3,2], [4,2,1,3], [4,2,3,1],
+            [4,3,1,2], [4,3,2,1]])
+        end
+      end
+
+      context "and an integral argument" do
+        it "yields all permutations of the given length" do
+          yielded = []
+          vector.permutation(2) { |obj| yielded << obj }
+          yielded.sort.should eql([[1,2], [1,3], [1,4], [2,1], [2,3], [2,4], [3,1],
+            [3,2], [3,4], [4,1], [4,2], [4,3]])
+        end
+      end
+    end
+
+    context "on an empty vector" do
+      it "yields the empty permutation" do
+        yielded = []
+        Hamster.vector.permutation { |obj| yielded << obj }
+        yielded.should eql([[]])
+      end
+    end
+
+    context "with an argument of zero" do
+      it "yields the empty permutation" do
+        yielded = []
+        vector.permutation(0) { |obj| yielded << obj }
+        yielded.should eql([[]])
+      end
+    end
+
+    context "with a length greater than the size of the vector" do
+      it "yields no permutations" do
+        vector.permutation(5) { |obj| fail }
+      end
+    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],
+        [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))
+    end
+
+    it "behaves like Array#permutation" do
+      10.times do
+        array  = rand(8).times.map { rand(10000) }
+        vector = V.new(array)
+        perm_size = array.size == 0 ? 0 : rand(array.size)
+        array.permutation(perm_size).to_a.should == vector.permutation(perm_size).to_a
+      end
+    end
+  end
+end