hamster 1.0.0 → 1.0.1.pre.rc.1

data/spec/hamster/stack/pop_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+require "hamster/stack"
+
+describe Hamster::Stack do
+
+  [:pop, :dequeue].each do |method|
+
+    describe "##{method}" do
+
+      [
+        [[], []],
+        [["A"], []],
+        [%w[A B], ["A"]],
+        [%w[A B C], %w[A B]],
+      ].each do |values, expected|
+
+        describe "on #{values.inspect}" do
+
+          before do
+            @original = Hamster.stack(*values)
+            @result = @original.send(method)
+          end
+
+          it "preserves the original" do
+            @original.should == Hamster.stack(*values)
+          end
+
+          it "returns #{expected.inspect}" do
+            @result.should == Hamster.stack(*expected)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/stack/push_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+require "hamster/stack"
+
+describe Hamster::Stack do
+
+  [:push, :<<, :enqueue].each do |method|
+
+    describe "##{method}" do
+
+      [
+        [[], "A", ["A"]],
+        [["A"], "B", %w[A B]],
+        [["A"], "A", %w[A A]],
+        [%w[A B C], "D", %w[A B C D]],
+      ].each do |values, new_value, expected|
+
+        describe "on #{values.inspect} with #{new_value.inspect}" do
+
+          before do
+            @original = Hamster.stack(*values)
+            @result = @original.send(method, new_value)
+          end
+
+          it "preserves the original" do
+            @original.should == Hamster.stack(*values)
+          end
+
+          it "returns #{expected.inspect}" do
+            @result.should == Hamster.stack(*expected)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/stack/size_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+require "hamster/stack"
+
+describe Hamster::Stack do
+
+  [:size, :length].each do |method|
+
+    describe "##{method}" do
+
+      [
+        [[], 0],
+        [["A"], 1],
+        [%w[A B C], 3],
+      ].each do |values, expected|
+
+        describe "on #{values.inspect}" do
+
+          before do
+            @stack = Hamster.stack(*values)
+          end
+
+          it "returns #{expected.inspect}" do
+            @stack.send(method).should == expected
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/stack/to_a_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+require "hamster/stack"
+
+describe Hamster::Stack do
+
+  [:to_a, :entries].each do |method|
+
+    describe "##{method}" do
+
+      [
+        [[], []],
+        [["A"], ["A"]],
+        [%w[A B C], %w[C B A]],
+      ].each do |values, expected|
+
+        describe "on #{values.inspect}" do
+
+          before do
+            @stack = Hamster.stack(*values)
+            @result = @stack.send(method)
+          end
+
+          it "returns #{expected.inspect}" do
+            @result.should == expected
+          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/stack/to_ary.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "hamster/stack"
+
+describe Hamster::Stack do
+  let(:stack) { Hamster.stack("D", "C", "B", "A") }
+
+  describe "#to_ary" do
+    context "enables implicit conversion to" do
+      it "block parameters" do
+        def func(&block)
+          yield(stack)
+        end
+
+        func do |a, b, *c|
+          expect(a).to eq("A")
+          expect(b).to eq("B")
+          expect(c).to eq(%w[C D])
+        end
+      end
+
+      it "method arguments" do
+        def func(a, b, *c)
+          expect(a).to eq("A")
+          expect(b).to eq("B")
+          expect(c).to eq(%w[C D])
+        end
+
+        func(*stack)
+      end
+
+      it "works with splat" do
+        array = *stack
+        expect(array).to eq(%w[A B C D])
+      end
+    end
+  end
+end

data/spec/hamster/stack/to_list_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+require "hamster/stack"
+require "hamster/list"
+
+describe Hamster::Stack do
+
+  describe "#to_list" do
+
+    [
+      [[], []],
+      [["A"], ["A"]],
+      [%w[A B C], %w[C B A]],
+    ].each do |values, expected|
+
+      describe "on #{values.inspect}" do
+
+        before do
+          @stack = Hamster.stack(*values)
+          @result = @stack.to_list
+        end
+
+        it "returns #{expected.inspect}" do
+          @result.should == Hamster.list(*expected)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/trie/remove_spec.rb

@@ -0,0 +1,117 @@
+# require 'spec_helper'
+#
+# describe Hamster::Hash do
+#
+#   describe "#remove" do
+#
+#     describe "the last key" do
+#
+#       before do
+#         @hash = Hamster::Hash.new.put("A", "aye").remove("A")
+#       end
+#
+#       it "no longer provides access to the removed key" do
+#         @hash.key?("A").should == false
+#       end
+#
+#     end
+#
+#     describe "with an existing key" do
+#
+#       before do
+#         @original = Hamster::Hash.new.put("A", "aye").put("B", "bee")
+#         @copy = @original.remove("A")
+#       end
+#
+#       it "returns a modified copy" do
+#         @copy.should_not equal(@original)
+#       end
+#
+#       describe "the original" do
+#
+#         it "still has the original key/value pairs" do
+#           @original.get("A").should == "aye"
+#           @original.get("B").should == "bee"
+#         end
+#
+#         it "still has the original size" do
+#           @original.size.should == 2
+#         end
+#
+#       end
+#
+#       describe "the modified copy" do
+#
+#         it "has all but the removed original key/value pairs" do
+#           @copy.get("B").should == "bee"
+#         end
+#
+#         it "doesn't have the removed key" do
+#           @copy.key?("A").should == false
+#         end
+#
+#         it "has a size one less than the original" do
+#           @copy.size.should == 1
+#         end
+#
+#       end
+#
+#     end
+#
+#     describe "with non-existing keys" do
+#
+#       before do
+#         @original = Hamster::Hash.new.put("A", "aye")
+#         @copy = @original.remove("missing")
+#       end
+#
+#       it "returns self" do
+#         @copy.should equal(@original)
+#       end
+#
+#       describe "the original" do
+#
+#         it "still has the original key/value pairs" do
+#           @original.get("A").should == "aye"
+#         end
+#
+#         it "still has the original size" do
+#           @original.size.should == 1
+#         end
+#
+#       end
+#
+#     end
+#
+#     describe "with keys of the same hash value" do
+#
+#       class Key
+#         def hash; 1; end
+#       end
+#
+#       def instance_count
+#         ObjectSpace.garbage_collect
+#         ObjectSpace.each_object(Hamster::Trie) {}
+#       end
+#
+#       before do
+#         @a = Key.new
+#         @b = Key.new
+#         @original = Hamster::Hash.new.put(@a, "aye").put(@b, "bee")
+#       end
+#
+#       it "no longer provides access to the removed key" do
+#         copy = @original.remove(@b)
+#         copy.key?(@b).should == false
+#       end
+#
+#       it "provides access to the remaining keys" do
+#         copy = @original.remove(@a)
+#         copy.get(@b).should == "bee"
+#       end
+#
+#     end
+#
+#   end
+#
+# end

data/spec/hamster/tuple/copying_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+require "hamster/tuple"
+
+describe Hamster::Tuple do
+
+  [:dup, :clone].each do |method|
+
+    describe "#{method}" do
+
+      before do
+        @original = Hamster::Tuple.new("A", "B")
+        @result = @original.send(method)
+      end
+
+      it "returns self" do
+        @result.should equal(@original)
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/tuple/eql_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+require "hamster/tuple"
+
+describe Hamster::Tuple do
+
+  [:eql?, :==].each do |method|
+
+    describe "##{method}" do
+
+      describe "returns false when comparing with" do
+
+        before do
+          @tuple = Hamster::Tuple.new("A", "B", "C")
+        end
+
+        it "an array with the same values" do
+          @tuple.send(method, %w[A B C]).should == false
+        end
+
+        it "an aribtrary object" do
+          @tuple.send(method, Object.new).should == false
+        end
+
+      end
+
+      [
+        [[], [], true],
+        [[], [nil], false],
+        [["A"], [], false],
+        [["A"], ["A"], true],
+        [["A"], ["B"], false],
+        [%w[A B], ["A"], false],
+        [%w[A B C], %w[A B C], true],
+        [%w[C A B], %w[A B C], false],
+      ].each do |a, b, expected|
+
+        describe "returns #{expected.inspect}" do
+
+          before do
+            @a = Hamster::Tuple.new(*a)
+            @b = Hamster::Tuple.new(*b)
+          end
+
+          it "for #{a.inspect} and #{b.inspect}" do
+            @a.send(method, @b).should == expected
+          end
+
+          it "for #{b.inspect} and #{a.inspect}" do
+            @b.send(method, @a).should == expected
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/hamster/tuple/first_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+require "hamster/tuple"
+
+describe Hamster::Tuple do
+
+  describe "#first" do
+
+    before do
+      @tuple = Hamster::Tuple.new("A", "B")
+    end
+
+    it "returns the first value" do
+      @tuple.first.should == "A"
+    end
+
+  end
+
+end