hamster 1.0.1.pre.rc3 → 2.0.0

data/lib/hamster/version.rb

@@ -1,3 +1,5 @@
 module Hamster
-  VERSION = "1.0.1-rc3"
+  # Current released gem version. Note that master will often have the same
+  # value as a release gem but with different code.
+  VERSION = "2.0.0"
 end

data/spec/lib/hamster/associable/associable_spec.rb

@@ -0,0 +1,150 @@
+require "spec_helper"
+require "hamster/hash"
+require "hamster/vector"
+
+describe Hamster::Associable do
+  describe "#update_in" do
+    let(:hash) {
+      Hamster::Hash[
+        "A" => "aye",
+        "B" => Hamster::Hash["C" => "see", "D" => Hamster::Hash["E" => "eee"]],
+        "F" => Hamster::Vector["G", Hamster::Hash["H" => "eitch"], "I"]
+      ]
+    }
+    let(:vector) {
+      Hamster::Vector[
+        100,
+        101,
+        102,
+        Hamster::Vector[200, 201, Hamster::Vector[300, 301, 302]],
+        Hamster::Hash["A" => "alpha", "B" => "bravo"],
+        [400, 401, 402]
+      ]
+    }
+    context "with one level on existing key" do
+      it "Hash passes the value to the block" do
+        hash.update_in("A") { |value| value.should == "aye" }
+      end
+
+      it "Vector passes the value to the block" do
+        vector.update_in(1) { |value| value.should == 101 }
+      end
+
+      it "Hash replaces the value with the result of the block" do
+        result = hash.update_in("A") { |value| "FLIBBLE" }
+        result.get("A").should == "FLIBBLE"
+      end
+
+      it "Vector replaces the value with the result of the block" do
+        result = vector.update_in(1) { |value| "FLIBBLE" }
+        result.get(1).should == "FLIBBLE"
+      end
+
+      it "Hash should preserve the original" do
+        result = hash.update_in("A") { |value| "FLIBBLE" }
+        hash.get("A").should == "aye"
+      end
+
+      it "Vector should preserve the original" do
+        result = vector.update_in(1) { |value| "FLIBBLE" }
+        vector.get(1).should == 101
+      end
+    end
+
+    context "with multi-level on existing keys" do
+      it "Hash passes the value to the block" do
+        hash.update_in("B", "D", "E") { |value| value.should == "eee" }
+      end
+
+      it "Vector passes the value to the block" do
+        vector.update_in(3, 2, 0) { |value| value.should == 300 }
+      end
+
+      it "Hash replaces the value with the result of the block" do
+        result = hash.update_in("B", "D", "E") { |value| "FLIBBLE" }
+        result["B"]["D"]["E"].should == "FLIBBLE"
+      end
+
+      it "Vector replaces the value with the result of the block" do
+        result = vector.update_in(3, 2, 0) { |value| "FLIBBLE" }
+        result[3][2][0].should == "FLIBBLE"
+      end
+
+      it "Hash should preserve the original" do
+        result = hash.update_in("B", "D", "E") { |value| "FLIBBLE" }
+        hash["B"]["D"]["E"].should == "eee"
+      end
+
+      it "Vector should preserve the original" do
+        result = vector.update_in(3, 2, 0) { |value| "FLIBBLE" }
+        vector[3][2][0].should == 300
+      end
+
+    end
+
+    context "with multi-level creating sub-hashes when keys don't exist" do
+      it "Hash passes nil to the block" do
+        hash.update_in("B", "X", "Y") { |value| value.should be_nil }
+      end
+
+      it "Vector passes nil to the block" do
+        vector.update_in(3, 3, "X", "Y") { |value| value.should be_nil }
+      end
+
+      it "Hash creates subhashes on the way to set the value" do
+        result = hash.update_in("B", "X", "Y") { |value| "NEWVALUE" }
+        result["B"]["X"]["Y"].should == "NEWVALUE"
+        result["B"]["D"]["E"].should == "eee"
+      end
+
+      it "Vector creates subhashes on the way to set the value" do
+        result = vector.update_in(3, 3, "X", "Y") { |value| "NEWVALUE" }
+        result[3][3]["X"]["Y"].should == "NEWVALUE"
+        result[3][2][0].should == 300
+      end
+    end
+
+    context "Hash with multi-level including Vector with existing keys" do
+      it "passes the value to the block" do
+        hash.update_in("F", 1, "H") { |value| value.should == "eitch" }
+      end
+
+      it "replaces the value with the result of the block" do
+        result = hash.update_in("F", 1, "H") { |value| "FLIBBLE" }
+        result["F"][1]["H"].should == "FLIBBLE"
+      end
+
+      it "should preserve the original" do
+        result = hash.update_in("F", 1, "H") { |value| "FLIBBLE" }
+        hash["F"][1]["H"].should == "eitch"
+      end
+    end
+
+    context "Vector with multi-level including Hash with existing keys" do
+      it "passes the value to the block" do
+        vector.update_in(4, "B") { |value| value.should == "bravo" }
+      end
+
+      it "replaces the value with the result of the block" do
+        result = vector.update_in(4, "B") { |value| "FLIBBLE" }
+        result[4]["B"].should == "FLIBBLE"
+      end
+
+      it "should preserve the original" do
+        result = vector.update_in(4, "B") { |value| "FLIBBLE" }
+        vector[4]["B"].should == "bravo"
+      end
+    end
+
+    context "with empty key_path" do
+      it "Hash raises ArguemntError" do
+        expect { hash.update_in() { |v| 42 } }.to raise_error(ArgumentError)
+      end
+
+      it "Vector raises ArguemntError" do
+        expect { vector.update_in() { |v| 42 } }.to raise_error(ArgumentError)
+      end
+
+    end
+  end
+end

data/spec/lib/hamster/core_ext/array_spec.rb

@@ -8,7 +8,7 @@ describe Array do
     let(:to_list) { array.to_list }
 
     it "returns an equivalent hamster list" do
-      expect(to_list).to eq(Hamster.list("A", "B", "C"))
+      expect(to_list).to eq(L["A", "B", "C"])
     end
   end
 end

data/spec/lib/hamster/core_ext/enumerable_spec.rb

@@ -20,11 +20,11 @@ describe Enumerable do
     let(:to_list) { enumerable.to_list }
 
     it "returns an equivalent list" do
-      expect(to_list).to eq(Hamster.list("A", "B", "C"))
+      expect(to_list).to eq(L["A", "B", "C"])
     end
 
     it "works on Ranges" do
-      expect((1..3).to_list).to eq(Hamster.list(1, 2, 3))
+      expect((1..3).to_list).to eq(L[1, 2, 3])
     end
   end
 end

data/spec/lib/hamster/core_ext/io_spec.rb

@@ -3,7 +3,7 @@ require "hamster/core_ext/io"
 
 describe IO do
   describe "#to_list" do
-    let(:list) { Hamster.list("A\n", "B\n", "C\n") }
+    let(:list) { L["A\n", "B\n", "C\n"] }
     let(:to_list) { io.to_list }
 
     after(:each) do

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

@@ -9,15 +9,15 @@ describe Hamster::Deque do
       %w[A B C],
     ].each do |values|
       context "on #{values}" do
-        let(:deque) { Hamster.deque(*values) }
+        let(:deque) { D[*values] }
 
         it "preserves the original" do
           deque.clear
-          deque.should eql(Hamster.deque(*values))
+          deque.should eql(D[*values])
         end
 
         it "returns an empty deque" do
-          deque.clear.should equal(Hamster.deque)
+          deque.clear.should equal(D.empty)
         end
       end
     end

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

@@ -2,28 +2,28 @@ require "spec_helper"
 require "hamster/deque"
 
 describe Hamster::Deque do
-  describe ".deque" do
+  describe ".[]" do
     context "with no arguments" do
       it "always returns the same instance" do
-        Hamster.deque.class.should be(Hamster::Deque)
-        Hamster.deque.should equal(Hamster.deque)
+        D[].class.should be(Hamster::Deque)
+        D[].should equal(D[])
       end
 
       it "returns an empty, frozen deque" do
-        Hamster.deque.should be_empty
-        Hamster.deque.should be_frozen
+        D[].should be_empty
+        D[].should be_frozen
       end
     end
 
     context "with a number of items" do
-      let(:deque) { Hamster.deque("A", "B", "C") }
+      let(:deque) { D["A", "B", "C"] }
 
       it "always returns a different instance" do
-        deque.should_not equal(Hamster.deque("A", "B", "C"))
+        deque.should_not equal(D["A", "B", "C"])
       end
 
       it "is the same as repeatedly using #endeque" do
-        deque.should eql(Hamster.deque.enqueue("A").enqueue("B").enqueue("C"))
+        deque.should eql(D.empty.enqueue("A").enqueue("B").enqueue("C"))
       end
     end
   end

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

@@ -9,7 +9,7 @@ describe Hamster::Deque do
       %w[A B C],
     ].each do |values|
       context "on #{values.inspect}" do
-        let(:deque) { Hamster.deque(*values) }
+        let(:deque) { D[*values] }
 
         it "returns self" do
           deque.send(method).should equal(deque)

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/deque"
 
 describe Hamster::Deque do
-  [:dequeue, :tail, :shift].each do |method|
+  [:dequeue, :shift].each do |method|
     describe "##{method}" do
       [
         [[], []],
@@ -10,18 +10,26 @@ describe Hamster::Deque do
         [%w[A B C], %w[B C]],
       ].each do |values, expected|
         context "on #{values.inspect}" do
-          let(:deque) { Hamster.deque(*values) }
+          let(:deque) { D[*values] }
 
           it "preserves the original" do
             deque.send(method)
-            deque.should eql(Hamster.deque(*values))
+            deque.should eql(D[*values])
           end
 
           it "returns #{expected.inspect}" do
-            deque.send(method).should eql(Hamster.deque(*expected))
+            deque.send(method).should eql(D[*expected])
           end
         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.send(method).class.should be subclass
+      end
+    end
   end
 end

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

@@ -2,33 +2,31 @@ require "spec_helper"
 require "hamster/deque"
 
 describe Hamster::Deque do
-  [:empty?, :null?].each do |method|
-    describe "##{method}" do
-      [
-        [[], true],
-        [["A"], false],
-        [%w[A B C], false],
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            Hamster.deque(*values).send(method).should == expected
-          end
+  describe "#empty?" do
+    [
+      [[], true],
+      [["A"], false],
+      [%w[A B C], false],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          D[*values].empty?.should == expected
         end
       end
     end
 
     context "after dedequeing an item from #{%w[A B C].inspect}" do
       it "returns false" do
-        Hamster.deque("A", "B", "C").dequeue.should_not be_empty
+        D["A", "B", "C"].dequeue.should_not be_empty
       end
     end
   end
 
   describe ".empty" do
-    it "returns the canonical empty vector" do
-      Hamster::Deque.empty.size.should be(0)
-      Hamster::Deque.empty.class.should be(Hamster::Deque)
-      Hamster::Deque.empty.object_id.should be(Hamster::EmptyDeque.object_id)
+    it "returns the canonical empty deque" do
+      D.empty.size.should be(0)
+      D.empty.class.should be(Hamster::Deque)
+      D.empty.object_id.should be(Hamster::EmptyDeque.object_id)
     end
 
     context "from a subclass" do

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/deque"
 
 describe Hamster::Deque do
-  [:enqueue, :<<, :add, :conj, :conjoin, :push].each do |method|
+  [:enqueue, :push].each do |method|
     describe "##{method}" do
       [
         [[], "A", ["A"]],
@@ -11,15 +11,15 @@ describe Hamster::Deque do
         [%w[A B C], "D", %w[A B C D]],
       ].each do |values, new_value, expected|
         describe "on #{values.inspect} with #{new_value.inspect}" do
-          let(:deque) { Hamster.deque(*values) }
+          let(:deque) { D[*values] }
 
           it "preserves the original" do
             deque.send(method, new_value)
-            deque.should eql(Hamster.deque(*values))
+            deque.should eql(D[*values])
           end
 
           it "returns #{expected.inspect}" do
-            deque.send(method, new_value).should eql(Hamster.deque(*expected))
+            deque.send(method, new_value).should eql(D[*expected])
           end
         end
       end

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

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "#first" do
+    [
+      [[], nil],
+      [["A"], "A"],
+      [%w[A B C], "A"],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          D[*values].first.should == expected
+        end
+      end
+    end
+  end
+end

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

@@ -9,7 +9,7 @@ describe Hamster::Deque do
       [%w[A B C], 'Hamster::Deque["A", "B", "C"]']
     ].each do |values, expected|
       context "on #{values.inspect}" do
-        let(:deque) { Hamster.deque(*values) }
+        let(:deque) { D[*values] }
 
         it "returns #{expected.inspect}" do
           deque.inspect.should == expected

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

@@ -2,17 +2,15 @@ require "spec_helper"
 require "hamster/deque"
 
 describe Hamster::Deque do
-  [:last, :peek].each do |method|
-    describe "##{method}" do
-      [
-        [[], nil],
-        [["A"], "A"],
-        [%w[A B C], "C"],
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            Hamster.deque(*values).send(method).should eql(expected)
-          end
+  describe "#last" do
+    [
+      [[], nil],
+      [["A"], "A"],
+      [%w[A B C], "C"],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          D[*values].last.should eql(expected)
         end
       end
     end

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

@@ -7,7 +7,7 @@ describe Hamster::Deque do
       File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
     end
     let(:child_cmd) do
-      %Q|#{ruby} -I lib -r hamster -e 'deque = Hamster.deque(5, 10, 15); $stdout.write(Marshal.dump(deque))'|
+      %Q|#{ruby} -I lib -r hamster -e 'deque = Hamster::Deque[5, 10, 15]; $stdout.write(Marshal.dump(deque))'|
     end
 
     let(:reloaded_deque) do
@@ -19,16 +19,16 @@ describe Hamster::Deque do
     end
 
     it "can survive dumping and loading into a new process" do
-      expect(reloaded_deque).to eql(Hamster.deque(5, 10, 15))
+      expect(reloaded_deque).to eql(D[5, 10, 15])
     end
 
     it "is still possible to push and pop items after loading" do
       expect(reloaded_deque.first).to eq(5)
       expect(reloaded_deque.last).to eq(15)
-      expect(reloaded_deque.push(20)).to eql(Hamster.deque(5, 10, 15, 20))
-      expect(reloaded_deque.pop).to eql(Hamster.deque(5, 10))
-      expect(reloaded_deque.unshift(1)).to eql(Hamster.deque(1, 5, 10, 15))
-      expect(reloaded_deque.shift).to eql(Hamster.deque(10, 15))
+      expect(reloaded_deque.push(20)).to eql(D[5, 10, 15, 20])
+      expect(reloaded_deque.pop).to eql(D[5, 10])
+      expect(reloaded_deque.unshift(1)).to eql(D[1, 5, 10, 15])
+      expect(reloaded_deque.shift).to eql(D[10, 15])
     end
   end
 end