hamster 1.0.1.pre.rc3 → 2.0.0

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  let(:original) { Hamster.set("A", "B", "C") }
+  let(:original) { S["A", "B", "C"] }
 
   [:add, :<<].each do |method|
     describe "##{method}" do
@@ -11,11 +11,11 @@ describe Hamster::Set do
 
         it "preserves the original" do
           result
-          original.should eql(Hamster.set("A", "B", "C"))
+          original.should eql(S["A", "B", "C"])
         end
 
         it "returns a copy with the superset of values" do
-          result.should eql(Hamster.set("A", "B", "C", "D"))
+          result.should eql(S["A", "B", "C", "D"])
         end
       end
 
@@ -24,7 +24,7 @@ describe Hamster::Set do
 
         it "preserves the original values" do
           result
-          original.should eql(Hamster.set("A", "B", "C"))
+          original.should eql(S["A", "B", "C"])
         end
 
         it "returns self" do
@@ -33,15 +33,17 @@ describe Hamster::Set do
       end
 
       it "can add nil to a set" do
-        original.add(nil).should eql(Hamster.set("A", "B", "C", nil))
+        original.add(nil).should eql(S["A", "B", "C", nil])
       end
 
       it "works on large sets, with many combinations of input" do
         50.times do
-          array = (1..500).to_a.sample(100)
-          set = Hamster::Set.new(array)
+          # Array#sample is buggy on RBX 2.5.8; that's why #uniq is needed here
+          # See https://github.com/rubinius/rubinius/issues/3506
+          array = (1..500).to_a.sample(100).uniq
+          set   = S.new(array)
           to_add = 1000 + rand(1000)
-          set.add(to_add).size.should == 101
+          set.add(to_add).size.should == array.size + 1
           set.add(to_add).include?(to_add).should == true
         end
       end
@@ -53,11 +55,11 @@ describe Hamster::Set do
       let(:result) { original.add?("D") }
 
       it "preserves the original" do
-        original.should eql(Hamster.set("A", "B", "C"))
+        original.should eql(S["A", "B", "C"])
       end
 
       it "returns a copy with the superset of values" do
-        result.should eql(Hamster.set("A", "B", "C", "D"))
+        result.should eql(S["A", "B", "C", "D"])
       end
     end
 
@@ -65,7 +67,7 @@ describe Hamster::Set do
       let(:result) { original.add?("C") }
 
       it "preserves the original values" do
-        original.should eql(Hamster.set("A", "B", "C"))
+        original.should eql(S["A", "B", "C"])
       end
 
       it "returns false" do

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

@@ -2,50 +2,48 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  [:all?, :forall?].each do |method|
-    describe "##{method}" do
-      context "when empty" do
-        it "with a block returns true" do
-          Hamster.set.send(method) {}.should == true
-        end
+  describe "#all?" do
+    context "when empty" do
+      it "with a block returns true" do
+        S.empty.all? {}.should == true
+      end
 
-        it "with no block returns true" do
-          Hamster.set.send(method).should == true
-        end
+      it "with no block returns true" do
+        S.empty.all?.should == true
       end
+    end
 
-      context "when not empty" do
-        context "with a block" do
-          let(:set) { Hamster.set("A", "B", "C") }
+    context "when not empty" do
+      context "with a block" do
+        let(:set) { S["A", "B", "C"] }
 
-          it "returns true if the block always returns true" do
-            set.send(method) { |item| true }.should == true
-          end
+        it "returns true if the block always returns true" do
+          set.all? { |item| true }.should == true
+        end
 
-          it "returns false if the block ever returns false" do
-            set.send(method) { |item| item == "D" }.should == false
-          end
+        it "returns false if the block ever returns false" do
+          set.all? { |item| item == "D" }.should == false
+        end
 
-          it "propagates an exception from the block" do
-            -> { set.all? { |k,v| raise "help" } }.should raise_error(RuntimeError)
-          end
+        it "propagates an exception from the block" do
+          -> { set.all? { |k,v| raise "help" } }.should raise_error(RuntimeError)
+        end
 
-          it "stops iterating as soon as the block returns false" do
-            yielded = []
-            set.all? { |k,v| yielded << k; false }
-            yielded.size.should == 1
-          end
+        it "stops iterating as soon as the block returns false" do
+          yielded = []
+          set.all? { |k,v| yielded << k; false }
+          yielded.size.should == 1
         end
+      end
 
-        describe "with no block" do
-          it "returns true if all values are truthy" do
-            Hamster.set(true, "A").send(method).should == true
-          end
+      describe "with no block" do
+        it "returns true if all values are truthy" do
+          S[true, "A"].all?.should == true
+        end
 
-          [nil, false].each do |value|
-            it "returns false if any value is #{value.inspect}" do
-              Hamster.set(value, true, "A").send(method).should == false
-            end
+        [nil, false].each do |value|
+          it "returns false if any value is #{value.inspect}" do
+            S[value, true, "A"].all?.should == false
           end
         end
       end

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

@@ -2,51 +2,49 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  [:any?, :exist?, :exists?].each do |method|
-    describe "##{method}" do
-      context "when empty" do
-        it "with a block returns false" do
-          Hamster.set.send(method) {}.should == false
-        end
+  describe "#any?" do
+    context "when empty" do
+      it "with a block returns false" do
+        S.empty.any? {}.should == false
+      end
 
-        it "with no block returns false" do
-          Hamster.set.send(method).should == false
-        end
+      it "with no block returns false" do
+        S.empty.any?.should == false
       end
+    end
 
-      context "when not empty" do
-        context "with a block" do
-          let(:set) { Hamster.set("A", "B", "C", nil) }
+    context "when not empty" do
+      context "with a block" do
+        let(:set) { S["A", "B", "C", nil] }
 
-          ["A", "B", "C", nil].each do |value|
-            it "returns true if the block ever returns true (#{value.inspect})" do
-              set.send(method) { |item| item == value }.should == true
-            end
+        ["A", "B", "C", nil].each do |value|
+          it "returns true if the block ever returns true (#{value.inspect})" do
+            set.any? { |item| item == value }.should == true
           end
+        end
 
-          it "returns false if the block always returns false" do
-            set.send(method) { |item| item == "D" }.should == false
-          end
+        it "returns false if the block always returns false" do
+          set.any? { |item| item == "D" }.should == false
+        end
 
-          it "propagates exceptions raised in the block" do
-            -> { set.any? { |k,v| raise "help" } }.should raise_error(RuntimeError)
-          end
+        it "propagates exceptions raised in the block" do
+          -> { set.any? { |k,v| raise "help" } }.should raise_error(RuntimeError)
+        end
 
-          it "stops iterating as soon as the block returns true" do
-            yielded = []
-            set.any? { |k,v| yielded << k; true }
-            yielded.size.should == 1
-          end
+        it "stops iterating as soon as the block returns true" do
+          yielded = []
+          set.any? { |k,v| yielded << k; true }
+          yielded.size.should == 1
         end
+      end
 
-        context "with no block" do
-          it "returns true if any value is truthy" do
-            Hamster.set(nil, false, true, "A").send(method).should == true
-          end
+      context "with no block" do
+        it "returns true if any value is truthy" do
+          S[nil, false, true, "A"].any?.should == true
+        end
 
-          it "returns false if all values are falsey" do
-            Hamster.set(nil, false).send(method).should == false
-          end
+        it "returns false if all values are falsey" do
+          S[nil, false].any?.should == false
         end
       end
     end

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

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

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

@@ -15,15 +15,15 @@ describe Hamster::Set do
       [[nil, "B", nil], ["B"]],
     ].each do |values, expected|
       describe "on #{values.inspect}" do
-        let(:set) { Hamster.set(*values) }
+        let(:set) { S[*values] }
 
         it "preserves the original" do
           set.compact
-          set.should eql(Hamster.set(*values))
+          set.should eql(S[*values])
         end
 
         it "returns #{expected.inspect}" do
-          set.compact.should eql(Hamster.set(*expected))
+          set.compact.should eql(S[*expected])
         end
       end
     end

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

@@ -5,14 +5,14 @@ describe Hamster::Set do
   describe ".set" do
     context "with no values" do
       it "returns the empty set" do
-        Hamster.set.should be_empty
-        Hamster.set.should equal(Hamster::EmptySet)
+        S.empty.should be_empty
+        S.empty.should equal(Hamster::EmptySet)
       end
     end
 
     context "with a list of values" do
       it "is equivalent to repeatedly using #add" do
-        Hamster.set("A", "B", "C").should eql(Hamster.set.add("A").add("B").add("C"))
+        S["A", "B", "C"].should eql(S.empty.add("A").add("B").add("C"))
       end
     end
   end

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

@@ -3,7 +3,7 @@ require "hamster/set"
 
 describe Hamster::Set do
   [:dup, :clone].each do |method|
-    let(:set) { Hamster.set("A", "B", "C") }
+    let(:set) { S["A", "B", "C"] }
 
     describe "##{method}" do
       it "returns self" do

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

@@ -12,7 +12,7 @@ describe Hamster::Set do
       [[1, 2, 3, 4, 5], 3],
     ].each do |values, expected|
       describe "on #{values.inspect}" do
-        let(:set) { Hamster.set(*values) }
+        let(:set) { S[*values] }
 
         context "with a block" do
           it "returns #{expected.inspect}" do

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

@@ -2,24 +2,24 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  let(:set) { Hamster.set("A", "B", "C") }
+  let(:set) { S["A", "B", "C"] }
 
   describe "#delete" do
     context "with an existing value" do
       it "preserves the original" do
         set.delete("B")
-        set.should eql(Hamster.set("A", "B", "C"))
+        set.should eql(S["A", "B", "C"])
       end
 
       it "returns a copy with the remaining values" do
-        set.delete("B").should eql(Hamster.set("A", "C"))
+        set.delete("B").should eql(S["A", "C"])
       end
     end
 
     context "with a non-existing value" do
       it "preserves the original values" do
         set.delete("D")
-        set.should eql(Hamster.set("A", "B", "C"))
+        set.should eql(S["A", "B", "C"])
       end
 
       it "returns self" do
@@ -35,7 +35,7 @@ describe Hamster::Set do
 
     it "works on large sets, with many combinations of input" do
       array = 1000.times.map { %w[a b c d e f g h i j k l m n].sample(5).join }.uniq
-      set = Hamster::Set.new(array)
+      set = S.new(array)
       array.each do |key|
         result = set.delete(key)
         result.size.should == set.size - 1
@@ -50,18 +50,18 @@ describe Hamster::Set do
     context "with an existing value" do
       it "preserves the original" do
         set.delete?("B")
-        set.should eql(Hamster.set("A", "B", "C"))
+        set.should eql(S["A", "B", "C"])
       end
 
       it "returns a copy with the remaining values" do
-        set.delete?("B").should eql(Hamster.set("A", "C"))
+        set.delete?("B").should eql(S["A", "C"])
       end
     end
 
     context "with a non-existing value" do
       it "preserves the original values" do
         set.delete?("D")
-        set.should eql(Hamster.set("A", "B", "C"))
+        set.should eql(S["A", "B", "C"])
       end
 
       it "returns false" do

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  [:difference, :diff, :subtract, :-].each do |method|
+  [:difference, :subtract, :-].each do |method|
     describe "##{method}" do
       [
         [[], [], []],
@@ -14,24 +14,24 @@ describe Hamster::Set do
         [%w[A B C M X Y Z], %w[B C D E F G H I J X], %w[A M 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] }
           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).difference(b.freeze).should eql(Hamster.set(*expected))
+            S[*a].difference(b.freeze).should eql(S[*expected])
           end
         end
       end
@@ -41,7 +41,7 @@ describe Hamster::Set do
         50.times do
           array1 = items.sample(200)
           array2 = items.sample(200)
-          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

data/spec/lib/hamster/set/disjoint_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).disjoint?(Hamster.set(*b)).should be(expected)
+          S[*a].disjoint?(S[*b]).should be(expected)
         end
       end
     end

data/spec/lib/hamster/set/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 "#each" do
     let(:each) { set.each(&block) }
@@ -37,7 +37,7 @@ describe Hamster::Set do
     end
 
     it "yields both of a pair of colliding keys" do
-      set = Hamster::Set[DeterministicHash.new('a', 1010), DeterministicHash.new('b', 1010)]
+      set = S[DeterministicHash.new('a', 1010), DeterministicHash.new('b', 1010)]
       yielded = []
       set.each { |obj| yielded << obj }
       yielded.map(&:value).sort.should == ['a', 'b']