immutable-ruby 0.0.4 → 0.1.0

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

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Deque do
-  [:to_a, :entries].each do |method|
-    describe "##{method}" do
-      [
-        [],
-        ["A"],
-        %w[A B C],
-      ].each do |values|
-        context "on #{values.inspect}" do
-          it "returns #{values.inspect}" do
-            D[*values].send(method).should == values
-          end
-
-          it "returns a mutable array" do
-            result = D[*values].send(method)
-            expect(result.last).to_not eq("The End")
-            result << "The End"
-            result.last.should == "The End"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/lib/immutable/deque/to_ary_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Deque do
-  let(:deque) { D["A", "B", "C", "D"] }
-
-  describe "#to_ary" do
-    context "enables implicit conversion to" do
-      it "block parameters" do
-        def func(&block)
-          yield(deque)
-        end
-
-        func do |a, b, *c|
-          expect(a).to eq("A")
-          expect(b).to eq("B")
-          expect(c).to eq(%w[C D])
-        end
-      end
-
-      it "method arguments" do
-        def func(a, b, *c)
-          expect(a).to eq("A")
-          expect(b).to eq("B")
-          expect(c).to eq(%w[C D])
-        end
-        func(*deque)
-      end
-
-      it "works with splat" do
-        array = *deque
-        expect(array).to eq(%w[A B C D])
-      end
-    end
-  end
-end

data/spec/lib/immutable/deque/to_list_spec.rb

@@ -1,24 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Deque do
-  describe "#to_list" do
-    [
-      [],
-      ["A"],
-      %w[A B C],
-    ].each do |values|
-      context "on #{values.inspect}" do
-        it "returns a list containing #{values.inspect}" do
-          D[*values].to_list.should eql(L[*values])
-        end
-      end
-    end
-
-    context "after dedequeing an item from #{%w[A B C].inspect}" do
-      it "returns a list containing #{%w[B C].inspect}" do
-        list = D["A", "B", "C"].dequeue.to_list
-        list.should eql(L["B", "C"])
-      end
-    end
-  end
-end

data/spec/lib/immutable/deque/unshift_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Deque do
-  describe "#unshift" 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(:deque) { D[*values] }
-
-        it "preserves the original" do
-          deque.unshift(new_value)
-          deque.should eql(D[*values])
-        end
-
-        it "returns #{expected.inspect}" do
-          deque.unshift(new_value).should eql(D[*expected])
-        end
-
-
-        it "returns a frozen instance" do
-          deque.unshift(new_value).should be_frozen
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H[values] }
-
-  describe "#all?" do
-    context "when empty" do
-      let(:values) { H.new }
-
-      context "without a block" do
-        it "returns true" do
-          hash.all?.should == true
-        end
-      end
-
-      context "with a block" do
-        it "returns true" do
-          hash.all? { false }.should == true
-        end
-      end
-    end
-
-    context "when not empty" do
-      let(:values) { { "A" => 1, "B" => 2, "C" => 3 } }
-
-      context "without a block" do
-        it "returns true" do
-          hash.all?.should == true
-        end
-      end
-
-      context "with a block" do
-        it "returns true if the block always returns true" do
-          hash.all? { true }.should == true
-        end
-
-        it "returns false if the block ever returns false" do
-          hash.all? { |k,v| k != 'C' }.should == false
-        end
-
-        it "propagates an exception from the block" do
-          -> { hash.all? { |k,v| raise "help" } }.should raise_error(RuntimeError)
-        end
-
-        it "stops iterating as soon as the block returns false" do
-          yielded = []
-          hash.all? { |k,v| yielded << k; false }
-          yielded.size.should == 1
-        end
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#any?" do
-    context "when empty" do
-      it "with a block returns false" do
-        H.empty.any? {}.should == false
-      end
-
-      it "with no block returns false" do
-        H.empty.any?.should == false
-      end
-    end
-
-    context "when not empty" do
-      let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"] }
-
-      context "with a block" do
-        [
-          %w[A aye],
-          %w[B bee],
-          %w[C see],
-          [nil, "NIL"],
-        ].each do |pair|
-
-          it "returns true if the block ever returns true (#{pair.inspect})" do
-            hash.any? { |key, value| key == pair.first && value == pair.last }.should == true
-          end
-
-          it "returns false if the block always returns false" do
-            hash.any? { |key, value| key == "D" && value == "dee" }.should == false
-          end
-        end
-
-        it "propagates exceptions raised in the block" do
-          -> { hash.any? { |k,v| raise "help" } }.should raise_error(RuntimeError)
-        end
-
-        it "stops iterating as soon as the block returns true" do
-          yielded = []
-          hash.any? { |k,v| yielded << k; true }
-          yielded.size.should == 1
-        end
-      end
-
-      context "with no block" do
-        it "returns true" do
-          hash.any?.should == true
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H[a: 3, b: 2, c: 1] }
-
-  describe "#assoc" do
-    it "searches for a key/val pair with a given key" do
-      hash.assoc(:a).should == [:a, 3]
-      hash.assoc(:b).should == [:b, 2]
-      hash.assoc(:c).should == [:c, 1]
-    end
-
-    it "returns nil if a matching key is not found" do
-      hash.assoc(:d).should be_nil
-      hash.assoc(nil).should be_nil
-      hash.assoc(0).should be_nil
-    end
-
-    it "returns nil even if there is a default" do
-      H.new(a: 1, b: 2) { fail }.assoc(:c).should be_nil
-    end
-
-    it "uses #== to compare keys with provided object" do
-      hash.assoc(EqualNotEql.new).should_not be_nil
-      hash.assoc(EqlNotEqual.new).should be_nil
-    end
-  end
-
-  describe "#rassoc" do
-    it "searches for a key/val pair with a given value" do
-      hash.rassoc(1).should == [:c, 1]
-      hash.rassoc(2).should == [:b, 2]
-      hash.rassoc(3).should == [:a, 3]
-    end
-
-    it "returns nil if a matching value is not found" do
-      hash.rassoc(0).should be_nil
-      hash.rassoc(4).should be_nil
-      hash.rassoc(nil).should be_nil
-    end
-
-    it "returns nil even if there is a default" do
-      H.new(a: 1, b: 2) { fail }.rassoc(3).should be_nil
-    end
-
-    it "uses #== to compare values with provided object" do
-      hash.rassoc(EqualNotEql.new).should_not be_nil
-      hash.rassoc(EqlNotEqual.new).should be_nil
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#clear" do
-    [
-      [],
-      ["A" => "aye"],
-      ["A" => "aye", "B" => "bee", "C" => "see"],
-    ].each do |values|
-      context "on #{values}" do
-        let(:original) { H[*values] }
-        let(:result)   { original.clear }
-
-        it "preserves the original" do
-          result
-          original.should eql(H[*values])
-        end
-
-        it "returns an empty hash" do
-          result.should equal(H.empty)
-          result.should be_empty
-        end
-      end
-    end
-
-    it "maintains the default Proc, if there is one" do
-      hash = H.new(a: 1) { 1 }
-      hash.clear[:b].should == 1
-      hash.clear[:c].should == 1
-      hash.clear.default_proc.should_not be_nil
-    end
-
-    context "on a subclass" do
-      it "returns an empty instance of the subclass" do
-        subclass = Class.new(Immutable::Hash)
-        instance = subclass.new(a: 1, b: 2)
-        instance.clear.class.should be(subclass)
-        instance.clear.should be_empty
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe ".hash" do
-    context "with nothing" do
-      it "returns the canonical empty hash" do
-        H.empty.should be_empty
-        H.empty.should equal(Immutable::EmptyHash)
-      end
-    end
-
-    context "with an implicit hash" do
-      let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-      it "is equivalent to repeatedly using #put" do
-        hash.should eql(H.empty.put("A", "aye").put("B", "bee").put("C", "see"))
-        hash.size.should == 3
-      end
-    end
-
-    context "with an array of pairs" do
-      let(:hash) { H[[[:a, 1], [:b, 2]]] }
-
-      it "initializes a new Hash" do
-        hash.should eql(H[a: 1, b: 2])
-      end
-    end
-
-    context "with an Immutable::Hash" do
-      let(:hash) { H[a: 1, b: 2] }
-      let(:other) { H[hash] }
-
-      it "initializes an equivalent Hash" do
-        hash.should eql(other)
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-  [:dup, :clone].each do |method|
-    describe "##{method}" do
-      it "returns self" do
-        hash.send(method).should equal(hash)
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#default_proc" do
-    let(:hash) { H.new(1 => 2, 2 => 4) { |k| k * 2 } }
-
-    it "returns the default block given when the Hash was created" do
-      hash.default_proc.class.should be(Proc)
-      hash.default_proc.call(3).should == 6
-    end
-
-    it "returns nil if no default block was given" do
-      H.empty.default_proc.should be_nil
-    end
-
-    context "after a key/val pair are inserted" do
-      it "doesn't change" do
-        other = hash.put(3, 6)
-        other.default_proc.should be(hash.default_proc)
-        other.default_proc.call(4).should == 8
-      end
-    end
-
-    context "after all key/val pairs are filtered out" do
-      it "doesn't change" do
-        other = hash.reject { true }
-        other.default_proc.should be(hash.default_proc)
-        other.default_proc.call(4).should == 8
-      end
-    end
-
-    context "after Hash is inverted" do
-      it "doesn't change" do
-        other = hash.invert
-        other.default_proc.should be(hash.default_proc)
-        other.default_proc.call(4).should == 8
-      end
-    end
-
-    context "when a slice is taken" do
-      it "doesn't change" do
-        other = hash.slice(1)
-        other.default_proc.should be(hash.default_proc)
-        other.default_proc.call(5).should == 10
-      end
-    end
-
-    context "when keys are removed with #except" do
-      it "doesn't change" do
-        other = hash.except(1, 2)
-        other.default_proc.should be(hash.default_proc)
-        other.default_proc.call(5).should == 10
-      end
-    end
-
-    context "when Hash is mapped" do
-      it "doesn't change" do
-        other = hash.map { |k,v| [k + 10, v] }
-        other.default_proc.should be(hash.default_proc)
-        other.default_proc.call(5).should == 10
-      end
-    end
-
-    context "when another Hash is merged in" do
-      it "doesn't change" do
-        other = hash.merge(3 => 6, 4 => 8)
-        other.default_proc.should be(hash.default_proc)
-        other.default_proc.call(5).should == 10
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#delete" do
-    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-    context "with an existing key" do
-      let(:result) { hash.delete("B") }
-
-      it "preserves the original" do
-        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
-      end
-
-      it "returns a copy with the remaining key/value pairs" do
-        result.should eql(H["A" => "aye", "C" => "see"])
-      end
-    end
-
-    context "with a non-existing key" do
-      let(:result) { hash.delete("D") }
-
-      it "preserves the original values" do
-        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
-      end
-
-      it "returns self" do
-        result.should equal(hash)
-      end
-    end
-
-    context "when removing the last key" do
-      context "from a Hash with no default block" do
-        it "returns the canonical empty Hash" do
-          hash.delete('A').delete('B').delete('C').should be(Immutable::EmptyHash)
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require "spec_helper"
-require "immutable/hash"
-
-describe Immutable::Hash do
-  describe "#dig" do
-    let(:h) { H[:a => 9, :b => H[:c => 'a', :d => 4], :e => nil] }
-    it "returns the value with one argument to dig" do
-      expect(h.dig(:a)).to eq(9)
-    end
-
-    it "returns the value in nested hashes" do
-      expect(h.dig(:b, :c)).to eq('a')
-    end
-
-    it "returns nil if the key is not present" do
-      expect(h.dig(:f, :foo)).to eq(nil)
-    end
-
-    it "returns nil if you dig out the end of the hash" do
-      expect(h.dig(:f, :foo, :bar)).to eq(nil)
-    end
-
-    # This is a bit different from Ruby's Hash; it raises TypeError for
-    #   objects which don't respond to #dig
-    it "raises a NoMethodError if a value does not support #dig" do
-      expect { h.dig(:a, :foo) }.to raise_error(NoMethodError)
-    end
-
-    it "returns the correct value when there is a default proc" do
-      default_hash = H.new { |k, v| "#{k}-default" }
-      expect(default_hash.dig(:a)).to eq("a-default")
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-  [:each, :each_pair].each do |method|
-    describe "##{method}" do
-      context "with a block (internal iteration)" do
-        it "returns self" do
-          hash.send(method) {}.should be(hash)
-        end
-
-        it "yields all key/value pairs" do
-          actual_pairs = {}
-          hash.send(method) { |key, value| actual_pairs[key] = value }
-          actual_pairs.should == { "A" => "aye", "B" => "bee", "C" => "see" }
-        end
-
-        it "yields key/value pairs in the same order as #each_key and #each_value" do
-          hash.each.to_a.should eql(hash.each_key.zip(hash.each_value))
-        end
-
-        it "yields both of a pair of colliding keys" do
-          yielded = []
-          hash = H[DeterministicHash.new('a', 1) => 1, DeterministicHash.new('b', 1) => 1]
-          hash.each { |k,v| yielded << k }
-          yielded.size.should == 2
-          yielded.map { |x| x.value }.sort.should == ['a', 'b']
-        end
-
-        it "yields only the key to a block expecting |key,|" do
-          keys = []
-          hash.each { |key,| keys << key }
-          keys.sort.should == ["A", "B", "C"]
-        end
-      end
-
-      context "with no block" do
-        it "returns an Enumerator" do
-          @result = hash.send(method)
-          @result.class.should be(Enumerator)
-          @result.to_a.should == hash.to_a
-        end
-      end
-    end
-  end
-
-  describe "#each_key" do
-    it "yields all keys" do
-      keys = []
-      hash.each_key { |k| keys << k }
-      keys.sort.should == ['A', 'B', 'C']
-    end
-
-    context "with no block" do
-      it "returns an Enumerator" do
-        hash.each_key.class.should be(Enumerator)
-        hash.each_key.to_a.sort.should == ['A', 'B', 'C']
-      end
-    end
-  end
-
-  describe "#each_value" do
-    it "yields all values" do
-      values = []
-      hash.each_value { |v| values << v }
-      values.sort.should == ['aye', 'bee', 'see']
-    end
-
-    context "with no block" do
-      it "returns an Enumerator" do
-        hash.each_value.class.should be(Enumerator)
-        hash.each_value.to_a.sort.should == ['aye', 'bee', 'see']
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#each_with_index" do
-    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-    describe "with a block (internal iteration)" do
-      it "returns self" do
-        hash.each_with_index {}.should be(hash)
-      end
-
-      it "yields all key/value pairs with numeric indexes" do
-        actual_pairs = {}
-        indexes = []
-        hash.each_with_index { |(key, value), index| actual_pairs[key] = value; indexes << index }
-        actual_pairs.should == { "A" => "aye", "B" => "bee", "C" => "see" }
-        indexes.sort.should == [0, 1, 2]
-      end
-    end
-
-    describe "with no block" do
-      it "returns an Enumerator" do
-        hash.each_with_index.should be_kind_of(Enumerator)
-        hash.each_with_index.to_a.map(&:first).sort.should eql([["A", "aye"], ["B", "bee"], ["C", "see"]])
-        hash.each_with_index.to_a.map(&:last).should eql([0,1,2])
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#empty?" do
-    [
-      [[], true],
-      [["A" => "aye"], false],
-      [["A" => "aye", "B" => "bee", "C" => "see"], false],
-    ].each do |pairs, result|
-      it "returns #{result} for #{pairs.inspect}" do
-        H[*pairs].empty?.should == result
-      end
-    end
-
-    it "returns true for empty hashes which have a default block" do
-      H.new { 'default' }.empty?.should == true
-    end
-  end
-
-  describe ".empty" do
-    it "returns the canonical empty Hash" do
-      H.empty.should be_empty
-      H.empty.should be(Immutable::EmptyHash)
-    end
-
-    context "from a subclass" do
-      it "returns an empty instance of the subclass" do
-        subclass = Class.new(Immutable::Hash)
-        subclass.empty.class.should be subclass
-        subclass.empty.should be_empty
-      end
-
-      it "calls overridden #initialize when creating empty Hash" do
-        subclass = Class.new(Immutable::Hash) do
-          def initialize
-            @variable = 'value'
-          end
-        end
-        subclass.empty.instance_variable_get(:@variable).should == 'value'
-      end
-    end
-  end
-end