module Kernel - RDoc Documentation (original) (raw)

The Kernel module is included by class Object, so its methods are available in every Ruby object.

The Kernel instance methods are documented in class Object while the module methods are documented here. These methods are called without a receiver and thus can be called in functional form:

sprintf "%.1f", 1.234

What’s Here ↑

Module Kernel provides methods that are useful for:

Converting ↑

Querying ↑

Exiting ↑

Exceptions ↑

IO ↑

Procs ↑

Tracing ↑

Subprocesses ↑

Loading ↑

Yielding ↑

Random Values ↑

Other ↑

Public Instance Methods

Array(object) → object or new_array click to toggle source

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])
Array({foo: 0, bar: 1}) Array(0..4)

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

Array(:foo)

static VALUE rb_f_array(VALUE obj, VALUE arg) { return rb_Array(arg); }

Complex(real, imag = 0, exception: true) → complex or nil click to toggle source

Complex(s, exception: true) → complex or nil

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:

static VALUE nucomp_f_complex(int argc, VALUE *argv, VALUE klass) { VALUE a1, a2, opts = Qnil; int raise = TRUE;

if (rb_scan_args(argc, argv, "11:", &a1, &a2, &opts) == 1) {
    a2 = Qundef;
}
if (!NIL_P(opts)) {
    raise = rb_opts_exception_p(opts, raise);
}
if (argc > 0 && CLASS_OF(a1) == rb_cComplex && UNDEF_P(a2)) {
    return a1;
}
return nucomp_convert(rb_cComplex, a1, a2, raise);

}

Float(arg, exception: true) → float or nil click to toggle source

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)
Float("123.456")
Float("123.0_badstring") Float(nil)
Float("123.0_badstring", exception: false)

def Float(arg, exception: true) if Primitive.mandatory_only? Primitive.rb_f_float1(arg) else Primitive.rb_f_float(arg, exception) end end

Hash(object) → object or new_hash click to toggle source

Returns a hash converted from object.

Examples:

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

static VALUE rb_f_hash(VALUE obj, VALUE arg) { return rb_Hash(arg); }

Integer(object, base = 0, exception: true) → integer or nil click to toggle source

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)
Integer(-1)

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

Integer(1.9)
Integer(-1.9)

String objects ↑

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

Integer('100')
Integer('-100')

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

Integer('0100')
Integer('0b100') Integer('0x100')

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

Integer('100', 2)
Integer('100', 8)
Integer('-100', 16)

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

Integer('0x100', -2)
Integer('100', -2)
Integer('0b100', -8)
Integer('100', -8)
Integer('0o100', -10)
Integer('100', -10)

base -1 is equivalent to the -10 case.

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

Integer(' 100 ')
Integer('-1_0_0', 16)

Other classes ↑

Examples with object of various other classes:

Integer(Rational(9, 10)) Integer(Complex(2, 0))
Integer(Time.now)

Keywords ↑

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

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

def Integer(arg, base = 0, exception: true) if Primitive.mandatory_only? Primitive.rb_f_integer1(arg) else Primitive.rb_f_integer(arg, base, exception) end end

Rational(x, y, exception: true) → rational or nil click to toggle source

Rational(arg, exception: true) → rational or nil

Returns x/y or arg as a Rational.

Rational(2, 3)
Rational(5)
Rational(0.5)
Rational(0.3)

Rational("2/3")
Rational("0.3")

Rational("10 cents")
Rational(nil)
Rational(1, nil)

Rational("10 cents", exception: false)

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.

static VALUE nurat_f_rational(int argc, VALUE *argv, VALUE klass) { VALUE a1, a2, opts = Qnil; int raise = TRUE;

if (rb_scan_args(argc, argv, "11:", &a1, &a2, &opts) == 1) {
    a2 = Qundef;
}
if (!NIL_P(opts)) {
    raise = rb_opts_exception_p(opts, raise);
}
return nurat_convert(rb_cRational, a1, a2, raise);

}

String(object) → object or new_string click to toggle source

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])
String(0..5)
String({foo: 0, bar: 1})

Raises TypeError if object cannot be converted to a string.

static VALUE rb_f_string(VALUE obj, VALUE arg) { return rb_String(arg); }

__callee__ → symbol click to toggle source

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

static VALUE rb_f_callee_name(VALUE _) { ID fname = prev_frame_callee(); /* need callee ID */

if (fname) {
    return ID2SYM(fname);
}
else {
    return Qnil;
}

}

__dir__ → string click to toggle source

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__)).

static VALUE f_current_dirname(VALUE _) { VALUE base = rb_current_realfilepath(); if (NIL_P(base)) { return Qnil; } base = rb_file_dirname(base); return base; }

__method__ → symbol click to toggle source

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

static VALUE rb_f_method_name(VALUE _) { ID fname = prev_frame_func(); /* need method ID */

if (fname) {
    return ID2SYM(fname);
}
else {
    return Qnil;
}

}

`command` → string click to toggle source

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> $ $?.status # => 99>

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

static VALUE rb_f_backquote(VALUE obj, VALUE str) { VALUE port; VALUE result; rb_io_t *fptr;

StringValue(str);
rb_last_status_clear();
port = pipe_open_s(str, "r", FMODE_READABLE|DEFAULT_TEXTMODE, NULL);
if (NIL_P(port)) return rb_str_new(0,0);

GetOpenFile(port, fptr);
result = read_all(fptr, remain_size(fptr), Qnil);
rb_io_close(port);
rb_io_fptr_cleanup_all(fptr);
RB_GC_GUARD(port);

return result;

}

abort click to toggle source

abort(msg = nil)

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.

static VALUE f_abort(int c, const VALUE *a, VALUE _) { rb_f_abort(c, a); UNREACHABLE_RETURN(Qnil); }

at_exit { block } → proc click to toggle source

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

static VALUE rb_f_at_exit(VALUE _) { VALUE proc;

if (!rb_block_given_p()) {
    rb_raise(rb_eArgError, "called without a block");
}
proc = rb_block_proc();
rb_set_end_proc(rb_call_end_proc, proc);
return proc;

}

autoload(const, filename) → nil click to toggle source

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.

static VALUE rb_f_autoload(VALUE obj, VALUE sym, VALUE file) { VALUE klass = rb_class_real(rb_vm_cbase()); if (!klass) { rb_raise(rb_eTypeError, "Can not set autoload on singleton class"); } return rb_mod_autoload(klass, sym, file); }

autoload?(name, inherit=true) → String or nil click to toggle source

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)

module C autoload(:D, "d") autoload?(:D)
autoload?(:B)
end

class E autoload(:F, "f") autoload?(:F)
autoload?(:B)
end

static VALUE rb_f_autoload_p(int argc, VALUE argv, VALUE obj) { / use rb_vm_cbase() as same as rb_f_autoload. */ VALUE klass = rb_vm_cbase(); if (NIL_P(klass)) { return Qnil; } return rb_mod_autoload_p(argc, argv, klass); }

binding → a_binding click to toggle source

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}'

eval(template, user.get_binding)

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

def validate(field, validation, if: nil) condition = binding.local_variable_get('if') return unless condition

end

validate(:name, :empty?, if: false) validate(:name, :empty?, if: true)

static VALUE rb_f_binding(VALUE self) { return rb_binding_new(); }

block_given? → true or false click to toggle source

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
try { "hello" }
try do "hello" end

static VALUE rb_f_block_given_p(VALUE _) { rb_execution_context_t *ec = GET_EC(); rb_control_frame_t *cfp = ec->cfp; cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));

return RBOOL(cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE);

}

callcc {|cont| block } → obj click to toggle source

Generates a Continuation object, which it passes to the associated block. You need to require 'continuation' before using this method. Performing a cont.call will cause the callcc to return (as will falling through the end of the block). The value returned by the callcc is the value of the block, or the value passed to cont.call. See class Continuation for more details. Also see Kernel#throw for an alternative mechanism for unwinding a call stack.

static VALUE rb_callcc(VALUE self) { volatile int called; volatile VALUE val = cont_capture(&called);

if (called) {
    return val;
}
else {
    return rb_yield(val);
}

}

caller(start=1, length=nil) → array or nil click to toggle source

caller(range) → array or nil

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)
c(1)
c(2)
c(3)
c(4)
c(5)

static VALUE rb_f_caller(int argc, VALUE *argv, VALUE _) { return ec_backtrace_to_ary(GET_EC(), argc, argv, 1, 1, 1); }

caller_locations(start=1, length=nil) → array or nil click to toggle source

caller_locations(range) → array or nil

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.

static VALUE rb_f_caller_locations(int argc, VALUE *argv, VALUE _) { return ec_backtrace_to_ary(GET_EC(), argc, argv, 1, 1, 0); }

catch([tag]) {|tag| block } → obj click to toggle source

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 }

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) }
catch(1) { throw(1) }

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

catch(1) {|x| x + 2 }

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

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

static VALUE rb_f_catch(int argc, VALUE *argv, VALUE self) { VALUE tag = rb_check_arity(argc, 0, 1) ? argv[0] : rb_obj_alloc(rb_cObject); return rb_catch_obj(tag, catch_i, 0); }

chomp → $_ click to toggle source

chomp(string) → $_

Equivalent to $_ = $_.chomp(_string_). See String#chomp. Available only when -p/-n command line option specified.

static VALUE rb_f_chomp(int argc, VALUE *argv, VALUE _) { VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("chomp"), argc, argv); rb_lastline_set(str); return str; }

chop → $_ click to toggle source

Equivalent to ($_.dup).chop!, except nil is never returned. See String#chop!. Available only when -p/-n command line option specified.

static VALUE rb_f_chop(VALUE _) { VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("chop"), 0, 0); rb_lastline_set(str); return str; }

class → class click to toggle source

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
self.class

def class Primitive.attr! :leaf Primitive.cexpr! 'rb_obj_class(self)' end

clone(freeze: nil) → an_object click to toggle source

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
s1.str = "Hello"
s2 = s1.clone
s2.str[1,4] = "i"
s1.inspect
s2.inspect

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

def clone(freeze: nil) Primitive.rb_obj_clone2(freeze) end

eval(string [, binding [, filename [,lineno]]]) → obj click to toggle source

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'"
eval "str + ' Fred'", get_binding("bye")

VALUE rb_f_eval(int argc, const VALUE *argv, VALUE self) { VALUE src, scope, vfile, vline; VALUE file = Qundef; int line = 1;

rb_scan_args(argc, argv, "13", &src, &scope, &vfile, &vline);
StringValue(src);
if (argc >= 3) {
    StringValue(vfile);
}
if (argc >= 4) {
    line = NUM2INT(vline);
}

if (!NIL_P(vfile))
    file = vfile;

if (NIL_P(scope))
    return eval_string_with_cref(self, src, NULL, file, line);
else
    return eval_string_with_scope(scope, src, file, line);

}

exec([env, ] command_line, options = {}) click to toggle source

exec([env, ] exe_path, *args, options = {})

Replaces the current process by doing one of the following:

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

The new process is created using the exec system call; 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:

Argument command_line

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') exec('exit')
exec('date > date.tmp')

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.

Argument exe_path

Argument exe_path is one of the following:

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')

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.

static VALUE f_exec(int c, const VALUE *a, VALUE _) { rb_f_exec(c, a); UNREACHABLE_RETURN(Qnil); }

exit(status = true) click to toggle source

exit(status = true)

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.

static VALUE f_exit(int c, const VALUE *a, VALUE _) { rb_f_exit(c, a); UNREACHABLE_RETURN(Qnil); }

exit!(status = false) click to toggle source

exit!(status = false)

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.

static VALUE rb_f_exit_bang(int argc, VALUE *argv, VALUE obj) { int istatus;

if (rb_check_arity(argc, 0, 1) == 1) {
    istatus = exit_status_code(argv[0]);
}
else {
    istatus = EXIT_FAILURE;
}
_exit(istatus);

UNREACHABLE_RETURN(Qnil);

}

fail(*args)

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

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

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

p ex.backtrace_locations

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

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

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

fork { ... } → integer or nil click to toggle source

fork → integer or nil

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
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:

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:

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)

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

static VALUE rb_f_fork(VALUE obj) { rb_pid_t pid;

pid = rb_call_proc__fork();

if (pid == 0) {
    if (rb_block_given_p()) {
        int status;
        rb_protect(rb_yield, Qundef, &status);
        ruby_stop(status);
    }
    return Qnil;
}

return PIDT2NUM(pid);

}

format(*args)

Returns the string resulting from formatting objects into format_string.

For details on format_string, see Format Specifications.

frozen? → true or false click to toggle source

Returns the freeze status of obj.

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

def frozen? Primitive.attr! :leaf Primitive.cexpr! 'rb_obj_frozen_p(self)' end

gets(sep=$/ [, getline_args]) → string or nil click to toggle source

gets(limit [, getline_args]) → string or nil

gets(sep, limit [, getline_args]) → string or nil

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.

static VALUE rb_f_gets(int argc, VALUE *argv, VALUE recv) { if (recv == argf) { return argf_gets(argc, argv, argf); } return forward(argf, idGets, argc, argv); }

global_variables → array click to toggle source

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/

static VALUE f_global_variables(VALUE _) { return rb_f_global_variables(); }

gsub(pattern, replacement) → $_ click to toggle source

gsub(pattern) {|...| block } → $_

Equivalent to $_.gsub..., except that $_ will be updated if substitution occurs. Available only when -p/-n command line option specified.

static VALUE rb_f_gsub(int argc, VALUE *argv, VALUE _) { VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("gsub"), argc, argv); rb_lastline_set(str); return str; }

iterator? → true or false click to toggle source

Deprecated. Use block_given? instead.

static VALUE rb_f_iterator_p(VALUE self) { rb_warn_deprecated("iterator?", "block_given?"); return rb_f_block_given_p(self); }

lambda { |...| block } → a_proc click to toggle source

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

static VALUE f_lambda(VALUE _) { f_lambda_filter_non_literal(); return rb_block_lambda(); }

load(filename, wrap=false) → true click to toggle source

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.

static VALUE rb_f_load(int argc, VALUE *argv, VALUE _) { VALUE fname, wrap, path, orig_fname;

rb_scan_args(argc, argv, "11", &fname, &wrap);

orig_fname = rb_get_path_check_to_string(fname);
fname = rb_str_encode_ospath(orig_fname);
RUBY_DTRACE_HOOK(LOAD_ENTRY, RSTRING_PTR(orig_fname));

path = rb_find_file(fname);
if (!path) {
    if (!rb_file_load_ok(RSTRING_PTR(fname)))
        load_failed(orig_fname);
    path = fname;
}
rb_load_internal(path, wrap);

RUBY_DTRACE_HOOK(LOAD_RETURN, RSTRING_PTR(orig_fname));

return Qtrue;

}

local_variables → array click to toggle source

Returns the names of the current local variables.

fred = 1 for i in 1..10

end local_variables

static VALUE rb_f_local_variables(VALUE _) { struct local_var_list vars; rb_execution_context_t *ec = GET_EC(); rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(ec->cfp)); unsigned int i;

local_var_list_init(&vars);
while (cfp) {
    if (cfp->iseq) {
        for (i = 0; i < ISEQ_BODY(cfp->iseq)->local_table_size; i++) {
            local_var_list_add(&vars, ISEQ_BODY(cfp->iseq)->local_table[i]);
        }
    }
    if (!VM_ENV_LOCAL_P(cfp->ep)) {
        /* block */
        const VALUE *ep = VM_CF_PREV_EP(cfp);

        if (vm_collect_local_variables_in_heap(ep, &vars)) {
            break;
        }
        else {
            while (cfp->ep != ep) {
                cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
            }
        }
    }
    else {
        break;
    }
}
return local_var_list_finish(&vars);

}

loop { block } click to toggle source

loop → an_enumerator

Repeatedly executes the block.

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

loop do print "Input: " line = gets 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 }

def loop Primitive.attr! :inline_block unless defined?(yield) return Primitive.cexpr! 'SIZED_ENUMERATOR(self, 0, 0, rb_f_loop_size)' end

begin while true yield end rescue StopIteration => e e.result end end

open(path, mode = 'r', perm = 0666, **opts) → io or nil click to toggle source

open(path, mode = 'r', perm = 0666, **opts) {|io| ... } → obj

Creates an IO object connected to the given file.

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

With no block given, file stream is returned:

open('t.txt')

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

open('t.txt') {|f| p f }

Output:

See File.open for details.

static VALUE rb_f_open(int argc, VALUE *argv, VALUE _) { ID to_open = 0; int redirect = FALSE;

if (argc >= 1) {
    CONST_ID(to_open, "to_open");
    if (rb_respond_to(argv[0], to_open)) {
        redirect = TRUE;
    }
    else {
        VALUE tmp = argv[0];
        FilePathValue(tmp);
        if (NIL_P(tmp)) {
            redirect = TRUE;
        }
        else {
            VALUE cmd = check_pipe_command(tmp);
            if (!NIL_P(cmd)) {
                // TODO: when removed in 4.0, update command_injection.rdoc
                rb_warn_deprecated_to_remove_at(4.0, "Calling Kernel#open with a leading '|'", "IO.popen");
                argv[0] = cmd;
                return rb_io_s_popen(argc, argv, rb_cIO);
            }
        }
    }
}
if (redirect) {
    VALUE io = rb_funcallv_kw(argv[0], to_open, argc-1, argv+1, RB_PASS_CALLED_KEYWORDS);

    if (rb_block_given_p()) {
        return rb_ensure(rb_yield, io, io_close, io);
    }
    return io;
}
return rb_io_s_open(argc, argv, rb_cFile);

}

p(object) → obj click to toggle source

p(*objects) → array of objects

p → 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
p [r, r, r]
p

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.

static VALUE rb_f_p(int argc, VALUE *argv, VALUE self) { int i; for (i=0; i<argc; i++) { VALUE inspected = rb_obj_as_string(rb_inspect(argv[i])); rb_uninterruptible(rb_p_write, inspected); } return rb_p_result(argc, argv); }

print(*objects) → nil click to toggle source

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 $\), if it is not nil.

With argument objects given, for each object:

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
print

static VALUE rb_f_print(int argc, const VALUE *argv, VALUE _) { rb_io_print(argc, argv, rb_ractor_stdout()); return Qnil; }

printf(format_string, *objects) → nil click to toggle source

printf(io, format_string, *objects) → 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.

static VALUE rb_f_printf(int argc, VALUE *argv, VALUE _) { VALUE out;

if (argc == 0) return Qnil;
if (RB_TYPE_P(argv[0], T_STRING)) {
    out = rb_ractor_stdout();
}
else {
    out = argv[0];
    argv++;
    argc--;
}
rb_io_write(out, rb_f_sprintf(argc, argv));

return Qnil;

}

proc { |...| block } → a_proc click to toggle source

Equivalent to Proc.new.

static VALUE f_proc(VALUE _) { return proc_new(rb_cProc, FALSE); }

putc(int) → int click to toggle source

Equivalent to:

$stdout.putc(int)

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

static VALUE rb_f_putc(VALUE recv, VALUE ch) { VALUE r_stdout = rb_ractor_stdout(); if (recv == r_stdout) { return rb_io_putc(recv, ch); } return forward(r_stdout, rb_intern("putc"), 1, &ch); }

puts(*objects) → nil click to toggle source

Equivalent to

$stdout.puts(objects)

static VALUE rb_f_puts(int argc, VALUE *argv, VALUE recv) { VALUE r_stdout = rb_ractor_stdout(); if (recv == r_stdout) { return rb_io_puts(argc, argv, recv); } return forward(r_stdout, rb_intern("puts"), argc, argv); }

raise(exception, message = exception.to_s, backtrace = nil, cause: $!) click to toggle source

raise(message = nil, cause: $!)

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

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

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

p ex.backtrace_locations

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

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

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

static VALUE f_raise(int c, VALUE *v, VALUE _) { return rb_f_raise(c, v); }

Also aliased as: fail

rand(max=0) → number click to toggle source

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

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)

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) rand(-0.5) rand(1.9)

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

See also Random.rand.

static VALUE rb_f_rand(int argc, VALUE *argv, VALUE obj) { VALUE vmax; rb_random_t *rnd = rand_start(default_rand());

if (rb_check_arity(argc, 0, 1) && !NIL_P(vmax = argv[0])) {
    VALUE v = rand_range(obj, rnd, vmax);
    if (v != Qfalse) return v;
    vmax = rb_to_int(vmax);
    if (vmax != INT2FIX(0)) {
        v = rand_int(obj, rnd, vmax, 0);
        if (!NIL_P(v)) return v;
    }
}
return DBL2NUM(random_real(obj, rnd, TRUE));

}

readline(sep = $/, chomp: false) → string click to toggle source

readline(limit, chomp: false) → string

readline(sep, limit, chomp: false) → 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.

static VALUE rb_f_readline(int argc, VALUE *argv, VALUE recv) { if (recv == argf) { return argf_readline(argc, argv, argf); } return forward(argf, rb_intern("readline"), argc, argv); }

readlines(sep = $/, chomp: false, **enc_opts) → array click to toggle source

readlines(limit, chomp: false, **enc_opts) → array

readlines(sep, limit, chomp: false, **enc_opts) → array

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.

static VALUE rb_f_readlines(int argc, VALUE *argv, VALUE recv) { if (recv == argf) { return argf_readlines(argc, argv, argf); } return forward(argf, rb_intern("readlines"), argc, argv); }

require(name) → true or false click to toggle source

Loads the given name, returning true if successful and false if the feature is already loaded.

If the filename neither resolves to an absolute path nor starts with ‘./’ or ‘../’, the file will be searched for in the library directories listed in $LOAD_PATH ($:). If the filename starts with ‘./’ or ‘../’, resolution is based on Dir.pwd.

If the filename has the extension “.rb”, it is loaded as a source file; if the extension is “.so”, “.o”, or the default shared library extension on the current platform, Ruby loads the shared library as a Ruby extension. Otherwise, Ruby tries adding “.rb”, “.so”, and so on to the name until found. If the file named cannot be found, a LoadError will be raised.

For Ruby extensions the filename given may use “.so” or “.o”. For example, on macOS the socket extension is “socket.bundle” and require 'socket.so' will load the socket extension.

The absolute path of the loaded file is added to $LOADED_FEATURES ($"). A file will not be loaded again if its path already appears in $". For example, require 'a'; require './a' will not load a.rb again.

require "my-library.rb" require "db-driver"

Any constants or globals within the loaded source file will be available in the calling program’s global namespace. However, local variables will not be propagated to the loading environment.

VALUE rb_f_require(VALUE obj, VALUE fname) { return rb_require_string(fname); }

require_relative(string) → true or false click to toggle source

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.

VALUE rb_f_require_relative(VALUE obj, VALUE fname) { VALUE base = rb_current_realfilepath(); if (NIL_P(base)) { rb_loaderror("cannot infer basepath"); } base = rb_file_dirname(base); return rb_require_string_internal(rb_file_absolute_path(fname, base), false); }

select(read_ios, write_ios = [], error_ios = [], timeout = nil) → array or nil click to toggle source

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.

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:

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 {

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

static VALUE rb_f_select(int argc, VALUE *argv, VALUE obj) { VALUE scheduler = rb_fiber_scheduler_current(); if (scheduler != Qnil) { // It's optionally supported. VALUE result = rb_fiber_scheduler_io_selectv(scheduler, argc, argv); if (!UNDEF_P(result)) return result; }

VALUE timeout;
struct select_args args;
struct timeval timerec;
int i;

rb_scan_args(argc, argv, "13", &args.read, &args.write, &args.except, &timeout);
if (NIL_P(timeout)) {
    args.timeout = 0;
}
else {
    timerec = rb_time_interval(timeout);
    args.timeout = &timerec;
}

for (i = 0; i < numberof(args.fdsets); ++i)
    rb_fd_init(&args.fdsets[i]);

return rb_ensure(select_call, (VALUE)&args, select_end, (VALUE)&args);

}

set_trace_func(proc) → proc click to toggle source

set_trace_func(nil) → nil

Establishes proc as the handler for tracing, or disables tracing if the parameter is nil.

Note: this method is obsolete, please use TracePoint instead.

proc takes up to six parameters:

proc is invoked whenever an event occurs.

Events are:

"c-call"

call a C-language routine

"c-return"

return from a C-language routine

"call"

call a Ruby method

"class"

start a class or module definition

"end"

finish a class or module definition

"line"

execute code on a new line

"raise"

raise an exception

"return"

return from a Ruby method

Tracing is disabled within the context of proc.

class Test def test a = 1 b = 2 end end

set_trace_func proc { |event, file, line, id, binding, class_or_module| printf "%8s %s:%-2d %16p %14p\n", event, file, line, id, class_or_module } t = Test.new t.test

Produces:

c-return prog.rb:8 :set_trace_func Kernel line prog.rb:11 nil nil c-call prog.rb:11 :new Class c-call prog.rb:11 :initialize BasicObject c-return prog.rb:11 :initialize BasicObject c-return prog.rb:11 :new Class line prog.rb:12 nil nil call prog.rb:2 :test Test line prog.rb:3 :test Test line prog.rb:4 :test Test return prog.rb:5 :test Test

static VALUE set_trace_func(VALUE obj, VALUE trace) { rb_remove_event_hook(call_trace_func);

if (NIL_P(trace)) {
    return Qnil;
}

if (!rb_obj_is_proc(trace)) {
    rb_raise(rb_eTypeError, "trace_func needs to be Proc");
}

rb_add_event_hook(call_trace_func, RUBY_EVENT_ALL, trace);
return trace;

}

sleep(secs = nil) → slept_secs click to toggle source

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
sleep 1.2 Time.new
sleep 1.9 Time.new

static VALUE rb_f_sleep(int argc, VALUE *argv, VALUE _) { time_t beg = time(0); VALUE scheduler = rb_fiber_scheduler_current();

if (scheduler != Qnil) {
    rb_fiber_scheduler_kernel_sleepv(scheduler, argc, argv);
}
else {
    if (argc == 0 || (argc == 1 && NIL_P(argv[0]))) {
        rb_thread_sleep_forever();
    }
    else {
        rb_check_arity(argc, 0, 1);
        rb_thread_wait_for(rb_time_interval(argv[0]));
    }
}

time_t end = time(0) - beg;

return TIMET2NUM(end);

}

spawn([env, ] command_line, options = {}) → pid click to toggle source

spawn([env, ] exe_path, *args, options = {}) → pid

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

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:

The new process is created using the exec system call; 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:

Argument command_line

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') Process.wait
spawn('exit')
Process.wait
spawn('date > /tmp/date.tmp')
Process.wait
spawn('date > /nop/date.tmp')
Process.wait

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

spawn('echo "Foo"') Process.wait

Output:

Foo

See Execution Shell for details about the shell.

Raises an exception if the new process could not execute.

Argument exe_path

Argument exe_path is one of the following:

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*')
Process.wait
spawn('echo', 'hello', 'world') Process.wait

Output:

C* hello world

Raises an exception if the new process could not execute.

static VALUE rb_f_spawn(int argc, VALUE *argv, VALUE _) { rb_pid_t pid; char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' }; VALUE execarg_obj, fail_str; struct rb_execarg *eargp;

execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE);
eargp = rb_execarg_get(execarg_obj);
fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;

pid = rb_execarg_spawn(execarg_obj, errmsg, sizeof(errmsg));

if (pid == -1) {
    int err = errno;
    rb_exec_fail(eargp, err, errmsg);
    RB_GC_GUARD(execarg_obj);
    rb_syserr_fail_str(err, fail_str);
}

#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV) return PIDT2NUM(pid); #else return Qnil; #endif }

sprintf(format_string *objects) → string click to toggle source

Returns the string resulting from formatting objects into format_string.

For details on format_string, see Format Specifications.

static VALUE f_sprintf(int c, const VALUE *v, VALUE _) { return rb_f_sprintf(c, v); }

srand(number = Random.new_seed) → old_seed click to toggle source

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
[ rand, rand ]
[ rand(10), rand(1000) ] srand 1234
[ rand, rand ]

static VALUE rb_f_srand(int argc, VALUE *argv, VALUE obj) { VALUE seed, old; rb_random_mt_t *r = rand_mt_start(default_rand());

if (rb_check_arity(argc, 0, 1) == 0) {
    seed = random_seed(obj);
}
else {
    seed = rb_to_int(argv[0]);
}
old = r->base.seed;
rand_init(&random_mt_if, &r->base, seed);
r->base.seed = seed;

return old;

}

sub(pattern, replacement) → $_ click to toggle source

sub(pattern) {|...| block } → $_

Equivalent to $_.sub(_args_), except that $_ will be updated if substitution occurs. Available only when -p/-n command line option specified.

static VALUE rb_f_sub(int argc, VALUE *argv, VALUE _) { VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("sub"), argc, argv); rb_lastline_set(str); return str; }

syscall(integer_callno, *arguments) → integer click to toggle source

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.

static VALUE rb_f_syscall(int argc, VALUE argv, VALUE _) { VALUE arg[8]; #if SIZEOF_VOIDP == 8 && defined(HAVE___SYSCALL) && SIZEOF_INT != 8 / mainly *BSD */

define SYSCALL __syscall

define NUM2SYSCALLID(x) NUM2LONG(x)

define RETVAL2NUM(x) LONG2NUM(x)

if SIZEOF_LONG == 8

long num, retval = -1;

elif SIZEOF_LONG_LONG == 8

long long num, retval = -1;

else

error ---->> it is asserted that __syscall takes the first argument and returns retval in 64bit signed integer. <<----

endif

#elif defined(linux)

define SYSCALL syscall

define NUM2SYSCALLID(x) NUM2LONG(x)

define RETVAL2NUM(x) LONG2NUM(x)

/*
 * Linux man page says, syscall(2) function prototype is below.
 *
 *     int syscall(int number, ...);
 *
 * But, it's incorrect. Actual one takes and returned long. (see unistd.h)
 */
long num, retval = -1;

#else

define SYSCALL syscall

define NUM2SYSCALLID(x) NUM2INT(x)

define RETVAL2NUM(x) INT2NUM(x)

int num, retval = -1;

#endif int i;

if (RTEST(ruby_verbose)) {
    rb_category_warning(RB_WARN_CATEGORY_DEPRECATED,
        "We plan to remove a syscall function at future release. DL(Fiddle) provides safer alternative.");
}

if (argc == 0)
    rb_raise(rb_eArgError, "too few arguments for syscall");
if (argc > numberof(arg))
    rb_raise(rb_eArgError, "too many arguments for syscall");
num = NUM2SYSCALLID(argv[0]); ++argv;
for (i = argc - 1; i--; ) {
    VALUE v = rb_check_string_type(argv[i]);

    if (!NIL_P(v)) {
        StringValue(v);
        rb_str_modify(v);
        arg[i] = (VALUE)StringValueCStr(v);
    }
    else {
        arg[i] = (VALUE)NUM2LONG(argv[i]);
    }
}

switch (argc) {
  case 1:
    retval = SYSCALL(num);
    break;
  case 2:
    retval = SYSCALL(num, arg[0]);
    break;
  case 3:
    retval = SYSCALL(num, arg[0],arg[1]);
    break;
  case 4:
    retval = SYSCALL(num, arg[0],arg[1],arg[2]);
    break;
  case 5:
    retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3]);
    break;
  case 6:
    retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4]);
    break;
  case 7:
    retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5]);
    break;
  case 8:
    retval = SYSCALL(num, arg[0],arg[1],arg[2],arg[3],arg[4],arg[5],arg[6]);
    break;
}

if (retval == -1)
    rb_sys_fail(0);
return RETVAL2NUM(retval);

#undef SYSCALL #undef NUM2SYSCALLID #undef RETVAL2NUM }

system([env, ] command_line, options = {}, exception: false) → true, false, or nil click to toggle source

system([env, ] exe_path, *args, options = {}, exception: false) → true, false, or nil

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

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

Returns:

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; 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:

Argument command_line

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')
system('exit')
system('date > /tmp/date.tmp')
system('date > /nop/date.tmp')
system('date > /nop/date.tmp', exception: true)

Assigns the command’s error status to $?:

system('exit')
$?
system('date > /nop/date.tmp')
$?

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

system('echo "Foo"')

Output:

Foo

See Execution Shell for details about the shell.

Raises an exception if the new process could not execute.

Argument exe_path

Argument exe_path is one of the following:

Example:

system('/usr/bin/date') system('foo')

Output:

Mon Aug 28 11:43:10 AM CDT 2023

Assigns the command’s error status to $?:

system('/usr/bin/date') $?
system('foo')
$?

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

system('doesnt_exist')

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

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

Output:

C* hello world

Raises an exception if the new process could not execute.

static VALUE rb_f_system(int argc, VALUE *argv, VALUE _) { rb_thread_t *th = GET_THREAD(); VALUE execarg_obj = rb_execarg_new(argc, argv, TRUE, TRUE); struct rb_execarg *eargp = rb_execarg_get(execarg_obj);

struct rb_process_status status = {0};
eargp->status = &status;

last_status_clear(th);

// This function can set the thread's last status.
// May be different from waitpid_state.pid on exec failure.
rb_pid_t pid = rb_execarg_spawn(execarg_obj, 0, 0);

if (pid > 0) {
    VALUE status = rb_process_status_wait(pid, 0);
    struct rb_process_status *data = rb_check_typeddata(status, &rb_process_status_type);
    // Set the last status:
    rb_obj_freeze(status);
    th->last_status = status;

    if (data->status == EXIT_SUCCESS) {
        return Qtrue;
    }

    if (data->error != 0) {
        if (eargp->exception) {
            VALUE command = eargp->invoke.sh.shell_script;
            RB_GC_GUARD(execarg_obj);
            rb_syserr_fail_str(data->error, command);
        }
        else {
            return Qnil;
        }
    }
    else if (eargp->exception) {
        VALUE command = eargp->invoke.sh.shell_script;
        VALUE str = rb_str_new_cstr("Command failed with");
        rb_str_cat_cstr(pst_message_status(str, data->status), ": ");
        rb_str_append(str, command);
        RB_GC_GUARD(execarg_obj);
        rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, str));
    }
    else {
        return Qfalse;
    }

    RB_GC_GUARD(status);
}

if (eargp->exception) {
    VALUE command = eargp->invoke.sh.shell_script;
    RB_GC_GUARD(execarg_obj);
    rb_syserr_fail_str(errno, command);
}
else {
    return Qnil;
}

}

tap {|x| block } → obj click to toggle source

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}" }

def tap Primitive.attr! :inline_block yield(self) self end

test(char, path0, path1 = nil) → object click to toggle source

Performs a test on one or both of the filesystem entities at the given paths path0 and path1:

The tests:

static VALUE rb_f_test(int argc, VALUE *argv, VALUE _) { int cmd;

if (argc == 0) rb_check_arity(argc, 2, 3);
cmd = NUM2CHR(argv[0]);
if (cmd == 0) {
    goto unknown;
}
if (strchr("bcdefgGkloOprRsSuwWxXz", cmd)) {
    CHECK(1);
    switch (cmd) {
      case 'b':
        return rb_file_blockdev_p(0, argv[1]);

      case 'c':
        return rb_file_chardev_p(0, argv[1]);

      case 'd':
        return rb_file_directory_p(0, argv[1]);

      case 'e':
        return rb_file_exist_p(0, argv[1]);

      case 'f':
        return rb_file_file_p(0, argv[1]);

      case 'g':
        return rb_file_sgid_p(0, argv[1]);

      case 'G':
        return rb_file_grpowned_p(0, argv[1]);

      case 'k':
        return rb_file_sticky_p(0, argv[1]);

      case 'l':
        return rb_file_symlink_p(0, argv[1]);

      case 'o':
        return rb_file_owned_p(0, argv[1]);

      case 'O':
        return rb_file_rowned_p(0, argv[1]);

      case 'p':
        return rb_file_pipe_p(0, argv[1]);

      case 'r':
        return rb_file_readable_p(0, argv[1]);

      case 'R':
        return rb_file_readable_real_p(0, argv[1]);

      case 's':
        return rb_file_size_p(0, argv[1]);

      case 'S':
        return rb_file_socket_p(0, argv[1]);

      case 'u':
        return rb_file_suid_p(0, argv[1]);

      case 'w':
        return rb_file_writable_p(0, argv[1]);

      case 'W':
        return rb_file_writable_real_p(0, argv[1]);

      case 'x':
        return rb_file_executable_p(0, argv[1]);

      case 'X':
        return rb_file_executable_real_p(0, argv[1]);

      case 'z':
        return rb_file_zero_p(0, argv[1]);
    }
}

if (strchr("MAC", cmd)) {
    struct stat st;
    VALUE fname = argv[1];

    CHECK(1);
    if (rb_stat(fname, &st) == -1) {
        int e = errno;
        FilePathValue(fname);
        rb_syserr_fail_path(e, fname);
    }

    switch (cmd) {
      case 'A':
        return stat_atime(&st);
      case 'M':
        return stat_mtime(&st);
      case 'C':
        return stat_ctime(&st);
    }
}

if (cmd == '-') {
    CHECK(2);
    return rb_file_identical_p(0, argv[1], argv[2]);
}

if (strchr("=<>", cmd)) {
    struct stat st1, st2;
    struct timespec t1, t2;

    CHECK(2);
    if (rb_stat(argv[1], &st1) < 0) return Qfalse;
    if (rb_stat(argv[2], &st2) < 0) return Qfalse;

    t1 = stat_mtimespec(&st1);
    t2 = stat_mtimespec(&st2);

    switch (cmd) {
      case '=':
        if (t1.tv_sec == t2.tv_sec && t1.tv_nsec == t2.tv_nsec) return Qtrue;
        return Qfalse;

      case '>':
        if (t1.tv_sec > t2.tv_sec) return Qtrue;
        if (t1.tv_sec == t2.tv_sec && t1.tv_nsec > t2.tv_nsec) return Qtrue;
        return Qfalse;

      case '<':
        if (t1.tv_sec < t2.tv_sec) return Qtrue;
        if (t1.tv_sec == t2.tv_sec && t1.tv_nsec < t2.tv_nsec) return Qtrue;
        return Qfalse;
    }
}

unknown: /* unknown command */ if (ISPRINT(cmd)) { rb_raise(rb_eArgError, "unknown command '%s%c'", cmd == ''' || cmd == '\' ? "\" : "", cmd); } else { rb_raise(rb_eArgError, "unknown command "\x%02X"", cmd); } UNREACHABLE_RETURN(Qundef); }

then {|x| block } → an_object click to toggle source

Yields self to the block and returns the result of the block.

3.next.then {|x| x**x }.to_s

A good use of then is value piping in method chains:

require 'open-uri' require 'json'

construct_url(arguments) .then {|url| URI(url).read } .then {|response| JSON.parse(response) }

When called without a block, the method returns an Enumerator, which can be used, for example, for conditional circuit-breaking:

1.then.detect(&:odd?)

2.then.detect(&:odd?)

def then Primitive.attr! :inline_block unless defined?(yield) return Primitive.cexpr! 'SIZED_ENUMERATOR(self, 0, 0, rb_obj_size)' end yield(self) end

throw(tag [, obj]) click to toggle source

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.

static VALUE rb_f_throw(int argc, VALUE *argv, VALUE _) { VALUE tag, value;

rb_scan_args(argc, argv, "11", &tag, &value);
rb_throw_obj(tag, value);
UNREACHABLE_RETURN(Qnil);

}

trace_var(symbol, cmd ) → nil click to toggle source

trace_var(symbol) {|val| block } → nil

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'

static VALUE f_trace_var(int c, const VALUE *a, VALUE _) { return rb_f_trace_var(c, a); }

trap( signal, command ) → obj click to toggle source

trap( signal ) {| | block } → obj

Specifies the handling of signals. The first parameter is a signal name (a string such as “SIGALRM”, “SIGUSR1”, and so on) or a signal number. The characters “SIG” may be omitted from the signal name. The command or block specifies code to be run when the signal is raised. If the command is the string “IGNORE” or “SIG_IGN”, the signal will be ignored. If the command is “DEFAULT” or “SIG_DFL”, the Ruby’s default handler will be invoked. If the command is “EXIT”, the script will be terminated by the signal. If the command is “SYSTEM_DEFAULT”, the operating system’s default handler will be invoked. Otherwise, the given command or block will be run. The special signal name “EXIT” or signal number zero will be invoked just prior to program termination. trap returns the previous handler for the given signal.

Signal.trap(0, proc { puts "Terminating: #{$$}" }) Signal.trap("CLD") { puts "Child died" } fork && Process.wait

produces:

Terminating: 27461 Child died Terminating: 27460

static VALUE sig_trap(int argc, VALUE *argv, VALUE _) { int sig; sighandler_t func; VALUE cmd;

rb_check_arity(argc, 1, 2);

sig = trap_signm(argv[0]);
if (reserved_signal_p(sig)) {
    const char *name = signo2signm(sig);
    if (name)
        rb_raise(rb_eArgError, "can't trap reserved signal: SIG%s", name);
    else
        rb_raise(rb_eArgError, "can't trap reserved signal: %d", sig);
}

if (argc == 1) {
    cmd = rb_block_proc();
    func = sighandler;
}
else {
    cmd = argv[1];
    func = trap_handler(&cmd, sig);
}

if (rb_obj_is_proc(cmd) &&
    !rb_ractor_main_p() && !rb_ractor_shareable_p(cmd)) {
    cmd = rb_proc_isolate(cmd);
}

return trap(sig, func, cmd);

}

untrace_var(symbol [, cmd] ) → array or nil click to toggle source

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.

static VALUE f_untrace_var(int c, const VALUE *a, VALUE _) { return rb_f_untrace_var(c, a); }

warn(*msgs, uplevel: nil, category: nil) → nil click to toggle source

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.

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

def warn(*msgs, uplevel: nil, category: nil) if Primitive.cexpr!("NIL_P(category)") Primitive.rb_warn_m(msgs, uplevel, nil) elsif Warning[category = Primitive.cexpr!("rb_to_symbol_type(category)")] Primitive.rb_warn_m(msgs, uplevel, category) end end

Private Instance Methods

pp(*objs) click to toggle source

suppress redefinition warning

def pp(*objs) require 'pp' pp(*objs) end

Also aliased as: pp