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

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

@@ -0,0 +1,47 @@
+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
+        end
+      end
+    end
+  end
+
+  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)
+    end
+
+    context "from a subclass" do
+      it "returns an empty instance of the subclass" do
+        subclass = Class.new(Hamster::Set)
+        subclass.empty.class.should be(subclass)
+        subclass.empty.should be_empty
+      end
+
+      it "calls overridden #initialize when creating empty Hash" do
+        subclass = Class.new(Hamster::Set) do
+          def initialize
+            @variable = 'value'
+          end
+        end
+        subclass.empty.instance_variable_get(:@variable).should == 'value'
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ describe Hamster::Set do
   let(:set) { Hamster.set(*values) }
   let(:comparison) { Hamster.set(*comparison_values) }
 
-  describe "#==" do
+  describe "#eql?" do
     let(:eql?) { set.eql?(comparison) }
 
     shared_examples "comparing non-sets" do
@@ -29,6 +29,12 @@ describe Hamster::Set do
       include_examples "comparing non-sets"
     end
 
+    context "when comparing with a subclass of Hamster::Set" do
+      let(:comparison) { Class.new(Hamster::Set).new(%w[A B C]) }
+
+      include_examples "comparing non-sets"
+    end
+
     context "with an empty set for each comparison" do
       let(:values) { [] }
       let(:comparison_values) { [] }

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

@@ -0,0 +1,48 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:exclusion, :^].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], []],
+        [["A"], [], ["A"]],
+        [["A"], ["A"], []],
+        [%w[A B C], ["B"], %w[A C]],
+        [%w[A B C], %w[B C D], %w[A D]],
+        [%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(: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).exclusion(b.freeze).should eql(Hamster.set(*expected))
+          end
+        end
+      end
+
+      it "works for a wide variety of inputs" 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.to_a.sort.should eql(((array1 | array2) - (array1 & array2)).sort)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:filter, :select, :find_all].each do |method|
+    describe "##{method}" do
+      let(:set) { Hamster.set("A", "B", "C") }
+
+      context "when everything matches" do
+        it "returns self" do
+          set.send(method) { |item| true }.should equal(set)
+        end
+      end
+
+      context "when only some things match" do
+        context "with a block" do
+          let(:result) { set.send(method) { |item| item == "A" }}
+
+          it "preserves the original" do
+            result
+            set.should eql(Hamster.set("A", "B", "C"))
+          end
+
+          it "returns a set with the matching values" do
+            result.should eql(Hamster.set("A"))
+          end
+        end
+
+        context "with no block" do
+          it "returns an Enumerator" do
+            set.send(method).class.should be(Enumerator)
+            set.send(method).each { |item| item == "A" }.should eql(Hamster.set("A"))
+          end
+        end
+      end
+
+      context "when nothing matches" do
+        let(:result) { set.send(method) { |item| false }}
+
+        it "preserves the original" do
+          result
+          set.should eql(Hamster.set("A", "B", "C"))
+        end
+
+        it "returns the canonical empty set" do
+          result.should equal(Hamster::EmptySet)
+        end
+      end
+
+      context "from a subclass" do
+        it "returns an instance of the same class" do
+          subclass = Class.new(Hamster::Set)
+          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)
+        end
+      end
+
+      it "works on a large set, with many combinations of input" do
+        items = (1..1000).to_a
+        original = Hamster::Set.new(items)
+        30.times do
+          threshold = rand(1000)
+          result    = original.send(method) { |item| item <= threshold }
+          result.size.should == threshold
+          result.each { |item| item.should <= threshold }
+          (threshold+1).upto(1000) { |item| result.include?(item).should == false }
+        end
+        original.should eql(Hamster::Set.new(items))
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster do
+  describe "#flatten" 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]],
+    ].each do |values, expected|
+      describe "on #{values}" do
+        let(:set) { Hamster.set(*values) }
+
+        it "preserves the original" do
+          set.flatten
+          set.should eql(Hamster.set(*values))
+        end
+
+        it "returns the inlined values" do
+          set.flatten.should eql(Hamster.set(*expected))
+        end
+      end
+    end
+
+    context "on an empty set" do
+      it "returns an empty set" do
+        Hamster.set.flatten.should equal(Hamster.set)
+      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))
+      end
+    end
+
+    context "from a subclass" 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)
+      end
+    end
+  end
+end

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

@@ -11,16 +11,17 @@ describe Hamster::Set do
     context "without a block" do
       let(:block) { nil }
 
-      it "returns self" do
-        expect(foreach).to eq(set)
+      it "returns an Enumerator" do
+        expect(foreach.class).to be(Enumerator)
+        expect(foreach.to_a).to eq(set.to_a)
       end
     end
 
     context "with an empty block" do
       let(:block) { ->(item) {} }
 
-      it "returns nil" do
-        expect(foreach).to be(nil)
+      it "returns self" do
+        expect(foreach).to be(set)
       end
     end
 

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

@@ -50,7 +50,7 @@ describe Hamster::Set do
     end
 
     describe "with a block" do
-      let(:block) { ->(item) { item.downcase } }
+      let(:block) { ->(item) { item.downcase }}
 
       include_examples "check different types of inputs"
     end

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

@@ -0,0 +1,60 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:group_by, :group, :classify].each do |method|
+    describe "##{method}" 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)]],
+        ].each do |values, expected|
+          context "on #{values.inspect}" do
+            let(:set) { Hamster.set(*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
+            end
+          end
+        end
+      end
+
+      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)]],
+        ].each do |values, expected|
+          context "on #{values.inspect}" do
+            let(:set) { Hamster.set(*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
+            end
+          end
+        end
+      end
+
+      context "on an empty set" do
+        it "returns an empty hash" do
+          Hamster.set.group_by { |x| x }.should eql(Hamster.hash)
+        end
+      end
+
+      it "returns a hash without default proc" do
+        Hamster.set(1,2,3).group_by { |x| x }.default_proc.should be_nil
+      end
+
+      context "from a subclass" do
+        it "returns an Hash whose values are instances of the subclass" do
+          subclass = Class.new(Hamster::Set)
+          instance = subclass.new([1, 'string', :symbol])
+          instance.group_by { |x| x.class }.values.each { |v| v.class.should be(subclass) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#hash" do
+    context "on an empty set" do
+      it "returns 0" do
+        Hamster.set.hash.should == 0
+      end
+    end
+
+    it "generates the same hash value for a set regardless of the order things were added to it" 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
+    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
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:head, :first].each do |method|
+    describe "##{method}" do
+      context "on an empty set" do
+        it "returns nil" do
+          Hamster.set.send(method).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?(Hamster.set("A", "B", "C").send(method)).should == true
+        end
+      end
+
+      it "returns nil if only member of set is nil" do
+        Hamster.set(nil).send(method).should be(nil)
+      end
+
+      it "returns the first item yielded by #each" do
+        10.times do
+          set = Hamster::Set.new((rand(10)+1).times.collect { rand(10000 )})
+          set.each { |item| break item }.should be(set.send(method))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require "spec_helper"
+require "hamster/set"
+require 'set'
+
+describe Hamster::Set do
+  [:include?, :member?, :contains?, :elem?].each do |method|
+    describe "##{method}" do
+      let(:set) { Hamster.set("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
+          set.send(method, value).should == true
+        end
+      end
+
+      it "returns false for a non-existing value" do
+        set.send(method, "D").should == false
+      end
+
+      it "returns true even if existing value is nil" do
+        Hamster.set(nil).include?(nil).should == true
+      end
+
+      it "returns true even if existing value is false" do
+        Hamster.set(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.push('HOSED!')
+        set.include?(item).should == false
+      end
+
+      it "uses #eql? for equality" do
+        set.send(method, 2).should == false
+      end
+
+      it "returns the right answers after a lot of addings and removings" do
+        array, set, rb_set = [], Hamster::Set.new, Set.new
+
+        1000.times do
+          if rand(1) == 0
+            array << (item = rand(10000))
+            rb_set.add(item)
+            set = set.add(item)
+            set.include?(item).should == true
+          else
+            item = array.sample
+            rb_set.delete(item)
+            set = set.delete(item)
+            set.include?(item).should == false
+          end
+        end
+
+        array.each { |item| set.include?(item).should == rb_set.include?(item) }
+      end
+    end
+  end
+end