process_executer 1.3.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d2bd50be1f3683bc2c8210451c45e270e7072992ec48897a8bbb16cf10790c8b
-  data.tar.gz: e0d1ba5a7c5571b0059db55537726b68baf6017a66941883953ece63f5a58b53
+  metadata.gz: 658921c991aa6654711a48a4638e0de6d998f9b5bcdabf8314cad15bb7294a0f
+  data.tar.gz: 7aee46a6fe1459cbd4e0bc9a67895a3c9946741b192e3766937b90ddad416c03
 SHA512:
-  metadata.gz: bdaab34abbd99de650933f367eedcb40e7a2538d1f48ab8eda6f5df5da3d5f1748543eb28f54f21cc3557c64d34575001da2158caf2f30cc768bec88f657e16c
-  data.tar.gz: 920227450b1da0c56aa3987a2ff1bbeb2c73cd093d04c1318ebb39d02302a408682d0d40c1668eb1f9b37d71f58fe47a6c4b101b75e701fdbaf3db2cdb845b26
+  metadata.gz: c25a01c7d819932a0495b18fc332744c860df5d25c8234df15071ac3ee66a9f6bc6b6e0101e2b02bc0fb691af3a7ac5bf9a77a98565b44964abcbc3d63f4451e
+  data.tar.gz: 915c369b55e999c726c22b2e3ef0b377ac0253afd115615d4cd2cb8ae17244c5f042bde4018bf31cb76ec30baf924761cb26e045577959b29e3f7aedcceddb65

data/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to the process_executer gem will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v2.0.0 (2025-03-03)
+
+[Full Changelog](https://github.com/main-branch/process_executer/compare/v1.3.0..v2.0.0)
+
+Changes since v1.3.0:
+
+* f0836cc feat: refactor the interface to simplify the gem
+
 ## v1.3.0 (2025-02-26)
 
 [Full Changelog](https://github.com/main-branch/process_executer/compare/v1.2.0..v1.3.0)

data/README.md

@@ -11,16 +11,16 @@ Commits](https://img.shields.io/badge/Conventional%20Commits-1.0.0-%23FE5196?log
 [![Slack](https://img.shields.io/badge/slack-main--branch/process__executer-yellow.svg?logo=slack)](https://main-branch.slack.com/archives/C07NG2BPG8Y)
 
 * [Usage](#usage)
-  * [ProcessExecuter.run](#processexecuterrun)
-  * [ProcessExecuter::MonitoredPipe](#processexecutermonitoredpipe)
-  * [ProcessExecuter.spawn](#processexecuterspawn)
+    * [ProcessExecuter.run](#processexecuterrun)
+    * [ProcessExecuter::MonitoredPipe](#processexecutermonitoredpipe)
+    * [ProcessExecuter.spawn\_and\_wait](#processexecuterspawn_and_wait)
 * [Installation](#installation)
 * [Contributing](#contributing)
-  * [Reporting Issues](#reporting-issues)
-  * [Developing](#developing)
-  * [Commit message guidelines](#commit-message-guidelines)
-  * [Pull request guidelines](#pull-request-guidelines)
-  * [Releasing](#releasing)
+    * [Reporting Issues](#reporting-issues)
+    * [Developing](#developing)
+    * [Commit message guidelines](#commit-message-guidelines)
+    * [Pull request guidelines](#pull-request-guidelines)
+    * [Releasing](#releasing)
 * [License](#license)
 
 ## Usage
@@ -40,17 +40,17 @@ Supports the same features as
 [Process.spawn](https://docs.ruby-lang.org/en/3.3/Process.html#method-c-spawn).
 In addition, it (1) blocks until the command has exited, (2) captures stdout and
 stderr to a buffer or file, and (3) can optionally kill the command if it exceeds
-an timeout.
+a given timeout duration.
 
 This command takes two forms:
 
 1. When passing a single string the command is passed to a shell:
 
-    `ProcessExecuter.run([env, ] command_line, options = {}) ->` {ProcessExecuter::Command::Result}
+    `ProcessExecuter.run([env, ] command_line, options = {}) ->` {ProcessExecuter::Result}
 
 2. When passing an array of strings the command is run directly (bypassing the shell):
 
-    `ProcessExecuter.run([env, ] exe_path, *args, options = {}) ->` {ProcessExecuter::Command::Result}
+    `ProcessExecuter.run([env, ] exe_path, *args, options = {}) ->` {ProcessExecuter::Result}
 
 Argument env, if given, is a hash that affects ENV for the new process; see
 [Execution
@@ -99,27 +99,27 @@ output_buffer.string #=> "Hello World\n"
 File.read('process.out') #=> "Hello World\n"
 ```
 
-Since the data is streamed, any object that implements `#write` can be used. For insance,
-you can use it to parse process output as a stream which might be useful for long XML
-or JSON output.
+Since the data is streamed, any object that implements `#write` can be used. For
+insance, you can use it to parse process output as a stream which might be useful for
+long XML or JSON output.
 
-### ProcessExecuter.spawn
+### ProcessExecuter.spawn_and_wait
 
 `ProcessExecuter.spawn` has the same interface as `Process.spawn` but has two
 important behaviorial differences:
 
 1. It blocks until the subprocess finishes
-2. A timeout can be specified using the `:timeout` option
+2. A timeout can be specified using the `:timeout_after` option
 
-If the command does not terminate before the timeout, the process is killed by
-sending it the SIGKILL signal. The returned status object's `timeout?` attribute will
-return `true`. For example:
+If the command does not terminate before the number of seconds specified by
+`:timeout_after`, the process is killed by sending it the SIGKILL signal. The
+returned Result object's `timed_out?` attribute will return `true`. For example:
 
 ```ruby
-status = ProcessExecuter.spawn('sleep 10', timeout: 0.01)
-status.signaled? #=> true
-status.termsig #=> 9
-status.timeout? #=> true
+result = ProcessExecuter.spawn_and_wait('sleep 10', timeout_after: 0.01)
+result.signaled? #=> true
+result.termsig #=> 9
+result.timed_out? #=> true
 ```
 
 ## Installation

data/lib/process_executer/errors.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# rubocop:disable Layout/LineLength
+
+module ProcessExecuter
+  # Base class for all ProcessExecuter::Command errors
+  #
+  # It is recommended to rescue `ProcessExecuter::Error` to catch any
+  # runtime error raised by this gem unless you need more specific error handling.
+  #
+  # Custom errors are arranged in the following class hierarchy:
+  #
+  # ```text
+  # ::StandardError
+  #   └─> Error
+  #       ├─> CommandError
+  #       │   ├─> FailedError
+  #       │   └─> SignaledError
+  #       │       └─> TimeoutError
+  #       └─> ProcessIOError
+  # ```
+  #
+  # | Error Class | Description |
+  # | --- | --- |
+  # | `Error` | This catch-all error serves as the base class for other custom errors. |
+  # | `CommandError` | A subclass of this error is raised when there is a problem executing a command. |
+  # | `FailedError` | Raised when the command exits with a non-zero status code. |
+  # | `SignaledError` | Raised when the command is terminated as a result of receiving a signal. This could happen if the process is forcibly terminated or if there is a serious system error. |
+  # | `TimeoutError` | This is a specific type of `SignaledError` that is raised when the command times out and is killed via the SIGKILL signal. Raised when the operation takes longer than the specified timeout duration (if provided). |
+  # | `ProcessIOError` | Raised when an error was encountered reading or writing to the command's subprocess. |
+  #
+  # @example Rescuing any error
+  #   begin
+  #     ProcessExecuter.run_command('git', 'status')
+  #   rescue ProcessExecuter::Error => e
+  #     puts "An error occurred: #{e.message}"
+  #   end
+  #
+  # @example Rescuing a timeout error
+  #   begin
+  #     timeout_after = 0.1 # seconds
+  #     ProcessExecuter.run_command('sleep', '1', timeout_after:)
+  #   rescue ProcessExecuter::TimeoutError => e # Catch the more specific error first!
+  #     puts "Command took too long and timed out: #{e}"
+  #   rescue ProcessExecuter::Error => e
+  #     puts "Some other error occured: #{e}"
+  #   end
+  #
+  # @api public
+  #
+  class Error < ::StandardError; end
+
+  # Raised when a command fails or exits because of an uncaught signal
+  #
+  # The command executed, status, stdout, and stderr are available from this
+  # object.
+  #
+  # The Gem will raise a more specific error for each type of failure:
+  #
+  # * {FailedError}: when the command exits with a non-zero status
+  # * {SignaledError}: when the command exits because of an uncaught signal
+  # * {TimeoutError}: when the command times out
+  #
+  # @api public
+  #
+  class CommandError < ProcessExecuter::Error
+    # Create a CommandError object
+    #
+    # @example
+    #   `exit 1` # set $? appropriately for this example
+    #   result = ProcessExecuter::Result.new(%w[git status], $?, 'stdout', 'stderr')
+    #   error = ProcessExecuter::CommandError.new(result)
+    #   error.to_s #=> '["git", "status"], status: pid 89784 exit 1, stderr: "stderr"'
+    #
+    # @param result [Result] The result of the command including the command,
+    #   status, stdout, and stderr
+    #
+    def initialize(result)
+      @result = result
+      super(error_message)
+    end
+
+    # The human readable representation of this error
+    #
+    # @example
+    #   error.error_message #=> '["git", "status"], status: pid 89784 exit 1, stderr: "stderr"'
+    #
+    # @return [String]
+    #
+    def error_message
+      "#{result.command}, status: #{result}, stderr: #{result.stderr.inspect}"
+    end
+
+    # @attribute [r] result
+    #
+    # The result of the command including the command, its status and its output
+    #
+    # @example
+    #   error.result #=> #<ProcessExecuter::Result:0x00007f9b1b8b3d20>
+    #
+    # @return [Result]
+    #
+    attr_reader :result
+  end
+
+  # Raised when the command returns a non-zero exitstatus
+  #
+  # @api public
+  #
+  class FailedError < ProcessExecuter::CommandError; end
+
+  # Raised when the command exits because of an uncaught signal
+  #
+  # @api public
+  #
+  class SignaledError < ProcessExecuter::CommandError; end
+
+  # Raised when the command takes longer than the configured timeout_after
+  #
+  # @example
+  #   result.timed_out? #=> true
+  #
+  # @api public
+  #
+  class TimeoutError < ProcessExecuter::SignaledError; end
+
+  # Raised when the output of a command can not be read
+  #
+  # @api public
+  #
+  class ProcessIOError < ProcessExecuter::Error; end
+end
+
+# rubocop:enable Layout/LineLength

data/lib/process_executer/options.rb

@@ -7,7 +7,7 @@ module ProcessExecuter
   #
   # Valid options are those accepted by Process.spawn plus the following additions:
   #
-  # * `:timeout`:
+  # * `:timeout_after`: the number of seconds to allow a process to run before killing it
   #
   # @api public
   #
@@ -30,7 +30,7 @@ module ProcessExecuter
     # to `Process.spawn`
     #
     NON_SPAWN_OPTIONS = %i[
-      timeout
+      timeout_after raise_errors
     ].freeze
 
     # Any `SPAWN_OPTIONS` set to `NOT_SET` will not be passed to `Process.spawn`
@@ -50,7 +50,8 @@ module ProcessExecuter
       umask: NOT_SET,
       close_others: NOT_SET,
       chdir: NOT_SET,
-      timeout: nil
+      raise_errors: true,
+      timeout_after: nil
     }.freeze
 
     # :nocov:
@@ -71,14 +72,14 @@ module ProcessExecuter
     # Create a new Options object
     #
     # @example
-    #   options = ProcessExecuter::Options.new(out: $stdout, err: $stderr, timeout: 10)
+    #   options = ProcessExecuter::Options.new(out: $stdout, err: $stderr, timeout_after: 10)
     #
     # @param options [Hash] Process.spawn options plus additional options listed below.
     #
     #   See [Process.spawn](https://ruby-doc.org/core/Process.html#method-c-spawn)
     #   for a list of valid options that can be passed to `Process.spawn`.
     #
-    # @option options [Integer, Float, nil] :timeout
+    # @option options [Integer, Float, nil] :timeout_after
     #   Number of seconds to wait for the process to terminate. Any number
     #   may be used, including Floats to specify fractional seconds. A value of 0 or nil
     #   will allow the process to run indefinitely.
@@ -92,7 +93,7 @@ module ProcessExecuter
     # Returns the options to be passed to Process.spawn
     #
     # @example
-    #   options = ProcessExecuter::Options.new(out: $stdout, err: $stderr, timeout: 10)
+    #   options = ProcessExecuter::Options.new(out: $stdout, err: $stderr, timeout_after: 10)
     #   options.spawn_options # => { out: $stdout, err: $stderr }
     #
     # @return [Hash]
@@ -130,22 +131,24 @@ module ProcessExecuter
       raise ArgumentError, "Unknown options: #{unknown_options.join(', ')}" unless unknown_options.empty?
     end
 
-    # Raise an error if timeout is not a real non-negative number
+    # Raise an error if timeout_after is not a non-negative real number
     # @return [void]
-    # @raise [ArgumentError] if timeout is not a real non-negative number
+    # @raise [ArgumentError] if timeout_after is not a non-negative real number
     # @api private
     def assert_timeout_is_valid
-      return if @options[:timeout].nil?
-      return if @options[:timeout].is_a?(Numeric) && @options[:timeout].real? && !@options[:timeout].negative?
+      return if @options[:timeout_after].nil?
+      return if @options[:timeout_after].is_a?(Numeric) &&
+                @options[:timeout_after].real? &&
+                !@options[:timeout_after].negative?
 
-      raise ArgumentError, invalid_timeout_message
+      raise ArgumentError, invalid_timeout_after_message
     end
 
-    # The message to be used when raising an error for an invalid timeout
+    # The message to be used when raising an error for an invalid timeout_after
     # @return [String]
     # @api private
-    def invalid_timeout_message
-      "timeout must be nil or a real non-negative number but was #{options[:timeout].pretty_inspect}"
+    def invalid_timeout_after_message
+      "timeout_after must be nil or a non-negative real number but was #{options[:timeout_after].pretty_inspect}"
     end
 
     # Determine if the given option is a valid option

data/lib/process_executer/result.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module ProcessExecuter
+  # A decorator for Process::Status that adds the following attributes:
+  #
+  # * `command`: the command that was used to spawn the process
+  # * `options`: the options that were used to spawn the process
+  # * `elapsed_time`: the secs the command ran
+  # * `stdout`: the captured stdout output
+  # * `stderr`: the captured stderr output
+  # * `timed_out?`: true if the process timed out
+  #
+  # @api public
+  #
+  class Result < SimpleDelegator
+    # Create a new Result object
+    #
+    # @param status [Process::Status] the status to delegate to
+    # @param command [Array] the command that was used to spawn the process
+    # @param options [ProcessExecuter::Options] the options that were used to spawn the process
+    # @param timed_out [Boolean] true if the process timed out
+    # @param elapsed_time [Numeric] the secs the command ran
+    #
+    # @example
+    #   command = ['sleep 1']
+    #   options = ProcessExecuter::Options.new(timeout_after: 0.5)
+    #   start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    #   timed_out = false
+    #   status = nil
+    #   pid = Process.spawn(*command, **options.spawn_options)
+    #   Timeout.timeout(options.timeout_after) do
+    #     _pid, status = Process.wait2(pid)
+    #   rescue Timeout::Error
+    #     Process.kill('KILL', pid)
+    #     timed_out = true
+    #     _pid, status = Process.wait2(pid)
+    #   end
+    #   elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+    #
+    #   ProcessExecuter::Result.new(status, command:, options:, timed_out:, elapsed_time:)
+    #
+    # @api public
+    #
+    def initialize(status, command:, options:, timed_out:, elapsed_time:)
+      super(status)
+      @command = command
+      @options = options
+      @timed_out = timed_out
+      @elapsed_time = elapsed_time
+    end
+
+    # The command that was used to spawn the process
+    # @see Process.spawn
+    # @example
+    #   result.command #=> [{ 'GIT_DIR' => '/path/to/repo' }, 'git', 'status']
+    # @return [Array]
+    attr_reader :command
+
+    # The options that were used to spawn the process
+    # @see Process.spawn
+    # @example
+    #   result.options #=> { chdir: '/path/to/repo', timeout_after: 0.5 }
+    # @return [Hash]
+    # @api public
+    attr_reader :options
+
+    # The secs the command ran
+    # @example
+    #   result.elapsed_time #=> 10
+    # @return [Numeric, nil]
+    # @api public
+    attr_reader :elapsed_time
+
+    # @!attribute [r] timed_out?
+    # True if the process timed out and was sent the SIGKILL signal
+    # @example
+    #   result = ProcessExecuter.spawn('sleep 10', timeout_after: 0.01)
+    #   result.timed_out? # => true
+    # @return [Boolean]
+    #
+    def timed_out? = @timed_out
+
+    # Overrides the default success? method to return nil if the process timed out
+    #
+    # This is because when a timeout occurs, Windows will still return true.
+    #
+    # @example
+    #   result = ProcessExecuter.spawn('sleep 10', timeout_after: 0.01)
+    #   result.success? # => nil
+    # @return [true, nil]
+    #
+    def success?
+      return nil if timed_out? # rubocop:disable Style/ReturnNilInPredicateMethodDefinition
+
+      super
+    end
+
+    # Return a string representation of the result
+    # @example
+    #   result.to_s #=> "pid 70144 SIGKILL (signal 9) timed out after 10s"
+    # @return [String]
+    def to_s
+      "#{super}#{timed_out? ? " timed out after #{options.timeout_after}s" : ''}"
+    end
+
+    # Return the captured stdout output
+    #
+    # This output is only returned if the `:out` option was set to a
+    # `ProcessExecuter::MonitoredPipe` that includes a writer that implements `#string`
+    # method (e.g. a StringIO).
+    #
+    # @example
+    #   # Note that `ProcessExecuter.run` will wrap the given out: object in a
+    #   # ProcessExecuter::MonitoredPipe
+    #   result = ProcessExecuter.run('echo hello': out: StringIO.new)
+    #   result.stdout #=> "hello\n"
+    #
+    # @return [String, nil]
+    #
+    def stdout
+      Array(options.out).each do |pipe|
+        next unless pipe.is_a?(ProcessExecuter::MonitoredPipe)
+
+        pipe.writers.each do |writer|
+          return writer.string if writer.respond_to?(:string)
+        end
+      end
+
+      nil
+    end
+
+    # Return the captured stderr output
+    #
+    # This output is only returned if the `:err` option was set to a
+    # `ProcessExecuter::MonitoredPipe` that includes a writer that implements `#string`
+    # method (e.g. a StringIO).
+    #
+    # @example
+    #   # Note that `ProcessExecuter.run` will wrap the given err: object in a
+    #   # ProcessExecuter::MonitoredPipe
+    #   result = ProcessExecuter.run('echo ERROR 1>&2', err: StringIO.new)
+    #   resuilt.stderr #=> "ERROR\n"
+    #
+    # @return [String, nil]
+    #
+    def stderr
+      Array(options.err).each do |pipe|
+        next unless pipe.is_a?(ProcessExecuter::MonitoredPipe)
+
+        pipe.writers.each do |writer|
+          return writer.string if writer.respond_to?(:string)
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/process_executer/runner.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module ProcessExecuter
+  # The `Runner` class executes subprocess commands and captures their status and output.
+  #
+  # It does the following:
+  # - Run commands (`call`) with options for capturing output, handling timeouts, and merging stdout/stderr.
+  # - Process command results, including logging and error handling.
+  # - Raise detailed exceptions for common command failures, such as timeouts or subprocess errors.
+  #
+  # This class is used internally by {ProcessExecuter.run}.
+  #
+  # @api public
+  #
+  class Runner
+    # Create a new RunCommand instance
+    #
+    # @example
+    #   runner = Runner.new()
+    #   result = runner.call('echo', 'hello')
+    #
+    # @param logger [Logger] The logger to use. Defaults to a no-op logger if nil.
+    #
+    def initialize(logger = Logger.new(nil))
+      @logger = logger
+    end
+
+    # The logger to use
+    # @example
+    #   runner.logger #=> #<Logger:0x00007f9b1b8b3d20>
+    # @return [Logger]
+    attr_reader :logger
+
+    # Run a command and return the status including stdout and stderr output
+    #
+    # @example
+    #   runner = ProcessExecuter::Runner.new()
+    #   result = runner.call('echo hello')
+    #   result = ProcessExecuter.run('echo hello')
+    #   result.success? # => true
+    #   result.exitstatus # => 0
+    #   result.stdout # => "hello\n"
+    #   result.stderr # => ""
+    #
+    # @param command [Array<String>] The command to run
+    # @param out [#write, Array<#write>, nil] The object (or array of objects) to which stdout is written
+    # @param err [#write, Array<#write>, nil] The object (or array of objects) to which stderr is written
+    # @param merge [Boolean] Write both stdout and stderr into the buffer for stdout
+    # @param options_hash [Hash] Additional options to pass to Process.spawn
+    #
+    #   See {ProcessExecuter.run} for a full list of options.
+    #
+    # @return [ProcessExecuter::Result] The result of the completed subprocess
+    #
+    def call(*command, out: nil, err: nil, merge: false, **options_hash)
+      out ||= StringIO.new
+      err ||= (merge ? out : StringIO.new)
+
+      spawn(command, out:, err:, **options_hash).tap { |result| process_result(result) }
+    end
+
+    private
+
+    # Wrap the output buffers in pipes and then execute the command
+    #
+    # @param command [Array<String>] The command to execute
+    # @param out [#write, Array<#write>] The object (or array of objects) to which stdout is written
+    # @param err [#write, Array<#write>] The object (or array of objects) to which stderr is written
+    # @param options_hash [Hash] Additional options to pass to Process.spawn
+    #
+    #   See {ProcessExecuter.run} for a full list of options.
+    #
+    # @raise [ProcessExecuter::ProcessIOError] If an exception was raised while collecting subprocess output
+    # @raise [ProcessExecuter::TimeoutError] If the command times out
+    #
+    # @return [ProcessExecuter::Result] The result of the completed subprocess
+    #
+    # @api private
+    #
+    def spawn(command, out:, err:, **options_hash)
+      out = [out] unless out.is_a?(Array)
+      err = [err] unless err.is_a?(Array)
+      out_pipe = ProcessExecuter::MonitoredPipe.new(*out)
+      err_pipe = ProcessExecuter::MonitoredPipe.new(*err)
+      ProcessExecuter.spawn_and_wait(*command, out: out_pipe, err: err_pipe, **options_hash)
+    ensure
+      out_pipe.close
+      err_pipe.close
+      raise_pipe_error(command, :stdout, out_pipe) if out_pipe.exception
+      raise_pipe_error(command, :stderr, err_pipe) if err_pipe.exception
+    end
+
+    # Process the result of the command and return a ProcessExecuter::Result
+    #
+    # Log the command and result, and raise an error if the command failed.
+    #
+    # @param result [ProcessExecuter::Result] The result of the command
+    #
+    # @return [Void]
+    #
+    # @raise [ProcessExecuter::FailedError] If the command failed
+    # @raise [ProcessExecuter::SignaledError] If the command was signaled
+    # @raise [ProcessExecuter::TimeoutError] If the command times out
+    # @raise [ProcessExecuter::ProcessIOError] If an exception was raised while collecting subprocess output
+    #
+    # @api private
+    #
+    def process_result(result)
+      log_result(result)
+
+      return unless result.options.raise_errors
+
+      raise TimeoutError, result if result.timed_out?
+      raise SignaledError, result if result.signaled?
+      raise FailedError, result unless result.success?
+    end
+
+    # Log the result of running the command
+    # @param result [ProcessExecuter::Result] the result of the command including
+    #   the command, status, stdout, and stderr
+    # @return [void]
+    # @api private
+    def log_result(result)
+      logger.info { "#{result.command} exited with status #{result}" }
+      logger.debug { "stdout:\n#{result.stdout.inspect}\nstderr:\n#{result.stderr.inspect}" }
+    end
+
+    # Raise an error when there was exception while collecting the subprocess output
+    #
+    # @param command [Array<String>] The command that was executed
+    # @param pipe_name [Symbol] The name of the pipe that raised the exception
+    # @param pipe [ProcessExecuter::MonitoredPipe] The pipe that raised the exception
+    #
+    # @raise [ProcessExecuter::ProcessIOError]
+    #
+    # @return [void] This method always raises an error
+    #
+    # @api private
+    #
+    def raise_pipe_error(command, pipe_name, pipe)
+      error = ProcessExecuter::ProcessIOError.new("Pipe Exception for #{command}: #{pipe_name}")
+      raise(error, cause: pipe.exception)
+    end
+  end
+end

data/lib/process_executer/version.rb

@@ -2,5 +2,5 @@
 
 module ProcessExecuter
   # The current Gem version
-  VERSION = '1.3.0'
+  VERSION = '2.0.0'
 end