# module Kernel

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 #=> "1.2"

## What’s Here¶ ↑

Module Kernel provides methods that are useful for:

- Converting

- Querying

- Exiting

- Exceptions

- IO

- Procs

- Tracing

- Subprocesses

- Loading

- Yielding

- Random Values

- Other

### Converting¶ ↑

- `Array`: Returns an `Array` based on the given argument.

- `Complex`: Returns a `Complex` based on the given arguments.

- `Float`: Returns a `Float` based on the given arguments.

- `Hash`: Returns a `Hash` based on the given argument.

- `Integer`: Returns an `Integer` based on the given arguments.

- `Rational`: Returns a `Rational` based on the given arguments.

- `String`: Returns a `String` based on the given argument.

### Querying¶ ↑

- `__callee__`: Returns the called name of the current method as a symbol.

- `__dir__`: Returns the path to the directory from which the current method is called.

- `__method__`: Returns the name of the current method as a symbol.

- `autoload?`: Returns the file to be loaded when the given module is referenced.

- `binding`: Returns a `Binding` for the context at the point of call.

- `block_given?`: Returns `true` if a block was passed to the calling method.

- `caller`: Returns the current execution stack as an array of strings.

- `caller_locations`: Returns the current execution stack as an array of `Thread::Backtrace::Location` objects.

- `class`: Returns the class of `self`.

- `frozen?`: Returns whether `self` is frozen.

- `global_variables`: Returns an array of global variables as symbols.

- `local_variables`: Returns an array of local variables as symbols.

- `test`: Performs specified tests on the given single file or pair of files.

### Exiting¶ ↑

- `abort`: Exits the current process after printing the given arguments.

- `at_exit`: Executes the given block when the process exits.

- `exit`: Exits the current process after calling any registered `at_exit` handlers.

- `exit!`: Exits the current process without calling any registered `at_exit` handlers.

### Exceptions¶ ↑

- `catch`: Executes the given block, possibly catching a thrown object.

- `raise` (aliased as `fail`): Raises an exception based on the given arguments.

- `throw`: Returns from the active catch block waiting for the given tag.

### IO¶ ↑

- `::pp`: Prints the given objects in pretty form.

- `gets`: Returns and assigns to `$_` the next line from the current input.

- `open`: Creates an `IO` object connected to the given stream, file, or subprocess.

- `p`: Prints the given objects’ inspect output to the standard output.

- `print`: Prints the given objects to standard output without a newline.

- `printf`: Prints the string resulting from applying the given format string to any additional arguments.

- `putc`: Equivalent to <tt.$stdout.putc(object)</tt> for the given object.

- `puts`: Equivalent to `$stdout.puts(*objects)` for the given objects.

- `readline`: Similar to `gets`, but raises an exception at the end of file.

- `readlines`: Returns an array of the remaining lines from the current input.

- `select`: Same as `IO.select`.

### Procs¶ ↑

- `lambda`: Returns a lambda proc for the given block.

- `proc`: Returns a new `Proc`; equivalent to `Proc.new`.

### Tracing¶ ↑

- `set_trace_func`: Sets the given proc as the handler for tracing, or disables tracing if given `nil`.

- `trace_var`: Starts tracing assignments to the given global variable.

- `untrace_var`: Disables tracing of assignments to the given global variable.

### Subprocesses¶ ↑

- `command`: Returns the standard output of running `command` in a subshell.

- `exec`: Replaces current process with a new process.

- `fork`: Forks the current process into two processes.

- `spawn`: Executes the given command and returns its pid without waiting for completion.

- `system`: Executes the given command in a subshell.

### Loading¶ ↑

- `autoload`: Registers the given file to be loaded when the given constant is first referenced.

- `load`: Loads the given Ruby file.

- `require`: Loads the given Ruby file unless it has already been loaded.

- `require_relative`: Loads the Ruby file path relative to the calling file, unless it has already been loaded.

### Yielding¶ ↑

- `tap`: Yields `self` to the given block; returns `self`.

- `then` (aliased as `yield_self`): Yields `self` to the block and returns the result of the block.

### Random Values¶ ↑

- `rand`: Returns a pseudo-random floating point number strictly between 0.0 and 1.0.

- `srand`: Seeds the pseudo-random number generator with the given number.

### Other¶ ↑

- `eval`: Evaluates the given string as Ruby code.

- `loop`: Repeatedly executes the given block.

- `sleep`: Suspends the current thread for the given number of seconds.

- `sprintf` (aliased as `format`): Returns the string resulting from applying the given format string to any additional arguments.

- `syscall`: Runs an operating system call.

- `trap`: Specifies the handling of system signals.

- `warn`: Issue a warning based on the given messages and options.

### Public Class Methods

URI(uri) click to toggle source

Returns `uri` converted to an `URI` object.

    # File lib/uri/common.rb, line 718
    def URI(uri)
      if uri.is_a?(URI::Generic)
        uri
      elsif uri = String.try_convert(uri)
        URI.parse(uri)
      else
        raise ArgumentError,
          "bad argument (expected URI object or URI string)"
      end
    end

pp(*objs) click to toggle source

prints arguments in pretty form.

pp returns argument(s).

    # File lib/pp.rb, line 644
    def pp(*objs)
      objs.each {|obj|
        PP.pp(obj)
      }
      objs.size <= 1 ? objs.first : objs
    end

Also aliased as: pp

### 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])        # => [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]

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

BigDecimal(value, exception: true) → bigdecimal click to toggle source
BigDecimal(value, ndigits, exception: true) → 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 `true`.

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

    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);
    }

Complex(x[, y], exception: true) → numeric or nil click to toggle source

Returns x+i*y;

    Complex(1, 2)    #=> (1+2i)
    Complex('1+2i')  #=> (1+2i)
    Complex(nil)     #=> TypeError
    Complex(1, nil)  #=> TypeError

    Complex(1, nil, exception: false)  #=> nil
    Complex('1+2', exception: false)   #=> nil

Syntax of string form:

    string form = extra spaces , complex , extra spaces ;
    complex = real part | [ sign ] , imaginary part
            | real part , sign , imaginary part
            | rational , "@" , rational ;
    real part = rational ;
    imaginary part = imaginary unit | unsigned rational , imaginary unit ;
    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 ] ;
    imaginary unit = "i" | "I" | "j" | "J" ;
    sign = "-" | "+" ;
    digits = digit , { digit | "_" , digit };
    digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
    extra spaces = ? \s* ? ;

See `String#to_c`.

    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 a `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

    # File kernel.rb, line 171
    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`.

- 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([])               # => {}

    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 integer argument `object` given, returns `object`:

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

With floating-point argument `object` given, returns `object` truncated to an intger:

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

#### string objects¶ ↑

With 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 an integer in the radix indicator if 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 equal 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 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`.

- Raise `ArgumentError` if `object` is an invalid string.

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

    static VALUE
    rb_f_integer(int argc, VALUE *argv, VALUE obj)
    {
        VALUE arg = Qnil, opts = Qnil;
        int base = 0;

        if (argc > 1) {
            int narg = 1;
            VALUE vbase = rb_check_to_int(argv[1]);
            if (!NIL_P(vbase)) {
                base = NUM2INT(vbase);
                narg = 2;
            }
            if (argc > narg) {
                VALUE hash = rb_check_hash_type(argv[argc-1]);
                if (!NIL_P(hash)) {
                    opts = rb_extract_keywords(&hash);
                    if (!hash) --argc;
                }
            }
        }
        rb_check_arity(argc, 1, 2);
        arg = argv[0];

        return rb_convert_to_integer(arg, base, opts_exception_p(opts));
    }

Pathname(path) → pathname click to toggle source

Creates a new `Pathname` object from the given string, `path`, and returns pathname object.

In order to use this constructor, you must first require the `Pathname` standard library extension.

    require 'pathname'
    Pathname("/home/zzak")
    #=> #<Pathname:/home/zzak>

See also `Pathname::new` for more information.

    static VALUE
    path_f_pathname(VALUE self, VALUE str)
    {
        if (CLASS_OF(str) == rb_cPathname)
            return str;
        return rb_class_new_instance(1, &str, rb_cPathname);
    }

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)   #=> (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`.

    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])        # => "[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.

    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;

        SafeStringValue(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);
        RFILE(port)->fptr = NULL;
        rb_io_fptr_finalize(fptr);
        RB_GC_GUARD(port);

        return result;
    }

abort click to toggle source
Kernel::abort([msg])
abort([msg])

Terminate execution immediately, effectively by calling `Kernel.exit(false)`. If msg is given, it is written to STDERR prior to terminating.

    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`.

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

    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 `eval` to execute the evaluated command in this environment. See also the description of class `Binding`.

    def get_binding(param)
      binding
    end
    b = get_binding("hello")
    eval("param", b)   #=> "hello"

    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                  #=> "no block"
    try { "hello" }      #=> "hello"
    try do "hello" end   #=> "hello"

    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)   #=> ["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

    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 }            # => 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

    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      #=> Integer
    self.class   #=> Object

    # File kernel.rb, line 18
    def class
      Primitive.attr! 'inline'
      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      #=> #<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.

    # File kernel.rb, line 47
    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'"                      #=> "hello Fred"
    eval "str + ' Fred'", get_binding("bye")  #=> "bye Fred"

    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);
        SafeStringValue(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... [,options]) click to toggle source

Replaces the current process by running the given external command, which can take one of the following forms:

`exec(commandline)`

  command line string which is passed to the standard shell

`exec(cmdname, arg1, ...)`

  command name and one or more arguments (no shell)

`exec([cmdname, argv0], arg1, ...)`

  command name, `argv[0]` and zero or more arguments (no shell)

In the first form, the string is taken as a command line that is subject to shell expansion before being executed.

The standard shell always means `"/bin/sh"` on Unix-like systems, otherwise, `ENV["RUBYSHELL"]` or `ENV["COMSPEC"]` on Windows and similar. The command is passed as an argument to the `"-c"` switch to the shell, except in the case of `COMSPEC`.

If the string from the first form (`exec("command")`) follows these simple rules:

- no meta characters,

- not starting with shell reserved word or special built-in,

Ruby invokes the command directly without shell.

You can force shell invocation by adding “;” to the string (because “;” is a meta character).

Note that this behavior is observable by pid obtained (return value of spawn() and `IO#pid` for `IO.popen`) is the pid of the invoked command, not shell.

In the second form (`exec("command1", "arg1", ...)`), the first is taken as a command name and the rest are passed as parameters to command with no shell expansion.

In the third form (`exec(["command", "argv0"], "arg1", ...)`), starting a two-element array at the beginning of the command, the first element is the command to be executed, and the second argument is used as the `argv[0]` value, which may show up in process listings.

In order to execute the command, one of the `exec(2)` system calls are used, so the running command may inherit some of the environment of the original program (including open file descriptors).

This behavior is modified by the given `env` and `options` parameters. See ::spawn for details.

If the command fails to execute (typically Errno::ENOENT when it was not found) a `SystemCallError` exception is raised.

This method modifies process attributes according to given `options` before `exec(2)` system call. See ::spawn for more details about the given `options`.

The modified attributes may be retained when `exec(2)` system call fails.

For example, hard resource limits are not restorable.

Consider to create a child process using ::spawn or `Kernel#system` if this is not acceptable.

    exec "echo *"       # echoes list of files in current directory
    # never get here

    exec "echo", "*"    # echoes an asterisk
    # never get here

    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
Kernel::exit(status=true)
Process::exit(status=true)

Initiates the termination of the Ruby script by raising the `SystemExit` exception. This exception may be caught. The optional parameter is used to return a status code to the invoking environment. `true` and `FALSE` of status means success and failure respectively. The interpretation of other integer values are system dependent.

    begin
      exit
      puts "never get here"
    rescue SystemExit
      puts "rescued a SystemExit exception"
    end
    puts "after begin block"

produces:

    rescued a SystemExit exception
    after begin block

Just prior to termination, Ruby executes any `at_exit` functions (see Kernel::at_exit) and runs any object finalizers (see `ObjectSpace::define_finalizer`).

    at_exit { puts "at_exit function" }
    ObjectSpace.define_finalizer("string",  proc { puts "in finalizer" })
    exit

produces:

    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

Exits the process immediately. No exit handlers are run. status is returned to the underlying system as the exit status.

    Process.exit!(true)

    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);
    }

raise
fail
fail(string, cause: $!)
fail(exception [, string [, array]], cause: $!)

With no arguments, raises the exception in `$!` or raises a `RuntimeError` if `$!` is `nil`. With a single `String` argument, raises a `RuntimeError` with the string as a message. Otherwise, the first parameter should be an `Exception` class (or another object that returns an `Exception` object when sent an `exception` message). The optional second parameter sets the message associated with the exception (accessible via `Exception#message`), and the third parameter is an array of callback information (accessible via `Exception#backtrace`). The `cause` of the generated exception (accessible via `Exception#cause`) is automatically set to the “current” exception (`$!`), if any. An alternative value, either an `Exception` object or `nil`, can be specified via the `:cause` argument.

Exceptions are caught by the `rescue` clause of `begin...end` blocks.

    raise "Failed to create socket"
    raise ArgumentError, "No parameters", caller

Alias for: raise
fork [{ block }] → integer or nil click to toggle source
fork [{ block }] → integer or nil

Creates a subprocess. If a block is specified, that block is run in the subprocess, and the subprocess terminates with a status of zero. Otherwise, the `fork` call returns twice, once in the parent, returning the process ID of the child, and once in the child, returning nil. The child process can exit using `Kernel.exit!` to avoid running any `at_exit` functions. The parent process should use `Process.wait` to collect the termination statuses of its children or use `Process.detach` to register disinterest in their status; otherwise, the operating system may accumulate zombie processes.

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

If fork is not usable, Process.respond_to?(:fork) returns false.

Note that fork(2) is not available on some platforms like Windows and NetBSD 4. Therefore you should 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.

`Kernel#format` is an alias for `Kernel#sprintf`.

Alias for: sprintf
frozen? → true or false click to toggle source

Returns the freeze status of obj.

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

    # File kernel.rb, line 67
    def frozen?
      Primitive.attr! 'inline'
      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/   #=> [:$stdin, :$stdout, :$stderr]

    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_warn();
        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, protecting the calling program’s global namespace. 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   #=> [:fred, :i]

    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

`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

    static VALUE
    rb_f_loop(VALUE self)
    {
        RETURN_SIZED_ENUMERATOR(self, 0, 0, rb_f_loop_size);
        return rb_rescue2(loop_i, (VALUE)0, loop_stop, (VALUE)0, rb_eStopIteration, (VALUE)0);
    }

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 stream, file, or subprocess.

Required string argument `path` determines which of the following occurs:

- The file at the specified `path` is opened.

- The process forks.

- A subprocess is created.

Each of these is detailed below.

File Opened

If `path` does not start with a pipe character (`'|'`), a file stream is opened with `File.open(path, mode, perm, **opts)`.

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.

Process Forked

If `path` is the 2-character string `'|-'`, the process forks and the child process is connected to the parent.

With no block given:

    io = open('|-')
    if io
      $stderr.puts "In parent, child pid is #{io.pid}."
    else
      $stderr.puts "In child, pid is #{$$}."
    end

Output:

    In parent, child pid is 27903.
    In child, pid is 27903.

With a block given:

    open('|-') do |io|
      if io
        $stderr.puts "In parent, child pid is #{io.pid}."
      else
        $stderr.puts "In child, pid is #{$$}."
      end
    end

Output:

    In parent, child pid is 28427.
    In child, pid is 28427.

Subprocess Created

If `path` is `'|command'` (`'command' != '-'`), a new subprocess runs the command; its open stream is returned. Note that the command may be processed by shell if it contains shell metacharacters.

With no block given:

    io = open('|echo "Hi!"') # => #<IO:fd 12>
    print io.gets
    io.close

Output:

    "Hi!"

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

    open('|echo "Hi!"') do |io|
      print io.gets
    end

Output:

    "Hi!"

    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)) {
                        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                 # => 0..4
    p [r, r, r]         # => [0..4, 0..4, 0..4]
    p                   # => nil

Output:

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

    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);
    }

pretty_inspect() click to toggle source

Returns a pretty printed object as a string.

In order to use this method you must first require the `PP` module:

    require 'pp'

See the `PP` module for more information.

    # File lib/pp.rb, line 637
    def pretty_inspect
      PP.pp(self, ''.dup)
    end

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:

- 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 $_.

    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, TRUE);
    }

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 click to toggle source
raise(string, cause: $!)
raise(exception [, string [, array]], cause: $!)
fail

With no arguments, raises the exception in `$!` or raises a `RuntimeError` if `$!` is `nil`. With a single `String` argument, raises a `RuntimeError` with the string as a message. Otherwise, the first parameter should be an `Exception` class (or another object that returns an `Exception` object when sent an `exception` message). The optional second parameter sets the message associated with the exception (accessible via `Exception#message`), and the third parameter is an array of callback information (accessible via `Exception#backtrace`). The `cause` of the generated exception (accessible via `Exception#cause`) is automatically set to the “current” exception (`$!`), if any. An alternative value, either an `Exception` object or `nil`, can be specified via the `:cause` argument.

Exceptions are caught by the `rescue` clause of `begin...end` blocks.

    raise "Failed to create socket"
    raise ArgumentError, "No parameters", caller

    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        #=> 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.

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_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));
    }

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

- 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

    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:

    *   an event name
    *   a filename
    *   a line number
    *   an object id
    *   a binding
    *   the name of a class

    _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, classname|
           printf "%8s %s:%-2d %10s %8s\n", event, file, line, id, classname
        }
        t = Test.new
        t.test

          line prog.rb:11               false
        c-call prog.rb:11        new    Class
        c-call prog.rb:11 initialize   Object
      c-return prog.rb:11 initialize   Object
      c-return prog.rb:11        new    Class
          line prog.rb:12               false
          call prog.rb:2        test     Test
          line prog.rb:3        test     Test
          line prog.rb:4        test     Test
        return prog.rb:4        test     Test

Note that for `c-call` and `c-return` events, the binding returned is the binding of the nearest Ruby method calling the C method, since C methods themselves do not have bindings.

    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([duration]) → integer click to toggle source

Suspends the current thread for duration seconds (which may be any number, including a `Float` with fractional seconds). Returns the actual number of seconds slept (rounded), which may be less than that asked for if another thread calls `Thread#run`. Called without an argument, sleep() will sleep forever.

    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

    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) {
                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... [,options]) → pid click to toggle source
spawn([env,] command... [,options]) → pid

spawn executes specified command and return its pid.

    pid = spawn("tar xf ruby-2.0.0-p195.tar.bz2")
    Process.wait pid

    pid = spawn(RbConfig.ruby, "-eputs'Hello, world!'")
    Process.wait pid

This method is similar to `Kernel#system` but it doesn’t wait for the command to finish.

The parent process should use `Process.wait` to collect the termination status of its child or use `Process.detach` to register disinterest in their status; otherwise, the operating system may accumulate zombie processes.

spawn has bunch of options to specify process attributes:

    env: hash
      name => val : set the environment variable
      name => nil : unset the environment variable

      the keys and the values except for +nil+ must be strings.
    command...:
      commandline                 : command line string which is passed to the standard shell
      cmdname, arg1, ...          : command name and one or more arguments (This form does not use the shell. See below for caveats.)
      [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
    options: hash
      clearing environment variables:
        :unsetenv_others => true   : clear environment variables except specified by env
        :unsetenv_others => false  : don't clear (default)
      process group:
        :pgroup => true or 0 : make a new process group
        :pgroup => pgid      : join the specified process group
        :pgroup => nil       : don't change the process group (default)
      create new process group: Windows only
        :new_pgroup => true  : the new process is the root process of a new process group
        :new_pgroup => false : don't create a new process group (default)
      resource limit: resourcename is core, cpu, data, etc.  See Process.setrlimit.
        :rlimit_resourcename => limit
        :rlimit_resourcename => [cur_limit, max_limit]
      umask:
        :umask => int
      redirection:
        key:
          FD              : single file descriptor in child process
          [FD, FD, ...]   : multiple file descriptor in child process
        value:
          FD                        : redirect to the file descriptor in parent process
          string                    : redirect to file with open(string, "r" or "w")
          [string]                  : redirect to file with open(string, File::RDONLY)
          [string, open_mode]       : redirect to file with open(string, open_mode, 0644)
          [string, open_mode, perm] : redirect to file with open(string, open_mode, perm)
          [:child, FD]              : redirect to the redirected file descriptor
          :close                    : close the file descriptor in child process
        FD is one of follows
          :in     : the file descriptor 0 which is the standard input
          :out    : the file descriptor 1 which is the standard output
          :err    : the file descriptor 2 which is the standard error
          integer : the file descriptor of specified the integer
          io      : the file descriptor specified as io.fileno
      file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not
        :close_others => false  : inherit
      current directory:
        :chdir => str

The `cmdname, arg1, ...` form does not use the shell. However, on different OSes, different things are provided as built-in commands. An example of this is +‘echo’+, which is a built-in on Windows, but is a normal program on Linux and Mac OS X. This means that `Process.spawn 'echo', '%Path%'` will display the contents of the `%Path%` environment variable on Windows, but `Process.spawn 'echo', '$PATH'` prints the literal `$PATH`.

If a hash is given as `env`, the environment is updated by `env` before `exec(2)` in the child process. If a pair in `env` has nil as the value, the variable is deleted.

    # set FOO as BAR and unset BAZ.
    pid = spawn({"FOO"=>"BAR", "BAZ"=>nil}, command)

If a hash is given as `options`, it specifies process group, create new process group, resource limit, current directory, umask and redirects for the child process. Also, it can be specified to clear environment variables.

The `:unsetenv_others` key in `options` specifies to clear environment variables, other than specified by `env`.

    pid = spawn(command, :unsetenv_others=>true) # no environment variable
    pid = spawn({"FOO"=>"BAR"}, command, :unsetenv_others=>true) # FOO only

The `:pgroup` key in `options` specifies a process group. The corresponding value should be true, zero, a positive integer, or nil. true and zero cause the process to be a process leader of a new process group. A non-zero positive integer causes the process to join the provided process group. The default value, nil, causes the process to remain in the same process group.

    pid = spawn(command, :pgroup=>true) # process leader
    pid = spawn(command, :pgroup=>10) # belongs to the process group 10

The `:new_pgroup` key in `options` specifies to pass `CREATE_NEW_PROCESS_GROUP` flag to `CreateProcessW()` that is Windows API. This option is only for Windows. true means the new process is the root process of the new process group. The new process has CTRL+C disabled. This flag is necessary for `Process.kill(:SIGINT, pid)` on the subprocess. :new_pgroup is false by default.

    pid = spawn(command, :new_pgroup=>true)  # new process group
    pid = spawn(command, :new_pgroup=>false) # same process group

The `:rlimit_`foo key specifies a resource limit. foo should be one of resource types such as `core`. The corresponding value should be an integer or an array which have one or two integers: same as cur_limit and max_limit arguments for `Process.setrlimit`.

    cur, max = Process.getrlimit(:CORE)
    pid = spawn(command, :rlimit_core=>[0,max]) # disable core temporary.
    pid = spawn(command, :rlimit_core=>max) # enable core dump
    pid = spawn(command, :rlimit_core=>0) # never dump core.

The `:umask` key in `options` specifies the umask.

    pid = spawn(command, :umask=>077)

The :in, :out, :err, an integer, an `IO` and an array key specifies a redirection. The redirection maps a file descriptor in the child process.

For example, stderr can be merged into stdout as follows:

    pid = spawn(command, :err=>:out)
    pid = spawn(command, 2=>1)
    pid = spawn(command, STDERR=>:out)
    pid = spawn(command, STDERR=>STDOUT)

The hash keys specifies a file descriptor in the child process started by `spawn`. :err, 2 and STDERR specifies the standard error stream (stderr).

The hash values specifies a file descriptor in the parent process which invokes `spawn`. :out, 1 and STDOUT specifies the standard output stream (stdout).

In the above example, the standard output in the child process is not specified. So it is inherited from the parent process.

The standard input stream (stdin) can be specified by :in, 0 and STDIN.

A filename can be specified as a hash value.

    pid = spawn(command, :in=>"/dev/null") # read mode
    pid = spawn(command, :out=>"/dev/null") # write mode
    pid = spawn(command, :err=>"log") # write mode
    pid = spawn(command, [:out, :err]=>"/dev/null") # write mode
    pid = spawn(command, 3=>"/dev/null") # read mode

For stdout and stderr (and combination of them), it is opened in write mode. Otherwise read mode is used.

For specifying flags and permission of file creation explicitly, an array is used instead.

    pid = spawn(command, :in=>["file"]) # read mode is assumed
    pid = spawn(command, :in=>["file", "r"])
    pid = spawn(command, :out=>["log", "w"]) # 0644 assumed
    pid = spawn(command, :out=>["log", "w", 0600])
    pid = spawn(command, :out=>["log", File::WRONLY|File::EXCL|File::CREAT, 0600])

The array specifies a filename, flags and permission. The flags can be a string or an integer. If the flags is omitted or nil, File::RDONLY is assumed. The permission should be an integer. If the permission is omitted or nil, 0644 is assumed.

If an array of IOs and integers are specified as a hash key, all the elements are redirected.

    # stdout and stderr is redirected to log file.
    # The file "log" is opened just once.
    pid = spawn(command, [:out, :err]=>["log", "w"])

Another way to merge multiple file descriptors is [:child, fd]. [:child, fd] means the file descriptor in the child process. This is different from fd. For example, :err=>:out means redirecting child stderr to parent stdout. But :err=>[:child, :out] means redirecting child stderr to child stdout. They differ if stdout is redirected in the child process as follows.

    # stdout and stderr is redirected to log file.
    # The file "log" is opened just once.
    pid = spawn(command, :out=>["log", "w"], :err=>[:child, :out])

[:child, :out] can be used to merge stderr into stdout in `IO.popen`. In this case, `IO.popen` redirects stdout to a pipe in the child process and [:child, :out] refers the redirected stdout.

    io = IO.popen(["sh", "-c", "echo out; echo err >&2", :err=>[:child, :out]])
    p io.read #=> "out\nerr\n"

The `:chdir` key in `options` specifies the current directory.

    pid = spawn(command, :chdir=>"/var/tmp")

spawn closes all non-standard unspecified descriptors by default. The “standard” descriptors are 0, 1 and 2. This behavior is specified by :close_others option. :close_others doesn’t affect the standard descriptors which are closed only if :close is specified explicitly.

    pid = spawn(command, :close_others=>true)  # close 3,4,5,... (default)
    pid = spawn(command, :close_others=>false) # don't close 3,4,5,...

:close_others is false by default for spawn and `IO.popen`.

Note that fds which close-on-exec flag is already set are closed regardless of :close_others option.

So `IO.pipe` and spawn can be used as `IO.popen`.

    # similar to r = IO.popen(command)
    r, w = IO.pipe
    pid = spawn(command, :out=>w)   # r, w is closed in the child process.
    w.close

:close is specified as a hash value to close a fd individually.

    f = open(foo)
    system(command, f=>:close)        # don't inherit f.

If a file descriptor need to be inherited, io=>io can be used.

    # valgrind has --log-fd option for log destination.
    # log_w=>log_w indicates log_w.fileno inherits to child process.
    log_r, log_w = IO.pipe
    pid = spawn("valgrind", "--log-fd=#{log_w.fileno}", "echo", "a", log_w=>log_w)
    log_w.close
    p log_r.read

It is also possible to exchange file descriptors.

    pid = spawn(command, :out=>:err, :err=>:out)

The hash keys specify file descriptors in the child process. The hash values specifies file descriptors in the parent process. So the above specifies exchanging stdout and stderr. Internally, `spawn` uses an extra file descriptor to resolve such cyclic file descriptor mapping.

See `Kernel.exec` for the standard shell.

    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.

`Kernel#format` is an alias for `Kernel#sprintf`.

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

Also aliased as: format
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               # => 268519324636777531569100071560086917274
    [ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]
    [ rand(10), rand(1000) ] # => [4, 664]
    srand 1234               # => 1234
    [ rand, rand ]           # => [0.1915194503788923, 0.6221087710398319]

    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)) {
                SafeStringValue(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... [,options], exception: false) → true, false or nil click to toggle source

Executes command… in a subshell. command… is one of following forms.

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

`commandline`

  command line string which is passed to the standard shell

`cmdname, arg1, ...`

  command name and one or more arguments (no shell)

`[cmdname, argv0], arg1, ...`

  command name, `argv[0]` and zero or more arguments (no shell)

system returns `true` if the command gives zero exit status, `false` for non zero exit status. Returns `nil` if command execution fails. An error status is available in `$?`.

If the `exception: true` argument is passed, the method raises an exception instead of returning `false` or `nil`.

The arguments are processed in the same way as for `Kernel#spawn`.

The hash arguments, env and options, are same as `exec` and `spawn`. See `Kernel#spawn` for details.

    system("echo *")
    system("echo", "*")

produces:

    config.h main.rb
    *

Error handling:

    system("cat nonexistent.txt")
    # => false
    system("catt nonexistent.txt")
    # => nil

    system("cat nonexistent.txt", exception: true)
    # RuntimeError (Command failed with exit 1: cat)
    system("catt nonexistent.txt", exception: true)
    # Errno::ENOENT (No such file or directory - catt)

See `Kernel#exec` for the standard shell.

    static VALUE
    rb_f_system(int argc, VALUE *argv, VALUE _)
    {
        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;

        rb_last_status_clear();

        // 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);
            GET_THREAD()->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}" }

    # File kernel.rb, line 89
    def tap
      yield(self)
      self
    end

test(cmd, file1 [, file2] ) → obj click to toggle source

Uses the character `cmd` to perform various tests on `file1` (first table below) or on `file1` and `file2` (second table).

`File` tests on a single file:

    Cmd    Returns   Meaning
    "A"  | Time    | Last access time for file1
    "b"  | boolean | True if file1 is a block device
    "c"  | boolean | True if file1 is a character device
    "C"  | Time    | Last change time for file1
    "d"  | boolean | True if file1 exists and is a directory
    "e"  | boolean | True if file1 exists
    "f"  | boolean | True if file1 exists and is a regular file
    "g"  | boolean | True if file1 has the setgid bit set
    "G"  | boolean | True if file1 exists and has a group
         |         | ownership equal to the caller's group
    "k"  | boolean | True if file1 exists and has the sticky bit set
    "l"  | boolean | True if file1 exists and is a symbolic link
    "M"  | Time    | Last modification time for file1
    "o"  | boolean | True if file1 exists and is owned by
         |         | the caller's effective uid
    "O"  | boolean | True if file1 exists and is owned by
         |         | the caller's real uid
    "p"  | boolean | True if file1 exists and is a fifo
    "r"  | boolean | True if file1 is readable by the effective
         |         | uid/gid of the caller
    "R"  | boolean | True if file is readable by the real
         |         | uid/gid of the caller
    "s"  | int/nil | If file1 has nonzero size, return the size,
         |         | otherwise return nil
    "S"  | boolean | True if file1 exists and is a socket
    "u"  | boolean | True if file1 has the setuid bit set
    "w"  | boolean | True if file1 exists and is writable by
         |         | the effective uid/gid
    "W"  | boolean | True if file1 exists and is writable by
         |         | the real uid/gid
    "x"  | boolean | True if file1 exists and is executable by
         |         | the effective uid/gid
    "X"  | boolean | True if file1 exists and is executable by
         |         | the real uid/gid
    "z"  | boolean | True if file1 exists and has a zero length

Tests that take two files:

    "-"  | boolean | True if file1 and file2 are identical
    "="  | boolean | True if the modification times of file1
         |         | and file2 are equal
    "<"  | boolean | True if the modification time of file1
         |         | is prior to that of file2
    ">"  | boolean | True if the modification time of file1
         |         | is after that of file2

    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             #=> "256"

Good usage for `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 block, the method returns `Enumerator`, which can be used, for example, for conditional circuit-breaking:

    # meets condition, no-op
    1.then.detect(&:odd?)            # => 1
    # does not meet condition, drop value
    2.then.detect(&:odd?)            # => nil

    # File kernel.rb, line 120
    def then
      unless Primitive.block_given_p
        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 Kernel::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")

    <em>produces:</em>

      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

    <em>produces:</em>

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

    # File warning.rb, line 50
    def warn(*msgs, uplevel: nil, category: nil)
      Primitive.rb_warn_m(msgs, uplevel, category)
    end

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

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

    "my string".yield_self {|s| s.upcase }   #=> "MY STRING"

Good usage for `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) }

    # File kernel.rb, line 144
    def yield_self
      unless Primitive.block_given_p
        return Primitive.cexpr! 'SIZED_ENUMERATOR(self, 0, 0, rb_obj_size)'
      end
      yield(self)
    end

### Private Instance Methods

JSON(object, *args) click to toggle source

If object is string-like, parse the string and return the parsed result as a Ruby data structure. Otherwise, generate a `JSON` text from the Ruby data structure object and return it.

The opts argument is passed through to generate/parse respectively. See generate and parse for their documentation.

    # File ext/json/lib/json/common.rb, line 685
    def JSON(object, *args)
      if object.respond_to? :to_str
        JSON.parse(object.to_str, args.first)
      else
        JSON.generate(object, args.first)
      end
    end

URI(uri) click to toggle source

Returns `uri` converted to an `URI` object.

    # File lib/uri/common.rb, line 718
    def URI(uri)
      if uri.is_a?(URI::Generic)
        uri
      elsif uri = String.try_convert(uri)
        URI.parse(uri)
      else
        raise ArgumentError,
          "bad argument (expected URI object or URI string)"
      end
    end

gem(gem_name, *requirements) click to toggle source

Use `Kernel#gem` to activate a specific version of `gem_name`.

`requirements` is a list of version requirements that the specified gem must match, most commonly “= example.version.number”. See `Gem::Requirement` for how to specify a version requirement.

If you will be activating the latest version of a gem, there is no need to call `Kernel#gem`, `Kernel#require` will do the right thing for you.

`Kernel#gem` returns true if the gem was activated, otherwise false. If the gem could not be found, didn’t match the version requirements, or a different version was already activated, an exception will be raised.

`Kernel#gem` should be called before any require statements (otherwise RubyGems may load a conflicting library version).

`Kernel#gem` only loads prerelease versions when prerelease `requirements` are given:

    gem 'rake', '>= 1.1.a', '< 2'

In older RubyGems versions, the environment variable GEM_SKIP could be used to skip activation of specified gems, for example to test out changes that haven’t been installed yet. Now RubyGems defers to -I and the RUBYLIB environment variable to skip activation of a gem.

Example:

    GEM_SKIP=libA:libB ruby -I../libA -I../libB ./mycode.rb

    # File lib/rubygems/core_ext/kernel_gem.rb, line 36
    def gem(gem_name, *requirements) # :doc:
      skip_list = (ENV["GEM_SKIP"] || "").split(/:/)
      raise Gem::LoadError, "skipping #{gem_name}" if skip_list.include? gem_name

      if gem_name.kind_of? Gem::Dependency
        unless Gem::Deprecate.skip
          warn "#{Gem.location_of_caller.join ':'}:Warning: Kernel.gem no longer "\
            "accepts a Gem::Dependency object, please pass the name "\
            "and requirements directly"
        end

        requirements = gem_name.requirement
        gem_name = gem_name.name
      end

      dep = Gem::Dependency.new(gem_name, *requirements)

      loaded = Gem.loaded_specs[gem_name]

      return false if loaded && dep.matches_spec?(loaded)

      spec = dep.to_spec

      if spec
        if Gem::LOADED_SPECS_MUTEX.owned?
          spec.activate
        else
          Gem::LOADED_SPECS_MUTEX.synchronize { spec.activate }
        end
      end
    end

j(*objs) click to toggle source

Outputs objs to STDOUT as `JSON` strings in the shortest form, that is in one line.

    # File ext/json/lib/json/common.rb, line 663
    def j(*objs)
      objs.each do |obj|
        puts JSON::generate(obj, :allow_nan => true, :max_nesting => false)
      end
      nil
    end

jj(*objs) click to toggle source

Outputs objs to STDOUT as `JSON` strings in a pretty format, with indentation and over many lines.

    # File ext/json/lib/json/common.rb, line 672
    def jj(*objs)
      objs.each do |obj|
        puts JSON::pretty_generate(obj, :allow_nan => true, :max_nesting => false)
      end
      nil
    end

pp(*objs) click to toggle source

prints arguments in pretty form.

pp returns argument(s).

    # File lib/pp.rb, line 644
    def pp(*objs)
      objs.each {|obj|
        PP.pp(obj)
      }
      objs.size <= 1 ? objs.first : objs
    end

Also aliased as: pp
require(path) click to toggle source

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.

    # File lib/rubygems/core_ext/kernel_require.rb, line 37
    def require(path) # :doc:
      return gem_original_require(path) unless Gem.discover_gems_on_require

      begin
        RUBYGEMS_ACTIVATION_MONITOR.enter

        path = path.to_path if path.respond_to? :to_path

        if spec = Gem.find_unresolved_default_spec(path)
          # Ensure -I beats a default gem
          resolved_path = begin
            rp = nil
            load_path_check_index = Gem.load_path_insert_index - Gem.activated_gem_paths
            Gem.suffixes.each do |s|
              $LOAD_PATH[0...load_path_check_index].each do |lp|
                safe_lp = lp.dup.tap(&Gem::UNTAINT)
                begin
                  if File.symlink? safe_lp # for backward compatibility
                    next
                  end
                rescue SecurityError
                  RUBYGEMS_ACTIVATION_MONITOR.exit
                  raise
                end

                full_path = File.expand_path(File.join(safe_lp, "#{path}#{s}"))
                if File.file?(full_path)
                  rp = full_path
                  break
                end
              end
              break if rp
            end
            rp
          end

          begin
            Kernel.send(:gem, spec.name, Gem::Requirement.default_prerelease)
          rescue Exception
            RUBYGEMS_ACTIVATION_MONITOR.exit
            raise
          end unless resolved_path
        end

        # If there are no unresolved deps, then we can use just try
        # normal require handle loading a gem from the rescue below.

        if Gem::Specification.unresolved_deps.empty?
          RUBYGEMS_ACTIVATION_MONITOR.exit
          return gem_original_require(path)
        end

        # If +path+ is for a gem that has already been loaded, don't
        # bother trying to find it in an unresolved gem, just go straight
        # to normal require.
        #--
        # TODO request access to the C implementation of this to speed up RubyGems

        if Gem::Specification.find_active_stub_by_path(path)
          RUBYGEMS_ACTIVATION_MONITOR.exit
          return gem_original_require(path)
        end

        # Attempt to find +path+ in any unresolved gems...

        found_specs = Gem::Specification.find_in_unresolved path

        # If there are no directly unresolved gems, then try and find +path+
        # in any gems that are available via the currently unresolved gems.
        # For example, given:
        #
        #   a => b => c => d
        #
        # If a and b are currently active with c being unresolved and d.rb is
        # requested, then find_in_unresolved_tree will find d.rb in d because
        # it's a dependency of c.
        #
        if found_specs.empty?
          found_specs = Gem::Specification.find_in_unresolved_tree path

          found_specs.each do |found_spec|
            found_spec.activate
          end

        # We found +path+ directly in an unresolved gem. Now we figure out, of
        # the possible found specs, which one we should activate.
        else

          # Check that all the found specs are just different
          # versions of the same gem
          names = found_specs.map(&:name).uniq

          if names.size > 1
            RUBYGEMS_ACTIVATION_MONITOR.exit
            raise Gem::LoadError, "#{path} found in multiple gems: #{names.join ', '}"
          end

          # Ok, now find a gem that has no conflicts, starting
          # at the highest version.
          valid = found_specs.find {|s| !s.has_conflicts? }

          unless valid
            le = Gem::LoadError.new "unable to find a version of '#{names.first}' to activate"
            le.name = names.first
            RUBYGEMS_ACTIVATION_MONITOR.exit
            raise le
          end

          valid.activate
        end

        RUBYGEMS_ACTIVATION_MONITOR.exit
        return gem_original_require(path)
      rescue LoadError => load_error
        if load_error.path == path
          RUBYGEMS_ACTIVATION_MONITOR.enter

          begin
            require_again = Gem.try_activate(path)
          ensure
            RUBYGEMS_ACTIVATION_MONITOR.exit
          end

          return gem_original_require(path) if require_again
        end

        raise load_error
      end
    end

y(*objects) click to toggle source

An alias for `Psych.dump_stream` meant to be used with `IRB`.

    # File ext/psych/lib/psych/y.rb, line 5
    def y *objects
      puts Psych.dump_stream(*objects)
    end