hamster 1.0.1.pre.rc3 → 2.0.0

data/spec/lib/hamster/sorted_set/take_while_spec.rb

@@ -9,23 +9,23 @@ describe Hamster::SortedSet do
       [%w[A B C], %w[A B]],
     ].each do |values, expected|
       context "on #{values.inspect}" do
-        let(:sorted_set) { Hamster.sorted_set(*values) }
+        let(:sorted_set) { SS[*values] }
 
         context "with a block" do
           it "returns #{expected.inspect}" do
-            sorted_set.take_while { |item| item < "C" }.should eql(Hamster.sorted_set(*expected))
+            sorted_set.take_while { |item| item < "C" }.should eql(SS[*expected])
           end
 
           it "preserves the original" do
             sorted_set.take_while { |item| item < "C" }
-            sorted_set.should eql(Hamster.sorted_set(*values))
+            sorted_set.should eql(SS[*values])
           end
         end
 
         context "without a block" do
           it "returns an Enumerator" do
             sorted_set.take_while.class.should be(Enumerator)
-            sorted_set.take_while.each { |item| item < "C" }.should eql(Hamster.sorted_set(*expected))
+            sorted_set.take_while.each { |item| item < "C" }.should eql(SS[*expected])
           end
         end
       end

data/spec/lib/hamster/sorted_set/to_set_spec.rb

@@ -11,7 +11,7 @@ describe Hamster::SortedSet do
     ].each do |values|
       context "on #{values.inspect}" do
         it "returns a set with the same values" do
-          Hamster.sorted_set(*values).to_set.should eql(Hamster.set(*values))
+          SS[*values].to_set.should eql(S[*values])
         end
       end
     end

data/spec/lib/hamster/sorted_set/union_spec.rb

@@ -13,13 +13,13 @@ describe Hamster::SortedSet do
       ].each do |a, b, expected|
         context "for #{a.inspect} and #{b.inspect}" do
           it "returns #{expected.inspect}" do
-            Hamster.sorted_set(*a).send(method, Hamster.sorted_set(*b)).should eql(Hamster.sorted_set(*expected))
+            SS[*a].send(method, SS[*b]).should eql(SS[*expected])
           end
         end
 
         context "for #{b.inspect} and #{a.inspect}" do
           it "returns #{expected.inspect}" do
-            Hamster.sorted_set(*b).send(method, Hamster.sorted_set(*a)).should eql(Hamster.sorted_set(*expected))
+            SS[*b].send(method, SS[*a]).should eql(SS[*expected])
           end
         end
       end

data/spec/lib/hamster/sorted_set/up_to_spec.rb

@@ -6,11 +6,11 @@ describe Hamster::SortedSet do
     context "when called without a block" do
       it "returns a sorted set of all items equal to or less than the argument" do
         100.times do
-          items = rand(100).times.collect { rand(1000) }
-          set   = Hamster::SortedSet.new(items)
+          items     = rand(100).times.collect { rand(1000) }
+          set       = SS.new(items)
           threshold = rand(1000)
-          result = set.up_to(threshold)
-          array  = items.select { |x| x <= threshold }.sort
+          result    = set.up_to(threshold)
+          array     = items.select { |x| x <= threshold }.sort
           result.class.should be(Hamster::SortedSet)
           result.size.should == array.size
           result.to_a.should == array
@@ -21,10 +21,10 @@ describe Hamster::SortedSet do
     context "when called with a block" do
       it "yields all the items equal to or less than than the argument" do
         100.times do
-          items = rand(100).times.collect { rand(1000) }
-          set   = Hamster::SortedSet.new(items)
+          items     = rand(100).times.collect { rand(1000) }
+          set       = SS.new(items)
           threshold = rand(1000)
-          result = []
+          result    = []
           set.up_to(threshold) { |x| result << x }
           array  = items.select { |x| x <= threshold }.sort
           result.size.should == array.size
@@ -35,15 +35,16 @@ describe Hamster::SortedSet do
 
     context "on an empty set" do
       it "returns an empty set" do
-        Hamster::SortedSet.empty.up_to(1).should be_empty
-        Hamster::SortedSet.empty.up_to('abc').should be_empty
-        Hamster::SortedSet.empty.up_to(:symbol).should be_empty
+        SS.empty.up_to(1).should be_empty
+        SS.empty.up_to('abc').should be_empty
+        SS.empty.up_to(:symbol).should be_empty
+        SS.empty.up_to(nil).should be_empty
       end
     end
 
     context "with an argument less than all the values in the set" do
       it "returns an empty set" do
-        result = Hamster.sorted_set(*(1..100)).up_to(0)
+        result = SS.new(1..100).up_to(0)
         result.class.should be(Hamster::SortedSet)
         result.should be_empty
       end

data/spec/lib/hamster/sorted_set/values_at_spec.rb

@@ -3,23 +3,23 @@ require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
   describe "#values_at" do
-    let(:sorted_set) { Hamster.sorted_set('a', 'b', 'c') }
+    let(:sorted_set) { SS['a', 'b', 'c'] }
 
     it "accepts any number of indices, and returns a sorted_set of items at those indices" do
-      sorted_set.values_at(0).should eql(Hamster.sorted_set('a'))
-      sorted_set.values_at(1,2).should eql(Hamster.sorted_set('b', 'c'))
+      sorted_set.values_at(0).should   eql(SS['a'])
+      sorted_set.values_at(1,2).should eql(SS['b', 'c'])
     end
 
     context "when passed invalid indices" do
       it "filters them out" do
-        sorted_set.values_at(1,2,3).should eql(Hamster.sorted_set('b', 'c'))
-        sorted_set.values_at(-10,10).should eql(Hamster.sorted_set)
+        sorted_set.values_at(1,2,3).should  eql(SS['b', 'c'])
+        sorted_set.values_at(-10,10).should eql(SS.empty)
       end
     end
 
     context "when passed no arguments" do
       it "returns an empty sorted_set" do
-        sorted_set.values_at.should eql(Hamster.sorted_set)
+        sorted_set.values_at.should eql(SS.empty)
       end
     end
 

data/spec/lib/hamster/vector/add_spec.rb

@@ -2,12 +2,12 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  let(:vector) { Hamster.vector(*values) }
+  let(:vector) { V[*values] }
 
-  [:add, :<<, :conj, :conjoin, :push].each do |method|
+  [:add, :<<, :push].each do |method|
     describe "##{method}" do
       shared_examples "checking adding values" do
-        let(:added_vector) { Hamster.vector(*added_values) }
+        let(:added_vector) { V[*added_values] }
 
         it "preserves the original" do
           original = vector

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  let(:vector) { Hamster.vector(*values) }
+  let(:vector) { V[*values] }
 
   describe "#any?" do
     let(:any?) { vector.any?(&block) }

data/spec/lib/hamster/vector/assoc_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/vector"
 
 describe Hamster::Vector do
-  let(:vector) { Hamster.vector([:a, 3], [:b, 2], [:c, 1]) }
+  let(:vector) { V[[:a, 3], [:b, 2], [:c, 1]] }
 
   describe "#assoc" do
     it "searches for a 2-element array with a given 1st item" do
@@ -17,6 +17,11 @@ describe Hamster::Vector do
       vector.assoc(EqualNotEql.new).should_not be_nil
       vector.assoc(EqlNotEqual.new).should be_nil
     end
+
+    it "skips elements which are not indexable" do
+      V[false, true, nil].assoc(:b).should be_nil
+      V[[1,2], nil].assoc(3).should be_nil
+    end
   end
 
   describe "#rassoc" do
@@ -32,5 +37,10 @@ describe Hamster::Vector do
       vector.rassoc(EqualNotEql.new).should_not be_nil
       vector.rassoc(EqlNotEqual.new).should be_nil
     end
+
+    it "skips elements which are not indexable" do
+      V[false, true, nil].rassoc(:b).should be_nil
+      V[[1,2], nil].rassoc(3).should be_nil
+    end
   end
 end

data/spec/lib/hamster/vector/bsearch_spec.rb

@@ -3,7 +3,7 @@ require "hamster/vector"
 
 describe Hamster::Vector do
   describe "#bsearch" do
-    let(:vector) { Hamster.vector(5,10,20,30) }
+    let(:vector) { V[5,10,20,30] }
 
     context "with a block which returns false for elements below desired position, and true for those at/above" do
       it "returns the first element for which the predicate is true" do
@@ -47,11 +47,19 @@ describe Hamster::Vector do
           vector.bsearch { |x| x <=> 11 }.should be_nil
         end
       end
+
+      context "if not passed a block" do
+        it "returns an Enumerator" do
+          enum = vector.bsearch
+          enum.should be_a(Enumerator)
+          enum.each { |x| x <=> 10 }.should == 10
+        end
+      end
     end
 
     context "on an empty vector" do
       it "returns nil" do
-        Hamster.vector.bsearch { |x| x > 5 }.should be_nil
+        V.empty.bsearch { |x| x > 5 }.should be_nil
       end
     end
   end

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

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

data/spec/lib/hamster/vector/combination_spec.rb

@@ -3,7 +3,7 @@ require "hamster/vector"
 
 describe Hamster::Vector do
   describe "#combination" do
-    let(:vector) { Hamster.vector(1,2,3,4) }
+    let(:vector) { V[1,2,3,4] }
 
     context "with a block" do
       it "returns self" do
@@ -59,8 +59,8 @@ describe Hamster::Vector do
 
     context "on an empty vector" do
       it "works the same" do
-        Hamster.vector.combination(0).to_a.should == [[]]
-        Hamster.vector.combination(1).to_a.should == []
+        V.empty.combination(0).to_a.should == [[]]
+        V.empty.combination(1).to_a.should == []
       end
     end
 
@@ -76,7 +76,7 @@ describe Hamster::Vector do
 
     it "leaves the original unmodified" do
       vector.combination(2) {}
-      vector.should eql(Hamster.vector(1,2,3,4))
+      vector.should eql(V[1,2,3,4])
     end
   end
 end

data/spec/lib/hamster/vector/compact_spec.rb

@@ -6,12 +6,12 @@ describe Hamster::Vector do
     it "returns a new Vector with all nils removed" do
       V[1, nil, 2, nil].compact.should eql(V[1, 2])
       V[1, 2, 3].compact.should eql(V[1, 2, 3])
-      V[nil].compact.should eql(V[])
+      V[nil].compact.should eql(V.empty)
     end
 
     context "on an empty vector" do
       it "returns self" do
-        Hamster.vector.compact.should be(Hamster.vector)
+        V.empty.compact.should be(V.empty)
       end
     end
 

data/spec/lib/hamster/vector/compare_spec.rb

@@ -12,19 +12,19 @@ describe Hamster::Vector do
     ].each do |items1, items2|
       describe "with #{items1} and #{items2}" do
         it "returns -1" do
-          (Hamster::Vector.new(items1) <=> Hamster::Vector.new(items2)).should be(-1)
+          (V.new(items1) <=> V.new(items2)).should be(-1)
         end
       end
 
       describe "with #{items2} and #{items1}" do
         it "returns 1" do
-          (Hamster::Vector.new(items2) <=> Hamster::Vector.new(items1)).should be(1)
+          (V.new(items2) <=> V.new(items1)).should be(1)
         end
       end
 
       describe "with #{items1} and #{items1}" do
         it "returns 0" do
-          (Hamster::Vector.new(items1) <=> Hamster::Vector.new(items1)).should be(0)
+          (V.new(items1) <=> V.new(items1)).should be(0)
         end
       end
     end

data/spec/lib/hamster/vector/concat_spec.rb

@@ -16,8 +16,8 @@ describe Hamster::Vector do
         vector.concat(1..1000).should eql(V.new((1..100).to_a + (1..1000).to_a))
         vector.concat(1..200).size.should == 300
         vector.concat(vector).should eql(V.new((1..100).to_a * 2))
-        vector.concat(Hamster::EmptyVector).should eql(vector)
-        Hamster::EmptyVector.concat(vector).should eql(vector)
+        vector.concat(V.empty).should eql(vector)
+        V.empty.concat(vector).should eql(vector)
       end
 
       [1, 31, 32, 33, 1023, 1024, 1025].each do |size|

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

@@ -10,7 +10,7 @@ describe Hamster::Vector do
       (1..32),
     ].each do |values|
       describe "on #{values.inspect}" do
-        let(:vector) { Hamster.vector(*values) }
+        let(:vector) { V[*values] }
 
         it "returns self" do
           vector.send(method).should equal(vector)

data/spec/lib/hamster/vector/delete_at_spec.rb

@@ -3,12 +3,12 @@ require "hamster/vector"
 
 describe Hamster::Vector do
   describe "#delete_at" do
-    let(:vector) { Hamster.vector(1,2,3,4,5) }
+    let(:vector) { V[1,2,3,4,5] }
 
     it "removes the element at the specified index" do
-      vector.delete_at(0).should eql(Hamster.vector(2,3,4,5))
-      vector.delete_at(2).should eql(Hamster.vector(1,2,4,5))
-      vector.delete_at(-1).should eql(Hamster.vector(1,2,3,4))
+      vector.delete_at(0).should eql(V[2,3,4,5])
+      vector.delete_at(2).should eql(V[1,2,4,5])
+      vector.delete_at(-1).should eql(V[1,2,3,4])
     end
 
     it "makes no modification if the index is out of range" do
@@ -23,13 +23,13 @@ describe Hamster::Vector do
     end
 
     it "works on an empty vector" do
-      Hamster.vector.delete_at(0).should be(Hamster.vector)
-      Hamster.vector.delete_at(1).should be(Hamster.vector)
+      V.empty.delete_at(0).should be(V.empty)
+      V.empty.delete_at(1).should be(V.empty)
     end
 
     it "works on a vector with 1 item" do
-      Hamster.vector(10).delete_at(0).should eql(Hamster.vector)
-      Hamster.vector(10).delete_at(1).should eql(Hamster.vector(10))
+      V[10].delete_at(0).should eql(V.empty)
+      V[10].delete_at(1).should eql(V[10])
     end
 
     it "works on a vector with 32 items" do

data/spec/lib/hamster/vector/delete_spec.rb

@@ -10,13 +10,13 @@ describe Hamster::Vector do
       V[1,2,3].delete(0).should eql(V[1,2,3])
       V['a','b','a','c','a','a','d'].delete('a').should eql(V['b','c','d'])
 
-      V[EqualNotEql.new, EqualNotEql.new].delete(:something).should eql(V[])
+      V[EqualNotEql.new, EqualNotEql.new].delete(:something).should eql(V.empty)
       V[EqlNotEqual.new, EqlNotEqual.new].delete(:something).should_not be_empty
     end
 
     context "on an empty vector" do
       it "returns self" do
-        Hamster.vector.delete(1).should be(Hamster.vector)
+        V.empty.delete(1).should be(V.empty)
       end
     end
 

data/spec/lib/hamster/vector/drop_spec.rb

@@ -14,15 +14,15 @@ describe Hamster::Vector do
       [(1..33), 32, [33]]
     ].each do |values, number, expected|
       describe "#{number} from #{values.inspect}" do
-        let(:vector) { Hamster.vector(*values) }
+        let(:vector) { V[*values] }
 
         it "preserves the original" do
           vector.drop(number)
-          vector.should eql(Hamster.vector(*values))
+          vector.should eql(V[*values])
         end
 
         it "returns #{expected.inspect}" do
-          vector.drop(number).should eql(Hamster.vector(*expected))
+          vector.drop(number).should eql(V[*expected])
         end
       end
     end
@@ -31,5 +31,12 @@ describe Hamster::Vector do
       -> { V[1, 2, 3].drop(-1) }.should raise_error(ArgumentError)
       -> { V[1, 2, 3].drop(-3) }.should raise_error(ArgumentError)
     end
+
+    context "when number of elements specified is zero" do
+      let(:vector) { V[1, 2, 3, 4, 5, 6] }
+      it "returns self" do
+        vector.drop(0).should be(vector)
+      end
+    end
   end
 end

data/spec/lib/hamster/vector/drop_while_spec.rb

@@ -9,25 +9,25 @@ describe Hamster::Vector do
       [%w[A B C], ["C"]],
     ].each do |values, expected|
       describe "on #{values.inspect}" do
-        let(:vector) { Hamster.vector(*values) }
+        let(:vector) { V[*values] }
 
         describe "with a block" do
           let(:result) { vector.drop_while { |item| item < "C" } }
 
           it "preserves the original" do
             result
-            vector.should eql(Hamster.vector(*values))
+            vector.should eql(V[*values])
           end
 
           it "returns #{expected.inspect}" do
-            result.should eql(Hamster.vector(*expected))
+            result.should eql(V[*expected])
           end
         end
 
         describe "without a block" do
           it "returns an Enumerator" do
             vector.drop_while.class.should be(Enumerator)
-            vector.drop_while.each { |item| item < "C" }.should eql(Hamster.vector(*expected))
+            vector.drop_while.each { |item| item < "C" }.should eql(V[*expected])
           end
         end
       end
@@ -35,7 +35,7 @@ describe Hamster::Vector do
 
     context "on an empty vector" do
       it "returns an empty vector" do
-        Hamster.vector.drop_while { false }.should eql(Hamster.vector)
+        V.empty.drop_while { false }.should eql(V.empty)
       end
     end