immutable-ruby 0.0.1 → 0.1.0

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

@@ -1,75 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#store" do
-    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-    context "with a unique key" do
-      let(:result) { hash.store("D", "dee") }
-
-      it "preserves the original" do
-        result
-        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
-      end
-
-      it "returns a copy with the superset of key/value pairs" do
-        result.should eql(H["A" => "aye", "B" => "bee", "C" => "see", "D" => "dee"])
-      end
-    end
-
-    context "with a duplicate key" do
-      let(:result) { hash.store("C", "sea") }
-
-      it "preserves the original" do
-        result
-        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
-      end
-
-      it "returns a copy with the superset of key/value pairs" do
-        result.should eql(H["A" => "aye", "B" => "bee", "C" => "sea"])
-      end
-    end
-
-    context "with duplicate key and identical value" do
-      let(:hash) { H["X" => 1, "Y" => 2] }
-      let(:result) { hash.store("X", 1) }
-
-      it "returns the original hash unmodified" do
-        result.should be(hash)
-      end
-
-      context "with big hash (force nested tries)" do
-        let(:keys) { (0..99).map(&:to_s) }
-        let(:values) { (100..199).to_a }
-        let(:hash) { H[keys.zip(values)] }
-
-        it "returns the original hash unmodified for all changes" do
-          keys.each_with_index do |key, index|
-            result = hash.store(key, values[index])
-            result.should be(hash)
-          end
-        end
-      end
-    end
-
-    context "with unequal keys which hash to the same value" do
-      let(:hash) { H[DeterministicHash.new('a', 1) => 'aye'] }
-
-      it "stores and can retrieve both" do
-        result = hash.store(DeterministicHash.new('b', 1), 'bee')
-        result.get(DeterministicHash.new('a', 1)).should eql('aye')
-        result.get(DeterministicHash.new('b', 1)).should eql('bee')
-      end
-    end
-
-    context "when a String is inserted as key and then mutated" do
-      it "is not affected" do
-        string = "a string!"
-        hash = H.empty.store(string, 'a value!')
-        string.upcase!
-        hash['a string!'].should == 'a value!'
-        hash['A STRING!'].should be_nil
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-  describe "#take" do
-    it "returns the first N key/val pairs from hash" do
-      hash.take(0).should == []
-      [[['A', 'aye']], [['B', 'bee']], [['C', 'see']]].include?(hash.take(1)).should == true
-      [['A', 'aye'], ['B', 'bee'], ['C', 'see']].combination(2).include?(hash.take(2).sort).should == true
-      hash.take(3).sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
-      hash.take(4).sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
-    end
-  end
-
-  describe "#take_while" do
-    it "passes elements to the block until the block returns nil/false" do
-      passed = nil
-      hash.take_while { |k,v| passed = k; false }
-      ['A', 'B', 'C'].include?(passed).should == true
-    end
-
-    it "returns an array of all elements before the one which returned nil/false" do
-      count = 0
-      result = hash.take_while { count += 1; count < 3 }
-      [['A', 'aye'], ['B', 'bee'], ['C', 'see']].combination(2).include?(result.sort).should == true
-    end
-
-    it "passes all elements if the block never returns nil/false" do
-      passed = []
-      hash.take_while { |k,v| passed << [k, v]; true }.should == hash.to_a
-      passed.sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#to_a" do
-    it "returns an Array of [key, value] pairs in same order as #each" do
-      hash = H[:a => 1, 1 => :a, 3 => :b, :b => 5]
-      pairs = []
-      hash.each_pair { |k,v| pairs << [k,v] }
-      hash.to_a.should be_kind_of(Array)
-      hash.to_a.should == pairs
-    end
-  end
-end

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#chunk" do
-    it "is lazy" do
-      -> { Immutable.stream { fail }.chunk(2) }.should_not raise_error
-    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] }
-
-        it "preserves the original" do
-          list.chunk(2)
-          list.should eql(L[*values])
-        end
-
-        it "returns #{expected.inspect}" do
-          list.chunk(2).should eql(L[*expected])
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#clear" do
-    [
-      [],
-      ["A"],
-      %w[A B C],
-    ].each do |values|
-      describe "on #{values}" do
-        let(:list) { L[*values] }
-
-        it "preserves the original" do
-          list.clear
-          list.should eql(L[*values])
-        end
-
-        it "returns an empty list" do
-          list.clear.should equal(L.empty)
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-describe Immutable::List do
-  describe "#combination" do
-    it "is lazy" do
-      -> { Immutable.stream { fail }.combination(2) }.should_not raise_error
-    end
-
-    [
-      [%w[A B C D], 1, [L["A"], L["B"], L["C"], L["D"]]],
-      [%w[A B C D], 2, [L["A","B"], L["A","C"], L["A","D"], L["B","C"], L["B","D"], L["C","D"]]],
-      [%w[A B C D], 3, [L["A","B","C"], L["A","B","D"], L["A","C","D"], L["B","C","D"]]],
-      [%w[A B C D], 4, [L["A", "B", "C", "D"]]],
-      [%w[A B C D], 0, [EmptyList]],
-      [%w[A B C D], 5, []],
-      [[], 0, [EmptyList]],
-      [[], 1, []],
-    ].each do |values, number, expected|
-      context "on #{values.inspect} in groups of #{number}" do
-        let(:list) { L[*values] }
-
-        it "preserves the original" do
-          list.combination(number)
-          list.should eql(L[*values])
-        end
-
-        it "returns #{expected.inspect}" do
-          list.combination(number).should eql(L[*expected])
-        end
-      end
-    end
-  end
-end