immutable-ruby 0.0.1

data/spec/lib/immutable/hash/to_hash_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  [:to_hash, :to_h].each do |method|
+    describe "##{method}" do
+      it "converts an empty Immutable::Hash to an empty Ruby Hash" do
+        H.empty.send(method).should eql({})
+      end
+
+      it "converts a non-empty Immutable::Hash to a Hash with the same keys and values" do
+        H[a: 1, b: 2].send(method).should eql({a: 1, b: 2})
+      end
+
+      it "doesn't modify the receiver" do
+        hash = H[a: 1, b: 2]
+        hash.send(method)
+        hash.should eql(H[a: 1, b: 2])
+      end
+    end
+  end
+end

data/spec/lib/immutable/hash/update_in_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#update_in" do
+    let(:hash) {
+      Immutable::Hash[
+        "A" => "aye",
+        "B" => Immutable::Hash["C" => "see", "D" => Immutable::Hash["E" => "eee"]],
+        "F" => Immutable::Vector["G", Immutable::Hash["H" => "eitch"], "I"]
+      ]
+    }
+
+    context "with one level on existing key" do
+      it "passes the value to the block" do
+        hash.update_in("A") { |value| value.should == "aye" }
+      end
+
+      it "replaces the value with the result of the block" do
+        result = hash.update_in("A") { |value| "FLIBBLE" }
+        result.get("A").should == "FLIBBLE"
+      end
+
+      it "should preserve the original" do
+        result = hash.update_in("A") { |value| "FLIBBLE" }
+        hash.get("A").should == "aye"
+      end
+    end
+
+    context "with multi-level on existing keys" do
+      it "passes the value to the block" do
+        hash.update_in("B", "D", "E") { |value| value.should == "eee" }
+      end
+
+      it "replaces the value with the result of the block" do
+        result = hash.update_in("B", "D", "E") { |value| "FLIBBLE" }
+        result["B"]["D"]["E"].should == "FLIBBLE"
+      end
+
+      it "should preserve the original" do
+        result = hash.update_in("B", "D", "E") { |value| "FLIBBLE" }
+        hash["B"]["D"]["E"].should == "eee"
+      end
+    end
+
+    context "with multi-level creating sub-hashes when keys don't exist" do
+      it "passes nil to the block" do
+        hash.update_in("B", "X", "Y") { |value| value.should be_nil }
+      end
+
+      it "creates subhashes on the way to set the value" do
+        result = hash.update_in("B", "X", "Y") { |value| "NEWVALUE" }
+        result["B"]["X"]["Y"].should == "NEWVALUE"
+        result["B"]["D"]["E"].should == "eee"
+      end
+    end
+
+    context "with multi-level including vector with existing keys" do
+      it "passes the value to the block" do
+        hash.update_in("F", 1, "H") { |value| value.should == "eitch" }
+      end
+
+      it "replaces the value with the result of the block" do
+        result = hash.update_in("F", 1, "H") { |value| "FLIBBLE" }
+        result["F"][1]["H"].should == "FLIBBLE"
+      end
+
+      it "should preserve the original" do
+        result = hash.update_in("F", 1, "H") { |value| "FLIBBLE" }
+        hash["F"][1]["H"].should == "eitch"
+      end
+    end
+
+    context "with empty key_path" do
+      it "raises ArguemntError" do
+        expect { hash.update_in() { |v| 42 } }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/lib/immutable/hash/values_at_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#values_at" do
+    it "returns a vector of values for the given keys" do
+      h = H[:a => 9, :b => 'a', :c => -10, :d => nil]
+      h.values_at.should be_kind_of(Immutable::Vector)
+      h.values_at.should eql(V.empty)
+      h.values_at(:a, :d, :b).should be_kind_of(Immutable::Vector)
+      h.values_at(:a, :d, :b).should eql(V[9, nil, 'a'])
+    end
+  end
+end

data/spec/lib/immutable/hash/values_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#values" do
+    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
+    let(:result) { hash.values }
+
+    it "returns the keys as a Vector" do
+      result.should be_a Immutable::Vector
+      result.to_a.sort.should == %w(aye bee see)
+    end
+
+    context "with duplicates" do
+      let(:hash) { H[:A => 15, :B => 19, :C => 15] }
+      let(:result) { hash.values }
+
+      it "returns the keys as a Vector" do
+        result.class.should be(Immutable::Vector)
+        result.to_a.sort.should == [15, 15, 19]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#add" 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.add(new_value)
+          list.should eql(L[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          list.add(new_value).should eql(L[*expected])
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Immutable::List do
+  [:append, :concat, :+].each do |method|
+    describe "##{method}" do
+      it "is lazy" do
+        -> { Immutable.stream { fail }.append(Immutable.stream { fail }) }.should_not raise_error
+      end
+
+      [
+        [[], [], []],
+        [["A"], [], ["A"]],
+        [[], ["A"], ["A"]],
+        [%w[A B], %w[C D], %w[A B C D]],
+      ].each do |left_values, right_values, expected|
+        context "on #{left_values.inspect} and #{right_values.inspect}" do
+          let(:left) { L[*left_values] }
+          let(:right) { L[*right_values] }
+          let(:result) { left.append(right) }
+
+          it "preserves the left" do
+            result
+            left.should eql(L[*left_values])
+          end
+
+          it "preserves the right" do
+            result
+            right.should eql(L[*right_values])
+          end
+
+          it "returns #{expected.inspect}" do
+            result.should eql(L[*expected])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#at" do
+    context "on a really big list" do
+      let(:list) { Immutable.interval(0, STACK_OVERFLOW_DEPTH) }
+
+      it "doesn't run out of stack" do
+        -> { list.at(STACK_OVERFLOW_DEPTH) }.should_not raise_error
+      end
+    end
+
+    [
+      [[], 10, nil],
+      [["A"], 10, nil],
+      [%w[A B C], 0, "A"],
+      [%w[A B C], 2, "C"],
+      [%w[A B C], -1, "C"],
+      [%w[A B C], -2, "B"],
+      [%w[A B C], -4, nil]
+    ].each do |values, number, expected|
+      describe "#{values.inspect} with #{number}" do
+        it "returns #{expected.inspect}" do
+          L[*values].at(number).should == expected
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require "spec_helper"
+
+describe Immutable::List do
+  describe "#break" do
+    it "is lazy" do
+      -> { Immutable.stream { fail }.break { |item| false } }.should_not raise_error
+    end
+
+    [
+      [[], [], []],
+      [[1], [1], []],
+      [[1, 2], [1, 2], []],
+      [[1, 2, 3], [1, 2], [3]],
+      [[1, 2, 3, 4], [1, 2], [3, 4]],
+      [[2, 3, 4], [2], [3, 4]],
+      [[3, 4], [], [3, 4]],
+      [[4], [], [4]],
+    ].each do |values, expected_prefix, expected_remainder|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        context "with a block" do
+          let(:result) { list.break { |item| item > 2 }}
+          let(:prefix) { result.first }
+          let(:remainder) { result.last }
+
+          it "preserves the original" do
+            result
+            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 prefix" do
+            prefix.should eql(L[*expected_prefix])
+          end
+
+          it "correctly identifies the remainder" do
+            remainder.should eql(L[*expected_remainder])
+          end
+        end
+
+        context "without a block" do
+          let(:result) { list.break }
+          let(:prefix) { result.first }
+          let(:remainder) { result.last }
+
+          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 "returns self as the prefix" do
+            prefix.should equal(list)
+          end
+
+          it "leaves the remainder empty" do
+            remainder.should be_empty
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Immutable::List do
+  [
+    [[], :car, nil],
+    [["A"], :car, "A"],
+    [%w[A B C], :car, "A"],
+    [%w[A B C], :cadr, "B"],
+    [%w[A B C], :caddr, "C"],
+    [%w[A B C], :cadddr, nil],
+    [%w[A B C], :caddddr, nil],
+    [[], :cdr, L.empty],
+    [["A"], :cdr, L.empty],
+    [%w[A B C], :cdr, L["B", "C"]],
+    [%w[A B C], :cddr, L["C"]],
+    [%w[A B C], :cdddr, L.empty],
+    [%w[A B C], :cddddr, L.empty],
+  ].each do |values, method, expected|
+    describe "##{method}" do
+      it "is responded to" do
+        L.empty.respond_to?(method).should == true
+      end
+
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
+
+        it "preserves the original" do
+          list.send(method)
+          list.should eql(L[*values])
+        end
+
+        it "returns #{expected.inspect}" do
+          list.send(method).should == expected
+        end
+      end
+    end
+  end
+end