hamster 0.4.3 → 1.0.0

data/spec/lib/hamster/hash/sort_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash(a: 3, b: 2, c: 1) }
+
+  describe "#sort" do
+    it "returns a Vector of sorted key/val pairs" do
+      hash.sort.should eql(V[[:a, 3], [:b, 2], [:c, 1]])
+    end
+
+    it "works on large hashes" do
+      array = (1..1000).map { |n| [n,n] }
+      Hamster::Hash.new(array.shuffle).sort.should eql(Hamster::Vector.new(array))
+    end
+
+    it "uses block as comparator to sort if passed a block" do
+      hash.sort { |a,b| b <=> a }.should eql(V[[:c, 1], [:b, 2], [:a, 3]])
+    end
+  end
+
+  describe "#sort_by" do
+    it "returns a Vector of key/val pairs, sorted using the block as a key function" do
+      hash.sort_by { |k,v| v }.should eql(V[[:c, 1], [:b, 2], [:a, 3]])
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#store" do
+    let(:hash) { Hamster.hash("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(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+      end
+
+      it "returns a copy with the superset of key/value pairs" do
+        result.should eql(Hamster.hash("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(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+      end
+
+      it "returns a copy with the superset of key/value pairs" do
+        result.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "sea"))
+      end
+    end
+
+    context "with duplicate key and identical value" do
+      let(:hash) { Hamster::Hash["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) { Hamster::Hash[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) { Hamster.hash(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 = Hamster.hash.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/hamster/hash/take_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash("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 { |pair| passed << pair; true }.should == hash.to_a
+      passed.sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#to_a" do
+    it "returns an Array of [key, value] pairs in same order as #each" do
+      hash = Hamster.hash(: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/hamster/hash/to_hash_spec.rb

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

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

@@ -0,0 +1,80 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#update_in" do
+    let(:hash) {
+      Hamster::Hash[
+        "A" => "aye",
+        "B" => Hamster::Hash["C" => "see", "D" => Hamster::Hash["E" => "eee"]],
+        "F" => Hamster::Vector["G", Hamster::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/hamster/hash/values_at_spec.rb

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

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

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

data/spec/{hamster → lib/hamster}/immutable/copying_spec.rb

@@ -1,17 +1,13 @@
-require 'spec_helper'
-
-require 'hamster/immutable'
+require "spec_helper"
+require "hamster/immutable"
 
 describe Hamster::Immutable do
-
   class Fixture
     include Hamster::Immutable
   end
 
   [:dup, :clone].each do |method|
-
     describe "##{method}" do
-
       before do
         @original = Fixture.new
         @result = @original.send(method)
@@ -20,9 +16,6 @@ describe Hamster::Immutable do
       it "returns self" do
         @result.should equal(@original)
       end
-
     end
-
   end
-
-end
+end

data/spec/{hamster → lib/hamster}/immutable/immutable_spec.rb

@@ -1,13 +1,9 @@
-require 'spec_helper'
-
-require 'hamster/immutable'
+require "spec_helper"
+require "hamster/immutable"
 
 describe Hamster::Immutable do
-
   describe "#immutable?" do
-
     describe "object constructed after its class becomes Immutable" do
-
       class Fixture
         include Hamster::Immutable
       end
@@ -19,11 +15,9 @@ describe Hamster::Immutable do
       it "returns true" do
         @fixture.should be_immutable
       end
-
     end
 
     describe "object constructed before its class becomes Immutable" do
-
       before do
         @fixture = Class.new.new
         @fixture.class.instance_eval do
@@ -32,15 +26,12 @@ describe Hamster::Immutable do
       end
 
       describe "that are not frozen" do
-
         it "returns false" do
           @fixture.should_not be_immutable
         end
-
       end
 
       describe "that are frozen" do
-
         before do
           @fixture.freeze
         end
@@ -48,11 +39,7 @@ describe Hamster::Immutable do
         it "returns true" do
           @fixture.should be_immutable
         end
-
       end
-
     end
-
   end
-
-end
+end

data/spec/lib/hamster/immutable/memoize_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+require "hamster/immutable"
+
+describe Hamster::Immutable do
+  class Fixture
+    include Hamster::Immutable
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def call
+      @block.call
+    end
+    memoize :call
+
+    def copy
+      transform {}
+    end
+  end
+
+  let(:immutable) { Fixture.new { @count += 1 } }
+
+  describe "#memoize" do
+    before(:each) do
+      @count = 0
+      immutable.call
+    end
+
+    it "keeps the receiver frozen and immutable" do
+      expect(immutable).to be_immutable
+    end
+
+    context "when called multiple times" do
+      before(:each) do
+        immutable.call
+      end
+
+      it "doesn't evaluate the memoized method more than once" do
+        expect(@count).to eq(1)
+      end
+    end
+
+    describe "when making a copy" do
+      let(:copy) { immutable.copy }
+
+      before(:each) do
+        copy.call
+      end
+
+      it "clears all memory" do
+        expect(@count).to eq(2)
+      end
+    end
+  end
+end