hamster 0.4.3 → 1.0.0

data/spec/lib/hamster/immutable/new_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "hamster/immutable"
+
+describe Hamster::Immutable do
+  class NewPerson < Struct.new(:first, :last)
+    include Hamster::Immutable
+  end
+
+  let(:immutable) { NewPerson.new("Simon", "Harris") }
+
+  it "freezes the instance" do
+    expect(immutable).to be_frozen
+  end
+end

data/spec/lib/hamster/immutable/transform_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "hamster/immutable"
+
+describe Hamster::Immutable do
+  class TransformPerson < Struct.new(:first, :last)
+    include Hamster::Immutable
+
+    public :transform
+  end
+
+  let(:immutable) { TransformPerson.new("Simon", "Harris") }
+
+  describe "#transform" do
+    let(:transform) { immutable.transform { self.first = "Sampy" } }
+    let(:original) { immutable.first }
+    let(:modified) { transform.first }
+
+    it "preserves the original" do
+      expect(original).to eq("Simon")
+    end
+
+    it "returns a new instance with the updated values" do
+      expect(modified).to eq("Sampy")
+    end
+  end
+end

data/spec/lib/hamster/immutable/transform_unless_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "hamster/immutable"
+
+describe Hamster::Immutable do
+  class TransformUnlessPerson < Struct.new(:first, :last)
+    include Hamster::Immutable
+
+    public :transform_unless
+  end
+
+  let(:immutable) { TransformUnlessPerson.new("Simon", "Harris") }
+
+  describe "#transform_unless" do
+    let(:transform_unless) { immutable.transform_unless(condition, &block) }
+    let(:original) { immutable.first }
+    let(:modified) { transform_unless.first }
+
+    context "when the condition is false" do
+      let(:condition) { false }
+      let(:block) { ->(thing) { self.first = "Sampy" } }
+
+      it "preserves the original" do
+        expect(original).to eq("Simon")
+      end
+
+      it "returns a new instance with the updated values" do
+        expect(modified).to eq("Sampy")
+      end
+    end
+
+    context "when the condition is true" do
+      let(:condition) { true }
+      let(:block) { -> { fail("Should never be called") } }
+
+      it "preserves the original" do
+        expect(original).to eq("Simon")
+      end
+
+      it "returns the original" do
+        expect(original).to eq(modified)
+      end
+    end
+  end
+end

data/spec/lib/hamster/list/add_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#add" 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(:list) { Hamster.list(*values) }
+
+        it "preserves the original" do
+          list.add(new_value)
+          list.should eql(Hamster.list(*values))
+        end
+
+        it "returns #{expected.inspect}" do
+          list.add(new_value).should eql(Hamster.list(*expected))
+        end
+      end
+    end
+  end
+end

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

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

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

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

data/spec/lib/hamster/list/append_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  [:append, :concat, :+].each do |method|
+    describe "##{method}" do
+      it "is lazy" do
+        -> { Hamster.stream { fail }.append(Hamster.stream { fail }) }.should_not raise_error
+      end
+
+      [
+        [[], [], []],
+        [["A"], [], ["A"]],
+        [[], ["A"], ["A"]],
+        [%w[A B], %w[C D], %w[A B C D]],
+      ].each do |left_values, right_values, expected|
+        context "on #{left_values.inspect} and #{right_values.inspect}" do
+          let(:left) { Hamster.list(*left_values) }
+          let(:right) { Hamster.list(*right_values) }
+          let(:result) { left.append(right) }
+
+          it "preserves the left" do
+            result
+            left.should eql(Hamster.list(*left_values))
+          end
+
+          it "preserves the right" do
+            result
+            right.should eql(Hamster.list(*right_values))
+          end
+
+          it "returns #{expected.inspect}" do
+            result.should eql(Hamster.list(*expected))
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/list/at_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#at" do
+    context "on a really big list" do
+      let(:list) { Hamster.interval(0, STACK_OVERFLOW_DEPTH) }
+
+      it "doesn't run out of stack" do
+        -> { list.at(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"],
+      [%w[A B C], -1, "C"],
+      [%w[A B C], -2, "B"],
+      [%w[A B C], -4, nil]
+    ].each do |values, number, expected|
+      describe "#{values.inspect} with #{number}" do
+        it "returns #{expected.inspect}" do
+          Hamster.list(*values).at(number).should == expected
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/list/break_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#break" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.break { |item| false } }.should_not raise_error
+    end
+
+    [
+      [[], [], []],
+      [[1], [1], []],
+      [[1, 2], [1, 2], []],
+      [[1, 2, 3], [1, 2], [3]],
+      [[1, 2, 3, 4], [1, 2], [3, 4]],
+      [[2, 3, 4], [2], [3, 4]],
+      [[3, 4], [], [3, 4]],
+      [[4], [], [4]],
+    ].each do |values, expected_prefix, expected_remainder|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        context "with a block" do
+          let(:result) { list.break { |item| item > 2 }}
+          let(:prefix) { result.first }
+          let(:remainder) { result.last }
+
+          it "preserves the original" do
+            result
+            list.should eql(Hamster.list(*values))
+          end
+
+          it "returns a frozen array with two items" do
+            result.class.should be(Array)
+            result.should be_frozen
+            result.size.should be(2)
+          end
+
+          it "correctly identifies the prefix" do
+            prefix.should eql(Hamster.list(*expected_prefix))
+          end
+
+          it "correctly identifies the remainder" do
+            remainder.should eql(Hamster.list(*expected_remainder))
+          end
+        end
+
+        context "without a block" do
+          let(:result) { list.break }
+          let(:prefix) { result.first }
+          let(:remainder) { result.last }
+
+          it "returns a frozen array with two items" do
+            result.class.should be(Array)
+            result.should be_frozen
+            result.size.should be(2)
+          end
+
+          it "returns self as the prefix" do
+            prefix.should equal(list)
+          end
+
+          it "leaves the remainder empty" do
+            remainder.should be_empty
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/list/cadr_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  [
+    [[], :car, nil],
+    [["A"], :car, "A"],
+    [%w[A B C], :car, "A"],
+    [%w[A B C], :cadr, "B"],
+    [%w[A B C], :caddr, "C"],
+    [%w[A B C], :cadddr, nil],
+    [%w[A B C], :caddddr, nil],
+    [[], :cdr, Hamster.list],
+    [["A"], :cdr, Hamster.list],
+    [%w[A B C], :cdr, Hamster.list("B", "C")],
+    [%w[A B C], :cddr, Hamster.list("C")],
+    [%w[A B C], :cdddr, Hamster.list],
+    [%w[A B C], :cddddr, Hamster.list],
+  ].each do |values, method, expected|
+    describe "##{method}" do
+      it "is responded to" do
+        Hamster.list.respond_to?(method).should == true
+      end
+
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        it "preserves the original" do
+          list.send(method)
+          list.should eql(Hamster.list(*values))
+        end
+
+        it "returns #{expected.inspect}" do
+          list.send(method).should == expected
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/list/chunk_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#chunk" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.chunk(2) }.should_not raise_error
+    end
+
+    [
+      [[], []],
+      [["A"], [Hamster.list("A")]],
+      [%w[A B C], [Hamster.list("A", "B"), Hamster.list("C")]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        it "preserves the original" do
+          list.chunk(2)
+          list.should eql(Hamster.list(*values))
+        end
+
+        it "returns #{expected.inspect}" do
+          list.chunk(2).should eql(Hamster.list(*expected))
+        end
+      end
+    end
+  end
+end

data/spec/lib/hamster/list/clear_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#clear" do
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      describe "on #{values}" do
+        let(:list) { Hamster.list(*values) }
+
+        it "preserves the original" do
+          list.clear
+          list.should eql(Hamster.list(*values))
+        end
+
+        it "returns an empty list" do
+          list.clear.should equal(Hamster.list)
+        end
+      end
+    end
+  end
+end