hamster 1.0.1.pre.rc3 → 2.0.0

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

@@ -38,25 +38,25 @@ describe Hamster::List do
     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')
+  include_examples 'equal using =='       , L["A", "B", "C"], %w[A B C]
+  include_examples 'not equal using eql?' , L["A", "B", "C"], %w[A B C]
+  include_examples 'not equal using =='   , L["A", "B", "C"], Object.new
+  include_examples 'not equal using eql?' , L["A", "B", "C"], Object.new
+  include_examples 'equal using =='       , L.empty, []
+  include_examples 'not equal using eql?' , L.empty, []
+
+  include_examples 'equal using eql?'     , L.empty, L.empty
+  include_examples 'not equal using eql?' , L.empty, L[nil]
+  include_examples 'not equal using eql?' , L["A"], L.empty
+  include_examples 'equal using eql?'     , L["A"], L["A"]
+  include_examples 'not equal using eql?' , L["A"], L["B"]
+  include_examples 'not equal using eql?' , L["A", "B"], L["A"]
+  include_examples 'equal using eql?'     , L["A", "B", "C"], L["A", "B", "C"]
+  include_examples 'not equal using eql?' , L["C", "A", "B"], L["A", "B", "C"]
+
+  include_examples 'equal using =='       , L['A'], ['A']
+  include_examples 'equal using =='       , ['A'], L['A']
+
+  include_examples 'not equal using eql?' , L['A'], ['A']
+  include_examples 'not equal using eql?' , ['A'], L['A']
 end

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

@@ -3,37 +3,37 @@ require "hamster/list"
 
 describe Hamster::List do
   describe "#fill" do
-    let(:list) { Hamster.list(1, 2, 3, 4, 5, 6) }
+    let(:list) { L[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))
+      list.fill(:a, 0, 3).should eql(L[: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))
+      list.fill(:a, 3, 2).should eql(L[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))
+      list.fill(:a, 4, 2).should eql(L[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))
+      list.fill(:a, 0, 6).should eql(L[: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))
+      list.fill(:a, 3, 6).should eql(L[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))
+        list.fill(:a).should eql(L[: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))
+        list.fill(:a, 4).should eql(L[1, 2, 3, 4, :a, :a])
       end
     end
 

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

@@ -2,8 +2,8 @@ require "spec_helper"
 require "hamster/list"
 
 describe Hamster::List do
-  let(:list) { Hamster.list(*values) }
-  let(:found_list) { Hamster.list(*found_values) }
+  let(:list) { L[*values] }
+  let(:found_list) { L[*found_values] }
 
   describe "#find_all" do
     it "is lazy" do
@@ -15,7 +15,7 @@ describe Hamster::List do
         let(:find_all) { list.find_all { |item| item == item.upcase } }
 
         it "preserves the original" do
-          expect(list).to eq(Hamster.list(*values))
+          expect(list).to eq(L[*values])
         end
 
         it "returns the found list" do

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

@@ -27,7 +27,7 @@ describe Hamster::List do
       ].each do |values, item, expected|
         context "looking for #{item.inspect} in #{values.inspect}" do
           it "returns #{expected.inspect}" do
-            Hamster.list(*values).send(method) { |x| x == item }.should == expected
+            L[*values].send(method) { |x| x == item }.should == expected
           end
         end
       end

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

@@ -22,7 +22,7 @@ describe Hamster::List do
         [["A", "B", nil], "C", nil],
       ].each do |values, item, 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/flat_map_spec.rb

@@ -2,12 +2,12 @@ require "spec_helper"
 require "hamster/list"
 
 describe Hamster::List do
-  let(:list) { Hamster.list(*values) }
+  let(:list) { L[*values] }
 
   describe "#flat_map" do
     let(:block) { ->(item) { [item, item + 1, item * item] } }
     let(:flat_map) { list.flat_map(&block) }
-    let(:flattened_list) { Hamster.list(*flattened_values) }
+    let(:flattened_list) { L[*flattened_values] }
 
     shared_examples "checking flattened result" do
 

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

@@ -11,19 +11,19 @@ describe Hamster do
       [[], []],
       [["A"], ["A"]],
       [%w[A B C], %w[A B C]],
-      [["A", Hamster.list("B"), "C"], %w[A B C]],
-      [[Hamster.list("A"), Hamster.list("B"), Hamster.list("C")], %w[A B C]],
+      [["A", L["B"], "C"], %w[A B C]],
+      [[L["A"], L["B"], L["C"]], %w[A B C]],
     ].each do |values, expected|
       context "on #{values}" do
-        let(:list) { Hamster.list(*values) }
+        let(:list) { L[*values] }
 
         it "preserves the original" do
           list.flatten
-          list.should eql(Hamster.list(*values))
+          list.should eql(L[*values])
         end
 
         it "returns an empty list" do
-          list.flatten.should eql(Hamster.list(*expected))
+          list.flatten.should eql(L[*expected])
         end
       end
     end

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

@@ -16,7 +16,7 @@ describe Hamster::List do
       ].each do |values, expected|
         context "on #{values.inspect}" do
           it "returns #{expected.inspect}" do
-            Hamster.list(*values).grep(String).should eql(Hamster.list(*expected))
+            L[*values].grep(String).should eql(L[*expected])
           end
         end
       end
@@ -30,15 +30,15 @@ describe Hamster::List do
         [["A", 2, "C"], %w[a c]],
       ].each do |values, expected|
         context "on #{values.inspect}" do
-          let(:list) { Hamster.list(*values) }
+          let(:list) { L[*values] }
 
           it "preserves the original" do
             list.grep(String, &:downcase)
-            list.should eql(Hamster.list(*values))
+            list.should eql(L[*values])
           end
 
           it "returns #{expected.inspect}" do
-            list.grep(String, &:downcase).should eql(Hamster.list(*expected))
+            list.grep(String, &:downcase).should eql(L[*expected])
           end
         end
       end

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

@@ -13,12 +13,12 @@ describe Hamster::List do
       context "with a block" do
         [
           [[], []],
-          [[1], [true => Hamster.list(1)]],
-          [[1, 2, 3, 4], [true => Hamster.list(3, 1), false => Hamster.list(4, 2)]],
+          [[1], [true => L[1]]],
+          [[1, 2, 3, 4], [true => L[3, 1], false => L[4, 2]]],
         ].each do |values, expected|
           context "on #{values.inspect}" do
             it "returns #{expected.inspect}" do
-              Hamster.list(*values).send(method, &:odd?).should eql(Hamster.hash(*expected))
+              L[*values].send(method, &:odd?).should eql(H[*expected])
             end
           end
         end
@@ -27,12 +27,12 @@ describe Hamster::List do
       context "without a block" do
         [
           [[], []],
-          [[1], [1 => Hamster.list(1)]],
-          [[1, 2, 3, 4], [1 => Hamster.list(1), 2 => Hamster.list(2), 3 => Hamster.list(3), 4 => Hamster.list(4)]],
+          [[1], [1 => L[1]]],
+          [[1, 2, 3, 4], [1 => L[1], 2 => L[2], 3 => L[3], 4 => L[4]]],
         ].each do |values, expected|
           context "on #{values.inspect}" do
             it "returns #{expected.inspect}" do
-              Hamster.list(*values).send(method).should eql(Hamster.hash(*expected))
+              L[*values].send(method).should eql(H[*expected])
             end
           end
         end

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

@@ -11,12 +11,12 @@ describe Hamster::List do
 
     context "on an empty list" do
       it "returns 0" do
-        expect(Hamster.list.hash).to eq(0)
+        expect(L.empty.hash).to eq(0)
       end
     end
 
     it "values are sufficiently distributed" do
-      (1..4000).each_slice(4).map { |a, b, c, d| Hamster.list(a, b, c, d).hash }.uniq.size.should == 1000
+      (1..4000).each_slice(4).map { |a, b, c, d| L[a, b, c, d].hash }.uniq.size.should == 1000
     end
   end
 end

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

@@ -11,7 +11,7 @@ describe Hamster::List do
       ].each do |values, expected|
         context "on #{values.inspect}" do
           it "returns #{expected.inspect}" do
-            Hamster.list(*values).send(method).should == expected
+            L[*values].send(method).should == expected
           end
         end
       end

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

@@ -2,7 +2,7 @@ require "spec_helper"
 require "hamster/list"
 
 describe Hamster::List do
-  [:include?, :member?, :contains?, :elem?].each do |method|
+  [:include?, :member?].each do |method|
     describe "##{method}" do
       context "on a really big list" do
         it "doesn't run out of stack" do
@@ -27,7 +27,7 @@ describe Hamster::List do
       ].each do |values, item, expected|
         context "on #{values.inspect}" do
           it "returns #{expected.inspect}" do
-            Hamster.list(*values).send(method, item).should == expected
+            L[*values].send(method, item).should == expected
           end
         end
       end

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

@@ -0,0 +1,38 @@
+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
+          if RUBY_ENGINE == 'jruby' && RUBY_VERSION <= '2.2.2' && values[0].is_a?(Fixnum) && item.is_a?(Float)
+            skip "On JRuby, Enumerable#find_index doesn't test equality properly"
+          else
+            L[*values].index(item).should == expected
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  describe "#indices" do
+    context "when called with a block" do
+      it "is lazy" do
+        count = 0
+        Hamster.stream { count += 1 }.indices { |item| true }
+        count.should <= 1
+      end
+
+      context "on a large list which doesn't contain desired item" do
+        it "doesn't blow the stack" do
+          -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).indices { |x| x < 0 }.size }.should_not raise_error
+        end
+      end
+
+      [
+        [[], "A", []],
+        [["A"], "B", []],
+        [%w[A B A], "B", [1]],
+        [%w[A B A], "A", [0, 2]],
+        [[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
+            L[*values].indices { |x| x == item }.should eql(L[*expected])
+          end
+        end
+      end
+    end
+
+    context "when called with a single argument" do
+      it "is lazy" do
+        count = 0
+        Hamster.stream { count += 1 }.indices(nil)
+        count.should <= 1
+      end
+
+      [
+        [[], "A", []],
+        [["A"], "B", []],
+        [%w[A B A], "B", [1]],
+        [%w[A B A], "A", [0, 2]],
+        [[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
+            L[*values].indices(item).should eql(L[*expected])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,15 +13,15 @@ describe Hamster::List do
       [%w[A B C], %w[A 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.init
-          list.should eql(Hamster.list(*values))
+          list.should eql(L[*values])
         end
 
         it "returns the list without the last element: #{expected.inspect}" do
-          list.init.should eql(Hamster.list(*expected))
+          list.init.should eql(L[*expected])
         end
       end
     end

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

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

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

@@ -3,7 +3,7 @@ require "hamster/list"
 
 describe Hamster::List do
   describe "#insert" do
-    let(:original) { Hamster.list(1, 2, 3) }
+    let(:original) { L[1, 2, 3] }
 
     it "can add items at the beginning of a list" do
       list = original.insert(0, :a, :b)

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

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

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

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