in_threads 1.3.1 → 1.4.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    Mzk1MDRlMTMzNjc1OTBjMzIyYzA3ZTEyNTdlODk4NmM1ZjAzOTkzNA==
-  data.tar.gz: !binary |-
-    ZGM4ZTQ3N2YxM2M4NTgxODNiNWUzMTc1NWE5MjJlYWQ0MjE2NTY5Yw==
+SHA1:
+  metadata.gz: 3cd4f7083b8d1d0be3787fb95a747ac290882761
+  data.tar.gz: 7a8b5b3e65d59bcdc03be378a9f8d9f94d1b0535
 SHA512:
-  metadata.gz: !binary |-
-    MGQwMjZiZjU1NmE2NTVkYzdjOTU1OWMzNDA0MDkxNjFkNzQwOTNkZDAwYmQy
-    OWRkODZkMWE0ZTFmZjU0YjNhY2YyNjQyNmI2MDFkOGE2Y2FlOTIxNzU1ZWUx
-    Zjc1ZDE0NGI5Mjg1MjcxNTgyMmI4NWVkM2UyMTg4NDhjZDExMDc=
-  data.tar.gz: !binary |-
-    OGFmODBhMDljYzNjZDdmYmI5YjBhNmI0NzA4NzgxYTk4OTUwODM5YThhNmQ0
-    MDAzMGU2ZTIwNGU4ZjlmNGZjNDBjNjgxNTZhMTA2NzAwZWJhODQyNDFlODlj
-    YzYyZWIwYjUyOGUzM2ExMGNhOTIwZmI5NWEzODBlN2E2YWU2OTY=
+  metadata.gz: 6d7547364ef110ff2cb51e8e57441028e694bfae5d54e7c44ae63b58599aefa4523fda5531a90af5d0e54dc0415c365b024d6ab585481862ffa4868ca47e6992
+  data.tar.gz: 22b699ee74f26862c5cf7a844d7aaf6f77af5a50d4d7ce0c287c8682fa577b6dbadca1c207282673b9da36d7f68bff90d6bfde0ea343b81ae28dd2835cc31c68

data/.rubocop.yml

@@ -3,22 +3,29 @@ AllCops:
     - '*.gemspec'
 
 Lint/EndAlignment:
-  AlignWith: variable
+  EnforcedStyleAlignWith: variable
 
 Metrics/AbcSize:
   Max: 25
 
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*.rb'
+
 Metrics/ClassLength:
   Max: 150
 
 Metrics/MethodLength:
   Max: 25
 
+Performance/RedundantBlockCall:
+  Enabled: false
+
 Style/AccessModifierIndentation:
   EnforcedStyle: outdent
 
 Style/CaseIndentation:
-  IndentWhenRelativeTo: end
+  EnforcedStyle: end
 
 Style/DotPosition:
   EnforcedStyle: trailing
@@ -38,6 +45,9 @@ Style/IfUnlessModifier:
 Style/IndentHash:
   EnforcedStyle: consistent
 
+Style/ParallelAssignment:
+  Enabled: false
+
 Style/PercentLiteralDelimiters:
   PreferredDelimiters:
     '%w': '[]'
@@ -46,11 +56,17 @@ Style/PercentLiteralDelimiters:
 Style/Semicolon:
   AllowAsExpressionSeparator: true
 
+Style/SignalException:
+  EnforcedStyle: semantic
+
 Style/SpaceBeforeBlockBraces:
   EnforcedStyle: no_space
 
 Style/SpaceInsideHashLiteralBraces:
   EnforcedStyle: no_space
 
-Style/TrailingComma:
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: no_comma
+
+Style/TrailingCommaInLiteral:
   EnforcedStyleForMultiline: comma

data/.travis.yml

@@ -1,22 +1,25 @@
+sudo: false
 language: ruby
 rvm:
-  - 1.8.7
-  - 1.9.2
-  - 1.9.3
-  - '2.0'
-  - '2.1'
-  - '2.2'
-  - jruby-18mode
-  - jruby-19mode
-  - ree
-script:
-  if [ -z "$RUBOCOP" ]; then
-    bundle exec rspec
-  ; else
-    bundle exec rubocop
-  ; fi
+  - '1.8.7-p371'
+  - '1.9.3-p551'
+  - '2.0.0-p648'
+  - '2.1.10'
+  - '2.2.6'
+  - '2.3.3'
+  - '2.4.0'
+  - 'ruby-head'
+  - 'jruby-1.7.26'
+  - 'jruby-9.0.5.0'
+  - 'jruby-9.1.5.0'
+script: bundle exec rspec
 matrix:
-  fast_finish: true
   include:
-    - env: RUBOCOP=true
-      rvm: default
+    - env: RUBOCOP=✓
+      rvm: '2.4.0'
+      script: bundle exec rubocop
+    - env: CHECK_RUBIES=✓
+      rvm: '2.4.0'
+      script: bundle exec travis_check_rubies
+  allow_failures:
+    - rvm: 'ruby-head'

data/Gemfile

@@ -1,3 +1,7 @@
 source 'https://rubygems.org'
 
 gemspec
+
+if RUBY_VERSION >= '2.0'
+  gem 'travis_check_rubies', '~> 0.2'
+end

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2015 Ivan Kuchin
+Copyright (c) 2010-2017 Ivan Kuchin
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -2,40 +2,98 @@
 [![Build Status](https://img.shields.io/travis/toy/in_threads/master.svg?style=flat)](https://travis-ci.org/toy/in_threads)
 [![Code Climate](https://img.shields.io/codeclimate/github/toy/in_threads.svg?style=flat)](https://codeclimate.com/github/toy/in_threads)
 [![Dependency Status](https://img.shields.io/gemnasium/toy/in_threads.svg?style=flat)](https://gemnasium.com/toy/in_threads)
-[![Inch CI](http://inch-ci.org/github/toy/in_threads.svg?branch=master&style=flat)](http://inch-ci.org/github/toy/in_threads)
+[![Inch CI](https://inch-ci.org/github/toy/in_threads.svg?branch=master&style=flat)](https://inch-ci.org/github/toy/in_threads)
 
 # in_threads
 
-Easily execute ruby code in parallel.
+Easily execute Ruby code in parallel.
+
+```ruby
+urls.in_threads(20).map do |url|
+  HTTP.get(url)
+end
+```
 
 ## Installation
 
-    gem install in_threads
+Add the gem to your Gemfile...
+
+```ruby
+gem 'in_threads'
+```
+
+...and install it with [Bundler](http://bundler.io).
+
+```sh
+$ bundle install
+```
+
+Or, if you don't use Bundler, install it globally:
+
+```sh
+$ gem install in_threads
+```
 
 ## Usage
 
-By default there is maximum of 10 simultaneous threads
+Let's say you have a list of web pages to download.
+
+```ruby
+urls = [
+  "https://google.com",
+  "https://en.wikipedia.org/wiki/Ruby",
+  "https://news.ycombinator.com",
+  "https://github.com/trending"
+]
+```
+
+You can easily download each web page one after the other.
+
+```ruby
+urls.each do |url|
+  HTTP.get(url)
+end
+```
+
+However, this is slow, especially for a large number of web pages. Instead,
+download the web pages in parallel with `in_threads`.
+
+```ruby
+require 'in_threads'
+
+urls.in_threads.each do |url|
+  HTTP.get(url)
+end
+```
+
+By calling `in_threads`, the each web page is downloaded in its own thread,
+reducing the time by almost 4x.
+
+By default, no more than 10 threads run at any one time. However, this can be
+easily overriden.
 
-    urls.in_threads.map do |url|
-      url.fetch
-    end
+```ruby
+# Read all XML files in a directory
+Dir['*.xml'].in_threads(100).each do |file|
+  File.read(file)
+end
+```
 
-    urls.in_threads.each do |url|
-      url.save_to_disk
-    end
+Predicate methods (methods that return `true` or `false` for each object in a
+collection) are particularly well suited for use with `in_threads`.
 
-    numbers.in_threads(2).map do |number|
-      # whery long and complicated formula
-      # using only 2 threads
-    end
+```ruby
+# Are all URLs valid?
+urls.in_threads.all? { |url| HTTP.get(url).status == 200 }
 
-You can use any Enumerable method, but some of them can not use threads (`inject`, `reduce`) or don't use blocks (`to_a`, `entries`, `drop`, `take`, `first`, `include?`, `member?`) or have both problems depending on usage type (`min`, `max`, `minmax`, `sort`)
+# Are any URLs invalid?
+urls.in_threads.any? { |url| HTTP.get(url).status == 404 }
+```
 
-    urls.in_threads.any?(&:ok?)
-    urls.in_threads.all?(&:ok?)
-    urls.in_threads.none?(&:error?)
-    urls.in_threads.grep(/example\.com/, &:fetch)
+You can call any `Enumerable` method, but some (`#inject`, `#reduce`, `#max`,
+`#min`, `#sort`, `#to_a`, and others) cannot run concurrently, and so will
+simply act as if `in_threads` wasn't used.
 
 ## Copyright
 
-Copyright (c) 2010-2015 Ivan Kuchin. See LICENSE.txt for details.
+Copyright (c) 2010-2017 Ivan Kuchin. See LICENSE.txt for details.

data/in_threads.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'in_threads'
-  s.version     = '1.3.1'
+  s.version     = '1.4.0'
   s.summary     = %q{Execute ruby code in parallel}
   s.homepage    = "http://github.com/toy/#{s.name}"
   s.authors     = ['Ivan Kuchin']
@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'rspec-retry', '~> 0.3'
-  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('1.9.3')
-    s.add_development_dependency 'rubocop', '~> 0.26'
+  if RUBY_VERSION >= '2.0'
+    s.add_development_dependency 'rubocop', '~> 0.47'
   end
 end

data/lib/in_threads.rb

@@ -57,11 +57,8 @@ class InThreads < SimpleDelegator
     # Add thread to `ThreadsWait`, wait for finishing of one thread if limit
     # reached
     def <<(thread)
-      if @waiter.threads.length + 1 >= @count
-        @waiter.join(thread).join
-      else
-        @waiter.join_nowait(thread)
-      end
+      @waiter.join_nowait(thread)
+      @waiter.next_wait.join unless @waiter.threads.length < @count
     end
 
     # Wait for waiting threads
@@ -74,32 +71,23 @@ class InThreads < SimpleDelegator
   class Splitter
     # Enumerable using Queue
     class Transfer
-      # Holds one object, for distinguishing eof
-      class Item
-        attr_reader :value
-
-        def initialize(value)
-          @value = value
-        end
-      end
-
       include Enumerable
 
       def initialize
         @queue = Queue.new
       end
 
-      def <<(object)
-        @queue << Item.new(object)
+      def <<(args)
+        @queue << args
       end
 
       def finish
         @queue << nil
       end
 
-      def each
-        while (o = @queue.pop)
-          yield o.value
+      def each(&block)
+        while (args = @queue.pop)
+          block.call(*args)
         end
         nil # non reusable
       end
@@ -111,9 +99,9 @@ class InThreads < SimpleDelegator
     def initialize(enumerable, enum_count)
       @enums = Array.new(enum_count){ Transfer.new }
       @filler = Thread.new do
-        enumerable.each do |o|
+        enumerable.each do |*args|
           @enums.each do |enum|
-            enum << o
+            enum << args
           end
         end
         @enums.each(&:finish)
@@ -151,9 +139,8 @@ class InThreads < SimpleDelegator
       methods = Array(options[:for])
       fail 'no methods provided using :for option' if methods.empty?
       ignore_undefined = options[:ignore_undefined]
-      enumerable_methods = Enumerable.instance_methods.map(&:to_s)
       methods.each do |method|
-        next if ignore_undefined && !enumerable_methods.include?(method)
+        next if ignore_undefined && !enumerable_method?(method)
         class_eval <<-RUBY
           def #{method}(*args, &block)
             #{runner}(:#{method}, *args, &block)
@@ -161,6 +148,13 @@ class InThreads < SimpleDelegator
         RUBY
       end
     end
+
+  private
+
+    def enumerable_method?(name)
+      @enumerable_methods ||= Enumerable.instance_methods.map(&:to_sym)
+      @enumerable_methods.include?(name.to_sym)
+    end
   end
 
   use :run_in_threads_return_original_enum, :for => %w[each]
@@ -176,7 +170,7 @@ class InThreads < SimpleDelegator
     all? any? none? one?
     detect find find_index drop_while take_while
     partition find_all select reject count
-    collect map group_by max_by min_by minmax_by sort_by
+    collect map group_by max_by min_by minmax_by sort_by sum uniq
     flat_map collect_concat
   ], :ignore_undefined => true
 
@@ -188,7 +182,7 @@ class InThreads < SimpleDelegator
     first
     include? member?
     each_with_object
-    chunk slice_before slice_after slice_when
+    chunk chunk_while slice_before slice_after slice_when
   ].map(&:to_sym)
 
   # Special case method, works by applying `run_in_threads_consecutive` with
@@ -201,6 +195,18 @@ class InThreads < SimpleDelegator
     end
   end
 
+  if enumerable_method?(:grep_v)
+    # Special case method, works by applying `run_in_threads_consecutive` with
+    # map on enumerable returned by blockless run
+    def grep_v(*args, &block)
+      if block
+        self.class.new(enumerable.grep_v(*args), thread_count).map(&block)
+      else
+        enumerable.grep_v(*args)
+      end
+    end
+  end
+
   # befriend with progress gem
   def with_progress(title = nil, length = nil, &block)
     ::Progress::WithProgress.new(self, title, length, &block)
@@ -213,7 +219,7 @@ protected
     if block
       ThreadLimiter.limit(thread_count) do |limiter|
         enumerable.send(method, *args) do |*block_args|
-          limiter << Thread.new(*block_args, &block)
+          limiter << Thread.new{ block.call(*block_args) }
         end
       end
     else
@@ -229,9 +235,9 @@ protected
       runner = Thread.new do
         Thread.current.priority = -1
         ThreadLimiter.limit(thread_count) do |limiter|
-          enum_a.each do |object|
+          enum_a.each do |*block_args|
             break if Thread.current[:stop]
-            thread = Thread.new(object, &block)
+            thread = Thread.new{ block.call(*block_args) }
             results << thread
             limiter << thread
           end
@@ -239,7 +245,7 @@ protected
       end
 
       begin
-        enum_b.send(method, *args) do |_object|
+        enum_b.send(method, *args) do
           results.pop.value
         end
       ensure

data/spec/in_threads_spec.rb

@@ -18,7 +18,7 @@ class ValueItem
   end
 
   def ==(other)
-    id == other.id
+    id == other.id if other.is_a?(self.class)
   end
 
   def value
@@ -67,24 +67,41 @@ class RandItem < ValueItem
   end
 end
 
+# Pure class with Enumerable instead of Array
+class TestEnum
+  include Enumerable
+
+  def initialize(count, &block)
+    @items = Array.new(count){ |i| block[i] }
+  end
+
+  def each(&block)
+    @items.each(&block)
+    self
+  end
+end
+
 class TestException < StandardError; end
 
+ENUM_METHODS = Enumerable.instance_methods.map(&:to_s)
 def describe_enum_method(method, &block)
-  @enum_methods ||= Enumerable.instance_methods.map(&:to_s)
-  if @enum_methods.include?(method)
-    describe(method, &block)
+  if ENUM_METHODS.include?(method)
+    describe "##{method}", &block
   else
-    it 'should not be defined' do
-      exception_regexp =
-        /^undefined method `#{Regexp.escape(method)}' .*\bInThreads\b/
-      expect{ enum.in_threads.send(method) }.
-        to raise_error(NoMethodError, exception_regexp)
+    describe "##{method}" do
+      it 'is not defined' do
+        exception_regexp =
+          /^undefined method `#{Regexp.escape(method)}' .*\bInThreads\b/
+        expect{ enum.in_threads.send(method) }.
+          to raise_error(NoMethodError, exception_regexp)
+      end
     end
   end
 end
 
 describe 'in_threads' do
-  let(:enum){ 30.times.map{ |i| RandItem.new(i) } }
+  let(:items){ Array.new(30){ |i| RandItem.new(i) } }
+  let(:enum){ TestEnum.new(items) }
 
   # small coefficient, should be more if sleep time coefficient is bigger
   let(:speed_coef){ 0.666 }
@@ -97,32 +114,32 @@ describe 'in_threads' do
 
   describe 'consistency' do
     describe 'verifying params' do
-      it 'should complain about using with non enumerable' do
+      it 'complains about using with non enumerable' do
         expect{ InThreads.new(1) }.to raise_error(ArgumentError)
       end
 
       [1..10, 10.times, {}, []].each do |o|
-        it "should not complain about using with #{o.class}" do
+        it "does not complain about using with #{o.class}" do
           expect{ InThreads.new(o) }.not_to raise_error
         end
       end
 
-      it 'should complain about using less than 2 threads' do
+      it 'complains about using less than 2 threads' do
         expect{ 10.times.in_threads(1) }.to raise_error(ArgumentError)
       end
 
-      it 'should not complain about using 2 or more threads' do
+      it 'does not complain about using 2 or more threads' do
         expect{ 10.times.in_threads(2) }.not_to raise_error
       end
     end
 
     describe 'in_threads method' do
-      it 'should not change existing instance' do
+      it 'does not change existing instance' do
         threaded = enum.in_threads(10)
         expect{ threaded.in_threads(20) }.not_to change(threaded, :thread_count)
       end
 
-      it 'should create new instance with different title when called on '\
+      it 'creates new instance with different title when called on '\
           'WithProgress' do
         threaded = enum.in_threads(10)
         tthreaded = threaded.in_threads(20)
@@ -135,10 +152,10 @@ describe 'in_threads' do
     end
 
     describe 'thread count' do
-      let(:enum){ 100.times.map{ |i| ValueItem.new(i, i < 50) } }
+      let(:items){ Array.new(100){ |i| ValueItem.new(i, i < 50) } }
 
       %w[each map all?].each do |method|
-        it "should run in specified number of threads for #{method}" do
+        it "runs in specified number of threads for #{method}" do
           @thread_count = 0
           @max_thread_count = 0
           @mutex = Mutex.new
@@ -161,15 +178,15 @@ describe 'in_threads' do
 
     describe 'underlying enumerable usage' do
       %w[each map all?].each do |method|
-        it "should call underlying enumerable.each only once for #{method}" do
-          enum = 100.times.map{ |i| ValueItem.new(i, i < 50) }
+        it "calls underlying enumerable.each only once for #{method}" do
+          enum = Array.new(100){ |i| ValueItem.new(i, i < 50) }
 
           expect(enum).to receive(:each).once.and_call_original
           enum.in_threads(13).send(method, &:check?)
         end
       end
 
-      it 'should not yield all elements when not needed' do
+      it 'does not yield all elements when not needed' do
         enum = []
         def enum.each
           100.times{ yield 1 }
@@ -179,6 +196,37 @@ describe 'in_threads' do
         enum.in_threads(13).all?{ false }
       end
     end
+
+    describe 'block arguments' do
+      before do
+        def enum.each
+          yield
+          yield 1
+          yield 2, 3
+          yield 4, 5, 6
+        end
+      end
+
+      it 'passes all to methods ignoring block result' do
+        o = double
+        enum.each do |*args|
+          expect(o).to receive(:notify).with(args)
+        end
+        enum.in_threads.each do |*args|
+          o.notify(args)
+        end
+      end
+
+      it 'passes all to methods using block result' do
+        o = double
+        enum.each do |*args|
+          expect(o).to receive(:notify).with(args)
+        end
+        enum.in_threads.map do |*args|
+          o.notify(args)
+        end
+      end
+    end
   end
 
   describe 'methods' do
@@ -193,31 +241,31 @@ describe 'in_threads' do
       expect{ block[enum.in_threads(1000)] }.to raise_exception(TestException)
     end
 
-    describe 'each' do
-      it 'should return same enum after running' do
+    describe '#each' do
+      it 'returns same enum after running' do
         expect(enum.in_threads.each(&:value)).to eq(enum)
       end
 
-      it 'should execute block for each element' do
+      it 'executes block for each element' do
         enum.each{ |o| expect(o).to receive(:touch).once }
         enum.in_threads.each(&:touch_n_value)
       end
 
-      it 'should run faster with threads', :retry => 3 do
+      it 'runs faster with threads', :retry => 3 do
         expect(measure{ enum.in_threads.each(&:value) }).
           to be < measure{ enum.each(&:value) } * speed_coef
       end
 
-      it 'should run faster with more threads', :retry => 3 do
+      it 'runs faster with more threads', :retry => 3 do
         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
+      it 'returns same enum without block' do
         expect(enum.in_threads.each.to_a).to eq(enum.each.to_a)
       end
 
-      it 'should raise exception in outer thread' do
+      it 'raises exception in outer thread' do
         check_test_exception(enum) do |threaded|
           threaded.each{ fail TestException }
         end
@@ -228,27 +276,27 @@ describe 'in_threads' do
       describe_enum_method method do
         let(:runner){ proc{ |o, _i| o.value } }
 
-        it 'should return same result with threads' do
+        it 'returns same result with threads' do
           expect(enum.in_threads.send(method, &runner)).
             to eq(enum.send(method, &runner))
         end
 
-        it 'should fire same objects' do
+        it 'fires same objects' do
           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', :retry => 3 do
+        it 'runs faster with threads', :retry => 3 do
           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
+        it 'returns same enum without block' do
           expect(enum.in_threads.send(method).to_a).
             to eq(enum.send(method).to_a)
         end
 
-        it 'should raise exception in outer thread' do
+        it 'raises exception in outer thread' do
           check_test_exception(enum) do |threaded|
             threaded.send(method){ fail TestException }
           end
@@ -256,18 +304,18 @@ describe 'in_threads' do
       end
     end
 
-    describe 'reverse_each' do
-      it 'should return same result with threads' do
+    describe '#reverse_each' do
+      it 'returns same result with threads' do
         expect(enum.in_threads.reverse_each(&:value)).
           to eq(enum.reverse_each(&:value))
       end
 
-      it 'should fire same objects in reverse order' do
+      it 'fires same objects in reverse order' do
         @order = double('order', :notify => nil)
-        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 }
+        expect(@order).to receive(:notify).with(items.last).ordered
+        expect(@order).to receive(:notify).with(items[items.length / 2]).ordered
+        expect(@order).to receive(:notify).with(items.first).ordered
+        enum.each{ |o| expect(o).to receive(:touch).once }
         @mutex = Mutex.new
         enum.in_threads.reverse_each do |o|
           @mutex.synchronize{ @order.notify(o) }
@@ -275,16 +323,16 @@ describe 'in_threads' do
         end
       end
 
-      it 'should run faster with threads', :retry => 3 do
+      it 'runs faster with threads', :retry => 3 do
         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
+      it 'returns same enum without block' do
         expect(enum.in_threads.reverse_each.to_a).to eq(enum.reverse_each.to_a)
       end
 
-      it 'should raise exception in outer thread' do
+      it 'raises exception in outer thread' do
         check_test_exception(enum) do |threaded|
           threaded.reverse_each{ fail TestException }
         end
@@ -295,15 +343,15 @@ describe 'in_threads' do
       all? any? none? one?
       detect find find_index drop_while take_while
     ].each do |method|
-      describe method do
-        let(:enum){ 100.times.map{ |i| ValueItem.new(i, i.odd?) } }
+      describe "##{method}" do
+        let(:items){ Array.new(100){ |i| ValueItem.new(i, i.odd?) } }
 
-        it 'should return same result with threads' do
+        it 'returns same result with threads' do
           expect(enum.in_threads.send(method, &:check?)).
             to eq(enum.send(method, &:check?))
         end
 
-        it 'should fire same objects but not all' do
+        it 'fires same objects but not all' do
           a = []
           enum.send(method) do |o|
             a << o
@@ -318,17 +366,17 @@ describe 'in_threads' do
           end
 
           expect(@a.length).to be >= a.length
-          expect(@a.length).to be <= enum.length * 0.5
+          expect(@a.length).to be <= items.length * 0.5
         end
 
-        it 'should run faster with threads', :retry => 3 do
+        it 'runs faster with threads', :retry => 3 do
           boolean = %w[all? drop_while take_while].include?(method)
-          enum = 30.times.map{ |i| ValueItem.new(i, boolean) }
+          enum = Array.new(30){ |i| ValueItem.new(i, boolean) }
           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
+        it 'raises exception in outer thread' do
           check_test_exception(enum) do |threaded|
             threaded.send(method){ fail TestException }
           end
@@ -337,23 +385,23 @@ describe 'in_threads' do
     end
 
     %w[partition find_all select reject count].each do |method|
-      describe method do
-        it 'should return same result with threads' do
+      describe "##{method}" do
+        it 'returns same result with threads' do
           expect(enum.in_threads.send(method, &:check?)).
             to eq(enum.send(method, &:check?))
         end
 
-        it 'should fire same objects' do
+        it 'fires same objects' do
           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', :retry => 3 do
+        it 'runs faster with threads', :retry => 3 do
           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
+        it 'raises exception in outer thread' do
           check_test_exception(enum) do |threaded|
             threaded.send(method){ fail TestException }
           end
@@ -361,24 +409,28 @@ describe 'in_threads' do
       end
     end
 
-    %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
+    %w[
+      collect map
+      group_by max_by min_by minmax_by sort_by
+      sum uniq
+    ].each do |method|
+      describe_enum_method method do
+        it 'returns same result with threads' do
           expect(enum.in_threads.send(method, &:value)).
             to eq(enum.send(method, &:value))
         end
 
-        it 'should fire same objects' do
+        it 'fires same objects' do
           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', :retry => 3 do
+        it 'runs faster with threads', :retry => 3 do
           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
+        it 'raises exception in outer thread' do
           check_test_exception(enum) do |threaded|
             threaded.send(method){ fail TestException }
           end
@@ -390,29 +442,29 @@ describe 'in_threads' do
       describe_enum_method method do
         let(:runner){ proc{ |a| a.each(&:value) } }
 
-        it 'should fire same objects' do
+        it 'fires same objects' do
           enum.send(method, 3) do |a|
             expect(a.first).to receive(:touch).with(a).once
           end
           enum.in_threads.send(method, 3){ |a| a.first.touch_n_value(a) }
         end
 
-        it 'should return same with block' do
+        it 'returns same with block' do
           expect(enum.in_threads.send(method, 3, &runner)).
             to eq(enum.send(method, 3, &runner))
         end
 
-        it 'should run faster with threads', :retry => 3 do
+        it 'runs faster with threads', :retry => 3 do
           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
+        it 'returns same without block' do
           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
+        it 'raises exception in outer thread' do
           check_test_exception(enum) do |threaded|
             threaded.send(method, 3){ fail TestException }
           end
@@ -420,10 +472,10 @@ describe 'in_threads' do
       end
     end
 
-    describe 'zip' do
+    describe '#zip' do
       let(:runner){ proc{ |a| a.each(&:value) } }
 
-      it 'should fire same objects' do
+      it 'fires same objects' do
         enum.zip(enum, enum) do |a|
           expect(a.first).to receive(:touch).with(a).once
         end
@@ -433,119 +485,125 @@ describe 'in_threads' do
         end
       end
 
-      it 'should return same with block' do
+      it 'returns same with block' do
         expect(enum.in_threads.zip(enum, enum, &runner)).
           to eq(enum.zip(enum, enum, &runner))
       end
 
-      it 'should run faster with threads', :retry => 3 do
+      it 'runs faster with threads', :retry => 3 do
         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
+      it 'returns same without block' do
         expect(enum.in_threads.zip(enum, enum)).to eq(enum.zip(enum, enum))
       end
 
-      it 'should raise exception in outer thread' do
+      it 'raises exception in outer thread' do
         check_test_exception(enum) do |threaded|
           threaded.zip(enum, enum){ fail TestException }
         end
       end
     end
 
-    describe 'cycle' do
-      it 'should fire same objects' do
+    describe '#cycle' do
+      it 'fires same objects' do
         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', :retry => 3 do
+      it 'runs faster with threads', :retry => 3 do
         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
+      it 'returns same enum without block' do
         expect(enum.in_threads.cycle(3).to_a).to eq(enum.cycle(3).to_a)
       end
 
-      it 'should raise exception in outer thread' do
+      it 'raises exception in outer thread' do
         check_test_exception(enum) do |threaded|
           threaded.cycle{ fail TestException }
         end
       end
     end
 
-    describe 'grep' do
-      let(:matcher){ ValueItem::FastCheckMatcher }
-
-      it 'should fire same objects' do
-        enum.each do |o|
-          expect(o).to receive(:touch).exactly(o.fast_check? ? 1 : 0).times
+    %w[grep grep_v].each do |method|
+      describe_enum_method method do
+        let(:matcher){ ValueItem::FastCheckMatcher }
+
+        it 'fires same objects' do
+          enum.each do |o|
+            if o.fast_check? == (method == 'grep')
+              expect(o).to receive(:touch)
+            else
+              expect(o).not_to receive(:touch)
+            end
+          end
+          enum.in_threads.send(method, matcher, &:touch_n_value)
         end
-        enum.in_threads.grep(matcher, &:touch_n_value)
-      end
 
-      it 'should return same with block' do
-        expect(enum.in_threads.grep(matcher, &:value)).
-          to eq(enum.grep(matcher, &:value))
-      end
+        it 'returns same with block' do
+          expect(enum.in_threads.send(method, matcher, &:value)).
+            to eq(enum.send(method, matcher, &:value))
+        end
 
-      it 'should run faster with threads', :retry => 3 do
-        expect(measure{ enum.in_threads.grep(matcher, &:value) }).
-          to be < measure{ enum.grep(matcher, &:value) } * speed_coef
-      end
+        it 'runs faster with threads', :retry => 3 do
+          expect(measure{ enum.in_threads.send(method, matcher, &:value) }).
+            to be < measure{ enum.send(method, matcher, &:value) } * speed_coef
+        end
 
-      it 'should return same without block' do
-        expect(enum.in_threads.grep(matcher)).to eq(enum.grep(matcher))
-      end
+        it 'returns same without block' do
+          expect(enum.in_threads.send(method, matcher)).
+            to eq(enum.send(method, matcher))
+        end
 
-      it 'should raise exception in outer thread' do
-        check_test_exception(enum) do |threaded|
-          threaded.grep(matcher){ fail TestException }
+        it 'raises exception in outer thread' do
+          check_test_exception(enum) do |threaded|
+            threaded.send(method, matcher){ fail TestException }
+          end
         end
       end
     end
 
     describe_enum_method 'each_entry' do
-      let(:enum) do
-        [].tap do |enum|
-          def enum.each
-            10.times{ yield 1 }
-            10.times{ yield 2, 3 }
-            10.times{ yield 4, 5, 6 }
-          end
+      before do
+        def enum.each
+          10.times{ yield }
+          10.times{ yield 1 }
+          10.times{ yield 2, 3 }
+          10.times{ yield 4, 5, 6 }
         end
       end
       let(:runner){ proc{ |o| ValueItem.new(0, o).value } }
 
-      it 'should return same result with threads' do
+      it 'returns same result with threads' do
         expect(enum.in_threads.each_entry(&runner)).
           to eq(enum.each_entry(&runner))
       end
 
-      it 'should execute block for each element' do
+      it 'executes block for each element' do
         @o = double('order')
-        expect(@o).to receive(:notify).with(1).exactly(10).times.ordered
-        expect(@o).to receive(:notify).with([2, 3]).exactly(10).times.ordered
-        expect(@o).to receive(:notify).with([4, 5, 6]).exactly(10).times.ordered
+        enum.each_entry do |*o|
+          expect(@o).to receive(:notify).with(o)
+        end
         @mutex = Mutex.new
-        enum.in_threads.each_entry do |o|
+        enum.in_threads.each_entry do |*o|
           @mutex.synchronize{ @o.notify(o) }
           runner[]
         end
       end
 
-      it 'should run faster with threads', :retry => 3 do
+      it 'runs faster with threads', :retry => 3 do
         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
+      it 'returns same enum without block' do
         expect(enum.in_threads.each_entry.to_a).to eq(enum.each_entry.to_a)
       end
 
-      it 'should raise exception in outer thread' do
+      it 'raises exception in outer thread' do
         check_test_exception(enum) do |threaded|
           threaded.each_entry{ fail TestException }
         end
@@ -554,15 +612,15 @@ describe 'in_threads' do
 
     %w[flat_map collect_concat].each do |method|
       describe_enum_method method do
-        let(:enum){ 20.times.map{ |i| RandItem.new(i) }.each_slice(3) }
+        let(:items){ Array.new(20){ |i| RandItem.new(i) }.each_slice(3).to_a }
         let(:runner){ proc{ |a| a.map(&:value) } }
 
-        it 'should return same result with threads' do
+        it 'returns same result with threads' do
           expect(enum.in_threads.send(method, &runner)).
             to eq(enum.send(method, &runner))
         end
 
-        it 'should fire same objects' do
+        it 'fires same objects' do
           enum.send(method) do |a|
             a.each do |o|
               expect(o).to receive(:touch).with(a).once
@@ -576,17 +634,17 @@ describe 'in_threads' do
           end
         end
 
-        it 'should run faster with threads', :retry => 3 do
+        it 'runs faster with threads', :retry => 3 do
           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
+        it 'returns same enum without block' do
           expect(enum.in_threads.send(method).to_a).
             to eq(enum.send(method).to_a)
         end
 
-        it 'should raise exception in outer thread' do
+        it 'raises exception in outer thread' do
           check_test_exception(enum) do |threaded|
             threaded.send(method){ fail TestException }
           end
@@ -596,14 +654,14 @@ describe 'in_threads' do
 
     context 'unthreaded' do
       %w[inject reduce].each do |method|
-        describe method do
-          it 'should return same result' do
+        describe "##{method}" do
+          it 'returns same result' do
             combiner = proc{ |memo, o| memo + o.value }
             expect(enum.in_threads.send(method, 0, &combiner)).
               to eq(enum.send(method, 0, &combiner))
           end
 
-          it 'should raise exception in outer thread' do
+          it 'raises exception in outer thread' do
             check_test_exception(enum) do |threaded|
               threaded.send(method){ fail TestException }
             end
@@ -612,14 +670,14 @@ describe 'in_threads' do
       end
 
       %w[max min minmax sort].each do |method|
-        describe method do
-          it 'should return same result' do
+        describe "##{method}" do
+          it 'returns same result' do
             comparer = proc{ |a, b| a.value <=> b.value }
             expect(enum.in_threads.send(method, &comparer)).
               to eq(enum.send(method, &comparer))
           end
 
-          it 'should raise exception in outer thread' do
+          it 'raises exception in outer thread' do
             check_test_exception(enum) do |threaded|
               threaded.send(method){ fail TestException }
             end
@@ -628,24 +686,24 @@ describe 'in_threads' do
       end
 
       %w[to_a entries].each do |method|
-        describe method do
-          it 'should return same result' do
+        describe "##{method}" do
+          it 'returns same result' do
             expect(enum.in_threads.send(method)).to eq(enum.send(method))
           end
         end
       end
 
       %w[drop take].each do |method|
-        describe method do
-          it 'should return same result' do
+        describe "##{method}" do
+          it 'returns same result' do
             expect(enum.in_threads.send(method, 2)).to eq(enum.send(method, 2))
           end
         end
       end
 
       %w[first].each do |method|
-        describe method do
-          it 'should return same result' do
+        describe "##{method}" do
+          it 'returns same result' do
             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
@@ -653,10 +711,10 @@ describe 'in_threads' do
       end
 
       %w[include? member?].each do |method|
-        describe method do
-          it 'should return same result' do
-            expect(enum.in_threads.send(method, enum[10])).
-              to eq(enum.send(method, enum[10]))
+        describe "##{method}" do
+          it 'returns same result' do
+            expect(enum.in_threads.send(method, items[10])).
+              to eq(enum.send(method, items[10]))
           end
         end
       end
@@ -664,26 +722,26 @@ describe 'in_threads' do
       describe_enum_method 'each_with_object' do
         let(:runner){ proc{ |o, h| h[o.value] = true } }
 
-        it 'should return same result' do
+        it 'returns same result' do
           expect(enum.in_threads.each_with_object({}, &runner)).
             to eq(enum.each_with_object({}, &runner))
         end
 
-        it 'should raise exception in outer thread' do
+        it 'raises exception in outer thread' do
           check_test_exception(enum) do |threaded|
             threaded.each_with_object({}){ fail TestException }
           end
         end
       end
 
-      %w[chunk slice_before].each do |method|
+      %w[chunk slice_before slice_after].each do |method|
         describe_enum_method method do
-          it 'should return same result' do
+          it 'returns same result' do
             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
+          it 'raises exception in outer thread' do
             check_test_exception(enum) do |threaded|
               threaded.send(method){ fail TestException }.to_a
             end

metadata

@@ -1,66 +1,66 @@
 --- !ruby/object:Gem::Specification
 name: in_threads
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Ivan Kuchin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-09 00:00:00.000000000 Z
+date: 2017-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rspec-retry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.26'
+        version: '0.47'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.26'
+        version: '0.47'
 description: 
 email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rubocop.yml
-- .travis.yml
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.markdown
@@ -78,21 +78,20 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: in_threads
-rubygems_version: 2.4.5
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: Execute ruby code in parallel
 test_files:
 - spec/in_threads_spec.rb
 - spec/spec_helper.rb
-has_rdoc: