hamster 1.0.1.pre.rc2 → 1.0.1.pre.rc3

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

@@ -0,0 +1,62 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  [:remove, :reject, :delete_if].each do |method|
+    describe "##{method}" do
+      let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+
+      context "when nothing matches" do
+        it "returns self" do
+          hash.send(method) { |key, value| false }.should equal(hash)
+        end
+      end
+
+      context "when only some things match" do
+        context "with a block" do
+          let(:result) { hash.send(method) { |key, value| key == "A" && value == "aye" }}
+
+          it "preserves the original" do
+            result
+            hash.should eql(Hamster.hash("A" => "aye", "B" => "bee", "C" => "see"))
+          end
+
+          it "returns a set with the matching values" do
+            result.should eql(Hamster.hash("B" => "bee", "C" => "see"))
+          end
+
+          it "yields entries in the same order as #each" do
+            each_pairs = []
+            remove_pairs = []
+            hash.each_pair { |k,v| each_pairs << [k,v] }
+            hash.send(method) { |k,v| remove_pairs << [k,v] }
+            each_pairs.should == remove_pairs
+          end
+        end
+
+        context "with no block" do
+          it "returns an Enumerator" do
+            hash.send(method).class.should be(Enumerator)
+            hash.send(method).to_a.sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
+            hash.send(method).each { true }.should eql(Hamster.hash)
+          end
+        end
+
+        context "on a large hash, with many combinations of input" do
+          it "still works" do
+            array = 1000.times.collect { |n| [n, n] }
+            hash  = Hamster::Hash.new(array)
+            [0, 10, 100, 200, 500, 800, 900, 999, 1000].each do |threshold|
+              result = hash.send(method) { |k,v| k >= threshold}
+              result.size.should == threshold
+              0.upto(threshold-1) { |n| result.key?(n).should == true }
+              threshold.upto(1000) { |n| result.key?(n).should == false }
+            end
+            # shouldn't have changed
+            hash.should eql(Hamster::Hash.new(1000.times.collect { |n| [n, n] }))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
+
+  describe "#reverse_each" do
+    context "with a block" do
+      it "returns self" do
+        hash.reverse_each {}.should be(hash)
+      end
+
+      it "yields all key/value pairs in the opposite order as #each" do
+        result = []
+        hash.reverse_each { |entry| result << entry }
+        result.should eql(hash.to_a.reverse)
+      end
+    end
+
+    context "with no block" do
+      it "returns an Enumerator" do
+        result = hash.reverse_each
+        result.class.should be(Enumerator)
+        result.to_a.should eql(hash.to_a.reverse)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#sample" do
+    let(:hash) { Hamster::Hash.new((:a..:z).zip(1..26)) }
+
+    it "returns a randomly chosen item" do
+      chosen = 250.times.map { hash.sample }.sort.uniq
+      chosen.each { |item| hash.include?(item[0]).should == true }
+      hash.each { |item| chosen.include?(item).should == true }
+    end
+  end
+end

data/spec/{hamster → lib/hamster}/hash/size_spec.rb

@@ -19,7 +19,7 @@ describe Hamster::Hash do
       srand 89_533_474
       random_things = (lots + lots).sort_by { |x|rand }
 
-      it "should have the correct size after adding lots of things with colliding keys and such" do
+      it "has the correct size after adding lots of things with colliding keys and such" do
         h = Hamster.hash
         random_things.each do |thing|
           h = h.put(thing, thing * 2)
@@ -36,7 +36,7 @@ describe Hamster::Hash do
         end
         h
       end.size
-      it "should have the correct size after lots of addings and removings" do
+      it "has the correct size after lots of addings and removings" do
         h = Hamster.hash
         random_actions.each do |(act, ob)|
           if act == :add

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

@@ -0,0 +1,45 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster::Hash.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL") }
+
+  describe "#slice" do
+    let(:slice) { hash.slice(*values) }
+
+    context "with all keys present in the Hash" do
+      let(:values) { ["B", nil] }
+
+      it "returns the sliced values" do
+        expect(slice).to eq(described_class.new("B" => "bee", nil => "NIL"))
+      end
+
+      it "doesn't modify the original Hash" do
+        slice
+        hash.should eql(Hamster::Hash.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"))
+      end
+    end
+
+    context "with keys aren't present in the Hash" do
+      let(:values) { ["B", "A", 3] }
+
+      it "returns the sliced values of the matching keys" do
+        expect(slice).to eq(described_class.new("A" => "aye", "B" => "bee"))
+      end
+
+      it "doesn't modify the original Hash" do
+        slice
+        hash.should eql(Hamster::Hash.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"))
+      end
+    end
+
+    context "on a Hash with a default block" do
+      let(:hash) { Hamster.hash('A' => 'aye', 'B' => 'bee') { 'nothing' }}
+      let(:values) { ["B", nil] }
+
+      it "maintains the default block" do
+        expect(slice['C']).to eq('nothing')
+      end
+    end
+  end
+end

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,54 @@
+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 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/{hamster → lib/hamster}/hash/uniq_spec.rb

@@ -2,14 +2,12 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  before do
-    @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-  end
+  let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see") }
 
   [:uniq, :nub, :remove_duplicates].each do |method|
     describe "##{method}" do
       it "returns self" do
-        @hash.send(method).should equal(@hash)
+        hash.send(method).should equal(hash)
       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/memoize_spec.rb

@@ -27,7 +27,7 @@ describe Hamster::Immutable do
       immutable.call
     end
 
-    it "should still freezes be immutable" do
+    it "keeps the receiver frozen and immutable" do
       expect(immutable).to be_immutable
     end
 
@@ -48,7 +48,7 @@ describe Hamster::Immutable do
         copy.call
       end
 
-      it "should clear all memory" do
+      it "clears all memory" do
         expect(@count).to eq(2)
       end
     end

data/spec/lib/hamster/list/add_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#add" do
+    it "adds an item onto the end of a list" do
+      list = Hamster.list("a", "b")
+      list.add("c").should eql(Hamster.list("a", "b", "c"))
+      list.should eql(Hamster.list("a", "b"))
+    end
+
+    context "on an empty list" do
+      it "returns a list with one item" do
+        list = Hamster.list
+        list.add("c").should eql(Hamster.list("c"))
+        list.should eql(Hamster.list)
+      end
+    end
+  end
+end

data/spec/lib/hamster/list/all_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  [:all?, :forall?].each do |method|
+    describe "##{method}" do
+      context "on a really big list" do
+        let(:list) { Hamster.interval(0, STACK_OVERFLOW_DEPTH) }
+
+        it "doesn't run out of stack" do
+          -> { list.send(method) }.should_not raise_error
+        end
+      end
+
+      context "when empty" do
+        it "with a block returns true" do
+          Hamster.list.send(method) {}.should == true
+        end
+
+        it "with no block returns true" do
+          Hamster.list.send(method).should == true
+        end
+      end
+
+      context "when not empty" do
+        context "with a block" do
+          let(:list) { Hamster.list("A", "B", "C") }
+
+          context "if the block always returns true" do
+            it "returns true" do
+              list.send(method) { |item| true }.should == true
+            end
+          end
+
+          context "if the block ever returns false" do
+            it "returns false" do
+              list.send(method) { |item| item == "D" }.should == false
+            end
+          end
+        end
+
+        context "with no block" do
+          context "if all values are truthy" do
+            it "returns true" do
+              Hamster.list(true, "A").send(method).should == true
+            end
+          end
+
+          [nil, false].each do |value|
+            context "if any value is #{value.inspect}" do
+              it "returns false" do
+                Hamster.list(value, true, "A").send(method).should == false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end