immutable-ruby 0.0.1

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

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#none?" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).none? { false } }.should_not raise_error
+      end
+    end
+
+    context "when empty" do
+      it "with a block returns true" do
+        L.empty.none? {}.should == true
+      end
+
+      it "with no block returns true" do
+        L.empty.none?.should == true
+      end
+    end
+
+    context "when not empty" do
+      context "with a block" do
+        let(:list) { L["A", "B", "C", nil] }
+
+        ["A", "B", "C", nil].each do |value|
+          it "returns false if the block ever returns true (#{value.inspect})" do
+            list.none? { |item| item == value }.should == false
+          end
+        end
+
+        it "returns true if the block always returns false" do
+          list.none? { |item| item == "D" }.should == true
+        end
+      end
+
+      context "with no block" do
+        it "returns false if any value is truthy" do
+          L[nil, false, true, "A"].none?.should == false
+        end
+
+        it "returns true if all values are falsey" do
+          L[nil, false].none?.should == true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#one?" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).one? { false } }.should_not raise_error
+      end
+    end
+
+    context "when empty" do
+      it "with a block returns false" do
+        L.empty.one? {}.should == false
+      end
+
+      it "with no block returns false" do
+        L.empty.one?.should == false
+      end
+    end
+
+    context "when not empty" do
+      context "with a block" do
+        let(:list) { L["A", "B", "C"] }
+
+        it "returns false if the block returns true more than once" do
+          list.one? { |item| true }.should == false
+        end
+
+        it "returns false if the block never returns true" do
+          list.one? { |item| false }.should == false
+        end
+
+        it "returns true if the block only returns true once" do
+          list.one? { |item| item == "A" }.should == true
+        end
+      end
+
+      context "with no block" do
+        it "returns false if more than one value is truthy" do
+          L[nil, true, "A"].one?.should == false
+        end
+
+        it "returns true if only one value is truthy" do
+          L[nil, true, false].one?.should == true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+require "spec_helper"
+require "thread"
+
+describe Immutable::List do
+  describe "#partition" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.partition }.should_not raise_error
+    end
+
+    it "calls the passed block only once for each item" do
+      count = 0
+      a,b = L[1, 2, 3].partition { |item| count += 1; item.odd? }
+      (a.size + b.size).should be(3) # force realization of lazy lists
+      count.should be(3)
+    end
+
+    # note: Lists are not as lazy as they could be!
+    # they always realize elements a bit ahead of the current one
+
+    it "returns a lazy list of items for which predicate is true" do
+      count = 0
+      a,b = L[1, 2, 3, 4].partition { |item| count += 1; item.odd? }
+      a.take(1).should == [1]
+      count.should be(3) # would be 1 if lists were lazier
+      a.take(2).should == [1, 3]
+      count.should be(4) # would be 3 if lists were lazier
+    end
+
+    it "returns a lazy list of items for which predicate is false" do
+      count = 0
+      a,b = L[1, 2, 3, 4].partition { |item| count += 1; item.odd? }
+      b.take(1).should == [2]
+      count.should be(4) # would be 2 if lists were lazier
+      b.take(2).should == [2, 4]
+      count.should be(4)
+    end
+
+    it "calls the passed block only once for each item, even with multiple threads" do
+      mutex = Mutex.new
+      yielded = [] # record all the numbers yielded to the block, to make sure each is yielded only once
+      list = Immutable.iterate(0) do |n|
+        sleep(rand / 500) # give another thread a chance to get in
+        mutex.synchronize { yielded << n }
+        sleep(rand / 500)
+        n + 1
+      end
+      left, right = list.partition(&:odd?)
+
+      10.times.collect do |i|
+        Thread.new do
+          # half of the threads will consume the "left" lazy list, while half consume
+          # the "right" lazy list
+          # make sure that only one thread will run the above "iterate" block at a
+          # time, regardless
+          if i % 2 == 0
+            left.take(100).sum.should == 10000
+          else
+            right.take(100).sum.should == 9900
+          end
+        end
+      end.each(&:join)
+
+      # if no threads "stepped on" each other, the following should be true
+      # make some allowance for "lazy" lists which actually realize a little bit ahead:
+      (200..203).include?(yielded.size).should == true
+      yielded.should == (0..(yielded.size-1)).to_a
+    end
+
+    [
+      [[], [], []],
+      [[1], [1], []],
+      [[1, 2], [1], [2]],
+      [[1, 2, 3], [1, 3], [2]],
+      [[1, 2, 3, 4], [1, 3], [2, 4]],
+      [[2, 3, 4], [3], [2, 4]],
+      [[3, 4], [3], [4]],
+      [[4], [], [4]],
+    ].each do |values, expected_matches, expected_remainder|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        context "with a block" do
+          let(:result)  { list.partition(&:odd?) }
+          let(:matches) { result.first }
+          let(:remainder) { result.last }
+
+          it "preserves the original" do
+            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
+            matches.should eql(L[*expected_matches])
+          end
+
+          it "correctly identifies the remainder" do
+            remainder.should eql(L[*expected_remainder])
+          end
+        end
+
+        context "without a block" do
+          it "returns an Enumerator" do
+            list.partition.class.should be(Enumerator)
+            list.partition.each(&:odd?).should eql([L[*expected_matches], L[*expected_remainder]])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#permutation" do
+    let(:list) { L[1,2,3,4] }
+
+    context "with no block" do
+      it "returns an Enumerator" do
+        list.permutation.class.should be(Enumerator)
+        list.permutation.to_a.sort.should == [1,2,3,4].permutation.to_a.sort
+      end
+    end
+
+    context "with no argument" do
+      it "yields all permutations of the list" do
+        perms = list.permutation.to_a
+        perms.size.should be(24)
+        perms.sort.should == [1,2,3,4].permutation.to_a.sort
+        perms.each { |item| item.should be_kind_of(Immutable::List) }
+      end
+    end
+
+    context "with a length argument" do
+      it "yields all N-size permutations of the list" do
+        perms = list.permutation(2).to_a
+        perms.size.should be(12)
+        perms.sort.should == [1,2,3,4].permutation(2).to_a.sort
+        perms.each { |item| item.should be_kind_of(Immutable::List) }
+      end
+    end
+
+    context "with a length argument greater than length of list" do
+      it "yields nothing" do
+        list.permutation(5).to_a.should be_empty
+      end
+    end
+
+    context "with a length argument of 0" do
+      it "yields an empty list" do
+        perms = list.permutation(0).to_a
+        perms.size.should be(1)
+        perms[0].should be_kind_of(Immutable::List)
+        perms[0].should be_empty
+      end
+    end
+
+    context "with a block" do
+      it "returns the original list" do
+        list.permutation(0) {}.should be(list)
+        list.permutation(1) {}.should be(list)
+        list.permutation {}.should be(list)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Immutable::List do
+  let(:list) { L[*values] }
+
+  describe "#pop" do
+    let(:pop) { list.pop }
+
+    context "with an empty list" do
+      let(:values) { [] }
+
+      it "returns an empty list" do
+        expect(pop).to eq(L.empty)
+      end
+    end
+
+    context "with a list with a few items" do
+      let(:values) { %w[a b c] }
+
+      it "removes the last item" do
+        expect(pop).to eq(L["a", "b"])
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Immutable::List do
+  [:reduce, :inject].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, &:+) }.should_not raise_error
+        end
+      end
+
+      [
+        [[], 10, 10],
+        [[1], 10, 9],
+        [[1, 2, 3], 10, 4],
+      ].each do |values, initial, expected|
+        context "on #{values.inspect}" do
+          context "with an initial value of #{initial} and a block" do
+            it "returns #{expected.inspect}" do
+              L[*values].send(method, initial) { |memo, item| memo - item }.should == expected
+            end
+          end
+        end
+      end
+
+      [
+        [[], nil],
+        [[1], 1],
+        [[1, 2, 3], -4],
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          context "with no initial value and a block" do
+            it "returns #{expected.inspect}" do
+              L[*values].send(method) { |memo, item| memo - item }.should == expected
+            end
+          end
+        end
+      end
+
+      context "with no block and a symbol argument" do
+        it "uses the symbol as the name of a method to reduce with" do
+          L[1, 2, 3].send(method, :+).should == 6
+        end
+      end
+
+      context "with no block and a string argument" do
+        it "uses the string as the name of a method to reduce with" do
+          L[1, 2, 3].send(method, '+').should == 6
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Immutable::List do
+  [:reject, :delete_if].each do |method|
+    describe "##{method}" do
+      it "is lazy" do
+        -> { Immutable.stream { fail }.send(method) { |item| false } }.should_not raise_error
+      end
+
+      [
+        [[], []],
+        [["A"], ["A"]],
+        [%w[A B C], %w[A B C]],
+        [%w[A b C], %w[A C]],
+        [%w[a b c], []],
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          let(:list) { L[*values] }
+
+          context "with a block" do
+            it "returns #{expected.inspect}" do
+              list.send(method) { |item| item == item.downcase }.should eql(L[*expected])
+            end
+
+            it "is lazy" do
+              count = 0
+              list.send(method) do |item|
+                count += 1
+                false
+              end
+              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 { |item| item == item.downcase }.should eql(L[*expected])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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