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

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

@@ -3,40 +3,34 @@ require "hamster/set"
 
 describe Hamster::Set do
   describe "#one?" do
-    describe "when empty" do
-      before do
-        @set = Hamster.set
-      end
-
+    context "when empty" do
       it "with a block returns false" do
-        @set.one? {}.should == false
+        Hamster.set.one? {}.should == false
       end
 
       it "with no block returns false" do
-        @set.one?.should == false
+        Hamster.set.one?.should == false
       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 false if the block returns true more than once" do
-          @set.one? { |item| true }.should == false
+          set.one? { |item| true }.should == false
         end
 
         it "returns false if the block never returns true" do
-          @set.one? { |item| false }.should == false
+          set.one? { |item| false }.should == false
         end
 
         it "returns true if the block only returns true once" do
-          @set.one? { |item| item == "A" }.should == true
+          set.one? { |item| item == "A" }.should == true
         end
       end
 
-      describe "with no block" do
+      context "with no block" do
         it "returns false if more than one value is truthy" do
           Hamster.set(nil, true, "A").one?.should == false
         end
@@ -44,6 +38,10 @@ describe Hamster::Set do
         it "returns true if only one value is truthy" do
           Hamster.set(nil, true, false).one?.should == true
         end
+
+        it "returns false if no values are truthy" do
+          Hamster.set(nil, false).one?.should == false
+        end
       end
     end
   end

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

@@ -0,0 +1,53 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#partition" do
+    [
+      [[], [], []],
+      [[1], [1], []],
+      [[1, 2], [1], [2]],
+      [[1, 2, 3], [1, 3], [2]],
+      [[1, 2, 3, 4], [1, 3], [2, 4]],
+      [[2, 3, 4], [3], [2, 4]],
+      [[3, 4], [3], [4]],
+      [[4], [], [4]],
+    ].each do |values, expected_matches, expected_remainder|
+      context "on #{values.inspect}" do
+        let(:set) { Hamster.set(*values) }
+
+        context "with a block" do
+          let(:result)  { set.partition(&:odd?) }
+          let(:matches) { result.first }
+          let(:remainder) { result.last }
+
+          it "preserves the original" do
+            result
+            set.should eql(Hamster.set(*values))
+          end
+
+          it "returns a frozen array with two items" do
+            result.class.should be(Array)
+            result.should be_frozen
+            result.size.should be(2)
+          end
+
+          it "correctly identifies the matches" do
+            matches.should eql(Hamster.set(*expected_matches))
+          end
+
+          it "correctly identifies the remainder" do
+            remainder.should eql(Hamster.set(*expected_remainder))
+          end
+        end
+
+        describe "without a block" do
+          it "returns an Enumerator" do
+            set.partition.class.should be(Enumerator)
+            set.partition.each(&:odd?).should eql([Hamster::Set.new(expected_matches), Hamster::Set.new(expected_remainder)])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,15 +8,15 @@ describe Hamster::Set do
       [[2], 2],
       [[1, 3, 5, 7, 11], 1155],
     ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:set) { Hamster.set(*values) }
 
-      describe "on #{values.inspect}" do
-        before do
-          original = Hamster.set(*values)
-          @result = original.product
+        it "returns #{expected.inspect}" do
+          set.product.should == expected
         end
 
-        it "returns #{expected.inspect}" do
-          @result.should == expected
+        it "doesn't change the original Set" do
+          set.should eql(Hamster::Set.new(values))
         end
       end
     end

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

@@ -0,0 +1,56 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:reduce, :inject, :fold, :foldr].each do |method|
+    describe "##{method}" do
+      [
+        [[], 10, 10],
+        [[1], 10, 9],
+        [[1, 2, 3], 10, 4],
+      ].each do |values, initial, expected|
+        describe "on #{values.inspect}" do
+          let(:set) { Hamster.set(*values) }
+
+          context "with an initial value of #{initial}" do
+            context "and a block" do
+              it "returns #{expected.inspect}" do
+                set.send(method, initial) { |memo, item| memo - item }.should == expected
+              end
+            end
+          end
+        end
+      end
+
+      [
+        [[], nil],
+        [[1], 1],
+        [[1, 2, 3], 6],
+      ].each do |values, expected|
+        describe "on #{values.inspect}" do
+          let(:set) { Hamster.set(*values) }
+
+          context "with no initial value" do
+            context "and a block" do
+              it "returns #{expected.inspect}" do
+                set.send(method) { |memo, item| memo + item }.should == expected
+              end
+            end
+          end
+        end
+      end
+
+      describe "with no block and a symbol argument" do
+        it "uses the symbol as the name of a method to reduce with" do
+          Hamster.set(1, 2, 3).reduce(:+).should == 6
+        end
+      end
+
+      describe "with no block and a string argument" do
+        it "uses the string as the name of a method to reduce with" do
+          Hamster.set(1, 2, 3).reduce('+').should == 6
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:remove, :reject, :delete_if].each do |method|
+    describe "##{method}" do
+      let(:set) { Hamster.set("A", "B", "C") }
+
+      context "when nothing matches" do
+        it "returns self" do
+          set.send(method) { |item| false }.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("B", "C"))
+          end
+        end
+
+        context "with no block" do
+          it "returns self" do
+            set.send(method).class.should be(Enumerator)
+            set.send(method).each { |item| item == "A" }.should == Hamster.set("B", "C")
+          end
+        end
+      end
+
+      context "on a large set, with many combinations of input" do
+        it "still works" do
+          array = (1..1000).to_a
+          set   = Hamster::Set.new(array)
+          [0, 10, 100, 200, 500, 800, 900, 999, 1000].each do |threshold|
+            result = set.send(method) { |item| item > threshold }
+            result.size.should == threshold
+            1.upto(threshold)  { |n| result.include?(n).should == true }
+            (threshold+1).upto(1000) { |n| result.include?(n).should == false }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/{hamster/set/each_spec.rb → lib/hamster/set/reverse_each_spec.rb}

@@ -5,22 +5,23 @@ require "hamster/set"
 describe Hamster::Set do
   let(:set) { Hamster.set("A", "B", "C") }
 
-  describe "#each" do
-    let(:each) { set.each(&block) }
+  describe "#reverse_each" do
+    let(:reverse_each) { set.reverse_each(&block) }
 
     context "without a block" do
       let(:block) { nil }
 
-      it "returns self" do
-        expect(each).to eq(set)
+      it "returns an Enumerator" do
+        expect(reverse_each.class).to be(Enumerator)
+        expect(reverse_each.to_a).to eq(set.to_a.reverse)
       end
     end
 
     context "with an empty block" do
       let(:block) { ->(item) {} }
 
-      it "returns nil" do
-        expect(each).to be(nil)
+      it "returns self" do
+        expect(reverse_each).to be(set)
       end
     end
 
@@ -28,7 +29,7 @@ describe Hamster::Set do
       let(:items) { ::Set.new }
       let(:values) { ::Set.new(%w[A B C]) }
       let(:block) { ->(item) { items << item } }
-      before(:each) { each }
+      before(:each) { reverse_each }
 
       it "yields all values" do
         expect(items).to eq(values)

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

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#sample" do
+    let(:set) { Hamster::Set.new(1..10) }
+
+    it "returns a randomly chosen item" do
+      chosen = 100.times.map { set.sample }
+      chosen.each { |item| set.include?(item).should == true }
+      set.each { |item| chosen.include?(item).should == true }
+    end
+  end
+end

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

@@ -9,7 +9,6 @@ describe Hamster::Set do
         [["A"], 1],
         [%w[A B C], 3],
       ].each do |values, result|
-
         it "returns #{result} for #{values.inspect}" do
           Hamster.set(*values).send(method).should == result
         end

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

@@ -6,36 +6,40 @@ describe Hamster::Set do
     [:sort, ->(left, right) { left.length <=> right.length }],
     [:sort_by, ->(item) { item.length }],
   ].each do |method, comparator|
-
     describe "##{method}" do
       [
         [[], []],
         [["A"], ["A"]],
         [%w[Ichi Ni San], %w[Ni San Ichi]],
       ].each do |values, expected|
-
         describe "on #{values.inspect}" do
-          before do
-            @original = Hamster.set(*values)
-          end
+          let(:set) { Hamster.set(*values) }
 
           describe "with a block" do
-            before do
-              @result = @original.send(method, &comparator)
-            end
+            let(:result) { set.send(method, &comparator) }
 
             it "returns #{expected.inspect}" do
-              @result.should == Hamster.list(*expected)
+              result.should eql(Hamster.sorted_set(*expected, &comparator))
+              result.to_a.should == expected
+            end
+
+            it "doesn't change the original Set" do
+              result
+              set.should eql(Hamster::Set.new(values))
             end
           end
 
           describe "without a block" do
-            before do
-              @result = @original.send(method)
-            end
+            let(:result) { set.send(method) }
 
             it "returns #{expected.sort.inspect}" do
-              @result.should == Hamster.list(*expected.sort)
+              result.should eql(Hamster.sorted_set(*expected))
+              result.to_a.should == expected.sort
+            end
+
+            it "doesn't change the original Set" do
+              result
+              set.should eql(Hamster::Set.new(values))
             end
           end
         end

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

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:subset?, :<=].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], true],
+        [["A"], [], false],
+        [[], ["A"], true],
+        [["A"], ["A"], true],
+        [%w[A B C], ["B"], false],
+        [["B"], %w[A B C], true],
+        [%w[A B C], %w[A C], false],
+        [%w[A C], %w[A B C], true],
+        [%w[A B C], %w[A B C], true],
+        [%w[A B C], %w[A B C D], true],
+        [%w[A B C D], %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).send(method, Hamster.set(*b)).should == expected
+          end
+        end
+      end
+    end
+  end
+
+  [:proper_subset?, :<].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], false],
+        [["A"], [], false],
+        [[], ["A"], true],
+        [["A"], ["A"], false],
+        [%w[A B C], ["B"], false],
+        [["B"], %w[A B C], true],
+        [%w[A B C], %w[A C], false],
+        [%w[A C], %w[A B C], true],
+        [%w[A B C], %w[A B C], false],
+        [%w[A B C], %w[A B C D], true],
+        [%w[A B C D], %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).send(method, Hamster.set(*b)).should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  describe "#sum" do
+    [
+      [[], 0],
+      [[2], 2],
+      [[1, 3, 5, 7, 11], 27],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:set) { Hamster.set(*values) }
+
+        it "returns #{expected.inspect}" do
+          set.sum.should == expected
+        end
+
+        it "doesn't change the original Set" do
+          set.should eql(Hamster::Set.new(values))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "hamster/set"
+
+describe Hamster::Set do
+  [:superset?, :>=].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], true],
+        [["A"], [], true],
+        [[], ["A"], false],
+        [["A"], ["A"], true],
+        [%w[A B C], ["B"], true],
+        [["B"], %w[A B C], false],
+        [%w[A B C], %w[A C], true],
+        [%w[A C], %w[A B C], false],
+        [%w[A B C], %w[A B C], true],
+        [%w[A B C], %w[A B C D], false],
+        [%w[A B C D], %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).send(method, Hamster.set(*b)).should == expected
+          end
+        end
+      end
+    end
+  end
+
+  [:proper_superset?, :>].each do |method|
+    describe "##{method}" do
+      [
+        [[], [], false],
+        [["A"], [], true],
+        [[], ["A"], false],
+        [["A"], ["A"], false],
+        [%w[A B C], ["B"], true],
+        [["B"], %w[A B C], false],
+        [%w[A B C], %w[A C], true],
+        [%w[A C], %w[A B C], false],
+        [%w[A B C], %w[A B C], false],
+        [%w[A B C], %w[A B C D], false],
+        [%w[A B C D], %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).send(method, Hamster.set(*b)).should == expected
+          end
+        end
+      end
+    end
+  end
+end