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

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

@@ -0,0 +1,48 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#inspect" do
+    [
+      [[], "Hamster::Set[]"],
+      [["A"], 'Hamster::Set["A"]'],
+    ].each do |values, expected|
+      describe "on #{values.inspect}" do
+        let(:set) { Hamster.set(*values) }
+
+        it "returns #{expected.inspect}" do
+          set.inspect.should == expected
+        end
+
+        it "returns a string which can be eval'd to get an equivalent set" do
+          eval(set.inspect).should eql(set)
+        end
+      end
+    end
+
+    describe 'on ["A", "B", "C"]' do
+      let(:set) { Hamster.set("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]"\]$/)
+      end
+
+      it "returns a string which can be eval'd to get an equivalent set" do
+        eval(set.inspect).should eql(set)
+      end
+    end
+
+    context "from a subclass" do
+      MySet = Class.new(Hamster::Set)
+      let(:set) { MySet[1, 2] }
+
+      it "returns a programmer-readable representation of the set contents" do
+        set.inspect.should match(/^MySet\[[1-2], [1-2]\]$/)
+      end
+
+      it "returns a string which can be eval'd to get an equivalent set" do
+        eval(set.inspect).should eql(set)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,53 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:intersection, :intersect, :&].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], []],
+        [["A"], [], []],
+        [["A"], ["A"], ["A"]],
+        [%w[A B C], ["B"], ["B"]],
+        [%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) }
+
+          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))
+          end
+        end
+
+        context "for #{b.inspect} and #{a.inspect}"  do
+          let(:set_a) { Hamster.set(*a) }
+          let(:set_b) { Hamster.set(*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))
+          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))
+          end
+        end
+      end
+
+      it "returns results consistent with Array#&" 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.to_a.sort.should eql((array1 & array2).sort)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#join" do
+    context "with a separator" do
+      [
+        [[], ""],
+        [["A"], "A"],
+        [[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)], "A|B|C"]
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          let(:set) { Hamster.set(*values) }
+
+          it "preserves the original" do
+            set.join("|")
+            set.should eql(Hamster.set(*values))
+          end
+
+          it "returns #{expected.inspect}" do
+            set.join("|").should eql(expected)
+          end
+        end
+      end
+    end
+
+    context "without a separator" do
+      [
+        [[], ""],
+        [["A"], "A"],
+        [[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)], "ABC"]
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          let(:set) { Hamster.set(*values) }
+
+          it "preserves the original" do
+            set.join
+            set.should eql(Hamster.set(*values))
+          end
+
+          it "returns #{expected.inspect}" do
+            set.join.should eql(expected)
+          end
+        end
+      end
+    end
+
+    context "without a separator (with global default separator set)" do
+      before { $, = '**' }
+      let(:set) { Hamster::Set[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)] }
+      after  { $, = nil }
+
+      context "on ['A', 'B', 'C']" do
+        it "preserves the original" do
+          set.join
+          set.should eql(Hamster::Set[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)])
+        end
+
+        it "returns #{@expected.inspect}" do
+          set.join.should == "A**B**C"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:map, :collect].each do |method|
+    describe "##{method}" do
+      context "when empty" do
+        it "returns self" do
+          Hamster.set.send(method) {}.should equal(Hamster.set)
+        end
+      end
+
+      context "when not empty" do
+        let(:set) { Hamster.set("A", "B", "C") }
+
+        context "with a block" do
+          it "preserves the original values" do
+            set.send(method, &:downcase)
+            set.should eql(Hamster.set("A", "B", "C"))
+          end
+
+          it "returns a new set with the mapped values" do
+            set.send(method, &:downcase).should eql(Hamster.set("a", "b", "c"))
+          end
+        end
+
+        context "with no block" do
+          it "returns an Enumerator" do
+            set.send(method).class.should be(Enumerator)
+            set.send(method).each(&:downcase).should == Hamster.set('a', 'b', 'c')
+          end
+        end
+      end
+
+      context "from a subclass" do
+        it "returns an instance of the subclass" do
+          subclass = Class.new(Hamster::Set)
+          instance = subclass['a', 'b']
+          instance.map { |item| item.upcase }.class.should be(subclass)
+        end
+      end
+
+      context "when multiple items map to the same value" do
+        it "filters out the duplicates" do
+          set = Hamster::Set.new('aa'..'zz')
+          result = set.map { |s| s[0] }
+          result.should eql(Hamster::Set.new('a'..'z'))
+          result.size.should == 26
+        end
+      end
+
+      it "works on large sets" do
+        set = Hamster::Set.new(1..1000)
+        result = set.map { |x| x * 10 }
+        result.size.should == 1000
+        1.upto(1000) { |n| result.include?(n * 10).should == true }
+      end
+    end
+  end
+end

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

@@ -17,11 +17,11 @@ describe Hamster::Set do
       end
     end
 
-    it "should survive dumping and loading into a new process" do
-      reloaded_hash.should == Hamster.set(:one, :two)
+    it "can survive dumping and loading into a new process" do
+      reloaded_hash.should eql(Hamster.set(:one, :two))
     end
 
-    it "should still be possible to test items by key" do
+    it "is still possible to test items by key after loading" do
       reloaded_hash.should include :one
       reloaded_hash.should include :two
     end

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

@@ -4,41 +4,32 @@ require "hamster/set"
 describe Hamster::Set do
   [:maximum, :max].each do |method|
     describe "##{method}" do
-      describe "with a block" do
+      context "with a block" do
         [
           [[], nil],
           [["A"], "A"],
           [%w[Ichi Ni San], "Ichi"],
         ].each do |values, expected|
-
           describe "on #{values.inspect}" do
-            before do
-              original = Hamster.set(*values)
-              @result = original.send(method) { |maximum, item| item.length <=> maximum.length }
-            end
+            let(:set) { Hamster.set(*values) }
+            let(:result) { set.send(method) { |maximum, item| maximum.length <=> item.length }}
 
             it "returns #{expected.inspect}" do
-              @result.should == expected
+              result.should == expected
             end
           end
         end
       end
 
-      describe "without a block" do
+      context "without a block" do
         [
           [[], nil],
           [["A"], "A"],
           [%w[Ichi Ni San], "San"],
         ].each do |values, expected|
-
           describe "on #{values.inspect}" do
-            before do
-              original = Hamster.set(*values)
-              @result = original.send(method)
-            end
-
             it "returns #{expected.inspect}" do
-              @result.should == expected
+              Hamster.set(*values).send(method).should == expected
             end
           end
         end

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

@@ -4,42 +4,32 @@ require "hamster/set"
 describe Hamster::Set do
   [:minimum, :min].each do |method|
     describe "##{method}" do
-      describe "with a block" do
-
+      context "with a block" do
         [
           [[], nil],
           [["A"], "A"],
           [%w[Ichi Ni San], "Ni"],
         ].each do |values, expected|
-
           describe "on #{values.inspect}" do
-            before do
-              original = Hamster.set(*values)
-              @result = original.send(method) { |minimum, item| item.length <=> minimum.length }
-            end
+            let(:set) { Hamster.set(*values) }
+            let(:result) { set.send(method) { |minimum, item| minimum.length <=> item.length }}
 
             it "returns #{expected.inspect}" do
-              @result.should == expected
+              result.should == expected
             end
           end
         end
       end
 
-      describe "without a block" do
+      context "without a block" do
         [
           [[], nil],
           [["A"], "A"],
           [%w[Ichi Ni San], "Ichi"],
         ].each do |values, expected|
-
           describe "on #{values.inspect}" do
-            before do
-              original = Hamster.set(*values)
-              @result = original.send(method)
-            end
-
             it "returns #{expected.inspect}" do
-              @result.should == expected
+              Hamster.set(*values).send(method).should == expected
             end
           end
         end

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

@@ -0,0 +1,54 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe ".new" do
+    it "initializes a new set" do
+      set = Hamster::Set.new([1,2,3])
+      set.size.should be(3)
+      [1,2,3].each { |n| set.include?(n).should == true }
+    end
+
+    it "accepts a Range" do
+      set = Hamster::Set.new(1..3)
+      set.size.should be(3)
+      [1,2,3].each { |n| set.include?(n).should == true }
+    end
+
+    it "returns a Set which doesn't change even if the initializer is mutated" do
+      array = [1,2,3]
+      set = Hamster::Set.new([1,2,3])
+      array.push('BAD')
+      set.should eql(Hamster.set(1,2,3))
+    end
+
+    context "from a subclass" do
+      it "returns a frozen instance of the subclass" do
+        subclass = Class.new(Hamster::Set)
+        instance = subclass.new(["some", "values"])
+        instance.class.should be subclass
+        instance.should be_frozen
+      end
+    end
+
+    it "is amenable to overriding of #initialize" do
+      class SnazzySet < Hamster::Set
+        def initialize
+          super(['SNAZZY!!!'])
+        end
+      end
+
+      set = SnazzySet.new
+      set.size.should be(1)
+      set.include?('SNAZZY!!!').should == true
+    end
+  end
+
+  describe "[]" do
+    it "accepts any number of arguments and initializes a new set" do
+      set = Hamster::Set[1,2,3,4]
+      set.size.should be(4)
+      [1,2,3,4].each { |n| set.include?(n).should == true }
+    end
+  end
+end

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

@@ -3,38 +3,38 @@ require "hamster/set"
 
 describe Hamster::Set do
   describe "#none?" do
-    describe "when empty" do
-      before do
-        @set = Hamster.set
-      end
-
+    context "when empty" do
       it "with a block returns true" do
-        @set.none? {}.should == true
+        Hamster.set.none? {}.should == true
       end
 
       it "with no block returns true" do
-        @set.none?.should == true
+        Hamster.set.none?.should == true
       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 false if the block ever returns true (#{value.inspect})" do
-            @set.none? { |item| item == value }.should == false
+            set.none? { |item| item == value }.should == false
           end
         end
 
         it "returns true if the block always returns false" do
-          @set.none? { |item| item == "D" }.should == true
+          set.none? { |item| item == "D" }.should == true
+        end
+
+        it "stops iterating as soon as the block returns true" do
+          yielded = []
+          set.none? { |item| yielded << item; true }
+          yielded.size.should == 1
         end
       end
 
-      describe "with no block" do
+      context "with no block" do
         it "returns false if any value is truthy" do
           Hamster.set(nil, false, true, "A").none?.should == false
         end