in-parallel 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 727d8d9b9bba7b35600ceb413fa49cc67051863d
-  data.tar.gz: 05ef1dd733547320a4cf270fea067114ace9d2b3
+  metadata.gz: c73c6b3c70624e4afbe733cbe691e933f2ee178d
+  data.tar.gz: 1139cdd892f6242ff9a83cdf722d1df8e5520cc7
 SHA512:
-  metadata.gz: 68a7d78e8c45443a419279684e819f01fc3167cd77f6e7a7cdb2cdf5880700eadc353c460ec4d94350e5d3b104a3dffa7d9bc44f56b3eafebe89dbd775f91568
-  data.tar.gz: 4eca6ca978053f9a08c3e0ed9d66b3e851543cbdae48fff7e9c13547633e386d97faba0f463d098f996fa287fa3bf425dcdfce05775c3ba9074d35cb9df34297
+  metadata.gz: 7efe4eaa24eb74c0a1af3a5ebb7408c14afe26c682d0f0e76d4ef9ab31efd027ef9989c1c3bf73143d129aadafdca8c2ea2a66dccc607ba0651edd1e0d9c1ecb
+  data.tar.gz: 5008f55eedcc36458011d549d6bb0ad1b87ab5f9126b9dfae00025e0923aff6d0d8a870bf7b5a1e68a53d592cfbcd4c25257c6abd90dc884a6c72d87353b0a00

data/README.md

@@ -1,9 +1,9 @@
 # in-parallel
 A lightweight Ruby library with very simple syntax, making use of process.fork for parallelization
 
-I know there are other libraries that do parallelization, but I wanted something very simple to consume, and this was fun. I plan on using this within a test framework to enable parallel execution of some of the framework's tasks, and allow people within thier tests to execute code in parallel when wanted.  This solution does not check to see how many processors you have, it just forks as many processes as you ask for.  That means that it will handle a handful of parallel processes well, but could definitely overload your system with ruby processes if you try to spin up a LOT of processes.  If you're looking for something simple and light-weight and on either linux or mac, then this solution could be what you want.
+The other Ruby librarys that do parallel execution all support one primary use case - crunching through a large queue of small tasks as quickly and efficiently as possible.  This library primarily supports the use case of needing to run a few larger tasks in parallel and managing the stdout to make it easy to understand which processes are logging what. This library was created to be used by the Beaker test framework to enable parallel execution of some of the framework's tasks, and allow people within thier tests to execute code in parallel when wanted.  This solution does not check to see how many processors you have, it just forks as many processes as you ask for.  That means that it will handle a handful of parallel processes well, but could definitely overload your system with ruby processes if you try to spin up a LOT of processes.  If you're looking for something simple and light-weight and on either linux or mac (forking processes is not supported on Windows), then this solution could be what you want.
 
-If you are looking for something a little more production ready, you should take a look at the [parallel](https://github.com/grosser/parallel) project.
+If you are looking for something a little more production ready, you should take a look at the [parallel](https://github.com/grosser/parallel) project.  In the future this library will extend the in the parallel gem to take advantage of all of it's useful features as well.
 
 ## Methods:
 
@@ -99,8 +99,8 @@ hello world, bar
   
 ```
 
-### Array.each_in_parallel(&block)
-1. This is very similar to other solutions, except that it directly extends the Array class with an each_in_parallel method, giving you the ability to pretty simply spawn a process for any item in an array.
+### Enumerable.each_in_parallel(&block)
+1. This is very similar to other solutions, except that it directly extends the Enumerable class with an each_in_parallel method, giving you the ability to pretty simply spawn a process for any item in an array or map.
 2. Identifies the block location (or caller location if the block does not have a source_location) in the console log to make it clear which block is being executed
 
 ```ruby

data/in_parallel.gemspec

@@ -10,15 +10,17 @@ Gem::Specification.new do |spec|
   spec.email         = ["sam.woods@puppetlabs.com"]
 
   spec.summary       = "A lightweight library to execute a handful of tasks in parallel with simple syntax"
-  spec.description   = "I know there are other libraries that do parallelization, but I wanted something very " +
-      "simple to consume, and this was fun. I plan on using this within a test framework to enable parallel " +
-      "execution of some of the framework's tasks, and allow people within thier tests to execute code in " +
-      "parallel when wanted. This solution does not check to see how many processors you have, it just forks " +
-      "as many processes as you ask for. That means that it will handle a handful of parallel processes well, " +
-      "but could definitely overload your system with ruby processes if you try to spin up a LOT of processes. " +
-      "If you're looking for something simple and light-weight and on either linux or mac, then this solution " +
-      "could be what you want. If you are looking for something a little more production ready, you should take " +
-      "a look at the parallel project."
+  spec.description   = "The other Ruby librarys that do parallel execution all support one primary use case " +
+      "- crunching through a large queue of small tasks as quickly and efficiently as possible. This library " +
+      "primarily supports the use case of needing to run a few larger tasks in parallel and managing the " +
+      "stdout to make it easy to understand which processes are logging what. This library was created to be " +
+      "used by the Beaker test framework to enable parallel execution of some of the framework's tasks, and " +
+      "allow people within thier tests to execute code in parallel when wanted. This solution does not check " +
+      "to see how many processors you have, it just forks as many processes as you ask for. That means that it " +
+      "will handle a handful of parallel processes well, but could definitely overload your system with ruby " +
+      "processes if you try to spin up a LOT of processes. If you're looking for something simple and " +
+      "light-weight and on either linux or mac (forking processes is not supported on Windows), then this " +
+      "solution could be what you want."
   spec.homepage      = "https://github.com/samwoods1/in-parallel"
   spec.license       = "MIT"
 

data/in_parallel/version.rb

@@ -1,3 +1,3 @@
-module InParallel
-  VERSION = Version = '0.1.1'
+class InParallel
+  VERSION = Version = '0.1.2'
 end

data/lib/in_parallel.rb

@@ -1,182 +1,238 @@
-require_relative 'enumerable'
+require_relative 'parallel_enumerable'
 
 class InParallel
-   @@supported = Process.respond_to?(:fork)
-   @@outs = []
-    def self.outs
-      @@outs
+  # How many seconds between outputting to stdout that we are waiting for child processes.
+  # 0 or < 0 means no signaling.
+  @@signal_interval = 30
+  @@process_infos = []
+  @@raise_error = nil
+  def self.process_infos
+    @@process_infos
+  end
+
+  @@background_objs = []
+  @@result_id = 0
+
+  @@pids = []
+
+  # Example - will spawn 2 processes, (1 for each method) wait until they both complete, and log STDOUT:
+  # InParallel.run_in_parallel {
+  #   @result_1 = on agents[0], 'puppet agent -t'
+  #   @result_2 = on agents[1], 'puppet agent -t'
+  # }
+  # NOTE: Only supports assigning instance variables within the block, not local variables
+  def self.run_in_parallel(&block)
+    if Process.respond_to?(:fork)
+      proxy = BlankBindingParallelProxy.new(self)
+      proxy.instance_eval(&block)
+      results_map = wait_for_processes
+      # pass in the 'self' from the block.binding which is the instance of the class
+      # that contains the initial binding call.
+      # This gives us access to the local and instance variables from that context.
+      return result_lookup(proxy, eval("self", block.binding), results_map)
     end
+    puts 'Warning: Fork is not supported on this OS, executing block normally'
+    block.call
+  end
 
-   @@background_objs = []
-    @@result_id = 0
-
-    # Example - will spawn 2 processes, (1 for each method) wait until they both complete, and log STDOUT:
-    # InParallel.run_in_parallel {
-    #   @result_1 = on agents[0], 'puppet agent -t'
-    #   @result_2 = on agents[1], 'puppet agent -t'
-    # }
-    # NOTE: Only supports assigning instance variables within the block, not local variables
-    def self.run_in_parallel(&block)
-      if @@supported
-        proxy = BlankBindingParallelProxy.new(self)
-        proxy.instance_eval(&block)
-        results_map = wait_for_processes
-        # pass in the 'self' from the block.binding which is the instance of the class
-        # that contains the initial binding call.
-        # This gives us access to the local and instance variables from that context.
-        return result_lookup(proxy, eval("self", block.binding), results_map)
+  # Private method to lookup results from the results_map and replace the
+  # temp values with actual return values
+  def self.result_lookup(proxy_obj, target_obj, results_map)
+    vars = (proxy_obj.instance_variables)
+    results_map.keys.each { |tmp_result|
+      vars.each {|var|
+        if proxy_obj.instance_variable_get(var) == tmp_result
+          target_obj.instance_variable_set(var, results_map[tmp_result])
+          break
+        end
+      }
+    }
+  end
+  private_class_method :result_lookup
+
+  # Example - Will spawn a process in the background to run puppet agent on two agents and return immediately:
+  # Parallel.run_in_background {
+  #   @result = on agents[0], 'puppet agent -t'
+  #   @result_2 = on agents[1], 'puppet agent -t'
+  # }
+  # # Do something else here before waiting for the process to complete
+  #
+  # # Optionally wait for the processes to complete before continuing.
+  # # Otherwise use run_in_background(true) to clean up the process status and output immediately.
+  # Parrallel.get_background_results(self)
+  # NOTE: must call get_background_results to allow instance variables in calling object to be set,
+  # otherwise @result will evaluate to "unresolved_parallel_result_0"
+  def self.run_in_background(ignore_result = true, &block)
+    if Process.respond_to?(:fork)
+      proxy = BlankBindingParallelProxy.new(self)
+      proxy.instance_eval(&block)
+
+      if ignore_result
+        Process.detach(@@process_infos.last[:pid])
+        @@process_infos.pop
+      else
+        @@background_objs << {:proxy => proxy, :target => eval("self", block.binding)}
+        return process_infos.last[:tmp_result]
       end
-      puts 'Warning: Fork is not supported on this OS, executing block normally'
-      block.call
+      return
     end
+    puts 'Warning: Fork is not supported on this OS, executing block normally'
+    result = block.call
+    return nil if ignore_result
+    result
+  end
 
-    # Private method to lookup results from the results_map and replace the
-    # temp values with actual return values
-    def self.result_lookup(proxy_obj, target_obj, results_map)
-      vars = (proxy_obj.instance_variables)
-      results_map.keys.each { |tmp_result|
-        vars.each {|var|
-          if proxy_obj.instance_variable_get(var) == tmp_result
-            target_obj.instance_variable_set(var, results_map[tmp_result])
-            break
-          end
-        }
-      }
+  def self.get_background_results
+   results_map = wait_for_processes
+   # pass in the 'self' from the block.binding which is the instance of the class
+   # that contains the initial binding call.
+   # This gives us access to the instance variables from that context.
+   @@background_objs.each {|obj|
+     return result_lookup(obj[:proxy], obj[:target], results_map)
+   }
+  end
 
+  # Waits for all processes to complete and logs STDOUT and STDERR in chunks from any processes
+  # that were triggered from this Parallel class
+  def self.wait_for_processes
+    trap(:INT) do
+      puts "Warning, recieved interrupt.  Processing child results and exiting."
+      @@proces_infos.each { |process_info|
+        # Send INT to each child process so it returns and can print stdout and stderr to console before exiting.
+        Process.kill("INT", process_info[:pid])
+      }
     end
-    private_class_method :result_lookup
-
-    # Example - Will spawn a process in the background to run puppet agent on two agents and return immediately:
-    # Parallel.run_in_background {
-    #   @result = on agents[0], 'puppet agent -t'
-    #   @result_2 = on agents[1], 'puppet agent -t'
-    # }
-    # # Do something else here before waiting for the process to complete
-    #
-    # # Optionally wait for the processes to complete before continuing.
-    # # Otherwise use run_in_background(true) to clean up the process status and output immediately.
-    # Parrallel.get_background_results(self)
-    # NOTE: must call get_background_results to allow instance variables in calling object to be set,
-    # otherwise @result will evaluate to "unresolved_parallel_result_0"
-    def self.run_in_background(ignore_result = true, &block)
-      if @@supported
-        proxy = BlankBindingParallelProxy.new(self)
-        proxy.instance_eval(&block)
-
-        if ignore_result
-          Process.detach(@@outs.last[:pid])
-          @@outs.pop
-        else
-          @@background_objs << {:proxy => proxy, :target => eval("self", block.binding)}
-          return outs.last[:tmp_result]
-        end
-        return
+    return unless Process.respond_to?(:fork)
+    # Custom process to wait so that we can do things like time out, and kill child processes if
+    # one process returns with an error before the others complete.
+    results_map = {}
+    timer = Time.now
+    while !@@process_infos.empty? do
+      if @@signal_interval > 0 && Time.now > timer + @@signal_interval
+        puts 'Waiting for child processes.'
+        timer = Time.now
       end
-      puts 'Warning: Fork is not supported on this OS, executing block normally'
-      result = block.call
-      return nil if ignore_result
-      result
-    end
-
-   def self.get_background_results
-     results_map = wait_for_processes
-     # pass in the 'self' from the block.binding which is the instance of the class
-     # that contains the initial binding call.
-     # This gives us access to the local and instance variables from that context.
-     @@background_objs.each {|obj|
-       return result_lookup(obj[:proxy], obj[:target], results_map)
-     }
-   end
-
-    # Waits for all processes to complete and logs STDOUT and STDERR in chunks from any processes
-    # that were triggered from this Parallel class
-    def self.wait_for_processes
-      return unless @@supported
-      # Wait for all processes to complete
-      statuses = Process.waitall
-
-      results_map = {}
-      # Print the STDOUT and STDERR for each process with signals for start and end
-      while !@@outs.empty? do
-        out = @@outs.shift
-        begin
-          puts "\n------ Begin output for #{out[:method_sym]} - #{out[:pid]}\n"
-          puts out[:std_out].readlines
-          puts "------ Completed output for #{out[:method_sym]} - #{out[:pid]}\n"
-          results_map[out[:tmp_result]] = Marshal.load(out[:result].read)
-        ensure
-          # close the read end pipes
-          out[:std_out].close unless out[:std_out].closed?
-          out[:result].close unless out[:result].closed?
+      @@process_infos.each {|process_info|
+        # wait up to half a second for each thread to see if it is complete, if not, check the next thread.
+        # returns immediately if the process has completed.
+        thr = process_info[:wait_thread].join(0.5)
+        unless thr.nil?
+          # the process completed, get the result and rethrow on error.
+          begin
+            # Print the STDOUT and STDERR for each process with signals for start and end
+            puts "\n------ Begin output for #{process_info[:method_sym]} - #{process_info[:pid]}\n"
+            puts File.new(process_info[:std_out], 'r').readlines
+            puts "------ Completed output for #{process_info[:method_sym]} - #{process_info[:pid]}\n"
+            result = process_info[:result].read
+            results_map[process_info[:tmp_result]] = (result.nil? || result.empty?) ? result : Marshal.load(result)
+            File.delete(process_info[:std_out])
+            # Kill all other processes and let them log their stdout before re-raising
+            # if a child process raised an error.
+            if results_map[process_info[:tmp_result]].is_a?(StandardError)
+              @@process_infos.each{|p_info|
+                begin
+                  Process.kill(0, p_info[:pid]) unless p_info[:pid] == process_info[:pid]
+                rescue StandardError
+                end
+              }
+            end
+          ensure
+            # close the read end pipe
+            process_info[:result].close unless process_info[:result].closed?
+            @@process_infos.delete(process_info)
+            @@raise_error = results_map[process_info[:tmp_result]] if results_map[process_info[:tmp_result]].is_a?(StandardError)
+            break
+          end
         end
-      end
-
-      statuses.each { |status|
-        raise("Parallel process with PID '#{status[0]}' failed: #{status[1]}") unless status[1].success?
       }
+    end
 
-      return results_map
+    # Reset the error in case the error is rescued
+    begin
+      raise @@raise_error unless @@raise_error.nil?
+    ensure
+      @@raise_error = nil
     end
 
-    # private method to execute some code in a separate process and store the STDOUT and STDERR for later retrieval
-    def self._execute_in_parallel(method_sym, obj = self, &block)
-      ret_val = nil
-      # Communicate the return value of the method or block
-      read_result, write_result = IO.pipe
-      # Store the STDOUT and STDERR of the method or block
-      read_io, write_io = IO.pipe
-      pid = fork do
-        STDOUT.reopen(write_io)
-        STDERR.reopen(write_io)
-        # Need to store this for the case of run_in_background in _execute
-        @@result_writer = write_result
-        begin
-          # close subprocess's copy of read_io since it only needs to write
-          read_io.close
-          read_result.close
-          ret_val = obj.instance_eval(&block)
-          # Write the result to the write_result IO stream.
-          # Have to serialize the value so it can be transmitted via IO
-          Marshal.dump(ret_val, write_result)
-        rescue SystemCallError => err
-          puts "error: #{err.message}"
-          write_io.write('.')
-          exit 1
-        ensure
-          write_io.close
-          write_result.close
+    return results_map
+  end
+
+  # private method to execute some code in a separate process and store the STDOUT and STDERR for later retrieval
+  def self._execute_in_parallel(method_sym, obj = self, &block)
+    ret_val = nil
+    # Communicate the return value of the method or block
+    read_result, write_result = IO.pipe
+    pid = fork do
+      exit_status = 0
+      trap(:INT) do
+        raise StandardError.new("Warning: Interrupt received; exiting...")
+      end
+      Dir.mkdir('tmp') unless Dir.exists? 'tmp'
+      write_file = File.new("tmp/parallel_process_#{Process.pid}", 'w')
+
+      # IO buffer is 64kb, which isn't much... if debug logging is turned on,
+      # this can be exceeded before a process completes.
+      # Storing output in file rather than using IO.pipe
+      STDOUT.reopen(write_file)
+      STDERR.reopen(write_file)
+
+      begin
+        # close subprocess's copy of read_result since it only needs to write
+        read_result.close
+        ret_val = obj.instance_eval(&block)
+        # Write the result to the write_result IO stream.
+        # Have to serialize the value so it can be transmitted via IO
+        if(!ret_val.nil? && ret_val.singleton_methods && ret_val.class != TrueClass && ret_val.class != FalseClass && ret_val.class != Fixnum)
+          begin
+          ret_val = ret_val.dup
+          rescue StandardError => err
+            #in case there are other types that can't dup
+          end
         end
+        Marshal.dump(ret_val, write_result) unless ret_val.nil?
+      rescue StandardError => err
+        puts "Error in process #{pid}: #{err.message}"
+        # Return the error if an error is rescued so we can re-throw in the main process.
+        Marshal.dump(err, write_result)
+        exit_status = 1
+      ensure
+        write_result.close
+        exit exit_status
       end
-      write_io.close
-      write_result.close
-      # store the IO object with the STDOUT for each pid
-      out = { :pid => pid,
-              :method_sym => method_sym,
-              :std_out => read_io,
-              :result => read_result,
-              :tmp_result => "unresolved_parallel_result_#{@@result_id}" }
-      @@outs.push(out)
-      @@result_id += 1
-      out
     end
+    write_result.close
+    # Process.detach returns a thread that will be nil if the process is still running and thr if not.
+    # This allows us to check to see if processes have exited without having to call the blocking Process.wait functions.
+    wait_thread = Process.detach(pid)
+    # store the IO object with the STDOUT and waiting thread for each pid
+    process_info = { :wait_thread => wait_thread,
+            :pid => pid,
+            :method_sym => method_sym,
+            :std_out => "tmp/parallel_process_#{pid}",
+            :result => read_result,
+            :tmp_result => "unresolved_parallel_result_#{@@result_id}" }
+    @@process_infos.push(process_info)
+    @@result_id += 1
+    process_info
+  end
 
-    # Proxy class used to wrap each method execution in a block and run it in parallel
-    # A block from Parallel.run_in_parallel is executed with a binding of an instance of this class
-    class BlankBindingParallelProxy < BasicObject
-      # Don't worry about running methods like puts or other basic stuff in parallel
-      include ::Kernel
-
-      def initialize(obj)
-        @object = obj
-        @result_id = 0
-      end
+  # Proxy class used to wrap each method execution in a block and run it in parallel
+  # A block from Parallel.run_in_parallel is executed with a binding of an instance of this class
+  class BlankBindingParallelProxy < BasicObject
+    # Don't worry about running methods like puts or other basic stuff in parallel
+    include ::Kernel
 
-      # All methods within the block should show up as missing (unless defined in :Kernel)
-      def method_missing(method_sym, *args, &block)
-          out = ::InParallel._execute_in_parallel(method_sym) {@object.send(method_sym, *args, &block)}
-          puts "Forked process for '#{method_sym}' - PID = '#{out[:pid]}'\n"
-          out[:tmp_result]
-      end
+    def initialize(obj)
+      @object = obj
+      @result_id = 0
+    end
 
+    # All methods within the block should show up as missing (unless defined in :Kernel)
+    def method_missing(method_sym, *args, &block)
+        out = ::InParallel._execute_in_parallel(method_sym) {@object.send(method_sym, *args, &block)}
+        puts "Forked process for '#{method_sym}' - PID = '#{out[:pid]}'\n"
+        out[:tmp_result]
     end
+
   end
+end

data/lib/{enumerable.rb → parallel_enumerable.rb}

@@ -4,9 +4,9 @@
 #   on agent, 'puppet agent -t'
 # }
 module Enumerable
-  def each_in_parallel(&block)
-    if Process.respond_to?(:fork)
-      method_sym = "#{caller_locations[0]}"
+  def each_in_parallel(method_sym=nil, &block)
+    if Process.respond_to?(:fork) && size > 1
+      method_sym ||= "#{caller_locations[0]}"
       each do |item|
         out = InParallel._execute_in_parallel(method_sym) {block.call(item)}
         puts "'each_in_parallel' forked process for '#{method_sym}' - PID = '#{out[:pid]}'\n"
@@ -14,7 +14,7 @@ module Enumerable
       # return the array of values, no need to look up from the map.
       return InParallel.wait_for_processes.values
     end
-    puts 'Warning: Fork is not supported on this OS, executing block normally'
+    puts 'Warning: Fork is not supported on this OS, executing block normally' unless Process.respond_to? :fork
     block.call
     each(&block)
   end

metadata

@@ -1,54 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: in-parallel
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - samwoods1
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-09 00:00:00.000000000 Z
+date: 2016-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.11'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
-description: I know there are other libraries that do parallelization, but I wanted
-  something very simple to consume, and this was fun. I plan on using this within
-  a test framework to enable parallel execution of some of the framework's tasks,
-  and allow people within thier tests to execute code in parallel when wanted. This
-  solution does not check to see how many processors you have, it just forks as many
-  processes as you ask for. That means that it will handle a handful of parallel processes
-  well, but could definitely overload your system with ruby processes if you try to
-  spin up a LOT of processes. If you're looking for something simple and light-weight
-  and on either linux or mac, then this solution could be what you want. If you are
-  looking for something a little more production ready, you should take a look at
-  the parallel project.
+description: The other Ruby librarys that do parallel execution all support one primary
+  use case - crunching through a large queue of small tasks as quickly and efficiently
+  as possible. This library primarily supports the use case of needing to run a few
+  larger tasks in parallel and managing the stdout to make it easy to understand which
+  processes are logging what. This library was created to be used by the Beaker test
+  framework to enable parallel execution of some of the framework's tasks, and allow
+  people within thier tests to execute code in parallel when wanted. This solution
+  does not check to see how many processors you have, it just forks as many processes
+  as you ask for. That means that it will handle a handful of parallel processes well,
+  but could definitely overload your system with ruby processes if you try to spin
+  up a LOT of processes. If you're looking for something simple and light-weight and
+  on either linux or mac (forking processes is not supported on Windows), then this
+  solution could be what you want.
 email:
 - sam.woods@puppetlabs.com
 executables: []
@@ -61,8 +63,8 @@ files:
 - Rakefile
 - in_parallel.gemspec
 - in_parallel/version.rb
-- lib/enumerable.rb
 - lib/in_parallel.rb
+- lib/parallel_enumerable.rb
 homepage: https://github.com/samwoods1/in-parallel
 licenses:
 - MIT
@@ -73,17 +75,17 @@ 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: 
-rubygems_version: 2.4.7
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A lightweight library to execute a handful of tasks in parallel with simple