hamster 0.1.8 → 0.1.11

data/spec/hamster/hash/empty_spec.rb

@@ -4,12 +4,16 @@ describe Hamster::Hash do
 
   describe "#empty?" do
 
-    it "initially returns true" do
-      Hamster::Hash.new.should be_empty
-    end
+    [
+      [[], true],
+      [["A" => "aye"], false],
+      [["A" => "aye", "B" => "bee", "C" => "see"], false],
+    ].each do |pairs, result|
+
+      it "returns #{result} for #{pairs.inspect}" do
+        Hamster.hash(*pairs).empty?.should == result
+      end
 
-    it "returns false once items have been added" do
-      Hamster::Hash.new.put("A", "aye").should_not be_empty
     end
 
   end

data/spec/hamster/hash/eql_spec.rb

@@ -2,33 +2,28 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Hamster::Hash do
 
-  describe "#eql?" do
+  [:eql?, :==].each do |method|
 
-    it "is true for the same instance" do
-      hash = Hamster::Hash.new
-      hash.should eql(hash)
-    end
+    describe "##{method}" do
 
-    it "is true for two empty instances" do
-      Hamster::Hash.new.should eql(Hamster::Hash.new)
-    end
+      [
+        [[], [], 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, result|
 
-    it "is true for two instances with the same key/value pairs" do
-      a = Hamster::Hash.new.put("a", "Aye").put("b", "Bee").put("c", "See")
-      b = Hamster::Hash.new.put("a", "Aye").put("b", "Bee").put("c", "See")
-      a.should eql(b)
-    end
+        it "returns #{result} for #{a.inspect} and #{b.inspect}" do
+          Hamster.hash(*a).send(method, Hamster.hash(*b)).should == result
+        end
 
-    it "is false for two instances with different key/value pairs" do
-      a = Hamster::Hash.new.put("a", "Aye").put("b", "Bee").put("c", "See")
-      b = Hamster::Hash.new.put("a", "Aye").put("b", "Bee").put("d", "Dee")
-      a.should_not eql(b)
-    end
+      end
 
-    it "is false for two instances with different numbers of overlapping key/value pairs" do
-      a = Hamster::Hash.new.put("a", "Aye").put("b", "Bee").put("c", "See")
-      b = Hamster::Hash.new.put("a", "Aye").put("b", "Bee")
-      a.should_not eql(b)
     end
 
   end

data/spec/hamster/hash/filter_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Hamster::Hash do
+
+  [:filter, :select].each do |method|
+
+    describe "##{method}" do
+
+      before do
+        @original = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
+      end
+
+      describe "when everything matches" do
+
+        before do
+          @result = @original.send(method) { |key, value| true }
+        end
+
+        it "returns self" do
+          @result.should equal(@original)
+        end
+
+      end
+
+      describe "when only some things match" do
+
+        describe "with a block" do
+
+          before do
+            @result = @original.send(method) { |key, value| key == "A" && value == "aye" }
+          end
+
+          it "preserves the original" do
+            @original.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
+          end
+
+          it "returns a set with the matching values" do
+            @result.should == Hamster.hash("A" => "aye")
+          end
+
+        end
+
+        describe "with no block" do
+
+          before do
+            @enumerator = @original.send(method)
+          end
+
+          it "returns an enumerator over the values" do
+            Hamster.hash(@enumerator.to_a).should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/hash/get_spec.rb

@@ -2,21 +2,33 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Hamster::Hash do
 
-  describe "#get" do
+  [:get, :[]].each do |method|
 
-    before do
-      @hash = Hamster::Hash.new
-      @hash = @hash.put("A", "aye")
-    end
+    describe "##{method}" do
 
-    it "returns the value for an existing key" do
-      @hash.get("A").should == "aye"
-    end
+      before do
+        @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL")
+      end
+
+      [
+        ["A", "aye"],
+        ["B", "bee"],
+        ["C", "see"],
+        [nil, "NIL"]
+        ].each do |key, value|
+
+          it "returns the value (#{value.inspect}) for an existing key (#{key.inspect})" do
+            @hash.send(method, key).should == value
+          end
+
+        end
+
+        it "returns nil for a non-existing key" do
+          @hash.send(method, "D").should be_nil
+        end
+
+      end
 
-    it "returns nil for a non-existing key" do
-      @hash.get("B").should be_nil
     end
 
   end
-
-end

data/spec/hamster/hash/has_key_spec.rb

@@ -2,22 +2,26 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Hamster::Hash do
 
-  describe "#has_key?" do
+  [:has_key?, :key?, :include?, :member?].each do |method|
 
-    before do
-      @hash = Hamster::Hash.new.put("A", "aye").put("NIL", nil)
-    end
+    describe "#has_key?" do
 
-    it "returns true for an existing key" do
-      @hash.has_key?("A").should be_true
-    end
+      before do
+        @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL")
+      end
+
+      ["A", "B", "C", nil].each do |key|
+
+        it "returns true for an existing key (#{key.inspect})" do
+          @hash.send(method, key).should be_true
+        end
+
+      end
+
+      it "returns false for a non-existing key" do
+        @hash.send(method, "D").should be_false
+      end
 
-    it "returns false for a non-existing key" do
-      @hash.has_key?("B").should be_false
-    end
-    
-    it "returns true for a nil value" do
-      @hash.has_key?("NIL").should be_true
     end
 
   end

data/spec/hamster/hash/map_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Hamster::Hash do
+
+  [:map, :collect].each do |method|
+
+    describe "##{method}" do
+
+      describe "when empty" do
+
+        before do
+          @original = Hamster.hash
+          @mapped = @original.send(method) {}
+        end
+
+        it "returns self" do
+          @mapped.should equal(@original)
+        end
+
+      end
+
+      describe "when not empty" do
+
+        before do
+          @original = Hamster.hash("A" => "aye", "B"  => "bee", "C" => "see")
+        end
+
+        describe "with a block" do
+
+          before do
+            @mapped = @original.send(method) { |key, value| [key.downcase, value.upcase] }
+          end
+
+          it "preserves the original values" do
+            @original.should == Hamster.hash("A" => "aye", "B"  => "bee", "C" => "see")
+          end
+
+          it "returns a new hash with the mapped values" do
+            @mapped.should == Hamster.hash("a" => "AYE", "b"  => "BEE", "c" => "SEE")
+          end
+
+        end
+
+        describe "with no block" do
+
+          before do
+            @enumerator = @original.send(method)
+          end
+
+          it "preserves the original values" do
+            @original.should == Hamster.hash("A" => "aye", "B"  => "bee", "C" => "see")
+          end
+
+          it "returns an enumerator over the key value pairs" do
+            Hamster.hash(@enumerator.to_a).should == @original
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/hash/none_spec.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Hamster::Hash do
+
+  describe "#none?" do
+
+    describe "when empty" do
+
+      before do
+        @hash = Hamster.hash
+      end
+
+      it "with a block returns true" do
+        @hash.none? {}.should be_true
+      end
+
+      it "with no block returns true" do
+        @hash.none?.should be_true
+      end
+
+    end
+
+    describe "when not empty" do
+
+      before do
+        @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL")
+      end
+
+      describe "with a block" do
+
+        [
+          ["A", "aye"],
+          ["B", "bee"],
+          ["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 be_false
+          end
+
+          it "returns true if the block always returns false" do
+            @hash.none? { |key, value| key == "D" && value == "dee" }.should be_true
+          end
+
+        end
+
+      end
+
+      describe "with no block" do
+
+        it "returns false" do
+          @hash.none?.should be_false
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/hash/put_spec.rb

@@ -2,104 +2,48 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Hamster::Hash do
 
-  describe "#put" do
+  [:put, :[]=].each do |method|
 
-    describe "with a key/value pair that already exists" do
+    describe "##{method}" do
 
       before do
-        @original = Hamster::Hash.new.put("A", "aye").put("B", "bee")
-        @copy = @original.put("A", "yes")
+        @original = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
       end
 
-      it "returns a modified copy" do
-        @copy.should_not equal(@original)
-      end
-
-      describe "the original" do
-
-        it "still has the original key/value pairs" do
-          @original.get("A").should == "aye"
-          @original.get("B").should == "bee"
-        end
-
-        it "still has the original size" do
-          @original.size.should == 2
-        end
-
-      end
-
-      describe "the modified copy" do
-
-        it "has the new key/value pairs" do
-          @copy.get("A").should == "yes"
-          @copy.get("B").should == "bee"
-        end
-
-        it "has the original size" do
-          @copy.size == 2
-        end
-
-      end
-
-    end
-
-    describe "with a key/value pair that doesn't exist" do
-
-      before do
-        @original = Hamster::Hash.new.put("A", "aye")
-        @copy = @original.put("B", "bee")
-      end
-
-      it "returns a modified copy" do
-        @copy.should_not equal(@original)
-      end
-
-      describe "the original" do
+      describe "with a unique key" do
 
-        it "still has the original key/value pairs" do
-          @original.get("A").should == "aye"
+        before do
+          @result = @original.send(method, "D", "dee")
         end
 
-        it "doesn't contain the new key/value pair" do
-          @original.has_key?("B").should be_false
+        it "preserves the original" do
+          @original.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
         end
 
-        it "still has the original size" do
-          @original.size.should == 1
+        it "returns a copy with the superset of key/value pairs" do
+          @result.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", "D" => "dee")
         end
 
       end
 
-      describe "the modified copy" do
+      describe "with a duplicate key" do
 
-        it "has the original key/value pairs" do
-          @copy.get("A").should == "aye"
+        before do
+          @result = @original.send(method, "C", "sea")
         end
 
-        it "has the new key/value pair" do
-          @copy.get("B").should == "bee"
+        it "preserves the original" do
+          @original.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
         end
 
-        it "size is increased by one" do
-          @copy.size.should == 2
+        it "returns a copy with the superset of key/value pairs" do
+          @result.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "sea")
         end
 
       end
 
     end
 
-    describe "with a nil key" do
-
-      before do
-        @hash = Hamster::Hash.new.put(nil, "NIL")
-      end
-
-      it "can locate the key/value pair" do
-        @hash.get(nil).should == "NIL"
-      end
-
-    end
-
   end
 
 end