hamster 1.0.0 → 1.0.1.pre.rc.1

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

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

data/spec/hamster/set/reduce_spec.rb

@@ -0,0 +1,87 @@
+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
+
+          before do
+            @set = Hamster.set(*values)
+          end
+
+          describe "with an initial value of #{initial}" do
+
+            describe "and a block" do
+
+              it "returns #{expected.inspect}" do
+                @set.send(method, initial) { |memo, item| memo - item }.should == expected
+              end
+
+            end
+
+            describe "and no block" do
+
+              it "returns the memo" do
+                @set.send(method, initial).should == initial
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+
+      [
+        [[], nil],
+        [[1], 1],
+        [[1, 2, 3], 6],
+      ].each do |values, expected|
+
+        describe "on #{values.inspect}" do
+
+          before do
+            @set = Hamster.set(*values)
+          end
+
+          describe "with no initial value" do
+
+            describe "and a block" do
+
+              it "returns #{expected.inspect}" do
+                @set.send(method) { |memo, item| memo + item }.should == expected
+              end
+
+            end
+
+            describe "and no block" do
+
+              it "returns nil" do
+                @set.send(method).should be_nil
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/set/remove_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+require "hamster/set"
+
+describe Hamster::Set do
+
+  [:remove, :reject, :delete_if].each do |method|
+
+    describe "##{method}" do
+
+      before do
+        @original = Hamster.set("A", "B", "C")
+      end
+
+      describe "when nothing matches" do
+
+        before do
+          @result = @original.send(method) { |item| false }
+        end
+
+        it "returns self" do
+          @result.should equal(@original)
+        end
+
+      end
+
+      describe "when only some things match" do
+
+        describe "with a block" do
+
+          before do
+            @result = @original.send(method) { |item| item == "A" }
+          end
+
+          it "preserves the original" do
+            @original.should == Hamster.set("A", "B", "C")
+          end
+
+          it "returns a set with the matching values" do
+            @result.should == Hamster.set("B", "C")
+          end
+
+        end
+
+        describe "with no block" do
+
+          before do
+            @result = @original.send(method)
+          end
+
+          it "returns self" do
+            @result.should equal(@original)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,18 +1,27 @@
 require "spec_helper"
+
 require "hamster/set"
 
 describe Hamster::Set do
+
   [:size, :length].each do |method|
+
     describe "##{method}" do
+
       [
         [[], 0],
         [["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
+
       end
+
     end
+
   end
-end
+
+end

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

@@ -1,4 +1,5 @@
 require "spec_helper"
+
 require "hamster/set"
 
 describe Hamster::Set do
@@ -6,44 +7,41 @@ 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
-          let(:set) { Hamster.set(*values) }
+          before do
+            @original = Hamster.set(*values)
+          end
 
           describe "with a block" do
-            let(:result) { set.send(method, &comparator) }
-
-            it "returns #{expected.inspect}" do
-              result.should eql(Hamster.sorted_set(*expected, &comparator))
-              result.to_a.should == expected
+            before do
+              @result = @original.send(method, &comparator)
             end
 
-            it "doesn't change the original Set" do
-              result
-              set.should eql(Hamster::Set.new(values))
+            it "returns #{expected.inspect}" do
+              @result.should == Hamster.list(*expected)
             end
           end
 
           describe "without a block" do
-            let(:result) { set.send(method) }
-
-            it "returns #{expected.sort.inspect}" do
-              result.should eql(Hamster.sorted_set(*expected))
-              result.to_a.should == expected.sort
+            before do
+              @result = @original.send(method)
             end
 
-            it "doesn't change the original Set" do
-              result
-              set.should eql(Hamster::Set.new(values))
+            it "returns #{expected.sort.inspect}" do
+              @result.should == Hamster.list(*expected.sort)
             end
           end
         end
       end
     end
   end
-end
+end

data/spec/hamster/set/subset_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+require "hamster/set"
+
+describe Hamster::Set do
+
+  describe "#subset?" 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
+
+        before do
+          @result = Hamster.set(*a).subset?(Hamster.set(*b))
+        end
+
+        it "returns #{expected}"  do
+          @result.should == expected
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/{lib/hamster/vector → hamster/set}/sum_spec.rb

@@ -1,18 +1,32 @@
 require "spec_helper"
-require "hamster/vector"
 
-describe Hamster::Vector do
+require "hamster/set"
+
+describe Hamster::Set do
+
   describe "#sum" do
+
     [
       [[], 0],
       [[2], 2],
       [[1, 3, 5, 7, 11], 27],
     ].each do |values, expected|
+
       describe "on #{values.inspect}" do
+
+        before do
+          original = Hamster.set(*values)
+          @result = original.sum
+        end
+
         it "returns #{expected.inspect}" do
-          Hamster.vector(*values).sum.should == expected
+          @result.should == expected
         end
+
       end
+
     end
+
   end
-end
+
+end

data/spec/hamster/set/superset_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+require "hamster/set"
+
+describe Hamster::Set do
+
+  describe "#superset?" 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
+
+        before do
+          @result = Hamster.set(*a).superset?(Hamster.set(*b))
+        end
+
+        it "returns #{expected}"  do
+          @result.should == expected
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/set/to_a_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+require "hamster/set"
+
+describe Hamster::Set do
+
+  [:to_a, :entries].each do |method|
+
+    describe "##{method}" do
+
+      [
+        [],
+        ["A"],
+        %w[A B C],
+      ].each do |values|
+
+        describe "on #{values.inspect}" do
+
+          before do
+            @set = Hamster.set(*values)
+            @result = @set.send(method)
+          end
+
+          it "returns #{values.inspect}" do
+            @result.sort.should == values.sort
+          end
+
+          it "returns a mutable array" do
+            expect(@result.last).to_not eq("The End")
+            @result << "The End"
+            @result.last.should == "The End"
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end