immutable-ruby 0.0.1 → 0.1.0

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

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

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

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#<=>" do
-    [
-      [[], [1]],
-      [[1], [2]],
-      [[1], [1, 2]],
-      [[2, 3, 4], [3, 4, 5]]
-    ].each do |items1, items2|
-      context "with #{items1} and #{items2}" do
-        it "returns -1" do
-          (L[*items1] <=> L[*items2]).should be(-1)
-        end
-      end
-
-      context "with #{items2} and #{items1}" do
-        it "returns 1" do
-          (L[*items2] <=> L[*items1]).should be(1)
-        end
-      end
-
-      context "with #{items1} and #{items1}" do
-        it "returns 0" do
-          (L[*items1] <=> L[*items1]).should be(0)
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#cons" do
-    [
-      [[], "A", ["A"]],
-      [["A"], "B", %w[B A]],
-      [["A"], "A", %w[A A]],
-      [%w[A B C], "D", %w[D A B C]],
-    ].each do |values, new_value, expected|
-      context "on #{values.inspect} with #{new_value.inspect}" do
-        let(:list) { L[*values] }
-
-        it "preserves the original" do
-          list.cons(new_value)
-          list.should eql(L[*values])
-        end
-
-        it "returns #{expected.inspect}" do
-          list.cons(new_value).should eql(L[*expected])
-        end
-      end
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-require "spec_helper"
-
-describe Immutable do
-  describe ".list" do
-    context "with no arguments" do
-      it "always returns the same instance" do
-        L.empty.should equal(L.empty)
-      end
-
-      it "returns an empty list" do
-        L.empty.should be_empty
-      end
-    end
-
-    context "with a number of items" do
-      it "always returns a different instance" do
-        L["A", "B", "C"].should_not equal(L["A", "B", "C"])
-      end
-
-      it "is the same as repeatedly using #cons" do
-        L["A", "B", "C"].should eql(L.empty.cons("C").cons("B").cons("A"))
-      end
-    end
-  end
-
-  describe ".stream" do
-    context "with no block" do
-      it "returns an empty list" do
-        Immutable.stream.should eql(L.empty)
-      end
-    end
-
-    context "with a block" do
-      let(:list) { count = 0; Immutable.stream { count += 1 }}
-
-      it "repeatedly calls the block" do
-        list.take(5).should eql(L[1, 2, 3, 4, 5])
-      end
-    end
-  end
-
-  describe ".interval" do
-    context "for numbers" do
-      it "is equivalent to a list with explicit values" do
-        Immutable.interval(98, 102).should eql(L[98, 99, 100, 101, 102])
-      end
-    end
-
-    context "for strings" do
-      it "is equivalent to a list with explicit values" do
-        Immutable.interval("A", "AA").should eql(L["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA"])
-      end
-    end
-  end
-
-  describe ".repeat" do
-    it "returns an infinite list with specified value for each element" do
-      Immutable.repeat("A").take(5).should eql(L["A", "A", "A", "A", "A"])
-    end
-  end
-
-  describe ".replicate" do
-    it "returns a list with the specified value repeated the specified number of times" do
-      Immutable.replicate(5, "A").should eql(L["A", "A", "A", "A", "A"])
-    end
-  end
-
-  describe ".iterate" do
-    it "returns an infinite list where the first item is calculated by applying the block on the initial argument, the second item by applying the function on the previous result and so on" do
-      Immutable.iterate(1) { |item| item * 2 }.take(10).should eql(L[1, 2, 4, 8, 16, 32, 64, 128, 256, 512])
-    end
-  end
-
-  describe ".enumerate" do
-    let(:enum) do
-      Enumerator.new do |yielder|
-        yielder << 1
-        yielder << 2
-        yielder << 3
-        raise "list fully realized"
-      end
-    end
-
-    let(:list) { Immutable.enumerate(enum) }
-
-    it "returns a list based on the values yielded from the enumerator" do
-      expect(list.take(2)).to eq L[1, 2]
-    end
-
-    it "realizes values as they are needed" do
-      # this example shows that Lists are not as lazy as they could be
-      # if Lists were fully lazy, you would have to take(4) to hit the exception
-      expect { list.take(3).to_a }.to raise_exception
-    end
-  end
-
-  describe "[]" do
-    it "takes a variable number of items and returns a list" do
-      list = Immutable::List[1,2,3]
-      list.should be_kind_of(Immutable::List)
-      list.size.should be(3)
-      list.to_a.should == [1,2,3]
-    end
-
-    it "returns an empty list when called without arguments" do
-      L[].should be_kind_of(Immutable::List)
-      L[].should be_empty
-    end
-  end
-end

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

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

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

@@ -1,36 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#count" do
-    context "on a really big list" do
-      it "doesn't run out of stack" do
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).count }.should_not raise_error
-      end
-    end
-
-    [
-      [[], 0],
-      [[1], 1],
-      [[1, 2], 1],
-      [[1, 2, 3], 2],
-      [[1, 2, 3, 4], 2],
-      [[1, 2, 3, 4, 5], 3],
-    ].each do |values, expected|
-      context "on #{values.inspect}" do
-        let(:list) { L[*values] }
-
-        context "with a block" do
-          it "returns #{expected.inspect}" do
-            list.count(&:odd?).should == expected
-          end
-        end
-
-        context "without a block" do
-          it "returns length" do
-            list.count.should == list.length
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-describe Immutable do
-  describe "#cycle" do
-    it "is lazy" do
-      -> { Immutable.stream { fail }.cycle }.should_not raise_error
-    end
-
-    context "with an empty list" do
-      it "returns an empty list" do
-        L.empty.cycle.should be_empty
-      end
-    end
-
-    context "with a non-empty list" do
-      let(:list) { L["A", "B", "C"] }
-
-      it "preserves the original" do
-        list.cycle
-        list.should == L["A", "B", "C"]
-      end
-
-      it "infinitely cycles through all values" do
-        list.cycle.take(7).should == L["A", "B", "C", "A", "B", "C", "A"]
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#delete_at" do
-    let(:list) { L[1,2,3,4,5] }
-
-    it "removes the element at the specified index" do
-      list.delete_at(0).should eql(L[2,3,4,5])
-      list.delete_at(2).should eql(L[1,2,4,5])
-      list.delete_at(-1).should eql(L[1,2,3,4])
-    end
-
-    it "makes no modification if the index is out of range" do
-      list.delete_at(5).should eql(list)
-      list.delete_at(-6).should eql(list)
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#delete" do
-    it "removes elements that are #== to the argument" do
-      L[1,2,3].delete(1).should eql(L[2,3])
-      L[1,2,3].delete(2).should eql(L[1,3])
-      L[1,2,3].delete(3).should eql(L[1,2])
-      L[1,2,3].delete(0).should eql(L[1,2,3])
-      L['a','b','a','c','a','a','d'].delete('a').should eql(L['b','c','d'])
-
-      L[EqualNotEql.new, EqualNotEql.new].delete(:something).should eql(L[])
-      L[EqlNotEqual.new, EqlNotEqual.new].delete(:something).should_not be_empty
-    end
-  end
-end

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

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

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

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

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

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

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

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

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

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