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

data/spec/hamster/hash/map_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:map, :collect].each do |method|
-    describe "##{method}" do
-      describe "when empty" do
-        before do
-          @original = Hamster.hash
-          @mapped = @original.send(method) {}
-        end
-
-        it "returns self" do
-          @mapped.should equal(@original)
-        end
-      end
-
-      describe "when not empty" do
-        before do
-          @original = Hamster.hash("A" => "aye", "B"  => "bee", "C" => "see")
-        end
-
-        describe "with a block" do
-          before do
-            @mapped = @original.send(method) { |key, value| [key.downcase, value.upcase] }
-          end
-
-          it "preserves the original values" do
-            @original.should == Hamster.hash("A" => "aye", "B"  => "bee", "C" => "see")
-          end
-
-          it "returns a new hash with the mapped values" do
-            @mapped.should == Hamster.hash("a" => "AYE", "b"  => "BEE", "c" => "SEE")
-          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/hash/merge_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:merge, :+].each do |method|
-    describe "##{method}" do
-      [
-        [[], [], []],
-        [["A" => "aye"], [], ["A" => "aye"]],
-        [["A" => "aye"], ["A" => "bee"], ["A" => "bee"]],
-        [["A" => "aye"], ["B" => "bee"], ["A" => "aye", "B" => "bee"]],
-      ].each do |a, b, expected|
-
-        describe "for #{a.inspect} and #{b.inspect}" do
-          before do
-            @result = Hamster.hash(*a).send(method, Hamster.hash(*b))
-          end
-
-          it "returns #{expected.inspect} when passed a Hamster::Hash"  do
-            @result.should == Hamster.hash(*expected)
-          end
-
-          it "returns #{expected.inspect} when passed a Ruby Hash" do
-            Hamster.hash(*a).send(method, Hash[*b]).should == Hamster.hash(*expected)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/hash/new_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe "new" do
-    describe "from a subclass" do
-      before do
-        @subclass = Class.new(Hamster::Hash)
-        @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/hash/put_spec.rb

@@ -1,67 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  describe "#put" do
-    before do
-      @original = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-    end
-
-    describe "with a block" do
-      it "passes the value to the block" do
-        @original.put("A") { |value| value.should == "aye" }
-      end
-
-      it "replaces the value with the result of the block" do
-        result = @original.put("A") { |value| "FLIBBLE" }
-        result.get("A").should == "FLIBBLE"
-      end
-
-      it "supports to_proc methods" do
-        result = @original.put("A", &:upcase)
-        result.get("A").should == "AYE"
-      end
-    end
-
-    describe "with a unique key" do
-      before do
-        @result = @original.put("D", "dee")
-      end
-
-      it "preserves the original" do
-        @original.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      it "returns a copy with the superset of key/value pairs" do
-        @result.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", "D" => "dee")
-      end
-    end
-
-    describe "with a duplicate key" do
-      before do
-        @result = @original.put("C", "sea")
-      end
-
-      it "preserves the original" do
-        @original.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      it "returns a copy with the superset of key/value pairs" do
-        @result.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "sea")
-      end
-    end
-
-    context "when a String is inserted as key and then mutated" do
-      before do
-        @string = "a string!"
-        @hash = Hamster.hash(@string => 'a value!')
-        @string.upcase!
-      end
-
-      it "is not affected" do
-        @hash['a string!'].should == 'a value!'
-        @hash['A STRING!'].should be_nil
-      end
-    end
-  end
-end

data/spec/hamster/hash/reduce_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:reduce, :inject, :fold, :foldr].each do |method|
-    describe "##{method}" do
-      describe "when empty" do
-        before do
-          @original = Hamster.hash
-          @result = @original.send(method, "ABC") {}
-        end
-
-        it "returns the memo" do
-          @result.should == "ABC"
-        end
-      end
-
-      describe "when not empty" do
-        before do
-          @original = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-        end
-
-        describe "with a block" do
-          before do
-            @result = @original.send(method, 0) { |memo, key, value| memo + 1 }
-          end
-
-          it "returns the final memo" do
-            @result.should == 3
-          end
-        end
-
-        describe "with no block" do
-          before do
-            @result = @original.send(method, "ABC")
-          end
-
-          it "returns the memo" do
-            @result.should == "ABC"
-          end
-        end
-      end
-
-      context "from a subclass" do
-        it "returns an instance of the subclass" do
-          @subclass = Class.new(Hamster::Set)
-          @instance = @subclass.new(*(1..100).to_a)
-        end
-      end
-    end
-  end
-end

data/spec/hamster/hash/remove_spec.rb

@@ -1,48 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  [:remove, :reject, :delete_if].each do |method|
-    describe "##{method}" do
-      before do
-        @original = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      end
-
-      describe "when nothing matches" do
-        before do
-          @result = @original.send(method) { |key, value| 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) { |key, value| key == "A" && value == "aye" }
-          end
-
-          it "preserves the original" do
-            @original.should == Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-          end
-
-          it "returns a set with the matching values" do
-            @result.should == Hamster.hash("B" => "bee", "C" => "see")
-          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/hash/slice_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-
-describe Hamster::Hash do
-  let(:hash) { described_class.new("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL") }
-
-  describe "#slice" do
-    let(:slice) { hash.slice(*values) }
-
-    context "with all keys present in the Hash" do
-      let(:values) { ["B", nil] }
-
-      it "returns the sliced values" do
-        expect(slice).to eq(described_class.new("B" => "bee", nil => "NIL"))
-      end
-    end
-
-    context "with keys aren't present in the Hash" do
-      let(:values) { ["B", "A", 3] }
-
-      it "returns the sliced values of the matching keys" do
-        expect(slice).to eq(described_class.new("A" => "aye", "B" => "bee"))
-      end
-    end
-  end
-end

data/spec/hamster/hash/values_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-require "hamster/hash"
-require "hamster/set"
-
-describe Hamster::Hash do
-  describe "#values" do
-    before do
-      hash = Hamster.hash("A" => "aye", "B" => "bee", "C" => "see")
-      @result = hash.values
-    end
-
-    it "returns the keys as a list" do
-      @result.should be_a Hamster::List
-      @result.to_a.sort.should == %w(aye bee see)
-    end
-  end
-
-  describe "#values with duplicates" do
-    before do
-      hash = Hamster.hash(:A => 15, :B => 19, :C => 15)
-      @result = hash.values
-    end
-
-    it "returns the keys as a list" do
-      @result.should be_a Hamster::List
-      @result.to_a.sort.should == [15, 15, 19]
-    end
-  end
-end

data/spec/hamster/list/add_spec.rb

@@ -1,11 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  describe "#add" do
-    it "should add an item onto the end of a list" do
-      list = Hamster.list("a", "b")
-      list.add("c").should == Hamster.list("a", "b", "c")
-    end
-  end
-end

data/spec/hamster/list/all_spec.rb

@@ -1,84 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  [:all?, :forall?].each do |method|
-    describe "##{method}" do
-      describe "on a really big list" do
-        before do
-          @list = Hamster.interval(0, STACK_OVERFLOW_DEPTH)
-        end
-
-        it "doesn't run out of stack" do
-          -> { @list.send(method) }.should_not raise_error
-        end
-      end
-
-      describe "when empty" do
-        before do
-          @list = Hamster.list
-        end
-
-        it "with a block returns true" do
-          @list.send(method) {}.should == true
-        end
-
-        it "with no block returns true" do
-          @list.send(method).should == true
-        end
-      end
-
-      describe "when not empty" do
-        describe "with a block" do
-          before do
-            @list = Hamster.list("A", "B", "C")
-          end
-
-          describe "if the block always returns true" do
-            before do
-              @result = @list.send(method) { |item| true }
-            end
-
-            it "returns true" do
-              @result.should == true
-            end
-          end
-
-          describe "if the block ever returns false" do
-            before do
-              @result = @list.send(method) { |item| item == "D" }
-            end
-
-            it "returns false" do
-              @result.should == false
-            end
-          end
-        end
-
-        describe "with no block" do
-          describe "if all values are truthy" do
-            before do
-              @result = Hamster.list(true, "A").send(method)
-            end
-
-            it "returns true" do
-              @result.should == true
-            end
-          end
-
-          [nil, false].each do |value|
-            describe "if any value is #{value.inspect}" do
-              before do
-                @result = Hamster.list(value, true, "A").send(method)
-              end
-
-              it "returns false" do
-                @result.should == false
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/list/at_spec.rb

@@ -1,37 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  [:at, :[]].each do |method|
-    describe "##{method}" do
-      describe "on a really big list" do
-        before do
-          @list = Hamster.interval(0, STACK_OVERFLOW_DEPTH)
-        end
-
-        it "doesn't run out of stack" do
-          -> { @list.send(method, STACK_OVERFLOW_DEPTH) }.should_not raise_error
-        end
-      end
-
-      [
-        [[], 10, nil],
-        [["A"], 10, nil],
-        [%w[A B C], 0, "A"],
-        [%w[A B C], 2, "C"],
-      ].each do |values, number, expected|
-
-        describe "#{values.inspect} with #{number}" do
-          before do
-            @original = Hamster.list(*values)
-            @result = @original.send(method, number)
-          end
-
-          it "returns #{expected.inspect}" do
-            @result.should == expected
-          end
-        end
-      end
-    end
-  end
-end