module Kernel
RubyGems adds the gem method to
allow activation of specific gem versions and overrides the require method on Kernel to make gems appear as if they live on the
$LOAD_PATH
. See the documentation of these methods for
further detail.
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"
Public Class Methods
Returns uri
converted to a URI object.
# File lib/uri/common.rb, line 732 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
Creates an IO object connected to the given stream, file, or subprocess.
If path
does not start with a pipe character (|
),
treat it as the name of a file to open using the specified mode (defaulting
to “r”).
The mode
is either a string or an integer. If it is an
integer, it must be bitwise-or of open(2) flags, such as File::RDWR or
File::EXCL. If it is a string, it is either “fmode”, “fmode:ext_enc”, or
“fmode:ext_enc:int_enc”.
See the documentation of IO.new for full
documentation of the mode
string directives.
If a file is being created, its initial permissions may be set using the
perm
parameter. See File.new and the open(2) and chmod(2) man
pages for a description of permissions.
If a block is specified, it will be invoked with the IO object as a parameter, and the IO will be automatically closed when the block terminates. The call returns the value of the block.
If path
starts with a pipe character
("|"
), a subprocess is created, connected to the
caller by a pair of pipes. The returned IO object
may be used to write to the standard input and read from the standard
output of this subprocess.
If the command following the pipe is a single minus sign
("|-"
), Ruby forks, and this subprocess is connected
to the parent. If the command is not "-"
, the
subprocess runs the command.
When the subprocess is Ruby (opened via "|-"
), the
open
call returns nil
. If a block is associated
with the open call, that block will run twice — once in the parent and once
in the child.
The block parameter will be an IO object in the
parent and nil
in the child. The parent's IO
object will be connected to the child's $stdin and $stdout. The
subprocess will be terminated at the end of the block.
Examples¶ ↑
Reading from “testfile”:
open("testfile") do |f| print f.gets end
Produces:
This is line one
Open a subprocess and read its output:
cmd = open("|date") print cmd.gets cmd.close
Produces:
Wed Apr 9 08:56:31 CDT 2003
Open a subprocess running the same Ruby program:
f = open("|-", "w+") if f.nil? puts "in Child" exit else puts "Got: #{f.gets}" end
Produces:
Got: in Child
Open a subprocess using a block to receive the IO object:
open "|-" do |f| if f then # parent process puts "Got: #{f.gets}" else # child process puts "in Child" end end
Produces:
Got: in Child
static VALUE rb_f_open(int argc, VALUE *argv) { 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(argv[0], to_open, argc-1, argv+1); 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); }
prints arguments in pretty form.
pp returns argument(s).
# File lib/pp.rb, line 19 def pp(*objs) objs.each {|obj| PP.pp(obj) } objs.size <= 1 ? objs.first : objs end
Private Class Methods
Public Instance Methods
Returns arg
as an Array.
First tries to call to_ary
on arg
, then
to_a
.
Array(1..5) #=> [1, 2, 3, 4, 5]
static VALUE rb_f_array(VALUE obj, VALUE arg) { return rb_Array(arg); }
See also BigDecimal.new
static VALUE BigDecimal_global_new(int argc, VALUE *argv, VALUE self) { ENTER(1); Real *pv; VALUE obj; obj = TypedData_Wrap_Struct(rb_cBigDecimal, &BigDecimal_data_type, 0); GUARD_OBJ(pv, BigDecimal_new(argc, argv)); if (ToValue(pv)) pv = VpCopy(NULL, pv); RTYPEDDATA_DATA(obj) = pv; return pv->obj = obj; }
Returns x+i*y;
Complex(1, 2) #=> (1+2i) Complex('1+2i') #=> (1+2i) Complex(nil) #=> TypeError Complex(1, nil) #=> TypeError
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) { return nucomp_s_convert(argc, argv, rb_cComplex); }
static VALUE rb_f_float(VALUE obj, VALUE arg))
Converts arg to a Hash
by calling
arg.to_hash
. Returns an empty Hash
when
arg is nil
or []
.
Hash([]) #=> {} Hash(nil) #=> {} Hash(key: :value) #=> {:key => :value} Hash([1, 2, 3]) #=> TypeError
static VALUE rb_f_hash(VALUE obj, VALUE arg) { return rb_Hash(arg); }
Converts arg to an Integer
. Numeric types are converted directly (with floating
point numbers being truncated). base (0, or between 2 and 36) is
a base for integer string representation. If arg is a
String
, when base is omitted or equals zero, radix
indicators (0
, 0b
, and 0x
) are
honored. In any case, strings should be strictly conformed to numeric
representation. This behavior is different from that of
String#to_i
. Non string values will be converted by first
trying to_int
, then to_i
. Passing
nil
raises a TypeError.
Integer(123.999) #=> 123 Integer("0x1a") #=> 26 Integer(Time.new) #=><PHONE_NUMBER> Integer("0930", 10) #=> 930 Integer("111", 2) #=> 7 Integer(nil) #=> TypeError
static VALUE rb_f_integer(int argc, VALUE *argv, VALUE obj) { VALUE arg = Qnil; int base = 0; switch (argc) { case 2: base = NUM2INT(argv[1]); case 1: arg = argv[0]; break; default: /* should cause ArgumentError */ rb_scan_args(argc, argv, "11", NULL, NULL); } return rb_convert_to_integer(arg, base); }
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) { return rb_class_new_instance(1, &str, rb_cPathname); }
Returns x/y;
Rational(1, 2) #=> (1/2) Rational('1/2') #=> (1/2) Rational(nil) #=> TypeError Rational(1, nil) #=> TypeError
Syntax of 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 String#to_r.
static VALUE nurat_f_rational(int argc, VALUE *argv, VALUE klass) { return nurat_s_convert(argc, argv, rb_cRational); }
Returns arg as a String
.
First tries to call its to_str
method, then its
to_s
method.
String(self) #=> "main" String(self.class) #=> "Object" String(123456) #=> "123456"
static VALUE rb_f_string(VALUE obj, VALUE arg) { return rb_String(arg); }
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(void) { ID fname = prev_frame_callee(); /* need *callee* ID */ if (fname) { return ID2SYM(fname); } else { return Qnil; } }
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(void) { VALUE base = rb_current_realfilepath(); if (NIL_P(base)) { return Qnil; } base = rb_file_dirname(base); return base; }
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(void) { ID fname = prev_frame_func(); /* need *method* ID */ if (fname) { return ID2SYM(fname); } else { return Qnil; } }
Returns the standard output of running cmd in a subshell. The
built-in syntax %x{...}
uses this method. Sets $?
to the process status.
%x`date` #=> "Wed Apr 9 08:56:30 CDT 2003\n" %x`ls testdir`.split[1] #=> "main.rb" %x`echo oops && exit 99` #=> "oops\n" $?.exitstatus #=> 99
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); rb_io_fptr_finalize(fptr); rb_gc_force_recycle(port); /* also guards from premature GC */ return result; }
Terminate execution immediately, effectively by calling
Kernel.exit(false)
. If msg is given, it is written to
STDERR prior to terminating.
VALUE rb_f_abort(int argc, const VALUE *argv) { rb_check_arity(argc, 0, 1); if (argc == 0) { if (!NIL_P(GET_THREAD()->errinfo)) { ruby_error_print(); } rb_exit(EXIT_FAILURE); } else { VALUE args[2]; args[1] = args[0] = argv[0]; StringValue(args[0]); rb_io_puts(1, args, rb_stderr); args[0] = INT2NUM(EXIT_FAILURE); rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit)); } UNREACHABLE; }
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(void) { 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; }
Registers filename to be loaded (using
Kernel::require
) the first time that module (which
may be a String
or a symbol) is accessed.
autoload(:MyModule, "/usr/local/lib/modules/my_module.rb")
static VALUE rb_f_autoload(VALUE obj, VALUE sym, VALUE file) { VALUE klass = rb_class_real(rb_vm_cbase()); if (NIL_P(klass)) { rb_raise(rb_eTypeError, "Can not set autoload on singleton class"); } return rb_mod_autoload(klass, sym, file); }
Returns filename to be loaded if name is registered as
autoload
.
autoload(:B, "b") autoload?(:B) #=> "b"
static VALUE rb_f_autoload_p(VALUE obj, VALUE sym) { /* 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(klass, sym); }
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(); }
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"
VALUE rb_f_block_given_p(void) { rb_thread_t *th = GET_THREAD(); rb_control_frame_t *cfp = th->cfp; cfp = vm_get_ruby_level_caller_cfp(th, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)); if (cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE) { return Qtrue; } else { return Qfalse; } }
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 #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); } }
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) { return vm_backtrace_to_ary(GET_THREAD(), argc, argv, 1, 1, 1); }
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) { return vm_backtrace_to_ary(GET_THREAD(), argc, argv, 1, 1, 0); }
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 tag; if (argc == 0) { tag = rb_obj_alloc(rb_cObject); } else { rb_scan_args(argc, argv, "01", &tag); } return rb_catch_obj(tag, catch_i, 0); }
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 str = rb_funcall_passing_block(uscore_get(), rb_intern("chomp"), argc, argv); rb_lastline_set(str); return str; }
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(void) { VALUE str = rb_funcall_passing_block(uscore_get(), rb_intern("chop"), 0, 0); rb_lastline_set(str); return str; }
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; return eval_string(self, src, scope, file, line); }
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 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, same as ENV["RUBYSHELL"]
(or
ENV["COMSPEC"]
on Windows NT series), and similar.
If the string from the first form (exec("command")
)
follows these simple rules:
-
no meta characters
-
no shell reserved word and no 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 #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
VALUE rb_f_exec(int argc, const VALUE *argv) { VALUE execarg_obj, fail_str; struct rb_execarg *eargp; #define CHILD_ERRMSG_BUFLEN 80 char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' }; int err; execarg_obj = rb_execarg_new(argc, argv, TRUE); eargp = rb_execarg_get(execarg_obj); before_exec(); /* stop timer thread before redirects */ rb_execarg_parent_start(execarg_obj); fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; rb_exec_async_signal_safe(eargp, errmsg, sizeof(errmsg)); err = errno; after_exec(); /* restart timer thread */ rb_exec_fail(eargp, err, errmsg); RB_GC_GUARD(execarg_obj); rb_syserr_fail_str(err, fail_str); UNREACHABLE; }
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
VALUE rb_f_exit(int argc, const VALUE *argv) { int istatus; if (rb_check_arity(argc, 0, 1) == 1) { istatus = exit_status_code(argv[0]); } else { istatus = EXIT_SUCCESS; } rb_exit(istatus); UNREACHABLE; }
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; }
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 the
name of an Exception
class (or an object that returns an
Exception
object when sent an exception
message).
The optional second parameter sets the message associated with the
exception, and the third parameter is an array of callback information.
Exceptions are caught by the rescue
clause of
begin...end
blocks.
raise "Failed to create socket" raise ArgumentError, "No parameters", caller
static VALUE rb_f_raise(int argc, VALUE *argv) { VALUE err; VALUE opts[raise_max_opt], *const cause = &opts[raise_opt_cause]; argc = extract_raise_opts(argc, argv, opts); if (argc == 0) { if (*cause != Qundef) { rb_raise(rb_eArgError, "only cause is given with no arguments"); } err = get_errinfo(); if (!NIL_P(err)) { argc = 1; argv = &err; } } rb_raise_jump(rb_make_exception(argc, argv), *cause); UNREACHABLE; }
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; switch (pid = rb_fork_ruby(NULL)) { case 0: rb_thread_atfork(); if (rb_block_given_p()) { int status; rb_protect(rb_yield, Qundef, &status); ruby_stop(status); } return Qnil; case -1: rb_sys_fail("fork(2)"); return Qnil; default: return PIDT2NUM(pid); } }
Returns the string resulting from applying format_string to any additional arguments. Within the format string, any characters other than format sequences are copied to the result.
The syntax of a format sequence is follows.
%[flags][width][.precision]type
A format sequence consists of a percent sign, followed by optional flags,
width, and precision indicators, then terminated with a field type
character. The field type controls how the corresponding
sprintf
argument is to be interpreted, while the flags modify
that interpretation.
The field type characters are:
Field | Integer Format ------+-------------------------------------------------------------- b | Convert argument as a binary number. | Negative numbers will be displayed as a two's complement | prefixed with `..1'. B | Equivalent to `b', but uses an uppercase 0B for prefix | in the alternative format by #. d | Convert argument as a decimal number. i | Identical to `d'. o | Convert argument as an octal number. | Negative numbers will be displayed as a two's complement | prefixed with `..7'. u | Identical to `d'. x | Convert argument as a hexadecimal number. | Negative numbers will be displayed as a two's complement | prefixed with `..f' (representing an infinite string of | leading 'ff's). X | Equivalent to `x', but uses uppercase letters. Field | Float Format ------+-------------------------------------------------------------- e | Convert floating point argument into exponential notation | with one digit before the decimal point as [-]d.dddddde[+-]dd. | The precision specifies the number of digits after the decimal | point (defaulting to six). E | Equivalent to `e', but uses an uppercase E to indicate | the exponent. f | Convert floating point argument as [-]ddd.dddddd, | where the precision specifies the number of digits after | the decimal point. g | Convert a floating point number using exponential form | if the exponent is less than -4 or greater than or | equal to the precision, or in dd.dddd form otherwise. | The precision specifies the number of significant digits. G | Equivalent to `g', but use an uppercase `E' in exponent form. a | Convert floating point argument as [-]0xh.hhhhp[+-]dd, | which is consisted from optional sign, "0x", fraction part | as hexadecimal, "p", and exponential part as decimal. A | Equivalent to `a', but use uppercase `X' and `P'. Field | Other Format ------+-------------------------------------------------------------- c | Argument is the numeric code for a single character or | a single character string itself. p | The valuing of argument.inspect. s | Argument is a string to be substituted. If the format | sequence contains a precision, at most that many characters | will be copied. % | A percent sign itself will be displayed. No argument taken.
The flags modifies the behavior of the formats. The flag characters are:
Flag | Applies to | Meaning ---------+---------------+----------------------------------------- space | bBdiouxX | Leave a space at the start of | aAeEfgG | non-negative numbers. | (numeric fmt) | For `o', `x', `X', `b' and `B', use | | a minus sign with absolute value for | | negative values. ---------+---------------+----------------------------------------- (digit)$ | all | Specifies the absolute argument number | | for this field. Absolute and relative | | argument numbers cannot be mixed in a | | sprintf string. ---------+---------------+----------------------------------------- # | bBoxX | Use an alternative format. | aAeEfgG | For the conversions `o', increase the precision | | until the first digit will be `0' if | | it is not formatted as complements. | | For the conversions `x', `X', `b' and `B' | | on non-zero, prefix the result with ``0x'', | | ``0X'', ``0b'' and ``0B'', respectively. | | For `a', `A', `e', `E', `f', `g', and 'G', | | force a decimal point to be added, | | even if no digits follow. | | For `g' and 'G', do not remove trailing zeros. ---------+---------------+----------------------------------------- + | bBdiouxX | Add a leading plus sign to non-negative | aAeEfgG | numbers. | (numeric fmt) | For `o', `x', `X', `b' and `B', use | | a minus sign with absolute value for | | negative values. ---------+---------------+----------------------------------------- - | all | Left-justify the result of this conversion. ---------+---------------+----------------------------------------- 0 (zero) | bBdiouxX | Pad with zeros, not spaces. | aAeEfgG | For `o', `x', `X', `b' and `B', radix-1 | (numeric fmt) | is used for negative numbers formatted as | | complements. ---------+---------------+----------------------------------------- * | all | Use the next argument as the field width. | | If negative, left-justify the result. If the | | asterisk is followed by a number and a dollar | | sign, use the indicated argument as the width.
Examples of flags:
# `+' and space flag specifies the sign of non-negative numbers. sprintf("%d", 123) #=> "123" sprintf("%+d", 123) #=> "+123" sprintf("% d", 123) #=> " 123" # `#' flag for `o' increases number of digits to show `0'. # `+' and space flag changes format of negative numbers. sprintf("%o", 123) #=> "173" sprintf("%#o", 123) #=> "0173" sprintf("%+o", -123) #=> "-173" sprintf("%o", -123) #=> "..7605" sprintf("%#o", -123) #=> "..7605" # `#' flag for `x' add a prefix `0x' for non-zero numbers. # `+' and space flag disables complements for negative numbers. sprintf("%x", 123) #=> "7b" sprintf("%#x", 123) #=> "0x7b" sprintf("%+x", -123) #=> "-7b" sprintf("%x", -123) #=> "..f85" sprintf("%#x", -123) #=> "0x..f85" sprintf("%#x", 0) #=> "0" # `#' for `X' uses the prefix `0X'. sprintf("%X", 123) #=> "7B" sprintf("%#X", 123) #=> "0X7B" # `#' flag for `b' add a prefix `0b' for non-zero numbers. # `+' and space flag disables complements for negative numbers. sprintf("%b", 123) #=> "1111011" sprintf("%#b", 123) #=> "0b1111011" sprintf("%+b", -123) #=> "-1111011" sprintf("%b", -123) #=> "..10000101" sprintf("%#b", -123) #=> "0b..10000101" sprintf("%#b", 0) #=> "0" # `#' for `B' uses the prefix `0B'. sprintf("%B", 123) #=> "1111011" sprintf("%#B", 123) #=> "0B1111011" # `#' for `e' forces to show the decimal point. sprintf("%.0e", 1) #=> "1e+00" sprintf("%#.0e", 1) #=> "1.e+00" # `#' for `f' forces to show the decimal point. sprintf("%.0f", 1234) #=> "1234" sprintf("%#.0f", 1234) #=> "1234." # `#' for `g' forces to show the decimal point. # It also disables stripping lowest zeros. sprintf("%g", 123.4) #=> "123.4" sprintf("%#g", 123.4) #=> "123.400" sprintf("%g", 123456) #=> "123456" sprintf("%#g", 123456) #=> "123456."
The field width is an optional integer, followed optionally by a period and a precision. The width specifies the minimum number of characters that will be written to the result for this field.
Examples of width:
# padding is done by spaces, width=20 # 0 or radix-1. <------------------> sprintf("%20d", 123) #=> " 123" sprintf("%+20d", 123) #=> " +123" sprintf("%020d", 123) #=> "00000000000000000123" sprintf("%+020d", 123) #=> "+0000000000000000123" sprintf("% 020d", 123) #=> "<PHONE_NUMBER>000000123" sprintf("%-20d", 123) #=> "123 " sprintf("%-+20d", 123) #=> "+123 " sprintf("%- 20d", 123) #=> " 123 " sprintf("%020x", -123) #=> "..ffffffffffffffff85"
For numeric fields, the precision controls the number of decimal places
displayed. For string fields, the precision determines the maximum number
of characters to be copied from the string. (Thus, the format sequence
%10.10s
will always contribute exactly ten characters to the
result.)
Examples of precisions:
# precision for `d', 'o', 'x' and 'b' is # minimum number of digits <------> sprintf("%20.8d", 123) #=> " 00000123" sprintf("%20.8o", 123) #=> " 00000173" sprintf("%20.8x", 123) #=> " 0000007b" sprintf("%20.8b", 123) #=> " 01111011" sprintf("%20.8d", -123) #=> " -00000123" sprintf("%20.8o", -123) #=> " ..777605" sprintf("%20.8x", -123) #=> " ..ffff85" sprintf("%20.8b", -11) #=> " ..110101" # "0x" and "0b" for `#x' and `#b' is not counted for # precision but "0" for `#o' is counted. <------> sprintf("%#20.8d", 123) #=> " 00000123" sprintf("%#20.8o", 123) #=> " 00000173" sprintf("%#20.8x", 123) #=> " 0x0000007b" sprintf("%#20.8b", 123) #=> " 0b01111011" sprintf("%#20.8d", -123) #=> " -00000123" sprintf("%#20.8o", -123) #=> " ..777605" sprintf("%#20.8x", -123) #=> " 0x..ffff85" sprintf("%#20.8b", -11) #=> " 0b..110101" # precision for `e' is number of # digits after the decimal point <------> sprintf("%20.8e", 1234.56789) #=> " 1.23456789e+03" # precision for `f' is number of # digits after the decimal point <------> sprintf("%20.8f", 1234.56789) #=> " 1234.56789000" # precision for `g' is number of # significant digits <-------> sprintf("%20.8g", 1234.56789) #=> " 1234.5679" # <-------> sprintf("%20.8g", 123456789) #=> " 1.2345679e+08" # precision for `s' is # maximum number of characters <------> sprintf("%20.8s", "string test") #=> " string t"
Examples:
sprintf("%d %04x", 123, 123) #=> "123 007b" sprintf("%08b '%4s'", 123, 123) #=> "01111011 ' 123'" sprintf("%1$*2$s %2$d %1$s", "hello", 8) #=> " hello 8 hello" sprintf("%1$*2$s %2$d", "hello", -8) #=> "hello -8" sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23) #=> "+1.23: 1.23:1.23" sprintf("%u", -123) #=> "-123"
For more complex formatting, Ruby supports a reference by name. %<name>s style uses format style, but %{name} style doesn't.
Examples:
sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 }) #=> 1 : 2.000000 sprintf("%{foo}f", { :foo => 1 }) # => "1f"
VALUE rb_f_sprintf(int argc, const VALUE *argv) { return rb_str_format(argc - 1, argv + 1, GETNTHARG(0)); }
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 rb_funcallv(argf, idGets, argc, argv); }
Returns an array of the names of global variables.
global_variables.grep /std/ #=> [:$stdin, :$stdout, :$stderr]
VALUE rb_f_global_variables(void) { VALUE ary = rb_ary_new(); VALUE sym, backref = rb_backref_get(); rb_id_table_foreach(rb_global_tbl, gvar_i, (void *)ary); if (!NIL_P(backref)) { char buf[2]; int i, nmatch = rb_match_count(backref); buf[0] = '$'; for (i = 1; i <= nmatch; ++i) { if (!rb_match_nth_defined(i, backref)) continue; if (i < 10) { /* probably reused, make static ID */ buf[1] = (char)(i + '0'); sym = ID2SYM(rb_intern2(buf, 2)); } else { /* dynamic symbol */ sym = rb_str_intern(rb_sprintf("$%d", i)); } rb_ary_push(ary, sym); } } return ary; }
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 str = rb_funcall_passing_block(uscore_get(), rb_intern("gsub"), argc, argv); rb_lastline_set(str); return str; }
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"
VALUE rb_f_block_given_p(void) { rb_thread_t *th = GET_THREAD(); rb_control_frame_t *cfp = th->cfp; cfp = vm_get_ruby_level_caller_cfp(th, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)); if (cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE) { return Qtrue; } else { return Qfalse; } }
Equivalent to Proc.new
, except the resulting Proc objects check the number of parameters passed
when called.
VALUE rb_block_lambda(void) { return proc_new(rb_cProc, TRUE); }
Loads and executes the Ruby program in the file filename. If the
filename does not resolve to an absolute path, the file is searched for in
the library directories listed in $:
. If the optional
wrap parameter is true
, the loaded script will be
executed under an anonymous module, protecting the calling program's
global namespace. 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 fname, wrap, path, orig_fname; rb_scan_args(argc, argv, "11", &fname, &wrap); RUBY_DTRACE_HOOK(LOAD_ENTRY, StringValuePtr(fname)); orig_fname = rb_get_path_check_to_string(fname, rb_safe_level()); fname = rb_str_encode_ospath(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, RTEST(wrap)); RUBY_DTRACE_HOOK(LOAD_RETURN, StringValuePtr(fname)); return Qtrue; }
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(void) { struct local_var_list vars; rb_thread_t *th = GET_THREAD(); rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(th, RUBY_VM_PREVIOUS_CONTROL_FRAME(th->cfp)); unsigned int i; local_var_list_init(&vars); while (cfp) { if (cfp->iseq) { for (i = 0; i < cfp->iseq->body->local_table_size; i++) { local_var_list_add(&vars, cfp->iseq->body->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(th, ep, &vars)) { break; } else { while (cfp->ep != ep) { cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp); } } } else { break; } } return local_var_list_finish(&vars); }
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 =~ /^qQ/ # ... 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); }
For each object, directly writes obj.inspect
followed
by a newline to the program's standard output.
S = Struct.new(:name, :state) s = S['dave', 'TX'] p s
produces:
#<S name="dave", state="TX">
static VALUE rb_f_p(int argc, VALUE *argv, VALUE self) { struct rb_f_p_arg arg; arg.argc = argc; arg.argv = argv; return rb_uninterruptible(rb_f_p_internal, (VALUE)&arg); }
Prints each object in turn to $stdout
. If the output field
separator ($,
) is not nil
, its contents will
appear between each field. If the output record separator ($\
)
is not nil
, it will be appended to the output. If no arguments
are given, prints $_
. Objects that aren't strings will be
converted by calling their to_s
method.
print "cat", [1,2,3], 99, "\n" $, = ", " $\ = "\n" print "cat", [1,2,3], 99
produces:
cat12399 cat, 1, 2, 3, 99
static VALUE rb_f_print(int argc, const VALUE *argv) { rb_io_print(argc, argv, rb_stdout); return Qnil; }
Equivalent to:
io.write(sprintf(string, obj, ...))
or
$stdout.write(sprintf(string, obj, ...))
static VALUE rb_f_printf(int argc, VALUE *argv) { VALUE out; if (argc == 0) return Qnil; if (RB_TYPE_P(argv[0], T_STRING)) { out = rb_stdout; } else { out = argv[0]; argv++; argc--; } rb_io_write(out, rb_f_sprintf(argc, argv)); return Qnil; }
Equivalent to Proc.new
.
VALUE rb_block_proc(void) { return proc_new(rb_cProc, FALSE); }
Equivalent to:
$stdout.putc(int)
Refer to the documentation for IO#putc for important information regarding multi-byte characters.
static VALUE rb_f_putc(VALUE recv, VALUE ch) { if (recv == rb_stdout) { return rb_io_putc(recv, ch); } return rb_funcallv(rb_stdout, rb_intern("putc"), 1, &ch); }
Equivalent to
$stdout.puts(obj, ...)
static VALUE rb_f_puts(int argc, VALUE *argv, VALUE recv) { if (recv == rb_stdout) { return rb_io_puts(argc, argv, recv); } return rb_funcallv(rb_stdout, rb_intern("puts"), argc, argv); }
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 the
name of an Exception
class (or an object that returns an
Exception
object when sent an exception
message).
The optional second parameter sets the message associated with the
exception, and the third parameter is an array of callback information.
Exceptions are caught by the rescue
clause of
begin...end
blocks.
raise "Failed to create socket" raise ArgumentError, "No parameters", caller
static VALUE rb_f_raise(int argc, VALUE *argv) { VALUE err; VALUE opts[raise_max_opt], *const cause = &opts[raise_opt_cause]; argc = extract_raise_opts(argc, argv, opts); if (argc == 0) { if (*cause != Qundef) { rb_raise(rb_eArgError, "only cause is given with no arguments"); } err = get_errinfo(); if (!NIL_P(err)) { argc = 1; argv = &err; } } rb_raise_jump(rb_make_exception(argc, argv), *cause); UNREACHABLE; }
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
#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(Qnil, rnd, vmax); if (v != Qfalse) return v; vmax = rb_to_int(vmax); if (vmax != INT2FIX(0)) { v = rand_int(Qnil, rnd, vmax, 0); if (!NIL_P(v)) return v; } } return DBL2NUM(genrand_real(&rnd->mt)); }
Equivalent to Kernel::gets
, except readline
raises EOFError
at end of file.
static VALUE rb_f_readline(int argc, VALUE *argv, VALUE recv) { if (recv == argf) { return argf_readline(argc, argv, argf); } return rb_funcallv(argf, rb_intern("readline"), argc, argv); }
Returns an array containing the lines returned by calling
Kernel.gets(sep)
until the end of file.
static VALUE rb_f_readlines(int argc, VALUE *argv, VALUE recv) { if (recv == argf) { return argf_readlines(argc, argv, argf); } return rb_funcallv(argf, rb_intern("readlines"), argc, argv); }
Ruby tries to load the library named string relative to the
requiring file's path. If the file's path cannot be determined a
LoadError is raised. If a file is loaded
true
is returned and false otherwise.
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_safe(rb_file_absolute_path(fname, base), rb_safe_level()); }
Calls select(2) system call. It monitors given arrays of IO
objects, waits until one or more of IO
objects are ready for
reading, are ready for writing, and have pending exceptions respectively,
and returns an array that contains arrays of those IO
objects. It will return nil
if optional timeout
value is given and no IO
object is ready in timeout
seconds.
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 nonblocking
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 nonblocking 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 blocks.
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 nonblocking 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) manual on GNU/Linux system.
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
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
Parameters¶ ↑
- read_array
-
an array of
IO
objects that wait until ready for read - write_array
-
an array of
IO
objects that wait until ready for write - error_array
-
an array of
IO
objects that wait for exceptions - timeout
-
a numeric value in second
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 }
produces:
ping pong ping pong ping pong (snipped) ping
static VALUE rb_f_select(int argc, VALUE *argv, VALUE obj) { 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); }
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
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; }
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) { time_t beg, end; beg = time(0); if (argc == 0) { rb_thread_sleep_forever(); } else { rb_check_arity(argc, 0, 1); rb_thread_wait_for(rb_time_interval(argv[0])); } end = time(0) - beg; return INT2FIX(end); }
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 #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 => true : don't 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 true 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) { 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); 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 }
Returns the string resulting from applying format_string to any additional arguments. Within the format string, any characters other than format sequences are copied to the result.
The syntax of a format sequence is follows.
%[flags][width][.precision]type
A format sequence consists of a percent sign, followed by optional flags,
width, and precision indicators, then terminated with a field type
character. The field type controls how the corresponding
sprintf
argument is to be interpreted, while the flags modify
that interpretation.
The field type characters are:
Field | Integer Format ------+-------------------------------------------------------------- b | Convert argument as a binary number. | Negative numbers will be displayed as a two's complement | prefixed with `..1'. B | Equivalent to `b', but uses an uppercase 0B for prefix | in the alternative format by #. d | Convert argument as a decimal number. i | Identical to `d'. o | Convert argument as an octal number. | Negative numbers will be displayed as a two's complement | prefixed with `..7'. u | Identical to `d'. x | Convert argument as a hexadecimal number. | Negative numbers will be displayed as a two's complement | prefixed with `..f' (representing an infinite string of | leading 'ff's). X | Equivalent to `x', but uses uppercase letters. Field | Float Format ------+-------------------------------------------------------------- e | Convert floating point argument into exponential notation | with one digit before the decimal point as [-]d.dddddde[+-]dd. | The precision specifies the number of digits after the decimal | point (defaulting to six). E | Equivalent to `e', but uses an uppercase E to indicate | the exponent. f | Convert floating point argument as [-]ddd.dddddd, | where the precision specifies the number of digits after | the decimal point. g | Convert a floating point number using exponential form | if the exponent is less than -4 or greater than or | equal to the precision, or in dd.dddd form otherwise. | The precision specifies the number of significant digits. G | Equivalent to `g', but use an uppercase `E' in exponent form. a | Convert floating point argument as [-]0xh.hhhhp[+-]dd, | which is consisted from optional sign, "0x", fraction part | as hexadecimal, "p", and exponential part as decimal. A | Equivalent to `a', but use uppercase `X' and `P'. Field | Other Format ------+-------------------------------------------------------------- c | Argument is the numeric code for a single character or | a single character string itself. p | The valuing of argument.inspect. s | Argument is a string to be substituted. If the format | sequence contains a precision, at most that many characters | will be copied. % | A percent sign itself will be displayed. No argument taken.
The flags modifies the behavior of the formats. The flag characters are:
Flag | Applies to | Meaning ---------+---------------+----------------------------------------- space | bBdiouxX | Leave a space at the start of | aAeEfgG | non-negative numbers. | (numeric fmt) | For `o', `x', `X', `b' and `B', use | | a minus sign with absolute value for | | negative values. ---------+---------------+----------------------------------------- (digit)$ | all | Specifies the absolute argument number | | for this field. Absolute and relative | | argument numbers cannot be mixed in a | | sprintf string. ---------+---------------+----------------------------------------- # | bBoxX | Use an alternative format. | aAeEfgG | For the conversions `o', increase the precision | | until the first digit will be `0' if | | it is not formatted as complements. | | For the conversions `x', `X', `b' and `B' | | on non-zero, prefix the result with ``0x'', | | ``0X'', ``0b'' and ``0B'', respectively. | | For `a', `A', `e', `E', `f', `g', and 'G', | | force a decimal point to be added, | | even if no digits follow. | | For `g' and 'G', do not remove trailing zeros. ---------+---------------+----------------------------------------- + | bBdiouxX | Add a leading plus sign to non-negative | aAeEfgG | numbers. | (numeric fmt) | For `o', `x', `X', `b' and `B', use | | a minus sign with absolute value for | | negative values. ---------+---------------+----------------------------------------- - | all | Left-justify the result of this conversion. ---------+---------------+----------------------------------------- 0 (zero) | bBdiouxX | Pad with zeros, not spaces. | aAeEfgG | For `o', `x', `X', `b' and `B', radix-1 | (numeric fmt) | is used for negative numbers formatted as | | complements. ---------+---------------+----------------------------------------- * | all | Use the next argument as the field width. | | If negative, left-justify the result. If the | | asterisk is followed by a number and a dollar | | sign, use the indicated argument as the width.
Examples of flags:
# `+' and space flag specifies the sign of non-negative numbers. sprintf("%d", 123) #=> "123" sprintf("%+d", 123) #=> "+123" sprintf("% d", 123) #=> " 123" # `#' flag for `o' increases number of digits to show `0'. # `+' and space flag changes format of negative numbers. sprintf("%o", 123) #=> "173" sprintf("%#o", 123) #=> "0173" sprintf("%+o", -123) #=> "-173" sprintf("%o", -123) #=> "..7605" sprintf("%#o", -123) #=> "..7605" # `#' flag for `x' add a prefix `0x' for non-zero numbers. # `+' and space flag disables complements for negative numbers. sprintf("%x", 123) #=> "7b" sprintf("%#x", 123) #=> "0x7b" sprintf("%+x", -123) #=> "-7b" sprintf("%x", -123) #=> "..f85" sprintf("%#x", -123) #=> "0x..f85" sprintf("%#x", 0) #=> "0" # `#' for `X' uses the prefix `0X'. sprintf("%X", 123) #=> "7B" sprintf("%#X", 123) #=> "0X7B" # `#' flag for `b' add a prefix `0b' for non-zero numbers. # `+' and space flag disables complements for negative numbers. sprintf("%b", 123) #=> "1111011" sprintf("%#b", 123) #=> "0b1111011" sprintf("%+b", -123) #=> "-1111011" sprintf("%b", -123) #=> "..10000101" sprintf("%#b", -123) #=> "0b..10000101" sprintf("%#b", 0) #=> "0" # `#' for `B' uses the prefix `0B'. sprintf("%B", 123) #=> "1111011" sprintf("%#B", 123) #=> "0B1111011" # `#' for `e' forces to show the decimal point. sprintf("%.0e", 1) #=> "1e+00" sprintf("%#.0e", 1) #=> "1.e+00" # `#' for `f' forces to show the decimal point. sprintf("%.0f", 1234) #=> "1234" sprintf("%#.0f", 1234) #=> "1234." # `#' for `g' forces to show the decimal point. # It also disables stripping lowest zeros. sprintf("%g", 123.4) #=> "123.4" sprintf("%#g", 123.4) #=> "123.400" sprintf("%g", 123456) #=> "123456" sprintf("%#g", 123456) #=> "123456."
The field width is an optional integer, followed optionally by a period and a precision. The width specifies the minimum number of characters that will be written to the result for this field.
Examples of width:
# padding is done by spaces, width=20 # 0 or radix-1. <------------------> sprintf("%20d", 123) #=> " 123" sprintf("%+20d", 123) #=> " +123" sprintf("%020d", 123) #=> "00000000000000000123" sprintf("%+020d", 123) #=> "+0000000000000000123" sprintf("% 020d", 123) #=> "<PHONE_NUMBER>000000123" sprintf("%-20d", 123) #=> "123 " sprintf("%-+20d", 123) #=> "+123 " sprintf("%- 20d", 123) #=> " 123 " sprintf("%020x", -123) #=> "..ffffffffffffffff85"
For numeric fields, the precision controls the number of decimal places
displayed. For string fields, the precision determines the maximum number
of characters to be copied from the string. (Thus, the format sequence
%10.10s
will always contribute exactly ten characters to the
result.)
Examples of precisions:
# precision for `d', 'o', 'x' and 'b' is # minimum number of digits <------> sprintf("%20.8d", 123) #=> " 00000123" sprintf("%20.8o", 123) #=> " 00000173" sprintf("%20.8x", 123) #=> " 0000007b" sprintf("%20.8b", 123) #=> " 01111011" sprintf("%20.8d", -123) #=> " -00000123" sprintf("%20.8o", -123) #=> " ..777605" sprintf("%20.8x", -123) #=> " ..ffff85" sprintf("%20.8b", -11) #=> " ..110101" # "0x" and "0b" for `#x' and `#b' is not counted for # precision but "0" for `#o' is counted. <------> sprintf("%#20.8d", 123) #=> " 00000123" sprintf("%#20.8o", 123) #=> " 00000173" sprintf("%#20.8x", 123) #=> " 0x0000007b" sprintf("%#20.8b", 123) #=> " 0b01111011" sprintf("%#20.8d", -123) #=> " -00000123" sprintf("%#20.8o", -123) #=> " ..777605" sprintf("%#20.8x", -123) #=> " 0x..ffff85" sprintf("%#20.8b", -11) #=> " 0b..110101" # precision for `e' is number of # digits after the decimal point <------> sprintf("%20.8e", 1234.56789) #=> " 1.23456789e+03" # precision for `f' is number of # digits after the decimal point <------> sprintf("%20.8f", 1234.56789) #=> " 1234.56789000" # precision for `g' is number of # significant digits <-------> sprintf("%20.8g", 1234.56789) #=> " 1234.5679" # <-------> sprintf("%20.8g", 123456789) #=> " 1.2345679e+08" # precision for `s' is # maximum number of characters <------> sprintf("%20.8s", "string test") #=> " string t"
Examples:
sprintf("%d %04x", 123, 123) #=> "123 007b" sprintf("%08b '%4s'", 123, 123) #=> "01111011 ' 123'" sprintf("%1$*2$s %2$d %1$s", "hello", 8) #=> " hello 8 hello" sprintf("%1$*2$s %2$d", "hello", -8) #=> "hello -8" sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23) #=> "+1.23: 1.23:1.23" sprintf("%u", -123) #=> "-123"
For more complex formatting, Ruby supports a reference by name. %<name>s style uses format style, but %{name} style doesn't.
Examples:
sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 }) #=> 1 : 2.000000 sprintf("%{foo}f", { :foo => 1 }) # => "1f"
VALUE rb_f_sprintf(int argc, const VALUE *argv) { return rb_str_format(argc - 1, argv + 1, GETNTHARG(0)); }
Seeds the system pseudo-random number generator, Random::DEFAULT, 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 # =><PHONE_NUMBER>36777531569100071560086917274 [ 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_t *r = &default_rand; if (rb_check_arity(argc, 0, 1) == 0) { seed = random_seed(); } else { seed = rb_to_int(argv[0]); } old = r->seed; r->seed = rand_init(&r->mt, seed); return old; }
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 str = rb_funcall_passing_block(uscore_get(), rb_intern("sub"), argc, argv); rb_lastline_set(str); return str; }
Calls the operating system function identified by num and returns the result of the function or raises SystemCallError if it failed.
Arguments for the function can follow num. They must be either
String
objects or Integer
objects. A
String
object is passed as a pointer to the byte sequence. An
Integer
object is passed as an integer whose bit size is same
as a pointer. Up to nine parameters may be passed.
The function identified by num is system dependent. On some Unix
systems, the numbers may be obtained from a header file called
syscall.h
.
syscall 4, 1, "hello\n", 6 # '4' is write(2) on our box
produces:
hello
Calling syscall
on a platform which does not have any way to
an arbitrary system function just fails with NotImplementedError.
Note: syscall
is essentially unsafe and
unportable. Feel free to shoot your foot. The DL (Fiddle) library is
preferred for safer and a bit more portable programming.
static VALUE rb_f_syscall(int argc, VALUE *argv) { 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_warning("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 }
Executes command… in a subshell. command… is one of following forms.
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 $?
.
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 *
See Kernel.exec
for the standard shell.
static VALUE rb_f_system(int argc, VALUE *argv) { rb_pid_t pid; int status; #if defined(SIGCLD) && !defined(SIGCHLD) # define SIGCHLD SIGCLD #endif #ifdef SIGCHLD RETSIGTYPE (*chfunc)(int); rb_last_status_clear(); chfunc = signal(SIGCHLD, SIG_DFL); #endif pid = rb_spawn_internal(argc, argv, NULL, 0); #if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV) if (pid > 0) { int ret, status; ret = rb_waitpid(pid, &status, 0); if (ret == (rb_pid_t)-1) rb_sys_fail("Another thread waited the process started by system()."); } #endif #ifdef SIGCHLD signal(SIGCHLD, chfunc); #endif if (pid < 0) { return Qnil; } status = PST2INT(rb_last_status_get()); if (status == EXIT_SUCCESS) return Qtrue; return Qfalse; }
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 \CF{setgid} bit | | set (false under NT) "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) { int cmd; if (argc == 0) rb_check_arity(argc, 2, 3); cmd = NUM2CHR(argv[0]); if (cmd == 0) { 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); } } 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; } } goto unknown; }
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 tag, value; rb_scan_args(argc, argv, "11", &tag, &value); rb_throw_obj(tag, value); UNREACHABLE; }
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'
VALUE rb_f_trace_var(int argc, const VALUE *argv) { VALUE var, cmd; struct rb_global_entry *entry; struct trace_var *trace; if (rb_scan_args(argc, argv, "11", &var, &cmd) == 1) { cmd = rb_block_proc(); } if (NIL_P(cmd)) { return rb_f_untrace_var(argc, argv); } entry = rb_global_entry(rb_to_id(var)); if (OBJ_TAINTED(cmd)) { rb_raise(rb_eSecurityError, "Insecure: tainted variable trace"); } trace = ALLOC(struct trace_var); trace->next = entry->var->trace; trace->func = rb_trace_eval; trace->data = cmd; trace->removed = 0; entry->var->trace = trace; return Qnil; }
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) { 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 (OBJ_TAINTED(cmd)) { rb_raise(rb_eSecurityError, "Insecure: tainted signal trap"); } return trap(sig, func, cmd); }
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.
VALUE rb_f_untrace_var(int argc, const VALUE *argv) { VALUE var, cmd; ID id; struct rb_global_entry *entry; struct trace_var *trace; VALUE data; rb_scan_args(argc, argv, "11", &var, &cmd); id = rb_check_id(&var); if (!id) { rb_name_error_str(var, "undefined global variable %"PRIsVALUE"", QUOTE(var)); } if (!rb_id_table_lookup(rb_global_tbl, id, &data)) { rb_name_error(id, "undefined global variable %"PRIsVALUE"", QUOTE_ID(id)); } trace = (entry = (struct rb_global_entry *)data)->var->trace; if (NIL_P(cmd)) { VALUE ary = rb_ary_new(); while (trace) { struct trace_var *next = trace->next; rb_ary_push(ary, (VALUE)trace->data); trace->removed = 1; trace = next; } if (!entry->var->block_trace) remove_trace(entry->var); return ary; } else { while (trace) { if (trace->data == cmd) { trace->removed = 1; if (!entry->var->block_trace) remove_trace(entry->var); return rb_ary_new3(1, cmd); } trace = trace->next; } } return Qnil; }
Displays each of the given messages followed by a record separator on
STDERR unless warnings have been disabled (for example with the
-W0
flag).
warn("warning 1", "warning 2") <em>produces:</em> warning 1 warning 2
static VALUE rb_warn_m(int argc, VALUE *argv, VALUE exc) { if (!NIL_P(ruby_verbose) && argc > 0) { rb_io_puts(argc, argv, rb_stderr); } return Qnil; }
Private Instance Methods
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 438 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
Returns uri
converted to a URI object.
# File lib/uri/common.rb, line 732 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
Use #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 #gem, #require will do the right thing for you.
#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.
#gem should be called before any require statements (otherwise RubyGems may load a conflicting library version).
#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 43 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 Gem::LOADED_SPECS_MUTEX.synchronize { spec.activate } if spec end
Outputs objs to STDOUT as JSON strings in the shortest form, that is in one line.
# File ext/json/lib/json/common.rb, line 416 def j(*objs) objs.each do |obj| puts JSON::generate(obj, :allow_nan => true, :max_nesting => false) end nil end
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 425 def jj(*objs) objs.each do |obj| puts JSON::pretty_generate(obj, :allow_nan => true, :max_nesting => false) end nil end
Creates an IO object connected to the given stream, file, or subprocess.
If path
does not start with a pipe character (|
),
treat it as the name of a file to open using the specified mode (defaulting
to “r”).
The mode
is either a string or an integer. If it is an
integer, it must be bitwise-or of open(2) flags, such as File::RDWR or
File::EXCL. If it is a string, it is either “fmode”, “fmode:ext_enc”, or
“fmode:ext_enc:int_enc”.
See the documentation of IO.new for full
documentation of the mode
string directives.
If a file is being created, its initial permissions may be set using the
perm
parameter. See File.new and the open(2) and chmod(2) man
pages for a description of permissions.
If a block is specified, it will be invoked with the IO object as a parameter, and the IO will be automatically closed when the block terminates. The call returns the value of the block.
If path
starts with a pipe character
("|"
), a subprocess is created, connected to the
caller by a pair of pipes. The returned IO object
may be used to write to the standard input and read from the standard
output of this subprocess.
If the command following the pipe is a single minus sign
("|-"
), Ruby forks, and this subprocess is connected
to the parent. If the command is not "-"
, the
subprocess runs the command.
When the subprocess is Ruby (opened via "|-"
), the
open
call returns nil
. If a block is associated
with the open call, that block will run twice — once in the parent and once
in the child.
The block parameter will be an IO object in the
parent and nil
in the child. The parent's IO
object will be connected to the child's $stdin and $stdout. The
subprocess will be terminated at the end of the block.
Examples¶ ↑
Reading from “testfile”:
open("testfile") do |f| print f.gets end
Produces:
This is line one
Open a subprocess and read its output:
cmd = open("|date") print cmd.gets cmd.close
Produces:
Wed Apr 9 08:56:31 CDT 2003
Open a subprocess running the same Ruby program:
f = open("|-", "w+") if f.nil? puts "in Child" exit else puts "Got: #{f.gets}" end
Produces:
Got: in Child
Open a subprocess using a block to receive the IO object:
open "|-" do |f| if f then # parent process puts "Got: #{f.gets}" else # child process puts "in Child" end end
Produces:
Got: in Child
static VALUE rb_f_open(int argc, VALUE *argv) { 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(argv[0], to_open, argc-1, argv+1); 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); }
prints arguments in pretty form.
pp returns argument(s).
# File lib/pp.rb, line 19 def pp(*objs) objs.each {|obj| PP.pp(obj) } objs.size <= 1 ? objs.first : objs end
When RubyGems is required, #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 38 def require path RUBYGEMS_ACTIVATION_MONITOR.enter path = path.to_path if path.respond_to? :to_path spec = Gem.find_unresolved_default_spec(path) if spec Gem.remove_unresolved_default_spec(spec) Kernel.send(:gem, spec.name) 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? then 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 spec = Gem::Specification.find_active_stub_by_path path begin RUBYGEMS_ACTIVATION_MONITOR.exit return gem_original_require(path) end if spec # 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? then 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 then 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.reject { |s| s.has_conflicts? }.first unless valid then 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 RUBYGEMS_ACTIVATION_MONITOR.enter begin if load_error.message.start_with?("Could not find") or (load_error.message.end_with?(path) and Gem.try_activate(path)) then require_again = true end ensure RUBYGEMS_ACTIVATION_MONITOR.exit end return gem_original_require(path) if require_again raise load_error end
An alias for Psych.dump_stream meant to be used with IRB.
# File ext/psych/lib/psych/y.rb, line 4 def y *objects puts Psych.dump_stream(*objects) end