hamster 1.0.1.pre.rc3 → 2.0.0

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

@@ -22,9 +22,17 @@ describe Hamster::SortedSet do
         [[2.0], 2.0, 0],
         [[2.0], 2, 0],
       ].each do |values, item, expected|
-        context "looking for #{item.inspect} in #{values.inspect}" do
+        unless item.nil? # test breaks otherwise
+          context "looking for #{item.inspect} in #{values.inspect} without block" do
+            it "returns #{expected.inspect}" do
+              SS[*values].send(method, item).should == expected
+            end
+          end
+        end
+
+        context "looking for #{item.inspect} in #{values.inspect} with block" do
           it "returns #{expected.inspect}" do
-            Hamster.sorted_set(*values).send(method) { |x| x == item }.should == expected
+            SS[*values].send(method) { |x| x == item }.should == expected
           end
         end
       end

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

@@ -2,18 +2,16 @@ require "spec_helper"
 require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
-  [:first, :head].each do |method|
-    describe "##{method}" do
-      [
-        [[], nil],
-        [["A"], "A"],
-        [%w[A B C], "A"],
-        [%w[Z Y X], "X"]
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            Hamster.sorted_set(*values).send(method).should eql(expected)
-          end
+  describe "#first" do
+    [
+      [[], nil],
+      [["A"], "A"],
+      [%w[A B C], "A"],
+      [%w[Z Y X], "X"]
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          SS[*values].first.should eql(expected)
         end
       end
     end

data/spec/lib/hamster/sorted_set/from_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 greater 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.from(threshold)
-          array  = items.select { |x| x >= threshold }.sort
+          result    = set.from(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 greater 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.from(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.from(1).should be_empty
-        Hamster::SortedSet.empty.from('abc').should be_empty
-        Hamster::SortedSet.empty.from(:symbol).should be_empty
+        SS.empty.from(1).should be_empty
+        SS.empty.from('abc').should be_empty
+        SS.empty.from(: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)).from(101)
+        result = SS.new(1..100).from(101)
         result.class.should be(Hamster::SortedSet)
         result.should be_empty
       end

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

@@ -7,19 +7,19 @@ describe Hamster::SortedSet do
       context "with a block" do
         [
           [[], []],
-          [[1], [true => Hamster.sorted_set(1)]],
-          [[1, 2, 3, 4], [true => Hamster.sorted_set(3, 1), false => Hamster.sorted_set(4, 2)]],
+          [[1], [true => SS[1]]],
+          [[1, 2, 3, 4], [true => SS[3, 1], false => SS[4, 2]]],
         ].each do |values, expected|
           context "on #{values.inspect}" do
-            let(:sorted_set) { Hamster.sorted_set(*values) }
+            let(:sorted_set) { SS[*values] }
 
             it "preserves the original" do
               sorted_set.send(method, &:odd?)
-              sorted_set.should eql(Hamster.sorted_set(*values))
+              sorted_set.should eql(SS[*values])
             end
 
             it "returns #{expected.inspect}" do
-              sorted_set.send(method, &:odd?).should eql(Hamster.hash(*expected))
+              sorted_set.send(method, &:odd?).should eql(H[*expected])
             end
           end
         end
@@ -28,19 +28,19 @@ describe Hamster::SortedSet do
       context "without a block" do
         [
           [[], []],
-          [[1], [1 => Hamster.sorted_set(1)]],
-          [[1, 2, 3, 4], [1 => Hamster.sorted_set(1), 2 => Hamster.sorted_set(2), 3 => Hamster.sorted_set(3), 4 => Hamster.sorted_set(4)]],
+          [[1], [1 => SS[1]]],
+          [[1, 2, 3, 4], [1 => SS[1], 2 => SS[2], 3 => SS[3], 4 => SS[4]]],
         ].each do |values, expected|
           context "on #{values.inspect}" do
-            let(:sorted_set) { Hamster.sorted_set(*values) }
+            let(:sorted_set) { SS[*values] }
 
             it "preserves the original" do
               sorted_set.group_by
-              sorted_set.should eql(Hamster.sorted_set(*values))
+              sorted_set.should eql(SS[*values])
             end
 
             it "returns #{expected.inspect}" do
-              sorted_set.group_by.should eql(Hamster.hash(*expected))
+              sorted_set.group_by.should eql(H[*expected])
             end
           end
         end

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

@@ -2,9 +2,9 @@ require "spec_helper"
 require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
-  [:include?, :member?, :contains?, :elem?].each do |method|
+  [:include?, :member?].each do |method|
     describe "##{method}" do
-      let(:sorted_set) { Hamster.sorted_set(1, 2, 3, 4.0) }
+      let(:sorted_set) { SS[1, 2, 3, 4.0] }
 
       [1, 2, 3, 4.0].each do |value|
         it "returns true for an existing value (#{value.inspect})" do

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

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

data/spec/lib/hamster/sorted_set/intersect_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).intersect?(Hamster.sorted_set(*b)).should be(expected)
+          SS[*a].intersect?(SS[*b]).should be(expected)
         end
       end
     end

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
-  [:intersection, :intersect, :&].each do |method|
+  [:intersection, :&].each do |method|
     describe "##{method}" do
       [
         [[], [], []],
@@ -14,13 +14,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/last_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
-  let(:sorted_set) { Hamster.sorted_set(*values) }
+  let(:sorted_set) { SS[*values] }
 
   describe "#last" do
     let(:last) { sorted_set.last }

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

@@ -6,31 +6,39 @@ describe Hamster::SortedSet do
     describe "##{method}" do
       context "when empty" do
         it "returns self" do
-          Hamster.sorted_set.send(method) {}.should equal(Hamster.sorted_set)
+          SS.empty.send(method) {}.should equal(SS.empty)
         end
       end
 
       context "when not empty" do
-        let(:sorted_set) { Hamster.sorted_set("A", "B", "C") }
+        let(:sorted_set) { SS["A", "B", "C"] }
 
         context "with a block" do
           it "preserves the original values" do
             sorted_set.send(method, &:downcase)
-            sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
+            sorted_set.should eql(SS["A", "B", "C"])
           end
 
           it "returns a new set with the mapped values" do
-            sorted_set.send(method, &:downcase).should eql(Hamster.sorted_set("a", "b", "c"))
+            sorted_set.send(method, &:downcase).should eql(SS["a", "b", "c"])
           end
         end
 
         context "with no block" do
           it "returns an Enumerator" do
             sorted_set.send(method).class.should be(Enumerator)
-            sorted_set.send(method).each(&:downcase).should == Hamster.sorted_set('a', 'b', 'c')
+            sorted_set.send(method).each(&:downcase).should == SS['a', 'b', 'c']
           end
         end
       end
+
+      context "on a set ordered by a comparator" do
+        let(:sorted_set) { SS.new(["A", "B", "C"]) { |a,b| b <=> a }}
+
+        it "returns a new set with the mapped values" do
+          sorted_set.send(method, &:downcase).should == ['c', 'b', 'a']
+        end
+      end
     end
   end
 end

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

@@ -7,7 +7,7 @@ describe Hamster::SortedSet do
       File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
     end
     let(:child_cmd) do
-      %Q|#{ruby} -I lib -r hamster -e 'set = Hamster.sorted_set(5, 10, 15); $stdout.write(Marshal.dump(set))'|
+      %Q|#{ruby} -I lib -r hamster -e 'set = Hamster::SortedSet[5, 10, 15]; $stdout.write(Marshal.dump(set))'|
     end
 
     let(:reloaded_set) do
@@ -19,7 +19,7 @@ describe Hamster::SortedSet do
     end
 
     it "can survive dumping and loading into a new process" do
-      expect(reloaded_set).to eql(Hamster.sorted_set(5, 10, 15))
+      expect(reloaded_set).to eql(SS[5, 10, 15])
     end
 
     it "is still possible to find items by index after loading" do
@@ -31,7 +31,7 @@ describe Hamster::SortedSet do
 
     it "raises a TypeError if set has a custom sort order" do
       # this is because comparator block can't be serialized
-      -> { Marshal.dump(Hamster.sorted_set(1, 2, 3) { |x| -x }) }.should raise_error(TypeError)
+      -> { Marshal.dump(SS.new([1, 2, 3]) { |x| -x }) }.should raise_error(TypeError)
     end
   end
 end

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

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::SortedSet do
+  describe "#max" do
+    context "with a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "Ichi"],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          let(:set) { SS[*values] }
+          let(:result) { set.max { |maximum, item| maximum.length <=> item.length }}
+
+          it "returns #{expected.inspect}" do
+            result.should == expected
+          end
+        end
+      end
+    end
+
+    context "without a block" do
+      [
+        [[], nil],
+        [["A"], "A"],
+        [%w[Ichi Ni San], "San"],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          it "returns #{expected.inspect}" do
+            SS[*values].max.should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,19 +2,17 @@ require "spec_helper"
 require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
-  [:minimum, :min].each do |method|
-    describe "##{method}" do
-      [
-        [[], nil],
-        [["A"], "A"],
-        [%w[Ichi Ni San], "Ichi"],
-        [[1,2,3,4,5], 1],
-        [[0, -0.0, 2.2, -4, -4.2], -4.2],
-      ].each do |values, expected|
-        context "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            Hamster.sorted_set(*values).send(method).should == expected
-          end
+  describe "#min" do
+    [
+      [[], nil],
+      [["A"], "A"],
+      [%w[Ichi Ni San], "Ichi"],
+      [[1,2,3,4,5], 1],
+      [[0, -0.0, 2.2, -4, -4.2], -4.2],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          SS[*values].min.should == expected
         end
       end
     end

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

@@ -4,7 +4,7 @@ require "hamster/sorted_set"
 describe Hamster::SortedSet do
   describe ".new" do
     it "accepts a single enumerable argument and creates a new sorted set" do
-      sorted_set = Hamster::SortedSet.new([1,2,3])
+      sorted_set = SS.new([1,2,3])
       sorted_set.size.should be(3)
       sorted_set[0].should be(1)
       sorted_set[1].should be(2)
@@ -12,7 +12,7 @@ describe Hamster::SortedSet do
     end
 
     it "also works with a Range" do
-      sorted_set = Hamster::SortedSet.new(1..3)
+      sorted_set = SS.new(1..3)
       sorted_set.size.should be(3)
       sorted_set[0].should be(1)
       sorted_set[1].should be(2)
@@ -31,6 +31,26 @@ describe Hamster::SortedSet do
       sorted_set.to_a.should == ['SNAZZY!!!']
     end
 
+    it "accepts a block with arity 1" do
+      sorted_set = SS.new(1..3) { |a| -a }
+      sorted_set[0].should be(3)
+      sorted_set[1].should be(2)
+      sorted_set[2].should be(1)
+    end
+
+    it "accepts a block with arity 2" do
+      sorted_set = SS.new(1..3) { |a,b| b <=> a }
+      sorted_set[0].should be(3)
+      sorted_set[1].should be(2)
+      sorted_set[2].should be(1)
+    end
+
+    it "can use a block produced by Symbol#to_proc" do
+      sorted_set = SS.new([Object, BasicObject], &:name.to_proc)
+      sorted_set[0].should be(BasicObject)
+      sorted_set[1].should be(Object)
+    end
+
     context "from a subclass" do
       it "returns a frozen instance of the subclass" do
         subclass = Class.new(Hamster::SortedSet)
@@ -43,7 +63,7 @@ describe Hamster::SortedSet do
 
   describe ".[]" do
     it "accepts a variable number of items and creates a new sorted set" do
-      sorted_set = Hamster::SortedSet['a', 'b']
+      sorted_set = SS['a', 'b']
       sorted_set.size.should be(2)
       sorted_set[0].should == 'a'
       sorted_set[1].should == 'b'

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

@@ -4,7 +4,7 @@ require "hamster/sorted_set"
 describe Hamster::SortedSet do
   describe "#reverse_each" do
     context "with no block" do
-      let(:sorted_set) { Hamster.sorted_set("A", "B", "C") }
+      let(:sorted_set) { SS["A", "B", "C"] }
 
       it "returns an Enumerator" do
         sorted_set.reverse_each.class.should be(Enumerator)
@@ -13,7 +13,7 @@ describe Hamster::SortedSet do
     end
 
     context "with a block" do
-      let(:sorted_set) { Hamster::SortedSet.new((1..1025).to_a) }
+      let(:sorted_set) { SS.new(1..1025) }
 
       it "returns self" do
         sorted_set.reverse_each {}.should be(sorted_set)

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

@@ -2,14 +2,14 @@ require "spec_helper"
 require "hamster/sorted_set"
 
 describe Hamster::SortedSet do
-  [:filter, :select, :find_all].each do |method|
+  [:select, :find_all].each do |method|
     describe "##{method}" do
-      let(:sorted_set) { Hamster.sorted_set("A", "B", "C") }
+      let(:sorted_set) { SS["A", "B", "C"] }
 
       context "when everything matches" do
         it "preserves the original" do
           sorted_set.send(method) { true }
-          sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
+          sorted_set.should eql(SS["A", "B", "C"])
         end
 
         it "returns self" do
@@ -21,18 +21,18 @@ describe Hamster::SortedSet do
         context "with a block" do
           it "preserves the original" do
             sorted_set.send(method) { |item| item == "A" }
-            sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
+            sorted_set.should eql(SS["A", "B", "C"])
           end
 
           it "returns a set with the matching values" do
-            sorted_set.send(method) { |item| item == "A" }.should eql(Hamster.sorted_set("A"))
+            sorted_set.send(method) { |item| item == "A" }.should eql(SS["A"])
           end
         end
 
         context "with no block" do
           it "returns an Enumerator" do
             sorted_set.send(method).class.should be(Enumerator)
-            sorted_set.send(method).each { |item| item == "A" }.should eql(Hamster.sorted_set("A"))
+            sorted_set.send(method).each { |item| item == "A" }.should eql(SS["A"])
           end
         end
       end
@@ -40,7 +40,7 @@ describe Hamster::SortedSet do
       context "when nothing matches" do
         it "preserves the original" do
           sorted_set.send(method) { |item| false }
-          sorted_set.should eql(Hamster.sorted_set("A", "B", "C"))
+          sorted_set.should eql(SS["A", "B", "C"])
         end
 
         it "returns the canonical empty set" do
@@ -52,9 +52,9 @@ describe Hamster::SortedSet do
         it "returns an instance of the same class" do
           subclass = Class.new(Hamster::SortedSet)
           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
     end