hamster 1.0.0 → 1.0.1.pre.rc.1

data/spec/hamster/list/filter_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+require "hamster/list"
+
+describe Hamster::List do
+  let(:list) { Hamster.list(*values) }
+  let(:filtered_list) { Hamster.list(*filtered_values) }
+
+  describe "#filter" do
+    it "is lazy" do
+      expect { Hamster.stream { fail }.filter { |item| false } }.to_not raise_error
+    end
+
+    shared_examples "checking values" do
+      context "with a block" do
+        let(:filter) { list.filter { |item| item == item.upcase } }
+
+        it "preserves the original" do
+          expect(list).to eq(Hamster.list(*values))
+        end
+
+        it "returns the filtered list" do
+          expect(filter).to eq(filtered_list)
+        end
+      end
+
+      context "without a block" do
+        let(:filter) { list.filter }
+
+        it "returns itself" do
+          expect(filter).to eq(list)
+        end
+      end
+    end
+
+    context "with an empty array" do
+      let(:values) { [] }
+      let(:filtered_values) { [] }
+
+      include_examples "checking values"
+    end
+
+    context "with a single item array" do
+      let(:values) { ["A"] }
+      let(:filtered_values) { ["A"] }
+
+      include_examples "checking values"
+    end
+
+    context "with a multi-item array" do
+      let(:values) { %w[A B] }
+      let(:filtered_values) { %w[A B] }
+
+      include_examples "checking values"
+    end
+
+    context "with a multi-item single filterable array" do
+      let(:values) { %w[A b] }
+      let(:filtered_values) { ["A"] }
+
+      include_examples "checking values"
+    end
+
+    context "with a multi-item multi-filterable array" do
+      let(:values) { %w[a b] }
+      let(:filtered_values) { [] }
+
+      include_examples "checking values"
+    end
+  end
+end

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

@@ -26,9 +26,8 @@ describe Hamster::List do
       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)
+        it "returns itself" do
+          expect(find_all).to eq(list)
         end
       end
     end

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

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

data/spec/hamster/list/find_indices_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+require "hamster/list"
+
+describe Hamster::List do
+
+  [:find_indices, :indices].each do |method|
+
+    describe "##{method}" do
+
+      it "is lazy" do
+        -> { Hamster.stream { fail }.send(method) { |item| true } }.should_not raise_error
+      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|
+
+        describe "looking for #{item.inspect} in #{values.inspect}" do
+
+          before do
+            list = Hamster.list(*values)
+            @result = list.send(method) { |x| x == item }
+          end
+
+          it "returns #{expected.inspect}" do
+            @result.should == Hamster.list(*expected)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

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

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

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

@@ -1,8 +1,11 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster do
+
   describe "#flatten" do
+
     it "is lazy" do
       -> { Hamster.stream { fail }.flatten }.should_not raise_error
     end
@@ -14,18 +17,26 @@ describe Hamster do
       [["A", Hamster.list("B"), "C"], %w[A B C]],
       [[Hamster.list("A"), Hamster.list("B"), Hamster.list("C")], %w[A B C]],
     ].each do |values, expected|
-      context "on #{values}" do
-        let(:list) { Hamster.list(*values) }
+
+      describe "on #{values}" do
+
+        before do
+          @original = Hamster.list(*values)
+          @result = @original.flatten
+        end
 
         it "preserves the original" do
-          list.flatten
-          list.should eql(Hamster.list(*values))
+          @original.should == Hamster.list(*values)
         end
 
         it "returns an empty list" do
-          list.flatten.should eql(Hamster.list(*expected))
+          @result.should == Hamster.list(*expected)
         end
+
       end
+
     end
+
   end
-end
+
+end

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

@@ -1,47 +1,70 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
+
   describe "#grep" do
+
     it "is lazy" do
       -> { Hamster.stream { fail }.grep(Object) { |item| item } }.should_not raise_error
     end
 
-    context "without a block" do
+    describe "without a block" do
+
       [
         [[], []],
         [["A"], ["A"]],
         [[1], []],
         [["A", 2, "C"], %w[A C]],
       ].each do |values, expected|
-        context "on #{values.inspect}" do
+
+        describe "on #{values.inspect}" do
+
+          before do
+            @list = Hamster.list(*values)
+          end
+
           it "returns #{expected.inspect}" do
-            Hamster.list(*values).grep(String).should eql(Hamster.list(*expected))
+            @list.grep(String).should == Hamster.list(*expected)
           end
+
         end
+
       end
+
     end
 
-    context "with a block" do
+    describe "with a block" do
+
       [
         [[], []],
         [["A"], ["a"]],
         [[1], []],
         [["A", 2, "C"], %w[a c]],
       ].each do |values, expected|
-        context "on #{values.inspect}" do
-          let(:list) { Hamster.list(*values) }
+
+        describe "on #{values.inspect}" do
+
+          before do
+            @original = Hamster.list(*values)
+            @result = @original.grep(String, &:downcase)
+          end
 
           it "preserves the original" do
-            list.grep(String, &:downcase)
-            list.should eql(Hamster.list(*values))
+            @original.should == Hamster.list(*values)
           end
 
           it "returns #{expected.inspect}" do
-            list.grep(String, &:downcase).should eql(Hamster.list(*expected))
+            @result.should == Hamster.list(*expected)
           end
+
         end
+
       end
+
     end
+
   end
-end
+
+end

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

@@ -1,42 +1,77 @@
 require "spec_helper"
+
 require "hamster/list"
 
 describe Hamster::List do
+
   [:group_by, :group].each do |method|
+
     describe "##{method}" do
-      context "on a really big list" do
+
+      describe "on a really big list" do
+
+        before do
+          @list = Hamster.interval(0, STACK_OVERFLOW_DEPTH)
+        end
+
         it "doesn't run out of stack" do
-          -> { Hamster.interval(0, STACK_OVERFLOW_DEPTH).send(method) }.should_not raise_error
+          -> { @list.send(method) }.should_not raise_error
         end
+
       end
 
-      context "with a block" do
+      describe "with a block" do
+
         [
           [[], []],
           [[1], [true => Hamster.list(1)]],
           [[1, 2, 3, 4], [true => Hamster.list(3, 1), false => Hamster.list(4, 2)]],
         ].each do |values, expected|
-          context "on #{values.inspect}" do
+
+          describe "on #{values.inspect}" do
+
+            before do
+              original = Hamster.list(*values)
+              @result = original.send(method, &:odd?)
+            end
+
             it "returns #{expected.inspect}" do
-              Hamster.list(*values).send(method, &:odd?).should eql(Hamster.hash(*expected))
+              @result.should == Hamster.hash(*expected)
             end
+
           end
+
         end
+
       end
 
-      context "without a block" do
+      describe "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)]],
         ].each do |values, expected|
-          context "on #{values.inspect}" do
+
+          describe "on #{values.inspect}" do
+
+            before do
+              original = Hamster.list(*values)
+              @result = original.send(method)
+            end
+
             it "returns #{expected.inspect}" do
-              Hamster.list(*values).send(method).should eql(Hamster.hash(*expected))
+              @result.should == Hamster.hash(*expected)
             end
+
           end
+
         end
+
       end
+
     end
+
   end
-end
+
+end