immutable-ruby 0.0.4 → 0.2.0

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

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  [:include?, :member?].each do |method|
-    describe "##{method}" do
-      context "on a really big list" do
-        it "doesn't run out of stack" do
-          -> { BigList.send(method, nil) }.should_not raise_error
-        end
-      end
-
-      [
-        [[], "A", false],
-        [[], nil, false],
-        [["A"], "A", true],
-        [["A"], "B", false],
-        [["A"], nil, false],
-        [["A", "B", nil], "A", true],
-        [["A", "B", nil], "B", true],
-        [["A", "B", nil], nil, true],
-        [["A", "B", nil], "C", false],
-        [[2], 2, true],
-        [[2], 2.0, true],
-        [[2.0], 2.0, true],
-        [[2.0], 2, true],
-      ].each do |values, item, expected|
-        context "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            L[*values].send(method, item).should == expected
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#index" do
-    context "on a really big list" do
-      it "doesn't run out of stack" do
-        -> { BigList.index(nil) }.should_not raise_error
-      end
-    end
-
-    [
-      [[], "A", nil],
-      [[], nil, nil],
-      [["A"], "A", 0],
-      [["A"], "B", nil],
-      [["A"], nil, nil],
-      [["A", "B", nil], "A", 0],
-      [["A", "B", nil], "B", 1],
-      [["A", "B", nil], nil, 2],
-      [["A", "B", nil], "C", nil],
-      [[2], 2, 0],
-      [[2], 2.0, 0],
-      [[2.0], 2.0, 0],
-      [[2.0], 2, 0],
-    ].each do |values, item, expected|
-      context "looking for #{item.inspect} in #{values.inspect}" do
-        it "returns #{expected.inspect}" do
-          if RUBY_ENGINE == 'jruby' && RUBY_VERSION <= '2.2.2' && values[0].is_a?(Fixnum) && item.is_a?(Float)
-            skip "On JRuby, Enumerable#find_index doesn't test equality properly"
-          else
-            L[*values].index(item).should == expected
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#indices" do
-    context "when called with a block" do
-      it "is lazy" do
-        count = 0
-        Immutable.stream { count += 1 }.indices { |item| true }
-        count.should <= 1
-      end
-
-      context "on a large list which doesn't contain desired item" do
-        it "doesn't blow the stack" do
-          -> { BigList.indices { |x| x < 0 }.size }.should_not raise_error
-        end
-      end
-
-      [
-        [[], "A", []],
-        [["A"], "B", []],
-        [%w[A B A], "B", [1]],
-        [%w[A B A], "A", [0, 2]],
-        [[2], 2, [0]],
-        [[2], 2.0, [0]],
-        [[2.0], 2.0, [0]],
-        [[2.0], 2, [0]],
-      ].each do |values, item, expected|
-        context "looking for #{item.inspect} in #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            L[*values].indices { |x| x == item }.should eql(L[*expected])
-          end
-        end
-      end
-    end
-
-    context "when called with a single argument" do
-      it "is lazy" do
-        count = 0
-        Immutable.stream { count += 1 }.indices(nil)
-        count.should <= 1
-      end
-
-      [
-        [[], "A", []],
-        [["A"], "B", []],
-        [%w[A B A], "B", [1]],
-        [%w[A B A], "A", [0, 2]],
-        [[2], 2, [0]],
-        [[2], 2.0, [0]],
-        [[2.0], 2.0, [0]],
-        [[2.0], 2, [0]],
-      ].each do |values, item, expected|
-        context "looking for #{item.inspect} in #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            L[*values].indices(item).should eql(L[*expected])
-          end
-        end
-      end
-    end
-  end
-end

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

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

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

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

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

@@ -1,46 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#insert" do
-    let(:original) { L[1, 2, 3] }
-
-    it "can add items at the beginning of a list" do
-      list = original.insert(0, :a, :b)
-      list.size.should be(5)
-      list.at(0).should be(:a)
-      list.at(2).should be(1)
-    end
-
-    it "can add items in the middle of a list" do
-      list = original.insert(1, :a, :b, :c)
-      list.size.should be(6)
-      list.to_a.should == [1, :a, :b, :c, 2, 3]
-    end
-
-    it "can add items at the end of a list" do
-      list = original.insert(3, :a, :b, :c)
-      list.size.should be(6)
-      list.to_a.should == [1, 2, 3, :a, :b, :c]
-    end
-
-    it "can add items past the end of a list" do
-      list = original.insert(6, :a, :b)
-      list.size.should be(8)
-      list.to_a.should == [1, 2, 3, nil, nil, nil, :a, :b]
-    end
-
-    it "accepts a negative index, which counts back from the end of the list" do
-      list = original.insert(-2, :a)
-      list.size.should be(4)
-      list.to_a.should == [1, :a, 2, 3]
-    end
-
-    it "raises IndexError if a negative index is too great" do
-      expect { original.insert(-4, :a) }.to raise_error(IndexError)
-    end
-
-    it "is lazy" do
-      -> { Immutable.stream { fail }.insert(0, :a) }.should_not raise_error
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-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
-        -> { BigList.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

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

@@ -1,63 +0,0 @@
-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
-        -> { BigList.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

@@ -1,23 +0,0 @@
-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
-        -> { BigList.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

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

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

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

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

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

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

@@ -1,47 +0,0 @@
-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::Atom.new(0)
-    list = (1..10000).to_list.map { |x| counter.swap { |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.value.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