immutable-ruby 0.0.1

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#inspect" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).inspect }.should_not raise_error
+      end
+    end
+
+    [
+      [[], 'Immutable::List[]'],
+      [["A"], 'Immutable::List["A"]'],
+      [%w[A B C], 'Immutable::List["A", "B", "C"]']
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        it "returns #{expected.inspect}" do
+          list.inspect.should == expected
+        end
+
+        it "returns a string which can be eval'd to get an equivalent object" do
+          eval(list.inspect).should eql(list)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#join" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).join }.should_not raise_error
+      end
+    end
+
+    context "with a separator" do
+      [
+        [[], ""],
+        [["A"], "A"],
+        [%w[A B C], "A|B|C"]
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          let(:list) { L[*values] }
+
+          it "preserves the original" do
+            list.join("|")
+            list.should eql(L[*values])
+          end
+
+          it "returns #{expected.inspect}" do
+            list.join("|").should == expected
+          end
+        end
+      end
+    end
+
+    context "without a separator" do
+      [
+        [[], ""],
+        [["A"], "A"],
+        [%w[A B C], "ABC"]
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          let(:list) { L[*values] }
+
+          it "preserves the original" do
+            list.join
+            list.should eql(L[*values])
+          end
+
+          it "returns #{expected.inspect}" do
+            list.join.should == expected
+          end
+        end
+      end
+    end
+
+    context "without a separator (with global default separator set)" do
+      before { $, = '**' }
+      let(:list) { L["A", "B", "C"] }
+      after  { $, = nil }
+
+      it "uses the default global separator" do
+        list.join.should == "A**B**C"
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#<<" do
+    it "adds an item onto the end of a list" do
+      list = L["a", "b"]
+      (list << "c").should eql(L["a", "b", "c"])
+      list.should eql(L["a", "b"])
+    end
+
+    context "on an empty list" do
+      it "returns a list with one item" do
+        list = L.empty
+        (list << "c").should eql(L["c"])
+        list.should eql(L.empty)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#max" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).max }.should_not raise_error
+      end
+    end
+
+    context "with a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "Ichi"],
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            L[*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|
+        context "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            L[*values].max.should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Immutable::List do
+  context "without a comparator" do
+    context "on an empty list" do
+      it "returns an empty list" do
+        L.empty.merge_by.should be_empty
+      end
+    end
+
+    context "on a single list" do
+      let(:list) { L[1, 2, 3] }
+
+      it "returns the list" do
+        L[list].merge_by.should eql(list)
+      end
+    end
+
+    context "with multiple lists" do
+      subject { L[L[3, 6, 7, 8], L[1, 2, 4, 5, 9]] }
+
+      it "merges the lists based on natural sort order" do
+        subject.merge_by.should == L[1, 2, 3, 4, 5, 6, 7, 8, 9]
+      end
+    end
+  end
+
+  context "with a comparator" do
+    context "on an empty list" do
+      it "returns an empty list" do
+        L.empty.merge_by { |item| fail("should never be called") }.should be_empty
+      end
+    end
+
+    context "on a single list" do
+      let(:list) { L[1, 2, 3] }
+
+      it "returns the list" do
+        L[list].merge_by { |item| -item }.should == L[1, 2, 3]
+      end
+    end
+
+    context "with multiple lists" do
+      subject { L[L[8, 7, 6, 3], L[9, 5, 4, 2, 1]] }
+
+      it "merges the lists based on the specified transformer" do
+        subject.merge_by { |item| -item }.should == L[9, 8, 7, 6, 5, 4, 3, 2, 1]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require "spec_helper"
+
+describe Immutable::List do
+  context "without a comparator" do
+    context "on an empty list" do
+      subject { L.empty }
+
+      it "returns an empty list" do
+        subject.merge.should be_empty
+      end
+    end
+
+    context "on a single list" do
+      let(:list) { L[1, 2, 3] }
+
+      subject { L[list] }
+
+      it "returns the list" do
+        subject.merge.should == list
+      end
+    end
+
+    context "with multiple lists" do
+      subject { L[L[3, 6, 7, 8], L[1, 2, 4, 5, 9]] }
+
+      it "merges the lists based on natural sort order" do
+        subject.merge.should == L[1, 2, 3, 4, 5, 6, 7, 8, 9]
+      end
+    end
+  end
+
+  context "with a comparator" do
+    context "on an empty list" do
+      subject { L.empty }
+
+      it "returns an empty list" do
+        subject.merge { |a, b| fail("should never be called") }.should be_empty
+      end
+    end
+
+    context "on a single list" do
+      let(:list) { L[1, 2, 3] }
+
+      subject { L[list] }
+
+      it "returns the list" do
+        subject.merge { |a, b| fail("should never be called") }.should == list
+      end
+    end
+
+    context "with multiple lists" do
+      subject { L[L[8, 7, 6, 3], L[9, 5, 4, 2, 1]] }
+
+      it "merges the lists based on the specified comparator" do
+        subject.merge { |a, b| b <=> a }.should == L[9, 8, 7, 6, 5, 4, 3, 2, 1]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#min" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).min }.should_not raise_error
+      end
+    end
+
+    context "with a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "Ni"],
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            L[*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|
+        context "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            L[*values].min.should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "concurrent/atomics"
+
+describe Immutable::List do
+  it "ensures each node of a lazy list will only be realized on ONE thread, even when accessed by multiple threads" do
+    counter = Concurrent::Atomic.new(0)
+    list = (1..10000).to_list.map { |x| counter.update { |count| count + 1 }; x * 2 }
+
+    threads = 10.times.collect do
+      Thread.new do
+        node = list
+        node = node.tail until node.empty?
+      end
+    end
+    threads.each(&:join)
+
+    counter.get.should == 10000
+    list.sum.should == 100010000
+  end
+
+  it "doesn't go into an infinite loop if lazy list block raises an exception" do
+    list = (1..10).to_list.map { raise "Oops!" }
+
+    threads = 10.times.collect do
+      Thread.new do
+        -> { list.head }.should raise_error(RuntimeError)
+      end
+    end
+    threads.each(&:join)
+  end
+
+  it "doesn't give horrendously bad performance if thread realizing the list sleeps" do
+    start = Time.now
+    list  = (1..100).to_list.map { |x| sleep(0.001); x * 2 }
+
+    threads = 10.times.collect do
+      Thread.new do
+        node = list
+        node = node.tail until node.empty?
+      end
+    end
+    threads.each(&:join)
+
+    elapsed = Time.now - start
+    elapsed.should_not > 0.3
+  end
+end