hamster 0.4.3 → 1.0.0

data/spec/hamster/hash/put_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-require 'hamster/hash'
-
-describe Hamster::Hash do
-
-  describe "#put" do
-
-    before do
-      @original = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-    end
-
-    describe "with a block" do
-
-      it "passes the value to the block" do
-        @original.put("A") { |value| value.should == "aye" }
-      end
-
-      it "replaces the value with the result of the block" do
-        result = @original.put("A") { |value| "FLIBBLE" }
-        result.get("A").should == "FLIBBLE"
-      end
-
-      it "supports to_proc methods" do
-        result = @original.put("A", &:upcase)
-        result.get("A").should == "AYE"
-      end
-
-    end
-
-    describe "with a unique key" do
-
-      before do
-        @result = @original.put("D", "dee")
-      end
-
-      it "preserves the original" do
-        @original.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      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 "with a duplicate key" do
-
-      before do
-        @result = @original.put("C", "sea")
-      end
-
-      it "preserves the original" do
-        @original.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      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
-
-end

data/spec/hamster/hash/reduce_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-require 'hamster/hash'
-
-describe Hamster::Hash do
-
-  [:reduce, :inject, :fold, :foldr].each do |method|
-
-    describe "##{method}" do
-
-      describe "when empty" do
-
-        before do
-          @original = Hamster.hash
-          @result = @original.send(method, "ABC") {}
-        end
-
-        it "returns the memo" do
-          @result.should == "ABC"
-        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
-            @result = @original.send(method, 0) { |memo, key, value| memo + 1 }
-          end
-
-          it "returns the final memo" do
-            @result.should == 3
-          end
-
-        end
-
-        describe "with no block" do
-
-          before do
-            @result = @original.send(method, "ABC")
-          end
-
-          it "returns the memo" do
-            @result.should == "ABC"
-          end
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/spec/hamster/hash/remove_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-require 'hamster/hash'
-
-describe Hamster::Hash do
-
-  [:remove, :reject, :delete_if].each do |method|
-
-    describe "##{method}" do
-
-      before do
-        @original = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      describe "when nothing matches" do
-
-        before do
-          @result = @original.send(method) { |key, value| false }
-        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("B" => "bee", "C" => "see")
-          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/slice_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-require 'hamster/hash'
-
-describe Hamster::Hash do
-
-  describe "#slice" 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 with only those values" do
-        @hash.slice("B", nil).should == Hamster.hash("B" => "bee", nil => "NIL")
-      end
-
-    end
-
-    describe "with keys that the Hash doesn't have" do
-
-      it "returns a Hash with only the values that have matching keys" do
-        @hash.slice("B", "A", 3).should == Hamster.hash("A" => "aye", "B" => "bee")
-      end
-
-    end
-
-  end
-
-end

data/spec/hamster/hash/uniq_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-require 'hamster/hash'
-
-describe Hamster::Hash do
-
-  before do
-    @hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-  end
-
-  [:uniq, :nub, :remove_duplicates].each do |method|
-
-    describe "##{method}" do
-
-      it "returns self" do
-        @hash.send(method).should equal(@hash)
-      end
-
-    end
-
-  end
-
-end

data/spec/hamster/hash/values_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-require 'hamster/hash'
-require 'hamster/set'
-
-describe Hamster::Hash do
-
-  describe "#values" do
-
-    before do
-      hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      @result = hash.values
-    end
-
-    it "returns the keys as a list" do
-      @result.should be_a Hamster::List
-      @result.to_a.sort.should == %w(aye bee see)
-    end
-
-  end
-
-  describe "#values with duplicates" do
-    before do
-      hash = Hamster.hash(:A => 15, :B => 19, :C => 15)
-      @result = hash.values
-    end
-
-    it "returns the keys as a list" do
-      @result.should be_a Hamster::List
-      @result.to_a.sort.should == [15,15,19]
-    end
-  end
-
-end

data/spec/hamster/immutable/memoize_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-require 'hamster/immutable'
-
-describe Hamster::Immutable do
-
-  describe "#memoize" do
-
-    class Fixture
-      include Hamster::Immutable
-
-      def initialize(&block)
-        @block = block
-      end
-
-      def call
-        @block.call
-      end
-      memoize :call
-
-      def copy
-        transform {}
-      end
-
-    end
-
-    before do
-      @count = 0
-      @fixture = Fixture.new { @count += 1 }
-      @fixture.call
-    end
-
-    it "should still freezes be immutable" do
-      @fixture.should be_immutable
-    end
-
-    describe "when called multiple times" do
-
-      before do
-        @fixture.call
-      end
-
-      it "a memoized method will only be evaluated once" do
-        @count.should == 1
-      end
-
-    end
-
-    describe "when making a copy" do
-
-      before do
-        @copy = @fixture.copy
-        @copy.call
-      end
-
-      it "should clear all memory" do
-        @count.should == 2
-      end
-
-    end
-
-  end
-
-end

data/spec/hamster/immutable/new_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-require 'hamster/immutable'
-
-describe Hamster::Immutable do
-
-  describe "#new" do
-
-    class NewPerson < Struct.new(:first, :last)
-      include Hamster::Immutable
-    end
-
-    before do
-      @instance = NewPerson.new("Simon", "Harris")
-    end
-
-    it "passes the constructor arguments" do
-      @instance.first.should == "Simon"
-      @instance.last.should == "Harris"
-    end
-
-    it "freezes the instance" do
-      @instance.should be_frozen
-    end
-
-  end
-
-end

data/spec/hamster/immutable/transform_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-require 'hamster/immutable'
-
-describe Hamster::Immutable do
-
-  describe "#transform" do
-
-    class TransformPerson < Struct.new(:first, :last)
-      include Hamster::Immutable
-      public :transform
-    end
-
-    before do
-      @original = TransformPerson.new("Simon", "Harris")
-      @result = @original.transform { self.first = "Sampy" }
-    end
-
-    it "preserves the original" do
-      @original.first.should == "Simon"
-      @original.last.should == "Harris"
-    end
-
-    it "returns a new instance with the updated values" do
-      @result.first.should == "Sampy"
-      @result.last.should == "Harris"
-    end
-
-  end
-
-end

data/spec/hamster/immutable/transform_unless_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-require 'hamster/immutable'
-
-describe Hamster::Immutable do
-
-  describe "#transform_unless" do
-
-    class TransformUnlessPerson < Struct.new(:first, :last)
-      include Hamster::Immutable
-      public :transform_unless
-    end
-
-    before do
-      @original = TransformUnlessPerson.new("Simon", "Harris")
-    end
-
-    describe "when the condition is false" do
-
-      before do
-        @result = @original.transform_unless(false) { self.first = "Sampy" }
-      end
-
-      it "preserves the original" do
-        @original.first.should == "Simon"
-        @original.last.should == "Harris"
-      end
-
-      it "returns a new instance with the updated values" do
-        @result.first.should == "Sampy"
-        @result.last.should == "Harris"
-      end
-
-    end
-
-    describe "when the condition is true" do
-
-      before do
-        @result = @original.transform_unless(true) { fail("Should never be called") }
-      end
-
-      it "preserves the original" do
-        @original.first.should == "Simon"
-        @original.last.should == "Harris"
-      end
-
-      it "returns the original" do
-        @result.should equal(@original)
-      end
-
-    end
-
-  end
-
-end