immutable-ruby 0.0.1

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

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  let(:vector) { V[*values] }
+
+  describe "#last" do
+    let(:last) { vector.last }
+
+    shared_examples "checking values" do
+      it "returns the last item" do
+        expect(last).to eq(last_item)
+      end
+    end
+
+    context "with an empty vector" do
+      let(:last_item) { nil }
+      let(:values) { [] }
+
+      include_examples "checking values"
+    end
+
+    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 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/lib/immutable/vector/length_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  let(:vector) { V[*values] }
+
+  describe "#length" do
+    let(:length) { vector.length }
+
+    shared_examples "checking size" do
+      it "returns the values" do
+        expect(length).to eq(size)
+      end
+    end
+
+    context "with an empty vector" do
+      let(:values) { [] }
+      let(:size) { 0 }
+
+      include_examples "checking size"
+    end
+
+    context "with a single item vector" do
+      let(:values) { %w[A] }
+      let(:size) { 1 }
+
+      include_examples "checking size"
+    end
+
+    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/immutable/vector/ltlt_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  let(:vector) { V[*values] }
+
+  describe "#<<" do
+    let(:ltlt) { vector << added_value }
+
+    shared_examples "checking adding values" do
+      let(:added_vector) { V[*added_values] }
+
+      it "preserves the original" do
+        original = vector
+        vector << added_value
+        expect(original).to eq(vector)
+      end
+
+      it "ltlts the item to the vector" do
+        expect(ltlt).to eq(added_vector)
+      end
+    end
+
+    context "with a empty array adding a single item" do
+      let(:values) { [] }
+      let(:added_value) { "A" }
+      let(:added_values) { ["A"] }
+
+      include_examples "checking adding values"
+    end
+
+    context "with a single-item array adding a different item" do
+      let(:values) { ["A"] }
+      let(:added_value) { "B" }
+      let(:added_values) { %w[A B] }
+
+      include_examples "checking adding values"
+    end
+
+    context "with a single-item array adding a duplicate item" do
+      let(:values) { ["A"] }
+      let(:added_value) { "A" }
+      let(:added_values) { %w[A A] }
+
+      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(Immutable::Vector)
+        instance = subclass[1,2,3]
+        (instance << 4).class.should be(subclass)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  [:map, :collect].each do |method|
+    describe "##{method}" do
+      context "when empty" do
+        let(:vector) { V.empty }
+
+        it "returns self" do
+          vector.send(method) {}.should equal(vector)
+        end
+      end
+
+      context "when not empty" do
+        let(:vector) { V["A", "B", "C"] }
+
+        context "with a block" do
+          it "preserves the original values" do
+            vector.send(method, &:downcase)
+            vector.should eql(V["A", "B", "C"])
+          end
+
+          it "returns a new vector with the mapped values" do
+            vector.send(method, &:downcase).should eql(V["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(V['a', 'b', 'c'])
+          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.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/immutable/vector/marshal_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Immutable::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 immutable -e 'vector = Immutable::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(V[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/immutable/vector/maximum_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#max" 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
+            V[*values].max { |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
+            V[*values].max.should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#min" 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
+            V[*values].min { |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
+            V[*values].min.should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe "#*" do
+    let(:vector) { V[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(V.empty)
+        (vector * 1).should eql(vector)
+        (vector * 2).should eql(V[1,2,3,1,2,3])
+        (vector * 3).should eql(V[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(Immutable::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/immutable/vector/new_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe Immutable::Vector do
+  describe ".new" do
+    it "accepts a single enumerable argument and creates a new vector" do
+      vector = Immutable::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 = Immutable::Vector.new(array)
+      array[0] = 'changed'
+      vector[0].should be(1)
+    end
+
+    it "is amenable to overriding of #initialize" do
+      class SnazzyVector < Immutable::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(Immutable::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 = Immutable::Vector['a', 'b']
+      vector.size.should be(2)
+      vector[0].should == 'a'
+      vector[1].should == 'b'
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+describe Immutable::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) { V[*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(V[*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(V[*expected_matches])
+          end
+
+          it "correctly identifies the remainder" do
+            remainder.should eql(V[*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([V.new(expected_matches), V.new(expected_remainder)])
+          end
+        end
+      end
+    end
+  end
+end