immutable-ruby 0.0.1

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

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  [:map, :collect].each do |method|
+    describe "##{method}" do
+      context "when empty" do
+        it "returns self" do
+          H.empty.send(method) {}.should equal(H.empty)
+        end
+      end
+
+      context "when not empty" do
+        let(:hash) { H["A" => "aye", "B"  => "bee", "C" => "see"] }
+
+        context "with a block" do
+          let(:mapped) { hash.send(method) { |key, value| [key.downcase, value.upcase] }}
+
+          it "preserves the original values" do
+            mapped
+            hash.should eql(H["A" => "aye", "B"  => "bee", "C" => "see"])
+          end
+
+          it "returns a new hash with the mapped values" do
+            mapped.should eql(H["a" => "AYE", "b"  => "BEE", "c" => "SEE"])
+          end
+        end
+
+        context "with no block" do
+          it "returns an Enumerator" do
+            hash.send(method).class.should be(Enumerator)
+            hash.send(method).each { |k,v| [k.downcase, v] }.should == hash.map { |k,v| [k.downcase, v] }
+          end
+        end
+      end
+
+      context "from a subclass" do
+        it "returns an instance of the subclass" do
+          subclass = Class.new(Immutable::Hash)
+          instance = subclass.new('a' => 'aye', 'b' => 'bee')
+          instance.map { |k,v| [k, v.upcase] }.class.should be(subclass)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#marshal_dump/#marshal_load" do
+    let(:ruby) do
+      File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
+    end
+    let(:child_cmd) do
+      %Q|#{ruby} -I lib -r immutable -e 'dict = Immutable::Hash[existing_key: 42, other_thing: "data"]; $stdout.write(Marshal.dump(dict))'|
+    end
+
+    let(:reloaded_hash) do
+      IO.popen(child_cmd, "r+") do |child|
+        reloaded_hash = Marshal.load(child)
+        child.close
+        reloaded_hash
+      end
+    end
+
+    it "can survive dumping and loading into a new process" do
+      expect(reloaded_hash).to eql(H[existing_key: 42, other_thing: "data"])
+    end
+
+    it "is still possible to find items by key after loading" do
+      expect(reloaded_hash[:existing_key]).to eq(42)
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#merge" do
+    [
+      [{}, {}, {}],
+      [{"A" => "aye"}, {}, {"A" => "aye"}],
+      [{"A" => "aye"}, {"A" => "bee"}, {"A" => "bee"}],
+      [{"A" => "aye"}, {"B" => "bee"}, {"A" => "aye", "B" => "bee"}],
+      [(1..300).zip(1..300), (150..450).zip(150..450), (1..450).zip(1..450)]
+    ].each do |a, b, expected|
+      context "for #{a.inspect} and #{b.inspect}" do
+        let(:hash_a) { H[a] }
+        let(:hash_b) { H[b] }
+        let(:result) { hash_a.merge(hash_b) }
+
+        it "returns #{expected.inspect} when passed an Immutable::Hash"  do
+          result.should eql(H[expected])
+        end
+
+        it "returns #{expected.inspect} when passed a Ruby Hash" do
+          H[a].merge(::Hash[b]).should eql(H[expected])
+        end
+
+        it "doesn't change the original Hashes" do
+          result
+          hash_a.should eql(H[a])
+          hash_b.should eql(H[b])
+        end
+      end
+    end
+
+    context "when merging with an empty Hash" do
+      it "returns self" do
+        hash = H[a: 1, b: 2]
+        hash.merge(H.empty).should be(hash)
+      end
+    end
+
+    context "when merging with subset Hash" do
+      it "returns self" do
+        big_hash   = H[(1..300).zip(1..300)]
+        small_hash = H[(1..200).zip(1..200)]
+        big_hash.merge(small_hash).should be(big_hash)
+      end
+    end
+
+    context "when called on a subclass" do
+      it "returns an instance of the subclass" do
+        subclass = Class.new(Immutable::Hash)
+        instance = subclass.new(a: 1, b: 2)
+        instance.merge(c: 3, d: 4).class.should be(subclass)
+      end
+    end
+
+    it "sets any duplicate key to the value of block if passed a block" do
+      h1 = H[a: 2, b: 1, d: 5]
+      h2 = H[a: -2, b: 4, c: -3]
+      r = h1.merge(h2) { |k,x,y| nil }
+      r.should eql(H[a: nil, b: nil, c: -3, d: 5])
+
+      r = h1.merge(h2) { |k,x,y| "#{k}:#{x+2*y}" }
+      r.should eql(H[a: "a:-2", b: "b:9", c: -3, d: 5])
+
+      lambda {
+        h1.merge(h2) { |k, x, y| raise(IndexError) }
+      }.should raise_error(IndexError)
+
+      r = h1.merge(h1) { |k,x,y| :x }
+      r.should eql(H[a: :x, b: :x, d: :x])
+    end
+
+    it "yields key/value pairs in the same order as #each" do
+      hash = H[a: 1, b: 2, c: 3]
+      each_pairs = []
+      merge_pairs = []
+      hash.each { |k, v| each_pairs << [k, v] }
+      hash.merge(hash) { |k, v1, v2| merge_pairs << [k, v1] }
+      each_pairs.should == merge_pairs
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  let(:hash) { H["a" => 3, "b" => 2, "c" => 1] }
+
+  describe "#min" do
+    it "returns the smallest key/val pair" do
+      hash.min.should == ["a", 3]
+    end
+  end
+
+  describe "#max" do
+    it "returns the largest key/val pair" do
+      hash.max.should == ["c", 1]
+    end
+  end
+
+  describe "#min_by" do
+    it "returns the smallest key/val pair (after passing it through a key function)" do
+      hash.min_by { |k,v| v }.should == ["c", 1]
+    end
+
+    it "returns the first key/val pair yielded by #each in case of a tie" do
+      hash.min_by { 0 }.should == hash.each.first
+    end
+
+    it "returns nil if the hash is empty" do
+      H.empty.min_by { |k,v| v }.should be_nil
+    end
+  end
+
+  describe "#max_by" do
+    it "returns the largest key/val pair (after passing it through a key function)" do
+      hash.max_by { |k,v| v }.should == ["a", 3]
+    end
+
+    it "returns the first key/val pair yielded by #each in case of a tie" do
+      hash.max_by { 0 }.should == hash.each.first
+    end
+
+    it "returns nil if the hash is empty" do
+      H.empty.max_by { |k,v| v }.should be_nil
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe ".new" do
+    it "is amenable to overriding of #initialize" do
+      class SnazzyHash < Immutable::Hash
+        def initialize
+          super({'snazzy?' => 'oh yeah'})
+        end
+      end
+
+      SnazzyHash.new['snazzy?'].should == 'oh yeah'
+    end
+
+    context "from a subclass" do
+      it "returns a frozen instance of the subclass" do
+        subclass = Class.new(Immutable::Hash)
+        instance = subclass.new("some" => "values")
+        instance.class.should be(subclass)
+        instance.frozen?.should be true
+      end
+    end
+
+    it "accepts an array as initializer" do
+      H.new([['a', 'b'], ['c', 'd']]).should eql(H['a' => 'b', 'c' => 'd'])
+    end
+
+    it "returns a Hash which doesn't change even if initializer is mutated" do
+      rbhash = {a: 1, b: 2}
+      hash = H.new(rbhash)
+      rbhash[:a] = 'BAD'
+      hash.should eql(H[a: 1, b: 2])
+    end
+  end
+
+  describe ".[]" do
+    it "accepts a Ruby Hash as initializer" do
+      hash = H[a: 1, b: 2]
+      hash.class.should be(Immutable::Hash)
+      hash.size.should == 2
+      hash.key?(:a).should == true
+      hash.key?(:b).should == true
+    end
+
+    it "accepts a Immutable::Hash as initializer" do
+      hash = H[H.new(a: 1, b: 2)]
+      hash.class.should be(Immutable::Hash)
+      hash.size.should == 2
+      hash.key?(:a).should == true
+      hash.key?(:b).should == true
+    end
+
+    it "accepts an array as initializer" do
+      hash = H[[[:a, 1], [:b, 2]]]
+      hash.class.should be(Immutable::Hash)
+      hash.size.should == 2
+      hash.key?(:a).should == true
+      hash.key?(:b).should == true
+    end
+
+    it "can be used with a subclass of Immutable::Hash" do
+      subclass = Class.new(Immutable::Hash)
+      instance = subclass[a: 1, b: 2]
+      instance.class.should be(subclass)
+      instance.size.should == 2
+      instance.key?(:a).should == true
+      instance.key?(:b).should == true
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#none?" do
+    context "when empty" do
+      it "with a block returns true" do
+        H.empty.none? {}.should == true
+      end
+
+      it "with no block returns true" do
+        H.empty.none?.should == true
+      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 false if the block ever returns true (#{pair.inspect})" do
+            hash.none? { |key, value| key == pair.first && value == pair.last }.should == false
+          end
+
+          it "returns true if the block always returns false" do
+            hash.none? { |key, value| key == "D" && value == "dee" }.should == true
+          end
+
+          it "stops iterating as soon as the block returns true" do
+            yielded = []
+            hash.none? { |k,v| yielded << k; true }
+            yielded.size.should == 1
+          end
+        end
+      end
+
+      context "with no block" do
+        it "returns false" do
+          hash.none?.should == false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  let(:hash) { H["a" => 1, "b" => 2, "c" => 3, "d" => 4] }
+  let(:partition) { hash.partition { |k,v| v % 2 == 0 }}
+
+  describe "#partition" do
+    it "returns a pair of Immutable::Hashes" do
+      partition.each { |h| h.class.should be(Immutable::Hash) }
+      partition.should be_frozen
+    end
+
+    it "returns key/val pairs for which predicate is true in first Hash" do
+      partition[0].should == {"b" => 2, "d" => 4}
+    end
+
+    it "returns key/val pairs for which predicate is false in second Hash" do
+      partition[1].should == {"a" => 1, "c" => 3}
+    end
+
+    it "doesn't modify the original Hash" do
+      partition
+      hash.should eql(H["a" => 1, "b" => 2, "c" => 3, "d" => 4])
+    end
+
+    context "from a subclass" do
+      it "should return instances of the subclass" do
+        subclass  = Class.new(Immutable::Hash)
+        instance  = subclass.new("a" => 1, "b" => 2, "c" => 3, "d" => 4)
+        partition = instance.partition { |k,v| v % 2 == 0 }
+        partition.each { |h| h.class.should be(subclass) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "pp"
+require "stringio"
+
+describe Immutable::Hash do
+  describe "#pretty_print" do
+    let(:hash) { Immutable::Hash.new(DeterministicHash.new(1,1) => "tin", DeterministicHash.new(2,2) => "earwax", DeterministicHash.new(3,3) => "neanderthal") }
+    let(:stringio) { StringIO.new }
+
+
+    it "prints the whole Hash on one line if it fits" do
+      PP.pp(hash, stringio, 80)
+      stringio.string.chomp.should == 'Immutable::Hash[1 => "tin", 2 => "earwax", 3 => "neanderthal"]'
+    end
+
+    it "prints each key/val pair on its own line, if not" do
+      PP.pp(hash, stringio, 20)
+      stringio.string.chomp.should == 'Immutable::Hash[
+ 1 => "tin",
+ 2 => "earwax",
+ 3 => "neanderthal"]'
+    end
+
+    it "prints keys and vals on separate lines, if space is very tight" do
+      PP.pp(hash, stringio, 15)
+      # the trailing space after "3 =>" below is needed, don't remove it
+      stringio.string.chomp.should == 'Immutable::Hash[
+ 1 => "tin",
+ 2 => "earwax",
+ 3 => 
+  "neanderthal"]'
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+describe Immutable::Hash do
+  describe "#put" do
+    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
+
+    context "with a block" do
+      it "passes the value to the block" do
+        hash.put("A") { |value| value.should == "aye" }
+      end
+
+      it "replaces the value with the result of the block" do
+        result = hash.put("A") { |value| "FLIBBLE" }
+        result.get("A").should == "FLIBBLE"
+      end
+
+      it "supports to_proc methods" do
+        result = hash.put("A", &:upcase)
+        result.get("A").should == "AYE"
+      end
+
+      context "if there is no existing association" do
+        it "passes nil to the block" do
+          hash.put("D") { |value| value.should be_nil }
+        end
+
+        it "stores the result of the block as the new value" do
+          result = hash.put("D") { |value| "FLIBBLE" }
+          result.get("D").should == "FLIBBLE"
+        end
+      end
+    end
+
+    context "with a unique key" do
+      let(:result) { hash.put("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.put("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.put("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.put(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.put(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.put(string, 'a value!')
+        string.upcase!
+        hash['a string!'].should == 'a value!'
+        hash['A STRING!'].should be_nil
+      end
+    end
+  end
+end