immutable-ruby 0.0.1 → 0.1.0

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

@@ -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
-          -> { 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

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
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).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
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).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

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
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).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,33 +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
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).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
-          L[*values].index(item).should == expected
-        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
-          -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).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
-        -> { Immutable.interval(0, STACK_OVERFLOW_DEPTH).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