immutable-ruby 0.0.1

data/spec/lib/immutable/list/chunk_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#chunk" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.chunk(2) }.should_not raise_error
+    end
+
+    [
+      [[], []],
+      [["A"], [L["A"]]],
+      [%w[A B C], [L["A", "B"], L["C"]]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        it "preserves the original" do
+          list.chunk(2)
+          list.should eql(L[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          list.chunk(2).should eql(L[*expected])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#clear" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      describe "on #{values}" do
+        let(:list) { L[*values] }
+
+        it "preserves the original" do
+          list.clear
+          list.should eql(L[*values])
+        end
+
+        it "returns an empty list" do
+          list.clear.should equal(L.empty)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#combination" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.combination(2) }.should_not raise_error
+    end
+
+    [
+      [%w[A B C D], 1, [L["A"], L["B"], L["C"], L["D"]]],
+      [%w[A B C D], 2, [L["A","B"], L["A","C"], L["A","D"], L["B","C"], L["B","D"], L["C","D"]]],
+      [%w[A B C D], 3, [L["A","B","C"], L["A","B","D"], L["A","C","D"], L["B","C","D"]]],
+      [%w[A B C D], 4, [L["A", "B", "C", "D"]]],
+      [%w[A B C D], 0, [EmptyList]],
+      [%w[A B C D], 5, []],
+      [[], 0, [EmptyList]],
+      [[], 1, []],
+    ].each do |values, number, expected|
+      context "on #{values.inspect} in groups of #{number}" do
+        let(:list) { L[*values] }
+
+        it "preserves the original" do
+          list.combination(number)
+          list.should eql(L[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          list.combination(number).should eql(L[*expected])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#compact" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.compact }.should_not raise_error
+    end
+
+    [
+      [[], []],
+      [["A"], ["A"]],
+      [%w[A B C], %w[A B C]],
+      [[nil], []],
+      [[nil, "B"], ["B"]],
+      [["A", nil], ["A"]],
+      [[nil, nil], []],
+      [["A", nil, "C"], %w[A C]],
+      [[nil, "B", nil], ["B"]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        it "preserves the original" do
+          list.compact
+          list.should eql(L[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          list.compact.should eql(L[*expected])
+        end
+      end
+    end
+  end
+end

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

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

data/spec/lib/immutable/list/cons_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#cons" do
+    [
+      [[], "A", ["A"]],
+      [["A"], "B", %w[B A]],
+      [["A"], "A", %w[A A]],
+      [%w[A B C], "D", %w[D A B C]],
+    ].each do |values, new_value, expected|
+      context "on #{values.inspect} with #{new_value.inspect}" do
+        let(:list) { L[*values] }
+
+        it "preserves the original" do
+          list.cons(new_value)
+          list.should eql(L[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          list.cons(new_value).should eql(L[*expected])
+        end
+      end
+    end
+  end
+end

data/spec/lib/immutable/list/construction_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+
+describe Immutable do
+  describe ".list" do
+    context "with no arguments" do
+      it "always returns the same instance" do
+        L.empty.should equal(L.empty)
+      end
+
+      it "returns an empty list" do
+        L.empty.should be_empty
+      end
+    end
+
+    context "with a number of items" do
+      it "always returns a different instance" do
+        L["A", "B", "C"].should_not equal(L["A", "B", "C"])
+      end
+
+      it "is the same as repeatedly using #cons" do
+        L["A", "B", "C"].should eql(L.empty.cons("C").cons("B").cons("A"))
+      end
+    end
+  end
+
+  describe ".stream" do
+    context "with no block" do
+      it "returns an empty list" do
+        Immutable.stream.should eql(L.empty)
+      end
+    end
+
+    context "with a block" do
+      let(:list) { count = 0; Immutable.stream { count += 1 }}
+
+      it "repeatedly calls the block" do
+        list.take(5).should eql(L[1, 2, 3, 4, 5])
+      end
+    end
+  end
+
+  describe ".interval" do
+    context "for numbers" do
+      it "is equivalent to a list with explicit values" do
+        Immutable.interval(98, 102).should eql(L[98, 99, 100, 101, 102])
+      end
+    end
+
+    context "for strings" do
+      it "is equivalent to a list with explicit values" do
+        Immutable.interval("A", "AA").should eql(L["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA"])
+      end
+    end
+  end
+
+  describe ".repeat" do
+    it "returns an infinite list with specified value for each element" do
+      Immutable.repeat("A").take(5).should eql(L["A", "A", "A", "A", "A"])
+    end
+  end
+
+  describe ".replicate" do
+    it "returns a list with the specified value repeated the specified number of times" do
+      Immutable.replicate(5, "A").should eql(L["A", "A", "A", "A", "A"])
+    end
+  end
+
+  describe ".iterate" do
+    it "returns an infinite list where the first item is calculated by applying the block on the initial argument, the second item by applying the function on the previous result and so on" do
+      Immutable.iterate(1) { |item| item * 2 }.take(10).should eql(L[1, 2, 4, 8, 16, 32, 64, 128, 256, 512])
+    end
+  end
+
+  describe ".enumerate" do
+    let(:enum) do
+      Enumerator.new do |yielder|
+        yielder << 1
+        yielder << 2
+        yielder << 3
+        raise "list fully realized"
+      end
+    end
+
+    let(:list) { Immutable.enumerate(enum) }
+
+    it "returns a list based on the values yielded from the enumerator" do
+      expect(list.take(2)).to eq L[1, 2]
+    end
+
+    it "realizes values as they are needed" do
+      # this example shows that Lists are not as lazy as they could be
+      # if Lists were fully lazy, you would have to take(4) to hit the exception
+      expect { list.take(3).to_a }.to raise_exception
+    end
+  end
+
+  describe "[]" do
+    it "takes a variable number of items and returns a list" do
+      list = Immutable::List[1,2,3]
+      list.should be_kind_of(Immutable::List)
+      list.size.should be(3)
+      list.to_a.should == [1,2,3]
+    end
+
+    it "returns an empty list when called without arguments" do
+      L[].should be_kind_of(Immutable::List)
+      L[].should be_empty
+    end
+  end
+end

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

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

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

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#count" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).count }.should_not raise_error
+      end
+    end
+
+    [
+      [[], 0],
+      [[1], 1],
+      [[1, 2], 1],
+      [[1, 2, 3], 2],
+      [[1, 2, 3, 4], 2],
+      [[1, 2, 3, 4, 5], 3],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        context "with a block" do
+          it "returns #{expected.inspect}" do
+            list.count(&:odd?).should == expected
+          end
+        end
+
+        context "without a block" do
+          it "returns length" do
+            list.count.should == list.length
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/immutable/list/cycle_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Immutable do
+  describe "#cycle" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.cycle }.should_not raise_error
+    end
+
+    context "with an empty list" do
+      it "returns an empty list" do
+        L.empty.cycle.should be_empty
+      end
+    end
+
+    context "with a non-empty list" do
+      let(:list) { L["A", "B", "C"] }
+
+      it "preserves the original" do
+        list.cycle
+        list.should == L["A", "B", "C"]
+      end
+
+      it "infinitely cycles through all values" do
+        list.cycle.take(7).should == L["A", "B", "C", "A", "B", "C", "A"]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#delete_at" do
+    let(:list) { L[1,2,3,4,5] }
+
+    it "removes the element at the specified index" do
+      list.delete_at(0).should eql(L[2,3,4,5])
+      list.delete_at(2).should eql(L[1,2,4,5])
+      list.delete_at(-1).should eql(L[1,2,3,4])
+    end
+
+    it "makes no modification if the index is out of range" do
+      list.delete_at(5).should eql(list)
+      list.delete_at(-6).should eql(list)
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#delete" do
+    it "removes elements that are #== to the argument" do
+      L[1,2,3].delete(1).should eql(L[2,3])
+      L[1,2,3].delete(2).should eql(L[1,3])
+      L[1,2,3].delete(3).should eql(L[1,2])
+      L[1,2,3].delete(0).should eql(L[1,2,3])
+      L['a','b','a','c','a','a','d'].delete('a').should eql(L['b','c','d'])
+
+      L[EqualNotEql.new, EqualNotEql.new].delete(:something).should eql(L[])
+      L[EqlNotEqual.new, EqlNotEqual.new].delete(:something).should_not be_empty
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#drop" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.drop(1) }.should_not raise_error
+    end
+
+    [
+      [[], 10, []],
+      [["A"], 10, []],
+      [["A"], -1, ["A"]],
+      [%w[A B C], 0, %w[A B C]],
+      [%w[A B C], 2, ["C"]],
+    ].each do |values, number, expected|
+      context "with #{number} from #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        it "preserves the original" do
+          list.drop(number)
+          list.should eql(L[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          list.drop(number).should == L[*expected]
+        end
+      end
+    end
+  end
+end