hamster 1.0.0 → 1.0.1.pre.rc.1

data/spec/hamster/hash/put_spec.rb

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,63 @@
+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/{lib/hamster → 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 "has the correct size after adding lots of things with colliding keys and such" do
+      it "should have 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 "has the correct size after lots of addings and removings" do
+      it "should have the correct size after lots of addings and removings" do
         h = Hamster.hash
         random_actions.each do |(act, ob)|
           if act == :add

data/spec/hamster/hash/slice_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { described_class.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
+    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
+    end
+  end
+end

data/spec/hamster/hash/uniq_spec.rb

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,34 @@
+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/{lib/hamster → hamster}/immutable/copying_spec.rb

@@ -1,13 +1,17 @@
 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)
@@ -16,6 +20,9 @@ describe Hamster::Immutable do
       it "returns self" do
         @result.should equal(@original)
       end
+
     end
+
   end
-end
+
+end

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

@@ -1,9 +1,13 @@
 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
@@ -15,9 +19,11 @@ 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
@@ -26,12 +32,15 @@ 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
@@ -39,7 +48,11 @@ describe Hamster::Immutable do
         it "returns true" do
           @fixture.should be_immutable
         end
+
       end
+
     end
+
   end
-end
+
+end

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

@@ -22,12 +22,13 @@ describe Hamster::Immutable do
   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
+    it "should still freezes be immutable" do
       expect(immutable).to be_immutable
     end
 
@@ -48,7 +49,7 @@ describe Hamster::Immutable do
         copy.call
       end
 
-      it "clears all memory" do
+      it "should clear all memory" do
         expect(@count).to eq(2)
       end
     end

data/spec/hamster/list/add_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+require "hamster/list"
+
+describe Hamster::List do
+
+  describe "#add" do
+
+    it "should add an item onto the end of a list" do
+      list = Hamster.list("a", "b")
+      list.add("c").should == Hamster.list("a", "b", "c")
+    end
+
+  end
+
+end

data/spec/hamster/list/all_spec.rb

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