hamster 0.4.3 → 1.0.0

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

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  [
+    [:sort, ->(left, right) { left.length <=> right.length }],
+    [:sort_by, ->(item) { item.length }],
+  ].each do |method, comparator|
+    describe "##{method}" do
+      it "is lazy" do
+        -> { Hamster.stream { fail }.send(method, &comparator) }.should_not raise_error
+      end
+
+      [
+        [[], []],
+        [["A"], ["A"]],
+        [%w[Ichi Ni San], %w[Ni San Ichi]],
+      ].each do |values, expected|
+        context "on #{values.inspect}" do
+          let(:list) { Hamster.list(*values) }
+
+          context "with a block" do
+            it "preserves the original" do
+              list.send(method, &comparator)
+              list.should == Hamster.list(*values)
+            end
+
+            it "returns #{expected.inspect}" do
+              list.send(method, &comparator).should == Hamster.list(*expected)
+            end
+          end
+
+          context "without a block" do
+            it "preserves the original" do
+              list.send(method)
+              list.should eql(Hamster.list(*values))
+            end
+
+            it "returns #{expected.sort.inspect}" do
+              list.send(method).should == Hamster.list(*expected.sort)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+require "spec_helper"
+require "hamster/list"
+
+describe "Hamster.list#span" do
+  it "is lazy" do
+    -> { Hamster.stream { |item| fail }.span { true } }.should_not raise_error
+  end
+
+  describe <<-DESC do
+given a predicate (in the form of a block), splits the list into two lists
+  (returned as an array) such that elements in the first list (the prefix) are
+  taken from the head of the list while the predicate is satisfied, and elements
+  in the second list (the remainder) are the remaining elements from the list
+  once the predicate is not satisfied. For example:
+DESC
+
+    [
+      [[], [], []],
+      [[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 "given the list #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        context "and a predicate that returns true for values <= 2" do
+          let(:result) { list.span { |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 the prefix as #{expected_prefix.inspect}" do
+            prefix.should eql(Hamster.list(*expected_prefix))
+          end
+
+          it "returns the remainder as #{expected_remainder.inspect}" do
+            remainder.should eql(Hamster.list(*expected_remainder))
+          end
+
+          it "calls the block only once for each element" do
+            count = 0
+            result = list.span { |item| count += 1; item <= 2 }
+            # force realization of lazy lists
+            result.first.size.should == expected_prefix.size
+            result.last.size.should == expected_remainder.size
+            # it may not need to call the block on every element, just up to the
+            # point where the block first returns a false value
+            count.should <= values.size
+          end
+        end
+
+        context "without a predicate" do
+          it "returns a frozen array" do
+            list.span.class.should be(Array)
+            list.span.should be_frozen
+          end
+
+          it "returns self as the prefix" do
+            list.span.first.should equal(list)
+          end
+
+          it "returns an empty list as the remainder" do
+            list.span.last.should be_empty
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#split_at" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.split_at(1) }.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]],
+    ].each do |values, expected_prefix, expected_remainder|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+        let(:result) { list.split_at(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 matches" do
+          prefix.should eql(Hamster.list(*expected_prefix))
+        end
+
+        it "correctly identifies the remainder" do
+          remainder.should eql(Hamster.list(*expected_remainder))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#subsequences" do
+    let(:list) { Hamster.list(1,2,3,4,5) }
+
+    it "yields all sublists with 1 or more consecutive items" do
+      result = []
+      list.subsequences { |l| result << l }
+      result.size.should == (5 + 4 + 3 + 2 + 1)
+      result.sort.should == [[1], [1,2], [1,2,3], [1,2,3,4], [1,2,3,4,5],
+        [2], [2,3], [2,3,4], [2,3,4,5], [3], [3,4], [3,4,5], [4], [4,5], [5]]
+    end
+
+    context "with no block" do
+      it "returns an Enumerator" do
+        list.subsequences.class.should be(Enumerator)
+        list.subsequences.to_a.sort.should == [[1], [1,2], [1,2,3], [1,2,3,4], [1,2,3,4,5],
+        [2], [2,3], [2,3,4], [2,3,4,5], [3], [3,4], [3,4,5], [4], [4,5], [5]]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#sum" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).sum }.should_not raise_error
+      end
+    end
+
+    [
+      [[], 0],
+      [[2], 2],
+      [[1, 3, 5, 7, 11], 27],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          Hamster.list(*values).sum.should == expected
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#tail" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).select(&:nil?).tail }.should_not raise_error
+      end
+    end
+
+    [
+      [[], []],
+      [["A"], []],
+      [%w[A B C], %w[B C]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        it "preserves the original" do
+          list.tail
+          list.should eql(Hamster.list(*values))
+        end
+
+        it "returns #{expected.inspect}" do
+          list.tail.should eql(Hamster.list(*expected))
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#take_while" do
+    it "is lazy" do
+      -> { Hamster.stream { fail }.take_while { false } }.should_not raise_error
+    end
+
+    [
+      [[], []],
+      [["A"], ["A"]],
+      [%w[A B C], %w[A B]],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        let(:list) { Hamster.list(*values) }
+
+        context "with a block" do
+          it "returns #{expected.inspect}" do
+            list.take_while { |item| item < "C" }.should eql(Hamster.list(*expected))
+          end
+
+          it "preserves the original" do
+            list.take_while { |item| item < "C" }
+            list.should eql(Hamster.list(*values))
+          end
+
+          it "is lazy" do
+            count = 0
+            list.take_while do |item|
+              count += 1
+              true
+            end
+            count.should <= 1
+          end
+        end
+
+        context "without a block" do
+          it "returns an Enumerator" do
+            list.take_while.class.should be(Enumerator)
+            list.take_while.each { |item| item < "C" }.should eql(Hamster.list(*expected))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  [:to_a, :entries].each do |method|
+    describe "##{method}" do
+      context "on a really big list" do
+        it "doesn't run out of stack" do
+          -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).to_a }.should_not raise_error
+        end
+      end
+
+      [
+        [],
+        ["A"],
+        %w[A B C],
+      ].each do |values|
+        context "on #{values.inspect}" do
+          let(:list) { Hamster.list(*values) }
+
+          it "returns #{values.inspect}" do
+            list.send(method).should == values
+          end
+
+          it "leaves the original unchanged" do
+            list.send(method)
+            list.should eql(Hamster.list(*values))
+          end
+
+          it "returns a mutable array" do
+            result = list.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/list/to_ary_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  let(:list) { Hamster.list("A", "B", "C", "D") }
+
+  describe "#to_ary" do
+    context "on a really big list" do
+      it "doesn't run out of stack" do
+        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).to_ary }.should_not raise_error
+      end
+    end
+
+    context "enables implicit conversion to" do
+      it "block parameters" do
+        def func(&block)
+          yield(list)
+        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(*list)
+      end
+
+      it "works with splat" do
+        array = *list
+        expect(array).to eq(%w[A B C D])
+      end
+    end
+  end
+end