hamster 1.0.1.pre.rc3 → 2.0.0

data/spec/lib/hamster/sorted_set/between_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 from the first argument to the second" 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)
           from,to = [rand(1000),rand(1000)].sort
-          result = set.between(from, to)
-          array  = items.select { |x| x >= from && x <= to }.sort
+          result  = set.between(from, to)
+          array   = items.select { |x| x >= from && x <= to }.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 lower 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)
           from,to = [rand(1000),rand(1000)].sort
-          result = []
+          result  = []
           set.between(from, to) { |x| result << x }
           array  = items.select { |x| x >= from && x <= to }.sort
           result.size.should == array.size
@@ -35,15 +35,15 @@ describe Hamster::SortedSet do
 
     context "on an empty set" do
       it "returns an empty set" do
-        Hamster::SortedSet.empty.between(1, 2).should be_empty
-        Hamster::SortedSet.empty.between('abc', 'def').should be_empty
-        Hamster::SortedSet.empty.between(:symbol, :another).should be_empty
+        SS.empty.between(1, 2).should be_empty
+        SS.empty.between('abc', 'def').should be_empty
+        SS.empty.between(:symbol, :another).should be_empty
       end
     end
 
     context "with a 'to' argument lower than the 'from' argument" do
       it "returns an empty set" do
-        result = Hamster.sorted_set(*(1..100)).between(6, 5)
+        result = SS.new(1..100).between(6, 5)
         result.class.should be(Hamster::SortedSet)
         result.should be_empty
       end

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

@@ -9,11 +9,11 @@ describe Hamster::SortedSet do
       %w[A B C],
     ].each do |values|
       context "on #{values}" do
-        let(:sorted_set) { Hamster.sorted_set(*values) }
+        let(:sorted_set) { SS[*values] }
 
         it "preserves the original" do
           sorted_set.clear
-          sorted_set.should eql(Hamster.sorted_set(*values))
+          sorted_set.should eql(SS[*values])
         end
 
         it "returns an empty set" do
@@ -31,5 +31,14 @@ describe Hamster::SortedSet do
         instance.clear.should be_empty
       end
     end
+
+    context "with a comparator" do
+      let(:sorted_set) { SS.new([1, 2, 3]) { |x| -x } }
+      it "returns an empty instance with same comparator" do
+        e = sorted_set.clear
+        e.should be_empty
+        e.add(4).add(5).add(6).to_a.should == [6, 5, 4]
+      end
+    end
   end
 end

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

@@ -0,0 +1,21 @@
+require "spec_helper"
+require "hamster/sorted_set"
+
+describe Hamster::SortedSet do
+  [:dup, :clone].each do |method|
+    [
+      [],
+      ["A"],
+      %w[A B C],
+      (1..32),
+    ].each do |values|
+      describe "on #{values.inspect}" do
+        let(:sorted_set) { SS[*values] }
+
+        it "returns self" do
+          sorted_set.send(method).should equal(sorted_set)
+        end
+      end
+    end
+  end
+end

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

@@ -3,12 +3,12 @@ require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
   describe "#delete_at" do
-    let(:sorted_set) { Hamster.sorted_set(1,2,3,4,5) }
+    let(:sorted_set) { SS[1,2,3,4,5] }
 
     it "removes the element at the specified index" do
-      sorted_set.delete_at(0).should eql(Hamster.sorted_set(2,3,4,5))
-      sorted_set.delete_at(2).should eql(Hamster.sorted_set(1,2,4,5))
-      sorted_set.delete_at(-1).should eql(Hamster.sorted_set(1,2,3,4))
+      sorted_set.delete_at(0).should  eql(SS[2,3,4,5])
+      sorted_set.delete_at(2).should  eql(SS[1,2,4,5])
+      sorted_set.delete_at(-1).should eql(SS[1,2,3,4])
     end
 
     it "makes no modification if the index is out of range" do

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

@@ -2,30 +2,30 @@ require "spec_helper"
 require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
-  let(:sorted_set) { Hamster.sorted_set("A", "B", "C") }
+  let(:sorted_set) { SS["A", "B", "C"] }
 
   describe "#delete" do
     context "on an empty set" do
       it "returns an empty set" do
-        Hamster::EmptySortedSet.delete(0).should be(Hamster::EmptySortedSet)
+        SS.empty.delete(0).should be(SS.empty)
       end
     end
 
     context "with an existing value" do
       it "preserves the original" do
         sorted_set.delete("B")
-        sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
+        sorted_set.should eql(SS["A", "B", "C"])
       end
 
       it "returns a copy with the remaining of values" do
-        sorted_set.delete("B").should eql(Hamster.sorted_set("A", "C"))
+        sorted_set.delete("B").should eql(SS["A", "C"])
       end
     end
 
     context "with a non-existing value" do
       it "preserves the original values" do
         sorted_set.delete("D")
-        sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
+        sorted_set.should eql(SS["A", "B", "C"])
       end
 
       it "returns self" do
@@ -34,8 +34,17 @@ describe Hamster::SortedSet do
     end
 
     context "when removing the last value in a sorted set" do
-      it "returns the canonical empty set" do
-        sorted_set.delete("B").delete("C").delete("A").should be(Hamster::EmptySortedSet)
+      it "maintains the set order" do
+        ss = SS.new(["peanuts", "jam", "milk"]) { |word| word.length }
+        ss = ss.delete("jam").delete("peanuts").delete("milk")
+        ss = ss.add("banana").add("sugar").add("spam")
+        ss.to_a.should == ['spam', 'sugar', 'banana']
+      end
+
+      context "when the set is in natural order" do
+        it "returns the canonical empty set" do
+          sorted_set.delete("B").delete("C").delete("A").should be(Hamster::EmptySortedSet)
+        end
       end
     end
 
@@ -45,9 +54,9 @@ describe Hamster::SortedSet do
         expected = to_delete.reduce(values.dup) { |ary,val| ary.delete(val); ary }
         describe "on #{values.inspect}, when deleting #{to_delete.inspect}" do
           it "returns #{expected.inspect}" do
-            set = Hamster::SortedSet.new(values)
+            set    = SS.new(values)
             result = to_delete.reduce(set) { |s,val| s.delete(val) }
-            result.should eql(Hamster::SortedSet.new(expected))
+            result.should eql(SS.new(expected))
             result.to_a.should eql(expected)
           end
         end
@@ -59,18 +68,18 @@ describe Hamster::SortedSet do
     context "with an existing value" do
       it "preserves the original" do
         sorted_set.delete?("B")
-        sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
+        sorted_set.should eql(SS["A", "B", "C"])
       end
 
       it "returns a copy with the remaining values" do
-        sorted_set.delete?("B").should eql(Hamster.sorted_set("A", "C"))
+        sorted_set.delete?("B").should eql(SS["A", "C"])
       end
     end
 
     context "with a non-existing value" do
       it "preserves the original values" do
         sorted_set.delete?("D")
-        sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
+        sorted_set.should eql(SS["A", "B", "C"])
       end
 
       it "returns false" do

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
-  [:difference, :diff, :subtract, :-].each do |method|
+  [:difference, :subtract, :-].each do |method|
     describe "##{method}" do
       [
         [[], [], []],
@@ -14,7 +14,7 @@ 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
       end

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

@@ -18,7 +18,7 @@ describe Hamster::SortedSet do
     ].each do |a, b, expected|
       context "for #{a.inspect} and #{b.inspect}" do
         it "returns #{expected}" do
-          Hamster.sorted_set(*a).disjoint?(Hamster.sorted_set(*b)).should be(expected)
+          SS[*a].disjoint?(SS[*b]).should be(expected)
         end
       end
     end

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

@@ -13,17 +13,44 @@ describe Hamster::SortedSet do
       [%w[A B C], 3, []]
     ].each do |values, number, expected|
       context "#{number} from #{values.inspect}" do
-        let(:sorted_set) { Hamster.sorted_set(*values) }
+        let(:sorted_set) { SS[*values] }
 
         it "preserves the original" do
           sorted_set.drop(number)
-          sorted_set.should eql(Hamster.sorted_set(*values))
+          sorted_set.should eql(SS[*values])
         end
 
         it "returns #{expected.inspect}" do
-          sorted_set.drop(number).should eql(Hamster.sorted_set(*expected))
+          sorted_set.drop(number).should eql(SS[*expected])
         end
       end
     end
+
+    context "when argument is zero" do
+      let(:sorted_set) { SS[6, 7, 8, 9] }
+      it "returns self" do
+        sorted_set.drop(0).should be(sorted_set)
+      end
+    end
+
+    context "when the set has a custom order" do
+      let(:sorted_set) { SS.new([1, 2, 3]) { |x| -x }}
+      it "maintains the custom order" do
+        sorted_set.drop(1).to_a.should == [2, 1]
+        sorted_set.drop(2).to_a.should == [1]
+      end
+
+      it "keeps the comparator even when set is cleared" do
+        s = sorted_set.drop(3)
+        s.add(4).add(5).add(6).to_a.should == [6, 5, 4]
+      end
+    end
+
+    context "when called on a subclass" do
+      it "should return an instance of the subclass" do
+        subclass = Class.new(Hamster::SortedSet)
+        subclass.new([1,2,3]).drop(1).class.should be(subclass)
+      end
+    end
   end
 end

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

@@ -10,23 +10,23 @@ describe Hamster::SortedSet do
       [%w[A B C D E F G], %w[C D E F G]]
     ].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 "preserves the original" do
             sorted_set.drop_while { |item| item < "C" }
-            sorted_set.should eql(Hamster.sorted_set(*values))
+            sorted_set.should eql(SS[*values])
           end
 
           it "returns #{expected.inspect}" do
-            sorted_set.drop_while { |item| item < "C" }.should eql(Hamster.sorted_set(*expected))
+            sorted_set.drop_while { |item| item < "C" }.should eql(SS[*expected])
           end
         end
 
         context "without a block" do
           it "returns an Enumerator" do
             sorted_set.drop_while.class.should be(Enumerator)
-            sorted_set.drop_while.each { |item| item < "C" }.should eql(Hamster.sorted_set(*expected))
+            sorted_set.drop_while.each { |item| item < "C" }.should eql(SS[*expected])
           end
         end
       end

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

@@ -2,29 +2,27 @@ require "spec_helper"
 require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
-  [:each, :foreach].each do |method|
-    describe "##{method}" do
-      context "with no block" do
-        let(:sorted_set) { Hamster.sorted_set("A", "B", "C") }
+  describe "#each" do
+    context "with no block" do
+      let(:sorted_set) { SS["A", "B", "C"] }
 
-        it "returns an Enumerator" do
-          sorted_set.send(method).class.should be(Enumerator)
-          sorted_set.send(method).to_a.should eql(sorted_set.to_a)
-        end
+      it "returns an Enumerator" do
+        sorted_set.each.class.should be(Enumerator)
+        sorted_set.each.to_a.should eql(sorted_set.to_a)
       end
+    end
 
-      context "with a block" do
-        let(:sorted_set) { Hamster::SortedSet.new((1..1025).to_a.reverse) }
+    context "with a block" do
+      let(:sorted_set) { SS.new((1..1025).to_a.reverse) }
 
-        it "returns self" do
-          sorted_set.send(method) {}.should be(sorted_set)
-        end
+      it "returns self" do
+        sorted_set.each {}.should be(sorted_set)
+      end
 
-        it "iterates over the items in order" do
-          items = []
-          sorted_set.send(method) { |item| items << item }
-          items.should == (1..1025).to_a
-        end
+      it "iterates over the items in order" do
+        items = []
+        sorted_set.each { |item| items << item }
+        items.should == (1..1025).to_a
       end
     end
   end

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

@@ -2,19 +2,17 @@ require "spec_helper"
 require "hamster/sorted_set"
 
 describe Hamster::SortedSet 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
-          let(:sorted_set) { Hamster.sorted_set(*values) }
+  describe "#empty?" do
+    [
+      [[], true],
+      [["A"], false],
+      [%w[A B C], false],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:sorted_set) { SS[*values] }
 
-          it "returns #{expected.inspect}" do
-            sorted_set.send(method).should == expected
-          end
+        it "returns #{expected.inspect}" do
+          sorted_set.empty?.should == expected
         end
       end
     end
@@ -22,8 +20,8 @@ describe Hamster::SortedSet do
 
   describe ".empty" do
     it "returns the canonical empty set" do
-      Hamster::SortedSet.empty.size.should be(0)
-      Hamster::SortedSet.empty.object_id.should be(Hamster::SortedSet.empty.object_id)
+      SS.empty.size.should be(0)
+      SS.empty.object_id.should be(SS.empty.object_id)
     end
 
     context "from a subclass" do

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

@@ -3,8 +3,8 @@ require "set"
 require "hamster/set"
 
 describe Hamster::SortedSet do
-  let(:set) { Hamster.sorted_set(*values) }
-  let(:comparison) { Hamster.sorted_set(*comparison_values) }
+  let(:set) { SS[*values] }
+  let(:comparison) { SS[*comparison_values] }
 
   describe "#eql?" do
     let(:eql?) { set.eql?(comparison) }
@@ -18,7 +18,7 @@ describe Hamster::SortedSet do
     end
 
     context "when comparing to a standard set" do
-      let(:comparison) { Set.new(%w[A B C]) }
+      let(:comparison) { ::Set.new(%w[A B C]) }
       include_examples "comparing something which is not a sorted set"
     end
 
@@ -110,8 +110,8 @@ describe Hamster::SortedSet do
     end
 
     context "with the same values, but a different sort order" do
-      let(:set) { Hamster.sorted_set(1, 2, 3) }
-      let(:comparison) { Hamster.sorted_set(1, 2, 3) { |n| -n }}
+      let(:set) { SS[1, 2, 3] }
+      let(:comparison) { SS.new([1, 2, 3]) { |n| -n }}
 
       it "returns false" do
         expect(eql?).to eq(false)

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

@@ -14,7 +14,7 @@ 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
       end

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

@@ -3,7 +3,7 @@ require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
   describe "#fetch" do
-    let(:sorted_set) { Hamster.sorted_set('a', 'b', 'c') }
+    let(:sorted_set) { SS['a', 'b', 'c'] }
 
     context "with no default provided" do
       context "when the index exists" do