hamster 1.0.1.pre.rc3 → 2.0.0

data/spec/lib/hamster/deque/new_spec.rb

@@ -6,9 +6,9 @@ describe Hamster::Deque do
     it "accepts a single enumerable argument and creates a new deque" do
       deque = Hamster::Deque.new([1,2,3])
       deque.size.should be(3)
-      deque.head.should be(1)
-      deque.dequeue.head.should be(2)
-      deque.dequeue.dequeue.head.should be(3)
+      deque.first.should be(1)
+      deque.dequeue.first.should be(2)
+      deque.dequeue.dequeue.first.should be(3)
     end
 
     it "is amenable to overriding of #initialize" do
@@ -37,8 +37,8 @@ describe Hamster::Deque do
     it "accepts a variable number of items and creates a new deque" do
       deque = Hamster::Deque['a', 'b']
       deque.size.should be(2)
-      deque.head.should == 'a'
-      deque.dequeue.head.should == 'b'
+      deque.first.should == 'a'
+      deque.dequeue.first.should == 'b'
     end
   end
 end

data/spec/lib/hamster/deque/pop_spec.rb

@@ -9,16 +9,28 @@ describe Hamster::Deque do
       [%w[A B C], %w[A B]],
     ].each do |values, expected|
       context "on #{values.inspect}" do
-        let(:deque) { Hamster.deque(*values) }
+        let(:deque) { D[*values] }
 
         it "preserves the original" do
           deque.pop
-          deque.should eql(Hamster.deque(*values))
+          deque.should eql(D[*values])
         end
 
         it "returns #{expected.inspect}" do
-          deque.pop.should eql(Hamster.deque(*expected))
+          deque.pop.should eql(D[*expected])
         end
+
+        it "returns a frozen instance" do
+          deque.pop.should be_frozen
+        end
+      end
+    end
+
+    context "on empty subclass" do
+      let(:subclass) { Class.new(Hamster::Deque) }
+      let(:empty_instance) { subclass.new }
+      it "returns emtpy object of same class" do
+        empty_instance.pop.class.should be subclass
       end
     end
   end

data/spec/lib/hamster/deque/pretty_print_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "hamster/deque"
+require "pp"
+require "stringio"
+
+describe Hamster::Deque do
+  describe "#pretty_print" do
+    let(:deque) { Hamster::Deque["AAAA", "BBBB", "CCCC"] }
+    let(:stringio) { StringIO.new }
+
+    it "prints the whole Deque on one line if it fits" do
+      PP.pp(deque, stringio, 80)
+      stringio.string.chomp.should == 'Hamster::Deque["AAAA", "BBBB", "CCCC"]'
+    end
+
+    it "prints each item on its own line, if not" do
+      PP.pp(deque, stringio, 10)
+      stringio.string.chomp.should == 'Hamster::Deque[
+ "AAAA",
+ "BBBB",
+ "CCCC"]'
+    end
+  end
+end

data/spec/lib/hamster/deque/push_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "#push" do
+    [
+      [[], "A", ["A"]],
+      [["A"], "B", %w[A B]],
+      [%w[A B C], "D", %w[A B C D]],
+    ].each do |original, item, expected|
+      context "pushing #{item.inspect} into #{original.inspect}" do
+        let(:deque) { D.new(original) }
+
+        it "preserves the original" do
+          deque.push(item)
+          deque.should eql(D.new(original))
+        end
+
+        it "returns #{expected.inspect}" do
+          deque.push(item).should eql(D.new(expected))
+        end
+
+        it "returns a frozen instance" do
+          deque.push(item).should be_frozen
+        end
+      end
+    end
+
+    context "on a subclass" do
+      let(:subclass) { Class.new(Hamster::Deque) }
+      let(:empty_instance) { subclass.new }
+      it "returns an object of same class" do
+        empty_instance.push(1).class.should be subclass
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/shift_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "#shift" do
+    [
+      [[], []],
+      [["A"], []],
+      [%w[A B C], %w[B C]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:deque) { D.new(values) }
+
+        it "preserves the original" do
+          deque.shift
+          deque.should eql(D.new(values))
+        end
+
+        it "returns #{expected.inspect}" do
+          deque.shift.should eql(D.new(expected))
+        end
+
+
+        it "returns a frozen instance" do
+          deque.shift.should be_frozen
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/size_spec.rb

@@ -11,7 +11,7 @@ describe Hamster::Deque do
       ].each do |values, expected|
         context "on #{values.inspect}" do
           it "returns #{expected.inspect}" do
-            Hamster.deque(*values).send(method).should == expected
+            D[*values].send(method).should == expected
           end
         end
       end

data/spec/lib/hamster/deque/to_a_spec.rb

@@ -11,11 +11,11 @@ describe Hamster::Deque do
       ].each do |values|
         context "on #{values.inspect}" do
           it "returns #{values.inspect}" do
-            Hamster.deque(*values).send(method).should == values
+            D[*values].send(method).should == values
           end
 
           it "returns a mutable array" do
-            result = Hamster.deque(*values).send(method)
+            result = D[*values].send(method)
             expect(result.last).to_not eq("The End")
             result << "The End"
             result.last.should == "The End"

data/spec/lib/hamster/deque/to_ary_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/deque"
 
 describe Hamster::Deque do
-  let(:deque) { Hamster.deque("A", "B", "C", "D") }
+  let(:deque) { D["A", "B", "C", "D"] }
 
   describe "#to_ary" do
     context "enables implicit conversion to" do

data/spec/lib/hamster/deque/to_list_spec.rb

@@ -11,15 +11,15 @@ describe Hamster::Deque do
     ].each do |values|
       context "on #{values.inspect}" do
         it "returns a list containing #{values.inspect}" do
-          Hamster.deque(*values).to_list.should eql(Hamster.list(*values))
+          D[*values].to_list.should eql(L[*values])
         end
       end
     end
 
     context "after dedequeing an item from #{%w[A B C].inspect}" do
       it "returns a list containing #{%w[B C].inspect}" do
-        list = Hamster.deque("A", "B", "C").dequeue.to_list
-        list.should eql(Hamster.list("B", "C"))
+        list = D["A", "B", "C"].dequeue.to_list
+        list.should eql(L["B", "C"])
       end
     end
   end

data/spec/lib/hamster/deque/unshift_spec.rb

@@ -10,15 +10,20 @@ describe Hamster::Deque do
       [%w[A B C], "D", %w[D A B C]],
     ].each do |values, new_value, expected|
       context "on #{values.inspect} with #{new_value.inspect}" do
-        let(:deque) { Hamster.deque(*values) }
+        let(:deque) { D[*values] }
 
         it "preserves the original" do
           deque.unshift(new_value)
-          deque.should eql(Hamster.deque(*values))
+          deque.should eql(D[*values])
         end
 
         it "returns #{expected.inspect}" do
-          deque.unshift(new_value).should eql(Hamster.deque(*expected))
+          deque.unshift(new_value).should eql(D[*expected])
+        end
+
+
+        it "returns a frozen instance" do
+          deque.unshift(new_value).should be_frozen
         end
       end
     end

data/spec/lib/hamster/experimental/mutable_set/add_qm_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 require "hamster/experimental/mutable_set"
 
 describe Hamster::MutableSet do
-  let(:mutable) { Hamster.mutable_set(*values) }
+  let(:mutable) { Hamster::MutableSet[*values] }
 
   describe "#add?" do
     let(:values) { %w[A B C] }
@@ -18,7 +18,7 @@ describe Hamster::MutableSet do
 
       it "modifies the set to include the new value" do
         add?
-        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C", "D"))
+        expect(mutable).to eq(Hamster::MutableSet["A", "B", "C", "D"])
       end
 
     end
@@ -32,7 +32,7 @@ describe Hamster::MutableSet do
 
       it "preserves the original values" do
         add?
-        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C"))
+        expect(mutable).to eq(Hamster::MutableSet["A", "B", "C"])
       end
     end
   end

data/spec/lib/hamster/experimental/mutable_set/add_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/experimental/mutable_set"
 
 describe Hamster::MutableSet do
-  let(:mutable) { Hamster.mutable_set(*values) }
+  let(:mutable) { Hamster::MutableSet[*values] }
 
   describe "#add" do
     let(:values) { %w[A B C] }
@@ -17,7 +17,7 @@ describe Hamster::MutableSet do
 
       it "modifies the original set to include new value" do
         add
-        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C", "D"))
+        expect(mutable).to eq(Hamster::MutableSet["A", "B", "C", "D"])
       end
     end
 
@@ -30,7 +30,7 @@ describe Hamster::MutableSet do
 
       it "preserves the original values" do
         add
-        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C"))
+        expect(mutable).to eq(Hamster::MutableSet["A", "B", "C"])
       end
     end
   end

data/spec/lib/hamster/experimental/mutable_set/delete_qm_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/experimental/mutable_set"
 
 describe Hamster::MutableSet do
-  let(:mutable) { Hamster.mutable_set(*values) }
+  let(:mutable) { Hamster::MutableSet[*values] }
 
   describe "#delete?" do
     let(:values) { %w[A B C] }
@@ -18,7 +18,7 @@ describe Hamster::MutableSet do
 
       it "modifies the set to remove the value" do
         delete?
-        expect(mutable).to eq(Hamster.mutable_set("A", "C"))
+        expect(mutable).to eq(Hamster::MutableSet["A", "C"])
       end
     end
 
@@ -31,7 +31,7 @@ describe Hamster::MutableSet do
 
       it "preserves the original values" do
         delete?
-        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C"))
+        expect(mutable).to eq(Hamster::MutableSet["A", "B", "C"])
       end
     end
   end

data/spec/lib/hamster/experimental/mutable_set/delete_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/experimental/mutable_set"
 
 describe Hamster::MutableSet do
-  let(:mutable) { Hamster.mutable_set(*values) }
+  let(:mutable) { Hamster::MutableSet[*values] }
 
   describe "#delete" do
     let(:values) { %w[A B C] }
@@ -17,7 +17,7 @@ describe Hamster::MutableSet do
 
       it "modifies the set to remove the value" do
         delete
-        expect(mutable).to eq(Hamster.mutable_set("A", "C"))
+        expect(mutable).to eq(Hamster::MutableSet["A", "C"])
       end
     end
 
@@ -30,7 +30,7 @@ describe Hamster::MutableSet do
 
       it "preserves the original values" do
         delete
-        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C"))
+        expect(mutable).to eq(Hamster::MutableSet["A", "B", "C"])
       end
     end
   end

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

@@ -2,53 +2,51 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  let(:hash) { Hamster.hash(values) }
+  let(:hash) { H[values] }
 
-  [:all?, :forall?].each do |method|
-    describe "##{method}" do
-      context "when empty" do
-        let(:values) { Hash.new }
+  describe "#all?" do
+    context "when empty" do
+      let(:values) { H.new }
 
-        context "without a block" do
-          it "returns true" do
-            hash.send(method).should == true
-          end
+      context "without a block" do
+        it "returns true" do
+          hash.all?.should == true
         end
+      end
 
-        context "with a block" do
-          it "returns true" do
-            hash.send(method) { false }.should == true
-          end
+      context "with a block" do
+        it "returns true" do
+          hash.all? { false }.should == true
         end
       end
+    end
 
-      context "when not empty" do
-        let(:values) { { "A" => 1, "B" => 2, "C" => 3 } }
+    context "when not empty" do
+      let(:values) { { "A" => 1, "B" => 2, "C" => 3 } }
 
-        context "without a block" do
-          it "returns true" do
-            hash.send(method).should == true
-          end
+      context "without a block" do
+        it "returns true" do
+          hash.all?.should == true
         end
+      end
 
-        context "with a block" do
-          it "returns true if the block always returns true" do
-            hash.send(method) { true }.should == true
-          end
+      context "with a block" do
+        it "returns true if the block always returns true" do
+          hash.all? { true }.should == true
+        end
 
-          it "returns false if the block ever returns false" do
-            hash.send(method) { |k,v| k != 'C' }.should == false
-          end
+        it "returns false if the block ever returns false" do
+          hash.all? { |k,v| k != 'C' }.should == false
+        end
 
-          it "propagates an exception from the block" do
-            -> { hash.all? { |k,v| raise "help" } }.should raise_error(RuntimeError)
-          end
+        it "propagates an exception from the block" do
+          -> { hash.all? { |k,v| raise "help" } }.should raise_error(RuntimeError)
+        end
 
-          it "stops iterating as soon as the block returns false" do
-            yielded = []
-            hash.all? { |k,v| yielded << k; false }
-            yielded.size.should == 1
-          end
+        it "stops iterating as soon as the block returns false" do
+          yielded = []
+          hash.all? { |k,v| yielded << k; false }
+          yielded.size.should == 1
         end
       end
     end

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

@@ -2,53 +2,51 @@ require "spec_helper"
 require "hamster/hash"
 
 describe Hamster::Hash do
-  [:any?, :exist?, :exists?].each do |method|
-    describe "##{method}" do
-      context "when empty" do
-        it "with a block returns false" do
-          Hamster.hash.send(method) {}.should == false
-        end
-
-        it "with no block returns false" do
-          Hamster.hash.send(method).should == false
-        end
+  describe "#any?" do
+    context "when empty" do
+      it "with a block returns false" do
+        H.empty.any? {}.should == false
       end
 
-      context "when not empty" do
-        let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL") }
+      it "with no block returns false" do
+        H.empty.any?.should == false
+      end
+    end
 
-        context "with a block" do
-          [
-            %w[A aye],
-            %w[B bee],
-            %w[C see],
-            [nil, "NIL"],
-          ].each do |pair|
+    context "when not empty" do
+      let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"] }
 
-            it "returns true if the block ever returns true (#{pair.inspect})" do
-              hash.send(method) { |key, value| key == pair.first && value == pair.last }.should == true
-            end
+      context "with a block" do
+        [
+          %w[A aye],
+          %w[B bee],
+          %w[C see],
+          [nil, "NIL"],
+        ].each do |pair|
 
-            it "returns false if the block always returns false" do
-              hash.send(method) { |key, value| key == "D" && value == "dee" }.should == false
-            end
+          it "returns true if the block ever returns true (#{pair.inspect})" do
+            hash.any? { |key, value| key == pair.first && value == pair.last }.should == true
           end
 
-          it "propagates exceptions raised in the block" do
-            -> { hash.any? { |k,v| raise "help" } }.should raise_error(RuntimeError)
+          it "returns false if the block always returns false" do
+            hash.any? { |key, value| key == "D" && value == "dee" }.should == false
           end
+        end
 
-          it "stops iterating as soon as the block returns true" do
-            yielded = []
-            hash.any? { |k,v| yielded << k; true }
-            yielded.size.should == 1
-          end
+        it "propagates exceptions raised in the block" do
+          -> { hash.any? { |k,v| raise "help" } }.should raise_error(RuntimeError)
         end
 
-        context "with no block" do
-          it "returns true" do
-            hash.send(method).should == true
-          end
+        it "stops iterating as soon as the block returns true" do
+          yielded = []
+          hash.any? { |k,v| yielded << k; true }
+          yielded.size.should == 1
+        end
+      end
+
+      context "with no block" do
+        it "returns true" do
+          hash.any?.should == true
         end
       end
     end