immutable-ruby 0.0.1

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

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#drop_while" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.drop_while { false } }.should_not raise_error
+    end
+
+    [
+      [[], []],
+      [["A"], []],
+      [%w[A B C], ["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.drop_while { |item| item < "C" }
+            list.should eql(L[*values])
+          end
+
+          it "returns #{expected.inspect}" do
+            list.drop_while { |item| item < "C" }.should eql(L[*expected])
+          end
+        end
+
+        context "without a block" do
+          it "returns an Enumerator" do
+            list.drop_while.class.should be(Enumerator)
+            list.drop_while.each { false }.should eql(list)
+            list.drop_while.each { true  }.should be_empty
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+describe Immutable::List do
+  [:each_chunk, :each_slice].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).send(method, 1) { |item| } }.should_not raise_error
+        end
+      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] }
+
+          context "with a block" do
+            it "preserves the original" do
+              list.should eql(L[*values])
+            end
+
+            it "iterates over the items in order" do
+              yielded = []
+              list.send(method, 2) { |item| yielded << item }
+              yielded.should eql(expected)
+            end
+
+            it "returns self" do
+              list.send(method, 2) { |item| item }.should be(list)
+            end
+          end
+
+          context "without a block" do
+            it "preserves the original" do
+              list.send(method, 2)
+              list.should eql(L[*values])
+            end
+
+            it "returns an Enumerator" do
+              list.send(method, 2).class.should be(Enumerator)
+              list.send(method, 2).to_a.should eql(expected)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#each" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).each { |item| } }.should_not raise_error
+      end
+    end
+
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        context "with a block" do
+          it "iterates over the items in order" do
+            yielded = []
+            list.each { |item| yielded << item }
+            yielded.should == values
+          end
+
+          it "returns nil" do
+            list.each { |item| item }.should be_nil
+          end
+        end
+
+        context "without a block" do
+          it "returns an Enumerator" do
+            list.each.class.should be(Enumerator)
+            Immutable::List[*list.each].should eql(list)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#each_with_index" do
+    context "with no block" do
+      let(:list) { L["A", "B", "C"] }
+
+      it "returns an Enumerator" do
+        list.each_with_index.class.should be(Enumerator)
+        list.each_with_index.to_a.should == [['A', 0], ['B', 1], ['C', 2]]
+      end
+    end
+
+    context "with a block" do
+      let(:list) { Immutable.interval(1, 1025) }
+
+      it "returns self" do
+        list.each_with_index { |item, index| item }.should be(list)
+      end
+
+      it "iterates over the items in order, yielding item and index" do
+        yielded = []
+        list.each_with_index { |item, index| yielded << [item, index] }
+        yielded.should == (1..list.size).zip(0..list.size.pred)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#eql?" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).eql?(Immutable.interval(0, STACK_OVERFLOW_DEPTH)) }.should_not raise_error
+      end
+    end
+  end
+
+  shared_examples 'equal using eql?' do |a, b|
+    specify "#{a.inspect} should eql? #{b.inspect}" do
+      expect(a).to eql b
+    end
+
+    specify "#{a.inspect} should == #{b.inspect}" do
+      expect(a).to eq b
+    end
+  end
+
+  shared_examples 'not equal using eql?' do |a, b|
+    specify "#{a.inspect} should not eql? #{b.inspect}" do
+      expect(a).to_not eql b
+    end
+  end
+
+  shared_examples 'equal using ==' do |a, b|
+    specify "#{a.inspect} should == #{b.inspect}" do
+      expect(a).to eq b
+    end
+  end
+
+  shared_examples 'not equal using ==' do |a, b|
+    specify "#{a.inspect} should not == #{b.inspect}" do
+      expect(a).to_not eq b
+    end
+  end
+
+  include_examples 'equal using =='       , L["A", "B", "C"], %w[A B C]
+  include_examples 'not equal using eql?' , L["A", "B", "C"], %w[A B C]
+  include_examples 'not equal using =='   , L["A", "B", "C"], Object.new
+  include_examples 'not equal using eql?' , L["A", "B", "C"], Object.new
+  include_examples 'equal using =='       , L.empty, []
+  include_examples 'not equal using eql?' , L.empty, []
+
+  include_examples 'equal using eql?'     , L.empty, L.empty
+  include_examples 'not equal using eql?' , L.empty, L[nil]
+  include_examples 'not equal using eql?' , L["A"], L.empty
+  include_examples 'equal using eql?'     , L["A"], L["A"]
+  include_examples 'not equal using eql?' , L["A"], L["B"]
+  include_examples 'not equal using eql?' , L["A", "B"], L["A"]
+  include_examples 'equal using eql?'     , L["A", "B", "C"], L["A", "B", "C"]
+  include_examples 'not equal using eql?' , L["C", "A", "B"], L["A", "B", "C"]
+
+  include_examples 'equal using =='       , L['A'], ['A']
+  include_examples 'equal using =='       , ['A'], L['A']
+
+  include_examples 'not equal using eql?' , L['A'], ['A']
+  include_examples 'not equal using eql?' , ['A'], L['A']
+end

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

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#fill" do
+    let(:list) { L[1, 2, 3, 4, 5, 6] }
+
+    it "can replace a range of items at the beginning of a list" do
+      list.fill(:a, 0, 3).should eql(L[:a, :a, :a, 4, 5, 6])
+    end
+
+    it "can replace a range of items in the middle of a list" do
+      list.fill(:a, 3, 2).should eql(L[1, 2, 3, :a, :a, 6])
+    end
+
+    it "can replace a range of items at the end of a list" do
+      list.fill(:a, 4, 2).should eql(L[1, 2, 3, 4, :a, :a])
+    end
+
+    it "can replace all the items in a list" do
+      list.fill(:a, 0, 6).should eql(L[:a, :a, :a, :a, :a, :a])
+    end
+
+    it "can fill past the end of the list" do
+      list.fill(:a, 3, 6).should eql(L[1, 2, 3, :a, :a, :a, :a, :a, :a])
+    end
+
+    context "with 1 argument" do
+      it "replaces all the items in the list by default" do
+        list.fill(:a).should eql(L[:a, :a, :a, :a, :a, :a])
+      end
+    end
+
+    context "with 2 arguments" do
+      it "replaces up to the end of the list by default" do
+        list.fill(:a, 4).should eql(L[1, 2, 3, 4, :a, :a])
+      end
+    end
+
+    context "when index and length are 0" do
+      it "leaves the list unmodified" do
+        list.fill(:a, 0, 0).should eql(list)
+      end
+    end
+
+    it "is lazy" do
+      -> { Immutable.stream { fail }.fill(:a, 0, 1) }.should_not raise_error
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+describe Immutable::List do
+  let(:list) { L[*values] }
+  let(:found_list) { L[*found_values] }
+
+  describe "#find_all" do
+    it "is lazy" do
+      expect { Immutable.stream { fail }.find_all { |item| false } }.to_not raise_error
+    end
+
+    shared_examples "checking values" do
+      context "with a block" do
+        let(:find_all) { list.find_all { |item| item == item.upcase } }
+
+        it "preserves the original" do
+          expect(list).to eq(L[*values])
+        end
+
+        it "returns the found list" do
+          expect(find_all).to eq(found_list)
+        end
+      end
+
+      context "without a block" do
+        let(:find_all) { list.find_all }
+
+        it "returns an Enumerator" do
+          expect(find_all.class).to be(Enumerator)
+          expect(find_all.each { |item| item == item.upcase }).to eq(found_list)
+        end
+      end
+    end
+
+    context "with an empty array" do
+      let(:values) { [] }
+      let(:found_values) { [] }
+
+      include_examples "checking values"
+    end
+
+    context "with a single item array" do
+      let(:values) { ["A"] }
+      let(:found_values) { ["A"] }
+
+      include_examples "checking values"
+    end
+
+    context "with a multi-item array" do
+      let(:values) { %w[A B] }
+      let(:found_values) { %w[A B] }
+
+      include_examples "checking values"
+    end
+
+    context "with a multi-item single find_allable array" do
+      let(:values) { %w[A b] }
+      let(:found_values) { ["A"] }
+
+      include_examples "checking values"
+    end
+
+    context "with a multi-item multi-find_allable array" do
+      let(:values) { %w[a b] }
+      let(:found_values) { [] }
+
+      include_examples "checking values"
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Immutable::List do
+  [:find_index, :index].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).send(method) { |item| false } }.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
+            L[*values].send(method) { |x| x == item }.should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Immutable::List do
+  [:find, :detect].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).send(method) { false } }.should_not raise_error
+        end
+      end
+
+      [
+        [[], "A", nil],
+        [[], nil, nil],
+        [["A"], "A", "A"],
+        [["A"], "B", nil],
+        [["A"], nil, nil],
+        [["A", "B", nil], "A", "A"],
+        [["A", "B", nil], "B", "B"],
+        [["A", "B", nil], nil, nil],
+        [["A", "B", nil], "C", nil],
+      ].each do |values, item, expected|
+        context "on #{values.inspect}" do
+          let(:list) { L[*values] }
+
+          context "with a block" do
+            it "returns #{expected.inspect}" do
+              list.send(method) { |x| x == item }.should == expected
+            end
+          end
+
+          context "without a block" do
+            it "returns an Enumerator" do
+              list.send(method).class.should be(Enumerator)
+              list.send(method).each { |x| x == item }.should == expected
+            end
+          end
+        end
+      end
+    end
+  end
+end