hamster 0.4.3 → 1.0.0

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

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

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

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

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

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

@@ -0,0 +1,71 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  let(:list) { Hamster.list(*values) }
+  let(:found_list) { Hamster.list(*found_values) }
+
+  describe "#find_all" do
+    it "is lazy" do
+      expect { Hamster.stream { fail }.find_all { |item| false } }.to_not raise_error
+    end
+
+    shared_examples "checking values" do
+      context "with a block" do
+        let(:find_all) { list.find_all { |item| item == item.upcase } }
+
+        it "preserves the original" do
+          expect(list).to eq(Hamster.list(*values))
+        end
+
+        it "returns the found list" do
+          expect(find_all).to eq(found_list)
+        end
+      end
+
+      context "without a block" do
+        let(:find_all) { list.find_all }
+
+        it "returns an Enumerator" do
+          expect(find_all.class).to be(Enumerator)
+          expect(find_all.each { |item| item == item.upcase }).to eq(found_list)
+        end
+      end
+    end
+
+    context "with an empty array" do
+      let(:values) { [] }
+      let(:found_values) { [] }
+
+      include_examples "checking values"
+    end
+
+    context "with a single item array" do
+      let(:values) { ["A"] }
+      let(:found_values) { ["A"] }
+
+      include_examples "checking values"
+    end
+
+    context "with a multi-item array" do
+      let(:values) { %w[A B] }
+      let(:found_values) { %w[A B] }
+
+      include_examples "checking values"
+    end
+
+    context "with a multi-item single find_allable array" do
+      let(:values) { %w[A b] }
+      let(:found_values) { ["A"] }
+
+      include_examples "checking values"
+    end
+
+    context "with a multi-item multi-find_allable array" do
+      let(:values) { %w[a b] }
+      let(:found_values) { [] }
+
+      include_examples "checking values"
+    end
+  end
+end

data/spec/{hamster → lib/hamster}/list/find_index_spec.rb

@@ -1,23 +1,13 @@
-require 'spec_helper'
-
-require 'hamster/list'
+require "spec_helper"
+require "hamster/list"
 
 describe Hamster::List do
-
   [:find_index, :index].each do |method|
-
     describe "##{method}" do
-
-      describe "on a really big list" do
-
-        before do
-          @list = Hamster.interval(0, STACK_OVERFLOW_DEPTH)
-        end
-
+      context "on a really big list" do
         it "doesn't run out of stack" do
-          lambda { @list.send(method) { |item| false } }.should_not raise_error
+          -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).send(method) { |item| false } }.should_not raise_error
         end
-
       end
 
       [
@@ -35,24 +25,12 @@ describe Hamster::List do
         [[2.0], 2.0, 0],
         [[2.0], 2, 0],
       ].each do |values, item, expected|
-
-        describe "looking for #{item.inspect} in #{values.inspect}" do
-
-          before do
-            list = Hamster.list(*values)
-            @result = list.send(method) { |x| x == item }
-          end
-
+        context "looking for #{item.inspect} in #{values.inspect}" do
           it "returns #{expected.inspect}" do
-            @result.should == expected
+            Hamster.list(*values).send(method) { |x| x == item }.should == expected
           end
-
         end
-
       end
-
     end
-
   end
-
-end
+end

data/spec/{hamster → lib/hamster}/list/find_spec.rb

@@ -1,23 +1,13 @@
-require 'spec_helper'
-
-require 'hamster/list'
+require "spec_helper"
+require "hamster/list"
 
 describe Hamster::List do
-
   [:find, :detect].each do |method|
-
     describe "##{method}" do
-
-      describe "on a really big list" do
-
-        before do
-          @list = Hamster.interval(0, STACK_OVERFLOW_DEPTH)
-        end
-
+      context "on a really big list" do
         it "doesn't run out of stack" do
-          lambda { @list.send(method) { false } }.should_not raise_error
+          -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).send(method) { false } }.should_not raise_error
         end
-
       end
 
       [
@@ -31,35 +21,23 @@ describe Hamster::List do
         [["A", "B", nil], nil, nil],
         [["A", "B", nil], "C", nil],
       ].each do |values, item, expected|
+        context "on #{values.inspect}" do
+          let(:list) { Hamster.list(*values) }
 
-        describe "on #{values.inspect}" do
-
-          before do
-            @list = Hamster.list(*values)
-          end
-
-          describe "with a block" do
-
+          context "with a block" do
             it "returns #{expected.inspect}" do
-              @list.send(method) { |x| x == item }.should == expected
+              list.send(method) { |x| x == item }.should == expected
             end
-
           end
 
-          describe "without a block" do
-
-            it "returns nil" do
-              @list.send(method).should be_nil
+          context "without a block" do
+            it "returns an Enumerator" do
+              list.send(method).class.should be(Enumerator)
+              list.send(method).each { |x| x == item }.should == expected
             end
-
           end
-
         end
-
       end
-
     end
-
   end
-
-end
+end

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

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  let(:list) { Hamster.list(*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) }
+
+    shared_examples "checking flattened result" do
+
+      it "returns the flattened values as a Hamster::List" do
+        expect(flat_map).to eq(flattened_list)
+      end
+
+      it "returns a Hamster::List" do
+        expect(flat_map).to be_a(Hamster::List)
+      end
+    end
+
+    context "with an empty list" do
+      let(:values) { [] }
+      let(:flattened_values) { [] }
+
+      include_examples "checking flattened result"
+    end
+
+    context "with a block that returns an empty list" do
+      let(:block) { ->(item) { [] } }
+      let(:values) { [1, 2, 3] }
+      let(:flattened_values) { [] }
+
+      include_examples "checking flattened result"
+    end
+
+    context "with a list of one item" do
+      let(:values) { [7] }
+      let(:flattened_values) { [7, 8, 49] }
+
+      include_examples "checking flattened result"
+    end
+
+    context "with a list of multiple items" do
+      let(:values) { [1, 2, 3] }
+      let(:flattened_values) { [1, 2, 1, 2, 3, 4, 3, 4, 9] }
+
+      include_examples "checking flattened result"
+    end
+  end
+end