hamster 1.0.1.pre.rc2 → 1.0.1.pre.rc3

data/spec/{hamster → lib/hamster}/set/all_spec.rb

@@ -4,32 +4,36 @@ require "hamster/set"
 describe Hamster::Set do
   [:all?, :forall?].each do |method|
     describe "##{method}" do
-      describe "when empty" do
-        before do
-          @set = Hamster.set
-        end
-
+      context "when empty" do
         it "with a block returns true" do
-          @set.send(method) {}.should == true
+          Hamster.set.send(method) {}.should == true
         end
 
         it "with no block returns true" do
-          @set.send(method).should == true
+          Hamster.set.send(method).should == true
         end
       end
 
-      describe "when not empty" do
-        describe "with a block" do
-          before do
-            @set = Hamster.set("A", "B", "C")
-          end
+      context "when not empty" do
+        context "with a block" do
+          let(:set) { Hamster.set("A", "B", "C") }
 
           it "returns true if the block always returns true" do
-            @set.send(method) { |item| true }.should == true
+            set.send(method) { |item| true }.should == true
           end
 
           it "returns false if the block ever returns false" do
-            @set.send(method) { |item| item == "D" }.should == false
+            set.send(method) { |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 "stops iterating as soon as the block returns false" do
+            yielded = []
+            set.all? { |k,v| yielded << k; false }
+            yielded.size.should == 1
           end
         end
 

data/spec/{hamster → lib/hamster}/set/any_spec.rb

@@ -4,39 +4,42 @@ require "hamster/set"
 describe Hamster::Set do
   [:any?, :exist?, :exists?].each do |method|
     describe "##{method}" do
-      describe "when empty" do
-        before do
-          @set = Hamster.set
-        end
-
+      context "when empty" do
         it "with a block returns false" do
-          @set.send(method) {}.should == false
+          Hamster.set.send(method) {}.should == false
         end
 
         it "with no block returns false" do
-          @set.send(method).should == false
+          Hamster.set.send(method).should == false
         end
       end
 
-      describe "when not empty" do
-        describe "with a block" do
-          before do
-            @set = Hamster.set("A", "B", "C", nil)
-          end
+      context "when not empty" do
+        context "with a block" do
+          let(:set) { Hamster.set("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
+              set.send(method) { |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
+            set.send(method) { |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 "stops iterating as soon as the block returns true" do
+            yielded = []
+            set.any? { |k,v| yielded << k; true }
+            yielded.size.should == 1
           end
         end
 
-        describe "with no block" do
+        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

data/spec/{hamster → lib/hamster}/set/clear_spec.rb

@@ -8,29 +8,26 @@ describe Hamster::Set do
       ["A"],
       %w[A B C],
     ].each do |values|
-
       describe "on #{values}" do
-        before do
-          @original = Hamster.set(*values)
-          @result = @original.clear
-        end
+        let(:set) { Hamster.set(*values) }
 
         it "preserves the original" do
-          @original.should == Hamster.set(*values)
+          set.clear
+          set.should eql(Hamster.set(*values))
         end
 
         it "returns an empty set" do
-          @result.should equal(Hamster.set)
+          set.clear.should equal(Hamster.set)
         end
       end
     end
 
     context "from a subclass" do
       it "returns an empty instance of the subclass" do
-        @subclass = Class.new(Hamster::Set)
-        @instance = @subclass.new(:a, :b, :c, :d)
-        @instance.clear.class.should be(@subclass)
-        @instance.clear.should be_empty
+        subclass = Class.new(Hamster::Set)
+        instance = subclass.new([:a, :b, :c, :d])
+        instance.clear.class.should be(subclass)
+        instance.clear.should be_empty
       end
     end
   end

data/spec/{hamster → lib/hamster}/set/compact_spec.rb

@@ -14,19 +14,16 @@ describe Hamster::Set do
       [["A", nil, "C"], %w[A C]],
       [[nil, "B", nil], ["B"]],
     ].each do |values, expected|
-
       describe "on #{values.inspect}" do
-        before do
-          @original = Hamster.set(*values)
-          @result = @original.compact
-        end
+        let(:set) { Hamster.set(*values) }
 
         it "preserves the original" do
-          @original.should == Hamster.set(*values)
+          set.compact
+          set.should eql(Hamster.set(*values))
         end
 
         it "returns #{expected.inspect}" do
-          @result.should == Hamster.set(*expected)
+          set.compact.should eql(Hamster.set(*expected))
         end
       end
     end

data/spec/{hamster → lib/hamster}/set/construction_spec.rb

@@ -3,20 +3,16 @@ require "hamster/set"
 
 describe Hamster::Set do
   describe ".set" do
-    describe "with no values" do
+    context "with no values" do
       it "returns the empty set" do
+        Hamster.set.should be_empty
         Hamster.set.should equal(Hamster::EmptySet)
       end
-
     end
 
-    describe "with a list of values" do
-      before do
-        @set = Hamster.set("A", "B", "C")
-      end
-
+    context "with a list of values" do
       it "is equivalent to repeatedly using #add" do
-        @set.should == Hamster.set.add("A").add("B").add("C")
+        Hamster.set("A", "B", "C").should eql(Hamster.set.add("A").add("B").add("C"))
       end
     end
   end

data/spec/{hamster → lib/hamster}/set/copying_spec.rb

@@ -2,14 +2,12 @@ require "spec_helper"
 require "hamster/set"
 
 describe Hamster::Set do
-  before do
-    @set = Hamster.set("A", "B", "C")
-  end
-
   [:dup, :clone].each do |method|
+    let(:set) { Hamster.set("A", "B", "C") }
+
     describe "##{method}" do
       it "returns self" do
-        @set.send(method).should equal(@set)
+        set.send(method).should equal(set)
       end
     end
   end

data/spec/{hamster → lib/hamster}/set/count_spec.rb

@@ -11,32 +11,27 @@ describe Hamster::Set do
       [[1, 2, 3, 4], 2],
       [[1, 2, 3, 4, 5], 3],
     ].each do |values, expected|
-
       describe "on #{values.inspect}" do
-        before do
-          @original = Hamster.set(*values)
-        end
-
-        describe "with a block" do
-          before do
-            @result = @original.count(&:odd?)
-          end
+        let(:set) { Hamster.set(*values) }
 
+        context "with a block" do
           it "returns #{expected.inspect}" do
-            @result.should == expected
+            set.count(&:odd?).should == expected
           end
         end
 
-        describe "without a block" do
-          before do
-            @result = @original.count
-          end
-
+        context "without a block" do
           it "returns length" do
-            @result.should == @original.length
+            set.count.should == set.length
           end
         end
       end
     end
+
+    it "works on large sets" do
+      set = Hamster::Set.new(1..2000)
+      set.count.should == 2000
+      set.count(&:odd?).should == 1000
+    end
   end
 end

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

@@ -0,0 +1,72 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  let(:set) { Hamster.set("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"))
+      end
+
+      it "returns a copy with the remaining values" do
+        set.delete("B").should eql(Hamster.set("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"))
+      end
+
+      it "returns self" do
+        set.delete("D").should equal(set)
+      end
+    end
+
+    context "when removing the last value in a set" do
+      it "returns the canonical empty set" do
+        set.delete("B").delete("C").delete("A").should be(Hamster::EmptySet)
+      end
+    end
+
+    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)
+      array.each do |key|
+        result = set.delete(key)
+        result.size.should == set.size - 1
+        result.include?(key).should == false
+        other = array.sample
+        (result.include?(other).should == true) if other != key
+      end
+    end
+  end
+
+  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"))
+      end
+
+      it "returns a copy with the remaining values" do
+        set.delete?("B").should eql(Hamster.set("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"))
+      end
+
+      it "returns false" do
+        set.delete?("D").should be(false)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:difference, :diff, :subtract, :-].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], []],
+        [["A"], [], ["A"]],
+        [["A"], ["A"], []],
+        [%w[A B C], ["B"], %w[A C]],
+        [%w[A B C], %w[A C], ["B"]],
+        [%w[A B C D E F G H], [], %w[A B C D E F G H]],
+        [%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(: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))
+          end
+
+          it "returns #{expected.inspect}"  do
+            result.should eql(Hamster.set(*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))
+          end
+        end
+      end
+
+      it "works on a wide variety of inputs" do
+        items = ('aa'..'zz').to_a
+        50.times do
+          array1 = items.sample(200)
+          array2 = items.sample(200)
+          result = Hamster::Set.new(array1).send(method, Hamster::Set.new(array2))
+          result.to_a.sort.should eql((array1 - array2).sort)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#disjoint?" do
+    [
+      [[], [], true],
+      [["A"], [], true],
+      [[], ["A"], true],
+      [["A"], ["A"], false],
+      [%w[A B C], ["B"], false],
+      [["B"], %w[A B C], false],
+      [%w[A B C], %w[D E], true],
+      [%w[F G H I], %w[A B C], true],
+      [%w[A B C], %w[A B C], false],
+      [%w[A B C], %w[A B C D], false],
+      [%w[D E F G], %w[A B C], true],
+    ].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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require "spec_helper"
+require "set"
+require "hamster/set"
+
+describe Hamster::Set do
+  let(:set) { Hamster.set("A", "B", "C") }
+
+  describe "#each" do
+    let(:each) { set.each(&block) }
+
+    context "without a block" do
+      let(:block) { nil }
+
+      it "returns an Enumerator" do
+        expect(each.class).to be(Enumerator)
+        expect(each.to_a).to eq(set.to_a)
+      end
+    end
+
+    context "with an empty block" do
+      let(:block) { ->(item) {} }
+
+      it "returns self" do
+        expect(each).to be(set)
+      end
+    end
+
+    context "with a block" do
+      let(:items)  { ::Set.new }
+      let(:values) { ::Set.new(%w[A B C]) }
+      let(:block)  { ->(item) { items << item } }
+      before(:each) { each }
+
+      it "yields all values" do
+        expect(items).to eq(values)
+      end
+    end
+
+    it "yields both of a pair of colliding keys" do
+      set = Hamster::Set[DeterministicHash.new('a', 1010), DeterministicHash.new('b', 1010)]
+      yielded = []
+      set.each { |obj| yielded << obj }
+      yielded.map(&:value).sort.should == ['a', 'b']
+    end
+  end
+end