hamster 1.0.0 → 1.0.1.pre.rc.1

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

@@ -1,37 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  describe "#count" do
-    context "on a really big list" do
-      it "doesn't run out of stack" do
-        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).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|
-      context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
-
-        context "with a block" do
-          it "returns #{expected.inspect}" do
-            list.count(&:odd?).should == expected
-          end
-        end
-
-        context "without a block" do
-          it "returns length" do
-            list.count.should == list.length
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +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
-
-    context "with an empty list" do
-      it "returns an empty list" do
-        Hamster.list.cycle.should be_empty
-      end
-    end
-
-    context "with a non-empty list" do
-      let(:list) { Hamster.list("A", "B", "C") }
-
-      it "preserves the original" do
-        list.cycle
-        list.should == Hamster.list("A", "B", "C")
-      end
-
-      it "infinitely cycles through all values" do
-        list.cycle.take(7).should == Hamster.list("A", "B", "C", "A", "B", "C", "A")
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  describe "#delete_at" do
-    let(:list) { Hamster.list(1,2,3,4,5) }
-
-    it "removes the element at the specified index" do
-      list.delete_at(0).should eql(Hamster.list(2,3,4,5))
-      list.delete_at(2).should eql(Hamster.list(1,2,4,5))
-      list.delete_at(-1).should eql(Hamster.list(1,2,3,4))
-    end
-
-    it "makes no modification if the index is out of range" do
-      list.delete_at(5).should eql(list)
-      list.delete_at(-6).should eql(list)
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  describe "#delete" do
-    it "removes elements that are #== to the argument" do
-      L[1,2,3].delete(1).should eql(L[2,3])
-      L[1,2,3].delete(2).should eql(L[1,3])
-      L[1,2,3].delete(3).should eql(L[1,2])
-      L[1,2,3].delete(0).should eql(L[1,2,3])
-      L['a','b','a','c','a','a','d'].delete('a').should eql(L['b','c','d'])
-
-      L[EqualNotEql.new, EqualNotEql.new].delete(:something).should eql(L[])
-      L[EqlNotEqual.new, EqlNotEqual.new].delete(:something).should_not be_empty
-    end
-  end
-end

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

@@ -1,39 +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|
-      context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
-
-        context "with a block" do
-          it "preserves the original" do
-            list.drop_while { |item| item < "C" }
-            list.should eql(Hamster.list(*values))
-          end
-
-          it "returns #{expected.inspect}" do
-            list.drop_while { |item| item < "C" }.should eql(Hamster.list(*expected))
-          end
-        end
-
-        context "without a block" do
-          it "returns an Enumerator" do
-            list.drop_while.class.should be(Enumerator)
-            list.drop_while.each { false }.should eql(list)
-            list.drop_while.each { true  }.should be_empty
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  [:each_chunk, :each_slice].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).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|
-        context "on #{values.inspect}" do
-          let(:list) { Hamster.list(*values) }
-
-          context "with a block" do
-            it "preserves the original" do
-              list.should eql(Hamster.list(*values))
-            end
-
-            it "iterates over the items in order" do
-              yielded = []
-              list.send(method, 2) { |item| yielded << item }
-              yielded.should eql(expected)
-            end
-
-            it "returns self" do
-              list.send(method, 2) { |item| item }.should be(list)
-            end
-          end
-
-          context "without a block" do
-            it "preserves the original" do
-              list.send(method, 2)
-              list.should eql(Hamster.list(*values))
-            end
-
-            it "returns an Enumerator" do
-              list.send(method, 2).class.should be(Enumerator)
-              list.send(method, 2).to_a.should eql(expected)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  describe "#each" do
-    context "on a really big list" do
-      it "doesn't run out of stack" do
-        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).each { |item| } }.should_not raise_error
-      end
-    end
-
-    [
-      [],
-      ["A"],
-      %w[A B C],
-    ].each do |values|
-      context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
-
-        context "with a block" do
-          it "iterates over the items in order" do
-            yielded = []
-            list.each { |item| yielded << item }
-            yielded.should == values
-          end
-
-          it "returns nil" do
-            list.each { |item| item }.should be_nil
-          end
-        end
-
-        context "without a block" do
-          it "returns an Enumerator" do
-            list.each.class.should be(Enumerator)
-            list.each.to_list.should eql(list)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  describe "#each_with_index" do
-    context "with no block" do
-      let(:list) { Hamster.list("A", "B", "C") }
-
-      it "returns an Enumerator" do
-        list.each_with_index.class.should be(Enumerator)
-        list.each_with_index.to_a.should == [['A', 0], ['B', 1], ['C', 2]]
-      end
-    end
-
-    context "with a block" do
-      let(:list) { Hamster.interval(1, 1025) }
-
-      it "returns self" do
-        list.each_with_index { |item, index| item }.should be(list)
-      end
-
-      it "iterates over the items in order, yielding item and index" do
-        yielded = []
-        list.each_with_index { |item, index| yielded << [item, index] }
-        yielded.should == (1..list.size).zip(0..list.size.pred)
-      end
-    end
-  end
-end

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

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

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

@@ -1,62 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  describe "#eql?" do
-    context "on a really big list" do
-      it "doesn't run out of stack" do
-        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).eql?(Hamster.interval(0, STACK_OVERFLOW_DEPTH)) }.should_not raise_error
-      end
-    end
-  end
-
-  shared_examples 'equal using eql?' do |a, b|
-    specify "#{a.inspect} should eql? #{b.inspect}" do
-      expect(a).to eql b
-    end
-
-    specify "#{a.inspect} should == #{b.inspect}" do
-      expect(a).to eq b
-    end
-  end
-
-  shared_examples 'not equal using eql?' do |a, b|
-    specify "#{a.inspect} should not eql? #{b.inspect}" do
-      expect(a).to_not eql b
-    end
-  end
-
-  shared_examples 'equal using ==' do |a, b|
-    specify "#{a.inspect} should == #{b.inspect}" do
-      expect(a).to eq b
-    end
-  end
-
-  shared_examples 'not equal using ==' do |a, b|
-    specify "#{a.inspect} should not == #{b.inspect}" do
-      expect(a).to_not eq b
-    end
-  end
-
-  include_examples 'equal using =='       , Hamster.list("A", "B", "C"), %w[A B C]
-  include_examples 'not equal using eql?' , Hamster.list("A", "B", "C"), %w[A B C]
-  include_examples 'not equal using =='   , Hamster.list("A", "B", "C"), Object.new
-  include_examples 'not equal using eql?' , Hamster.list("A", "B", "C"), Object.new
-  include_examples 'equal using =='       , Hamster.list, []
-  include_examples 'not equal using eql?' , Hamster.list, []
-
-  include_examples 'equal using eql?'     , Hamster.list, Hamster.list
-  include_examples 'not equal using eql?' , Hamster.list, Hamster.list(nil)
-  include_examples 'not equal using eql?' , Hamster.list("A"), Hamster.list
-  include_examples 'equal using eql?'     , Hamster.list("A"), Hamster.list("A")
-  include_examples 'not equal using eql?' , Hamster.list("A"), Hamster.list("B")
-  include_examples 'not equal using eql?' , Hamster.list(%w[A B]), Hamster.list("A")
-  include_examples 'equal using eql?'     , Hamster.list(*%w[A B C]), Hamster.list(*%w[A B C])
-  include_examples 'not equal using eql?' , Hamster.list(*%w[C A B]), Hamster.list(*%w[A B C])
-
-  include_examples 'equal using =='       , Hamster.list('A'), ['A']
-  include_examples 'equal using =='       , ['A'], Hamster.list('A')
-
-  include_examples 'not equal using eql?' , Hamster.list('A'), ['A']
-  include_examples 'not equal using eql?' , ['A'], Hamster.list('A')
-end

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

@@ -1,50 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  describe "#fill" do
-    let(:list) { Hamster.list(1, 2, 3, 4, 5, 6) }
-
-    it "can replace a range of items at the beginning of a list" do
-      list.fill(:a, 0, 3).should eql(Hamster.list(:a, :a, :a, 4, 5, 6))
-    end
-
-    it "can replace a range of items in the middle of a list" do
-      list.fill(:a, 3, 2).should eql(Hamster.list(1, 2, 3, :a, :a, 6))
-    end
-
-    it "can replace a range of items at the end of a list" do
-      list.fill(:a, 4, 2).should eql(Hamster.list(1, 2, 3, 4, :a, :a))
-    end
-
-    it "can replace all the items in a list" do
-      list.fill(:a, 0, 6).should eql(Hamster.list(:a, :a, :a, :a, :a, :a))
-    end
-
-    it "can fill past the end of the list" do
-      list.fill(:a, 3, 6).should eql(Hamster.list(1, 2, 3, :a, :a, :a, :a, :a, :a))
-    end
-
-    context "with 1 argument" do
-      it "replaces all the items in the list by default" do
-        list.fill(:a).should eql(Hamster.list(:a, :a, :a, :a, :a, :a))
-      end
-    end
-
-    context "with 2 arguments" do
-      it "replaces up to the end of the list by default" do
-        list.fill(:a, 4).should eql(Hamster.list(1, 2, 3, 4, :a, :a))
-      end
-    end
-
-    context "when index and length are 0" do
-      it "leaves the list unmodified" do
-        list.fill(:a, 0, 0).should eql(list)
-      end
-    end
-
-    it "is lazy" do
-      -> { Hamster.stream { fail }.fill(:a, 0, 1) }.should_not raise_error
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  describe "#index" do
-    context "on a really big list" do
-      it "doesn't run out of stack" do
-        -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).index(nil) }.should_not raise_error
-      end
-    end
-
-    [
-      [[], "A", nil],
-      [[], nil, nil],
-      [["A"], "A", 0],
-      [["A"], "B", nil],
-      [["A"], nil, nil],
-      [["A", "B", nil], "A", 0],
-      [["A", "B", nil], "B", 1],
-      [["A", "B", nil], nil, 2],
-      [["A", "B", nil], "C", nil],
-      [[2], 2, 0],
-      [[2], 2.0, 0],
-      [[2.0], 2.0, 0],
-      [[2.0], 2, 0],
-    ].each do |values, item, expected|
-      context "looking for #{item.inspect} in #{values.inspect}" do
-        it "returns #{expected.inspect}" do
-          Hamster.list(*values).index(item).should == expected
-        end
-      end
-    end
-  end
-end