hamster 1.0.0 → 1.0.1.pre.rc.1

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

@@ -1,26 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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/at_spec.rb

@@ -1,30 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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/combination_spec.rb

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

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

@@ -1,31 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster::List do
-  describe "#<=>" do
-    [
-      [[], [1]],
-      [[1], [2]],
-      [[1], [1, 2]],
-      [[2, 3, 4], [3, 4, 5]]
-    ].each do |items1, items2|
-      context "with #{items1} and #{items2}" do
-        it "returns -1" do
-          (Hamster.list(*items1) <=> Hamster.list(*items2)).should be(-1)
-        end
-      end
-
-      context "with #{items2} and #{items1}" do
-        it "returns 1" do
-          (Hamster.list(*items2) <=> Hamster.list(*items1)).should be(1)
-        end
-      end
-
-      context "with #{items1} and #{items1}" do
-        it "returns 0" do
-          (Hamster.list(*items1) <=> Hamster.list(*items1)).should be(0)
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,111 +0,0 @@
-require "spec_helper"
-require "hamster/list"
-
-describe Hamster do
-  describe ".list" do
-    context "with no arguments" do
-      it "always returns the same instance" do
-        Hamster.list.should equal(Hamster.list)
-      end
-
-      it "returns an empty list" do
-        Hamster.list.should be_empty
-      end
-    end
-
-    context "with a number of items" do
-      it "always returns a different instance" do
-        Hamster.list("A", "B", "C").should_not equal(Hamster.list("A", "B", "C"))
-      end
-
-      it "is the same as repeatedly using #cons" do
-        Hamster.list("A", "B", "C").should eql(Hamster.list.cons("C").cons("B").cons("A"))
-      end
-    end
-  end
-
-  describe ".stream" do
-    context "with no block" do
-      it "returns an empty list" do
-        Hamster.stream.should eql(Hamster.list)
-      end
-    end
-
-    context "with a block" do
-      let(:list) { count = 0; Hamster.stream { count += 1 }}
-
-      it "repeatedly calls the block" do
-        list.take(5).should eql(Hamster.list(1, 2, 3, 4, 5))
-      end
-    end
-  end
-
-  describe ".interval" do
-    context "for numbers" do
-      it "is equivalent to a list with explicit values" do
-        Hamster.interval(98, 102).should eql(Hamster.list(98, 99, 100, 101, 102))
-      end
-    end
-
-    context "for strings" do
-      it "is equivalent to a list with explicit values" do
-        Hamster.interval("A", "AA").should eql(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
-
-  describe ".repeat" do
-    it "returns an infinite list with specified value for each element" do
-      Hamster.repeat("A").take(5).should eql(Hamster.list("A", "A", "A", "A", "A"))
-    end
-  end
-
-  describe ".replicate" do
-    it "returns a list with the specified value repeated the specified number of times" do
-      Hamster.replicate(5, "A").should eql(Hamster.list("A", "A", "A", "A", "A"))
-    end
-  end
-
-  describe ".iterate" do
-    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
-      Hamster.iterate(1) { |item| item * 2 }.take(10).should eql(Hamster.list(1, 2, 4, 8, 16, 32, 64, 128, 256, 512))
-    end
-  end
-
-  describe ".enumerate" do
-    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 "returns a list based on the values yielded from the enumerator" do
-      expect(list.take(2)).to eq Hamster.list(1, 2)
-    end
-
-    it "realizes values as they are needed" do
-      # this example shows that Lists are not as lazy as they could be
-      # if Lists were fully lazy, you would have to take(4) to hit the exception
-      expect { list.take(3).to_a }.to raise_exception
-    end
-  end
-
-  describe "[]" do
-    it "takes a variable number of items and returns a list" do
-      list = Hamster::List[1,2,3]
-      list.should be_kind_of(Hamster::List)
-      list.size.should be(3)
-      list.to_a.should == [1,2,3]
-    end
-
-    it "returns an empty list when called without arguments" do
-      Hamster::List[].should be_kind_of(Hamster::List)
-      Hamster::List[].should be_empty
-    end
-  end
-end