immutable-ruby 0.0.1 → 0.1.0

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

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

@@ -1,69 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-  describe "#eql?" do
-    it "returns false when comparing with a standard hash" do
-      hash.eql?("A" => "aye", "B" => "bee", "C" => "see").should == false
-    end
-
-    it "returns false when comparing with an arbitrary object" do
-      hash.eql?(Object.new).should == false
-    end
-
-    it "returns false when comparing with a subclass of Immutable::Hash" do
-      subclass = Class.new(Immutable::Hash)
-      instance = subclass.new("A" => "aye", "B" => "bee", "C" => "see")
-      hash.eql?(instance).should == false
-    end
-  end
-
-  describe "#==" do
-    it "returns true when comparing with a standard hash" do
-      (hash == {"A" => "aye", "B" => "bee", "C" => "see"}).should == true
-    end
-
-    it "returns false when comparing with an arbitrary object" do
-      (hash == Object.new).should == false
-    end
-
-    it "returns true when comparing with a subclass of Immutable::Hash" do
-      subclass = Class.new(Immutable::Hash)
-      instance = subclass.new("A" => "aye", "B" => "bee", "C" => "see")
-      (hash == instance).should == true
-    end
-  end
-
-  [:eql?, :==].each do |method|
-    describe "##{method}" do
-      [
-        [{}, {}, true],
-        [{ "A" => "aye" }, {}, false],
-        [{}, { "A" => "aye" }, false],
-        [{ "A" => "aye" }, { "A" => "aye" }, true],
-        [{ "A" => "aye" }, { "B" => "bee" }, false],
-        [{ "A" => "aye", "B" => "bee" }, { "A" => "aye" }, false],
-        [{ "A" => "aye" }, { "A" => "aye", "B" => "bee" }, false],
-        [{ "A" => "aye", "B" => "bee", "C" => "see" }, { "A" => "aye", "B" => "bee", "C" => "see" }, true],
-        [{ "C" => "see", "A" => "aye", "B" => "bee" }, { "A" => "aye", "B" => "bee", "C" => "see" }, true],
-      ].each do |a, b, expected|
-        describe "returns #{expected.inspect}" do
-          it "for #{a.inspect} and #{b.inspect}" do
-            H[a].send(method, H[b]).should == expected
-          end
-
-          it "for #{b.inspect} and #{a.inspect}" do
-            H[b].send(method, H[a]).should == expected
-          end
-        end
-      end
-    end
-  end
-
-  it "returns true on a large hash which is modified and then modified back again" do
-    hash = H.new((1..1000).zip(2..1001))
-    hash.put('a', 1).delete('a').should == hash
-    hash.put('b', 2).delete('b').should eql(hash)
-  end
-end

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

@@ -1,42 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#except" do
-    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"] }
-
-    context "with only keys that the Hash has" do
-      it "returns a Hash without those values" do
-        hash.except("B", nil).should eql(H["A" => "aye", "C" => "see"])
-      end
-
-      it "doesn't change the original Hash" do
-        hash.except("B", nil)
-        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"])
-      end
-    end
-
-    context "with keys that the Hash doesn't have" do
-      it "returns a Hash without the values that it had keys for" do
-        hash.except("B", "A", 3).should eql(H["C" => "see", nil => "NIL"])
-      end
-
-      it "doesn't change the original Hash" do
-        hash.except("B", "A", 3)
-        hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"])
-      end
-    end
-
-    it "works on a large Hash, with many combinations of input" do
-      keys = (1..1000).to_a
-      original = H.new(keys.zip(2..1001))
-      100.times do
-        to_remove = rand(100).times.collect { keys.sample }
-        result    = original.except(*to_remove)
-        result.size.should == original.size - to_remove.uniq.size
-        to_remove.each { |key| result.key?(key).should == false }
-        (keys.sample(100) - to_remove).each { |key| result.key?(key).should == true }
-      end
-      original.should eql(H.new(keys.zip(2..1001))) # shouldn't have changed
-    end
-  end
-end