immutable-ruby 0.0.1

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

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#split_at" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.split_at(1) }.should_not raise_error
+    end
+
+    [
+      [[], [], []],
+      [[1], [1], []],
+      [[1, 2], [1, 2], []],
+      [[1, 2, 3], [1, 2], [3]],
+      [[1, 2, 3, 4], [1, 2], [3, 4]],
+    ].each do |values, expected_prefix, expected_remainder|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+        let(:result) { list.split_at(2) }
+        let(:prefix) { result.first }
+        let(:remainder) { result.last }
+
+        it "preserves the original" do
+          result
+          list.should eql(L[*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
+          prefix.should eql(L[*expected_prefix])
+        end
+
+        it "correctly identifies the remainder" do
+          remainder.should eql(L[*expected_remainder])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#subsequences" do
+    let(:list) { L[1,2,3,4,5] }
+
+    it "yields all sublists with 1 or more consecutive items" do
+      result = []
+      list.subsequences { |l| result << l }
+      result.size.should == (5 + 4 + 3 + 2 + 1)
+      result.sort.should == [[1], [1,2], [1,2,3], [1,2,3,4], [1,2,3,4,5],
+        [2], [2,3], [2,3,4], [2,3,4,5], [3], [3,4], [3,4,5], [4], [4,5], [5]]
+    end
+
+    context "with no block" do
+      it "returns an Enumerator" do
+        list.subsequences.class.should be(Enumerator)
+        list.subsequences.to_a.sort.should == [[1], [1,2], [1,2,3], [1,2,3,4], [1,2,3,4,5],
+        [2], [2,3], [2,3,4], [2,3,4,5], [3], [3,4], [3,4,5], [4], [4,5], [5]]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#sum" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).sum }.should_not raise_error
+      end
+    end
+
+    [
+      [[], 0],
+      [[2], 2],
+      [[1, 3, 5, 7, 11], 27],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          L[*values].sum.should == expected
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#tail" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).select(&:nil?).tail }.should_not raise_error
+      end
+    end
+
+    [
+      [[], []],
+      [["A"], []],
+      [%w[A B C], %w[B C]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        it "preserves the original" do
+          list.tail
+          list.should eql(L[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          list.tail.should eql(L[*expected])
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#take_while" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.take_while { false } }.should_not raise_error
+    end
+
+    [
+      [[], []],
+      [["A"], ["A"]],
+      [%w[A B C], %w[A B]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        context "with a block" do
+          it "returns #{expected.inspect}" do
+            list.take_while { |item| item < "C" }.should eql(L[*expected])
+          end
+
+          it "preserves the original" do
+            list.take_while { |item| item < "C" }
+            list.should eql(L[*values])
+          end
+
+          it "is lazy" do
+            count = 0
+            list.take_while do |item|
+              count += 1
+              true
+            end
+            count.should <= 1
+          end
+        end
+
+        context "without a block" do
+          it "returns an Enumerator" do
+            list.take_while.class.should be(Enumerator)
+            list.take_while.each { |item| item < "C" }.should eql(L[*expected])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Immutable::List do
+  [:to_a, :entries].each do |method|
+    describe "##{method}" do
+      context "on a really big list" do
+        it "doesn't run out of stack" do
+          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).to_a }.should_not raise_error
+        end
+      end
+
+      [
+        [],
+        ["A"],
+        %w[A B C],
+      ].each do |values|
+        context "on #{values.inspect}" do
+          let(:list) { L[*values] }
+
+          it "returns #{values.inspect}" do
+            list.send(method).should == values
+          end
+
+          it "leaves the original unchanged" do
+            list.send(method)
+            list.should eql(L[*values])
+          end
+
+          it "returns a mutable array" do
+            result = list.send(method)
+            expect(result.last).to_not eq("The End")
+            result << "The End"
+            result.last.should == "The End"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe Immutable::List do
+  let(:list) { L["A", "B", "C", "D"] }
+
+  describe "#to_ary" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).to_ary }.should_not raise_error
+      end
+    end
+
+    context "enables implicit conversion to" do
+      it "block parameters" do
+        def func(&block)
+          yield(list)
+        end
+
+        func do |a, b, *c|
+          expect(a).to eq("A")
+          expect(b).to eq("B")
+          expect(c).to eq(%w[C D])
+        end
+      end
+
+      it "method arguments" do
+        def func(a, b, *c)
+          expect(a).to eq("A")
+          expect(b).to eq("B")
+          expect(c).to eq(%w[C D])
+        end
+        func(*list)
+      end
+
+      it "works with splat" do
+        array = *list
+        expect(array).to eq(%w[A B C D])
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#to_set" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      context "on #{values.inspect}" do
+        it "returns a set with the same values" do
+          L[*values].to_set.should eql(S[*values])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#transpose" do
+    it "takes a list of lists and returns a list of all the first elements, all the 2nd elements, and so on" do
+      L[L[1, 'a'], L[2, 'b'], L[3, 'c']].transpose.should eql(L[L[1, 2, 3], L["a", "b", "c"]])
+      L[L[1, 2, 3], L["a", "b", "c"]].transpose.should eql(L[L[1, 'a'], L[2, 'b'], L[3, 'c']])
+      L[].transpose.should eql(L[])
+      L[L[]].transpose.should eql(L[])
+      L[L[], L[]].transpose.should eql(L[])
+      L[L[0]].transpose.should eql(L[L[0]])
+      L[L[0], L[1]].transpose.should eql(L[L[0, 1]])
+    end
+
+    it "only goes as far as the shortest list" do
+      L[L[1,2,3], L[2]].transpose.should eql(L[L[1,2]])
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Immutable::List do
+  [:union, :|].each do |method|
+    describe "##{method}" do
+      it "is lazy" do
+        -> { Immutable.stream { fail }.union(Immutable.stream { fail }) }.should_not raise_error
+      end
+
+      [
+        [[], [], []],
+        [["A"], [], ["A"]],
+        [%w[A B C], [], %w[A B C]],
+        [%w[A A], ["A"], ["A"]],
+      ].each do |a, b, expected|
+        context "returns #{expected.inspect}" do
+          let(:list_a) { L[*a] }
+          let(:list_b) { L[*b] }
+
+          it "for #{a.inspect} and #{b.inspect}"  do
+            list_a.send(method, list_b).should eql(L[*expected])
+          end
+
+          it "for #{b.inspect} and #{a.inspect}"  do
+            list_b.send(method, list_a).should eql(L[*expected])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#uniq" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.uniq }.should_not raise_error
+    end
+
+    context "when passed a block" do
+      it "uses the block to identify duplicates" do
+        L["a", "A", "b"].uniq(&:upcase).should eql(Immutable::List["a", "b"])
+      end
+    end
+
+    [
+      [[], []],
+      [["A"], ["A"]],
+      [%w[A B C], %w[A B C]],
+      [%w[A B A C C], %w[A B C]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        it "preserves the original" do
+          list.uniq
+          list.should eql(L[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          list.uniq.should eql(L[*expected])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#zip" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.zip(Immutable.stream { fail }) }.should_not raise_error
+    end
+
+    [
+      [[], [], []],
+      [["A"], ["aye"], [L["A", "aye"]]],
+      [["A"], [], [L["A", nil]]],
+      [[], ["A"], [L[nil, "A"]]],
+      [%w[A B C], %w[aye bee see], [L["A", "aye"], L["B", "bee"], L["C", "see"]]],
+    ].each do |left, right, expected|
+      context "on #{left.inspect} and #{right.inspect}" do
+        it "returns #{expected.inspect}" do
+          L[*left].zip(L[*right]).should eql(L[*expected])
+        end
+      end
+    end
+  end
+end