immutable-ruby 0.0.1

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

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

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

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

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

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

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

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

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

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

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

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

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