static VALUE
readline_s_get_basic_quote_characters(VALUE self)
{
    if (rl_basic_quote_characters == NULL)
        return Qnil;
    return rb_locale_str_new_cstr(rl_basic_quote_characters);
}

Возвращает список символов кавычек, которые могут вызвать разрыв слова.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает.

static VALUE
readline_s_set_basic_quote_characters(VALUE self, VALUE str)
{
    static char *basic_quote_characters = NULL;

    OutputStringValue(str);
    if (basic_quote_characters == NULL) {
        basic_quote_characters =
            ALLOC_N(char, RSTRING_LEN(str) + 1);
    }
    else {
        REALLOC_N(basic_quote_characters, char, RSTRING_LEN(str) + 1);
    }
    strncpy(basic_quote_characters,
            RSTRING_PTR(str), RSTRING_LEN(str));
    basic_quote_characters[RSTRING_LEN(str)] = '\0';
    rl_basic_quote_characters = basic_quote_characters;

    return self;
}

Устанавливает список символов кавычек, которые могут вызвать разрыв слова.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает.

static VALUE
readline_s_get_basic_word_break_characters(VALUE self)
{
    if (rl_basic_word_break_characters == NULL)
        return Qnil;
    return rb_locale_str_new_cstr(rl_basic_word_break_characters);
}

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

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает.

static VALUE
readline_s_set_basic_word_break_characters(VALUE self, VALUE str)
{
    static char *basic_word_break_characters = NULL;

    OutputStringValue(str);
    if (basic_word_break_characters == NULL) {
        basic_word_break_characters =
            ALLOC_N(char, RSTRING_LEN(str) + 1);
    }
    else {
        REALLOC_N(basic_word_break_characters, char, RSTRING_LEN(str) + 1);
    }
    strncpy(basic_word_break_characters,
            RSTRING_PTR(str), RSTRING_LEN(str));
    basic_word_break_characters[RSTRING_LEN(str)] = '\0';
    rl_basic_word_break_characters = basic_word_break_characters;
    return self;
}

Устанавливает базовый список символов, которые сигнализируют о разрыве между словами для процедуры автодополнения. По умолчанию это символы, которые разделяют слова для автодополнения в Bash: “ tn"\'`@$><=;|&{(”.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает.

static VALUE
readline_s_get_completer_quote_characters(VALUE self)
{
    if (rl_completer_quote_characters == NULL)
        return Qnil;
    return rb_locale_str_new_cstr(rl_completer_quote_characters);
}

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

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает.

static VALUE
readline_s_set_completer_quote_characters(VALUE self, VALUE str)
{
    static char *completer_quote_characters = NULL;

    OutputStringValue(str);
    if (completer_quote_characters == NULL) {
        completer_quote_characters =
            ALLOC_N(char, RSTRING_LEN(str) + 1);
    }
    else {
        REALLOC_N(completer_quote_characters, char, RSTRING_LEN(str) + 1);
    }
    strncpy(completer_quote_characters, RSTRING_PTR(str), RSTRING_LEN(str));
    completer_quote_characters[RSTRING_LEN(str)] = '\0';
    rl_completer_quote_characters = completer_quote_characters;

    return self;
}

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

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает.

static VALUE
readline_s_get_completer_word_break_characters(VALUE self)
{
    if (rl_completer_word_break_characters == NULL)
        return Qnil;
    return rb_locale_str_new_cstr(rl_completer_word_break_characters);
}

Возвращает базовый список символов, которые сигнализируют о разрыве между словами для rl_complete_internal().

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает.

static VALUE
readline_s_set_completer_word_break_characters(VALUE self, VALUE str)
{
    static char *completer_word_break_characters = NULL;

    OutputStringValue(str);
    if (completer_word_break_characters == NULL) {
        completer_word_break_characters =
            ALLOC_N(char, RSTRING_LEN(str) + 1);
    }
    else {
        REALLOC_N(completer_word_break_characters, char, RSTRING_LEN(str) + 1);
    }
    strncpy(completer_word_break_characters,
            RSTRING_PTR(str), RSTRING_LEN(str));
    completer_word_break_characters[RSTRING_LEN(str)] = '\0';
    rl_completer_word_break_characters = completer_word_break_characters;
    return self;
}

Устанавливает базовый список символов, которые сигнализируют о разрыве между словами для rl_complete_internal(). По умолчанию это значение Readline.basic_word_break_characters.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает.

static VALUE
readline_s_get_completion_append_character(VALUE self)
{
    char buf[1];

    if (rl_completion_append_character == '\0')
        return Qnil;

    buf[0] = (char) rl_completion_append_character;
    return rb_locale_str_new(buf, 1);
}

Возвращает строку, содержащую символ, который будет добавлен при автодополнении. По умолчанию это пробел (“ ”).

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает.

static VALUE
readline_s_set_completion_append_character(VALUE self, VALUE str)
{
    if (NIL_P(str)) {
        rl_completion_append_character = '\0';
    }
    else {
        OutputStringValue(str);
        if (RSTRING_LEN(str) == 0) {
            rl_completion_append_character = '\0';
        } else {
            rl_completion_append_character = RSTRING_PTR(str)[0];
        }
    }
    return self;
}

Указывает символ, который будет добавлен при автодополнении. Ничего не будет добавлено, если указана пустая строка (“”) или nil.

Например:

require "readline"

Readline.readline("> ", true)
Readline.completion_append_character = " "

Результат:

>
Input "/var/li".

> /var/li
Press TAB key.

> /var/lib
Completes "b" and appends " ". So, you can continuously input "/usr".

> /var/lib /usr

ПРИМЕЧАНИЕ: Можно указать только один символ. Когда указана “строка”, устанавливается только “с”, то есть первый.

require "readline"

Readline.completion_append_character = "string"
p Readline.completion_append_character # => "s"

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает.

static VALUE
readline_s_get_completion_case_fold(VALUE self)
{
    return rb_attr_get(mReadline, completion_case_fold);
}

Возвращает true, если автодополнение игнорирует регистр. В противном случае возвращает false.

ПРИМЕЧАНИЕ: Возвращает тот же объект, который указан методом Readline.completion_case_fold=.

require "readline"

Readline.completion_case_fold = "This is a String."
p Readline.completion_case_fold # => "This is a String."

static VALUE
readline_s_set_completion_case_fold(VALUE self, VALUE val)
{
    return rb_ivar_set(mReadline, completion_case_fold, val);
}

Устанавливает, игнорировать ли регистр при автодополнении.

static VALUE
readline_s_get_completion_proc(VALUE self)
{
    return rb_attr_get(mReadline, completion_proc);
}

Возвращает объект Proc автодополнения.

static VALUE
readline_s_set_completion_proc(VALUE self, VALUE proc)
{
    mustbe_callable(proc);
    return rb_ivar_set(mReadline, completion_proc, proc);
}

Указывает объект Proc proc для определения поведения автодополнения. Он должен принимать входную строку и возвращать массив кандидатов для автодополнения.

Если proc равно nil, используется автодополнение по умолчанию.

Строка String, передаваемая в Proc, зависит от свойства Readline.completer_word_break_characters. По умолчанию в Proc передаётся слово под курсором. Например, если входные данные — “foo bar”, то в процедуру автодополнения Proc будет передано только “bar”.

После успешного автодополнения Readline.completion_append_character будет добавлен ко входу, чтобы пользователь мог начать работу со своим следующим аргументом.

Примеры

Автодополнение для статического списка

require 'readline'

LIST = [
  'search', 'download', 'open',
  'help', 'history', 'quit',
  'url', 'next', 'clear',
  'prev', 'past'
].sort

comp = proc { |s| LIST.grep(/^#{Regexp.escape(s)}/) }

Readline.completion_append_character = " "
Readline.completion_proc = comp

while line = Readline.readline('> ', true)
  p line
end

Автодополнение для содержимого каталога

require 'readline'

Readline.completion_append_character = " "
Readline.completion_proc = Proc.new do |str|
  Dir[str+'*'].grep(/^#{Regexp.escape(str)}/)
end

while line = Readline.readline('> ', true)
  p line
end

Стратегии автодополнения

При работе с автодополнением существуют некоторые хорошо работающие стратегии. Чтобы получить некоторые идеи, вы можете взглянуть на файл completion.rb для irb.

Распространенная стратегия заключается в том, чтобы взять список возможных вариантов автодополнения и отфильтровать его до тех вариантов, которые начинаются с пользовательского ввода. В приведенных выше примерах используется Enumerator.grep. Ввод экранируется, чтобы предотвратить вмешательство специальных символов Regexp в сопоставление.

Также может быть полезно использовать библиотеку Abbrev для генерации вариантов автодополнения.

Вызывает ArgumentError, если proc не отвечает на вызов метода.

static VALUE
readline_s_get_completion_quote_character(VALUE self)
{
    char buf[1];

    if (rl_completion_quote_character == '\0')
        return Qnil;

    buf[0] = (char) rl_completion_quote_character;
    return rb_locale_str_new(buf, 1);
}

При вызове во время автодополнения (например, изнутри вашего completion_proc), он вернет строку, содержащую символ, используемый для заключения в кавычки аргумента, который дополняется, или nil, если аргумент не заключен в кавычки.

При вызове в другое время он всегда будет возвращать nil.

Обратите внимание, что Readline.completer_quote_characters должен быть установлен, иначе этот метод всегда будет возвращать nil.

static VALUE
readline_s_delete_text(int argc, VALUE *argv, VALUE self)
{
    rb_check_arity(argc, 0, 2);
    if (rl_line_buffer) {
        const char *p, *ptr = rl_line_buffer;
        long beg = 0, len = strlen(ptr);
        const char *end = ptr + len;
        rb_encoding *enc = rb_locale_encoding();
        if (argc == 2) {
            beg = NUM2LONG(argv[0]);
            len = NUM2LONG(argv[1]);
          num_pos:
            p = str_subpos(ptr, end, beg, &len, enc);
            if (!p) rb_raise(rb_eArgError, "invalid index");
            beg = p - ptr;
        }
        else if (argc == 1) {
            len = rb_enc_strlen(ptr, ptr + len, enc);
            if (!rb_range_beg_len(argv[0], &beg, &len, len, 1)) {
                beg = NUM2LONG(argv[0]);
                goto num_pos;
            }
        }
        rl_delete_text(rb_long2int(beg), rb_long2int(beg + len));
    }
    return self;
}

Удалить текст между start и end в текущей строке.

См. функцию rl_delete_text из GNU Readline.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_emacs_editing_mode(VALUE self)
{
    rl_emacs_editing_mode(1,0);
    return Qnil;
}

Устанавливает режим редактирования Emacs. По умолчанию используется этот режим. См. руководство по GNU Readline для подробностей о режиме редактирования Emacs.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_emacs_editing_mode_p(VALUE self)
{
    return rl_editing_mode == 1 ? Qtrue : Qfalse;
}

Возвращает true, если режим emacs активен, и false, если нет.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_get_filename_quote_characters(VALUE self)
{
    if (rl_filename_quote_characters == NULL)
        return Qnil;
    return rb_locale_str_new_cstr(rl_filename_quote_characters);
}

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

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_set_filename_quote_characters(VALUE self, VALUE str)
{
    static char *filename_quote_characters = NULL;

    OutputStringValue(str);
    if (filename_quote_characters == NULL) {
        filename_quote_characters =
            ALLOC_N(char, RSTRING_LEN(str) + 1);
    }
    else {
        REALLOC_N(filename_quote_characters, char, RSTRING_LEN(str) + 1);
    }
    strncpy(filename_quote_characters, RSTRING_PTR(str), RSTRING_LEN(str));
    filename_quote_characters[RSTRING_LEN(str)] = '\0';
    rl_filename_quote_characters = filename_quote_characters;

    return self;
}

Устанавливает список символов, которые заставляют оболочку цитировать имя файла при появлении в завершённом имени файла. По умолчанию значение nil.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_get_screen_size(VALUE self)
{
    int rows, columns;
    VALUE res;

    rl_get_screen_size(&rows, &columns);
    res = rb_ary_new();
    rb_ary_push(res, INT2NUM(rows));
    rb_ary_push(res, INT2NUM(columns));
    return res;
}

Возвращает количество строк и столбцов терминала.

См. функцию rl_get_screen_size из GNU Readline.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_set_input(VALUE self, VALUE input)
{
    rb_io_t *ifp;
    int fd;
    FILE *f;

    if (NIL_P(input)) {
        clear_rl_instream();
    }
    else {
        Check_Type(input, T_FILE);
        GetOpenFile(input, ifp);
        clear_rl_instream();
        fd = rb_cloexec_dup(ifp->fd);
        if (fd == -1)
            rb_sys_fail("dup");
        f = fdopen(fd, "r");
        if (f == NULL) {
            int save_errno = errno;
            close(fd);
            rb_syserr_fail(save_errno, "fdopen");
        }
        rl_instream = readline_rl_instream = f;
        readline_instream = input;
    }
    return input;
}

Устанавливает объект File input, который является потоком ввода для метода Readline.readline.

static VALUE
readline_s_insert_text(VALUE self, VALUE str)
{
    OutputStringValue(str);
    rl_insert_text(RSTRING_PTR(str));
    return self;
}

Вставить текст в строку в текущей позиции курсора.

См. функцию rl_insert_text из GNU Readline.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_get_line_buffer(VALUE self)
{
    if (rl_line_buffer == NULL)
        return Qnil;
    return rb_locale_str_new_cstr(rl_line_buffer);
}

Возвращает полную строку, которая редактируется. Это полезно внутри complete_proc для определения контекста запроса завершения.

Длина Readline.line_buffer и rl_end из GNU Readline совпадают.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_set_output(VALUE self, VALUE output)
{
    rb_io_t *ofp;
    int fd;
    FILE *f;

    if (NIL_P(output)) {
        clear_rl_outstream();
    }
    else {
        Check_Type(output, T_FILE);
        GetOpenFile(output, ofp);
        clear_rl_outstream();
        fd = rb_cloexec_dup(ofp->fd);
        if (fd == -1)
            rb_sys_fail("dup");
        f = fdopen(fd, "w");
        if (f == NULL) {
            int save_errno = errno;
            close(fd);
            rb_syserr_fail(save_errno, "fdopen");
        }
        rl_outstream = readline_rl_outstream = f;
        readline_outstream = output;
    }
    return output;
}

Устанавливает объект File output, который является потоком вывода для метода Readline.readline.

static VALUE
readline_s_get_point(VALUE self)
{
    return INT2NUM(rl_point);
}

Возвращает индекс текущей позиции курсора в Readline.line_buffer.

Индекс в Readline.line_buffer, который соответствует началу входной строки, переданной в completion_proc, вычисляется путём вычитания длины входной строки из Readline.point.

start = (the length of input-string) - Readline.point

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_set_point(VALUE self, VALUE pos)
{
    rl_point = NUM2INT(pos);
    return pos;
}

Устанавливает индекс текущей позиции курсора в Readline.line_buffer.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

См. Readline.point.

static VALUE
readline_s_get_pre_input_hook(VALUE self)
{
    return rb_attr_get(mReadline, id_pre_input_hook);
}

Возвращает объект Proc proc, который вызывается после вывода первого приглашения и непосредственно перед началом чтения входных символов readline. По умолчанию значение nil.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_set_pre_input_hook(VALUE self, VALUE proc)
{
    mustbe_callable(proc);
    return rb_ivar_set(mReadline, id_pre_input_hook, proc);
}

Устанавливает объект Proc proc, который вызывается после вывода первого приглашения и непосредственно перед началом чтения входных символов readline.

См. переменную rl_pre_input_hook из GNU Readline.

Вызывает ArgumentError, если proc не отвечает на вызов метода.

Вызывает NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_get_quoting_detection_proc(VALUE self)
{
    return rb_attr_get(mReadline, quoting_detection_proc);
}

Возвращает объект-процедуру для обнаружения цитирования.

static VALUE
readline_s_set_quoting_detection_proc(VALUE self, VALUE proc)
{
    mustbe_callable(proc);
    return rb_ivar_set(mReadline, quoting_detection_proc, proc);
}

Устанавливает объект-процедуру Proc proc для определения, экранирован ли символ в пользовательском вводе. Она должна принимать пользовательский ввод и индекс интересующего символа в качестве входных данных и возвращать логическое значение (true, если указанный символ экранирован).

Readline вызовет эту процедуру только для символов, указанных в completer_quote_characters, чтобы определить, указывают ли они на конец цитируемого аргумента, или символов, указанных в completer_word_break_characters, чтобы определить, указывают ли они на разрыв между аргументами.

Если completer_quote_characters не задан или если пользовательский ввод не содержит одного из completer_quote_characters или символа ++, Readline не будет пытаться использовать эту процедуру.

Вызывает ArgumentError, если proc не отвечает на вызов метода.

static VALUE
readline_readline(int argc, VALUE *argv, VALUE self)
{
    VALUE tmp, add_hist, result;
    char *prompt = NULL;
    char *buff;
    int status;

    if (rb_scan_args(argc, argv, "02", &tmp, &add_hist) > 0) {
        OutputStringValue(tmp);
#if USE_INSERT_IGNORE_ESCAPE
        tmp = insert_ignore_escape(self, tmp);
        rb_str_locktmp(tmp);
#endif
        prompt = RSTRING_PTR(tmp);
    }

    prepare_readline();

#ifdef _WIN32
    rl_prep_terminal(1);
#endif
    buff = (char*)rb_protect(readline_get, (VALUE)prompt, &status);
#if USE_INSERT_IGNORE_ESCAPE
    if (prompt) {
        rb_str_unlocktmp(tmp);
    }
#endif
    if (status) {
#if defined HAVE_RL_CLEANUP_AFTER_SIGNAL
        /* restore terminal mode and signal handler*/
#if defined HAVE_RL_FREE_LINE_STATE
        rl_free_line_state();
#endif
        rl_cleanup_after_signal();
#elif defined HAVE_RL_DEPREP_TERM_FUNCTION
        /* restore terminal mode */
        if (rl_deprep_term_function != NULL) /* NULL in libedit. [ruby-dev:29116] */
            (*rl_deprep_term_function)();
        else
#else
        rl_deprep_terminal();
#endif
        rb_jump_tag(status);
    }

    if (RTEST(add_hist) && buff) {
        add_history(buff);
    }
    if (buff) {
        result = rb_locale_str_new_cstr(buff);
    }
    else
        result = Qnil;
    if (buff) free(buff);
    return result;
}

Отображает prompt и считывает введённую строку с редактированием. Введённая строка добавляется в историю, если add_hist равно true.

Возвращает nil, когда введённая строка пустая и пользователь ввёл EOF (нажал ^D в UNIX).

Возникает исключение IOError, если выполняется одно из следующих условий.

1. stdin был закрыт.

2. stdout был закрыт.

Этот метод поддерживает потоки. Переключает контекст потока, когда ждёт ввода строки.

Поддерживает редактирование ввода строки. Предоставляет режимы редактирования VI и Emacs. По умолчанию используется режим редактирования Emacs.

ПРИМЕЧАНИЕ: Завершает интерпретатор ruby и не возвращает статус терминала после нажатия пользователем '^C' во время ожидания ввода строки. Ниже приведены 3 примера, которые этого избегают.

• Обрабатывает исключение Interrupt при нажатии ^C после возврата статуса терминала:

  require "readline"
  
  stty_save = `stty -g`.chomp
  begin
    while buf = Readline.readline
        p buf
        end
      rescue Interrupt
        system("stty", stty_save)
        exit
      end
    end
  end

• Обрабатывает сигнал INT при нажатии ^C после возврата статуса терминала:

  require "readline"
  
  stty_save = `stty -g`.chomp
  trap("INT") { system "stty", stty_save; exit }
  
  while buf = Readline.readline
    p buf
  end
  

• Игнорирует нажатие ^C:

  require "readline"
  
  trap("INT", "SIG_IGN")
  
  while buf = Readline.readline
    p buf
  end
  

Можно использовать константу Readline::HISTORY для следующих действий. Она не записывает в историю пустые строки или строки, совпадающие с последней введённой.

require "readline"

while buf = Readline.readline("> ", true)
  # p Readline::HISTORY.to_a
  Readline::HISTORY.pop if /^\s*$/ =~ buf

  begin
    if Readline::HISTORY[Readline::HISTORY.length-2] == buf
      Readline::HISTORY.pop
    end
  rescue IndexError
  end

  # p Readline::HISTORY.to_a
  print "-> ", buf, "\n"
end

static VALUE
readline_s_redisplay(VALUE self)
{
    rl_redisplay();
    return self;
}

Изменяет отображаемое на экране содержимое, чтобы отразить текущее состояние.

См. функцию rl_redisplay из GNU Readline.

Возникает исключение NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_refresh_line(VALUE self)
{
    prepare_readline();
    rl_refresh_line(0, 0);
    return Qnil;
}

Очищает текущую строку ввода.

static VALUE
readline_s_set_screen_size(VALUE self, VALUE rows, VALUE columns)
{
    rl_set_screen_size(NUM2INT(rows), NUM2INT(columns));
    return self;
}

Устанавливает размер терминала на rows и columns.

См. функцию rl_set_screen_size из GNU Readline.

Возникает исключение NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_get_special_prefixes(VALUE self)
{
    VALUE str;
    if (rl_special_prefixes == NULL) return Qnil;
    str = rb_ivar_get(mReadline, id_special_prefixes);
    if (!NIL_P(str)) {
        str = rb_str_dup_frozen(str);
        rb_obj_reveal(str, rb_cString);
    }
    return str;
}

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

См. переменную rl_special_prefixes из GNU Readline.

Возникает исключение NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_set_special_prefixes(VALUE self, VALUE str)
{
    if (!NIL_P(str)) {
        OutputStringValue(str);
        str = rb_str_dup_frozen(str);
        rb_obj_hide(str);
    }
    rb_ivar_set(mReadline, id_special_prefixes, str);
    if (NIL_P(str)) {
        rl_special_prefixes = NULL;
    }
    else {
        rl_special_prefixes = RSTRING_PTR(str);
    }
    return self;
}

Устанавливает список символов, которые являются разделителями слов, но должны оставаться в тексте при передаче в функцию автодополнения. Программы могут использовать это, чтобы определить, какой тип автодополнения использовать. Например, Bash устанавливает эту переменную в «$@», чтобы иметь возможность дополнять переменные оболочки и имена хостов.

См. переменную rl_special_prefixes из GNU Readline.

Возникает исключение NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_vi_editing_mode(VALUE self)
{
    rl_vi_editing_mode(1,0);
    return Qnil;
}

Устанавливает режим редактирования VI. Подробнее о режиме редактирования VI см. в документации к GNU Readline.

Возникает исключение NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.

static VALUE
readline_s_vi_editing_mode_p(VALUE self)
{
    return rl_editing_mode == 0 ? Qtrue : Qfalse;
}

Возвращает true, если режим vi активен. Возвращает false, если нет.

Возникает исключение NotImplementedError, если используемая библиотека readline не поддерживает эту функцию.