модуль Kernel

RubyGems добавляет метод gem для активации определённых версий gem и переопределяет метод require в Kernel, чтобы сделать gems, как будто они находятся в $LOAD_PATH. Подробнее см. документацию этих методов.

Модуль Kernel включается классом Object, поэтому его методы доступны в каждом объекте Ruby.

Инстансные методы Kernel документированы в классе Object, а методы модуля — здесь. Эти методы вызываются без получателя и поэтому могут быть вызваны в функциональной форме:

sprintf "%.1f", 1.234 #=> "1.2"

Публичные методы класса

URI(uri) Показать исходный код

# File lib/uri/common.rb, line 733
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

Возвращает uri, преобразованное в объект URI.

open(path [, mode [, perm]] [, opt]) → io or nil Показать исходный код

open(path [, mode [, perm]] [, opt]) {|io| block } → obj

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

Создаёт объект IO, подключенный к указанному потоку, файлу или подпроцессу.

Если path не начинается с символа трубы (|), рассматривать его как имя файла для открытия с указанным режимом (по умолчанию «r»).

Параметр mode — это строка или целое число. Если это целое число, оно должно быть побитовым или флагов open(2), таких как File::RDWR или File::EXCL. Если это строка, она имеет вид «fmode», «fmode:ext_enc» или «fmode:ext_enc:int_enc».

См. документацию IO.new для полной документации директив строки mode.

Если файл создаётся, его начальные разрешения можно установить с помощью параметра perm. См. File.new и страницы руководства open(2) и chmod(2) для описания разрешений.

Если указан блок, он вызывается с объектом IO в качестве параметра, и IO будет автоматически закрыт по окончании блока. Вызов возвращает значение блока.

Если path начинается с символа трубы ("|"), создаётся подпроцесс, подключённый к вызывающей программе парой каналов.

Возвращаемый объект IO может использоваться для записи в стандартный ввод и чтения из стандартного вывода этого подпроцесса.

Если команда после символа трубы — одиночный минус ("|-"), Ruby раздваивается, и этот подпроцесс подключается к родительскому. Если команда — не "-", подпроцесс выполняет команду.

Когда подпроцессом является Ruby (открытый через "|-"), вызов open возвращает nil. Если блок связан с вызовом open, этот блок будет выполняться дважды — один раз в родительском и один раз в дочернем процессе.

Параметр блока будет объектом IO в родительском процессе и nil в дочернем. Объект IO родительского процесса будет подключён к $stdin и $stdout дочернего процесса. Подпроцесс будет завершён по окончании блока.

Примеры

Чтение из «testfile»:

open("testfile") do |f|
  print f.gets
end

Результат:

This is line one

Открыть подпроцесс и прочитать его вывод:

cmd = open("|date")
print cmd.gets
cmd.close

Результат:

Wed Apr  9 08:56:31 CDT 2003

Открыть подпроцесс, выполняющий ту же программу Ruby:

f = open("|-", "w+")
if f.nil?
  puts "in Child"
  exit
else
  puts "Got: #{f.gets}"
end

Результат:

Got: in Child

Открыть подпроцесс, используя блок для получения объекта IO:

open "|-" do |f|
  if f then
    # parent process
    puts "Got: #{f.gets}"
  else
    # child process
    puts "in Child"
  end
end

Результат:

Got: in Child

Также алиасы: open_uri_original_open, open_uri_original_open

pp(*objs) Показать исходный код

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

Выводит аргументы в красивом формате.

pp возвращает аргумент(ы).

Также алиас: pp

Приватные методы класса

open_uri_original_open(*args)

Псевдоним для: open

Общедоступные методы экземпляров

Array(arg) → массив Показать исходный код

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

Возвращает arg в виде Array.

Сначала пытается вызвать to_ary на arg, затем to_a. Если arg не отвечает на to_ary или to_a, возвращает Array длиной 1, содержащий arg.

Если to_ary или to_a возвращают что-то кроме Array, генерирует TypeError.

Array(["a", "b"])  #=> ["a", "b"]
Array(1..5)        #=> [1, 2, 3, 4, 5]
Array(key: :value) #=> [[:key, :value]]
Array(nil)         #=> []
Array(1)           #=> [1]

BigDecimal(initial, digits, exception: true) Показать исходный код

static VALUE
f_BigDecimal(int argc, VALUE *argv, VALUE self)
{
    ENTER(1);
    Real *pv;
    VALUE obj;

    obj = TypedData_Wrap_Struct(rb_cBigDecimal, &BigDecimal_data_type, 0);
    pv = BigDecimal_new(argc, argv);
    if (pv == NULL) return Qnil;
    SAVE(pv);
    if (ToValue(pv)) pv = VpCopy(NULL, pv);
    RTYPEDDATA_DATA(obj) = pv;
    RB_OBJ_FREEZE(obj);
    return pv->obj = obj;
}

Создаёт новый объект BigDecimal.

initial

Начальное значение в виде Integer, Float, Rational, BigDecimal или String.

Если это String, пробелы игнорируются, а нераспознанные символы завершают значение.

digits

Количество значащих цифр в виде Integer. Если пропущено или равно 0, количество значащих цифр определяется по начальному значению.

Фактическое количество значащих цифр, используемых в вычислениях, обычно больше указанного значения.

exception

Указывает, должна ли генерироваться ошибка при некорректных аргументах. По умолчанию true, если передано false, возвращает nil для некорректных значений.

Исключения

TypeError: Если тип initial не является ни Integer, Float, Rational, ни BigDecimal, генерируется это исключение.
TypeError: Если digits не является Integer, генерируется это исключение.
ArgumentError: Если initial является Float, а digits больше, чем Float::DIG + 1, генерируется это исключение.
ArgumentError: Если initial является Float или Rational, а digits значение пропущено, генерируется это исключение.

Complex(x[, y], exception: false) → числовой Показать исходный код

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

    if (rb_scan_args(argc, argv, "11:", &a1, &a2, &opts) == 1) {
        a2 = Qundef;
    }
    if (!NIL_P(opts)) {
        static ID kwds[1];
        VALUE exception;
        if (!kwds[0]) {
            kwds[0] = idException;
        }
        rb_get_kwargs(opts, kwds, 0, 1, &exception);
        raise = (exception != Qfalse);
    }
    return nucomp_convert(rb_cComplex, a1, a2, raise);
}

Возвращает x+i*y;

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

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

Синтаксис строковой формы:

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* ? ;

См. String#to_c.

Float(arg, exception: true) → число с плавающей точкой Показать исходный код

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

    rb_scan_args(argc, argv, "1:", &arg, &opts);
    return rb_convert_to_float(arg, opts_exception_p(opts));
}

Возвращает arg, преобразованный в число с плавающей точкой. Типы Numeric преобразуются напрямую, а строки и nil - с использованием arg.to_f. Преобразование строки с некорректными символами приведёт к string. Преобразование nil генерирует TypeError. Исключение можно подавить, передав exception: false.

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

Hash(arg) → хэш Показать исходный код

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

Преобразует arg в Hash, вызывая arg.to_hash. Возвращает пустой Hash для nil или [].

Hash([])          #=> {}
Hash(nil)         #=> {}
Hash(key: :value) #=> {:key => :value}
Hash([1, 2, 3])   #=> TypeError

Integer(arg, base=0, exception: true) → целое число Показать исходный код

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

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

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

Преобразует arg в Integer. Типы Numeric преобразуются напрямую (числа с плавающей точкой усекаются). base (0 или от 2 до 36) - основание для представления целого числа в строке. Если arg - это строка, при отсутствии или нулевом значении base учитываются индикаторы основания (0, 0b, и 0x). Во всех случаях строки должны строго соответствовать числовому представлению. Это поведение отличается от String#to_i. Для значений, отличных от строк, сначала используется to_int, затем to_i.

Передача nil генерирует TypeError, а строка, не соответствующая числовому представлению, - ArgumentError. Это поведение можно изменить, передав exception: false, в этом случае неконвертируемое значение возвращает nil.

Integer(123.999)    #=> 123
Integer("0x1a")     #=> 26
Integer(Time.new)   #=> 1204973019
Integer("0930", 10) #=> 930
Integer("111", 2)   #=> 7
Integer(nil)        #=> TypeError: can't convert nil into Integer
Integer("x")        #=> ArgumentError: invalid value for Integer(): "x"

Integer("x", exception: false)        #=> nil

Pathname(path) → путь Показать исходный код

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

Создаёт новый объект Pathname из заданной строки, path, и возвращает объект пути.

Для использования этого конструктора необходимо сначала загрузить расширение стандартной библиотеки Pathname.

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

См. также Pathname::new для получения дополнительной информации.

Rational(x, y, exception: true) → рациональное число

Rational(arg, exception: true) → рациональное число

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

    if (rb_scan_args(argc, argv, "11:", &a1, &a2, &opts) == 1) {
        a2 = Qundef;
    }
    if (!NIL_P(opts)) {
        static ID kwds[1];
        VALUE exception;
        if (!kwds[0]) {
            kwds[0] = idException;
        }
        rb_get_kwargs(opts, kwds, 0, 1, &exception);
        raise = (exception != Qfalse);
    }
    return nurat_convert(rb_cRational, a1, a2, raise);
}

Возвращает x/y или arg в виде Rational.

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

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

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

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

Синтаксис строковой формы:

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* ? ;

См. также String#to_r.

String(arg) → строка Показать исходный код

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

Возвращает arg в виде String.

Сначала пытается вызвать его метод to_str, затем to_s.

String(self)        #=> "main"
String(self.class)  #=> "Object"
String(123456)      #=> "123456"

__callee__ → символ Показать исходный код

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

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

Возвращает имя вызываемого метода в виде Symbol. Если вызов происходит вне метода, возвращает nil.

__dir__ → строка Показать исходный код

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

Возвращает канонизированный абсолютный путь к директории файла, из которого вызван этот метод. Это означает, что ссылки на символические ссылки в пути разрешаются. Если __FILE__ равно nil, возвращает nil. Возвращаемое значение равно File.dirname(File.realpath(__FILE__)).

__method__ → символ Показать исходный код

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

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

Возвращает имя текущего метода в момент определения как Symbol. Если вызов происходит вне метода, возвращает nil.

`cmd` → строка Показать исходный код

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

Возвращает стандартный вывод, полученный при запуске cmd в дочерней оболочке. Встроенный синтаксис %x{...} использует этот метод. Устанавливает $? в состояние процесса.

`date`                   #=> "Wed Apr  9 08:56:30 CDT 2003\n"
`ls testdir`.split[1]    #=> "main.rb"
`echo oops && exit 99`   #=> "oops\n"
$?.exitstatus            #=> 99

abort

Kernel::abort([msg])

abort([msg])

VALUE
rb_f_abort(int argc, const VALUE *argv)
{
    rb_check_arity(argc, 0, 1);
    if (argc == 0) {
        rb_execution_context_t *ec = GET_EC();
        VALUE errinfo = ec->errinfo;
        if (!NIL_P(errinfo)) {
            rb_ec_error_print(ec, errinfo);
        }
        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_RETURN(Qnil);
}

Немедленно завершает выполнение, фактически вызывая Kernel.exit(false). Если msg задан, он выводится в STDERR перед завершением.

END_OF_DOCUMENT_MARKER

at_exit { блок } → proc Показать исходный код

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

Преобразует блок в объект Proc (и тем самым связывает его в момент вызова) и регистрирует его для выполнения при выходе из программы. Если зарегистрировано несколько обработчиков, они выполняются в обратном порядке регистрации.

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

выводит:

goodbye cruel world

autoload(модуль, имя_файла) → nil Показать исходный код

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

Регистрирует имя_файла для загрузки (используя Kernel::require) в первый раз, когда к модулю (который может быть модулем или символом) обращаются.

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

autoload?(имя) → Строка или nil Показать исходный код

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

Возвращает имя_файла для загрузки, если имя зарегистрировано как autoload.

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

binding → a_binding Показать исходный код

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

Возвращает объект Binding, описывающий привязки переменных и методов в момент вызова. Этот объект может быть использован при вызове eval для выполнения оцениваемой команды в этой среде. Также см. описание класса Binding.

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

block_given? → true или false Показать исходный код

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

    if (cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE) {
        return Qtrue;
    }
    else {
        return Qfalse;
    }
}

Возвращает true, если yield будет выполнять блок в текущем контексте. Форма iterator? немного устарела.

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

callcc {|cont| блок } → obj Показать исходный код

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

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

Генерирует объект Continuation, который передаётся в связанный блок. Вам нужно require 'continuation' перед использованием этого метода. Выполнение cont.call приведёт к возврату callcc (как и проход до конца блока). Значение, возвращённое callcc, является значением блока или значением, переданным в cont.call. См. класс Continuation для получения дополнительной информации. Также см. Kernel#throw для альтернативного механизма разматывания стека вызовов.

caller(start=1, length=nil) → массив или nil

caller(диапазон) → массив или nil

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

Возвращает текущий стек выполнения — массив, содержащий строки в формате file:line или file:line: in `method'.

Необязательный параметр start определяет количество начальных элементов стека, которые нужно пропустить сверху.

Необязательный параметр length может быть использован для ограничения количества возвращаемых элементов из стека.

Возвращает nil если start больше размера текущего стека выполнения.

Необязательно, вы можете передать диапазон, который вернёт массив, содержащий элементы в указанном диапазоне.

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

caller_locations(start=1, length=nil) → массив или nil

caller_locations(диапазон) → массив или nil

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

Возвращает текущий стек выполнения — массив, содержащий объекты местоположений трассировки.

См. Thread::Backtrace::Location для получения дополнительной информации.

Возвращает nil если start больше размера текущего стека выполнения.

catch([метка]) {|метка| блок } → obj Показать исходный код

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

catch выполняет свой блок. Если throw не вызывается, блок выполняется обычно, и catch возвращает значение последнего вычисленного выражения.

catch(1) { 123 }            # => 123

Если throw(tag2, val) вызывается, Ruby ищет в своём стеке блок catch, чей tag имеет то же значение, что и метка2. При обнаружении блок перестаёт выполняться и возвращает val (или nil если вторым аргументом в throw не передано значение).

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

Когда tag передаётся в качестве первого аргумента, catch передаёт его как параметр блока.

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

Когда не задана tag, catch передаёт новый уникальный объект (как из Object.new) в качестве параметра блока. Этот объект может затем использоваться в качестве аргумента для throw, и будет соответствовать правильному catch блоку.

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

chomp → $_

chomp(строка) → $_

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

Эквивалентно $_ = $_.chomp(string). См. String#chomp. Доступно только при указании опций командной строки -p/-n.

chop → $_ Показать исходный код

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

Эквивалентно ($_.dup).chop!, за исключением того, что nil никогда не возвращается. См. String#chop!. Доступно только при указании опций командной строки -p/-n.

eval(строка [, привязка [, имя_файла [, номер_строки]]]) → obj Показать исходный код

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

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

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

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

Вычисляет выражение(я) Ruby в строке. Если задана привязка, которая должна быть объектом Binding, вычисление выполняется в его контексте. Если присутствуют необязательные параметры имя_файла и номер_строки, они будут использоваться при сообщении об ошибках синтаксиса.

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

END_OF_DOCUMENT_MARKER

exec([env,] command... [,options]) Показать исходный код

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, FALSE);
    eargp = rb_execarg_get(execarg_obj);
    if (mjit_enabled) mjit_finish(FALSE); /* avoid leaking resources, and do not leave files. XXX: JIT-ed handle can leak after exec error is rescued. */
    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;

    err = exec_async_signal_safe(eargp, errmsg, sizeof(errmsg));
    after_exec(); /* restart timer thread */

    rb_exec_fail(eargp, err, errmsg);
    RB_GC_GUARD(execarg_obj);
    rb_syserr_fail_str(err, fail_str);
    UNREACHABLE_RETURN(Qnil);
}

Заменяет текущий процесс запуском указанной внешней команды, которая может иметь один из следующих форматов:

exec(commandline): строка командной строки, передаваемая в стандартную оболочку
exec(cmdname, arg1, ...): имя команды и один или более аргументов (без оболочки)
exec([cmdname, argv0], arg1, ...): имя команды, argv и ноль или более аргументов (без оболочки)

В первом формате строка воспринимается как командная строка, которая подвергается расширению оболочки перед выполнением.

Стандартная оболочка всегда означает "/bin/sh" на системах Unix-подобного типа, аналогично ENV["RUBYSHELL"] (или ENV["COMSPEC"] в системах Windows NT), и так далее.

Если строка из первого формата (exec("command")) следует простым правилам:

нет метасимволов
нет зарезервированных слов оболочки и нет специальных встроенных команд
Ruby вызывает команду непосредственно без оболочки

Вы можете принудительно вызвать оболочку, добавив «;» в строку (поскольку «;» является метасимволом).

Обратите внимание, что это поведение можно наблюдать по полученному идентификатору процесса (значение возврата spawn() и IO#pid для IO.popen) — это идентификатор процесса вызванной команды, а не оболочки.

Во втором формате (exec("command1", "arg1", ...)) первое значение используется как имя команды, а остальные передаются как параметры команде без расширения оболочки.

В третьем формате (exec(["command", "argv0"], "arg1", ...)) начальный двухелементный массив в начале команды, первый элемент — это команда для выполнения, а второй аргумент используется в качестве значения argv[0], которое может отображаться в списках процессов.

Для выполнения команды используются системные вызовы exec(2), поэтому выполняемая команда может унаследовать часть среды исходной программы (включая открытые дескрипторы файлов).

Это поведение изменяется с помощью переданных параметров env и options. См. ::spawn для получения подробностей.

Если команда не может быть выполнена (обычно Errno::ENOENT, когда она не найдена), генерируется исключение SystemCallError.

Данный метод изменяет атрибуты процесса в соответствии с переданными options перед системным вызовом exec(2). См. ::spawn для получения более подробной информации о переданных options.

Измененные атрибуты могут сохраняться, когда системный вызов exec(2) терпит неудачу.

Например, жёсткие ограничения ресурсов не восстанавливаются.

Рекомендуется создать дочерний процесс с помощью ::spawn или Kernel#system, если это недопустимо.

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

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

exit(status=true) Показать исходный код

Kernel::exit(status=true)

Process::exit(status=true)

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_RETURN(Qnil);
}

Инициализирует завершение скрипта Ruby, выбросив исключение SystemExit. Это исключение может быть перехвачено. Необязательный параметр используется для возврата кода состояния вызывающей среде. true и FALSE значения status соответствуют успеху и ошибке соответственно. Интерпретация других целочисленных значений зависит от системы.

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

выводит:

rescued a SystemExit exception
after begin block

Непосредственно перед завершением Ruby выполняет все функции at_exit (см. Kernel::at_exit) и выполняет все финализаторы объектов (см. ObjectSpace::define_finalizer).

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

выводит:

at_exit function
in finalizer

exit!(status=false) Показать исходный код

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

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

    UNREACHABLE_RETURN(Qnil);
}

Немедленно завершает процесс. Обработчики завершения не выполняются. status возвращается в базовую систему в качестве кода завершения.

Process.exit!(true)

fail Показать исходный код

fail(string, cause: $!)

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

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_RETURN(Qnil);
}

Без аргументов, генерирует исключение $! или RuntimeError, если $! равно nil. С одним аргументом — строкой, генерирует исключение RuntimeError с указанной строкой в качестве сообщения. В противном случае, первый параметр должен быть именем класса исключения (или объектом, возвращающим объект исключения при отправке сообщения exception). Необязательный второй параметр устанавливает сообщение, связанное с исключением, а третий параметр — массив информации обратного вызова. Исключения перехватываются блоком rescue в begin...end блоках.

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

Значение cause созданного исключения автоматически устанавливается в «текущее» исключение ($!), если таковое имеется. Альтернативное значение, либо объект Exception, либо nil, может быть указано через аргумент :cause.

fork [{ block }] → integer or nil Показать исходный код

fork [{ block }] → integer or nil

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

Создаёт дочерний процесс. Если указан блок, этот блок выполняется в дочернем процессе, и дочерний процесс завершается со статусом ноль. В противном случае вызов fork возвращает дважды, один раз в родительском процессе, возвращая идентификатор процесса дочернего процесса, и один раз в дочернем процессе, возвращая nil. Дочерний процесс может завершиться, используя Kernel.exit!, чтобы избежать выполнения каких-либо функций at_exit. Родительский процесс должен использовать Process.wait для сбора статусов завершения своих дочерних процессов или использовать Process.detach для регистрации отсутствия интереса к их статусу; в противном случае операционная система может накапливать процессы-зомби.

Поток, вызывающий fork, является единственным потоком в созданном дочернем процессе. fork не копирует другие потоки.

Если fork недоступен, Process.respond_to?(:fork) возвращает false.

Обратите внимание, что fork(2) недоступен на некоторых платформах, таких как Windows и NetBSD 4. Поэтому следует использовать spawn() вместо fork().

format(format_string [, arguments...] ) → string Показать исходный код

VALUE
rb_f_sprintf(int argc, const VALUE *argv)
{
    return rb_str_format(argc - 1, argv + 1, GETNTHARG(0));
}

Возвращает строку, полученную в результате применения format_string к дополнительным аргументам. Внутри строки формата любые символы, кроме последовательностей формата, копируются в результат.

Синтаксис последовательности формата следующий.

%[flags][width][.precision]type

Последовательность формата состоит из символа процента, за которым следуют необязательные флаги, ширина и точность, а затем завершается типом поля. Тип поля управляет тем, как соответствующий sprintf аргумент должен быть интерпретирован, а флаги изменяют эту интерпретацию.

Символы типа поля:

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.

Флаги изменяют поведение форматов. Символы флагов:

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.

Примеры флагов:

# `+' 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."

Ширина поля — это необязательное целое число, за которым необязательно следует точка и точность. Ширина указывает минимальное количество символов, которые будут записаны в результат для этого поля.

Примеры ширины:

# 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) #=> " 0000000000000000123"
sprintf("%-20d", 123)  #=> "123                 "
sprintf("%-+20d", 123) #=> "+123                "
sprintf("%- 20d", 123) #=> " 123                "
sprintf("%020x", -123) #=> "..ffffffffffffffff85"

Для числовых полей точность контролирует количество знаков после запятой. Для строковых полей точность определяет максимальное количество символов, которые будут скопированы из строки. (Таким образом, последовательность формата %10.10s всегда вносит ровно десять символов в результат.)

Примеры точностей:

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

Примеры:

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"

Для более сложного форматирования Ruby поддерживает ссылку по имени. Стиль %<name>s использует формат стиля, но %{name} стиль — нет.

Примеры:

sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 })
  #=> 1 : 2.000000
sprintf("%{foo}f", { :foo => 1 })
  # => "1f"

gem_original_require(path)

Псевдоним для: require

gets(sep=$/ [, getline_args]) → string or nil Показать исходный код

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

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

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

Возвращает (и присваивает $_) следующую строку из списка файлов в ARGV (или $*) или со стандартного ввода, если на командной строке нет файлов. Возвращает nil в конце файла. Необязательный аргумент задаёт разделитель записей. Разделитель включается в содержимое каждой записи. Разделитель nil считывает всё содержимое, а разделитель нулевой длины считывает ввод по абзацам, где абзацы разделены двумя последовательными символами новой строки. Если первый аргумент — целое число или задан необязательный второй аргумент, возвращаемая строка не будет длиннее указанного значения в байтах. Если в ARGV присутствует несколько имён файлов, gets(nil) будет считывать содержимое по одному файлу за раз.

ARGV << "testfile"
print while gets

выводит:

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

Стиль программирования, использующий $_ в качестве неявного параметра, постепенно теряет свою популярность в сообществе Ruby.

END_OF_DOCUMENT_MARKER

global_variables → массив Показать исходный код

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

Возвращает массив имён глобальных переменных.

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

gsub(pattern, replacement) → $_ Показать исходный код

gsub(pattern) {|...| блок } → $_

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

Эквивалентно $_.gsub..., за исключением того, что $_ будет обновлён, если замена произойдёт. Доступно только при указании опций командной строки -p/-n.

iterator? → true или false Показать исходный код

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

    if (cfp != NULL && VM_CF_BLOCK_HANDLER(cfp) != VM_BLOCK_HANDLER_NONE) {
        return Qtrue;
    }
    else {
        return Qfalse;
    }
}

Возвращает true, если yield бы выполнил блок в текущем контексте. Форма iterator? немного устарела.

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

lambda { |...| блок } → a_proc Показать исходный код

VALUE
rb_block_lambda(void)
{
    return proc_new(rb_cProc, TRUE);
}

Эквивалентно Proc.new, за исключением того, что полученные Proc объекты проверяют количество переданных параметров при вызове.

load(filename, wrap=false) → true Показать исходный код

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

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

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

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

    RUBY_DTRACE_HOOK(LOAD_RETURN, RSTRING_PTR(orig_fname));

    return Qtrue;
}

Загружает и выполняет Ruby-программу из файла filename. Если имя файла не соответствует абсолютному пути, файл ищется в каталогах библиотек, перечисленных в $:. Если необязательный параметр wrap имеет значение true, загруженный скрипт будет выполнен в анонимном модуле, защищая глобальное пространство имён вызывающей программы. Ни при каких обстоятельствах локальные переменные из загруженного файла не будут переданы в среду загрузки.

local_variables → массив Показать исходный код

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

    local_var_list_init(&vars);
    while (cfp) {
        if (cfp->iseq) {
            for (i = 0; i < 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(ep, &vars)) {
                break;
            }
            else {
                while (cfp->ep != ep) {
                    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
                }
            }
        }
        else {
            break;
        }
    }
    return local_var_list_finish(&vars);
}

Возвращает имена текущих локальных переменных.

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

loop { блок } Показать исходный код

loop → итерируемый_объект

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

Повторяет выполнение блока.

Если блок не задан, возвращается итерируемый объект.

loop do
  print "Input: "
  line = gets
  break if !line or line =~ /^qQ/
  # ...
end

StopIteration поднятый в блоке прерывает цикл. В этом случае loop возвращает значение «результат», сохранённое в исключении.

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

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

p(объект) → объект Показать исходный код

p(объект1, объект2, ...) → [объект, ...]

p() → null

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

Для каждого объекта напрямую записывает объект.inspect с новой строкой в стандартный вывод программы.

S = Struct.new(:name, :state)
s = S['dave', 'TX']
p s

вывод:

#<S name="dave", state="TX">

pretty_inspect() Показать исходный код

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

Возвращает красиво отформатированный объект в виде строки.

Для использования этого метода необходимо сначала загрузить модуль PP:

require 'pp'

См. модуль PP для получения дополнительной информации.

print(объект, ...) → null Показать исходный код

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

Выводит каждый объект по очереди в $stdout. Если разделитель вывода полей ($,) не nil, его содержимое будет отображаться между каждым полем. Если разделитель записей вывода ($\) не nil, он будет добавлен к выводу. Если аргументы не заданы, выводится $_. Объекты, которые не являются строками, будут преобразованы путём вызова их метода to_s.

print "cat", [1,2,3], 99, "\n"
$, = ", "
$\ = "\n"
print "cat", [1,2,3], 99

вывод:

cat12399
cat, 1, 2, 3, 99

printf(io, строка [, объект ... ]) → null Показать исходный код

printf(строка [, объект ... ]) → null

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

Эквивалентно:

io.write(sprintf(string, obj, ...))

или

$stdout.write(sprintf(string, obj, ...))

proc { |...| блок } → a_proc Показать исходный код

VALUE
rb_block_proc(void)
{
    return proc_new(rb_cProc, FALSE);
}

Эквивалентно Proc.new.

putc(int) → int Показать исходный код

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

Эквивалентно:

$stdout.putc(int)

Обратитесь к документации IO#putc за важной информацией о многобайтовых символах.

puts(объект, ...) → null Показать исходный код

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

Эквивалентно

$stdout.puts(obj, ...)

raise Показать исходный код

raise(строка, cause: $!)

raise(исключение [, строка [, массив]], cause: $!)

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_RETURN(Qnil);
}

Без аргументов, генерирует исключение в $! или генерирует RuntimeError если $! равно nil. С одним аргументом, генерирует RuntimeError с сообщением в качестве строки. В противном случае, первый параметр должен быть именем класса Exception (или объектом, возвращающим объект Exception при отправке сообщения exception). Необязательный второй параметр устанавливает сообщение, связанное с исключением, а третий — массив с информацией о обратном вызове. Исключение ловится rescue частью begin...end блоков.

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

Свойство cause сгенерированного исключения автоматически устанавливается в «текущее» исключение ($!) при наличии. Альтернативное значение, объект Exception или nil, может быть указано через аргумент :cause.

rand(max=0) → число Показать исходный код

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

Если вызвана без аргумента или если max.to_i.abs == 0, rand возвращает псевдослучайное число с плавающей точкой между 0,0 и 1,0 включительно 0,0 и исключая 1,0.

rand        #=> 0.2725926052826416

Если max.abs больше или равно 1, rand возвращает псевдослучайное целое число, большее или равное 0 и меньшее max.to_i.abs.

rand(100)   #=> 12

Если max это Range, rand возвращает случайное число, где range.member?(number) == true.

Отрицательные или значения с плавающей точкой для max допустимы, но могут давать неожиданные результаты.

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

Kernel.srand может быть использован для обеспечения воспроизводимости последовательностей случайных чисел при разных запусках программы.

См. также Random.rand.

readline(sep=$/) → строка Показать исходный код

readline(limit) → строка

readline(sep, limit) → строка

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

Эквивалентно Kernel::gets, за исключением того, что readline генерирует EOFError в конце файла.

readlines(sep=$/) → массив Показать исходный код

readlines(limit) → массив

readlines(sep, limit) → массив

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

Возвращает массив, содержащий строки, полученные при вызове Kernel.gets(sep) до конца файла.

require_relative(строка) → true или false Показать исходный код

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

Ruby пытается загрузить библиотеку с именем строка, относительно пути файла, который ее требует. Если путь файла определить невозможно, то генерируется LoadError. Если файл загружен, то возвращается true, в противном случае — false.

select(read_array [, write_array [, error_array [, timeout]]]) → массив или nil Показать исходный код

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

Вызывает системный вызов select(2). Он отслеживает заданные массивы IO объектов, ожидает, пока один или несколько из IO объектов будут готовы к чтению, к записи и соответственно к обработке исключений, и возвращает массив, содержащий массивы этих IO объектов. Он вернет nil если заданное значение timeout и ни один IO объект не готов в течение timeout секунд.

IO.select просматривает буфер IO объектов для проверки возможности чтения. Если буфер IO не пуст, IO.select немедленно сообщает о возможности чтения. Это «просмотр» происходит только для IO объектов. Это не происходит для объектов типа IO, таких как OpenSSL::SSL::SSLSocket.

Лучший способ использования IO.select — вызов его после выполнения неблокирующих методов, таких как read_nonblock, write_nonblock, и т.д. Эти методы могут вызывать исключение, которое расширяется IO::WaitReadable или IO::WaitWritable. Модули сообщают, как вызывающему коду следует ждать с помощью IO.select. Если возникает IO::WaitReadable, вызывающий код должен ждать чтения. Если возникает IO::WaitWritable, вызывающий код должен ждать записи.

Таким образом, блокирующее чтение (readpartial) можно смоделировать, используя read_nonblock и IO.select следующим образом:

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

В особенности, сочетание неблокирующих методов и IO.select предпочтительно для IO подобных объектов, таких как OpenSSL::SSL::SSLSocket. У него есть метод to_io для возврата базового IO объекта. IO.select вызывает to_io для получения дескриптора файла, на котором нужно ждать.

Это означает, что уведомление о возможности чтения, полученное от IO.select, не означает возможность чтения из OpenSSL::SSL::SSLSocket объекта.

Скорее всего, буфер OpenSSL::SSL::SSLSocket содержит некоторые данные. IO.select не видит буфера. Поэтому IO.select может заблокироваться, когда OpenSSL::SSL::SSLSocket#readpartial не блокируется.

Однако существуют и более сложные ситуации.

SSL — это протокол, который представляет собой последовательность записей. Запись состоит из нескольких байтов. Таким образом, удаленный конец SSL отправляет частичную запись, IO.select сообщает о возможности чтения, но OpenSSL::SSL::SSLSocket не может декодировать байт, и OpenSSL::SSL::SSLSocket#readpartial заблокируется.

Также, удаленный конец может запросить переподключение SSL, что заставляет локальный движок SSL записать некоторые данные. Это означает, что OpenSSL::SSL::SSLSocket#readpartial может вызвать системный вызов write и может заблокироваться. В такой ситуации, OpenSSL::SSL::SSLSocket#read_nonblock вызовет IO::WaitWritable вместо блокирования. Таким образом, вызывающему коду следует подождать готовности к записи, как в примере выше.

Сочетание неблокирующих методов и IO.select также полезно для потоков, таких как tty, pipe и сокет, когда несколько процессов считывают из потока.

Наконец, разработчики ядра Linux не гарантируют, что возможность чтения, полученная от select(2), означает возможность чтения с помощью последующего read(2), даже для одного процесса. См. руководство select(2) в системе GNU/Linux.

Вызов IO.select перед IO#readpartial работает как обычно. Однако это не лучший способ использования IO.select.

Уведомление о возможности записи, полученное от select(2), не показывает, сколько байтов можно записать. Метод IO#write блокируется до тех пор, пока весь указанный текст не будет записан. Поэтому IO#write(two or more bytes) может заблокироваться после уведомления о возможности записи IO.select. IO#write_nonblock требуется, чтобы избежать блокировки.

Блокирующая запись (write) можно смоделировать с помощью write_nonblock и IO.select, как следует: IO::WaitReadable также нужно обрабатывать для переподключения SSL в 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

Параметры

read_array: массив IO объектов, ожидающих готовности к чтению
write_array: массив IO объектов, ожидающих готовности к записи
error_array: массив IO объектов, ожидающих исключения
timeout: числовое значение в секундах

Пример

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
}

выводит:

ping pong
ping pong
ping pong
(snipped)
ping

set_trace_func(proc) → proc Показать исходный код

set_trace_func(nil) → nil

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

Устанавливает proc в качестве обработчика отслеживания или отключает отслеживание, если параметр равен nil.

Примечание: этот метод устарел, пожалуйста, используйте TracePoint вместо него.

proc принимает до шести параметров:

имя события
имя файла
номер строки
идентификатор объекта
связывание
имя класса

proc вызывается всякий раз, когда происходит событие.

События:

c-call: вызов C-функции
c-return: возврат из C-функции
call: вызов метода Ruby
class: начало определения класса или модуля
end: завершение определения класса или модуля
line: выполнение кода в новой строке
raise: выброс исключения
return: возврат из метода Ruby

Отслеживание отключается в контексте 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

sleep([duration]) → целое Показать исходный код

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

Приостанавливает выполнение текущей нити на duration секунд (которое может быть любым числом, включая Float с дробными секундами). Возвращает фактическое количество прошедших секунд (округлено), которое может быть меньше запрошенного, если другая нить вызывает Thread#run. Если вызов осуществляется без аргумента, sleep() будет приостанавливаться бесконечно.

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

spawn([env,] command... [,options]) → pid Показать исходный код

spawn([env,] command... [,options]) → pid

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, FALSE);
    eargp = rb_execarg_get(execarg_obj);
    fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;

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

    if (pid == -1) {
        int err = errno;
        rb_exec_fail(eargp, err, errmsg);
        RB_GC_GUARD(execarg_obj);
        rb_syserr_fail_str(err, fail_str);
    }
#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
    return PIDT2NUM(pid);
#else
    return Qnil;
#endif
}

spawn выполняет указанную команду и возвращает её 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

Этот метод похож на Kernel#system, но он не ожидает завершения команды.

Родительский процесс должен использовать Process.wait для получения состояния завершения своего дочернего процесса или использовать Process.detach для отмены интереса к его статусу; в противном случае операционная система может накапливать процессы-зомби.

spawn имеет множество опций для указания атрибутов процесса:

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

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

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

Если в качестве env передаётся хэш, среда обновляется с помощью env перед exec(2) в дочернем процессе. Если в паре в env значение равно nil, переменная удаляется.

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

Если в качестве options передаётся хэш, он определяет группу процессов, создание новой группы процессов, ограничения ресурсов, текущую директорию, umask и перенаправления для дочернего процесса. Также может быть указано очищение переменных среды.

Ключ :unsetenv_others в options указывает на очистку переменных среды, кроме тех, которые определены env.

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

Ключ :pgroup в options определяет группу процессов. Соответствующее значение должно быть true, ноль, положительным целым числом или nil. true и ноль заставляют процесс стать лидером новой группы процессов. Положительное целое число, отличное от нуля, заставляет процесс присоединиться к указанной группе процессов. Значение по умолчанию, nil, заставляет процесс остаться в той же группе процессов.

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

Ключ :new_pgroup в options определяет передачу флага CREATE_NEW_PROCESS_GROUP в CreateProcessW() (это функция API Windows). Эта опция предназначена только для Windows. true означает, что новый процесс является корневым процессом новой группы процессов. Новый процесс имеет отключённую комбинацию клавиш CTRL+C. Этот флаг необходим для Process.kill(:SIGINT, pid) в дочернем процессе. :new_pgroup по умолчанию имеет значение false.

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

Ключ :rlimit_foo определяет ограничение ресурсов. foo должен быть одним из типов ресурсов, таких как core. Соответствующее значение должно быть целым числом или массивом из одного или двух целых чисел: аналогично аргументам cur_limit и max_limit для 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.

Ключ :umask в options определяет umask.

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

Ключи :in, :out, :err, целое число, IO и массив определяют перенаправление. Перенаправление отображает дескриптор файла в дочернем процессе.

Например, stderr можно объединить со stdout следующим образом:

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

Ключи хэша определяют дескриптор файла в дочернем процессе, запущенном с помощью spawn. :err, 2 и STDERR определяют стандартный поток ошибок (stderr).

Значения хэша определяют дескриптор файла в родительском процессе, вызывающем spawn. :out, 1 и STDOUT определяют стандартный поток вывода (stdout).

В вышеприведённом примере стандартный поток вывода в дочернем процессе не указан. Поэтому он наследуется от родительского процесса.

Стандартный поток ввода (stdin) можно указать с помощью :in, 0 и STDIN.

Можно указать имя файла в качестве значения хэша.

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

Для stdout и stderr (и их комбинации) используется режим записи. В противном случае используется режим чтения.

Для явного указания флагов и разрешений для создания файла используется массив.

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

Массив содержит имя файла, флаги и разрешения. Флаги могут быть строкой или целым числом. Если флаги опущены или nil, предполагается File::RDONLY. Разрешения должны быть целым числом. Если разрешения опущены или nil, предполагается 0644.

Если в качестве ключа хэша указан массив I/O и целых чисел, все элементы перенаправляются.

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

Другой способ объединить несколько дескрипторов — [:child, fd]. [:child, fd] обозначает дескриптор файла в дочернем процессе. Это отличается от fd. Например, :err=>:out означает перенаправление stderr дочернего процесса в stdout родительского процесса. Но :err=>[:child, :out] означает перенаправление stderr дочернего процесса в stdout дочернего процесса. Они отличаются, если stdout перенаправлен в дочернем процессе, как показано ниже.

# 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] может использоваться для объединения stderr в stdout в IO.popen. В этом случае, IO.popen перенаправляет stdout в канал в дочернем процессе, а [:child, :out] ссылается на перенаправленный stdout.

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

Ключ :chdir в options определяет текущую директорию.

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

spawn по умолчанию закрывает все нестандартные, не указанные дескрипторы. «Стандартные» дескрипторы — 0, 1 и 2. Это поведение задано опцией :close_others. :close_others не влияет на стандартные дескрипторы, которые закрываются только если :close указано явно.

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 по умолчанию имеет значение false для spawn и IO.popen.

Обратите внимание, что дескрипторы, у которых флаг close-on-exec уже установлен, закрываются независимо от опции :close_others.

Поэтому IO.pipe и spawn могут использоваться как 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 указывается как значение хэша для закрытия дескриптора файла.

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

Если нужно унаследовать дескриптор файла, можно использовать io=>io.

# 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

Также возможно обмен дескрипторами файлов.

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

Ключи хэша определяют дескрипторы файлов в дочернем процессе. Значения хэша определяют дескрипторы файлов в родительском процессе. Таким образом, вышеприведённый пример указывает на обмен stdout и stderr. Внутренне spawn использует дополнительный дескриптор файла для решения такой циклической схемы отображения дескрипторов.

См. Kernel.exec для стандартной оболочки.

sprintf(format_string [, arguments...] ) → string Показать исходный код

VALUE
rb_f_sprintf(int argc, const VALUE *argv)
{
    return rb_str_format(argc - 1, argv + 1, GETNTHARG(0));
}

Возвращает строку, полученную путём применения format_string к дополнительным аргументам. Внутри строки форматирования все символы, отличные от последовательностей форматирования, копируются в результат.

Синтаксис последовательности форматирования следующий.

%[flags][width][.precision]type

Последовательность форматирования состоит из символа процента, за которым следуют необязательные флаги, ширина и показатели точности, а затем завершается символом типа поля. Символ типа поля определяет, как должен интерпретироваться соответствующий sprintf аргумент, в то время как флаги изменяют эту интерпретацию.

Символы типа поля:

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.

Флаги изменяют поведение форматов. Символы флагов:

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.

Примеры флагов:

# `+' 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."

Ширина поля — это необязательное целое число, за которым необязательно следует точка и точность. Ширина задаёт минимальное количество символов, которые будут записаны в результат для этого поля.

Примеры ширины:

# 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) #=> " 0000000000000000123"
sprintf("%-20d", 123)  #=> "123                 "
sprintf("%-+20d", 123) #=> "+123                "
sprintf("%- 20d", 123) #=> " 123                "
sprintf("%020x", -123) #=> "..ffffffffffffffff85"

Для числовых полей точность контролирует количество десятичных знаков, отображаемых. Для строковых полей точность определяет максимальное количество символов, копируемых из строки. (Таким образом, последовательность формата %10.10s всегда добавляет ровно десять символов в результат.)

Примеры точностей:

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

Примеры:

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"

Для более сложного форматирования Ruby поддерживает ссылки по имени. Стиль %<name>s использует стиль форматирования, но %{name} — нет.

Примеры:

sprintf("%<foo>d : %<bar>f", { :foo => 1, :bar => 2 })
  #=> 1 : 2.000000
sprintf("%{foo}f", { :foo => 1 })
  # => "1f"

srand(number = Random.new_seed) → old_seed Показать исходный код

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

Инициализирует генератор псевдослучайных чисел системы, Random::DEFAULT, значением number. Возвращает предыдущее значение генератора.

Если number опущено, инициализирует генератор, используя источник энтропии, предоставляемый операционной системой (если доступен — /dev/urandom на системах Unix или криптографический модуль RSA на Windows), который затем комбинируется со временем, идентификатором процесса и порядковым номером.

srand можно использовать для обеспечения повторяемости последовательностей псевдослучайных чисел при разных запусках программы. Установив seed на известное значение, можно сделать программы детерминированными во время тестирования.

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

sub(pattern, replacement) → $_ Показать исходный код

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

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

Эквивалентно $_.sub(args), за исключением того, что $_ будет обновлён, если произойдёт подстановка. Доступно только при указании опций командной строки -p/-n.

syscall(num [, args...]) → integer Показать исходный код

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
}

Вызывает функцию операционной системы, идентифицированную значением num, и возвращает результат функции или вызывает исключение SystemCallError, если произошла ошибка.

Аргументы функции могут следовать за num. Они должны быть либо объектами String, либо объектами Integer. Объект String передаётся как указатель на последовательность байтов. Объект Integer передаётся как целое число, размер которого в битах совпадает с размером указателя. Можно передать до девяти параметров.

Функция, идентифицированная значением num, зависит от операционной системы. На некоторых системах Unix номера можно получить из заголовочного файла под названием syscall.h.

syscall 4, 1, "hello\n", 6   # '4' is write(2) on our box

выводит:

hello

Вызов syscall на платформе, которая не предоставляет механизма вызова произвольной системной функции, завершается ошибкой с исключением NotImplementedError.

Примечание: syscall по своей сути небезопасен и непереносим. Чувствуйте себя свободно, чтобы использовать его. Для более безопасной и переносимой работы предпочтите библиотеку DL (Fiddle).

system([env,] command... [,options]) → true, false or nil Показать исходный код

static VALUE
rb_f_system(int argc, VALUE *argv)
{
    /*
     * n.b. using alloca for now to simplify future Thread::Light code
     * when we need to use malloc for non-native Fiber
     */
    struct waitpid_state *w = alloca(sizeof(struct waitpid_state));
    rb_pid_t pid; /* may be different from waitpid_state.pid on exec failure */
    VALUE execarg_obj;
    struct rb_execarg *eargp;
    int exec_errnum;

    execarg_obj = rb_execarg_new(argc, argv, TRUE, TRUE);
    eargp = rb_execarg_get(execarg_obj);
    w->ec = GET_EC();
    waitpid_state_init(w, 0, 0);
    eargp->waitpid_state = w;
    pid = rb_execarg_spawn(execarg_obj, 0, 0);
    exec_errnum = pid < 0 ? errno : 0;

#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV)
    if (w->pid > 0) {
        /* `pid' (not w->pid) may be < 0 here if execve failed in child */
        if (WAITPID_USE_SIGCHLD) {
            rb_ensure(waitpid_sleep, (VALUE)w, waitpid_cleanup, (VALUE)w);
        }
        else {
            waitpid_no_SIGCHLD(w);
        }
        rb_last_status_set(w->status, w->ret);
    }
#endif
    if (w->pid < 0 /* fork failure */ || pid < 0 /* exec failure */) {
        if (eargp->exception) {
            int err = exec_errnum ? exec_errnum : w->errnum;
            VALUE command = eargp->invoke.sh.shell_script;
            RB_GC_GUARD(execarg_obj);
            rb_syserr_fail_str(err, command);
        }
        else {
            return Qnil;
        }
    }
    if (w->status == EXIT_SUCCESS) return Qtrue;
    if (eargp->exception) {
        VALUE command = eargp->invoke.sh.shell_script;
        VALUE str = rb_str_new_cstr("Command failed with");
        rb_str_cat_cstr(pst_message_status(str, w->status), ": ");
        rb_str_append(str, command);
        RB_GC_GUARD(execarg_obj);
        rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, str));
    }
    else {
        return Qfalse;
    }
}

Выполняет command… в дочерней оболочке. command… имеет один из следующих форматов.

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 возвращает true, если команда завершилась с нулевым кодом выхода, false в противном случае. Возвращает nil при неудачном выполнении команды. Статус ошибки доступен в $?. Аргументы обрабатываются так же, как и для Kernel.spawn.

Аргументы в виде хэша, env и options, аналогичны exec и spawn. Подробности см. в Kernel.spawn.

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

Результат:

config.h main.rb
*

См. Kernel.exec для стандартной оболочки.

test(cmd, file1 [, file2] ) → obj Показать исходный код

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

Использует символ cmd для выполнения различных проверок на file1 (первая таблица ниже) или на file1 и file2 (вторая таблица).

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

Проверки, требующие два файла:

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

throw(tag [, obj]) Показать исходный код

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_RETURN(Qnil);
}

Передает управление в конец активного блока catch в ожидании tag. Вызывает UncaughtThrowError если нет блока catch для tag. Дополнительный второй параметр предоставляет возвращаемое значение для блока catch, в противном случае по умолчанию используется nil. Примеры см. в Kernel::catch.

trace_var(symbol, cmd ) → nil Показать исходный код

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

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

Управляет отслеживанием присваиваний глобальным переменным. Параметр symbol определяет переменную (как имя строки или идентификатор символа). cmd (который может быть строкой или объектом Proc) или блок выполняется всякий раз, когда переменной присваивается значение. Блок или объект Proc получает новое значение переменной в качестве параметра. Также см. Kernel::untrace_var.

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

Результат:

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

trap( signal, command ) → obj Показать исходный код

trap( signal ) {| | block } → obj

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

Устанавливает обработку сигналов. Первый параметр — имя сигнала (строка, например, «SIGALRM», «SIGUSR1» и т. д.) или номер сигнала. Символы «SIG» могут быть опущены из имени сигнала. Команда или блок определяют код, который будет выполняться при возникновении сигнала. Если команда — строка «IGNORE» или «SIG_IGN», сигнал будет проигнорирован. Если команда — «DEFAULT» или «SIG_DFL», будет вызвана обработчик по умолчанию Ruby. Если команда — «EXIT», сценарий будет завершён сигналом. Если команда — «SYSTEM_DEFAULT», будет вызвана обработчик по умолчанию операционной системы. В противном случае будет выполнена заданная команда или блок. Специальное имя сигнала «EXIT» или номер сигнала ноль будут вызваны непосредственно перед завершением программы. trap возвращает предыдущий обработчик для данного сигнала.

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

Результат:

Terminating: 27461
Child died
Terminating: 27460

untrace_var(symbol [, cmd] ) → array or nil Показать исходный код

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

Удаляет отслеживание для указанной команды по заданной глобальной переменной и возвращает nil. Если команда не указана, удаляет все отслеживание для этой переменной и возвращает массив, содержащий команды, которые были удалены.

warn(msg, ...) → nil Показать исходный код

static VALUE
rb_warn_m(int argc, VALUE *argv, VALUE exc)
{
    VALUE opts, location = Qnil;

    if (!NIL_P(ruby_verbose) && argc > 0 &&
            (argc = rb_scan_args(argc, argv, "*:", NULL, &opts)) > 0) {
        VALUE str = argv[0], uplevel = Qnil;
        if (!NIL_P(opts)) {
            static ID kwds[1];
            if (!kwds[0]) {
                CONST_ID(kwds[0], "uplevel");
            }
            rb_get_kwargs(opts, kwds, 0, 1, &uplevel);
            if (uplevel == Qundef) {
                uplevel = Qnil;
            }
            else if (!NIL_P(uplevel)) {
                VALUE args[2];
                long lev = NUM2LONG(uplevel);
                if (lev < 0) {
                    rb_raise(rb_eArgError, "negative level (%ld)", lev);
                }
                args[0] = LONG2NUM(lev + 1);
                args[1] = INT2FIX(1);
                location = rb_vm_thread_backtrace_locations(2, args, GET_THREAD()->self);
                if (!NIL_P(location)) {
                    location = rb_ary_entry(location, 0);
                }
            }
        }
        if (argc > 1 || !NIL_P(uplevel) || !end_with_asciichar(str, '\n')) {
            VALUE path;
            if (NIL_P(uplevel)) {
                str = rb_str_tmp_new(0);
            }
            else if (NIL_P(location) ||
                     NIL_P(path = rb_funcall(location, rb_intern("path"), 0))) {
                str = rb_str_new_cstr("warning: ");
            }
            else {
                str = rb_sprintf("%s:%ld: warning: ",
                    rb_string_value_ptr(&path),
                    NUM2LONG(rb_funcall(location, rb_intern("lineno"), 0)));
            }
            RBASIC_SET_CLASS(str, rb_cWarningBuffer);
            rb_io_puts(argc, argv, str);
            RBASIC_SET_CLASS(str, rb_cString);
        }
        if (exc == rb_mWarning) {
            rb_must_asciicompat(str);
            rb_write_error_str(str);
        }
        else {
            rb_write_warning_str(str);
        }
    }
    return Qnil;
}

Если предупреждения отключены (например, с флагом -W0), ничего не делает. В противном случае преобразует каждое сообщение в строки, добавляет символ новой строки к строке, если строка не заканчивается символом новой строки, и вызывает Warning.warn со строкой.

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

<em>produces:</em>

  warning 1
  warning 2

Если указан ключевой аргумент uplevel, строка будет дополнена информацией о данном кадре вызывающей функции в том же формате, что и функция rb_warn C.

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

  def bar
    foo
  end

  bar

<em>produces:</em>

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

Методы экземпляра (приватные)

JSON(object, *args) Показать исходный код

# 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

Если object является строкой, то разобрать строку и вернуть результат разбора в виде структуры данных Ruby. В противном случае, сгенерировать строку JSON из объекта структуры данных Ruby и вернуть её.

Аргумент opts передаётся в функцию generate/parse соответственно. Смотрите документацию generate и parse для получения подробностей.

URI(uri) Показать исходный код

# File lib/uri/common.rb, line 733
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

Возвращает uri, преобразованный в объект URI.

gem(gem_name, *requirements) Показать исходный код

# File lib/rubygems/core_ext/kernel_gem.rb, line 44
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

Используйте Kernel#gem для активации определённой версии gem_name.

requirements — это список требований к версии, которым должна соответствовать указанная жемчужина, чаще всего «= example.version.number». Смотрите Gem::Requirement для получения информации о том, как указать требования к версии.

Если вы активируете последнюю версию жемчужины, нет необходимости вызывать Kernel#gem, Kernel#require сделает всё правильно за вас.

Kernel#gem возвращает true, если жемчужина была активирована, в противном случае — false. Если жемчужина не найдена, не соответствует требованиям к версии или уже активирована другая версия, будет поднято исключение.

Kernel#gem следует вызывать до любых инструкций require (в противном случае RubyGems может загрузить конфликтующую версию библиотеки).

Kernel#gem загружает только предварительные версии, когда указаны предварительные requirements:

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

В более старых версиях RubyGems переменная среды GEM_SKIP могла использоваться для пропуска активации указанных жемчужин, например, для тестирования изменений, которые ещё не были установлены. Теперь RubyGems использует -I и переменную среды RUBYLIB для пропуска активации жемчужины.

Пример:

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

j(*objs) Показать исходный код

# 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

Выводит objs в стандартный вывод как строки JSON в кратчайшей форме, то есть в одной строке.

jj(*objs) Показать исходный код

# 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

Выводит objs в стандартный вывод как строки JSON в красивом формате с отступами и на нескольких строках.

open(path [, mode [, perm]] [, opt]) → io or nil Показать исходный код

open(path [, mode [, perm]] [, opt]) {|io| block } → obj

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

Создаёт объект IO, подключённый к заданному потоку, файлу или подпроцессу.

mode — это либо строка, либо целое число. Если это целое число, оно должно быть битовым или открытым флагом open(2), таким как File::RDWR или File::EXCL. Если это строка, то она может быть «fmode», «fmode:ext_enc» или «fmode:ext_enc:int_enc».

См. документацию IO.new для получения полной документации по параметрам mode.

Если создаётся файл, его начальные разрешения можно задать с помощью параметра perm. Смотрите File.new и страницы руководства open(2) и chmod(2) для описания разрешений.

Если указан блок, он вызывается с объектом IO в качестве параметра, и объект IO автоматически закрывается по окончании блока. Вызов возвращает значение блока.

Если path начинается с символа трубы ("|"), создаётся подпроцесс, подключённый к вызывающему процессу через пару каналов.

Если команда после символа трубы — одиночный дефис ("|-"), Ruby раздваивается, и этот подпроцесс подключается к родителю. Если команда не "-", подпроцесс выполняет команду.

Когда подпроцесс — Ruby (открыт через "|-"), вызов open возвращает nil. Если с вызовом open связан блок, этот блок будет выполнен дважды — один раз в родительском процессе и один раз в дочернем.

Параметр блока будет объектом IO в родительском процессе и nil в дочернем. Объект IO родительского процесса будет подключён к $stdin и $stdout дочернего процесса. Подпроцесс завершится по завершении блока.

Примеры

Чтение из «testfile»:

open("testfile") do |f|
  print f.gets
end

Результат:

This is line one

Открыть подпроцесс и прочитать его вывод:

cmd = open("|date")
print cmd.gets
cmd.close

Результат:

Wed Apr  9 08:56:31 CDT 2003

Открыть подпроцесс, выполняющий ту же программу Ruby:

f = open("|-", "w+")
if f.nil?
  puts "in Child"
  exit
else
  puts "Got: #{f.gets}"
end

Результат:

Got: in Child

Открыть подпроцесс, используя блок для получения объекта IO:

open "|-" do |f|
  if f then
    # parent process
    puts "Got: #{f.gets}"
  else
    # child process
    puts "in Child"
  end
end

Результат:

Got: in Child

Также алиасы: open_uri_original_open, open_uri_original_open

open_uri_original_open(*args)

Псевдоним для: open

pp(*objs) Показать исходный код

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

выводит аргументы в красивом виде.

pp возвращает аргументы.

Также алиасы: pp

require(path) Показать исходный код

# File lib/rubygems/core_ext/kernel_require.rb, line 34
def require(path)
  RUBYGEMS_ACTIVATION_MONITOR.enter

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

  if spec = Gem.find_unresolved_default_spec(path)
    Gem.remove_unresolved_default_spec(spec)
    begin
      Kernel.send(:gem, spec.name)
    rescue Exception
      RUBYGEMS_ACTIVATION_MONITOR.exit
      raise
    end
  end

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

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

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

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

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

  found_specs = Gem::Specification.find_in_unresolved path

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

    found_specs.each do |found_spec|
      found_spec.activate
    end

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

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

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

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

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

    valid.activate
  end

  RUBYGEMS_ACTIVATION_MONITOR.exit
  return gem_original_require(path)
rescue LoadError => load_error
  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))
      require_again = true
    end
  ensure
    RUBYGEMS_ACTIVATION_MONITOR.exit
  end

  return gem_original_require(path) if require_again

  raise load_error
end

При использовании RubyGems, Kernel#require заменяется собственным, который может загружать жемчужины по требованию.

Когда вы вызываете require 'x', происходит следующее:

Если файл можно загрузить из существующего пути загрузки Ruby, это делается.
В противном случае, ищутся установленные жемчужины для файла, который соответствует. Если он найден в gem 'y', эта жемчужина активируется (добавляется в путь загрузки).

Сохраняется обычная функциональность require возвращения false, если этот файл уже загружен.

Также алиасы: gem_original_require

scanf(format, &b) Показать исходный код

# File lib/scanf.rb, line 773
def scanf(format, &b) #:doc:
  STDIN.scanf(format ,&b)
end

Сканирует стандартный ввод на предмет данных, соответствующих format. См. IO#scanf для получения подробностей.

См. Scanf для получения подробностей о создании строки формата.

Вам необходимо выполнить require 'scanf', чтобы использовать Kernel#scanf.

y(*objects) Показать исходный код

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

Псевдоним для Psych.dump_stream, предназначенный для использования с IRB.

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.