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

data/spec/hamster/hash/delete_spec.rb

@@ -1,38 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe "#delete" do
-    before do
-      @original = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-    end
-
-    describe "with an existing key" do
-      before do
-        @result = @original.delete("B")
-      end
-
-      it "preserves the original" do
-        @original.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      it "returns a copy with the remaining key/value pairs" do
-        @result.should == Hamster.hash("A" => "aye", "C" => "see")
-      end
-    end
-
-    describe "with a non-existing key" do
-      before do
-        @result = @original.delete("D")
-      end
-
-      it "preserves the original values" do
-        @original.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      it "returns self" do
-        @result.should equal(@original)
-      end
-    end
-  end
-end

data/spec/hamster/hash/each_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:each, :foreach].each do |method|
-    describe "##{method}" do
-      before do
-        @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      describe "with a block (internal iteration)" do
-        it "returns nil" do
-          @hash.send(method) {}.should be_nil
-        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
-      end
-
-      describe "with no block" do
-        it "returns self" do
-          @hash.send(method).should equal(@hash)
-        end
-      end
-    end
-  end
-end

data/spec/hamster/hash/empty_spec.rb

@@ -1,27 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:empty?, :null?].each do |method|
-    describe "##{method}" do
-      [
-        [[], 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).send(method).should == result
-        end
-
-        context "from a subclass" do
-          it "returns an instance of the subclass" do
-            @subclass = Class.new(Hamster::Hash)
-            @subclass.empty.class.should be @subclass
-            @subclass.empty.should be_empty
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/hash/eql_spec.rb

@@ -1,70 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe "#eql?" do
-    describe "returns false when comparing with" do
-      before do
-        @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      it "a standard hash" do
-        @hash.eql?("A" => "aye", "B" => "bee", "C" => "see").should == false
-      end
-
-      it "an arbitrary object" do
-        @hash.eql?(Object.new).should == false
-      end
-    end
-  end
-
-  describe "#==" do
-    describe "returns true when comparing with" do
-      before do
-        @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      it "a standard hash" do
-        (@hash == {"A" => "aye", "B" => "bee", "C" => "see"}).should == true
-      end
-    end
-
-    describe "returns false when comparing with" do
-      it "an arbitrary object" do
-        (@hash == Object.new).should == false
-      end
-    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
-          before do
-            @a = Hamster.hash(a)
-            @b = Hamster.hash(b)
-          end
-
-          it "for #{a.inspect} and #{b.inspect}" do
-            @a.send(method, @b).should == expected
-          end
-
-          it "for #{b.inspect} and #{a.inspect}" do
-            @b.send(method, @a).should == expected
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/hash/except_spec.rb

@@ -1,22 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe "#except" do
-    before do
-      @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL")
-    end
-
-    describe "with only keys that the Hash has" do
-      it "returns a Hash without those values" do
-        @hash.except("B", nil).should == Hamster.hash("A" => "aye", "C" => "see")
-      end
-    end
-
-    describe "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 == Hamster.hash("C" => "see", nil => "NIL")
-      end
-    end
-  end
-end

data/spec/hamster/hash/fetch_spec.rb

@@ -1,72 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe "#fetch" do
-    describe "with no default provided" do
-      describe "when the key exists" do
-        before do
-          @hash = Hamster.hash("A" => "aye")
-        end
-
-        it "returns the value associated with the key" do
-          @hash.fetch("A").should == "aye"
-        end
-      end
-
-      describe "when the key does not exist" do
-        before do
-          @hash = Hamster.hash("A" => "aye")
-        end
-
-        it "raises a KeyError" do
-          -> { @hash.fetch("B") }.should raise_error(KeyError)
-        end
-      end
-    end
-
-    describe "with a default value" do
-      describe "when the key exists" do
-        before do
-          @hash = Hamster.hash("A" => "aye")
-        end
-
-        it "returns the value associated with the key" do
-          @hash.fetch("A", "default").should == "aye"
-        end
-      end
-
-      describe "when the key does not exist" do
-        before do
-          @hash = Hamster.hash("A" => "aye")
-        end
-
-        it "returns the default value" do
-          @hash.fetch("B", "default").should == "default"
-        end
-      end
-    end
-
-    describe "with a default block" do
-      describe "when the key exists" do
-        before do
-          @hash = Hamster.hash("A" => "aye")
-        end
-
-        it "returns the value associated with the key" do
-          @hash.fetch("A") { "default".upcase }.should == "aye"
-        end
-      end
-
-      describe "when the key does not exist" do
-        before do
-          @hash = Hamster.hash("A" => "aye")
-        end
-
-        it "returns the default value" do
-          @hash.fetch("B") { "default".upcase }.should == "DEFAULT"
-        end
-      end
-    end
-  end
-end

data/spec/hamster/hash/filter_spec.rb

@@ -1,48 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:filter, :select, :find_all].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
-            @result = @original.send(method)
-          end
-
-          it "returns self" do
-            @result.should equal(@original)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/hash/find_spec.rb

@@ -1,45 +0,0 @@
-require "spec_helper"
-require "hamster/tuple"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:find, :detect].each do |method|
-    describe "##{method}" do
-
-      [
-        [[], "A", nil],
-        [[], nil, nil],
-        [["A" => "aye"], "A", Hamster::Tuple.new("A", "aye")],
-        [["A" => "aye"], "B", nil],
-        [["A" => "aye"], nil, nil],
-        [["A" => "aye", "B" => "bee", nil => "NIL"], "A", Hamster::Tuple.new("A", "aye")],
-        [["A" => "aye", "B" => "bee", nil => "NIL"], "B", Hamster::Tuple.new("B", "bee")],
-        [["A" => "aye", "B" => "bee", nil => "NIL"], nil, Hamster::Tuple.new(nil, "NIL")],
-        [["A" => "aye", "B" => "bee", nil => "NIL"], "C", nil],
-      ].each do |values, key, expected|
-
-        describe "on #{values.inspect}" do
-          before do
-            @hash = Hamster.hash(*values)
-          end
-
-          describe "with a block" do
-            before do
-              @result = @hash.send(method) { |k, v| k == key }
-            end
-
-            it "returns #{expected.inspect}" do
-              @result.should == expected
-            end
-          end
-
-          describe "without a block" do
-            it "returns nil" do
-              @hash.send(method).should be_nil
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/hash/get_spec.rb

@@ -1,55 +0,0 @@
-require "spec_helper"
-
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:get, :[]].each do |method|
-    describe "##{method}" do
-      describe "with a default block" do
-        describe "when the key exists" do
-          before do
-            @hash = Hamster.hash("A" => "aye") { |key| fail }
-          end
-
-          it "returns the value associated with the key" do
-            @hash.get("A").should == "aye"
-          end
-        end
-
-        describe "when the key does not exist" do
-          before do
-            @hash = Hamster.hash("A" => "aye") do |key|
-              expect(key).to eq("B")
-              "bee"
-            end
-          end
-
-          it "returns the value associated with the key" do
-            @hash.get("B").should == "bee"
-          end
-        end
-      end
-
-      describe "with no default block" do
-        before do
-          @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL")
-        end
-
-        [
-          %w[A aye],
-          %w[B bee],
-          %w[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
-    end
-  end
-end

data/spec/hamster/hash/has_key_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:key?, :has_key?, :include?, :member?].each do |method|
-    describe "##{method}" do
-      before do
-        @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL", 2.0 => "two")
-      end
-
-      ["A", "B", "C", nil, 2.0].each do |key|
-        it "returns true for an existing key (#{key.inspect})" do
-          @hash.send(method, key).should == true
-        end
-      end
-
-      it "returns false for a non-existing key" do
-        @hash.send(method, "D").should == false
-      end
-
-      it "uses #eql? for equality" do
-        @hash.send(method, 2).should == false
-      end
-    end
-  end
-end

data/spec/hamster/hash/inspect_spec.rb

@@ -1,24 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe "#inspect" do
-    [
-      [[], "{}"],
-      [["A" => "aye"], "{\"A\" => \"aye\"}"],
-      [[DeterministicHash.new("A", 1) => "aye", DeterministicHash.new("B", 2) => "bee", DeterministicHash.new("C", 3) => "see"], "{\"A\" => \"aye\", \"B\" => \"bee\", \"C\" => \"see\"}"]
-    ].each do |values, expected|
-
-      describe "on #{values.inspect}" do
-        before do
-          original = Hamster.hash(*values)
-          @result = original.inspect
-        end
-
-        it "returns #{expected.inspect}" do
-          @result.should == expected
-        end
-      end
-    end
-  end
-end