subprocess 1.5.3 → 1.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4d97562256aef790c8c0a24420d8b6509375cc023809aaa833310d2e3c46442
-  data.tar.gz: 9b91371b9e3e9a2af35431f69c4d3a795f02697063675378676bdb2f8cd7a262
+  metadata.gz: 03feecd6b5ca0a66f4c795071be9ed48d4801ac8735e69660ff7e87b05f1e47d
+  data.tar.gz: 0dad63e1568ca3a477471b98b912ee0528963d80d1ee8646813b2efa7429d429
 SHA512:
-  metadata.gz: 7c757567b28d5e36cffd5ea13b705012ab790b445d757a1744a76d3eef375bfa6bc48259e0f0e744a351ee8455a79264a74dd9b6bcd6275c7fdd864b5b2ec82f
-  data.tar.gz: fd3dd1fdbda8bcf00a2a96a7855610d2c9ff7fb2a6ec1d8f24751df80723f050444dbccd8bd93d3090210e4c7c6be033a008d46e7af550a0181fff0146a0329d
+  metadata.gz: 0d5cc41f0a7d716cb87c6e70c25b4892905b12d2c55727e29af281bc8e66f46be68a6a76fc263ac1ed1a8fd709288b3101dcd0d2ed19aac36c94d9de133ea171
+  data.tar.gz: 25b247b27b30ce8dc4cf98670adb415f82bc4e4ce64ba5e410307ba194efd516c13af19ded736568a2e95ab88bacda16a46b626230be45f2a948db7e7876ad7e

data/lib/subprocess.rb

@@ -16,7 +16,13 @@ module Subprocess
 
   # An alias for `Process.new`. Mostly here to better emulate the Python API.
   #
+  # @param [Array<String>] cmd See {Process#initialize}
+  # @param [Hash] opts See {Process#initialize}
+  # @yield [process] See {Process#initialize}
+  # @yieldparam process [Process] See {Process#initialize}
   # @return [Process] A process with the given arguments
+  #
+  # @see Process#initialize
   def self.popen(cmd, opts={}, &blk)
     Process.new(cmd, opts, &blk)
   end
@@ -28,6 +34,11 @@ module Subprocess
   #   fills up, as neither file descriptor will be read from. To avoid this, use
   #   {Process#communicate} from a passed block.
   #
+  # @param [Array<String>] cmd See {Process#initialize}
+  # @param [Hash] opts See {Process#initialize}
+  # @yield [process] See {Process#initialize}
+  # @yieldparam process [Process] See {Process#initialize}
+  #
   # @return [::Process::Status] The exit status of the process
   #
   # @see Process#initialize
@@ -58,6 +69,11 @@ module Subprocess
   #   fills up, as neither file descriptor will be read from. To avoid this, use
   #   {Process#communicate} from a passed block.
   #
+  # @param [Array<String>] cmd See {Process#initialize}
+  # @param [Hash] opts See {Process#initialize}
+  # @yield [process] See {Process#initialize}
+  # @yieldparam process [Process] See {Process#initialize}
+  #
   # @raise [NonZeroExit] if the process returned a non-zero exit status (i.e.,
   #   was terminated with an error or was killed by a signal)
   # @return [::Process::Status] The exit status of the process
@@ -70,11 +86,16 @@ module Subprocess
   end
 
   # Like {Subprocess::check_call}, but return the contents of `stdout`, much
-  # like `Kernel#system`.
+  # like {::Kernel#system}.
   #
   # @example Get the system load
   #   system_load = Subprocess.check_output(['uptime']).split(' ').last(3)
   #
+  # @param [Array<String>] cmd See {Process#initialize}
+  # @param [Hash] opts See {Process#initialize}
+  # @yield [process] See {Process#initialize}
+  # @yieldparam process [Process] See {Process#initialize}
+  #
   # @raise [NonZeroExit] if the process returned a non-zero exit status (i.e.,
   #   was terminated with an error or was killed by a signal)
   # @return [String] The contents of `stdout`
@@ -130,16 +151,17 @@ module Subprocess
 
   # Error class representing a process's abnormal exit.
   class NonZeroExit < StandardError
-    # @!attribute [r] command
-    #   @note This is intended only for use in user-facing error messages. In
-    #     particular, no shell quoting of any sort is performed when
-    #     constructing this string, meaning that blindly running it in a shell
-    #     might have different semantics than the original command.
-    #   @return [String] The command and arguments for the process that exited
-    #     abnormally.
-    # @!attribute [r] status
-    #   @return [::Process::Status] The Ruby status object returned by `waitpid`
-    attr_reader :command, :status
+    # @note This is intended only for use in user-facing error messages. In
+    #   particular, no shell quoting of any sort is performed when
+    #   constructing this string, meaning that blindly running it in a shell
+    #   might have different semantics than the original command.
+    #
+    # @return [String] The command and arguments for the process that exited
+    #   abnormally.
+    attr_reader :command
+
+    # @return [::Process::Status] The Ruby status object returned by `waitpid`
+    attr_reader :status
 
     # Return an instance of {NonZeroExit}.
     #
@@ -163,12 +185,15 @@ module Subprocess
 
   # Error class representing a timeout during a call to `communicate`
   class CommunicateTimeout < StandardError
-    # @!attribute [r] stdout
-    #   @return [String] Content read from stdout before the timeout
-    # @!attribute [r] stderr
-    #   @return [String] Content read from stderr before the timeout
-    attr_reader :stdout, :stderr
+    # @return [String] Content read from stdout before the timeout
+    attr_reader :stdout
+
+    # @return [String] Content read from stderr before the timeout
+    attr_reader :stderr
 
+    # @param [Array<String>] cmd
+    # @param [String] stdout
+    # @param [String] stderr
     def initialize(cmd, stdout, stderr)
       @stdout = stdout
       @stderr = stderr
@@ -181,22 +206,24 @@ module Subprocess
   # functions on {Subprocess} (especially {Subprocess::check_call} and
   # {Subprocess::check_output}).
   class Process
-    # @!attribute [r] stdin
-    #   @return [IO] The `IO` that is connected to this process's `stdin`.
-    # @!attribute [r] stdout
-    #   @return [IO] The `IO` that is connected to this process's `stdout`.
-    # @!attribute [r] stderr
-    #   @return [IO] The `IO` that is connected to this process's `stderr`.
-    attr_reader :stdin, :stdout, :stderr
-
-    # @!attribute [r] command
-    #   @return [Array<String>] The command this process was invoked with.
-    # @!attribute [r] pid
-    #   @return [Fixnum] The process ID of the spawned process.
-    # @!attribute [r] status
-    #   @return [::Process::Status] The exit status code of the process. Only
-    #     set after the process has exited.
-    attr_reader :command, :pid, :status
+    # @return [IO] The `IO` that is connected to this process's `stdin`.
+    attr_reader :stdin
+
+    # @return [IO] The `IO` that is connected to this process's `stdout`.
+    attr_reader :stdout
+
+    # @return [IO] The `IO` that is connected to this process's `stderr`.
+    attr_reader :stderr
+
+    # @return [Array<String>] The command this process was invoked with.
+    attr_reader :command
+
+    # @return [Integer] The process ID of the spawned process.
+    attr_reader :pid
+
+    # @return [::Process::Status] The exit status code of the process. Only
+    #   set after the process has exited.
+    attr_reader :status
 
     # Create a new process.
     #
@@ -204,15 +231,15 @@ module Subprocess
     #   style of an `argv` array). Unlike Python's subprocess module, `cmd`
     #   cannot be a String.
     #
-    # @option opts [IO, Fixnum, String, Subprocess::PIPE, nil] :stdin The `IO`,
+    # @option opts [IO, Integer, String, Subprocess::PIPE, nil] :stdin The `IO`,
     #   file descriptor number, or file name to use for the process's standard
     #   input. If the magic value {Subprocess::PIPE} is passed, a new pipe will
     #   be opened.
-    # @option opts [IO, Fixnum, String, Subprocess::PIPE, nil] :stdout The `IO`,
+    # @option opts [IO, Integer, String, Subprocess::PIPE, nil] :stdout The `IO`,
     #   file descriptor number, or file name to use for the process's standard
     #   output. If the magic value {Subprocess::PIPE} is passed, a pipe will be
     #   opened and attached to the process.
-    # @option opts [IO, Fixnum, String, Subprocess::PIPE, Subprocess::STDOUT,
+    # @option opts [IO, Integer, String, Subprocess::PIPE, Subprocess::STDOUT,
     #   nil] :stderr The `IO`, file descriptor number, or file name to use for
     #   the process's standard error. If the special value {Subprocess::PIPE} is
     #   passed, a pipe will be opened and attached to the process. If the
@@ -223,12 +250,12 @@ module Subprocess
     #   child process.
     # @option opts [Hash<String, String>] :env The environment to use in the
     #   child process.
-    # @option opts [Array<Fixnum>] :retain_fds An array of file descriptor
+    # @option opts [Array<Integer>] :retain_fds An array of file descriptor
     #   numbers that should not be closed before executing the child process.
     #   Note that, unlike Python (which has :close_fds defaulting to false), all
     #   file descriptors not specified here will be closed.
     # @option opts [Hash] :exec_opts A hash that will be merged into the options
-    #   hash of the call to {Kernel#exec}.
+    #   hash of the call to {::Kernel#exec}.
     #
     # @option opts [Proc] :preexec_fn A function that will be called in the
     #   child process immediately before executing `cmd`.
@@ -494,15 +521,23 @@ module Subprocess
 
     # Does exactly what it says on the box.
     #
-    # @param [String, Symbol, Fixnum] signal The signal to send to the child
+    # @param [String, Symbol, Integer] signal The signal to send to the child
     #   process. Accepts all the same arguments as Ruby's built-in
     #   {::Process::kill}, for instance a string like "INT" or "SIGINT", or a
     #   signal number like 2.
+    #
+    # @return [Integer] See {::Process.kill}
+    #
+    # @see ::Process.kill
     def send_signal(signal)
       ::Process.kill(signal, pid)
     end
 
     # Sends `SIGTERM` to the process.
+    #
+    # @return [Integer] See {send_signal}
+    #
+    # @see send_signal
     def terminate
       send_signal("TERM")
     end
@@ -512,6 +547,10 @@ module Subprocess
     # descriptor should appear to the child and to this process, respectively.
     # "mine" is only non-nil in the case of a pipe (in fact, we just return a
     # list of length one, since ruby will unpack nils from missing list items).
+    #
+    # @param [IO, Integer, String, nil] fd
+    # @param [String] mode
+    # @return [Array<IO>]
     def parse_fd(fd, mode)
       fds = case fd
       when PIPE
@@ -533,6 +572,9 @@ module Subprocess
 
     # The pair to parse_fd, returns whether or not the file descriptor was
     # opened by us (and therefore should be closed by us).
+    #
+    # @param [IO, Integer, String, nil] fd
+    # @return [Boolean]
     def our_fd?(fd)
       case fd
       when PIPE, String
@@ -543,6 +585,12 @@ module Subprocess
     end
 
     # Call IO.select timing out at Time `timeout_at`. If `timeout_at` is nil, never times out.
+    #
+    # @param [Array<IO>, nil] read_array
+    # @param [Array<IO>, nil] write_array
+    # @param [Array<IO>, nil] err_array
+    # @param [Integer, Float, nil] timeout_at
+    # @return [Array<Array<IO>>, nil]
     def select_until(read_array, write_array, err_array, timeout_at)
       if !timeout_at
         return IO.select(read_array, write_array, err_array)
@@ -561,6 +609,7 @@ module Subprocess
     @sigchld_global_read = nil
     @sigchld_pipe_pid = nil
 
+    # @return [void]
     def self.handle_sigchld
       # We'd like to just notify everything in `@sigchld_fds`, but
       # ruby signal handlers are not executed atomically with respect
@@ -583,6 +632,7 @@ module Subprocess
     # and we want to let the process itself do that. In practice, we're not
     # likely to have that many in-flight subprocesses, so this is probably not a
     # big deal.
+    # @return [void]
     def self.wakeup_sigchld
       @sigchld_mutex.synchronize do
         @sigchld_fds.values.each do |fd|
@@ -598,6 +648,9 @@ module Subprocess
       end
     end
 
+    # @param [Integer] pid
+    # @param [IO] fd
+    # @return [void]
     def self.register_pid(pid, fd)
       @sigchld_mutex.synchronize do
         @sigchld_fds[pid] = fd
@@ -615,6 +668,8 @@ module Subprocess
       end
     end
 
+    # @param [Integer] pid
+    # @return [void]
     def self.unregister_pid(pid)
       @sigchld_mutex.synchronize do
         if @sigchld_fds.length == 1
@@ -624,6 +679,8 @@ module Subprocess
       end
     end
 
+    # @param [Integer] pid
+    # @return [void]
     def self.catching_sigchld(pid)
       IO.pipe do |self_read, self_write|
         begin

data/lib/subprocess/version.rb

@@ -1,3 +1,3 @@
 module Subprocess
-  VERSION = '1.5.3'
+  VERSION = '1.5.4'
 end

data/rbi/subprocess.rbi

@@ -0,0 +1,312 @@
+# typed: strong
+
+# THIS FILE IS AUTOGENERATED. DO NOT EDIT.
+# To regenerate from YARD comments:
+#
+#     bundle exec rake sord
+#
+# A Ruby clone of Python's subprocess module.
+#
+# @see http://docs.python.org/2/library/subprocess.html
+module ::Subprocess
+  PIPE = T.let(-1, T.untyped)
+  STDOUT = T.let(-2, T.untyped)
+  VERSION = T.let('1.5.4', T.untyped)
+
+  # An alias for `Process.new`. Mostly here to better emulate the Python API.
+  #
+  # _@param_ `cmd` — See {Process#initialize}
+  #
+  # _@param_ `opts` — See {Process#initialize}
+  #
+  # _@return_ — A process with the given arguments
+  #
+  # _@see_ `Process#initialize`
+  sig { params(cmd: T::Array[String], opts: T::Hash[T.untyped, T.untyped], blk: T.nilable(T.proc.params(process: Process).void)).returns(Process) }
+  def self.popen(cmd, opts = {}, &blk); end
+
+  # Call and wait for the return of a given process.
+  #
+  # _@param_ `cmd` — See {Process#initialize}
+  #
+  # _@param_ `opts` — See {Process#initialize}
+  #
+  # _@return_ — The exit status of the process
+  #
+  # _@note_ — If you call this function with `:stdout => PIPE` or `:stderr => PIPE`,
+  # this function will block indefinitely as soon as the OS's pipe buffer
+  # fills up, as neither file descriptor will be read from. To avoid this, use
+  # {Process#communicate} from a passed block.
+  #
+  # _@see_ `Process#initialize`
+  sig { params(cmd: T::Array[String], opts: T::Hash[T.untyped, T.untyped], blk: T.nilable(T.proc.params(process: Process).void)).returns(::Process::Status) }
+  def self.call(cmd, opts = {}, &blk); end
+
+  # Like {Subprocess::call}, except raise a {NonZeroExit} if the process did not
+  # terminate successfully.
+  #
+  # _@param_ `cmd` — See {Process#initialize}
+  #
+  # _@param_ `opts` — See {Process#initialize}
+  #
+  # _@return_ — The exit status of the process
+  #
+  # Grep a file for a string
+  # ```ruby
+  # Subprocess.check_call(%W{grep -q llama ~/favorite_animals})
+  # ```
+  #
+  # Communicate with a child process
+  # ```ruby
+  # Subprocess.check_call(%W{sendmail -t}, :stdin => Subprocess::PIPE) do |p|
+  #   p.communicate <<-EMAIL
+  # From: alpaca@example.com
+  # To: llama@example.com
+  # Subject: I am so fluffy.
+  #
+  # SO FLUFFY!
+  # http://upload.wikimedia.org/wikipedia/commons/3/3e/Unshorn_alpaca_grazing.jpg
+  #   EMAIL
+  # end
+  # ```
+  #
+  # _@note_ — If you call this function with `:stdout => PIPE` or `:stderr => PIPE`,
+  # this function will block indefinitely as soon as the OS's pipe buffer
+  # fills up, as neither file descriptor will be read from. To avoid this, use
+  # {Process#communicate} from a passed block.
+  #
+  # _@see_ `Process#initialize`
+  sig { params(cmd: T::Array[String], opts: T::Hash[T.untyped, T.untyped], blk: T.nilable(T.proc.params(process: Process).void)).returns(::Process::Status) }
+  def self.check_call(cmd, opts = {}, &blk); end
+
+  # Like {Subprocess::check_call}, but return the contents of `stdout`, much
+  # like {::Kernel#system}.
+  #
+  # _@param_ `cmd` — See {Process#initialize}
+  #
+  # _@param_ `opts` — See {Process#initialize}
+  #
+  # _@return_ — The contents of `stdout`
+  #
+  # Get the system load
+  # ```ruby
+  # system_load = Subprocess.check_output(['uptime']).split(' ').last(3)
+  # ```
+  #
+  # _@see_ `Process#initialize`
+  sig { params(cmd: T::Array[String], opts: T::Hash[T.untyped, T.untyped], blk: T.nilable(T.proc.params(process: Process).void)).returns(String) }
+  def self.check_output(cmd, opts = {}, &blk); end
+
+  # Print a human readable interpretation of a process exit status.
+  #
+  # _@param_ `status` — The status returned by `waitpid2`.
+  #
+  # _@param_ `convert_high_exit` — Whether to convert exit statuses greater than 128 into the usual convention for exiting after trapping a signal. (e.g. many programs will exit with status 130 after receiving a SIGINT / signal 2.)
+  #
+  # _@return_ — Text interpretation
+  sig { params(status: ::Process::Status, convert_high_exit: T::Boolean).returns(String) }
+  def self.status_to_s(status, convert_high_exit = true); end
+
+  # Error class representing a process's abnormal exit.
+  class NonZeroExit < StandardError
+    # Return an instance of {NonZeroExit}.
+    #
+    # _@param_ `cmd` — The command that returned a non-zero status.
+    #
+    # _@param_ `status` — The status returned by `waitpid`.
+    sig { params(cmd: T::Array[String], status: ::Process::Status).void }
+    def initialize(cmd, status); end
+
+    # _@return_ — The command and arguments for the process that exited
+    # abnormally.
+    #
+    # _@note_ — This is intended only for use in user-facing error messages. In
+    # particular, no shell quoting of any sort is performed when
+    # constructing this string, meaning that blindly running it in a shell
+    # might have different semantics than the original command.
+    sig { returns(String) }
+    attr_reader :command
+
+    # _@return_ — The Ruby status object returned by `waitpid`
+    sig { returns(::Process::Status) }
+    attr_reader :status
+  end
+
+  # Error class representing a timeout during a call to `communicate`
+  class CommunicateTimeout < StandardError
+    # _@param_ `cmd`
+    #
+    # _@param_ `stdout`
+    #
+    # _@param_ `stderr`
+    sig { params(cmd: T::Array[String], stdout: String, stderr: String).void }
+    def initialize(cmd, stdout, stderr); end
+
+    # _@return_ — Content read from stdout before the timeout
+    sig { returns(String) }
+    attr_reader :stdout
+
+    # _@return_ — Content read from stderr before the timeout
+    sig { returns(String) }
+    attr_reader :stderr
+  end
+
+  # A child process. The preferred way of spawning a subprocess is through the
+  # functions on {Subprocess} (especially {Subprocess::check_call} and
+  # {Subprocess::check_output}).
+  class Process
+    # Create a new process.
+    #
+    # _@param_ `cmd` — The command to run and its arguments (in the style of an `argv` array). Unlike Python's subprocess module, `cmd` cannot be a String.
+    sig { params(cmd: T::Array[String], opts: T::Hash[T.untyped, T.untyped], blk: T.nilable(T.proc.params(process: Process).void)).void }
+    def initialize(cmd, opts = {}, &blk); end
+
+    # Poll the child, setting (and returning) its status. If the child has not
+    # terminated, return nil and exit immediately
+    #
+    # _@return_ — The exit status of the process
+    sig { returns(T.nilable(::Process::Status)) }
+    def poll; end
+
+    # Wait for the child to return, setting and returning the status of the
+    # child.
+    #
+    # _@return_ — The exit status of the process
+    sig { returns(::Process::Status) }
+    def wait; end
+
+    # Do nonblocking reads from `fd`, appending all data read into `buf`.
+    #
+    # _@param_ `fd` — The file to read from.
+    #
+    # _@param_ `buf` — A buffer to append the read data to.
+    #
+    # _@return_ — Whether `fd` was closed due to an exceptional
+    # condition (`EOFError` or `EPIPE`).
+    sig { params(fd: IO, buf: T.nilable(String)).returns(T::Boolean) }
+    def drain_fd(fd, buf = nil); end
+
+    # Write the (optional) input to the process's `stdin` and read the contents of
+    # `stdout` and `stderr`. If a block is provided, stdout and stderr are yielded as they
+    # are read. Otherwise they are buffered in memory and returned when the process
+    # exits. Do this all using `IO::select`, so we don't deadlock due to full pipe
+    # buffers.
+    #
+    # This is only really useful if you set some of `:stdin`, `:stdout`, and
+    # `:stderr` to {Subprocess::PIPE}.
+    #
+    # _@param_ `input` — A string to feed to the child's standard input.
+    #
+    # _@param_ `timeout_s` — Raise {Subprocess::CommunicateTimeout} if communicate does not finish after timeout_s seconds.
+    #
+    # _@return_ — An array of two elements: the data read from the
+    # child's standard output and standard error, respectively.
+    # Returns nil if a block is provided.
+    sig { params(input: T.nilable(String), timeout_s: T.nilable(Numeric)).returns([String, String]) }
+    def communicate(input = nil, timeout_s = nil); end
+
+    # Does exactly what it says on the box.
+    #
+    # _@param_ `signal` — The signal to send to the child process. Accepts all the same arguments as Ruby's built-in {::Process::kill}, for instance a string like "INT" or "SIGINT", or a signal number like 2.
+    #
+    # _@return_ — See {::Process.kill}
+    #
+    # _@see_ `::Process.kill`
+    sig { params(signal: T.any(String, Symbol, Integer)).returns(Integer) }
+    def send_signal(signal); end
+
+    # Sends `SIGTERM` to the process.
+    #
+    # _@return_ — See {send_signal}
+    #
+    # _@see_ `send_signal`
+    sig { returns(Integer) }
+    def terminate; end
+
+    # Return a pair of values (child, mine), which are how the given file
+    # descriptor should appear to the child and to this process, respectively.
+    # "mine" is only non-nil in the case of a pipe (in fact, we just return a
+    # list of length one, since ruby will unpack nils from missing list items).
+    #
+    # _@param_ `fd`
+    #
+    # _@param_ `mode`
+    sig { params(fd: T.nilable(T.any(IO, Integer, String)), mode: String).returns(T::Array[IO]) }
+    def parse_fd(fd, mode); end
+
+    # The pair to parse_fd, returns whether or not the file descriptor was
+    # opened by us (and therefore should be closed by us).
+    #
+    # _@param_ `fd`
+    sig { params(fd: T.nilable(T.any(IO, Integer, String))).returns(T::Boolean) }
+    def our_fd?(fd); end
+
+    # Call IO.select timing out at Time `timeout_at`. If `timeout_at` is nil, never times out.
+    #
+    # _@param_ `read_array`
+    #
+    # _@param_ `write_array`
+    #
+    # _@param_ `err_array`
+    #
+    # _@param_ `timeout_at`
+    sig do
+      params(
+        read_array: T.nilable(T::Array[IO]),
+        write_array: T.nilable(T::Array[IO]),
+        err_array: T.nilable(T::Array[IO]),
+        timeout_at: T.nilable(T.any(Integer, Float))
+      ).returns(T.nilable(T::Array[T::Array[IO]]))
+    end
+    def select_until(read_array, write_array, err_array, timeout_at); end
+
+    sig { void }
+    def self.handle_sigchld; end
+
+    # Wake up everyone. We can't tell who we should wake up without `wait`ing,
+    # and we want to let the process itself do that. In practice, we're not
+    # likely to have that many in-flight subprocesses, so this is probably not a
+    # big deal.
+    sig { void }
+    def self.wakeup_sigchld; end
+
+    # _@param_ `pid`
+    #
+    # _@param_ `fd`
+    sig { params(pid: Integer, fd: IO).void }
+    def self.register_pid(pid, fd); end
+
+    # _@param_ `pid`
+    sig { params(pid: Integer).void }
+    def self.unregister_pid(pid); end
+
+    # _@param_ `pid`
+    sig { params(pid: Integer).void }
+    def self.catching_sigchld(pid); end
+
+    # _@return_ — The `IO` that is connected to this process's `stdin`.
+    sig { returns(IO) }
+    attr_reader :stdin
+
+    # _@return_ — The `IO` that is connected to this process's `stdout`.
+    sig { returns(IO) }
+    attr_reader :stdout
+
+    # _@return_ — The `IO` that is connected to this process's `stderr`.
+    sig { returns(IO) }
+    attr_reader :stderr
+
+    # _@return_ — The command this process was invoked with.
+    sig { returns(T::Array[String]) }
+    attr_reader :command
+
+    # _@return_ — The process ID of the spawned process.
+    sig { returns(Integer) }
+    attr_reader :pid
+
+    # _@return_ — The exit status code of the process. Only
+    # set after the process has exited.
+    sig { returns(::Process::Status) }
+    attr_reader :status
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: subprocess
 version: !ruby/object:Gem::Version
-  version: 1.5.3
+  version: 1.5.4
 platform: ruby
 authors:
 - Carl Jackson
@@ -9,10 +9,10 @@ authors:
 - Nelson Elhage
 - Andy Brody
 - Andreas Fuchs
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-06 00:00:00.000000000 Z
+date: 2021-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -56,6 +56,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Control and communicate with spawned processes
 email:
 - carl@stripe.com
@@ -70,11 +84,12 @@ files:
 - README.md
 - lib/subprocess.rb
 - lib/subprocess/version.rb
+- rbi/subprocess.rbi
 homepage: https://github.com/stripe/subprocess
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -90,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: A port of Python's subprocess module to Ruby
 test_files: []