immutable-ruby 0.0.4 → 0.1.0

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
-          -> { BigList.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
-        -> { BigList.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
-        -> { BigList.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
-        -> { BigList.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

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

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

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

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

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

@@ -1,51 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  let(:list) { L[*values] }
-
-  describe "#flat_map" do
-    let(:block) { ->(item) { [item, item + 1, item * item] } }
-    let(:flat_map) { list.flat_map(&block) }
-    let(:flattened_list) { L[*flattened_values] }
-
-    shared_examples "checking flattened result" do
-
-      it "returns the flattened values as a Immutable::List" do
-        expect(flat_map).to eq(flattened_list)
-      end
-
-      it "returns a Immutable::List" do
-        expect(flat_map).to be_a(Immutable::List)
-      end
-    end
-
-    context "with an empty list" do
-      let(:values) { [] }
-      let(:flattened_values) { [] }
-
-      include_examples "checking flattened result"
-    end
-
-    context "with a block that returns an empty list" do
-      let(:block) { ->(item) { [] } }
-      let(:values) { [1, 2, 3] }
-      let(:flattened_values) { [] }
-
-      include_examples "checking flattened result"
-    end
-
-    context "with a list of one item" do
-      let(:values) { [7] }
-      let(:flattened_values) { [7, 8, 49] }
-
-      include_examples "checking flattened result"
-    end
-
-    context "with a list of multiple items" do
-      let(:values) { [1, 2, 3] }
-      let(:flattened_values) { [1, 2, 1, 2, 3, 4, 3, 4, 9] }
-
-      include_examples "checking flattened result"
-    end
-  end
-end

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

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

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

@@ -1,46 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#grep" do
-    it "is lazy" do
-      -> { Immutable.stream { fail }.grep(Object) { |item| item } }.should_not raise_error
-    end
-
-    context "without a block" do
-      [
-        [[], []],
-        [["A"], ["A"]],
-        [[1], []],
-        [["A", 2, "C"], %w[A C]],
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            L[*values].grep(String).should eql(L[*expected])
-          end
-        end
-      end
-    end
-
-    context "with a block" do
-      [
-        [[], []],
-        [["A"], ["a"]],
-        [[1], []],
-        [["A", 2, "C"], %w[a c]],
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          let(:list) { L[*values] }
-
-          it "preserves the original" do
-            list.grep(String, &:downcase)
-            list.should eql(L[*values])
-          end
-
-          it "returns #{expected.inspect}" do
-            list.grep(String, &:downcase).should eql(L[*expected])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  [:group_by, :group].each do |method|
-    describe "##{method}" do
-      context "on a really big list" do
-        it "doesn't run out of stack" do
-          -> { BigList.send(method) }.should_not raise_error
-        end
-      end
-
-      context "with a block" do
-        [
-          [[], []],
-          [[1], [true => L[1]]],
-          [[1, 2, 3, 4], [true => L[3, 1], false => L[4, 2]]],
-        ].each do |values, expected|
-          context "on #{values.inspect}" do
-            it "returns #{expected.inspect}" do
-              L[*values].send(method, &:odd?).should eql(H[*expected])
-            end
-          end
-        end
-      end
-
-      context "without a block" do
-        [
-          [[], []],
-          [[1], [1 => L[1]]],
-          [[1, 2, 3, 4], [1 => L[1], 2 => L[2], 3 => L[3], 4 => L[4]]],
-        ].each do |values, expected|
-          context "on #{values.inspect}" do
-            it "returns #{expected.inspect}" do
-              L[*values].send(method).should eql(H[*expected])
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#hash" do
-    context "on a really big list" do
-      it "doesn't run out of stack" do
-        -> { BigList.hash }.should_not raise_error
-      end
-    end
-
-    context "on an empty list" do
-      it "returns 0" do
-        expect(L.empty.hash).to eq(0)
-      end
-    end
-
-    it "values are sufficiently distributed" do
-      (1..4000).each_slice(4).map { |a, b, c, d| L[a, b, c, d].hash }.uniq.size.should == 1000
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  [:head, :first].each do |method|
-    describe "##{method}" do
-      [
-        [[], nil],
-        [["A"], "A"],
-        [%w[A B C], "A"],
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            L[*values].send(method).should == expected
-          end
-        end
-      end
-    end
-  end
-end