in_threads 1.2.2 → 1.3.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YzcyOTliODQ1ZDMyYmY1NDRiMTEyZTc4ODI0ZGViNTQ3MDJmODNhMQ==
-  data.tar.gz: !binary |-
-    ZWNlZTE1ZjE5NmNlYzdiOWM4Y2YxNjJiMDVlYjVmMjQ2ZGY1OTM0MQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    MDJkYjFlZDRiMTJiZjc2OTU0NWM2NGJjMWU2MjQ3YzdkZDQ3OTkxZTY0N2Uw
-    OWRjMTc4ODFjZTM5MTM1OGUxNDlkMTMxZGI2OTljZTRmZjAwYTZjY2I3OTMw
-    ZDU0YTFhODA2YzFiOWNiZDlmNzBkYmQwZWU3MWJlOWRjYmI4MmU=
-  data.tar.gz: !binary |-
-    MDgzOWFkYmIwZjEzZDVlYjcyYTZlMjU4YzQwZTYyYThmNWM0MzExMjk4ZTY5
-    NWIwOTlhMTA3Y2UyMjA0NzYxYTA5NTcyZWVlNmU1M2Q2M2E1ODRmNWU2OGU2
-    ZjBlMzI0MTI2MWMzNTA3OWM2MDdkM2MxZWZlOGE3ZDc2NGQyNTU=
+SHA1:
+  metadata.gz: 55a72b765291c267b859530ea8413d70201e45fc
+  data.tar.gz: 2227981ac7e0ed5c3e4b3a438a6087acfe427504
+SHA512:
+  metadata.gz: 6eb1d9590ba97d801053e963772bdf69411e7b08c44c11c31f149ca71d2b0919b64bf07c7c73bda2748e17a99faa9abb3853bea7b161013c84c9b81336d466ba
+  data.tar.gz: dd1fa2f4e0d304a9f4f6a0ea33379fad3a28937f8d9e008e40e2e954a8d36ce613f3102d0259fd69154b4016045ac9cfed140f006235d5166d6b329bcc892e98

data/.rubocop.yml

@@ -0,0 +1,53 @@
+AllCops:
+  Exclude:
+    - '*.gemspec'
+
+Lint/EndAlignment:
+  AlignWith: variable
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/MethodLength:
+  Max: 25
+
+Style/AccessModifierIndentation:
+  EnforcedStyle: outdent
+
+Style/CaseIndentation:
+  IndentWhenRelativeTo: end
+
+Style/DotPosition:
+  EnforcedStyle: trailing
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/Encoding:
+  EnforcedStyle: when_needed
+
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
+
+Style/IfUnlessModifier:
+  MaxLineLength: 40
+
+Style/IndentHash:
+  EnforcedStyle: consistent
+
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    '%w': '[]'
+    '%W': '[]'
+
+Style/Semicolon:
+  AllowAsExpressionSeparator: true
+
+Style/SpaceBeforeBlockBraces:
+  EnforcedStyle: no_space
+
+Style/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+
+Style/TrailingComma:
+  EnforcedStyleForMultiline: comma

data/.travis.yml

@@ -4,7 +4,17 @@ rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1.0
+  - ruby-head
   - jruby-18mode
   - jruby-19mode
+  - jruby-head
   - ree
-script: "bundle exec rspec"
+script:
+  - bundle exec rspec
+  - '! bundle show rubocop || bundle exec rubocop' # run rubocop only if bundled
+matrix:
+  fast_finish: true
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head

data/Gemfile

@@ -1,3 +1,3 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 gemspec

data/README.markdown

@@ -1,9 +1,13 @@
+[![Gem Version](https://img.shields.io/gem/v/in_threads.svg?style=flat)](https://rubygems.org/gems/in_threads)
+[![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)
+
 # in_threads
 
 Easily execute ruby code in parallel.
 
-[![Build Status](https://travis-ci.org/toy/in_threads.png?branch=master)](https://travis-ci.org/toy/in_threads)
-
 ## Installation
 
     gem install in_threads

data/in_threads.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name        = 'in_threads'
-  s.version     = '1.2.2'
+  s.version     = '1.3.0'
   s.summary     = %q{Execute ruby code in parallel}
   s.homepage    = "http://github.com/toy/#{s.name}"
   s.authors     = ['Ivan Kuchin']
@@ -16,4 +16,7 @@ Gem::Specification.new do |s|
   s.require_paths = %w[lib]
 
   s.add_development_dependency 'rspec', '~> 3.0'
+  if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('1.9.3')
+    s.add_development_dependency 'rubocop', '~> 0.26.0'
+  end
 end

data/lib/in_threads.rb

@@ -1,16 +1,135 @@
 require 'thread'
+require 'thwait'
 require 'delegate'
 
-class InThreads < Delegator
+Enumerable.class_eval do
+  # Run enumerable method blocks in threads
+  #
+  #   urls.in_threads.map do |url|
+  #     url.fetch
+  #   end
+  #
+  # Specify number of threads to use:
+  #
+  #   files.in_threads(4).all? do |file|
+  #     file.valid?
+  #   end
+  #
+  # Passing block runs it against `each`
+  #
+  #   urls.in_threads.each{ ... }
+  #
+  # is same as
+  #
+  #   urls.in_threads{ ... }
+  def in_threads(thread_count = 10, &block)
+    InThreads.new(self, thread_count, &block)
+  end
+end
+
+# Run Enumerable methods with blocks in threads
+class InThreads < SimpleDelegator
+  protected :__getobj__, :__setobj__
+
+  # Use ThreadsWait to limit number of threads
+  class ThreadLimiter
+    # Initialize with limit
+    def initialize(count)
+      @count = count
+      @waiter = ThreadsWait.new
+    end
+
+    # Without block behaves as `new`
+    # With block yields it with `self` and ensures running of `finalize`
+    def self.limit(count, &block)
+      limiter = new(count)
+      if block
+        begin
+          yield limiter
+        ensure
+          limiter.finalize
+        end
+      else
+        limiter
+      end
+    end
+
+    # 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
+    end
+
+    # Wait for waiting threads
+    def finalize
+      @waiter.all_waits(&:join)
+    end
+  end
+
+  # Yield objects of one enum in multiple places
+  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)
+      end
+
+      def finish
+        @queue << nil
+      end
+
+      def each
+        while (o = @queue.pop)
+          yield o.value
+        end
+        nil # non reusable
+      end
+    end
+
+    # Enums receiving items
+    attr_reader :enums
+
+    def initialize(enumerable, enum_count)
+      @enums = Array.new(enum_count){ Transfer.new }
+      @filler = Thread.new do
+        enumerable.each do |o|
+          @enums.each do |enum|
+            enum << o
+          end
+        end
+        @enums.each(&:finish)
+      end
+    end
+  end
+
   attr_reader :enumerable, :thread_count
   def initialize(enumerable, thread_count = 10, &block)
     super(enumerable)
     @enumerable, @thread_count = enumerable, thread_count.to_i
     unless enumerable.is_a?(Enumerable)
-      raise ArgumentError.new('`enumerable` should include Enumerable.')
+      fail ArgumentError, '`enumerable` should include Enumerable.'
     end
     if thread_count < 2
-      raise ArgumentError.new('`thread_count` can\'t be less than 2.')
+      fail ArgumentError, '`thread_count` can\'t be less than 2.'
     end
     each(&block) if block
   end
@@ -25,21 +144,21 @@ class InThreads < Delegator
     #
     #   use :run_in_threads_consecutive, :for => %w[all? any? none? one?]
     #
-    # <tt>:for</tt> is required
-    # <tt>:ignore_undefined</tt> ignores methods which are not present in <tt>Enumerable.instance_methods</tt>
+    # `:for` is required
+    # `:ignore_undefined` ignores methods which are not present in
+    # `Enumerable.instance_methods`
     def use(runner, options)
       methods = Array(options[:for])
-      raise 'no methods provided using :for option' if methods.empty?
+      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|
-        unless ignore_undefined && !enumerable_methods.include?(method)
-          class_eval <<-RUBY
-            def #{method}(*args, &block)
-              #{runner}(enumerable, :#{method}, *args, &block)
-            end
-          RUBY
-        end
+        next if ignore_undefined && !enumerable_methods.include?(method)
+        class_eval <<-RUBY
+          def #{method}(*args, &block)
+            #{runner}(:#{method}, *args, &block)
+          end
+        RUBY
       end
     end
   end
@@ -71,10 +190,11 @@ class InThreads < Delegator
     chunk slice_before
   ], :ignore_undefined => true
 
-  # Special case method, works by applying <tt>run_in_threads_consecutive</tt> with map on enumerable returned by blockless run
+  # Special case method, works by applying `run_in_threads_consecutive` with
+  # map on enumerable returned by blockless run
   def grep(*args, &block)
     if block
-      run_in_threads_consecutive(enumerable.grep(*args), :map, &block)
+      self.class.new(enumerable.grep(*args), thread_count).map(&block)
     else
       enumerable.grep(*args)
     end
@@ -87,16 +207,8 @@ class InThreads < Delegator
 
 protected
 
-  def __getobj__
-    @enumerable
-  end
-
-  def __setobj__(obj)
-    @enumerable = obj
-  end
-
   # Use for methods which don't use block result
-  def run_in_threads_return_original_enum(enumerable, method, *args, &block)
+  def run_in_threads_return_original_enum(method, *args, &block)
     if block
       ThreadLimiter.limit(thread_count) do |limiter|
         enumerable.send(method, *args) do |*block_args|
@@ -108,24 +220,25 @@ protected
     end
   end
 
-  # Use for methods which do use block result and fire objects in same way as <tt>each</tt>
-  def run_in_threads_consecutive(enumerable, method, *args, &block)
+  # Use for methods which do use block result
+  def run_in_threads_consecutive(method, *args, &block)
     if block
-      begin
-        enum_a, enum_b = Filler.new(enumerable, 2).extractors
-        results = Queue.new
-        runner = Thread.new do
-          Thread.current.priority = -1
-          ThreadLimiter.limit(thread_count) do |limiter|
-            enum_a.each do |object|
-              break if Thread.current[:stop]
-              thread = Thread.new(object, &block)
-              results << thread
-              limiter << thread
-            end
+      enum_a, enum_b = Splitter.new(enumerable, 2).enums
+      results = Queue.new
+      runner = Thread.new do
+        Thread.current.priority = -1
+        ThreadLimiter.limit(thread_count) do |limiter|
+          enum_a.each do |object|
+            break if Thread.current[:stop]
+            thread = Thread.new(object, &block)
+            results << thread
+            limiter << thread
           end
         end
-        enum_b.send(method, *args) do |object|
+      end
+
+      begin
+        enum_b.send(method, *args) do |_object|
           results.pop.value
         end
       ensure
@@ -138,11 +251,7 @@ protected
   end
 
   # Use for methods which don't use blocks or can not use threads
-  def run_without_threads(enumerable, method, *args, &block)
+  def run_without_threads(method, *args, &block)
     enumerable.send(method, *args, &block)
   end
 end
-
-require 'in_threads/enumerable'
-require 'in_threads/filler'
-require 'in_threads/thread_limiter'