immutable-ruby 0.0.1 → 0.1.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  describe "#first" do
-    [
-      [[], nil],
-      [["A"], "A"],
-      [%w[A B C], "A"],
-      [(1..32), 1],
-    ].each do |values, expected|
-      describe "on #{values.inspect}" do
-        it "returns #{expected.inspect}" do
-          V[*values].first.should == expected
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  let(:vector) { V[*values] }
-
-  describe "#flat_map" do
-    let(:block) { ->(item) { [item, item + 1, item * item] } }
-    let(:flat_map) { vector.flat_map(&block) }
-    let(:flattened_vector) { V[*flattened_values] }
-
-    shared_examples "checking flattened result" do
-      it "returns the flattened values as an Immutable::Vector" do
-        expect(flat_map).to eq(flattened_vector)
-      end
-
-      it "returns an Immutable::Vector" do
-        expect(flat_map).to be_a(Immutable::Vector)
-      end
-    end
-
-    context "with an empty vector" do
-      let(:values) { [] }
-      let(:flattened_values) { [] }
-
-      include_examples "checking flattened result"
-    end
-
-    context "with a block that returns an empty vector" do
-      let(:block) { ->(item) { [] } }
-      let(:values) { [1, 2, 3] }
-      let(:flattened_values) { [] }
-
-      include_examples "checking flattened result"
-    end
-
-    context "with a vector of one item" do
-      let(:values) { [7] }
-      let(:flattened_values) { [7, 8, 49] }
-
-      include_examples "checking flattened result"
-    end
-
-    context "with a vector of multiple items" do
-      let(:values) { [1, 2, 3] }
-      let(:flattened_values) { [1, 2, 1, 2, 3, 4, 3, 4, 9] }
-
-      include_examples "checking flattened result"
-    end
-  end
-end