immutable-ruby 0.0.1

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

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#drop_while" do
+    [
+      [[], []],
+      [["A"], []],
+      [%w[A B C], ["C"]],
+    ].each do |values, expected|
+      describe "on #{values.inspect}" do
+        let(:vector) { V[*values] }
+
+        describe "with a block" do
+          let(:result) { vector.drop_while { |item| item < "C" } }
+
+          it "preserves the original" do
+            result
+            vector.should eql(V[*values])
+          end
+
+          it "returns #{expected.inspect}" do
+            result.should eql(V[*expected])
+          end
+        end
+
+        describe "without a block" do
+          it "returns an Enumerator" do
+            vector.drop_while.class.should be(Enumerator)
+            vector.drop_while.each { |item| item < "C" }.should eql(V[*expected])
+          end
+        end
+      end
+    end
+
+    context "on an empty vector" do
+      it "returns an empty vector" do
+        V.empty.drop_while { false }.should eql(V.empty)
+      end
+    end
+
+    it "returns an empty vector if block is always true" do
+      V.new(1..32).drop_while { true }.should eql(V.empty)
+      V.new(1..100).drop_while { true }.should eql(V.empty)
+    end
+
+    it "stops dropping items if block returns nil" do
+      V[1, 2, 3, nil, 4, 5].drop_while { |x| x }.should eql(V[nil, 4, 5])
+    end
+
+    it "stops dropping items if block returns false" do
+      V[1, 2, 3, false, 4, 5].drop_while { |x| x }.should eql(V[false, 4, 5])
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#each_index" do
+    let(:vector) { V[1,2,3,4] }
+
+    context "with a block" do
+      it "yields all the valid indices into the vector" do
+        result = []
+        vector.each_index { |i| result << i }
+        result.should eql([0,1,2,3])
+      end
+
+      it "returns self" do
+        vector.each_index {}.should be(vector)
+      end
+    end
+
+    context "without a block" do
+      it "returns an Enumerator" do
+        vector.each_index.class.should be(Enumerator)
+        vector.each_index.to_a.should eql([0,1,2,3])
+      end
+    end
+
+    context "on an empty vector" do
+      it "doesn't yield anything" do
+        V.empty.each_index { fail }
+      end
+    end
+
+    [1, 2, 10, 31, 32, 33, 1000, 1024, 1025].each do |size|
+      context "on a #{size}-item vector" do
+        it "yields all valid indices" do
+          V.new(1..size).each_index.to_a.should == (0..(size-1)).to_a
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#each" do
+    describe "with no block" do
+      let(:vector) { V["A", "B", "C"] }
+
+      it "returns an Enumerator" do
+        vector.each.class.should be(Enumerator)
+        vector.each.to_a.should == vector
+      end
+    end
+
+    [31, 32, 33, 1023, 1024, 1025].each do |size|
+      context "on a #{size}-item vector" do
+        describe "with a block" do
+          let(:vector) { V.new(1..size) }
+
+          it "returns self" do
+            items = []
+            vector.each { |item| items << item }.should be(vector)
+          end
+
+          it "yields all the items" do
+            items = []
+            vector.each { |item| items << item }
+            items.should == (1..size).to_a
+          end
+
+          it "iterates over the items in order" do
+            vector.each.first.should == 1
+            vector.each.to_a.last.should == size
+          end
+        end
+      end
+    end
+
+    context "on an empty vector" do
+      it "doesn't yield anything" do
+        V.empty.each { fail }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#each_with_index" do
+    describe "with no block" do
+      let(:vector) { V["A", "B", "C"] }
+
+      it "returns an Enumerator" do
+        vector.each_with_index.class.should be(Enumerator)
+        vector.each_with_index.to_a.should == [['A', 0], ['B', 1], ['C', 2]]
+      end
+    end
+
+    [1, 2, 31, 32, 33, 1023, 1024, 1025].each do |size|
+      context "on a #{size}-item vector" do
+        describe "with a block" do
+          let(:vector) { V.new(1..size) }
+
+          it "returns self" do
+            pairs = []
+            vector.each_with_index { |item, index| pairs << [item, index] }.should be(vector)
+          end
+
+          it "iterates over the items in order" do
+            pairs = []
+            vector.each_with_index { |item, index| pairs << [item, index] }.should be(vector)
+            pairs.should == (1..size).zip(0..size.pred)
+          end
+        end
+      end
+    end
+
+    context "on an empty vector" do
+      it "doesn't yield anything" do
+        V.empty.each_with_index { |item, index| fail }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#empty?" do
+    [
+      [[], true],
+      [["A"], false],
+      [%w[A B C], false],
+    ].each do |values, expected|
+      describe "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          V[*values].empty?.should == expected
+        end
+      end
+    end
+  end
+
+  describe ".empty" do
+    it "returns the canonical empty vector" do
+      V.empty.size.should be(0)
+      V.empty.object_id.should be(V.empty.object_id)
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Immutable::Vector)
+        subclass.empty.class.should be(subclass)
+        subclass.empty.should be_empty
+      end
+
+      it "calls overridden #initialize when creating empty Hash" do
+        subclass = Class.new(Immutable::Vector) do
+          def initialize
+            @variable = 'value'
+          end
+        end
+        subclass.empty.instance_variable_get(:@variable).should == 'value'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#eql" do
+    let(:vector) { V["A", "B", "C"] }
+
+    it "returns false when comparing with an array with the same contents" do
+      vector.eql?(%w[A B C]).should == false
+    end
+
+    it "returns false when comparing with an arbitrary object" do
+      vector.eql?(Object.new).should == false
+    end
+
+    it "returns false when comparing an empty vector with an empty array" do
+      V.empty.eql?([]).should == false
+    end
+
+    it "returns false when comparing with a subclass of Immutable::Vector" do
+      vector.eql?(Class.new(Immutable::Vector).new(%w[A B C])).should == false
+    end
+  end
+
+  describe "#==" do
+    let(:vector) { V["A", "B", "C"] }
+
+    it "returns true when comparing with an array with the same contents" do
+      (vector == %w[A B C]).should == true
+    end
+
+    it "returns false when comparing with an arbitrary object" do
+      (vector == Object.new).should == false
+    end
+
+    it "returns true when comparing an empty vector with an empty array" do
+      (V.empty == []).should == true
+    end
+
+    it "returns true when comparing with a subclass of Immutable::Vector" do
+      (vector == Class.new(Immutable::Vector).new(%w[A B C])).should == true
+    end
+
+    it "works on larger vectors" do
+      array = 2000.times.map { rand(10000) }
+      (V.new(array.dup) == array).should == true
+    end
+  end
+
+  [:eql?, :==].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], true],
+        [[], [nil], false],
+        [["A"], [], false],
+        [["A"], ["A"], true],
+        [["A"], ["B"], false],
+        [%w[A B], ["A"], false],
+        [%w[A B C], %w[A B C], true],
+        [%w[C A B], %w[A B C], false],
+      ].each do |a, b, expected|
+        describe "returns #{expected.inspect}" do
+          let(:vector_a) { V[*a] }
+          let(:vector_b) { V[*b] }
+
+          it "for vectors #{a.inspect} and #{b.inspect}" do
+            vector_a.send(method, vector_b).should == expected
+          end
+
+          it "for vectors #{b.inspect} and #{a.inspect}" do
+            vector_b.send(method, vector_a).should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#fetch" do
+    let(:vector) { V['a', 'b', 'c'] }
+
+    context "with no default provided" do
+      context "when the index exists" do
+        it "returns the value at the index" do
+          vector.fetch(0).should == "a"
+          vector.fetch(1).should == "b"
+          vector.fetch(2).should == "c"
+        end
+      end
+
+      context "when the key does not exist" do
+        it "raises an IndexError" do
+          -> { vector.fetch(3) }.should raise_error(IndexError)
+          -> { vector.fetch(-4) }.should raise_error(IndexError)
+        end
+      end
+    end
+
+    context "with a default value" do
+      context "when the index exists" do
+        it "returns the value at the index" do
+          vector.fetch(0, "default").should == "a"
+          vector.fetch(1, "default").should == "b"
+          vector.fetch(2, "default").should == "c"
+        end
+      end
+
+      context "when the index does not exist" do
+        it "returns the default value" do
+          vector.fetch(3, "default").should == "default"
+          vector.fetch(-4, "default").should == "default"
+        end
+      end
+    end
+
+    context "with a default block" do
+      context "when the index exists" do
+        it "returns the value at the index" do
+          vector.fetch(0) { "default".upcase }.should == "a"
+          vector.fetch(1) { "default".upcase }.should == "b"
+          vector.fetch(2) { "default".upcase }.should == "c"
+        end
+      end
+
+      context "when the index does not exist" do
+        it "invokes the block with the missing index as parameter" do
+          vector.fetch(3) { |index| index.should == 3}
+          vector.fetch(-4) { |index| index.should == -4 }
+          vector.fetch(3) { "default".upcase }.should == "DEFAULT"
+          vector.fetch(-4) { "default".upcase }.should == "DEFAULT"
+        end
+      end
+    end
+
+    it "gives precedence to default block over default argument if passed both" do
+      vector.fetch(3, 'one') { 'two' }.should == 'two'
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#fill" do
+    let(:vector) { V[1, 2, 3, 4, 5, 6] }
+
+    it "can replace a range of items at the beginning of a vector" do
+      vector.fill(:a, 0, 3).should eql(V[:a, :a, :a, 4, 5, 6])
+    end
+
+    it "can replace a range of items in the middle of a vector" do
+      vector.fill(:a, 3, 2).should eql(V[1, 2, 3, :a, :a, 6])
+    end
+
+    it "can replace a range of items at the end of a vector" do
+      vector.fill(:a, 4, 2).should eql(V[1, 2, 3, 4, :a, :a])
+    end
+
+    it "can replace all the items in a vector" do
+      vector.fill(:a, 0, 6).should eql(V[:a, :a, :a, :a, :a, :a])
+    end
+
+    it "can fill past the end of the vector" do
+      vector.fill(:a, 3, 6).should eql(V[1, 2, 3, :a, :a, :a, :a, :a, :a])
+    end
+
+    context "with 1 argument" do
+      it "replaces all the items in the vector by default" do
+        vector.fill(:a).should eql(V[:a, :a, :a, :a, :a, :a])
+      end
+    end
+
+    context "with 2 arguments" do
+      it "replaces up to the end of the vector by default" do
+        vector.fill(:a, 4).should eql(V[1, 2, 3, 4, :a, :a])
+      end
+    end
+
+    context "when index and length are 0" do
+      it "leaves the vector unmodified" do
+        vector.fill(:a, 0, 0).should eql(vector)
+      end
+    end
+
+    context "when expanding a vector past boundary where vector trie needs to deepen" do
+      it "works the same" do
+        vector.fill(:a, 32, 3).size.should == 35
+        vector.fill(:a, 32, 3).to_a.size.should == 35
+      end
+    end
+
+    [1000, 1023, 1024, 1025, 2000].each do |size|
+      context "on a #{size}-item vector" do
+        it "works the same" do
+          array = (0..size).to_a
+          vector = V.new(array)
+          [[:a, 0, 5], [:b, 31, 2], [:c, 32, 60], [:d, 1000, 20], [:e, 1024, 33], [:f, 1200, 35]].each do |obj, index, length|
+            next if index > size
+            vector = vector.fill(obj, index, length)
+            array.fill(obj, index, length)
+            vector.size.should == array.size
+            ary = vector.to_a
+            ary.size.should == vector.size
+            ary.should eql(array)
+          end
+        end
+      end
+    end
+
+    it "behaves like Array#fill, on a variety of inputs" do
+      50.times do
+        array = rand(100).times.map { rand(1000) }
+        index = rand(array.size)
+        length = rand(50)
+        V.new(array).fill(:a, index, length).should == array.fill(:a, index, length)
+      end
+      10.times do
+        array = rand(100).times.map { rand(10000) }
+        length = rand(100)
+        V.new(array).fill(:a, array.size, length).should == array.fill(:a, array.size, length)
+      end
+      10.times do
+        array = rand(100).times.map { rand(10000) }
+        V.new(array).fill(:a).should == array.fill(:a)
+      end
+    end
+  end
+end