hamster 0.4.3 → 1.0.0

data/spec/lib/hamster/deque/pretty_print_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "hamster/deque"
+require "pp"
+require "stringio"
+
+describe Hamster::Deque do
+  describe "#pretty_print" do
+    let(:deque) { Hamster::Deque["AAAA", "BBBB", "CCCC"] }
+    let(:stringio) { StringIO.new }
+
+    it "prints the whole Deque on one line if it fits" do
+      PP.pp(deque, stringio, 80)
+      stringio.string.chomp.should == 'Hamster::Deque["AAAA", "BBBB", "CCCC"]'
+    end
+
+    it "prints each item on its own line, if not" do
+      PP.pp(deque, stringio, 10)
+      stringio.string.chomp.should == 'Hamster::Deque[
+ "AAAA",
+ "BBBB",
+ "CCCC"]'
+    end
+  end
+end

data/spec/lib/hamster/deque/random_modification_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "modification (using #push, #pop, #shift, and #unshift)" do
+    it "works when applied in many random combinations" do
+      array = [1,2,3]
+      deque = Hamster::Deque.new(array)
+      1000.times do
+        case [:push, :pop, :shift, :unshift].sample
+        when :push
+          value = rand(10000)
+          array.push(value)
+          deque = deque.push(value)
+        when :pop
+          array.pop
+          deque = deque.pop
+        when :shift
+          array.shift
+          deque = deque.shift
+        when :unshift
+          value = rand(10000)
+          array.unshift(value)
+          deque = deque.unshift(value)
+        end
+
+        deque.to_a.should eql(array)
+        deque.size.should == array.size
+        deque.first.should == array.first
+        deque.last.should == array.last
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/size_spec.rb

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

data/spec/lib/hamster/deque/to_a_spec.rb

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

data/spec/lib/hamster/deque/to_ary_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  let(:deque) { Hamster.deque("A", "B", "C", "D") }
+
+  describe "#to_ary" do
+    context "enables implicit conversion to" do
+      it "block parameters" do
+        def func(&block)
+          yield(deque)
+        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(*deque)
+      end
+
+      it "works with splat" do
+        array = *deque
+        expect(array).to eq(%w[A B C D])
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/to_list_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "hamster/deque"
+require "hamster/list"
+
+describe Hamster::Deque do
+  describe "#to_list" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      context "on #{values.inspect}" do
+        it "returns a list containing #{values.inspect}" do
+          Hamster.deque(*values).to_list.should eql(Hamster.list(*values))
+        end
+      end
+    end
+
+    context "after dedequeing an item from #{%w[A B C].inspect}" do
+      it "returns a list containing #{%w[B C].inspect}" do
+        list = Hamster.deque("A", "B", "C").dequeue.to_list
+        list.should eql(Hamster.list("B", "C"))
+      end
+    end
+  end
+end

data/spec/lib/hamster/deque/unshift_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "hamster/deque"
+
+describe Hamster::Deque do
+  describe "#unshift" do
+    [
+      [[], "A", ["A"]],
+      [["A"], "B", %w[B A]],
+      [["A"], "A", %w[A A]],
+      [%w[A B C], "D", %w[D A B C]],
+    ].each do |values, new_value, expected|
+      context "on #{values.inspect} with #{new_value.inspect}" do
+        let(:deque) { Hamster.deque(*values) }
+
+        it "preserves the original" do
+          deque.unshift(new_value)
+          deque.should eql(Hamster.deque(*values))
+        end
+
+        it "returns #{expected.inspect}" do
+          deque.unshift(new_value).should eql(Hamster.deque(*expected))
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/experimental/mutable_set/add_qm_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+require "hamster/experimental/mutable_set"
+
+describe Hamster::MutableSet do
+  let(:mutable) { Hamster.mutable_set(*values) }
+
+  describe "#add?" do
+    let(:values) { %w[A B C] }
+    let(:add?) { mutable.add?(value) }
+
+    context "with a unique value" do
+      let(:value) { "D" }
+
+      it "returns true" do
+        expect(add?).to be true
+      end
+
+      it "modifies the set to include the new value" do
+        add?
+        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C", "D"))
+      end
+
+    end
+
+    context "with a duplicate value" do
+      let(:value) { "C" }
+
+      it "returns false" do
+        expect(add?).to be(false)
+      end
+
+      it "preserves the original values" do
+        add?
+        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C"))
+      end
+    end
+  end
+end

data/spec/lib/hamster/experimental/mutable_set/add_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "hamster/experimental/mutable_set"
+
+describe Hamster::MutableSet do
+  let(:mutable) { Hamster.mutable_set(*values) }
+
+  describe "#add" do
+    let(:values) { %w[A B C] }
+    let(:add) { mutable.add(value) }
+
+    context "with a unique value" do
+      let(:value) { "D" }
+
+      it "returns self" do
+        expect(add).to eq(mutable)
+      end
+
+      it "modifies the original set to include new value" do
+        add
+        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C", "D"))
+      end
+    end
+
+    context "with a duplicate value" do
+      let(:value) { "C" }
+
+      it "returns self" do
+        expect(add).to eq(mutable)
+      end
+
+      it "preserves the original values" do
+        add
+        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C"))
+      end
+    end
+  end
+end

data/spec/lib/hamster/experimental/mutable_set/delete_qm_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+require "hamster/experimental/mutable_set"
+
+describe Hamster::MutableSet do
+  let(:mutable) { Hamster.mutable_set(*values) }
+
+  describe "#delete?" do
+    let(:values) { %w[A B C] }
+    let(:delete?) { mutable.delete?(value) }
+
+
+    context "with an existing value" do
+      let(:value) { "B" }
+
+      it "returns true" do
+        expect(delete?).to be(true)
+      end
+
+      it "modifies the set to remove the value" do
+        delete?
+        expect(mutable).to eq(Hamster.mutable_set("A", "C"))
+      end
+    end
+
+    context "with a non-existing value" do
+      let(:value) { "D" }
+
+      it "returns false" do
+        expect(delete?).to be(false)
+      end
+
+      it "preserves the original values" do
+        delete?
+        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C"))
+      end
+    end
+  end
+end

data/spec/lib/hamster/experimental/mutable_set/delete_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "hamster/experimental/mutable_set"
+
+describe Hamster::MutableSet do
+  let(:mutable) { Hamster.mutable_set(*values) }
+
+  describe "#delete" do
+    let(:values) { %w[A B C] }
+    let(:delete) { mutable.delete(value) }
+
+    context "with an existing value" do
+      let(:value) { "B" }
+
+      it "returns self" do
+        expect(delete).to eq(mutable)
+      end
+
+      it "modifies the set to remove the value" do
+        delete
+        expect(mutable).to eq(Hamster.mutable_set("A", "C"))
+      end
+    end
+
+    context "with a non-existing value" do
+      let(:value) { "D" }
+
+      it "returns self" do
+        expect(delete).to eq(mutable)
+      end
+
+      it "preserves the original values" do
+        delete
+        expect(mutable).to eq(Hamster.mutable_set("A", "B", "C"))
+      end
+    end
+  end
+end

data/spec/lib/hamster/hash/all_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  let(:hash) { Hamster.hash(values) }
+
+  describe "#all?" do
+    context "when empty" do
+      let(:values) { Hash.new }
+
+      context "without a block" do
+        it "returns true" do
+          hash.all?.should == true
+        end
+      end
+
+      context "with a block" do
+        it "returns true" do
+          hash.all? { false }.should == true
+        end
+      end
+    end
+
+    context "when not empty" do
+      let(:values) { { "A" => 1, "B" => 2, "C" => 3 } }
+
+      context "without a block" do
+        it "returns true" do
+          hash.all?.should == true
+        end
+      end
+
+      context "with a block" do
+        it "returns true if the block always returns true" do
+          hash.all? { true }.should == true
+        end
+
+        it "returns false if the block ever returns false" do
+          hash.all? { |k,v| k != 'C' }.should == false
+        end
+
+        it "propagates an exception from the block" do
+          -> { hash.all? { |k,v| raise "help" } }.should raise_error(RuntimeError)
+        end
+
+        it "stops iterating as soon as the block returns false" do
+          yielded = []
+          hash.all? { |k,v| yielded << k; false }
+          yielded.size.should == 1
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/hash/any_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+require "hamster/hash"
+
+describe Hamster::Hash do
+  describe "#any?" do
+    context "when empty" do
+      it "with a block returns false" do
+        Hamster.hash.any? {}.should == false
+      end
+
+      it "with no block returns false" do
+        Hamster.hash.any?.should == false
+      end
+    end
+
+    context "when not empty" do
+      let(:hash) { Hamster.hash("A" => "aye", "B" => "bee", "C" => "see", nil => "NIL") }
+
+      context "with a block" do
+        [
+          %w[A aye],
+          %w[B bee],
+          %w[C see],
+          [nil, "NIL"],
+        ].each do |pair|
+
+          it "returns true if the block ever returns true (#{pair.inspect})" do
+            hash.any? { |key, value| key == pair.first && value == pair.last }.should == true
+          end
+
+          it "returns false if the block always returns false" do
+            hash.any? { |key, value| key == "D" && value == "dee" }.should == false
+          end
+        end
+
+        it "propagates exceptions raised in the block" do
+          -> { hash.any? { |k,v| raise "help" } }.should raise_error(RuntimeError)
+        end
+
+        it "stops iterating as soon as the block returns true" do
+          yielded = []
+          hash.any? { |k,v| yielded << k; true }
+          yielded.size.should == 1
+        end
+      end
+
+      context "with no block" do
+        it "returns true" do
+          hash.any?.should == true
+        end
+      end
+    end
+  end
+end