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

data/spec/hamster/list/break_spec.rb

@@ -1,73 +0,0 @@
-require "spec_helper"
-require "hamster/tuple"
-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|
-
-      describe "on #{values.inspect}" do
-        before do
-          @original = Hamster.list(*values)
-        end
-
-        describe "with a block" do
-          before do
-            @result = @original.break { |item| item > 2 }
-            @prefix = @result.first
-            @remainder = @result.last
-          end
-
-          it "preserves the original" do
-            @original.should == Hamster.list(*values)
-          end
-
-          it "returns a tuple with two items" do
-            @result.is_a?(Hamster::Tuple).should == true
-          end
-
-          it "correctly identifies the prefix" do
-            @prefix.should == Hamster.list(*expected_prefix)
-          end
-
-          it "correctly identifies the remainder" do
-            @remainder.should == Hamster.list(*expected_remainder)
-          end
-        end
-
-        describe "without a block" do
-          before do
-            @result = @original.break
-            @prefix = @result.first
-            @remainder = @result.last
-          end
-
-          it "returns a tuple with two items" do
-            @result.is_a?(Hamster::Tuple).should == true
-          end
-
-          it "returns self as the prefix" do
-            @prefix.should equal(@original)
-          end
-
-          it "leaves the remainder empty" do
-            @remainder.should be_empty
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/list/combinations_spec.rb

@@ -1,41 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  [:combinations, :combination].each do |method|
-    describe "##{method}" do
-      it "is lazy" do
-        -> { Hamster.stream { fail }.combinations(2) }.should_not raise_error
-      end
-
-      [
-        [%w[A B C D], 1, [["A"], ["B"], ["C"], ["D"]]],
-        [%w[A B C D], 2, [%w[A B], %w[A C], %w[A D], %w[B C], %w[B D], %w[C D]]],
-        [%w[A B C D], 3, [%w[A B C], %w[A B D], %w[A C D], %w[B C D]]],
-        [%w[A B C D], 4, [%w[A B C D]]],
-        [%w[A B C D], 0, [[]]],
-        [%w[A B C D], 5, []],
-        [[], 0, [[]]],
-        [[], 1, []],
-      ].each do |values, number, expected|
-
-        expected = expected.map { |x| Hamster.list(*x) }
-
-        describe "on #{values.inspect} in groups of #{number}" do
-          before do
-            @original = Hamster.list(*values)
-            @result = @original.send(method, number)
-          end
-
-          it "preserves the original" do
-            @original.should == Hamster.list(*values)
-          end
-
-          it "returns #{expected.inspect}" do
-            @result.should == Hamster.list(*expected)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/list/construction_spec.rb

@@ -1,137 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster do
-  describe ".list" do
-    describe "with no arguments" do
-      before do
-        @list = Hamster.list
-      end
-
-      it "always returns the same instance" do
-        @list.should equal(Hamster.list)
-      end
-
-      it "returns an empty list" do
-        @list.should be_empty
-      end
-    end
-
-    describe "with a number of items" do
-      before do
-        @list = Hamster.list("A", "B", "C")
-      end
-
-      it "always returns a different instance" do
-        @list.should_not equal(Hamster.list("A", "B", "C"))
-      end
-
-      it "is the same as repeatedly using #cons" do
-        @list.should == Hamster.list.cons("C").cons("B").cons("A")
-      end
-    end
-  end
-
-  describe ".stream" do
-    describe "with no block" do
-      before do
-        @list = Hamster.stream
-      end
-
-      it "returns an empty list" do
-        @list.should == Hamster.list
-      end
-    end
-
-    describe "with a block" do
-      before do
-        count = 0
-        @list = Hamster.stream { count += 1 }
-      end
-
-      it "repeatedly calls the block" do
-        @list.take(5).should == Hamster.list(1, 2, 3, 4, 5)
-      end
-    end
-  end
-
-  [:interval, :range].each do |method|
-    describe ".#{method}" do
-      describe "for numbers" do
-        before do
-          @list = Hamster.send(method, 98, 102)
-        end
-
-        it "is equivalent to a list with explicit values" do
-          @list.should == Hamster.list(98, 99, 100, 101, 102)
-        end
-      end
-
-      describe "for strings" do
-        before do
-          @list = Hamster.send(method, "A", "AA")
-        end
-
-        it "is equivalent to a list with explicit values" do
-          @list.should == Hamster.list("A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA")
-        end
-      end
-    end
-  end
-
-  describe ".repeat" do
-    before do
-      @list = Hamster.repeat("A")
-    end
-
-    it "returns an infinite list with specified value for each element" do
-      @list.take(5).should == Hamster.list("A", "A", "A", "A", "A")
-    end
-  end
-
-  describe ".replicate" do
-    before do
-      @list = Hamster.replicate(5, "A")
-    end
-
-    it "returns a list with the specified value repeated the specified number of times" do
-      @list.should == Hamster.list("A", "A", "A", "A", "A")
-    end
-  end
-
-  describe ".iterate" do
-    before do
-      @list = Hamster.iterate(1) { |item| item * 2 }
-    end
-
-    it "returns an infinite list where the first item is calculated by applying the block on the initial argument, the second item by applying the function on the previous result and so on" do
-      @list.take(10).should == Hamster.list(1, 2, 4, 8, 16, 32, 64, 128, 256, 512)
-    end
-  end
-
-  describe ".enumerate" do
-    let(:counter) do
-      i = 0
-      -> { i += 1 }
-    end
-
-    let(:enum) do
-      Enumerator.new do |yielder|
-        yielder << 1
-        yielder << 2
-        yielder << 3
-        raise "list fully realized"
-      end
-    end
-
-    let(:list) { Hamster.enumerate(enum) }
-
-    it "should return a list based on the values yielded from the enumerator" do
-      expect(list.take(2)).to eq Hamster.list(1, 2)
-    end
-
-    it "should realize values as they are needed" do
-      expect { list.take(3).to_a }.to raise_exception
-    end
-  end
-end

data/spec/hamster/list/count_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  describe "#count" 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.count }.should_not raise_error
-      end
-    end
-
-    [
-      [[], 0],
-      [[1], 1],
-      [[1, 2], 1],
-      [[1, 2, 3], 2],
-      [[1, 2, 3, 4], 2],
-      [[1, 2, 3, 4, 5], 3],
-    ].each do |values, expected|
-
-      describe "on #{values.inspect}" do
-        before do
-          @original = Hamster.list(*values)
-        end
-
-        describe "with a block" do
-          before do
-            @result = @original.count(&:odd?)
-          end
-
-          it "returns #{expected.inspect}" do
-            @result.should == expected
-          end
-        end
-
-        describe "without a block" do
-          before do
-            @result = @original.count
-          end
-
-          it "returns length" do
-            @result.should == @original.length
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hamster/list/cycle_spec.rb

@@ -1,36 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster do
-  describe "#cycle" do
-    it "is lazy" do
-      -> { Hamster.stream { fail }.cycle }.should_not raise_error
-    end
-
-    describe "with an empty list" do
-      before do
-        original = Hamster.list
-        @result = original.cycle
-      end
-
-      it "returns an empty list" do
-        @result.should be_empty
-      end
-    end
-
-    describe "with a non-empty list" do
-      before do
-        @original = Hamster.list("A", "B", "C")
-        @result = @original.cycle
-      end
-
-      it "preserves the original" do
-        @original.should == Hamster.list("A", "B", "C")
-      end
-
-      it "infinitely cycles through all values" do
-        @result.take(7).should == Hamster.list("A", "B", "C", "A", "B", "C", "A")
-      end
-    end
-  end
-end

data/spec/hamster/list/drop_while_spec.rb

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

data/spec/hamster/list/each_slice_spec.rb

@@ -1,64 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  [:each_chunk, :each_slice].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, 1) { |item| } }.should_not raise_error
-        end
-      end
-
-      [
-        [[], []],
-        [["A"], [Hamster.list("A")]],
-        [%w[A B C], [Hamster.list("A", "B"), Hamster.list("C")]],
-      ].each do |values, expected|
-
-        describe "on #{values.inspect}" do
-          before do
-            @original = Hamster.list(*values)
-          end
-
-          describe "with a block" do
-            before do
-              @items = []
-              @result = @original.send(method, 2) { |item| @items << item }
-            end
-
-            it "preserves the original" do
-              @original.should == Hamster.list(*values)
-            end
-
-            it "iterates over the items in order" do
-              @items.should == expected
-            end
-
-            it "returns nil" do
-              @result.should be_nil
-            end
-          end
-
-          describe "without a block" do
-            before do
-              @result = @original.send(method, 2)
-            end
-
-            it "preserves the original" do
-              @original.should == Hamster.list(*values)
-            end
-
-            it "returns the expected items" do
-              @result.should == Hamster.list(*expected)
-            end
-          end
-        end
-      end
-    end
-  end
-end