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

data/spec/hamster/set/include_spec.rb

@@ -1,27 +0,0 @@
-require "spec_helper"
-require "hamster/set"
-
-describe Hamster::Set do
-  [:include?, :member?, :contains?, :elem?].each do |method|
-    describe "##{method}" do
-      before do
-        @set = Hamster.set("A", "B", "C", 2.0, nil)
-      end
-
-      ["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 "uses #eql? for equality" do
-        @set.send(method, 2).should == false
-      end
-    end
-  end
-end

data/spec/hamster/set/inspect_spec.rb

@@ -1,24 +0,0 @@
-require "spec_helper"
-require "hamster/set"
-
-describe Hamster::Set do
-  describe "#inspect" do
-    [
-      [[], "{}"],
-      [["A"], "{\"A\"}"],
-      [[DeterministicHash.new("A", 1), DeterministicHash.new("B", 2), DeterministicHash.new("C", 3)], "{\"A\", \"B\", \"C\"}"]
-    ].each do |values, expected|
-
-      describe "on #{values.inspect}" do
-        before do
-          original = Hamster.set(*values)
-          @result = original.inspect
-        end
-
-        it "returns #{expected.inspect}" do
-          @result.should == expected
-        end
-      end
-    end
-  end
-end

data/spec/hamster/set/intersection_spec.rb

@@ -1,36 +0,0 @@
-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|
-
-        describe "returns #{expected.inspect}" do
-          before do
-            @a = Hamster.set(*a)
-            @b = Hamster.set(*b)
-          end
-
-          it "for #{a.inspect} and #{b.inspect}"  do
-            @result = @a.send(method, @b)
-          end
-
-          it "for #{b.inspect} and #{a.inspect}"  do
-            @result = @b.send(method, @a)
-          end
-
-          after  do
-            @result.should == Hamster.set(*expected)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/set/map_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-require "hamster/set"
-
-describe Hamster::Set do
-  [:map, :collect].each do |method|
-    describe "##{method}" do
-      describe "when empty" do
-        before do
-          @original = Hamster.set
-          @mapped = @original.send(method) {}
-        end
-
-        it "returns self" do
-          @mapped.should equal(@original)
-        end
-      end
-
-      describe "when not empty" do
-        before do
-          @original = Hamster.set("A", "B", "C")
-        end
-
-        describe "with a block" do
-          before do
-            @mapped = @original.send(method, &:downcase)
-          end
-
-          it "preserves the original values" do
-            @original.should == Hamster.set("A", "B", "C")
-          end
-
-          it "returns a new set with the mapped values" do
-            @mapped.should == Hamster.set("a", "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/hamster/set/new_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-require "hamster/set"
-
-describe Hamster::Set do
-  describe "new" do
-    describe "from a subclass" do
-      before do
-        @subclass = Class.new(Hamster::Set)
-        @instance = @subclass.new("some", "values")
-      end
-
-      it "should return an instance of the subclass" do
-        @instance.class.should be @subclass
-      end
-
-      it "should return a frozen instance" do
-        @instance.frozen?.should be true
-      end
-    end
-  end
-end

data/spec/hamster/set/partition_spec.rb

@@ -1,59 +0,0 @@
-require "spec_helper"
-require "hamster/tuple"
-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|
-
-      describe "on #{values.inspect}" do
-        before do
-          @original = Hamster.set(*values)
-        end
-
-        describe "with a block" do
-          before do
-            @result = @original.partition(&:odd?)
-            @matches = @result.first
-            @remainder = @result.last
-          end
-
-          it "preserves the original" do
-            @original.should == Hamster.set(*values)
-          end
-
-          it "returns a tuple with two items" do
-            @result.is_a?(Hamster::Tuple).should == true
-          end
-
-          it "correctly identifies the matches" do
-            @matches.should == Hamster.set(*expected_matches)
-          end
-
-          it "correctly identifies the remainder" do
-            @remainder.should == Hamster.set(*expected_remainder)
-          end
-        end
-
-        describe "without a block" do
-          before do
-            @result = @original.partition
-          end
-
-          it "returns self" do
-            @result.should equal(@original)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/set/reduce_spec.rb

@@ -1,62 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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/hamster/set/subset_spec.rb

@@ -1,31 +0,0 @@
-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/hamster/set/superset_spec.rb

@@ -1,31 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

data/spec/hamster/set/union_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-require "hamster/set"
-
-describe Hamster::Set do
-  [:union, :|, :+, :merge].each do |method|
-    describe "##{method}" do
-      [
-        [[], [], []],
-        [["A"], [], ["A"]],
-        [["A"], ["A"], ["A"]],
-        [%w[A B C], [], %w[A B C]],
-      ].each do |a, b, expected|
-
-        describe "returns #{expected.inspect}" do
-          before do
-            @a = Hamster.set(*a)
-            @b = Hamster.set(*b)
-          end
-
-          it "for #{a.inspect} and #{b.inspect}"  do
-            @result = @a.send(method, @b)
-          end
-
-          it "for #{b.inspect} and #{a.inspect}"  do
-            @result = @b.send(method, @a)
-          end
-
-          after  do
-            @result.should == Hamster.set(*expected)
-          end
-        end
-      end
-    end
-  end
-end