immutable-ruby 0.0.4 → 0.1.0

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/dig_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-require "immutable/vector"
-
-describe Immutable::Vector do
-  let(:v) { V[1, 2, V[3, 4]] }
-
-  describe "#dig" do
-    it "returns value at the index with one argument" do
-      expect(v.dig(0)).to eq(1)
-    end
-
-    it "returns value at index in nested arrays" do
-      expect(v.dig(2, 0)).to eq(3)
-    end
-
-    # This is different from Hash#dig, but it matches the behavior of Ruby's
-    #   built-in Array#dig (except that Array#dig raises a TypeError)
-    it "raises an error when indexing deeper than possible" do
-      expect { (v.dig(0, 0)) }.to raise_error(NoMethodError)
-    end
-
-    it "returns nil if you index past the end of an array" do
-      expect(v.dig(5)).to eq(nil)
-    end
-
-    it "raises an error when indexing with a key vectors don't understand" do
-      expect { v.dig(:foo) }.to raise_error(ArgumentError)
-    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

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

@@ -1,58 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Vector do
-  describe "#flatten" do
-    it "recursively flattens nested vectors into containing vector" do
-      V[V[1], V[2]].flatten.should eql(V[1,2])
-      V[V[V[V[V[V[1,2,3]]]]]].flatten.should eql(V[1,2,3])
-      V[V[V[1]], V[V[V[2]]]].flatten.should eql(V[1,2])
-    end
-
-    it "flattens nested arrays as well" do
-      V[[1,2,3],[[4],[5,6]]].flatten.should eql(V[1,2,3,4,5,6])
-    end
-
-    context "with an integral argument" do
-      it "only flattens down to the specified depth" do
-        V[V[V[1,2]]].flatten(1).should eql(V[V[1,2]])
-        V[V[V[V[1]], V[2], V[3]]].flatten(2).should eql(V[V[1], 2, 3])
-      end
-    end
-
-    context "with an argument of zero" do
-      it "returns self" do
-        vector = V[1,2,3]
-        vector.flatten(0).should be(vector)
-      end
-    end
-
-    context "on a subclass" do
-      it "returns an instance of the subclass" do
-        subclass = Class.new(Immutable::Vector)
-        instance = subclass.new([1,2])
-        instance.flatten.class.should be(subclass)
-      end
-    end
-
-    context "on a vector with no nested vectors" do
-      it "returns an unchanged vector" do
-        vector = V[1,2,3]
-        vector.flatten.should.eql?(V[1,2,3])
-      end
-
-      context "on a Vector larger than 32 items initialized with Vector.new" do
-        # Regression test, for problem discovered while working on GH issue #182
-        it "returns an unchanged vector" do
-          vector1,vector2 = 2.times.collect { V.new(0..33) }
-          vector1.flatten.should eql(vector2)
-        end
-      end
-    end
-
-    it "leaves the original unmodified" do
-      vector = V[1,2,3]
-      vector.flatten
-      vector.should eql(V[1,2,3])
-    end
-  end
-end