immutable-ruby 0.0.1

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

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Immutable::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) { V[1..size] }
+
+        context "with a block (internal iteration)" do
+          it "returns self" do
+            vector.reverse_each {}.should be(vector)
+          end
+
+          it "yields all items in the opposite order as #each" do
+            result = []
+            vector.reverse_each { |item| result << item }
+            result.should eql(vector.to_a.reverse)
+          end
+        end
+
+        context "with no block" do
+          it "returns an Enumerator" do
+            result = vector.reverse_each
+            result.class.should be(Enumerator)
+            result.to_a.should eql(vector.to_a.reverse)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#reverse" do
+    [
+      [[], []],
+      [[1], [1]],
+      [[1,2], [2,1]],
+      [(1..32).to_a, (1..32).to_a.reverse],
+      [(1..33).to_a, (1..33).to_a.reverse],
+      [(1..100).to_a, (1..100).to_a.reverse],
+      [(1..1024).to_a, (1..1024).to_a.reverse]
+    ].each do |initial, expected|
+      describe "on #{initial}" do
+        it "returns #{expected}" do
+          V.new(initial).reverse.should eql(V.new(expected))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#rindex" do
+    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
+        vector.rindex(1).should be(5)
+        vector.rindex(2).should be(4)
+        vector.rindex(3).should be(3)
+      end
+    end
+
+    context "when passed an object not present in the vector" do
+      it "returns nil" do
+        vector.rindex(0).should be_nil
+        vector.rindex(nil).should be_nil
+        vector.rindex('string').should be_nil
+      end
+    end
+
+    context "with a block" do
+      it "returns the last index of an object which the predicate is true for" do
+        vector.rindex { |n| n > 2 }.should be(3)
+      end
+    end
+
+    context "without an argument OR block" do
+      it "returns an Enumerator" do
+        vector.rindex.class.should be(Enumerator)
+        vector.rindex.each { |n| n > 2 }.should be(3)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#rotate" do
+    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(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(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(V[3,4,5,1,2])
+      end
+    end
+
+    context "with a non-numeric argument" do
+      it "raises a TypeError" do
+        -> { vector.rotate('hello') }.should raise_error(TypeError)
+      end
+    end
+
+    context "with an argument of zero" do
+      it "returns self" do
+        vector.rotate(0).should be(vector)
+      end
+    end
+
+    context "with an argument equal to the vector's size" do
+      it "returns self" do
+        vector.rotate(5).should be(vector)
+      end
+    end
+
+    [31, 32, 33, 1000, 1023, 1024, 1025].each do |size|
+      context "on a #{size}-item vector" do
+        it "behaves like Array#rotate" do
+          array = (1..size).to_a
+          vector = V.new(array)
+          10.times do
+            offset = rand(size)
+            vector.rotate(offset).should == array.rotate(offset)
+          end
+        end
+      end
+    end
+
+    context "from a subclass" do
+      it "returns an instance of the subclass" do
+        subclass = Class.new(Immutable::Vector)
+        instance = subclass.new([1,2,3])
+        instance.rotate(2).class.should be(subclass)
+      end
+    end
+
+    it "leaves the original unmodified" do
+      vector.rotate(3)
+      vector.should eql(V[1,2,3,4,5])
+    end
+  end
+end

data/spec/lib/immutable/vector/sample_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#sample" do
+    let(:vector) { V.new(1..10) }
+
+    it "returns a randomly chosen item" do
+      chosen = 100.times.map { vector.sample }
+      chosen.each { |item| vector.include?(item).should == true }
+      vector.each { |item| chosen.include?(item).should == true }
+    end
+  end
+end

data/spec/lib/immutable/vector/select_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  [:select, :find_all].each do |method|
+    describe "##{method}" do
+      let(:vector) { V["A", "B", "C"] }
+
+      describe "with a block" do
+        it "preserves the original" do
+          vector.send(method) { |item| item == "A" }
+          vector.should eql(V["A", "B", "C"])
+        end
+
+        it "returns a vector with the matching values" do
+          vector.send(method) { |item| item == "A" }.should eql(V["A"])
+        end
+      end
+
+      describe "with no block" do
+        it "returns an Enumerator" do
+          vector.send(method).class.should be(Enumerator)
+          vector.send(method).each { |item| item == "A" }.should eql(V["A"])
+        end
+      end
+
+      describe "when nothing matches" do
+        it "preserves the original" do
+          vector.send(method) { |item| false }
+          vector.should eql(V["A", "B", "C"])
+        end
+
+        it "returns an empty vector" do
+          vector.send(method) { |item| false }.should equal(V.empty)
+        end
+      end
+
+      context "on an empty vector" do
+        it "returns self" do
+          V.empty.send(method) { |item| true }.should be(V.empty)
+        end
+      end
+
+      context "from a subclass" do
+        it "returns an instance of the subclass" do
+          subclass = Class.new(Immutable::Vector)
+          instance = subclass[1,2,3]
+          instance.send(method) { |x| x > 1 }.class.should be(subclass)
+        end
+      end
+
+      it "works with a variety of inputs" do
+        [1, 2, 10, 31, 32, 33, 1023, 1024, 1025].each do |size|
+          [0, 5, 32, 50, 500, 800, 1024].each do |threshold|
+            vector = V.new(1..size)
+            result = vector.send(method) { |item| item <= threshold }
+            result.size.should == [size, threshold].min
+            result.should eql(V.new(1..[size, threshold].min))
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/immutable/vector/set_spec.rb

@@ -0,0 +1,174 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  let(:vector) { V[*values] }
+
+  describe "#set" do
+    context "when empty" do
+      let(:vector) { V.empty }
+
+      it "raises an error for index -1" do
+        expect { vector.set(-1, :a) }.to raise_error
+      end
+
+      it "allows indexes 0 and 1 to be set" do
+        vector.set(0, :a).should eql(V[:a])
+        vector.set(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.set(1) { |value| value.should == "B" }
+            end
+
+            it "replaces the value with the result of the block" do
+              result = vector.set(1) { |value| "FLIBBLE" }
+              result.should eql(V["A", "FLIBBLE", "C"])
+            end
+
+            it "supports to_proc methods" do
+              result = vector.set(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.set(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.set(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.set(-2) { |value| value.should == "B" }
+            end
+
+            it "replaces the value with the result of the block" do
+              result = vector.set(-2) { |value| "FLIBBLE" }
+              result.should eql(V["A", "FLIBBLE", "C"])
+            end
+
+            it "supports to_proc methods" do
+              result = vector.set(-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.set(-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(:set) { vector.set(1, "FLIBBLE") }
+
+            it "preserves the original" do
+              vector.should eql(V["A", "B", "C"])
+            end
+
+            it "sets the new value at the specified index" do
+              set.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.set(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.set(5, "FLIBBLE")
+              result.should eql(V["A", "B", "C", nil, nil, "FLIBBLE"])
+            end
+          end
+        end
+
+        context "with a negative index" do
+          let(:set) { vector.set(-2, "FLIBBLE") }
+
+          it "preserves the original" do
+            set
+            vector.should eql(V["A", "B", "C"])
+          end
+
+          it "sets the new value at the specified index" do
+            set.should eql(V["A", "FLIBBLE", "C"])
+          end
+        end
+
+        context "outside the absolute bounds of the vector" do
+          it "raises an error" do
+            expect { vector.set(-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(Immutable::Vector)
+        instance = subclass[1,2,3]
+        instance.set(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.set(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.set(index, index * index).should equal(vector)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/immutable/vector/shift_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#shift" do
+    [
+      [[], []],
+      [["A"], []],
+      [%w[A B C], %w[B C]],
+      [1..31, 2..31],
+      [1..32, 2..32],
+      [1..33, 2..33]
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:vector) { V[*values] }
+
+        it "preserves the original" do
+          vector.shift
+          vector.should eql(V[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          vector.shift.should eql(V[*expected])
+        end
+      end
+    end
+  end
+end