hamster 1.0.1.pre.rc3 → 2.0.0

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

@@ -2,19 +2,17 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  [:empty?, :null?].each do |method|
-    describe "##{method}" do
-      [
-        [[], true],
-        [["A"], false],
-        [%w[A B C], false],
-        [[nil], false],
-        [[false], false]
-      ].each do |values, expected|
-        describe "on #{values.inspect}" do
-          it "returns #{expected.inspect}" do
-            Hamster.set(*values).send(method).should == expected
-          end
+  describe "#empty?" do
+    [
+      [[], true],
+      [["A"], false],
+      [%w[A B C], false],
+      [[nil], false],
+      [[false], false]
+    ].each do |values, expected|
+      describe "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          S[*values].empty?.should == expected
         end
       end
     end
@@ -22,9 +20,9 @@ describe Hamster::Set do
 
   describe ".empty" do
     it "returns the canonical empty set" do
-      Hamster::Set.empty.should be_empty
-      Hamster::Set.empty.object_id.should be(Hamster::Set.empty.object_id)
-      Hamster::Set.empty.should be(Hamster::EmptySet)
+      S.empty.should be_empty
+      S.empty.object_id.should be(S[].object_id)
+      S.empty.should be(Hamster::EmptySet)
     end
 
     context "from a subclass" do
@@ -34,7 +32,7 @@ describe Hamster::Set do
         subclass.empty.should be_empty
       end
 
-      it "calls overridden #initialize when creating empty Hash" do
+      it "calls overridden #initialize when creating empty Set" do
         subclass = Class.new(Hamster::Set) do
           def initialize
             @variable = 'value'

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

@@ -3,8 +3,8 @@ require "set"
 require "hamster/set"
 
 describe Hamster::Set do
-  let(:set) { Hamster.set(*values) }
-  let(:comparison) { Hamster.set(*comparison_values) }
+  let(:set) { S[*values] }
+  let(:comparison) { S[*comparison_values] }
 
   describe "#==" do
     let(:eqeq) { set == comparison }
@@ -18,7 +18,7 @@ describe Hamster::Set 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 non-sets"
     end

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

@@ -3,8 +3,8 @@ require "set"
 require "hamster/set"
 
 describe Hamster::Set do
-  let(:set) { Hamster.set(*values) }
-  let(:comparison) { Hamster.set(*comparison_values) }
+  let(:set) { S[*values] }
+  let(:comparison) { S[*comparison_values] }
 
   describe "#eql?" do
     let(:eql?) { set.eql?(comparison) }
@@ -18,7 +18,7 @@ describe Hamster::Set 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 non-sets"
     end

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

@@ -13,24 +13,24 @@ describe Hamster::Set do
         [%w[A B C], %w[D E F], %w[A B C D E F]],
       ].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] }
           let(:result) { set_a.send(method, set_b) }
 
           it "doesn't modify the original Sets" do
             result
-            set_a.should eql(Hamster::Set.new(a))
-            set_b.should eql(Hamster::Set.new(b))
+            set_a.should eql(S.new(a))
+            set_b.should eql(S.new(b))
           end
 
           it "returns #{expected.inspect}"  do
-            result.should eql(Hamster.set(*expected))
+            result.should eql(S[*expected])
           end
         end
 
         context "when passed a Ruby Array" do
           it "returns the expected Set" do
-            Hamster.set(*a).exclusion(b.freeze).should eql(Hamster.set(*expected))
+            S[*a].exclusion(b.freeze).should eql(S[*expected])
           end
         end
       end
@@ -39,7 +39,7 @@ describe Hamster::Set do
         50.times do
           array1 = (1..400).to_a.sample(100)
           array2 = (1..400).to_a.sample(100)
-          result = Hamster::Set.new(array1) ^ Hamster::Set.new(array2)
+          result = S.new(array1) ^ S.new(array2)
           result.to_a.sort.should eql(((array1 | array2) - (array1 & array2)).sort)
         end
       end

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

@@ -18,13 +18,13 @@ describe Hamster::Set do
         describe "on #{values.inspect}" do
           context "with a block" do
             it "returns #{expected.inspect}" do
-              Hamster.set(*values).send(method) { |x| x == item }.should == expected
+              S[*values].send(method) { |x| x == item }.should == expected
             end
           end
 
           context "without a block" do
             it "returns an Enumerator" do
-              result = Hamster.set(*values).send(method)
+              result = S[*values].send(method)
               result.class.should be(Enumerator)
               result.each { |x| x == item}.should == expected
             end

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

@@ -0,0 +1,29 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#first" do
+    context "on an empty set" do
+      it "returns nil" do
+        S.empty.first.should be_nil
+      end
+    end
+
+    context "on a non-empty set" do
+      it "returns an arbitrary value from the set" do
+        %w[A B C].include?(S["A", "B", "C"].first).should == true
+      end
+    end
+
+    it "returns nil if only member of set is nil" do
+      S[nil].first.should be(nil)
+    end
+
+    it "returns the first item yielded by #each" do
+      10.times do
+        set = S.new((rand(10)+1).times.collect { rand(10000 )})
+        set.each { |item| break item }.should be(set.first)
+      end
+    end
+  end
+end

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

@@ -6,33 +6,33 @@ describe Hamster do
     [
       [["A"], ["A"]],
       [%w[A B C], %w[A B C]],
-      [["A", Hamster.set("B"), "C"], %w[A B C]],
-      [[Hamster.set("A"), Hamster.set("B"), Hamster.set("C")], %w[A B C]],
+      [["A", S["B"], "C"], %w[A B C]],
+      [[S["A"], S["B"], S["C"]], %w[A B C]],
     ].each do |values, expected|
       describe "on #{values}" do
-        let(:set) { Hamster.set(*values) }
+        let(:set) { S[*values] }
 
         it "preserves the original" do
           set.flatten
-          set.should eql(Hamster.set(*values))
+          set.should eql(S[*values])
         end
 
         it "returns the inlined values" do
-          set.flatten.should eql(Hamster.set(*expected))
+          set.flatten.should eql(S[*expected])
         end
       end
     end
 
     context "on an empty set" do
       it "returns an empty set" do
-        Hamster.set.flatten.should equal(Hamster.set)
+        S.empty.flatten.should equal(S.empty)
       end
     end
 
     context "on a set with multiple levels of nesting" do
       it "inlines lower levels of nesting" do
-        set = Hamster.set(Hamster.set(Hamster.set(1)), Hamster.set(Hamster.set(2)))
-        set.flatten.should eql(Hamster.set(1, 2))
+        set = S[S[S[1]], S[S[2]]]
+        set.flatten.should eql(S[1, 2])
       end
     end
 
@@ -40,7 +40,7 @@ describe Hamster do
       it "returns an instance of the subclass" do
         subclass = Class.new(Hamster::Set)
         subclass.new.flatten.class.should be(subclass)
-        subclass.new([Hamster.set(1), Hamster.set(2)]).flatten.class.should be(subclass)
+        subclass.new([S[1], S[2]]).flatten.class.should be(subclass)
       end
     end
   end

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  let(:set) { Hamster.set(*values) }
+  let(:set) { S[*values] }
 
   describe "#grep" do
     let(:grep) { set.grep(String, &block) }

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

@@ -7,15 +7,15 @@ describe Hamster::Set do
       context "with a block" do
         [
           [[], []],
-          [[1], [true => Hamster.set(1)]],
-          [[1, 2, 3, 4], [true => Hamster.set(3, 1), false => Hamster.set(4, 2)]],
+          [[1], [true => S[1]]],
+          [[1, 2, 3, 4], [true => S[3, 1], false => S[4, 2]]],
         ].each do |values, expected|
           context "on #{values.inspect}" do
-            let(:set) { Hamster.set(*values) }
+            let(:set) { S[*values] }
 
             it "returns #{expected.inspect}" do
-              set.send(method, &:odd?).should eql(Hamster.hash(*expected))
-              set.should eql(Hamster::Set.new(values)) # make sure it hasn't changed
+              set.send(method, &:odd?).should eql(H[*expected])
+              set.should eql(S.new(values)) # make sure it hasn't changed
             end
           end
         end
@@ -24,15 +24,15 @@ describe Hamster::Set do
       context "without a block" do
         [
           [[], []],
-          [[1], [1 => Hamster.set(1)]],
-          [[1, 2, 3, 4], [1 => Hamster.set(1), 2 => Hamster.set(2), 3 => Hamster.set(3), 4 => Hamster.set(4)]],
+          [[1], [1 => S[1]]],
+          [[1, 2, 3, 4], [1 => S[1], 2 => S[2], 3 => S[3], 4 => S[4]]],
         ].each do |values, expected|
           context "on #{values.inspect}" do
-            let(:set) { Hamster.set(*values) }
+            let(:set) { S[*values] }
 
             it "returns #{expected.inspect}" do
-              set.group_by.should eql(Hamster.hash(*expected))
-              set.should eql(Hamster::Set.new(values)) # make sure it hasn't changed
+              set.group_by.should eql(H[*expected])
+              set.should eql(S.new(values)) # make sure it hasn't changed
             end
           end
         end
@@ -40,12 +40,12 @@ describe Hamster::Set do
 
       context "on an empty set" do
         it "returns an empty hash" do
-          Hamster.set.group_by { |x| x }.should eql(Hamster.hash)
+          S.empty.group_by { |x| x }.should eql(H.empty)
         end
       end
 
       it "returns a hash without default proc" do
-        Hamster.set(1,2,3).group_by { |x| x }.default_proc.should be_nil
+        S[1,2,3].group_by { |x| x }.default_proc.should be_nil
       end
 
       context "from a subclass" do

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

@@ -5,7 +5,7 @@ describe Hamster::Set do
   describe "#hash" do
     context "on an empty set" do
       it "returns 0" do
-        Hamster.set.hash.should == 0
+        S.empty.hash.should == 0
       end
     end
 
@@ -13,11 +13,11 @@ describe Hamster::Set do
       item1 = DeterministicHash.new('a', 121)
       item2 = DeterministicHash.new('b', 474)
       item3 = DeterministicHash.new('c', 121)
-      Hamster.set.add(item1).add(item2).add(item3).hash.should == Hamster.set.add(item3).add(item2).add(item1).hash
+      S.empty.add(item1).add(item2).add(item3).hash.should == S.empty.add(item3).add(item2).add(item1).hash
     end
 
     it "values are sufficiently distributed" do
-      (1..4000).each_slice(4).map { |a, b, c, d| Hamster.set(a, b, c, d).hash }.uniq.size.should == 1000
+      (1..4000).each_slice(4).map { |a, b, c, d| S[a, b, c, d].hash }.uniq.size.should == 1000
     end
   end
 end

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

@@ -3,9 +3,9 @@ require "hamster/set"
 require 'set'
 
 describe Hamster::Set do
-  [:include?, :member?, :contains?, :elem?].each do |method|
+  [:include?, :member?].each do |method|
     describe "##{method}" do
-      let(:set) { Hamster.set("A", "B", "C", 2.0, nil) }
+      let(:set) { S["A", "B", "C", 2.0, nil] }
 
       ["A", "B", "C", 2.0, nil].each do |value|
         it "returns true for an existing value (#{value.inspect})" do
@@ -18,17 +18,17 @@ describe Hamster::Set do
       end
 
       it "returns true even if existing value is nil" do
-        Hamster.set(nil).include?(nil).should == true
+        S[nil].include?(nil).should == true
       end
 
       it "returns true even if existing value is false" do
-        Hamster.set(false).include?(false).should == true
+        S[false].include?(false).should == true
       end
 
       it "returns false for a mutable item which is mutated after adding" do
         item = ['mutable']
-        item = [rand(1000000)] while (item.hash & 31 == [item[0], 'HOSED!'].hash & 31)
-        set  = Hamster::Set[item]
+        item = [rand(1000000)] while (item.hash.abs & 31 == [item[0], 'HOSED!'].hash.abs & 31)
+        set  = S[item]
         item.push('HOSED!')
         set.include?(item).should == false
       end
@@ -38,10 +38,10 @@ describe Hamster::Set do
       end
 
       it "returns the right answers after a lot of addings and removings" do
-        array, set, rb_set = [], Hamster::Set.new, Set.new
+        array, set, rb_set = [], S.new, ::Set.new
 
         1000.times do
-          if rand(1) == 0
+          if rand(2) == 0
             array << (item = rand(10000))
             rb_set.add(item)
             set = set.add(item)

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

@@ -8,7 +8,7 @@ describe Hamster::Set do
       [["A"], 'Hamster::Set["A"]'],
     ].each do |values, expected|
       describe "on #{values.inspect}" do
-        let(:set) { Hamster.set(*values) }
+        let(:set) { S[*values] }
 
         it "returns #{expected.inspect}" do
           set.inspect.should == expected
@@ -21,7 +21,7 @@ describe Hamster::Set do
     end
 
     describe 'on ["A", "B", "C"]' do
-      let(:set) { Hamster.set("A", "B", "C") }
+      let(:set) { S["A", "B", "C"] }
 
       it "returns a programmer-readable representation of the set contents" do
         set.inspect.should match(/^Hamster::Set\["[A-C]", "[A-C]", "[A-C]"\]$/)

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

@@ -18,7 +18,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).intersect?(Hamster.set(*b)).should be(expected)
+          S[*a].intersect?(S[*b]).should be(expected)
         end
       end
     end

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  [:intersection, :intersect, :&].each do |method|
+  [:intersection, :&].each do |method|
     describe "##{method}" do
       [
         [[], [], []],
@@ -12,30 +12,30 @@ describe Hamster::Set do
         [%w[A B C], %w[A C], %w[A C]],
       ].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))
+            S[*a].send(method, b.freeze).should eql(S[*expected])
           end
         end
       end
@@ -44,7 +44,7 @@ describe Hamster::Set do
         50.times do
           array1 = rand(100).times.map { rand(1000000).to_s(16) }
           array2 = rand(100).times.map { rand(1000000).to_s(16) }
-          result = Hamster::Set.new(array1).send(method, Hamster::Set.new(array2))
+          result = S.new(array1).send(method, S.new(array2))
           result.to_a.sort.should eql((array1 & array2).sort)
         end
       end