module Kernel

() → Symbol?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 709
def self?.__callee__: () -> Symbol?

Returns the called name of the current method as a Symbol. If called outside of a method, it returns nil.

() → String?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 720
def self?.__dir__: () -> String?

Returns the canonicalized absolute path of the directory of the file from which this method is called. It means symlinks in the path is resolved. If __FILE__ is nil, it returns nil. The return value equals to File.dirname(File.realpath(*FILE*)).

() → Symbol?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 729
def self?.__method__: () -> Symbol?

Returns the name at the definition of the current method as a Symbol. If called outside of a method, it returns nil.

(String arg0) → String

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 750
def self?.`: (String arg0) -> String

Returns the $stdout output from running command in a subshell; sets global variable $? to the process status.

This method has potential security vulnerabilities if called with untrusted input; see Command Injection.

Examples:

$ `date`                 # => "Wed Apr  9 08:56:30 CDT 2003\n"
$ `echo oops && exit 99` # => "oops\n"
$ $?                     # => #<Process::Status: pid 17088 exit 99>
$ $?.exitstatus          # => 99

The built-in syntax %x{...} uses this method.

(nil) → [ ]
[T] (array[T] | _ToA[T] array_like) → Array[T]
[T] (T ele) → [ T ]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 443
def self?.Array: (nil) -> []
                 | [T] (array[T] | _ToA[T] array_like) -> Array[T]
                 | [T] (T ele) -> [T]

Returns an array converted from object.

Tries to convert object to an array using to_ary first and to_a second:

Array([0, 1, 2])        # => [0, 1, 2]
Array({foo: 0, bar: 1}) # => [[:foo, 0], [:bar, 1]]
Array(0..4)             # => [0, 1, 2, 3, 4]

Returns object in an array, [object], if object cannot be converted:

Array(:foo)             # => [:foo]

(real | string | BigDecimal initial, ?int digits, ?exception: bool) → BigDecimal

# File vendor/bundle/ruby/4.0.0/gems/bigdecimal-4.1.2/sig/big_decimal.rbs, line 1240
def self?.BigDecimal: (real | string | BigDecimal initial, ?int digits, ?exception: bool) -> BigDecimal

Returns the BigDecimal converted from value with a precision of ndigits decimal digits.

When ndigits is less than the number of significant digits in the value, the result is rounded to that number of digits, according to the current rounding mode; see BigDecimal.mode.

When ndigits is 0, the number of digits to correctly represent a float number is determined automatically.

Returns value converted to a BigDecimal, depending on the type of value:

• Integer, Float, Rational, Complex, or BigDecimal: converted directly:

  # Integer, Complex, or BigDecimal value does not require ndigits; ignored if given.
  BigDecimal(2)                     # => 0.2e1
  BigDecimal(Complex(2, 0))         # => 0.2e1
  BigDecimal(BigDecimal(2))         # => 0.2e1
  # Float or Rational value requires ndigits.
  BigDecimal(2.0, 0)                # => 0.2e1
  BigDecimal(Rational(2, 1), 0)     # => 0.2e1
  

• String: converted by parsing if it contains an integer or floating-point literal; leading and trailing whitespace is ignored:

  # String does not require ndigits; ignored if given.
  BigDecimal('2')     # => 0.2e1
  BigDecimal('2.0')   # => 0.2e1
  BigDecimal('0.2e1') # => 0.2e1
  BigDecimal(' 2.0 ') # => 0.2e1
  

• Other type that responds to method :to_str: first converted to a string, then converted to a BigDecimal, as above.

• Other type:

  • Raises an exception if keyword argument exception is true.

  • Returns nil if keyword argument exception is false.

Raises an exception if value evaluates to a Float and digits is larger than Float::DIG + 1.

---

Returns the BigDecimal converted from value with a precision of ndigits decimal digits.

When ndigits is less than the number of significant digits in the value, the result is rounded to that number of digits, according to the current rounding mode; see BigDecimal.mode.

When ndigits is 0, the number of digits to correctly represent a float number is determined automatically.

Returns value converted to a BigDecimal, depending on the type of value:

• Integer, Float, Rational, Complex, or BigDecimal: converted directly:

  # Integer, Complex, or BigDecimal value does not require ndigits; ignored if given.
  BigDecimal(2)                     # => 0.2e1
  BigDecimal(Complex(2, 0))         # => 0.2e1
  BigDecimal(BigDecimal(2))         # => 0.2e1
  # Float or Rational value requires ndigits.
  BigDecimal(2.0, 0)                # => 0.2e1
  BigDecimal(Rational(2, 1), 0)     # => 0.2e1
  

• String: converted by parsing if it contains an integer or floating-point literal; leading and trailing whitespace is ignored:

  # String does not require ndigits; ignored if given.
  BigDecimal('2')     # => 0.2e1
  BigDecimal('2.0')   # => 0.2e1
  BigDecimal('0.2e1') # => 0.2e1
  BigDecimal(' 2.0 ') # => 0.2e1
  

• Other type that responds to method :to_str: first converted to a string, then converted to a BigDecimal, as above.

• Other type:

  • Raises an exception if keyword argument exception is true.

  • Returns nil if keyword argument exception is false.

Raises an exception if value evaluates to a Float and digits is larger than Float::DIG + 1.

(_ToC complex_like, ?exception: true) → Complex
(_ToC complex_like, exception: bool) → Complex?
(Numeric | String real, ?Numeric | String imag, ?exception: true) → Complex
(Numeric | String real, ?Numeric | String imag, exception: bool) → Complex?
(untyped, ?untyped, ?exception: bool) → Complex?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 498
def self?.Complex: (_ToC complex_like, ?exception: true) -> Complex
                   | (_ToC complex_like, exception: bool) -> Complex?
                   | (Numeric | String real, ?Numeric | String imag, ?exception: true) -> Complex
                   | (Numeric | String real, ?Numeric | String imag, exception: bool) -> Complex?
                   | (untyped, ?untyped, ?exception: bool) -> Complex?

Returns a new Complex object if the arguments are valid; otherwise raises an exception if exception is true; otherwise returns nil.

With Numeric arguments real and imag, returns Complex.rect(real, imag) if the arguments are valid.

With string argument s, returns a new Complex object if the argument is valid; the string may have:

• One or two numeric substrings, each of which specifies a Complex, Float, Integer, Numeric, or Rational value, specifying rectangular coordinates:

  • Sign-separated real and imaginary numeric substrings (with trailing character 'i'):

    Complex('1+2i')  # => (1+2i)
    Complex('+1+2i') # => (1+2i)
    Complex('+1-2i') # => (1-2i)
    Complex('-1+2i') # => (-1+2i)
    Complex('-1-2i') # => (-1-2i)
    

  • Real-only numeric string (without trailing character 'i'):

    Complex('1')  # => (1+0i)
    Complex('+1') # => (1+0i)
    Complex('-1') # => (-1+0i)
    

  • Imaginary-only numeric string (with trailing character 'i'):

    Complex('1i')  # => (0+1i)
    Complex('+1i') # => (0+1i)
    Complex('-1i') # => (0-1i)
    

• At-sign separated real and imaginary rational substrings, each of which specifies a Rational value, specifying polar coordinates:

  Complex('1/2@3/4')   # => (0.36584443443691045+0.34081938001166706i)
  Complex('+1/2@+3/4') # => (0.36584443443691045+0.34081938001166706i)
  Complex('+1/2@-3/4') # => (0.36584443443691045-0.34081938001166706i)
  Complex('-1/2@+3/4') # => (-0.36584443443691045-0.34081938001166706i)
  Complex('-1/2@-3/4') # => (-0.36584443443691045+0.34081938001166706i)
  

(_ToF float_like, ?exception: true) → Float
(_ToF float_like, exception: bool) → Float?
(untyped, ?exception: bool) → Float?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 520
def self?.Float: (_ToF float_like, ?exception: true) -> Float
                 | (_ToF float_like, exception: bool) -> Float?
                 | (untyped, ?exception: bool) -> Float?

Returns arg converted to a float. Numeric types are converted directly, and with exception to String and nil, the rest are converted using arg.to_f. Converting a String with invalid characters will result in an ArgumentError. Converting nil generates a TypeError. Exceptions can be suppressed by passing exception: false.

Float(1)                 #=> 1.0
Float("123.456")         #=> 123.456
Float("123.0_badstring") #=> ArgumentError: invalid value for Float(): "123.0_badstring"
Float(nil)               #=> TypeError: can't convert nil into Float
Float("123.0_badstring", exception: false)  #=> nil

[K, V] (nil | [ ] _empty) → Hash[K, V]
[K, V] (hash[K, V] hash_like) → Hash[K, V]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 545
def self?.Hash: [K, V] (nil | [] _empty) -> Hash[K, V]
                | [K, V] (hash[K, V] hash_like) -> Hash[K, V]

Returns a hash converted from object.

• If object is:

  • A hash, returns object.

  • An empty array or nil, returns an empty hash.

• Otherwise, if object.to_hash returns a hash, returns that hash.

• Otherwise, returns TypeError.

Examples:

Hash({foo: 0, bar: 1}) # => {:foo=>0, :bar=>1}
Hash(nil)              # => {}
Hash([])               # => {}

(int | _ToI int_like, ?exception: true) → Integer
(int | _ToI int_like, exception: bool) → Integer?
(string str, int base, ?exception: true) → Integer
(string str, int base, exception: bool) → Integer?
(untyped, ?untyped, ?exception: bool) → Integer?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 631
def self?.Integer: (int | _ToI int_like, ?exception: true) -> Integer
                   | (int | _ToI int_like, exception: bool) -> Integer?
                   | (string str, int base, ?exception: true) -> Integer
                   | (string str, int base, exception: bool) -> Integer?
                   | (untyped, ?untyped, ?exception: bool) -> Integer?

Returns an integer converted from object.

Tries to convert object to an integer using to_int first and to_i second; see below for exceptions.

With a non-zero base, object must be a string or convertible to a string.

Numeric objects

With an integer argument object given, returns object:

Integer(1)                # => 1
Integer(-1)               # => -1

With a floating-point argument object given, returns object truncated to an integer:

Integer(1.9)              # => 1  # Rounds toward zero.
Integer(-1.9)             # => -1 # Rounds toward zero.

String objects

With a string argument object and zero base given, returns object converted to an integer in base 10:

Integer('100')    # => 100
Integer('-100')   # => -100

With base zero, string object may contain leading characters to specify the actual base (radix indicator):

Integer('0100')  # => 64  # Leading '0' specifies base 8.
Integer('0b100') # => 4   # Leading '0b' specifies base 2.
Integer('0x100') # => 256 # Leading '0x' specifies base 16.

With a positive base (in range 2..36) given, returns object converted to an integer in the given base:

Integer('100', 2)   # => 4
Integer('100', 8)   # => 64
Integer('-100', 16) # => -256

With a negative base (in range -36..-2) given, returns object converted to the radix indicator if it exists or base:

Integer('0x100', -2)   # => 256
Integer('100', -2)     # => 4
Integer('0b100', -8)   # => 4
Integer('100', -8)     # => 64
Integer('0o100', -10)  # => 64
Integer('100', -10)    # => 100

base -1 is equivalent to the -10 case.

When converting strings, surrounding whitespace and embedded underscores are allowed and ignored:

Integer(' 100 ')      # => 100
Integer('-1_0_0', 16) # => -256

Other classes

Examples with object of various other classes:

Integer(Rational(9, 10)) # => 0  # Rounds toward zero.
Integer(Complex(2, 0))   # => 2  # Imaginary part must be zero.
Integer(Time.now)        # => 1650974042

Keywords

With the optional keyword argument exception given as true (the default):

• Raises TypeError if object does not respond to to_int or to_i.

• Raises TypeError if object is nil.

• Raises ArgumentError if object is an invalid string.

With exception given as false, an exception of any kind is suppressed and nil is returned.

(string | Pathname) → Pathname

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/pathname.rbs, line 1311
def self?.Pathname: (string | Pathname) -> Pathname

Creates a Pathname object.

(int | _ToR rational_like, ?exception: true) → Rational
(int | _ToR rational_like, exception: bool) → Rational?
(int | _ToR numer, ?int | _ToR denom, ?exception: true) → Rational
(int | _ToR numer, ?int | _ToR denom, exception: bool) → Rational?
[T] (Numeric & _RationalDiv[T] numer, Numeric denom, ?exception: bool) → T
[T < Numeric] (T value, 1, ?exception: bool) → T
(untyped, ?untyped, ?exception: bool) → Rational?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 674
def self?.Rational: (int | _ToR rational_like, ?exception: true) -> Rational
                    | (int | _ToR rational_like, exception: bool) -> Rational?
                    | (int | _ToR numer, ?int | _ToR denom, ?exception: true) -> Rational
                    | (int | _ToR numer, ?int | _ToR denom, exception: bool) -> Rational?
                    | [T] (Numeric & _RationalDiv[T] numer, Numeric denom, ?exception: bool) -> T
                    | [T < Numeric] (T value, 1, ?exception: bool) -> T
                    | (untyped, ?untyped, ?exception: bool) -> Rational?

Returns x/y or arg as a Rational.

Rational(2, 3)   #=> (2/3)
Rational(5)      #=> (5/1)
Rational(0.5)    #=> (1/2)
Rational(0.3)    #=> (5404319552844595/18014398509481984)

Rational("2/3")  #=> (2/3)
Rational("0.3")  #=> (3/10)

Rational("10 cents")  #=> ArgumentError
Rational(nil)         #=> TypeError
Rational(1, nil)      #=> TypeError

Rational("10 cents", exception: false)  #=> nil

Syntax of the string form:

string form = extra spaces , rational , extra spaces ;
rational = [ sign ] , unsigned rational ;
unsigned rational = numerator | numerator , "/" , denominator ;
numerator = integer part | fractional part | integer part , fractional part ;
denominator = digits ;
integer part = digits ;
fractional part = "." , digits , [ ( "e" | "E" ) , [ sign ] , digits ] ;
sign = "-" | "+" ;
digits = digit , { digit | "_" , digit } ;
digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
extra spaces = ? \s* ? ;

See also String#to_r.

(string | _ToS string_like) → String

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 700
def self?.String: (string | _ToS string_like) -> String

Returns a string converted from object.

Tries to convert object to a string using to_str first and to_s second:

String([0, 1, 2])        # => "[0, 1, 2]"
String(0..5)             # => "0..5"
String({foo: 0, bar: 1}) # => "{foo: 0, bar: 1}"

Raises TypeError if object cannot be converted to a string.

(URI::Generic | string uri) → URI::Generic

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/stdlib/uri/0/common.rbs, line 620
def self?.URI: (URI::Generic | string uri) -> URI::Generic

Returns a URI object derived from the given uri, which may be a URI string or an existing URI object:

require 'uri'
# Returns a new URI.
uri = URI('http://github.com/ruby/ruby')
# => #<URI::HTTP http://github.com/ruby/ruby>
# Returns the given URI.
URI(uri)
# => #<URI::HTTP http://github.com/ruby/ruby>

You must require ‘uri’ to use this method.

(?string msg) → bot

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 764
def self?.abort: (?string msg) -> bot

Terminates execution immediately, effectively by calling Kernel.exit(false).

If string argument msg is given, it is written to STDERR prior to termination; otherwise, if an exception was raised, prints its message and backtrace.

() { () → void } → Proc

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 785
def self?.at_exit: () { () -> void } -> Proc

Converts block to a Proc object (and therefore binds it at the point of call) and registers it for execution when the program exits. If multiple handlers are registered, they are executed in reverse order of registration.

def do_at_exit(str1)
  at_exit { print str1 }
end
at_exit { puts "cruel world" }
do_at_exit("goodbye ")
exit

produces:

goodbye cruel world

(interned const, path filename) → nil

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 801
def self?.autoload: (interned const, path filename) -> nil

Registers filename to be loaded (using Kernel::require) the first time that const (which may be a String or a symbol) is accessed.

autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")

If const is defined as autoload, the file name to be loaded is replaced with filename. If const is defined but not as autoload, does nothing.

Files that are currently being loaded must not be registered for autoload.

(interned name, ?boolish inherit) → String?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 825
def self?.autoload?: (interned name, ?boolish inherit) -> String?

Returns filename to be loaded if name is registered as autoload in the current namespace or one of its ancestors.

autoload(:B, "b")
autoload?(:B)            #=> "b"

module C
  autoload(:D, "d")
  autoload?(:D)          #=> "d"
  autoload?(:B)          #=> nil
end

class E
  autoload(:F, "f")
  autoload?(:F)          #=> "f"
  autoload?(:B)          #=> "b"
end

() → Binding

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 868
def self?.binding: () -> Binding

Returns a Binding object, describing the variable and method bindings at the point of call. This object can be used when calling Binding#eval to execute the evaluated command in this environment, or extracting its local variables.

class User
  def initialize(name, position)
    @name = name
    @position = position
  end

  def get_binding
    binding
  end
end

user = User.new('Joan', 'manager')
template = '{name: @name, position: @position}'

# evaluate template in context of the object
eval(template, user.get_binding)
#=> {:name=>"Joan", :position=>"manager"}

Binding#local_variable_get can be used to access the variables whose names are reserved Ruby keywords:

# This is valid parameter declaration, but `if` parameter can't
# be accessed by name, because it is a reserved word.
def validate(field, validation, if: nil)
  condition = binding.local_variable_get('if')
  return unless condition

  # ...Some implementation ...
end

validate(:name, :empty?, if: false) # skips validation
validate(:name, :empty?, if: true) # performs validation

() → bool

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 315
def self?.block_given?: () -> bool

Returns true if yield would execute a block in the current context. The iterator? form is mildly deprecated.

def try
  if block_given?
    yield
  else
    "no block"
  end
end
try                  #=> "no block"
try { "hello" }      #=> "hello"
try do "hello" end   #=> "hello"

() → Array[String]
(int start, ?int? length) → Array[String]?
(range[int] range) → Array[String]?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 185
def self?.caller: () -> Array[String]
                  | (int start, ?int? length) -> Array[String]?
                  | (range[int] range) -> Array[String]?

Returns the current execution stack—an array containing strings in the form file:line or file:line: in `method'.

The optional start parameter determines the number of initial stack entries to omit from the top of the stack.

A second optional length parameter can be used to limit how many entries are returned from the stack.

Returns nil if start is greater than the size of current execution stack.

Optionally you can pass a range, which will return an array containing the entries within the specified range.

def a(skip)
  caller(skip)
end
def b(skip)
  a(skip)
end
def c(skip)
  b(skip)
end
c(0)   #=> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10:in `<main>'"]
c(1)   #=> ["prog:5:in `b'", "prog:8:in `c'", "prog:11:in `<main>'"]
c(2)   #=> ["prog:8:in `c'", "prog:12:in `<main>'"]
c(3)   #=> ["prog:13:in `<main>'"]
c(4)   #=> []
c(5)   #=> nil

() → Array[Thread::Backtrace::Location]
(int start, ?int? length) → Array[Thread::Backtrace::Location]?
(range[int] range) → Array[Thread::Backtrace::Location]?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 210
def self?.caller_locations: () -> Array[Thread::Backtrace::Location]
                            | (int start, ?int? length) -> Array[Thread::Backtrace::Location]?
                            | (range[int] range) -> Array[Thread::Backtrace::Location]?

Returns the current execution stack—an array containing backtrace location objects.

See Thread::Backtrace::Location for more information.

The optional start parameter determines the number of initial stack entries to omit from the top of the stack.

A second optional length parameter can be used to limit how many entries are returned from the stack.

Returns nil if start is greater than the size of current execution stack.

Optionally you can pass a range, which will return an array containing the entries within the specified range.

[T] (T tag) { (T tag) → untyped } → untyped
() { (Object tag) → untyped } → untyped

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 264
def self?.catch: [T] (T tag) { (T tag) -> untyped } -> untyped
                 | () { (Object tag) -> untyped } -> untyped

catch executes its block. If throw is not called, the block executes normally, and catch returns the value of the last expression evaluated.

catch(1) { 123 }            # => 123

If throw(tag2, val) is called, Ruby searches up its stack for a catch block whose tag has the same object_id as tag2. When found, the block stops executing and returns val (or nil if no second argument was given to throw).

catch(1) { throw(1, 456) }  # => 456
catch(1) { throw(1) }       # => nil

When tag is passed as the first argument, catch yields it as the parameter of the block.

catch(1) {|x| x + 2 }       # => 3

When no tag is given, catch yields a new unique object (as from Object.new) as the block parameter. This object can then be used as the argument to throw, and will match the correct catch block.

catch do |obj_A|
  catch do |obj_B|
    throw(obj_B, 123)
    puts "This puts is not reached"
  end

  puts "This puts is displayed"
  456
end

# => 456

catch do |obj_A|
  catch do |obj_B|
    throw(obj_A, 123)
    puts "This puts is still not reached"
  end

  puts "Now this puts is also not reached"
  456
end

# => 123

(string src, ?Binding? scope, ?string filename, ?int lineno) → untyped

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 295
def self?.eval: (string src, ?Binding? scope, ?string filename, ?int lineno) -> untyped

Evaluates the Ruby expression(s) in string. If binding is given, which must be a Binding object, the evaluation is performed in its context. If the optional filename and lineno parameters are present, they will be used when reporting syntax errors.

def get_binding(str)
  return binding
end
str = "hello"
eval "str + ' Fred'"                      #=> "hello Fred"
eval "str + ' Fred'", get_binding("bye")  #=> "bye Fred"

(String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String) → bot
(Hash[string, string?] env, String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String) → bot

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2013
def self?.exec: (String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String) -> bot
                | (Hash[string, string?] env, String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String) -> bot

Replaces the current process by doing one of the following:

• Passing string command_line to the shell.

• Invoking the executable at exe_path.

This method has potential security vulnerabilities if called with untrusted input; see Command Injection.

The new process is created using the [exec system call](pubs.opengroup.org/onlinepubs/9699919799.2018edition/functions/e xecve.html); it may inherit some of its environment from the calling program (possibly including open file descriptors).

Argument env, if given, is a hash that affects ENV for the new process; see Execution Environment.

Argument options is a hash of options for the new process; see Execution Options.

The first required argument is one of the following:

• command_line if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more meta characters.

• exe_path otherwise.

<strong>Argument command_line</strong>

String argument command_line is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:

exec('if true; then echo "Foo"; fi') # Shell reserved word.
exec('exit')                         # Built-in.
exec('date > date.tmp')              # Contains meta character.

The command line may also contain arguments and options for the command:

exec('echo "Foo"')

Output:

Foo

See Execution Shell for details about the shell.

Raises an exception if the new process could not execute.

<strong>Argument exe_path</strong>

Argument exe_path is one of the following:

• The string path to an executable to be called.

• A 2-element array containing the path to an executable and the string to be used as the name of the executing process.

Example:

exec('/usr/bin/date')

Output:

Sat Aug 26 09:38:00 AM CDT 2023

Ruby invokes the executable directly. This form does not use the shell; see Arguments args for caveats.

exec('doesnt_exist') # Raises Errno::ENOENT

If one or more args is given, each is an argument or option to be passed to the executable:

exec('echo', 'C*')
exec('echo', 'hello', 'world')

Output:

C*
hello world

Raises an exception if the new process could not execute.

(?int | bool status) → bot

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 912
def self?.exit: (?int | bool status) -> bot

Initiates termination of the Ruby script by raising SystemExit; the exception may be caught. Returns exit status status to the underlying operating system.

Values true and false for argument status indicate, respectively, success and failure; The meanings of integer values are system-dependent.

Example:

begin
  exit
  puts 'Never get here.'
rescue SystemExit
  puts 'Rescued a SystemExit exception.'
end
puts 'After begin block.'

Output:

Rescued a SystemExit exception.
After begin block.

Just prior to final termination, Ruby executes any at-exit procedures (see Kernel::at_exit) and any object finalizers (see ObjectSpace::define_finalizer).

Example:

at_exit { puts 'In at_exit function.' }
ObjectSpace.define_finalizer('string', proc { puts 'In finalizer.' })
exit

Output:

In at_exit function.
In finalizer.

(?int | bool status) → bot

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 927
def self?.exit!: (?int | bool status) -> bot

Exits the process immediately; no exit handlers are called. Returns exit status status to the underlying operating system.

Process.exit!(true)

Values true and false for argument status indicate, respectively, success and failure; The meanings of integer values are system-dependent.

() → bot
(string message, ?cause: Exception?) → bot
(_Exception exception, ?string | _ToS message, ?String | Array[String] | Array[Thread::Backtrace::Location] | nil backtrace, ?cause: Exception?) → bot
(_Exception exception, ?cause: Exception?, **untyped) → bot

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1029
def self?.fail: () -> bot
                | (string message, ?cause: Exception?) -> bot
                | (_Exception exception, ?string | _ToS message, ?String | Array[String] | Array[Thread::Backtrace::Location] | nil backtrace, ?cause: Exception?) -> bot
                | (_Exception exception, ?cause: Exception?, **untyped) -> bot

Raises an exception; see Exceptions.

Argument exception sets the class of the new exception; it should be class Exception or one of its subclasses (most commonly, RuntimeError or StandardError), or an instance of one of those classes:

begin
  raise(StandardError)
rescue => x
  p x.class
end
# => StandardError

Argument message sets the stored message in the new exception, which may be retrieved by method Exception#message; the message must be a string-convertible object or nil:

begin
  raise(StandardError, 'Boom')
rescue => x
  p x.message
end
# => "Boom"

If argument message is not given, the message is the exception class name.

See Messages.

Argument backtrace might be used to modify the backtrace of the new exception, as reported by Exception#backtrace and Exception#backtrace_locations; the backtrace must be an array of Thread::Backtrace::Location, an array of strings, a single string, or nil.

Using the array of Thread::Backtrace::Location instances is the most consistent option and should be preferred when possible. The necessary value might be obtained from #caller_locations, or copied from Exception#backtrace_locations of another error:

begin
  do_some_work()
rescue ZeroDivisionError => ex
  raise(LogicalError, "You have an error in your math", ex.backtrace_locations)
end

The ways, both Exception#backtrace and Exception#backtrace_locations of the raised error are set to the same backtrace.

When the desired stack of locations is not available and should be constructed from scratch, an array of strings or a singular string can be used. In this case, only Exception#backtrace is set:

begin
  raise(StandardError, 'Boom', %w[dsl.rb:3 framework.rb:1])
rescue => ex
  p ex.backtrace
  # => ["dsl.rb:3", "framework.rb:1"]
  p ex.backtrace_locations
  # => nil
end

If argument backtrace is not given, the backtrace is set according to an array of Thread::Backtrace::Location objects, as derived from the call stack.

See Backtraces.

Keyword argument cause sets the stored cause in the new exception, which may be retrieved by method Exception#cause; the cause must be an exception object (Exception or one of its subclasses), or nil:

begin
  raise(StandardError, cause: RuntimeError.new)
rescue => x
  p x.cause
end
# => #<RuntimeError: RuntimeError>

If keyword argument cause is not given, the cause is the value of $!.

See Cause.

In the alternate calling sequence, where argument exception not given, raises a new exception of the class given by $!, or of class RuntimeError if $! is nil:

begin
  raise
rescue => x
  p x
end
# => RuntimeError

With argument exception not given, argument message and keyword argument cause may be given, but argument backtrace may not be given.

cause can not be given as an only argument.

() → Integer?
() { () → void } → Integer

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 423
def self?.fork: () -> Integer?
                | () { () -> void } -> Integer

Creates a child process.

With a block given, runs the block in the child process; on block exit, the child terminates with a status of zero:

puts "Before the fork: #{Process.pid}"
fork do
  puts "In the child process: #{Process.pid}"
end                   # => 382141
puts "After the fork: #{Process.pid}"

Output:

Before the fork: 420496
After the fork: 420496
In the child process: 420520

With no block given, the fork call returns twice:

• Once in the parent process, returning the pid of the child process.

• Once in the child process, returning nil.

Example:

puts "This is the first line before the fork (pid #{Process.pid})"
puts fork
puts "This is the second line after the fork (pid #{Process.pid})"

Output:

This is the first line before the fork (pid 420199)
420223
This is the second line after the fork (pid 420199)

This is the second line after the fork (pid 420223)

In either case, the child process may exit using Kernel.exit! to avoid the call to Kernel#at_exit.

To avoid zombie processes, the parent process should call either:

• Process.wait, to collect the termination statuses of its children.

• Process.detach, to register disinterest in their status.

The thread calling fork is the only thread in the created child process; fork doesn’t copy other threads.

Note that method fork is available on some platforms, but not on others:

Process.respond_to?(:fork) # => true # Would be false on some.

If not, you may use ::spawn instead of fork.

(String format, *untyped args) → String

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1148
def self?.format: (String format, *untyped args) -> String

Returns the string resulting from formatting objects into format_string.

For details on format_string, see Format Specifications.

(String, *String) → void

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/sig/shims/rubygems.rbs, line 17
def self?.gem: (String, *String) -> void

(?String sep, ?Integer limit, ?chomp: boolish) → String?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1193
def self?.gets: (?String sep, ?Integer limit, ?chomp: boolish) -> String?

Returns (and assigns to $_) the next line from the list of files in ARGV (or $*), or from standard input if no files are present on the command line. Returns nil at end of file. The optional argument specifies the record separator. The separator is included with the contents of each record. A separator of nil reads the entire contents, and a zero-length separator reads the input one paragraph at a time, where paragraphs are divided by two consecutive newlines. If the first argument is an integer, or optional second argument is given, the returning string would not be longer than the given value in bytes. If multiple filenames are present in ARGV, gets(nil) will read the contents one file at a time.

ARGV << "testfile"
print while gets

produces:

This is line one
This is line two
This is line three
And so on...

The style of programming using $_ as an implicit parameter is gradually losing favor in the Ruby community.

() → Array[Symbol]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1206
def self?.global_variables: () -> Array[Symbol]

Returns an array of the names of global variables. This includes special regexp global variables such as $~ and $+, but does not include the numbered regexp global variables ($1, $2, etc.).

global_variables.grep /std/   #=> [:$stdin, :$stdout, :$stderr]

() { () → untyped } → Proc

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1395
def self?.lambda: () { () -> untyped } -> Proc

Equivalent to Proc.new, except the resulting Proc objects check the number of parameters passed when called.

(String filename, ?Module | bool) → bool

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1235
def self?.load: (String filename, ?Module | bool) -> bool

Loads and executes the Ruby program in the file filename.

If the filename is an absolute path (e.g. starts with ‘/’), the file will be loaded directly using the absolute path.

If the filename is an explicit relative path (e.g. starts with ‘./’ or ‘../’), the file will be loaded using the relative path from the current directory.

Otherwise, the file will be searched for in the library directories listed in $LOAD_PATH ($:). If the file is found in a directory, it will attempt to load the file relative to that directory. If the file is not found in any of the directories in $LOAD_PATH, the file will be loaded using the relative path from the current directory.

If the file doesn’t exist when there is an attempt to load it, a LoadError will be raised.

If the optional wrap parameter is true, the loaded script will be executed under an anonymous module. If the optional wrap parameter is a module, the loaded script will be executed under the given module. In no circumstance will any local variables in the loaded file be propagated to the loading environment.

() → Array[Symbol]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 339
def self?.local_variables: () -> Array[Symbol]

Returns the names of the current local variables.

fred = 1
for i in 1..10
   # ...
end
local_variables   #=> [:fred, :i]

() { () → void } → bot
() → ::Enumerator[nil, bot]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1267
def self?.loop: () { () -> void } -> bot
                | () -> ::Enumerator[nil, bot]

Repeatedly executes the block.

If no block is given, an enumerator is returned instead.

loop do
  print "Input: "
  line = gets
  # break if q, Q is entered or EOF signal (Ctrl-D on Unix, Ctrl-Z on windows) is sent
  break if !line or line =~ /^q/i
  # ...
end

A StopIteration raised in the block breaks the loop. In this case, loop returns the “result” value stored in the exception.

enum = Enumerator.new { |y|
  y << "one"
  y << "two"
  :ok
}

result = loop {
  puts enum.next
} #=> :ok

(String name, ?String mode, ?Integer perm) → IO?
[T] (String name, ?String mode, ?Integer perm) { (IO) → T } → T

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1292
def self?.open: (String name, ?String mode, ?Integer perm) -> IO?
                | [T] (String name, ?String mode, ?Integer perm) { (IO) -> T } -> T

Creates an IO object connected to the given file.

With no block given, file stream is returned:

open('t.txt') # => #<File:t.txt>

With a block given, calls the block with the open file stream, then closes the stream:

open('t.txt') {|f| p f } # => #<File:t.txt (closed)>

Output:

#<File:t.txt>

See File.open for details.

[T < _Inspect] (T arg0) → T
(_Inspect arg0, _Inspect arg1, *_Inspect rest) → Array[_Inspect]
() → nil

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1449
def self?.p: [T < _Inspect] (T arg0) -> T
             | (_Inspect arg0, _Inspect arg1, *_Inspect rest) -> Array[_Inspect]
             | () -> nil

For each object obj, executes:

$stdout.write(obj.inspect, "\n")

With one object given, returns the object; with multiple objects given, returns an array containing the objects; with no object given, returns nil.

Examples:

r = Range.new(0, 4)
p r                 # => 0..4
p [r, r, r]         # => [0..4, 0..4, 0..4]
p                   # => nil

Output:

0..4
[0..4, 0..4, 0..4]

Kernel#p is designed for debugging purposes. Ruby implementations may define Kernel#p to be uninterruptible in whole or in part. On CRuby, Kernel#p’s writing of data is uninterruptible.

[T] (T arg0) → T
(untyped, untyped, *untyped) → Array[untyped]
() → nil

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1461
def self?.pp: [T] (T arg0) -> T
              | (untyped, untyped, *untyped) -> Array[untyped]
              | () -> nil

prints arguments in pretty form.

#pp returns argument(s).

(*_ToS args) → nil

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1342
def self?.print: (*_ToS args) -> nil

Equivalent to $stdout.print(*objects), this method is the straightforward way to write to $stdout.

Writes the given objects to $stdout; returns nil. Appends the output record separator $OUTPUT_RECORD_SEPARATOR $</code>), if it is not <code>nil.

With argument objects given, for each object:

• Converts via its method to_s if not a string.

• Writes to stdout.

• If not the last object, writes the output field separator $OUTPUT_FIELD_SEPARATOR ($, if it is not nil.

With default separators:

objects = [0, 0.0, Rational(0, 1), Complex(0, 0), :zero, 'zero']
$OUTPUT_RECORD_SEPARATOR
$OUTPUT_FIELD_SEPARATOR
print(*objects)

Output:

nil
nil
00.00/10+0izerozero

With specified separators:

$OUTPUT_RECORD_SEPARATOR = "\n"
$OUTPUT_FIELD_SEPARATOR = ','
print(*objects)

Output:

0,0.0,0/1,0+0i,zero,zero

With no argument given, writes the content of $_ (which is usually the most recent user input):

gets  # Sets $_ to the most recent user input.
print # Prints $_.

() → nil
(String fmt, *untyped args) → nil
(_Writer io, string fmt, *untyped args) → nil

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1376
def self?.printf: () -> nil
                  | (String fmt, *untyped args) -> nil
                  | (_Writer io, string fmt, *untyped args) -> nil

Equivalent to:

io.write(sprintf(format_string, *objects))

For details on format_string, see Format Specifications.

With the single argument format_string, formats objects into the string, then writes the formatted string to $stdout:

printf('%4.4d %10s %2.2f', 24, 24, 24.0)

Output (on $stdout):

0024         24 24.00#

With arguments io and format_string, formats objects into the string, then writes the formatted string to io:

printf($stderr, '%4.4d %10s %2.2f', 24, 24, 24.0)

Output (on $stderr):

0024         24 24.00# => nil

With no arguments, does nothing.

() { (?) → untyped } → Proc

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1386
def self?.proc: () { (?) -> untyped } -> Proc

Equivalent to Proc.new.

[T < _ToInt] (T chr) → T
(String chr) → String

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1407
def self?.putc: [T < _ToInt] (T chr) -> T
                | (String chr) -> String

Equivalent to:

$stdout.putc(int)

See IO#putc for important information regarding multi-byte characters.

(*_ToS objects) → nil

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1418
def self?.puts: (*_ToS objects) -> nil

Equivalent to

$stdout.puts(objects)

(?0) → Float
(int arg0) → Integer
(::Range[Integer] arg0) → Integer?
(::Range[Float] arg0) → Float?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1498
def self?.rand: (?0) -> Float
                | (int arg0) -> Integer
                | (::Range[Integer] arg0) -> Integer?
                | (::Range[Float] arg0) -> Float?

If called without an argument, or if max.to_i.abs == 0, rand returns a pseudo-random floating point number between 0.0 and 1.0, including 0.0 and excluding 1.0.

rand        #=> 0.2725926052826416

When max.abs is greater than or equal to 1, rand returns a pseudo-random integer greater than or equal to 0 and less than max.to_i.abs.

rand(100)   #=> 12

When max is a Range, rand returns a random number where range.member?(number) == true.

Negative or floating point values for max are allowed, but may give surprising results.

rand(-100) # => 87
rand(-0.5) # => 0.8130921818028143
rand(1.9)  # equivalent to rand(1), which is always 0

Kernel.srand may be used to ensure that sequences of random numbers are reproducible between different runs of a program.

Related: Random.rand. rand(100.0) # => 64 (Integer because max.to_i is 100) Random.rand(100.0) # => 30.315320967824523

(?String arg0, ?Integer arg1, ?chomp: boolish) → String

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1519
def self?.readline: (?String arg0, ?Integer arg1, ?chomp: boolish) -> String

Equivalent to method Kernel#gets, except that it raises an exception if called at end-of-stream:

$ cat t.txt | ruby -e "p readlines; readline"
["First line\n", "Second line\n", "\n", "Fourth line\n", "Fifth line\n"]
in `readline': end of file reached (EOFError)

Optional keyword argument chomp specifies whether line separators are to be omitted.

(?string sep, ?int limit, ?chomp: boolish) → ::Array[String]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1574
def self?.readlines: (?string sep, ?int limit, ?chomp: boolish) -> ::Array[String]

Returns an array containing the lines returned by calling Kernel#gets until the end-of-stream is reached; (see Line IO).

With only string argument sep given, returns the remaining lines as determined by line separator sep, or nil if none; see Line Separator:

# Default separator.
$ cat t.txt | ruby -e "p readlines"
["First line\n", "Second line\n", "\n", "Fourth line\n", "Fifth line\n"]

# Specified separator.
$ cat t.txt | ruby -e "p readlines 'li'"
["First li", "ne\nSecond li", "ne\n\nFourth li", "ne\nFifth li", "ne\n"]

# Get-all separator.
$ cat t.txt | ruby -e "p readlines nil"
["First line\nSecond line\n\nFourth line\nFifth line\n"]

# Get-paragraph separator.
$ cat t.txt | ruby -e "p readlines ''"
["First line\nSecond line\n\n", "Fourth line\nFifth line\n"]

With only integer argument limit given, limits the number of bytes in the line; see Line Limit:

$cat t.txt | ruby -e "p readlines 10"
["First line", "\n", "Second lin", "e\n", "\n", "Fourth lin", "e\n", "Fifth line", "\n"]

$cat t.txt | ruby -e "p readlines 11"
["First line\n", "Second line", "\n", "\n", "Fourth line", "\n", "Fifth line\n"]

$cat t.txt | ruby -e "p readlines 12"
["First line\n", "Second line\n", "\n", "Fourth line\n", "Fifth line\n"]

With arguments sep and limit given, combines the two behaviors (see Line Separator and Line Limit).

Optional keyword argument chomp specifies whether line separators are to be omitted:

$ cat t.txt | ruby -e "p readlines(chomp: true)"
["First line", "Second line", "", "Fourth line", "Fifth line"]

Optional keyword arguments enc_opts specify encoding options; see Encoding options.

(String path) → bool

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1591
def self?.require: (String path) -> bool

When RubyGems is required, Kernel#require is replaced with our own which is capable of loading gems on demand.

When you call require 'x', this is what happens: * If the file can be loaded from the existing Ruby loadpath, it is. * Otherwise, installed gems are searched for a file that matches. If it’s found in gem ‘y’, that gem is activated (added to the loadpath).

The normal require functionality of returning false if that file has already been loaded is preserved.

(String feature) → bool

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1602
def self?.require_relative: (String feature) -> bool

Ruby tries to load the library named string relative to the directory containing the requiring file. If the file does not exist a LoadError is raised. Returns true if the file was loaded and false if the file was already loaded before.

(::Array[IO] read, ?::Array[IO] write, ?::Array[IO] error, ?Time::_Timeout timeout) → ::Array[String]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1745
def self?.select: (::Array[IO] read, ?::Array[IO] write, ?::Array[IO] error, ?Time::_Timeout timeout) -> ::Array[String]

Invokes system call select(2), which monitors multiple file descriptors, waiting until one or more of the file descriptors becomes ready for some class of I/O operation.

Not implemented on all platforms.

Each of the arguments read_ios, write_ios, and error_ios is an array of IO objects.

Argument timeout is a numeric value (such as integer or float) timeout interval in seconds. timeout can also be nil or Float::INFINITY. nil and Float::INFINITY means no timeout.

The method monitors the IO objects given in all three arrays, waiting for some to be ready; returns a 3-element array whose elements are:

• An array of the objects in read_ios that are ready for reading.

• An array of the objects in write_ios that are ready for writing.

• An array of the objects in error_ios have pending exceptions.

If no object becomes ready within the given timeout, nil is returned.

IO.select peeks the buffer of IO objects for testing readability. If the IO buffer is not empty, IO.select immediately notifies readability. This “peek” only happens for IO objects. It does not happen for IO-like objects such as OpenSSL::SSL::SSLSocket.

The best way to use IO.select is invoking it after non-blocking methods such as #read_nonblock, #write_nonblock, etc. The methods raise an exception which is extended by IO::WaitReadable or IO::WaitWritable. The modules notify how the caller should wait with IO.select. If IO::WaitReadable is raised, the caller should wait for reading. If IO::WaitWritable is raised, the caller should wait for writing.

So, blocking read (#readpartial) can be emulated using #read_nonblock and IO.select as follows:

begin
  result = io_like.read_nonblock(maxlen)
rescue IO::WaitReadable
  IO.select([io_like])
  retry
rescue IO::WaitWritable
  IO.select(nil, [io_like])
  retry
end

Especially, the combination of non-blocking methods and IO.select is preferred for IO like objects such as OpenSSL::SSL::SSLSocket. It has #to_io method to return underlying IO object. IO.select calls #to_io to obtain the file descriptor to wait.

This means that readability notified by IO.select doesn’t mean readability from OpenSSL::SSL::SSLSocket object.

The most likely situation is that OpenSSL::SSL::SSLSocket buffers some data. IO.select doesn’t see the buffer. So IO.select can block when OpenSSL::SSL::SSLSocket#readpartial doesn’t block.

However, several more complicated situations exist.

SSL is a protocol which is sequence of records. The record consists of multiple bytes. So, the remote side of SSL sends a partial record, IO.select notifies readability but OpenSSL::SSL::SSLSocket cannot decrypt a byte and OpenSSL::SSL::SSLSocket#readpartial will block.

Also, the remote side can request SSL renegotiation which forces the local SSL engine to write some data. This means OpenSSL::SSL::SSLSocket#readpartial may invoke #write system call and it can block. In such a situation, OpenSSL::SSL::SSLSocket#read_nonblock raises IO::WaitWritable instead of blocking. So, the caller should wait for ready for writability as above example.

The combination of non-blocking methods and IO.select is also useful for streams such as tty, pipe socket socket when multiple processes read from a stream.

Finally, Linux kernel developers don’t guarantee that readability of select(2) means readability of following read(2) even for a single process; see select(2)

Invoking IO.select before IO#readpartial works well as usual. However it is not the best way to use IO.select.

The writability notified by select(2) doesn’t show how many bytes are writable. IO#write method blocks until given whole string is written. So, IO#write(two or more bytes) can block after writability is notified by IO.select. IO#write_nonblock is required to avoid the blocking.

Blocking write (#write) can be emulated using #write_nonblock and IO.select as follows: IO::WaitReadable should also be rescued for SSL renegotiation in OpenSSL::SSL::SSLSocket.

while 0 < string.bytesize
  begin
    written = io_like.write_nonblock(string)
  rescue IO::WaitReadable
    IO.select([io_like])
    retry
  rescue IO::WaitWritable
    IO.select(nil, [io_like])
    retry
  end
  string = string.byteslice(written..-1)
end

Example:

rp, wp = IO.pipe
mesg = "ping "
100.times {
  # IO.select follows IO#read.  Not the best way to use IO.select.
  rs, ws, = IO.select([rp], [wp])
  if r = rs[0]
    ret = r.read(5)
    print ret
    case ret
    when /ping/
      mesg = "pong\n"
    when /pong/
      mesg = "ping "
    end
  end
  if w = ws[0]
    w.write(mesg)
  end
}

Output:

ping pong
ping pong
ping pong
(snipped)
ping

(?nil) → bot
(Time::_Timeout duration) → Integer

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1761
def self?.sleep: (?nil) -> bot
                 | (Time::_Timeout duration) -> Integer

Suspends execution of the current thread for the number of seconds specified by numeric argument secs, or forever if secs is nil; returns the integer number of seconds suspended (rounded).

Time.new  # => 2008-03-08 19:56:19 +0900
sleep 1.2 # => 1
Time.new  # => 2008-03-08 19:56:20 +0900
sleep 1.9 # => 2
Time.new  # => 2008-03-08 19:56:22 +0900

(String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String) → Integer
(Hash[string, string?] env, String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String) → Integer

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2118
def self?.spawn: (String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String) -> Integer
                 | (Hash[string, string?] env, String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String) -> Integer

Creates a new child process by doing one of the following in that process:

• Passing string command_line to the shell.

• Invoking the executable at exe_path.

This method has potential security vulnerabilities if called with untrusted input; see Command Injection.

Returns the process ID (pid) of the new process, without waiting for it to complete.

To avoid zombie processes, the parent process should call either:

• Process.wait, to collect the termination statuses of its children.

• Process.detach, to register disinterest in their status.

The new process is created using the [exec system call](pubs.opengroup.org/onlinepubs/9699919799.2018edition/functions/e xecve.html); it may inherit some of its environment from the calling program (possibly including open file descriptors).

Argument env, if given, is a hash that affects ENV for the new process; see Execution Environment.

Argument options is a hash of options for the new process; see Execution Options.

The first required argument is one of the following:

• command_line if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more meta characters.

• exe_path otherwise.

<strong>Argument command_line</strong>

String argument command_line is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:

spawn('if true; then echo "Foo"; fi') # => 798847 # Shell reserved word.
Process.wait                          # => 798847
spawn('exit')                         # => 798848 # Built-in.
Process.wait                          # => 798848
spawn('date > /tmp/date.tmp')         # => 798879 # Contains meta character.
Process.wait                          # => 798849
spawn('date > /nop/date.tmp')         # => 798882 # Issues error message.
Process.wait                          # => 798882

The command line may also contain arguments and options for the command:

spawn('echo "Foo"') # => 799031
Process.wait        # => 799031

Output:

Foo

See Execution Shell for details about the shell.

Raises an exception if the new process could not execute.

<strong>Argument exe_path</strong>

Argument exe_path is one of the following:

• The string path to an executable to be called.

• A 2-element array containing the path to an executable to be called, and the string to be used as the name of the executing process.

  spawn('/usr/bin/date') # Path to date on Unix-style system.
  Process.wait
  

  Output:

  Mon Aug 28 11:43:10 AM CDT 2023

Ruby invokes the executable directly. This form does not use the shell; see Arguments args for caveats.

If one or more args is given, each is an argument or option to be passed to the executable:

spawn('echo', 'C*')             # => 799392
Process.wait                    # => 799392
spawn('echo', 'hello', 'world') # => 799393
Process.wait                    # => 799393

Output:

C*
hello world

Raises an exception if the new process could not execute.

(?int number) → Integer

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 363
def self?.srand: (?int number) -> Integer

Seeds the system pseudo-random number generator, with number. The previous seed value is returned.

If number is omitted, seeds the generator using a source of entropy provided by the operating system, if available (/dev/urandom on Unix systems or the RSA cryptographic provider on Windows), which is then combined with the time, the process id, and a sequence number.

srand may be used to ensure repeatable sequences of pseudo-random numbers between different runs of the program. By setting the seed to a known value, programs can be made deterministic during testing.

srand 1234               # => 268519324636777531569100071560086917274
[ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]
[ rand(10), rand(1000) ] # => [4, 664]
srand 1234               # => 1234
[ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]

(Integer num, *untyped args) → untyped

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1788
def self?.syscall: (Integer num, *untyped args) -> untyped

Invokes Posix system call syscall(2), which calls a specified function.

Calls the operating system function identified by integer_callno; returns the result of the function or raises SystemCallError if it failed. The effect of the call is platform-dependent. The arguments and returned value are platform-dependent.

For each of arguments: if it is an integer, it is passed directly; if it is a string, it is interpreted as a binary sequence of bytes. There may be as many as nine such arguments.

Arguments integer_callno and argument, as well as the returned value, are platform-dependent.

Note: Method syscall is essentially unsafe and unportable. The DL (Fiddle) library is preferred for safer and a bit more portable programming.

Not implemented on all platforms.

(String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String, ?exception: bool) → (NilClass | FalseClass | TrueClass)
(Hash[string, string?] env, String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String, ?exception: bool) → (NilClass | FalseClass | TrueClass)

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2236
def self?.system: (String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String, ?exception: bool) -> (NilClass | FalseClass | TrueClass)
                  | (Hash[string, string?] env, String command, *String args, ?unsetenv_others: bool, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: bool, ?chdir: String, ?exception: bool) -> (NilClass | FalseClass | TrueClass)

Creates a new child process by doing one of the following in that process:

• Passing string command_line to the shell.

• Invoking the executable at exe_path.

This method has potential security vulnerabilities if called with untrusted input; see Command Injection.

Returns:

• true if the command exits with status zero.

• false if the exit status is a non-zero integer.

• nil if the command could not execute.

Raises an exception (instead of returning false or nil) if keyword argument exception is set to true.

Assigns the command’s error status to $?.

The new process is created using the [system system call](pubs.opengroup.org/onlinepubs/9699919799.2018edition/functions/s ystem.html); it may inherit some of its environment from the calling program (possibly including open file descriptors).

Argument env, if given, is a hash that affects ENV for the new process; see Execution Environment.

Argument options is a hash of options for the new process; see Execution Options.

The first required argument is one of the following:

• command_line if it is a string, and if it begins with a shell reserved word or special built-in, or if it contains one or more meta characters.

• exe_path otherwise.

<strong>Argument command_line</strong>

String argument command_line is a command line to be passed to a shell; it must begin with a shell reserved word, begin with a special built-in, or contain meta characters:

system('if true; then echo "Foo"; fi')          # => true  # Shell reserved word.
system('exit')                                  # => true  # Built-in.
system('date > /tmp/date.tmp')                  # => true  # Contains meta character.
system('date > /nop/date.tmp')                  # => false
system('date > /nop/date.tmp', exception: true) # Raises RuntimeError.

Assigns the command’s error status to $?:

system('exit')                             # => true  # Built-in.
$?                                         # => #<Process::Status: pid 640610 exit 0>
system('date > /nop/date.tmp')             # => false
$?                                         # => #<Process::Status: pid 640742 exit 2>

The command line may also contain arguments and options for the command:

system('echo "Foo"') # => true

Output:

Foo

See Execution Shell for details about the shell.

Raises an exception if the new process could not execute.

<strong>Argument exe_path</strong>

Argument exe_path is one of the following:

• The string path to an executable to be called.

• A 2-element array containing the path to an executable and the string to be used as the name of the executing process.

Example:

system('/usr/bin/date') # => true # Path to date on Unix-style system.
system('foo')           # => nil  # Command failed.

Output:

Mon Aug 28 11:43:10 AM CDT 2023

Assigns the command’s error status to $?:

system('/usr/bin/date') # => true
$?                      # => #<Process::Status: pid 645605 exit 0>
system('foo')           # => nil
$?                      # => #<Process::Status: pid 645608 exit 127>

Ruby invokes the executable directly. This form does not use the shell; see Arguments args for caveats.

system('doesnt_exist') # => nil

If one or more args is given, each is an argument or option to be passed to the executable:

system('echo', 'C*')             # => true
system('echo', 'hello', 'world') # => true

Output:

C*
hello world

Raises an exception if the new process could not execute.

("b" | "c" | "d" | "e" | "f" | "g" | "G" | "k" | "l" | "o" | "O" | "p" | "r" | "R" | "S" | "u" | "w" | "W" | "x" | "X" | "z" | 98 | 99 | 100 | 101 | 102 | 103 | 71 | 107 | 108 | 111 | 79 | 112 | 114 | 82 | 83 | 117 | 119 | 87 | 120 | 88 | 122, path filepath) → bool
("s" | 115, path filepath) → Integer?
("A" | "M" | "C" | 65 | 77 | 67, path filepath) → Time
("<" | "=" | ">" | "-" | 60 | 61 | 62 | 45, path filepath1, path filepath2) → bool
(String | int cmd, path filepath1, ?path filepath2) → (bool | Time | Integer | nil)

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1856
def self?.test: ('b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'G' | 'k' | 'l' | 'o' | 'O' | 'p' | 'r' | 'R' | 'S' | 'u' | 'w' | 'W' | 'x' | 'X' | 'z' |
                    98 | 99 | 100 | 101 | 102 | 103 | 71 | 107 | 108 | 111 | 79 | 112 | 114 | 82 | 83 | 117 | 119 | 87 | 120 | 88 | 122, path filepath) -> bool
                | ('s' | 115, path filepath) -> Integer?
                | ('A' | 'M' | 'C' | 65 | 77 | 67, path filepath) -> Time
                | ('<' | '=' | '>' | '-' | 60 | 61 | 62 | 45, path filepath1, path filepath2) -> bool
                | (String | int cmd, path filepath1, ?path filepath2) -> (bool | Time | Integer | nil)

Performs a test on one or both of the filesystem entities at the given paths path0 and path1: * Each path path0 or path1 points to a file, directory, device, pipe, etc. * Character char selects a specific test. The tests: * Each of these tests operates only on the entity at path0, and returns true or false; for a non-existent entity, returns false (does not raise exception): Character |Test —————-|—————————————————————————– 'b'|Whether the entity is a block device. 'c'|Whether the entity is a character device. 'd'|Whether the entity is a directory. 'e'|Whether the entity is an existing entity. 'f'|Whether the entity is an existing regular file. 'g'|Whether the entity’s setgid bit is set. 'G'|Whether the entity’s group ownership is equal to the caller’s. 'k'|Whether the entity’s sticky bit is set. 'l'|Whether the entity is a symbolic link. 'o'|Whether the entity is owned by the caller’s effective uid. 'O'|Like 'o', but uses the real uid (not the effective uid). 'p'|Whether the entity is a FIFO device (named pipe). 'r'|Whether the entity is readable by the caller’s effective uid/gid. 'R'|Like 'r', but uses the real uid/gid (not the effective uid/gid). 'S'|Whether the entity is a socket. 'u'|Whether the entity’s setuid bit is set. 'w'|Whether the entity is writable by the caller’s effective uid/gid. 'W'|Like 'w', but uses the real uid/gid (not the effective uid/gid). 'x'|Whether the entity is executable by the caller’s effective uid/gid. 'X'|Like 'x', but uses the real uid/gid (not the effective uid/git). 'z'|Whether the entity exists and is of length zero. * This test operates only on the entity at path0, and returns an integer size or +nil+: Character |Test —————-|——————————————————————————————– 's'|Returns positive integer size if the entity exists and has non-zero length, +nil+ otherwise. * Each of these tests operates only on the entity at path0, and returns a Time object; raises an exception if the entity does not exist: Character |Test —————-|————————————– 'A'|Last access time for the entity. 'C'|Last change time for the entity. 'M'|Last modification time for the entity. * Each of these tests operates on the modification time (mtime) of each of the entities at path0 and path1, and returns a true or false; returns false if either entity does not exist: Character |Test —————-|————————————————————— '<'|Whether the mtime at path0 is less than that at path1. '='|Whether the mtime at path0 is equal to that at path1. '>'|Whether the mtime at path0 is greater than that at path1. * This test operates on the content of each of the entities at path0 and path1, and returns a true or false; returns false if either entity does not exist: Character |Test —————-|——————————————— '-'|Whether the entities exist and are identical.

(untyped tag, ?untyped obj) → bot

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1872
def self?.throw: (untyped tag, ?untyped obj) -> bot

Transfers control to the end of the active catch block waiting for tag. Raises UncaughtThrowError if there is no catch block for the tag. The optional second parameter supplies a return value for the catch block, which otherwise defaults to nil. For examples, see Kernel::catch.

(interned name, String | _Tracer cmd) → nil
(interned name) { (untyped value) → void } → nil
(interned name, nil) → Array[String | _Tracer]?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2265
def self?.trace_var: (interned name, String | _Tracer cmd) -> nil
                     | (interned name) { (untyped value) -> void } -> nil
                     | (interned name, nil) -> Array[String | _Tracer]?

Controls tracing of assignments to global variables. The parameter symbol identifies the variable (as either a string name or a symbol identifier). cmd (which may be a string or a Proc object) or block is executed whenever the variable is assigned. The block or Proc object receives the variable’s new value as a parameter. Also see #untrace_var.

trace_var :$_, proc {|v| puts "$_ is now '#{v}'" }
$_ = "hello"
$_ = ' there'

produces:

$_ is now 'hello'
$_ is now ' there'

(interned name, ?nil) → Array[String | _Tracer]
(interned name, String cmd) → [ String ]?
[T < _Tracer] (interned name, T cmd) → [ T ]?
(interned name, untyped cmd) → nil

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2277
def self?.untrace_var: (interned name, ?nil) -> Array[String | _Tracer]
                       | (interned name, String cmd) -> [String]?
                       | [T < _Tracer] (interned name, T cmd) -> [T]?
                       | (interned name, untyped cmd) -> nil

Removes tracing for the specified command on the given global variable and returns nil. If no command is specified, removes all tracing for that variable and returns an array containing the commands actually removed.

(*_ToS msg, ?uplevel: int?, ?category: Warning::category?) → nil

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 1924
def self?.warn: (*_ToS msg, ?uplevel: int?, ?category: Warning::category?) -> nil

If warnings have been disabled (for example with the -W0 flag), does nothing. Otherwise, converts each of the messages to strings, appends a newline character to the string if the string does not end in a newline, and calls Warning.warn with the string.

warn("warning 1", "warning 2")

produces:

warning 1
warning 2

If the uplevel keyword argument is given, the string will be prepended with information for the given caller frame in the same format used by the rb_warn C function.

# In baz.rb
def foo
  warn("invalid call to foo", uplevel: 1)
end

def bar
  foo
end

bar

produces:

baz.rb:6: warning: invalid call to foo

If category keyword argument is given, passes the category to Warning.warn. The category given must be one of the following categories:

:deprecated

Used for warning for deprecated functionality that may be removed in the future.

:experimental

Used for experimental features that may change in future releases.

:performance

Used for warning about APIs or pattern that have negative performance impact

(untyped other) → bool

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2289
def !~: (untyped other) -> bool

Returns true if two objects do not match (using the =~ method), otherwise false.

(untyped other) → 0?

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2309
def <=>: (untyped other) -> 0?

Returns 0 if obj and other are the same object or obj == other, otherwise nil.

The <=> is used by various methods to compare objects, for example Enumerable#sort, Enumerable#max etc.

Your implementation of <=> should return one of the following values: -1, 0, 1 or nil. -1 means self is smaller than other. 0 means self is equal to other. 1 means self is bigger than other. Nil means the two values could not be compared.

When you define <=>, you can include Comparable to gain the methods #<=, #<,

#==, #>=, #> and #between?.

static VALUE
f_BigDecimal(int argc, VALUE *argv, VALUE self)
{
    VALUE val, digs_v, opts = Qnil;
    argc = rb_scan_args(argc, argv, "11:", &val, &digs_v, &opts);
    int exception = opts_exception_p(opts);

    size_t digs = SIZE_MAX; /* this means digs is omitted */
    if (argc > 1) {
        digs_v = rb_to_int(digs_v);
        if (FIXNUM_P(digs_v)) {
            long n = FIX2LONG(digs_v);
            if (n < 0)
                goto negative_digs;
            digs = (size_t)n;
        }
        else {
            if (RBIGNUM_NEGATIVE_P(digs_v)) {
              negative_digs:
                if (!exception)
                    return Qnil;
                rb_raise(rb_eArgError, "negative precision");
            }
            digs = NUM2SIZET(digs_v);
        }
    }

    return rb_convert_to_BigDecimal(val, digs, exception);
}

Returns the BigDecimal converted from value with a precision of ndigits decimal digits.

When ndigits is less than the number of significant digits in the value, the result is rounded to that number of digits, according to the current rounding mode; see BigDecimal.mode.

When ndigits is 0, the number of digits to correctly represent a float number is determined automatically.

Returns value converted to a BigDecimal, depending on the type of value:

• Integer, Float, Rational, Complex, or BigDecimal: converted directly:

  # Integer, Complex, Float, or BigDecimal value does not require ndigits; ignored if given.
  BigDecimal(2)                     # => 0.2e1
  BigDecimal(Complex(2, 0))         # => 0.2e1
  BigDecimal(BigDecimal(2))         # => 0.2e1
  BigDecimal(2.0)                   # => 0.2e1
  # Rational value requires ndigits.
  BigDecimal(Rational(2, 1), 0)     # => 0.2e1
  

• String: converted by parsing if it contains an integer or floating-point literal; leading and trailing whitespace is ignored:

  # String does not require ndigits; ignored if given.
  BigDecimal('2')     # => 0.2e1
  BigDecimal('2.0')   # => 0.2e1
  BigDecimal('0.2e1') # => 0.2e1
  BigDecimal(' 2.0 ') # => 0.2e1
  

• Other type that responds to method :to_str: first converted to a string, then converted to a BigDecimal, as above.

• Other type:

  • Raises an exception if keyword argument exception is true.

  • Returns nil if keyword argument exception is false.

Raises an exception if value evaluates to a Float and digits is larger than Float::DIG + 1.

() → Class

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 277
def class: () -> Class

Returns the class of obj. This method must always be called with an explicit receiver, as class is also a reserved word in Ruby.

1.class      #=> Integer
self.class   #=> Object

(?freeze: bool?) → self

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2343
def clone: (?freeze: bool?) -> self

Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference. clone copies the frozen value state of obj, unless the :freeze keyword argument is given with a false or true value. See also the discussion under Object#dup.

class Klass
   attr_accessor :str
end
s1 = Klass.new      #=> #<Klass:0x401b3a38>
s1.str = "Hello"    #=> "Hello"
s2 = s1.clone       #=> #<Klass:0x401b3998 @str="Hello">
s2.str[1,4] = "i"   #=> "i"
s1.inspect          #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
s2.inspect          #=> "#<Klass:0x401b3998 @str=\"Hi\">"

This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy method of the class.

(interned name, Method | UnboundMethod | Proc method) → Symbol
(interned name) { (?) [self: self] → untyped } → Symbol

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2375
def define_singleton_method: (interned name, Method | UnboundMethod | Proc method) -> Symbol
                             | (interned name) { (?) [self: self] -> untyped } -> Symbol

Defines a public singleton method in the receiver. The method parameter can be a Proc, a Method or an UnboundMethod object. If a block is specified, it is used as the method body. If a block or a method has parameters, they’re used as method parameters.

class A
  class << self
    def class_name
      to_s
    end
  end
end
A.define_singleton_method(:who_am_i) do
  "I am: #{class_name}"
end
A.who_am_i   # ==> "I am: A"

guy = "Bob"
guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
guy.hello    #=>  "Bob: Hello there!"

chris = "Chris"
chris.define_singleton_method(:greet) {|greeting| "#{greeting}, I'm Chris!" }
chris.greet("Hi") #=> "Hi, I'm Chris!"

(?_Writer port) → nil

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2393
def display: (?_Writer port) -> nil

Writes self on the given port:

1.display
"cat".display
[ 4, 5, 6 ].display
puts

Output:

1cat[4, 5, 6]

() → self

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2433
def dup: () -> self

Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference.

This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy method of the class.

on dup vs clone

In general, clone and dup may have different semantics in descendant classes. While clone is used to duplicate an object, including its internal state, dup typically uses the class of the descendant object to create the new instance.

When using dup, any modules that the object has been extended with will not be copied.

class Klass
  attr_accessor :str
end

module Foo
  def foo; 'foo'; end
end

s1 = Klass.new #=> #<Klass:0x401b3a38>
s1.extend(Foo) #=> #<Klass:0x401b3a38>
s1.foo #=> "foo"

s2 = s1.clone #=> #<Klass:0x401be280>
s2.foo #=> "foo"

s3 = s1.dup #=> #<Klass:0x401c1084>
s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401c1084>

(?interned method, *untyped, **untyped) ?{ (*untyped, **untyped) → Integer } → Enumerator[untyped, untyped]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2490
def enum_for: (?interned method, *untyped, **untyped) ?{ (*untyped, **untyped) -> Integer } -> Enumerator[untyped, untyped]

Creates a new Enumerator which will enumerate by calling method on obj, passing args if any. What was yielded by method becomes values of enumerator.

If a block is given, it will be used to calculate the size of the enumerator without the need to iterate it (see Enumerator#size).

Examples

str = "xyz"

enum = str.enum_for(:each_byte)
enum.each { |b| puts b }
# => 120
# => 121
# => 122

# protect an array from being modified by some_method
a = [1, 2, 3]
some_method(a.to_enum)

# String#split in block form is more memory-effective:
very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') }
# This could be rewritten more idiomatically with to_enum:
very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first

It is typical to call to_enum when defining methods for a generic Enumerable, in case no block is passed.

Here is such an example, with parameter passing and a sizing block:

module Enumerable
  # a generic method to repeat the values of any enumerable
  def repeat(n)
    raise ArgumentError, "#{n} is negative!" if n < 0
    unless block_given?
      return to_enum(__method__, n) do # __method__ is :repeat here
        sz = size     # Call size and multiply by n...
        sz * n if sz  # but return nil if size itself is nil
      end
    end
    each do |*val|
      n.times { yield *val }
    end
  end
end

%i[hello world].repeat(2) { |w| puts w }
  # => Prints 'hello', 'hello', 'world', 'world'
enum = (1..14).repeat(3)
  # => returns an Enumerator when called without a block
enum.first(4) # => [1, 1, 1, 2]
enum.size # => 42

(untyped other) → bool

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2529
def eql?: (untyped other) -> bool

Equality — At the Object level, #== returns true only if obj and other are the same object. Typically, this method is overridden in descendant classes to provide class-specific meaning.

Unlike #==, the #equal? method should never be overridden by subclasses as it is used to determine object identity (that is, a.equal?(b) if and only if a is the same object as b):

obj = "a"
other = obj.dup

obj == other      #=> true
obj.equal? other  #=> false
obj.equal? obj    #=> true

The eql? method returns true if obj and other refer to the same hash key. This is used by Hash to test members for equality. For any pair of objects where eql? returns true, the hash value of both objects must be equal. So any subclass that overrides eql? should also override hash appropriately.

For objects of class Object, eql? is synonymous with #==. Subclasses normally continue this tradition by aliasing eql? to their overridden #== method, but there are exceptions. Numeric types, for example, perform type conversion across #==, but not across eql?, so:

1 == 1.0     #=> true
1.eql? 1.0   #=> false

(Module module, *Module other_modules) → self

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2554
def extend: (Module module, *Module other_modules) -> self

Adds to obj the instance methods from each module given as a parameter.

module Mod
  def hello
    "Hello from Mod.\n"
  end
end

class Klass
  def hello
    "Hello from Klass.\n"
  end
end

k = Klass.new
k.hello         #=> "Hello from Klass.\n"
k.extend(Mod)   #=> #<Klass:0x401b3bc8>
k.hello         #=> "Hello from Mod.\n"

() → self

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2577
def freeze: () -> self

Prevents further modifications to obj. A FrozenError will be raised if modification is attempted. There is no way to unfreeze a frozen object. See also Object#frozen?.

This method returns self.

a = [ "a", "b", "c" ]
a.freeze
a << "z"

produces:

prog.rb:3:in `<<': can't modify frozen Array (FrozenError)
 from prog.rb:3

Objects of the following classes are always frozen: Integer, Float, Symbol.

() → bool

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2589
def frozen?: () -> bool

Returns the freeze status of obj.

a = [ "a", "b", "c" ]
a.freeze    #=> ["a", "b", "c"]
a.frozen?   #=> true

() → Integer

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2622
def hash: () -> Integer

Generates an Integer hash value for this object. This function must have the property that a.eql?(b) implies a.hash == b.hash.

The hash value is used along with eql? by the Hash class to determine if two objects reference the same hash key. Any hash value that exceeds the capacity of an Integer will be truncated before being used.

The hash value for an object may not be identical across invocations or implementations of Ruby. If you need a stable identifier across Ruby invocations and implementations you will need to generate one with a custom method.

Certain core classes such as Integer use built-in hash calculations and do not call the hash method when used as a hash key.

When implementing your own hash based on multiple values, the best practice is to combine the class and any values using the hash code of an array:

For example:

def hash
  [self.class, a, b, c].hash
end

The reason for this is that the Array#hash method already has logic for safely and efficiently combining multiple hash values.

(self object, ?freeze: bool?) → self

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 3169
def initialize_clone: (self object, ?freeze: bool?) -> self

(self object) → self

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 3167
def initialize_copy: (self object) -> self

(self object) → self

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 3171
def initialize_dup: (self object) -> self

() → String

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2650
def inspect: () -> String

Returns a string containing a human-readable representation of obj. The default inspect shows the object’s class name, an encoding of its memory address, and a list of the instance variables and their values (by calling

inspect on each of them). User defined classes should override this method to provide a better representation of obj. When overriding this method, it should return a string whose encoding is compatible with the default external encoding.

[ 1, 2, 3..4, 'five' ].inspect   #=> "[1, 2, 3..4, \"five\"]"
Time.new.inspect                 #=> "2008-03-08 19:43:39 +0900"

class Foo
end
Foo.new.inspect                  #=> "#<Foo:0x0300c868>"

class Bar
  def initialize
    @bar = 1
  end
end
Bar.new.inspect                  #=> "#<Bar:0x0300c868 @bar=1>"

(Module | Class module_or_class) → bool

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2668
def instance_of?: (Module | Class module_or_class) -> bool

Returns true if obj is an instance of the given class. See also Object#kind_of?.

class A;     end
class B < A; end
class C < B; end

b = B.new
b.instance_of? A   #=> false
b.instance_of? B   #=> true
b.instance_of? C   #=> false

(interned variable) → bool

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2688
def instance_variable_defined?: (interned variable) -> bool

Returns true if the given instance variable is defined in obj. String arguments are converted to symbols.

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_defined?(:@a)    #=> true
fred.instance_variable_defined?("@b")   #=> true
fred.instance_variable_defined?("@c")   #=> false

(interned variable) → untyped

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2710
def instance_variable_get: (interned variable) -> untyped

Returns the value of the given instance variable, or nil if the instance variable is not set. The @ part of the variable name should be included for regular instance variables. Throws a NameError exception if the supplied symbol is not valid as an instance variable name. String arguments are converted to symbols.

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_get(:@a)    #=> "cat"
fred.instance_variable_get("@b")   #=> 99

[T] (interned variable, T value) → T

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2733
def instance_variable_set: [T] (interned variable, T value) -> T

Sets the instance variable named by symbol to the given object. This may circumvent the encapsulation intended by the author of the class, so it should be used with care. The variable does not have to exist prior to this call. If the instance variable name is passed as a string, that string is converted to a symbol.

class Fred
  def initialize(p1, p2)
    @a, @b = p1, p2
  end
end
fred = Fred.new('cat', 99)
fred.instance_variable_set(:@a, 'dog')   #=> "dog"
fred.instance_variable_set(:@c, 'cat')   #=> "cat"
fred.inspect                             #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"

() → Array[Symbol]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2750
def instance_variables: () -> Array[Symbol]

Returns an array of instance variable names for the receiver. Note that simply defining an accessor does not create the corresponding instance variable.

class Fred
  attr_accessor :a1
  def initialize
    @iv = 3
  end
end
Fred.new.instance_variables   #=> [:@iv]

(Module | Class module_or_class) → bool

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2774
def is_a?: (Module | Class module_or_class) -> bool

Returns true if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj.

module M;    end
class A
  include M
end
class B < A; end
class C < B; end

b = B.new
b.is_a? A          #=> true
b.is_a? B          #=> true
b.is_a? C          #=> false
b.is_a? M          #=> true

b.kind_of? A       #=> true
b.kind_of? B       #=> true
b.kind_of? C       #=> false
b.kind_of? M       #=> true

() → self

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2787
def itself: () -> self

Returns the receiver.

string = "my string"
string.itself.object_id == string.object_id   #=> true

(interned name) → Method

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2826
def method: (interned name) -> Method

Looks up the named method as a receiver in obj, returning a Method object (or raising NameError). The Method object acts as a closure in obj‘s object instance, so instance variables and the value of self remain available.

class Demo
  def initialize(n)
    @iv = n
  end
  def hello()
    "Hello, @iv = #{@iv}"
  end
end

k = Demo.new(99)
m = k.method(:hello)
m.call   #=> "Hello, @iv = 99"

l = Demo.new('Fred')
m = l.method("hello")
m.call   #=> "Hello, @iv = Fred"

Note that Method implements to_proc method, which means it can be used with iterators.

[ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout

out = File.open('test.txt', 'w')
[ 1, 2, 3 ].each(&out.method(:puts)) # => prints 3 lines to file

require 'date'
%w[2017-03-01 2017-03-02].collect(&Date.method(:parse))
#=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>]

(?boolish regular) → Array[Symbol]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2856
def methods: (?boolish regular) -> Array[Symbol]

Returns a list of the names of public and protected methods of obj. This will include all the methods accessible in obj‘s ancestors. If the optional parameter is false, it returns an array of obj’s public and protected singleton methods, the array will not include methods in modules included in obj.

class Klass
  def klass_method()
  end
end
k = Klass.new
k.methods[0..9]    #=> [:klass_method, :nil?, :===,
                   #    :==~, :!, :eql?
                   #    :hash, :<=>, :class, :singleton_class]
k.methods.length   #=> 56

k.methods(false)   #=> []
def k.singleton_method; end
k.methods(false)   #=> [:singleton_method]

module M123; def m123; end end
k.extend M123
k.methods(false)   #=> [:singleton_method]

() → false

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2867
def nil?: () -> false

Only the object nil responds true to nil?.

Object.new.nil?   #=> false
nil.nil?          #=> true

() → String

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/stdlib/pp/0/pp.rbs, line 300
def pretty_inspect: () -> String

Returns a pretty printed object as a string.

See the PP module for more information.

(?boolish all) → Array[Symbol]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2902
def private_methods: (?boolish all) -> Array[Symbol]

Returns the list of private methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.

(?boolish all) → Array[Symbol]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2912
def protected_methods: (?boolish all) -> Array[Symbol]

Returns the list of protected methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.

(interned name) → Method

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2920
def public_method: (interned name) -> Method

Similar to method, searches public method only.

(?boolish all) → Array[Symbol]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2929
def public_methods: (?boolish all) -> Array[Symbol]

Returns the list of public methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.

(interned name, *untyped, **untyped) ?{ (?) → untyped } → untyped

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2942
def public_send: (interned name, *untyped, **untyped) ?{ (?) -> untyped } -> untyped

Invokes the method identified by symbol, passing it any arguments specified. Unlike send, public_send calls public methods only. When the method is identified by a string, the string is converted to a symbol.

1.public_send(:puts, "hello")  # causes NoMethodError

(interned variable) → untyped

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2966
def remove_instance_variable: (interned variable) -> untyped

Removes the named instance variable from obj, returning that variable’s value. String arguments are converted to symbols.

class Dummy
  attr_reader :var
  def initialize
    @var = 99
  end
  def remove
    remove_instance_variable(:@var)
  end
end
d = Dummy.new
d.var      #=> 99
d.remove   #=> 99
d.var      #=> nil

(interned name, ?boolish include_all) → bool

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 2986
def respond_to?: (interned name, ?boolish include_all) -> bool

Returns true if obj responds to the given method. Private and protected methods are included in the search only if the optional second parameter evaluates to true.

If the method is not implemented, as Process.fork on Windows, File.lchmod on GNU/Linux, etc., false is returned.

If the method is not defined, respond_to_missing? method is called and the result is returned.

When the method name parameter is given as a string, the string is converted to a symbol.

() → Class

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 3044
def singleton_class: () -> Class

Returns the singleton class of obj. This method creates a new singleton class if obj does not have one.

If obj is nil, true, or false, it returns NilClass, TrueClass, or FalseClass, respectively. If obj is an Integer, a Float or a Symbol, it raises a TypeError.

Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
String.singleton_class      #=> #<Class:String>
nil.singleton_class         #=> NilClass

(interned name) → Method

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 3069
def singleton_method: (interned name) -> Method

Similar to method, searches singleton method only.

class Demo
  def initialize(n)
    @iv = n
  end
  def hello()
    "Hello, @iv = #{@iv}"
  end
end

k = Demo.new(99)
def k.hi
  "Hi, @iv = #{@iv}"
end
m = k.singleton_method(:hi)
m.call   #=> "Hi, @iv = 99"
m = k.singleton_method(:hello) #=> NameError

(?boolish all) → Array[Symbol]

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 3102
def singleton_methods: (?boolish all) -> Array[Symbol]

Returns an array of the names of singleton methods for obj. If the optional all parameter is true, the list will include methods in modules included in obj. Only public and protected singleton methods are returned.

module Other
  def three() end
end

class Single
  def Single.four() end
end

a = Single.new

def a.one()
end

class << a
  include Other
  def two()
  end
end

Single.singleton_methods    #=> [:four]
a.singleton_methods(false)  #=> [:two, :one]
a.singleton_methods         #=> [:two, :one, :three]

() { (self) → void } → self

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 3117
def tap: () { (self) -> void } -> self

Yields self to the block and then returns self. The primary purpose of this method is to “tap into” a method chain, in order to perform operations on intermediate results within the chain.

(1..10)                  .tap {|x| puts "original: #{x}" }
  .to_a                  .tap {|x| puts "array:    #{x}" }
  .select {|x| x.even? } .tap {|x| puts "evens:    #{x}" }
  .map {|x| x*x }        .tap {|x| puts "squares:  #{x}" }

() → String

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 3128
def to_s: () -> String

Returns a string representing obj. The default to_s prints the object’s class and an encoding of the object id. As a special case, the top-level object that is the initial execution context of Ruby programs returns “main”.

() → Enumerator[self, untyped]
[T] () { (self) → T } → T

# File vendor/bundle/ruby/4.0.0/gems/rbs-4.1.3/core/kernel.rbs, line 3135
def yield_self: () -> Enumerator[self, untyped]
                | [T] () { (self) -> T } -> T

(untyped desc, *untyped additional_desc) { (?) → untyped } → untyped

# File vendor/bundle/ruby/4.0.0/gems/minitest-6.0.6/lib/minitest/spec.rb, line 74
def describe desc, *additional_desc, &block # :doc:
  stack = Minitest::Spec.describe_stack
  is_spec_class = Class === self && kind_of?(Minitest::Spec::DSL)
  name  = [stack.last, desc, *additional_desc]
  name.prepend self if stack.empty? && is_spec_class
  sclas =
    stack.last                 \
    || (is_spec_class && self) \
    || Minitest::Spec.spec_type(desc, *additional_desc)

  cls = sclas.create name.compact.join("::"), desc

  stack.push cls
  cls.class_eval(&block)
  stack.pop
  cls
end

Describe a series of expectations for a given target desc.

Defines a test class subclassing from either Minitest::Spec or from the surrounding describe’s class. The surrounding class may subclass Minitest::Spec manually in order to easily share code:

class MySpec < Minitest::Spec
  # ... shared code ...
end

class TestStuff < MySpec
  it "does stuff" do
    # shared code available here
  end
  describe "inner stuff" do
    it "still does stuff" do
      # ...and here
    end
  end
end

For more information on getting started with writing specs, see:

www.rubyinside.com/a-minitestspec-tutorial-elegant-spec-style-testing-that-comes-with-ruby-5354.html

For some suggestions on how to improve your specs, try:

betterspecs.org

but do note that several items there are debatable or specific to rspec.

For more information about expectations, see Minitest::Expectations.

---

Describe a series of expectations for a given target desc.

Defines a test class subclassing from either Minitest::Spec or from the surrounding describe’s class. The surrounding class may subclass Minitest::Spec manually in order to easily share code:

class MySpec < Minitest::Spec
  # ... shared code ...
end

class TestStuff < MySpec
  it "does stuff" do
    # shared code available here
  end
  describe "inner stuff" do
    it "still does stuff" do
      # ...and here
    end
  end
end

For more information on getting started with writing specs, see:

www.rubyinside.com/a-minitestspec-tutorial-elegant-spec-style-testing-t hat-comes-with-ruby-5354.html

For some suggestions on how to improve your specs, try:

betterspecs.org

but do note that several items there are debatable or specific to rspec.

For more information about expectations, see Minitest::Expectations.