in_threads 1.2.1 → 1.2.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MjRiZjE4NWM3ZGY5ZjUwNGQ2ZTY0NmU1MzE0ZWQ5N2ZiZWZkMjc0OQ==
+    YzcyOTliODQ1ZDMyYmY1NDRiMTEyZTc4ODI0ZGViNTQ3MDJmODNhMQ==
   data.tar.gz: !binary |-
-    YjY3NmE2NWI0NjgzNDAyN2FhNWUxYjY3OWMxNTk3ZmY2NzQzZDBiMA==
+    ZWNlZTE1ZjE5NmNlYzdiOWM4Y2YxNjJiMDVlYjVmMjQ2ZGY1OTM0MQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NjNkMzhlM2JhOGI0YzA2OTU5MWNlYzNlMDBiNjEyYTY5ZWY2ODdiYTE1MjY5
-    NDc4MmNkNmQ2MmJkZjhhN2ZhZDdjMDg4NTdkOGU5OTYyMGQ2ZjFkYWYyZGY0
-    MmQ3YjdiNDM4YTUyNWE2NjQ1MzIwMTA0MmQwYjY3YjRhOWRkMWM=
+    MDJkYjFlZDRiMTJiZjc2OTU0NWM2NGJjMWU2MjQ3YzdkZDQ3OTkxZTY0N2Uw
+    OWRjMTc4ODFjZTM5MTM1OGUxNDlkMTMxZGI2OTljZTRmZjAwYTZjY2I3OTMw
+    ZDU0YTFhODA2YzFiOWNiZDlmNzBkYmQwZWU3MWJlOWRjYmI4MmU=
   data.tar.gz: !binary |-
-    NDBkOGUxZGFmZmY2YjE4YjFhNTk2NDJjMzQ0OTZkMWY1ZDVhMmIzZjYxYWIw
-    NGQ1NDQ4YTg0YWExZWZiY2I3N2I0NWQyZGY5MjM3NzJkZWU3MTE0N2Y5M2Ux
-    ZmUwZDhlMmMwMGY4NWVhY2MzYTk1MTE3ZDNmYzVjMDRjMDBhOGI=
+    MDgzOWFkYmIwZjEzZDVlYjcyYTZlMjU4YzQwZTYyYThmNWM0MzExMjk4ZTY5
+    NWIwOTlhMTA3Y2UyMjA0NzYxYTA5NTcyZWVlNmU1M2Q2M2E1ODRmNWU2OGU2
+    ZjBlMzI0MTI2MWMzNTA3OWM2MDdkM2MxZWZlOGE3ZDc2NGQyNTU=

data/in_threads.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'in_threads'
-  s.version     = '1.2.1'
+  s.version     = '1.2.2'
   s.summary     = %q{Execute ruby code in parallel}
   s.homepage    = "http://github.com/toy/#{s.name}"
   s.authors     = ['Ivan Kuchin']
@@ -15,5 +15,5 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = %w[lib]
 
-  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec', '~> 3.0'
 end

data/lib/in_threads/thread_limiter.rb

@@ -27,7 +27,7 @@ class InThreads
     # Add thread to <tt>ThreadsWait</tt>, wait for finishing of one thread if limit reached
     def <<(thread)
       if @waiter.threads.length + 1 >= @count
-        @waiter.join(thread)
+        @waiter.join(thread).join
       else
         @waiter.join_nowait(thread)
       end
@@ -35,7 +35,7 @@ class InThreads
 
     # Wait for waiting threads
     def finalize
-      @waiter.all_waits
+      @waiter.all_waits(&:join)
     end
   end
 end

data/spec/in_threads_spec.rb

@@ -1,4 +1,6 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'rspec'
+require 'in_threads'
 
 class Item
   def initialize(i)
@@ -66,7 +68,7 @@ def describe_enum_method(method, &block)
   else
     it "should not be defined" do
       exception_regexp = /^undefined method `#{Regexp.escape(method)}' .*\bInThreads\b/
-      proc{ enum.in_threads.send(method) }.should raise_error(NoMethodError, exception_regexp)
+      expect{ enum.in_threads.send(method) }.to raise_error(NoMethodError, exception_regexp)
     end
   end
 end
@@ -84,38 +86,38 @@ describe "in_threads" do
   describe "consistency" do
     describe "verifying params" do
       it "should complain about using with non enumerable" do
-        proc{ InThreads.new(1) }.should raise_error(ArgumentError)
+        expect{ InThreads.new(1) }.to raise_error(ArgumentError)
       end
 
       [1..10, 10.times, {}, []].each do |o|
         it "should complain about using with #{o.class}" do
-          proc{ InThreads.new(o) }.should_not raise_error
+          expect{ InThreads.new(o) }.not_to raise_error
         end
       end
 
       it "should complain about using less than 2 threads" do
-        proc{ 10.times.in_threads(1) }.should raise_error(ArgumentError)
+        expect{ 10.times.in_threads(1) }.to raise_error(ArgumentError)
       end
 
       it "should not complain about using 2 or more threads" do
-        proc{ 10.times.in_threads(2) }.should_not raise_error
+        expect{ 10.times.in_threads(2) }.not_to raise_error
       end
     end
 
-    describe "in_threads" do
+    describe "in_threads method" do
       it "should not change existing instance" do
         threaded = enum.in_threads(10)
-        proc{ threaded.in_threads(20) }.should_not change(threaded, :thread_count)
+        expect{ threaded.in_threads(20) }.not_to change(threaded, :thread_count)
       end
 
       it "should create new instance with different title when called on WithProgress" do
         threaded = enum.in_threads(10)
         tthreaded = threaded.in_threads(20)
-        threaded.thread_count.should == 10
-        tthreaded.thread_count.should == 20
-        tthreaded.class.should == threaded.class
-        tthreaded.object_id.should_not == threaded.object_id
-        tthreaded.enumerable.should == threaded.enumerable
+        expect(threaded.thread_count).to eq(10)
+        expect(tthreaded.thread_count).to eq(20)
+        expect(tthreaded.class).to eq(threaded.class)
+        expect(tthreaded.object_id).not_to eq(threaded.object_id)
+        expect(tthreaded.enumerable).to eq(threaded.enumerable)
       end
     end
 
@@ -138,8 +140,8 @@ describe "in_threads" do
             end
             res
           end
-          @thread_count.should == 0
-          @max_thread_count.should == 4
+          expect(@thread_count).to eq(0)
+          expect(@max_thread_count).to eq(4)
         end
       end
     end
@@ -159,7 +161,7 @@ describe "in_threads" do
 
       %w[each map all?].each do |method|
         it "should call underlying enumerable.each only once for #{method}" do
-          enum.should_receive(:each_started).once
+          expect(enum).to receive(:each_started).once
           enum.in_threads(13).send(method, &:check?)
         end
       end
@@ -171,26 +173,39 @@ describe "in_threads" do
       pending method
     end
 
+    class TestException < StandardError; end
+
+    def check_test_exception(enum, &block)
+      expect{ block[enum.in_threads] }.to raise_exception(TestException)
+      expect{ block[enum.in_threads(1000)] }.to raise_exception(TestException)
+    end
+
     describe "each" do
       it "should return same enum after running" do
-        enum.in_threads.each(&:value).should == enum
+        expect(enum.in_threads.each(&:value)).to eq(enum)
       end
 
       it "should execute block for each element" do
-        enum.each{ |o| o.should_receive(:touch).once }
+        enum.each{ |o| expect(o).to receive(:touch).once }
         enum.in_threads.each(&:touch_n_value)
       end
 
       it "should run faster with threads" do
-        measure{ enum.in_threads.each(&:value) }.should < measure{ enum.each(&:value) } * speed_coef
+        expect(measure{ enum.in_threads.each(&:value) }).to be < measure{ enum.each(&:value) } * speed_coef
       end
 
       it "should run faster with more threads" do
-        measure{ enum.in_threads(10).each(&:value) }.should < measure{ enum.in_threads(2).each(&:value) } * speed_coef
+        expect(measure{ enum.in_threads(10).each(&:value) }).to be < measure{ enum.in_threads(2).each(&:value) } * speed_coef
       end
 
       it "should return same enum without block" do
-        enum.in_threads.each.to_a.should == enum.each.to_a
+        expect(enum.in_threads.each.to_a).to eq(enum.each.to_a)
+      end
+
+      it "should raise exception in outer thread" do
+        check_test_exception(enum) do |threaded|
+          threaded.each{ raise TestException }
+        end
       end
     end
 
@@ -199,35 +214,41 @@ describe "in_threads" do
         let(:runner){ proc{ |o, i| o.value } }
 
         it "should return same result with threads" do
-          enum.in_threads.send(method, &runner).should == enum.send(method, &runner)
+          expect(enum.in_threads.send(method, &runner)).to eq(enum.send(method, &runner))
         end
 
         it "should fire same objects" do
-          enum.send(method){ |o, i| o.should_receive(:touch).with(i).once }
+          enum.send(method){ |o, i| expect(o).to receive(:touch).with(i).once }
           enum.in_threads.send(method){ |o, i| o.touch_n_value(i) }
         end
 
         it "should run faster with threads" do
-          measure{ enum.in_threads.send(method, &runner) }.should < measure{ enum.send(method, &runner) } * speed_coef
+          expect(measure{ enum.in_threads.send(method, &runner) }).to be < measure{ enum.send(method, &runner) } * speed_coef
         end
 
         it "should return same enum without block" do
-          enum.in_threads.send(method).to_a.should == enum.send(method).to_a
+          expect(enum.in_threads.send(method).to_a).to eq(enum.send(method).to_a)
+        end
+
+        it "should raise exception in outer thread" do
+          check_test_exception(enum) do |threaded|
+            threaded.send(method){ raise TestException }
+          end
         end
       end
     end
 
     describe "reverse_each" do
       it "should return same result with threads" do
-        enum.in_threads.reverse_each(&:value).should == enum.reverse_each(&:value)
+        expect(enum.in_threads.reverse_each(&:value)).to eq(enum.reverse_each(&:value))
       end
 
       it "should fire same objects in reverse order" do
         @order = double('order', :notify => nil)
-        @order.should_receive(:notify).with(enum.last).ordered
-        @order.should_receive(:notify).with(enum[enum.length / 2]).ordered
-        @order.should_receive(:notify).with(enum.first).ordered
-        enum.reverse_each{ |o| o.should_receive(:touch).once }
+        expect(@order).to receive(:notify).with(enum.last).ordered
+        expect(@order).to receive(:notify).with(enum[enum.length / 2]).ordered
+        expect(@order).to receive(:notify).with(enum.first).ordered
+        enum.reverse_each{ |o| expect(o).to receive(:touch).once }
         @mutex = Mutex.new
         enum.in_threads.reverse_each do |o|
           @mutex.synchronize{ @order.notify(o) }
@@ -236,11 +257,17 @@ describe "in_threads" do
       end
 
       it "should run faster with threads" do
-        measure{ enum.in_threads.reverse_each(&:value) }.should < measure{ enum.reverse_each(&:value) } * speed_coef
+        expect(measure{ enum.in_threads.reverse_each(&:value) }).to be < measure{ enum.reverse_each(&:value) } * speed_coef
       end
 
       it "should return same enum without block" do
-        enum.in_threads.reverse_each.to_a.should == enum.reverse_each.to_a
+        expect(enum.in_threads.reverse_each.to_a).to eq(enum.reverse_each.to_a)
+      end
+
+      it "should raise exception in outer thread" do
+        check_test_exception(enum) do |threaded|
+          threaded.reverse_each{ raise TestException }
+        end
       end
     end
 
@@ -252,7 +279,7 @@ describe "in_threads" do
         let(:enum){ 100.times.map{ |i| ValueItem.new(i, i % 2 == 1) } }
 
         it "should return same result with threads" do
-          enum.in_threads.send(method, &:check?).should == enum.send(method, &:check?)
+          expect(enum.in_threads.send(method, &:check?)).to eq(enum.send(method, &:check?))
         end
 
         it "should fire same objects but not all" do
@@ -266,14 +293,20 @@ describe "in_threads" do
           @mutex = Mutex.new
           enum.in_threads.send(method){ |o| @mutex.synchronize{ @a << o }; o.check? }
 
-          @a.length.should >= a.length
-          @a.length.should <= enum.length * 0.5
+          expect(@a.length).to be >= a.length
+          expect(@a.length).to be <= enum.length * 0.5
         end
 
         it "should run faster with threads" do
           boolean = %w[all? drop_while take_while].include?(method)
           enum = 30.times.map{ |i| ValueItem.new(i, boolean) }
-          measure{ enum.in_threads.send(method, &:check?) }.should < measure{ enum.send(method, &:check?) } * speed_coef
+          expect(measure{ enum.in_threads.send(method, &:check?) }).to be < measure{ enum.send(method, &:check?) } * speed_coef
+        end
+
+        it "should raise exception in outer thread" do
+          check_test_exception(enum) do |threaded|
+            threaded.send(method){ raise TestException }
+          end
         end
       end
     end
@@ -281,16 +314,22 @@ describe "in_threads" do
     %w[partition find_all select reject count].each do |method|
       describe method do
         it "should return same result with threads" do
-          enum.in_threads.send(method, &:check?).should == enum.send(method, &:check?)
+          expect(enum.in_threads.send(method, &:check?)).to eq(enum.send(method, &:check?))
         end
 
         it "should fire same objects" do
-          enum.send(method){ |o| o.should_receive(:touch).once }
+          enum.send(method){ |o| expect(o).to receive(:touch).once }
           enum.in_threads.send(method, &:touch_n_check?)
         end
 
         it "should run faster with threads" do
-          measure{ enum.in_threads.send(method, &:check?) }.should < measure{ enum.send(method, &:check?) } * speed_coef
+          expect(measure{ enum.in_threads.send(method, &:check?) }).to be < measure{ enum.send(method, &:check?) } * speed_coef
+        end
+
+        it "should raise exception in outer thread" do
+          check_test_exception(enum) do |threaded|
+            threaded.send(method){ raise TestException }
+          end
         end
       end
     end
@@ -298,16 +337,22 @@ describe "in_threads" do
     %w[collect map group_by max_by min_by minmax_by sort_by].each do |method|
       describe method do
         it "should return same result with threads" do
-          enum.in_threads.send(method, &:value).should == enum.send(method, &:value)
+          expect(enum.in_threads.send(method, &:value)).to eq(enum.send(method, &:value))
         end
 
         it "should fire same objects" do
-          enum.send(method){ |o| o.should_receive(:touch).once; 0 }
+          enum.send(method){ |o| expect(o).to receive(:touch).once; 0 }
           enum.in_threads.send(method, &:touch_n_value)
         end
 
         it "should run faster with threads" do
-          measure{ enum.in_threads.send(method, &:value) }.should < measure{ enum.send(method, &:value) } * speed_coef
+          expect(measure{ enum.in_threads.send(method, &:value) }).to be < measure{ enum.send(method, &:value) } * speed_coef
+        end
+
+        it "should raise exception in outer thread" do
+          check_test_exception(enum) do |threaded|
+            threaded.send(method){ raise TestException }
+          end
         end
       end
     end
@@ -317,20 +362,26 @@ describe "in_threads" do
         let(:runner){ proc{ |a| a.each(&:value) } }
 
         it "should fire same objects" do
-          enum.send(method, 3){ |a| a.first.should_receive(:touch).with(a).once }
+          enum.send(method, 3){ |a| expect(a.first).to receive(:touch).with(a).once }
           enum.in_threads.send(method, 3){ |a| a.first.touch_n_value(a) }
         end
 
         it "should return same with block" do
-          enum.in_threads.send(method, 3, &runner).should == enum.send(method, 3, &runner)
+          expect(enum.in_threads.send(method, 3, &runner)).to eq(enum.send(method, 3, &runner))
         end
 
         it "should run faster with threads" do
-          measure{ enum.in_threads.send(method, 3, &runner) }.should < measure{ enum.send(method, 3, &runner) } * speed_coef
+          expect(measure{ enum.in_threads.send(method, 3, &runner) }).to be < measure{ enum.send(method, 3, &runner) } * speed_coef
         end
 
         it "should return same without block" do
-          enum.in_threads.send(method, 3).to_a.should == enum.send(method, 3).to_a
+          expect(enum.in_threads.send(method, 3).to_a).to eq(enum.send(method, 3).to_a)
+        end
+
+        it "should raise exception in outer thread" do
+          check_test_exception(enum) do |threaded|
+            threaded.send(method, 3){ raise TestException }
+          end
         end
       end
     end
@@ -339,35 +390,47 @@ describe "in_threads" do
       let(:runner){ proc{ |a| a.each(&:value) } }
 
       it "should fire same objects" do
-        enum.zip(enum, enum){ |a| a.first.should_receive(:touch).with(a).once }
+        enum.zip(enum, enum){ |a| expect(a.first).to receive(:touch).with(a).once }
         enum.in_threads.zip(enum, enum){ |a| a.first.touch_n_value(a) }
       end
 
       it "should return same with block" do
-        enum.in_threads.zip(enum, enum, &runner).should == enum.zip(enum, enum, &runner)
+        expect(enum.in_threads.zip(enum, enum, &runner)).to eq(enum.zip(enum, enum, &runner))
       end
 
       it "should run faster with threads" do
-        measure{ enum.in_threads.zip(enum, enum, &runner) }.should < measure{ enum.zip(enum, enum, &runner) } * speed_coef
+        expect(measure{ enum.in_threads.zip(enum, enum, &runner) }).to be < measure{ enum.zip(enum, enum, &runner) } * speed_coef
       end
 
       it "should return same without block" do
-        enum.in_threads.zip(enum, enum).should == enum.zip(enum, enum)
+        expect(enum.in_threads.zip(enum, enum)).to eq(enum.zip(enum, enum))
+      end
+
+      it "should raise exception in outer thread" do
+        check_test_exception(enum) do |threaded|
+          threaded.zip(enum, enum){ raise TestException }
+        end
       end
     end
 
     describe "cycle" do
       it "should fire same objects" do
-        enum.cycle(1){ |o| o.should_receive(:touch).exactly(3).times }
+        enum.cycle(1){ |o| expect(o).to receive(:touch).exactly(3).times }
         enum.in_threads.cycle(3, &:touch_n_value)
       end
 
       it "should run faster with threads" do
-        measure{ enum.in_threads.cycle(3, &:value) }.should < measure{ enum.cycle(3, &:value) } * speed_coef
+        expect(measure{ enum.in_threads.cycle(3, &:value) }).to be < measure{ enum.cycle(3, &:value) } * speed_coef
       end
 
       it "should return same enum without block" do
-        enum.in_threads.cycle(3).to_a.should == enum.cycle(3).to_a
+        expect(enum.in_threads.cycle(3).to_a).to eq(enum.cycle(3).to_a)
+      end
+
+      it "should raise exception in outer thread" do
+        check_test_exception(enum) do |threaded|
+          threaded.cycle{ raise TestException }
+        end
       end
     end
 
@@ -375,20 +438,26 @@ describe "in_threads" do
       let(:matcher){ Item::HalfMatcher.new }
 
       it "should fire same objects" do
-        enum.each{ |o| o.should_receive(:touch).exactly(matcher === o ? 1 : 0).times }
+        enum.each{ |o| expect(o).to receive(:touch).exactly(matcher === o ? 1 : 0).times }
         enum.in_threads.grep(matcher, &:touch_n_value)
       end
 
       it "should return same with block" do
-        enum.in_threads.grep(matcher, &:value).should == enum.grep(matcher, &:value)
+        expect(enum.in_threads.grep(matcher, &:value)).to eq(enum.grep(matcher, &:value))
       end
 
       it "should run faster with threads" do
-        measure{ enum.in_threads.grep(matcher, &:value) }.should < measure{ enum.grep(matcher, &:value) } * speed_coef
+        expect(measure{ enum.in_threads.grep(matcher, &:value) }).to be < measure{ enum.grep(matcher, &:value) } * speed_coef
       end
 
       it "should return same without block" do
-        enum.in_threads.grep(matcher).should == enum.grep(matcher)
+        expect(enum.in_threads.grep(matcher)).to eq(enum.grep(matcher))
+      end
+
+      it "should raise exception in outer thread" do
+        check_test_exception(enum) do |threaded|
+          threaded.grep(matcher){ raise TestException }
+        end
       end
     end
 
@@ -406,14 +475,14 @@ describe "in_threads" do
       let(:runner){ proc{ |o| ValueItem.new(0, o).value } }
 
       it "should return same result with threads" do
-        enum.in_threads.each_entry(&runner).should == enum.each_entry(&runner)
+        expect(enum.in_threads.each_entry(&runner)).to eq(enum.each_entry(&runner))
       end
 
       it "should execute block for each element" do
         @order = double('order')
-        @order.should_receive(:notify).with(1).exactly(10).times.ordered
-        @order.should_receive(:notify).with([2, 3]).exactly(10).times.ordered
-        @order.should_receive(:notify).with([4, 5, 6]).exactly(10).times.ordered
+        expect(@order).to receive(:notify).with(1).exactly(10).times.ordered
+        expect(@order).to receive(:notify).with([2, 3]).exactly(10).times.ordered
+        expect(@order).to receive(:notify).with([4, 5, 6]).exactly(10).times.ordered
         @mutex = Mutex.new
         enum.in_threads.each_entry do |o|
           @mutex.synchronize{ @order.notify(o) }
@@ -422,11 +491,17 @@ describe "in_threads" do
       end
 
       it "should run faster with threads" do
-        measure{ enum.in_threads.each_entry(&runner) }.should < measure{ enum.each_entry(&runner) } * speed_coef
+        expect(measure{ enum.in_threads.each_entry(&runner) }).to be < measure{ enum.each_entry(&runner) } * speed_coef
       end
 
       it "should return same enum without block" do
-        enum.in_threads.each_entry.to_a.should == enum.each_entry.to_a
+        expect(enum.in_threads.each_entry.to_a).to eq(enum.each_entry.to_a)
+      end
+
+      it "should raise exception in outer thread" do
+        check_test_exception(enum) do |threaded|
+          threaded.each_entry{ raise TestException }
+        end
       end
     end
 
@@ -436,20 +511,26 @@ describe "in_threads" do
         let(:runner){ proc{ |a| a.map(&:value) } }
 
         it "should return same result with threads" do
-          enum.in_threads.send(method, &runner).should == enum.send(method, &runner)
+          expect(enum.in_threads.send(method, &runner)).to eq(enum.send(method, &runner))
         end
 
         it "should fire same objects" do
-          enum.send(method){ |a| a.each{ |o| o.should_receive(:touch).with(a).once } }
+          enum.send(method){ |a| a.each{ |o| expect(o).to receive(:touch).with(a).once } }
           enum.in_threads.send(method){ |a| a.each{ |o| o.touch_n_value(a) } }
         end
 
         it "should run faster with threads" do
-          measure{ enum.in_threads.send(method, &runner) }.should < measure{ enum.send(method, &runner) } * speed_coef
+          expect(measure{ enum.in_threads.send(method, &runner) }).to be < measure{ enum.send(method, &runner) } * speed_coef
         end
 
         it "should return same enum without block" do
-          enum.in_threads.send(method).to_a.should == enum.send(method).to_a
+          expect(enum.in_threads.send(method).to_a).to eq(enum.send(method).to_a)
+        end
+
+        it "should raise exception in outer thread" do
+          check_test_exception(enum) do |threaded|
+            threaded.send(method){ raise TestException }
+          end
         end
       end
     end
@@ -459,7 +540,13 @@ describe "in_threads" do
         describe method do
           it "should return same result" do
             combiner = proc{ |memo, o| memo + o.value }
-            enum.in_threads.send(method, 0, &combiner).should == enum.send(method, 0, &combiner)
+            expect(enum.in_threads.send(method, 0, &combiner)).to eq(enum.send(method, 0, &combiner))
+          end
+
+          it "should raise exception in outer thread" do
+            check_test_exception(enum) do |threaded|
+              threaded.send(method){ raise TestException }
+            end
           end
         end
       end
@@ -468,7 +555,13 @@ describe "in_threads" do
         describe method do
           it "should return same result" do
             comparer = proc{ |a, b| a.value <=> b.value }
-            enum.in_threads.send(method, &comparer).should == enum.send(method, &comparer)
+            expect(enum.in_threads.send(method, &comparer)).to eq(enum.send(method, &comparer))
+          end
+
+          it "should raise exception in outer thread" do
+            check_test_exception(enum) do |threaded|
+              threaded.send(method){ raise TestException }
+            end
           end
         end
       end
@@ -476,7 +569,7 @@ describe "in_threads" do
       %w[to_a entries].each do |method|
         describe method do
           it "should return same result" do
-            enum.in_threads.send(method).should == enum.send(method)
+            expect(enum.in_threads.send(method)).to eq(enum.send(method))
           end
         end
       end
@@ -484,7 +577,7 @@ describe "in_threads" do
       %w[drop take].each do |method|
         describe method do
           it "should return same result" do
-            enum.in_threads.send(method, 2).should == enum.send(method, 2)
+            expect(enum.in_threads.send(method, 2)).to eq(enum.send(method, 2))
           end
         end
       end
@@ -492,8 +585,8 @@ describe "in_threads" do
       %w[first].each do |method|
         describe method do
           it "should return same result" do
-            enum.in_threads.send(method).should == enum.send(method)
-            enum.in_threads.send(method, 3).should == enum.send(method, 3)
+            expect(enum.in_threads.send(method)).to eq(enum.send(method))
+            expect(enum.in_threads.send(method, 3)).to eq(enum.send(method, 3))
           end
         end
       end
@@ -501,7 +594,7 @@ describe "in_threads" do
       %w[include? member?].each do |method|
         describe method do
           it "should return same result" do
-            enum.in_threads.send(method, enum[10]).should == enum.send(method, enum[10])
+            expect(enum.in_threads.send(method, enum[10])).to eq(enum.send(method, enum[10]))
           end
         end
       end
@@ -510,14 +603,26 @@ describe "in_threads" do
         let(:runner){ proc{ |o, h| h[o.value] = true } }
 
         it "should return same result" do
-          enum.in_threads.each_with_object({}, &runner).should == enum.each_with_object({}, &runner)
+          expect(enum.in_threads.each_with_object({}, &runner)).to eq(enum.each_with_object({}, &runner))
+        end
+
+        it "should raise exception in outer thread" do
+          check_test_exception(enum) do |threaded|
+            threaded.each_with_object({}){ raise TestException }
+          end
         end
       end
 
       %w[chunk slice_before].each do |method|
         describe_enum_method method do
           it "should return same result" do
-            enum.in_threads.send(method, &:check?).to_a.should == enum.send(method, &:check?).to_a
+            expect(enum.in_threads.send(method, &:check?).to_a).to eq(enum.send(method, &:check?).to_a)
+          end
+
+          it "should raise exception in outer thread" do
+            check_test_exception(enum) do |threaded|
+              threaded.send(method){ raise TestException }.to_a
+            end
           end
         end
       end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: in_threads
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Ivan Kuchin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-06 00:00:00.000000000 Z
+date: 2014-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 description: 
 email: 
 executables: []
@@ -41,7 +41,6 @@ files:
 - lib/in_threads/filler.rb
 - lib/in_threads/thread_limiter.rb
 - spec/in_threads_spec.rb
-- spec/spec_helper.rb
 homepage: http://github.com/toy/in_threads
 licenses:
 - MIT
@@ -68,4 +67,4 @@ specification_version: 4
 summary: Execute ruby code in parallel
 test_files:
 - spec/in_threads_spec.rb
-- spec/spec_helper.rb
+has_rdoc: 

data/spec/spec_helper.rb

@@ -1,3 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'rspec'
-require 'in_threads'