hamster 1.0.1.pre.rc3 → 2.0.0

data/spec/lib/hamster/set/reverse_each_spec.rb

@@ -3,7 +3,7 @@ require "set"
 require "hamster/set"
 
 describe Hamster::Set do
-  let(:set) { Hamster.set("A", "B", "C") }
+  let(:set) { S["A", "B", "C"] }
 
   describe "#reverse_each" do
     let(:reverse_each) { set.reverse_each(&block) }

data/spec/lib/hamster/set/sample_spec.rb

@@ -3,7 +3,7 @@ require "hamster/set"
 
 describe Hamster::Set do
   describe "#sample" do
-    let(:set) { Hamster::Set.new(1..10) }
+    let(:set) { S.new(1..10) }
 
     it "returns a randomly chosen item" do
       chosen = 100.times.map { set.sample }

data/spec/lib/hamster/set/{filter_spec.rb → select_spec.rb}

@@ -2,9 +2,9 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  [:filter, :select, :find_all].each do |method|
+  [:select, :find_all].each do |method|
     describe "##{method}" do
-      let(:set) { Hamster.set("A", "B", "C") }
+      let(:set) { S["A", "B", "C"] }
 
       context "when everything matches" do
         it "returns self" do
@@ -18,18 +18,18 @@ describe Hamster::Set do
 
           it "preserves the original" do
             result
-            set.should eql(Hamster.set("A", "B", "C"))
+            set.should eql(S["A", "B", "C"])
           end
 
           it "returns a set with the matching values" do
-            result.should eql(Hamster.set("A"))
+            result.should eql(S["A"])
           end
         end
 
         context "with no block" do
           it "returns an Enumerator" do
             set.send(method).class.should be(Enumerator)
-            set.send(method).each { |item| item == "A" }.should eql(Hamster.set("A"))
+            set.send(method).each { |item| item == "A" }.should eql(S["A"])
           end
         end
       end
@@ -39,7 +39,7 @@ describe Hamster::Set do
 
         it "preserves the original" do
           result
-          set.should eql(Hamster.set("A", "B", "C"))
+          set.should eql(S["A", "B", "C"])
         end
 
         it "returns the canonical empty set" do
@@ -51,15 +51,15 @@ describe Hamster::Set do
         it "returns an instance of the same class" do
           subclass = Class.new(Hamster::Set)
           instance = subclass.new(['A', 'B', 'C'])
-          instance.filter { true }.class.should be(subclass)
-          instance.filter { false }.class.should be(subclass)
-          instance.filter { rand(2) == 0 }.class.should be(subclass)
+          instance.send(method) { true }.class.should be(subclass)
+          instance.send(method) { false }.class.should be(subclass)
+          instance.send(method) { rand(2) == 0 }.class.should be(subclass)
         end
       end
 
       it "works on a large set, with many combinations of input" do
         items = (1..1000).to_a
-        original = Hamster::Set.new(items)
+        original = S.new(items)
         30.times do
           threshold = rand(1000)
           result    = original.send(method) { |item| item <= threshold }
@@ -67,7 +67,7 @@ describe Hamster::Set do
           result.each { |item| item.should <= threshold }
           (threshold+1).upto(1000) { |item| result.include?(item).should == false }
         end
-        original.should eql(Hamster::Set.new(items))
+        original.should eql(S.new(items))
       end
     end
   end

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

@@ -10,7 +10,7 @@ describe Hamster::Set do
         [%w[A B C], 3],
       ].each do |values, result|
         it "returns #{result} for #{values.inspect}" do
-          Hamster.set(*values).send(method).should == result
+          S[*values].send(method).should == result
         end
       end
     end

data/spec/lib/hamster/set/sorting_spec.rb

@@ -13,19 +13,19 @@ describe Hamster::Set do
         [%w[Ichi Ni San], %w[Ni San Ichi]],
       ].each do |values, expected|
         describe "on #{values.inspect}" do
-          let(:set) { Hamster.set(*values) }
+          let(:set) { S[*values] }
 
           describe "with a block" do
             let(:result) { set.send(method, &comparator) }
 
             it "returns #{expected.inspect}" do
-              result.should eql(Hamster.sorted_set(*expected, &comparator))
+              result.should eql(SS.new(expected, &comparator))
               result.to_a.should == expected
             end
 
             it "doesn't change the original Set" do
               result
-              set.should eql(Hamster::Set.new(values))
+              set.should eql(S.new(values))
             end
           end
 
@@ -33,17 +33,28 @@ describe Hamster::Set do
             let(:result) { set.send(method) }
 
             it "returns #{expected.sort.inspect}" do
-              result.should eql(Hamster.sorted_set(*expected))
+              result.should eql(SS[*expected])
               result.to_a.should == expected.sort
             end
 
             it "doesn't change the original Set" do
               result
-              set.should eql(Hamster::Set.new(values))
+              set.should eql(S.new(values))
             end
           end
         end
       end
     end
   end
+
+  describe "#sort_by" do
+    it "only calls the passed block once for each item" do
+      count = 0
+      fn    = lambda { |x| count += 1; -x }
+      items = 100.times.collect { rand(10000) }.uniq
+
+      S[*items].sort_by(&fn).to_a.should == items.sort.reverse
+      count.should == items.length
+    end
+  end
 end

data/spec/lib/hamster/set/subset_spec.rb

@@ -19,7 +19,7 @@ describe Hamster::Set do
       ].each do |a, b, expected|
         describe "for #{a.inspect} and #{b.inspect}" do
           it "returns #{expected}"  do
-            Hamster.set(*a).send(method, Hamster.set(*b)).should == expected
+            S[*a].send(method, S[*b]).should == expected
           end
         end
       end
@@ -43,7 +43,7 @@ describe Hamster::Set do
       ].each do |a, b, expected|
         describe "for #{a.inspect} and #{b.inspect}" do
           it "returns #{expected}"  do
-            Hamster.set(*a).send(method, Hamster.set(*b)).should == expected
+            S[*a].send(method, S[*b]).should == expected
           end
         end
       end

data/spec/lib/hamster/set/sum_spec.rb

@@ -9,14 +9,14 @@ describe Hamster::Set do
       [[1, 3, 5, 7, 11], 27],
     ].each do |values, expected|
       context "on #{values.inspect}" do
-        let(:set) { Hamster.set(*values) }
+        let(:set) { S[*values] }
 
         it "returns #{expected.inspect}" do
           set.sum.should == expected
         end
 
         it "doesn't change the original Set" do
-          set.should eql(Hamster::Set.new(values))
+          set.should eql(S.new(values))
         end
       end
     end

data/spec/lib/hamster/set/superset_spec.rb

@@ -19,7 +19,7 @@ describe Hamster::Set do
       ].each do |a, b, expected|
         describe "for #{a.inspect} and #{b.inspect}" do
           it "returns #{expected}"  do
-            Hamster.set(*a).send(method, Hamster.set(*b)).should == expected
+            S[*a].send(method, S[*b]).should == expected
           end
         end
       end
@@ -43,7 +43,7 @@ describe Hamster::Set do
       ].each do |a, b, expected|
         describe "for #{a.inspect} and #{b.inspect}" do
           it "returns #{expected}"  do
-            Hamster.set(*a).send(method, Hamster.set(*b)).should == expected
+            S[*a].send(method, S[*b]).should == expected
           end
         end
       end

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

@@ -6,7 +6,7 @@ describe Hamster::Set do
     describe "##{method}" do
       ('a'..'z').each do |letter|
         let(:values) { ('a'..letter).to_a }
-        let(:set) { Hamster::Set.new(values) }
+        let(:set) { S.new(values) }
         let(:result) { set.send(method) }
 
         context "on 'a'..'#{letter}'" do
@@ -16,7 +16,7 @@ describe Hamster::Set do
 
           it "doesn't change the original Set" do
             result
-            set.should eql(Hamster.set(*values))
+            set.should eql(S[*values])
           end
 
           it "returns a mutable array" do

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

@@ -10,7 +10,7 @@ describe Hamster::Set do
       %w[A B C],
     ].each do |values|
       context "on #{values.inspect}" do
-        let(:set) { Hamster.set(*values) }
+        let(:set) { S[*values] }
         let(:list) { set.to_list }
 
         it "returns a list" do
@@ -19,7 +19,7 @@ describe Hamster::Set do
 
         it "doesn't change the original Set" do
           list
-          set.should eql(Hamster::Set.new(values))
+          set.should eql(S.new(values))
         end
 
         describe "the returned list" do

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

@@ -9,7 +9,7 @@ describe Hamster::Set do
       %w[A B C],
     ].each do |values|
       describe "on #{values.inspect}" do
-        let(:set) { Hamster.set(*values) }
+        let(:set) { S[*values] }
 
         it "returns self" do
           set.to_set.should equal(set)

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

@@ -14,42 +14,51 @@ describe Hamster::Set do
         [%w[A B C], %w[X Y Z], %w[A B C X Y Z]]
       ].each do |a, b, expected|
         context "for #{a.inspect} and #{b.inspect}" do
-          let(:set_a) { Hamster.set(*a) }
-          let(:set_b) { Hamster.set(*b) }
+          let(:set_a) { S[*a] }
+          let(:set_b) { S[*b] }
 
           it "returns #{expected.inspect}, without changing the original Sets" do
-            set_a.send(method, set_b).should eql(Hamster.set(*expected))
-            set_a.should eql(Hamster::Set.new(a))
-            set_b.should eql(Hamster::Set.new(b))
+            set_a.send(method, set_b).should eql(S[*expected])
+            set_a.should eql(S.new(a))
+            set_b.should eql(S.new(b))
           end
         end
 
         context "for #{b.inspect} and #{a.inspect}" do
-          let(:set_a) { Hamster.set(*a) }
-          let(:set_b) { Hamster.set(*b) }
+          let(:set_a) { S[*a] }
+          let(:set_b) { S[*b] }
 
           it "returns #{expected.inspect}, without changing the original Sets" do
-            set_b.send(method, set_a).should eql(Hamster.set(*expected))
-            set_a.should eql(Hamster::Set.new(a))
-            set_b.should eql(Hamster::Set.new(b))
+            set_b.send(method, set_a).should eql(S[*expected])
+            set_a.should eql(S.new(a))
+            set_b.should eql(S.new(b))
           end
         end
 
         context "when passed a Ruby Array" do
           it "returns the expected Set" do
-            Hamster.set(*a).send(method, b.freeze).should eql(Hamster.set(*expected))
-            Hamster.set(*b).send(method, a.freeze).should eql(Hamster.set(*expected))
+            S[*a].send(method, b.freeze).should eql(S[*expected])
+            S[*b].send(method, a.freeze).should eql(S[*expected])
           end
         end
 
         context "from a subclass" do
           it "returns an instance of the subclass" do
             subclass = Class.new(Hamster::Set)
-            subclass.new(a).union(Hamster::Set.new(b)).class.should be(subclass)
-            subclass.new(b).union(Hamster::Set.new(a)).class.should be(subclass)
+            subclass.new(a).send(method, S.new(b)).class.should be(subclass)
+            subclass.new(b).send(method, S.new(a)).class.should be(subclass)
           end
         end
       end
+
+      context "when receiving a subset" do
+        let(:set_a) { S.new(1..300) }
+        let(:set_b) { S.new(1..200) }
+
+        it "returns self" do
+          set_a.send(method, set_b).should be(set_a)
+        end
+      end
     end
   end
 end

data/spec/lib/hamster/sorted_set/above_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 higher 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.above(threshold)
-          array  = items.select { |x| x > threshold }.sort
+          result    = set.above(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 higher 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.above(threshold) { |x| result << x }
           array  = items.select { |x| x > threshold }.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.above(1).should be_empty
-        Hamster::SortedSet.empty.above('abc').should be_empty
-        Hamster::SortedSet.empty.above(:symbol).should be_empty
+        SS.empty.above(1).should be_empty
+        SS.empty.above('abc').should be_empty
+        SS.empty.above(:symbol).should be_empty
       end
     end
 
     context "with an argument higher than all the values in the set" do
       it "returns an empty set" do
-        result = Hamster.sorted_set(*(1..100)).above(100)
+        result = SS.new(1..100).above(100)
         result.class.should be(Hamster::SortedSet)
         result.should be_empty
       end

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

@@ -2,25 +2,25 @@ require "spec_helper"
 require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
-  let(:sorted_set) { Hamster.sorted_set("B", "C", "D") }
+  let(:sorted_set) { SS["B", "C", "D"] }
 
   [:add, :<<].each do |method|
     describe "##{method}" do
       context "with a unique value" do
         it "preserves the original" do
           sorted_set.send(method, "A")
-          sorted_set.should eql(Hamster.sorted_set("B", "C", "D"))
+          sorted_set.should eql(SS["B", "C", "D"])
         end
 
         it "returns a copy with the superset of values (in order)" do
-          sorted_set.send(method, "A").should eql(Hamster.sorted_set("A", "B", "C", "D"))
+          sorted_set.send(method, "A").should eql(SS["A", "B", "C", "D"])
         end
       end
 
       context "with a duplicate value" do
         it "preserves the original values" do
           sorted_set.send(method, "C")
-          sorted_set.should eql(Hamster.sorted_set("B", "C", "D"))
+          sorted_set.should eql(SS["B", "C", "D"])
         end
 
         it "returns self" do
@@ -30,7 +30,7 @@ describe Hamster::SortedSet do
 
       context "on a set ordered by a comparator" do
         it "inserts the new item in the correct place" do
-          s = Hamster.sorted_set('tick', 'pig', 'hippopotamus') { |str| str.length }
+          s = SS.new(['tick', 'pig', 'hippopotamus']) { |str| str.length }
           s.add('giraffe').to_a.should == ['pig', 'tick', 'giraffe', 'hippopotamus']
         end
       end
@@ -41,18 +41,18 @@ describe Hamster::SortedSet do
     context "with a unique value" do
       it "preserves the original" do
         sorted_set.add?("A")
-        sorted_set.should eql(Hamster.sorted_set("B", "C", "D"))
+        sorted_set.should eql(SS["B", "C", "D"])
       end
 
       it "returns a copy with the superset of values" do
-        sorted_set.add?("A").should eql(Hamster.sorted_set("A", "B", "C", "D"))
+        sorted_set.add?("A").should eql(SS["A", "B", "C", "D"])
       end
     end
 
     context "with a duplicate value" do
       it "preserves the original values" do
         sorted_set.add?("C")
-        sorted_set.should eql(Hamster.sorted_set("B", "C", "D"))
+        sorted_set.should eql(SS["B", "C", "D"])
       end
 
       it "returns false" do

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

@@ -17,7 +17,7 @@ describe Hamster::SortedSet do
     ].each do |values, number, expected|
       describe "#{values.inspect} with #{number}" do
         it "returns #{expected.inspect}" do
-          Hamster.sorted_set(*values).at(number).should == expected
+          SS[*values].at(number).should == expected
         end
       end
     end

data/spec/lib/hamster/sorted_set/below_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 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)
           threshold = rand(1000)
-          result = set.below(threshold)
-          array  = items.select { |x| x < threshold }.sort
+          result    = set.below(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 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)
           threshold = rand(1000)
-          result = []
+          result    = []
           set.below(threshold) { |x| result << x }
           array  = items.select { |x| x < threshold }.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.below(1).should be_empty
-        Hamster::SortedSet.empty.below('abc').should be_empty
-        Hamster::SortedSet.empty.below(:symbol).should be_empty
+        SS.empty.below(1).should be_empty
+        SS.empty.below('abc').should be_empty
+        SS.empty.below(:symbol).should be_empty
       end
     end
 
     context "with an argument lower than all the values in the set" do
       it "returns an empty set" do
-        result = Hamster.sorted_set(*(1..100)).below(1)
+        result = SS.new(1..100).below(1)
         result.class.should be(Hamster::SortedSet)
         result.should be_empty
       end