immutable-ruby 0.0.1

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

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#bsearch" do
+    let(:vector) { V[5,10,20,30] }
+
+    context "with a block which returns false for elements below desired position, and true for those at/above" do
+      it "returns the first element for which the predicate is true" do
+        vector.bsearch { |x| x > 10 }.should be(20)
+        vector.bsearch { |x| x > 1 }.should be(5)
+        vector.bsearch { |x| x > 25 }.should be(30)
+      end
+
+      context "if the block always returns false" do
+        it "returns nil" do
+          vector.bsearch { false }.should be_nil
+        end
+      end
+
+      context "if the block always returns true" do
+        it "returns the first element" do
+          vector.bsearch { true }.should be(5)
+        end
+      end
+    end
+
+    context "with a block which returns a negative number for elements below desired position, zero for the right element, and positive for those above" do
+      it "returns the element for which the block returns zero" do
+        vector.bsearch { |x| x <=> 10 }.should be(10)
+      end
+
+      context "if the block always returns positive" do
+        it "returns nil" do
+          vector.bsearch { 1 }.should be_nil
+        end
+      end
+
+      context "if the block always returns negative" do
+        it "returns nil" do
+          vector.bsearch { -1 }.should be_nil
+        end
+      end
+
+      context "if the block returns sometimes positive, sometimes negative, but never zero" do
+        it "returns nil" do
+          vector.bsearch { |x| x <=> 11 }.should be_nil
+        end
+      end
+
+      context "if not passed a block" do
+        it "returns an Enumerator" do
+          enum = vector.bsearch
+          enum.should be_a(Enumerator)
+          enum.each { |x| x <=> 10 }.should == 10
+        end
+      end
+    end
+
+    context "on an empty vector" do
+      it "returns nil" do
+        V.empty.bsearch { |x| x > 5 }.should be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#clear" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      describe "on #{values}" do
+        let(:vector) { V[*values] }
+
+        it "preserves the original" do
+          vector.clear
+          vector.should eql(V[*values])
+        end
+
+        it "returns an empty vector" do
+          vector.clear.should equal(V.empty)
+        end
+      end
+
+      context "from a subclass" do
+        it "returns an instance of the subclass" do
+          subclass = Class.new(Immutable::Vector)
+          instance = subclass.new(%w{a b c})
+          instance.clear.class.should be(subclass)
+          instance.clear.should be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#combination" do
+    let(:vector) { V[1,2,3,4] }
+
+    context "with a block" do
+      it "returns self" do
+        vector.combination(2) {}.should be(vector)
+      end
+    end
+
+    context "with no block" do
+      it "returns an Enumerator" do
+        vector.combination(2).class.should be(Enumerator)
+        vector.combination(2).to_a.should == vector.to_a.combination(2).to_a
+      end
+    end
+
+    context "when passed an argument which is out of bounds" do
+      it "yields nothing and returns self" do
+        vector.combination(5) { fail }.should be(vector)
+        vector.combination(-1) { fail }.should be(vector)
+      end
+    end
+
+    context "when passed an argument zero" do
+      it "yields an empty array" do
+        result = []
+        vector.combination(0) { |obj| result << obj }
+        result.should eql([[]])
+      end
+    end
+
+    context "when passed an argument equal to the vector's length" do
+      it "yields self as an array" do
+        result = []
+        vector.combination(4) { |obj| result << obj }
+        result.should eql([vector.to_a])
+      end
+    end
+
+    context "when passed an argument 1" do
+      it "yields each item in the vector, as single-item vectors" do
+        result = []
+        vector.combination(1) { |obj| result << obj }
+        result.should eql([[1], [2], [3], [4]])
+      end
+    end
+
+    context "when passed another integral argument" do
+      it "yields all combinations of the given length" do
+        result = []
+        vector.combination(3) { |obj| result << obj }
+        result.should eql([[1,2,3], [1,2,4], [1,3,4], [2,3,4]])
+      end
+    end
+
+    context "on an empty vector" do
+      it "works the same" do
+        V.empty.combination(0).to_a.should == [[]]
+        V.empty.combination(1).to_a.should == []
+      end
+    end
+
+    it "works on many combinations of input" do
+      0.upto(5) do |comb_size|
+        array = 12.times.map { rand(1000) }
+        V.new(array).combination(comb_size).to_a.should == array.combination(comb_size).to_a
+      end
+
+      array = 20.times.map { rand(1000) }
+      V.new(array).combination(2).to_a.should == array.combination(2).to_a
+    end
+
+    it "leaves the original unmodified" do
+      vector.combination(2) {}
+      vector.should eql(V[1,2,3,4])
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#compact" do
+    it "returns a new Vector with all nils removed" do
+      V[1, nil, 2, nil].compact.should eql(V[1, 2])
+      V[1, 2, 3].compact.should eql(V[1, 2, 3])
+      V[nil].compact.should eql(V.empty)
+    end
+
+    context "on an empty vector" do
+      it "returns self" do
+        V.empty.compact.should be(V.empty)
+      end
+    end
+
+    it "doesn't remove false" do
+      V[false].compact.should eql(V[false])
+    end
+
+    context "from a subclass" do
+      it "returns an instance of the subclass" do
+        subclass = Class.new(V)
+        instance = subclass[1, nil, 2]
+        instance.compact.class.should be(subclass)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#<=>" do
+    [
+      [[], [1]],
+      [[1], [2]],
+      [[1], [1, 2]],
+      [[2, 3, 4], [3, 4, 5]],
+      [[[0]], [[1]]]
+    ].each do |items1, items2|
+      describe "with #{items1} and #{items2}" do
+        it "returns -1" do
+          (V.new(items1) <=> V.new(items2)).should be(-1)
+        end
+      end
+
+      describe "with #{items2} and #{items1}" do
+        it "returns 1" do
+          (V.new(items2) <=> V.new(items1)).should be(1)
+        end
+      end
+
+      describe "with #{items1} and #{items1}" do
+        it "returns 0" do
+          (V.new(items1) <=> V.new(items1)).should be(0)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  [:+, :concat].each do |method|
+    describe "##{method}" do
+      let(:vector) { V.new(1..100) }
+
+      it "preserves the original" do
+        vector.concat([1,2,3])
+        vector.should eql(V.new(1..100))
+      end
+
+      it "appends the elements in the other enumerable" do
+        vector.concat([1,2,3]).should eql(V.new((1..100).to_a + [1,2,3]))
+        vector.concat(1..1000).should eql(V.new((1..100).to_a + (1..1000).to_a))
+        vector.concat(1..200).size.should == 300
+        vector.concat(vector).should eql(V.new((1..100).to_a * 2))
+        vector.concat(V.empty).should eql(vector)
+        V.empty.concat(vector).should eql(vector)
+      end
+
+      [1, 31, 32, 33, 1023, 1024, 1025].each do |size|
+        context "on a #{size}-item vector" do
+          it "works the same" do
+            vector = V.new(1..size)
+            result = vector.concat((size+1)..size+10)
+            result.size.should == size + 10
+            result.should eql(V.new(1..(size+10)))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  [:dup, :clone].each do |method|
+    [
+      [],
+      ["A"],
+      %w[A B C],
+      (1..32),
+    ].each do |values|
+      describe "on #{values.inspect}" do
+        let(:vector) { V[*values] }
+
+        it "returns self" do
+          vector.send(method).should equal(vector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#count" do
+    it "returns the number of elements" do
+      V[:a, :b, :c].count.should == 3
+    end
+
+    it "returns the number of elements that equal the argument" do
+      V[:a, :b, :b, :c].count(:b).should == 2
+    end
+
+    it "returns the number of element for which the block evaluates to true" do
+      V[:a, :b, :c].count { |s| s != :b }.should == 2
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#delete_at" do
+    let(:vector) { V[1,2,3,4,5] }
+
+    it "removes the element at the specified index" do
+      vector.delete_at(0).should eql(V[2,3,4,5])
+      vector.delete_at(2).should eql(V[1,2,4,5])
+      vector.delete_at(-1).should eql(V[1,2,3,4])
+    end
+
+    it "makes no modification if the index is out of range" do
+      vector.delete_at(5).should eql(vector)
+      vector.delete_at(-6).should eql(vector)
+    end
+
+    it "works when deleting last item at boundary where vector trie needs to get shallower" do
+      vector = Immutable::Vector.new(1..33)
+      vector.delete_at(32).size.should == 32
+      vector.delete_at(32).to_a.should eql((1..32).to_a)
+    end
+
+    it "works on an empty vector" do
+      V.empty.delete_at(0).should be(V.empty)
+      V.empty.delete_at(1).should be(V.empty)
+    end
+
+    it "works on a vector with 1 item" do
+      V[10].delete_at(0).should eql(V.empty)
+      V[10].delete_at(1).should eql(V[10])
+    end
+
+    it "works on a vector with 32 items" do
+      V.new(1..32).delete_at(0).should eql(V.new(2..32))
+      V.new(1..32).delete_at(31).should eql(V.new(1..31))
+    end
+
+    it "has the right size and contents after many deletions" do
+      array  = (1..2000).to_a # we use an Array as standard of correctness
+      vector = Immutable::Vector.new(array)
+      500.times do
+        index = rand(vector.size)
+        vector = vector.delete_at(index)
+        array.delete_at(index)
+        vector.size.should == array.size
+        ary = vector.to_a
+        ary.size.should == vector.size
+        ary.should eql(array)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#delete" do
+    it "removes elements that are #== to the argument" do
+      V[1,2,3].delete(1).should eql(V[2,3])
+      V[1,2,3].delete(2).should eql(V[1,3])
+      V[1,2,3].delete(3).should eql(V[1,2])
+      V[1,2,3].delete(0).should eql(V[1,2,3])
+      V['a','b','a','c','a','a','d'].delete('a').should eql(V['b','c','d'])
+
+      V[EqualNotEql.new, EqualNotEql.new].delete(:something).should eql(V.empty)
+      V[EqlNotEqual.new, EqlNotEqual.new].delete(:something).should_not be_empty
+    end
+
+    context "on an empty vector" do
+      it "returns self" do
+        V.empty.delete(1).should be(V.empty)
+      end
+    end
+
+    context "on a subclass of Vector" do
+      it "returns an instance of the subclass" do
+        subclass = Class.new(Immutable::Vector)
+        instance = subclass.new([1,2,3])
+        instance.delete(1).class.should be(subclass)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#drop" do
+    [
+      [[], 10, []],
+      [["A"], 10, []],
+      [["A"], 1, []],
+      [["A"], 0, ["A"]],
+      [%w[A B C], 0, %w[A B C]],
+      [%w[A B C], 2, ["C"]],
+      [(1..32), 3, (4..32)],
+      [(1..33), 32, [33]]
+    ].each do |values, number, expected|
+      describe "#{number} from #{values.inspect}" do
+        let(:vector) { V[*values] }
+
+        it "preserves the original" do
+          vector.drop(number)
+          vector.should eql(V[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          vector.drop(number).should eql(V[*expected])
+        end
+      end
+    end
+
+    it "raises an ArgumentError if number of elements specified is negative" do
+      -> { V[1, 2, 3].drop(-1) }.should raise_error(ArgumentError)
+      -> { V[1, 2, 3].drop(-3) }.should raise_error(ArgumentError)
+    end
+
+    context "when number of elements specified is zero" do
+      let(:vector) { V[1, 2, 3, 4, 5, 6] }
+      it "returns self" do
+        vector.drop(0).should be(vector)
+      end
+    end
+  end
+end