class
   Process::Status
 
  
  Overview
The status of a terminated process. Returned by Process#wait.
Defined in:
process/status.crInstance Method Summary
- 
        #==(other : self)
        
          Returns trueif this reference is the same as other.
- 
        #abnormal_exit? : Bool
        
          Returns trueif the process terminated abnormally.
- 
        #description
        
          Returns a textual description of this process status. 
- 
        #exit_code : Int32
        
          Returns the exit code of the process if it exited normally ( #normal_exit?).
- 
        #exit_code? : Int32 | Nil
        
          Returns the exit code of the process if it exited normally. 
- 
        #exit_reason : ExitReason
        
          Returns a platform-independent reason why the process terminated. 
- 
        #exit_signal : Signal
        
          If #signal_exit?istrue, returns the Signal the process received and didn't handle.
- 
        #exit_signal? : Signal | Nil
        
          Returns the exit Signalornilif there is none.
- 
        #exit_status : Int32
        
          Platform-specific exit status code, which usually contains either the exit code or a termination signal. DEPRECATED Use #exit_reason,#exit_code, or#system_exit_statusinstead
- #hash(hasher)
- 
        #inspect(io : IO) : Nil
        
          Prints a textual representation of the process status to io. 
- 
        #normal_exit? : Bool
        
          Returns trueif the process terminated normally.
- 
        #signal_exit? : Bool
        
          Returns trueif the process was terminated by a signal.
- 
        #success? : Bool
        
          Returns trueif the process exited normally with an exit code of0.
- 
        #system_exit_status : UInt32
        
          Returns the exit status as indicated by the operating system. 
- 
        #to_s(io : IO) : Nil
        
          Prints a textual representation of the process status to io. 
- 
        #to_s : String
        
          Returns a textual representation of the process status. 
Instance methods inherited from class Reference
  
  
    
      ==(other : self)==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==, dup dup, hash(hasher) hash, initialize initialize, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, pretty_print(pp) : Nil pretty_print, same?(other : Reference) : Bool
same?(other : Nil) same?, to_s(io : IO) : Nil to_s
Constructor methods inherited from class Reference
  
  
    
      new
    new, 
    
  
    
      unsafe_construct(address : Pointer, *args, **opts) : self
    unsafe_construct
    
  
      
  Class methods inherited from class Reference
  
  
    
      pre_initialize(address : Pointer)
    pre_initialize
    
  
      
    
      
  Instance methods inherited from class Object
  
  
    
      ! : Bool
    !, 
    
  
    
      !=(other)
    !=, 
    
  
    
      !~(other)
    !~, 
    
  
    
      ==(other)
    ==, 
    
  
    
      ===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as
Class methods inherited from class Object
  
  
    
      from_json(string_or_io, root : String)from_json(string_or_io) from_json, from_yaml(string_or_io : String | IO) from_yaml
Macros inherited from class Object
  
  
    
      class_getter(*names, &block)
    class_getter, 
    
  
    
      class_getter!(*names)
    class_getter!, 
    
  
    
      class_getter?(*names, &block)
    class_getter?, 
    
  
    
      class_property(*names, &block)
    class_property, 
    
  
    
      class_property!(*names)
    class_property!, 
    
  
    
      class_property?(*names, &block)
    class_property?, 
    
  
    
      class_setter(*names)
    class_setter, 
    
  
    
      def_clone
    def_clone, 
    
  
    
      def_equals(*fields)
    def_equals, 
    
  
    
      def_equals_and_hash(*fields)
    def_equals_and_hash, 
    
  
    
      def_hash(*fields)
    def_hash, 
    
  
    
      delegate(*methods, to object)
    delegate, 
    
  
    
      forward_missing_to(delegate)
    forward_missing_to, 
    
  
    
      getter(*names, &block)
    getter, 
    
  
    
      getter!(*names)
    getter!, 
    
  
    
      getter?(*names, &block)
    getter?, 
    
  
    
      property(*names, &block)
    property, 
    
  
    
      property!(*names)
    property!, 
    
  
    
      property?(*names, &block)
    property?, 
    
  
    
      setter(*names)
    setter
    
  
    
  Instance Method Detail
Returns true if this reference is the same as other. Invokes same?.
Returns true if the process terminated abnormally.
Equivalent to ExitReason#abnormal?
- #exit_reasonprovides more insights into the specific exit reason.
- #normal_exit?returns the inverse.
Returns a textual description of this process status.
Process::Status.new(0).description # => "Process exited normally"
process = Process.new("sleep", ["10"])
process.terminate
process.wait.description # => "Process received and didn't handle signal TERM (15)"ExitReason#description provides the specific messages for non-signal exits.
Returns the exit code of the process if it exited normally (#normal_exit?).
Raises RuntimeError if the status describes an abnormal exit.
Process.run("true").exit_code                                # => 0
Process.run("exit 123", shell: true).exit_code               # => 123
Process.new("sleep", ["10"]).tap(&.terminate).wait.exit_code # RuntimeError: Abnormal exit has no exit codeReturns the exit code of the process if it exited normally.
Returns nil if the status describes an abnormal exit.
Process.run("true").exit_code?                                # => 0
Process.run("exit 123", shell: true).exit_code?               # => 123
Process.new("sleep", ["10"]).tap(&.terminate).wait.exit_code? # => nilIf #signal_exit? is true, returns the Signal the process
received and didn't handle. Will raise if #signal_exit? is false.
Available only on Unix-like operating systems.
NOTE  #exit_reason is preferred over this method as a portable alternative
which also works on Windows.
Returns the exit Signal or nil if there is none.
On Windows returns always nil.
- #exit_reasonis a portable alternative.
Platform-specific exit status code, which usually contains either the exit code or a termination signal.
The other Process::Status methods extract the values from #exit_status.
DEPRECATED  Use #exit_reason, #exit_code, or #system_exit_status instead
Prints a textual representation of the process status to io.
The result is similar to #to_s, but prefixed by the type name,
delimited by square brackets, and constants use full paths:
Process::Status[0], Process::Status[1], Process::Status[Signal::HUP],
Process::Status[LibC::STATUS_CONTROL_C_EXIT].
Returns true if the process terminated normally.
Equivalent to ExitReason::Normal
- #exit_reasonprovides more insights into other exit reasons.
- #abnormal_exit?returns the inverse.
Returns true if the process was terminated by a signal.
NOTE  In contrast to WIFSIGNALED in glibc, the status code 0x7E (SIGSTOP)
is considered a signal.
- #abnormal_exit?is a more portable alternative.
- #exit_signal?provides more information about the signal.
Returns the exit status as indicated by the operating system.
It can encode exit codes and termination signals and is platform-specific.
Prints a textual representation of the process status to io.
A normal exit status prints the numerical value (0, 1 etc) or a named
status (e.g. STATUS_CONTROL_C_EXIT on Windows).
A signal exit status prints the name of the Signal member (HUP, INT, etc.).