hamster 1.0.1.pre.rc3 → 2.0.0

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

@@ -19,15 +19,15 @@ describe Hamster::List do
       [[nil, "B", nil], ["B"]],
     ].each do |values, expected|
       context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         it "preserves the original" do
           list.compact
-          list.should eql(Hamster.list(*values))
+          list.should eql(L[*values])
         end
 
         it "returns #{expected.inspect}" do
-          list.compact.should eql(Hamster.list(*expected))
+          list.compact.should eql(L[*expected])
         end
       end
     end

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

@@ -11,19 +11,19 @@ describe Hamster::List do
     ].each do |items1, items2|
       context "with #{items1} and #{items2}" do
         it "returns -1" do
-          (Hamster.list(*items1) <=> Hamster.list(*items2)).should be(-1)
+          (L[*items1] <=> L[*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)
+          (L[*items2] <=> L[*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)
+          (L[*items1] <=> L[*items1]).should be(0)
         end
       end
     end

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

@@ -2,25 +2,23 @@ require "spec_helper"
 require "hamster/list"
 
 describe Hamster::List do
-  [:cons, :>>].each do |method|
-    describe "##{method}" 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) }
+  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) { L[*values] }
 
-          it "preserves the original" do
-            list.send(method, new_value)
-            list.should eql(Hamster.list(*values))
-          end
+        it "preserves the original" do
+          list.cons(new_value)
+          list.should eql(L[*values])
+        end
 
-          it "returns #{expected.inspect}" do
-            list.send(method, new_value).should eql(Hamster.list(*expected))
-          end
+        it "returns #{expected.inspect}" do
+          list.cons(new_value).should eql(L[*expected])
         end
       end
     end

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

@@ -5,21 +5,21 @@ describe Hamster do
   describe ".list" do
     context "with no arguments" do
       it "always returns the same instance" do
-        Hamster.list.should equal(Hamster.list)
+        L.empty.should equal(L.empty)
       end
 
       it "returns an empty list" do
-        Hamster.list.should be_empty
+        L.empty.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"))
+        L["A", "B", "C"].should_not equal(L["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"))
+        L["A", "B", "C"].should eql(L.empty.cons("C").cons("B").cons("A"))
       end
     end
   end
@@ -27,7 +27,7 @@ describe Hamster do
   describe ".stream" do
     context "with no block" do
       it "returns an empty list" do
-        Hamster.stream.should eql(Hamster.list)
+        Hamster.stream.should eql(L.empty)
       end
     end
 
@@ -35,51 +35,44 @@ describe Hamster 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))
+        list.take(5).should eql(L[1, 2, 3, 4, 5])
       end
     end
   end
 
-  [:interval, :range].each do |method|
-    describe ".#{method}" do
-      context "for numbers" do
-        it "is equivalent to a list with explicit values" do
-          Hamster.send(method, 98, 102).should eql(Hamster.list(98, 99, 100, 101, 102))
-        end
+  describe ".interval" do
+    context "for numbers" do
+      it "is equivalent to a list with explicit values" do
+        Hamster.interval(98, 102).should eql(L[98, 99, 100, 101, 102])
       end
+    end
 
-      context "for strings" do
-        it "is equivalent to a list with explicit values" do
-          Hamster.send(method, "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
+    context "for strings" do
+      it "is equivalent to a list with explicit values" do
+        Hamster.interval("A", "AA").should eql(L["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"))
+      Hamster.repeat("A").take(5).should eql(L["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"))
+      Hamster.replicate(5, "A").should eql(L["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))
+      Hamster.iterate(1) { |item| item * 2 }.take(10).should eql(L[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
@@ -92,7 +85,7 @@ describe Hamster do
     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)
+      expect(list.take(2)).to eq L[1, 2]
     end
 
     it "realizes values as they are needed" do
@@ -111,8 +104,8 @@ describe Hamster do
     end
 
     it "returns an empty list when called without arguments" do
-      Hamster::List[].should be_kind_of(Hamster::List)
-      Hamster::List[].should be_empty
+      L[].should be_kind_of(Hamster::List)
+      L[].should be_empty
     end
   end
 end

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

@@ -9,7 +9,7 @@ describe Hamster::List do
       %w[A B C],
     ].each do |values|
       context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         it "returns self" do
           list.send(method).should equal(list)

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

@@ -18,7 +18,7 @@ describe Hamster::List do
       [[1, 2, 3, 4, 5], 3],
     ].each do |values, expected|
       context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         context "with a block" do
           it "returns #{expected.inspect}" do

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

@@ -9,20 +9,20 @@ describe Hamster do
 
     context "with an empty list" do
       it "returns an empty list" do
-        Hamster.list.cycle.should be_empty
+        L.empty.cycle.should be_empty
       end
     end
 
     context "with a non-empty list" do
-      let(:list) { Hamster.list("A", "B", "C") }
+      let(:list) { L["A", "B", "C"] }
 
       it "preserves the original" do
         list.cycle
-        list.should == Hamster.list("A", "B", "C")
+        list.should == L["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")
+        list.cycle.take(7).should == L["A", "B", "C", "A", "B", "C", "A"]
       end
     end
   end

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

@@ -3,12 +3,12 @@ require "hamster/list"
 
 describe Hamster::List do
   describe "#delete_at" do
-    let(:list) { Hamster.list(1,2,3,4,5) }
+    let(:list) { L[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))
+      list.delete_at(0).should eql(L[2,3,4,5])
+      list.delete_at(2).should eql(L[1,2,4,5])
+      list.delete_at(-1).should eql(L[1,2,3,4])
     end
 
     it "makes no modification if the index is out of range" do

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

@@ -15,15 +15,15 @@ describe Hamster::List do
       [%w[A B C], 2, ["C"]],
     ].each do |values, number, expected|
       context "with #{number} from #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         it "preserves the original" do
           list.drop(number)
-          list.should eql(Hamster.list(*values))
+          list.should eql(L[*values])
         end
 
         it "returns #{expected.inspect}" do
-          list.drop(number).should == Hamster.list(*expected)
+          list.drop(number).should == L[*expected]
         end
       end
     end

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

@@ -13,16 +13,16 @@ describe Hamster::List do
       [%w[A B C], ["C"]],
     ].each do |values, expected|
       context "on #{values.inspect}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         context "with a block" do
           it "preserves the original" do
             list.drop_while { |item| item < "C" }
-            list.should eql(Hamster.list(*values))
+            list.should eql(L[*values])
           end
 
           it "returns #{expected.inspect}" do
-            list.drop_while { |item| item < "C" }.should eql(Hamster.list(*expected))
+            list.drop_while { |item| item < "C" }.should eql(L[*expected])
           end
         end
 

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

@@ -12,15 +12,15 @@ describe Hamster::List do
 
       [
         [[], []],
-        [["A"], [Hamster.list("A")]],
-        [%w[A B C], [Hamster.list("A", "B"), Hamster.list("C")]],
+        [["A"], [L["A"]]],
+        [%w[A B C], [L["A", "B"], L["C"]]],
       ].each do |values, expected|
         context "on #{values.inspect}" do
-          let(:list) { Hamster.list(*values) }
+          let(:list) { L[*values] }
 
           context "with a block" do
             it "preserves the original" do
-              list.should eql(Hamster.list(*values))
+              list.should eql(L[*values])
             end
 
             it "iterates over the items in order" do
@@ -37,7 +37,7 @@ describe Hamster::List do
           context "without a block" do
             it "preserves the original" do
               list.send(method, 2)
-              list.should eql(Hamster.list(*values))
+              list.should eql(L[*values])
             end
 
             it "returns an Enumerator" do

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

@@ -2,42 +2,40 @@ require "spec_helper"
 require "hamster/list"
 
 describe Hamster::List do
-  [:each, :foreach].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) { |item| } }.should_not raise_error
-        end
+  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) }
+    [
+      [],
+      ["A"],
+      %w[A B C],
+    ].each do |values|
+      context "on #{values.inspect}" do
+        let(:list) { L[*values] }
 
-          context "with a block" do
-            it "iterates over the items in order" do
-              yielded = []
-              list.send(method) { |item| yielded << item }
-              yielded.should == values
-            end
+        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.send(method) { |item| item }.should be_nil
-            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.send(method).class.should be(Enumerator)
-              list.send(method).to_list.should eql(list)
-            end
+        context "without a block" do
+          it "returns an Enumerator" do
+            list.each.class.should be(Enumerator)
+            Hamster::List[*list.each].should eql(list)
           end
         end
       end
     end
   end
-end
+end

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

@@ -4,7 +4,7 @@ require "hamster/list"
 describe Hamster::List do
   describe "#each_with_index" do
     context "with no block" do
-      let(:list) { Hamster.list("A", "B", "C") }
+      let(:list) { L["A", "B", "C"] }
 
       it "returns an Enumerator" do
         list.each_with_index.class.should be(Enumerator)

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

@@ -2,23 +2,21 @@ require "spec_helper"
 require "hamster/list"
 
 describe Hamster::List do
-  [:empty?, :null?].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).filter(&:nil?).empty? }.should_not raise_error
-        end
+  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).send(method).should == expected
-          end
+    [
+      [[], true],
+      [["A"], false],
+      [%w[A B C], false],
+    ].each do |values, expected|
+      context "on #{values.inspect}" do
+        it "returns #{expected.inspect}" do
+          L[*values].empty?.should == expected
         end
       end
     end