class StringIO

Pseudo I/O on String object.

Commonly used to simulate `$stdio` or `$stderr`

Examples ↑

require 'stringio'

io = StringIO.new
io.puts "Hello World"
io.string #=> "Hello World\n"

Public Class Methods

new(string=""[, mode]) click to toggle source

Creates new StringIO instance from with string and mode.

static VALUE
strio_initialize(int argc, VALUE *argv, VALUE self)
{
    struct StringIO *ptr = check_strio(self);

    if (!ptr) {
        DATA_PTR(self) = ptr = strio_alloc();
    }
    rb_call_super(0, 0);
    strio_init(argc, argv, ptr, self);
    return self;
}
open(string=""[, mode]) {|strio| ...} click to toggle source

Equivalent to StringIO.new except that when it is called with a block, it yields with the new instance and closes it, and returns the result which returned from the block.

static VALUE
strio_s_open(int argc, VALUE *argv, VALUE klass)
{
    VALUE obj = rb_class_new_instance(argc, argv, klass);
    if (!rb_block_given_p()) return obj;
    return rb_ensure(rb_yield, obj, strio_finalize, obj);
}

Public Instance Methods

binmode() click to toggle source 
static VALUE
strio_binmode(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    rb_encoding *enc = rb_ascii8bit_encoding();

    ptr->enc = enc;
    if (WRITABLE(self)) {
        rb_enc_associate(ptr->string, enc);
    }
    return self;
}
bytes() click to toggle source

This is a deprecated alias for each_byte.

static VALUE
strio_bytes(VALUE self)
{
    rb_warn("StringIO#bytes is deprecated; use #each_byte instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_byte")), 0, 0);
    return strio_each_byte(self);
}
chars() click to toggle source

This is a deprecated alias for each_char.

static VALUE
strio_chars(VALUE self)
{
    rb_warn("StringIO#chars is deprecated; use #each_char instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_char")), 0, 0);
    return strio_each_char(self);
}
close → nil click to toggle source

Closes strio. The strio is unavailable for any further data operations; an IOError is raised if such an attempt is made.

static VALUE
strio_close(VALUE self)
{
    StringIO(self);
    RBASIC(self)->flags &= ~STRIO_READWRITE;
    return Qnil;
}
close_read → nil click to toggle source

Closes the read end of a StringIO. Will raise an IOError if the strio is not readable.

static VALUE
strio_close_read(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    if (!(ptr->flags & FMODE_READABLE)) {
        rb_raise(rb_eIOError, "closing non-duplex IO for reading");
    }
    RBASIC(self)->flags &= ~STRIO_READABLE;
    return Qnil;
}
close_write → nil click to toggle source

Closes the write end of a StringIO. Will raise an IOError if the strio is not writeable.

static VALUE
strio_close_write(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    if (!(ptr->flags & FMODE_WRITABLE)) {
        rb_raise(rb_eIOError, "closing non-duplex IO for writing");
    }
    RBASIC(self)->flags &= ~STRIO_WRITABLE;
    return Qnil;
}
closed? → true or false click to toggle source

Returns true if strio is completely closed, false otherwise.

static VALUE
strio_closed(VALUE self)
{
    StringIO(self);
    if (!CLOSED(self)) return Qfalse;
    return Qtrue;
}
closed_read? → true or false click to toggle source

Returns true if strio is not readable, false otherwise.

static VALUE
strio_closed_read(VALUE self)
{
    StringIO(self);
    if (READABLE(self)) return Qfalse;
    return Qtrue;
}
closed_write? → true or false click to toggle source

Returns true if strio is not writable, false otherwise.

static VALUE
strio_closed_write(VALUE self)
{
    StringIO(self);
    if (WRITABLE(self)) return Qfalse;
    return Qtrue;
}
codepoints() click to toggle source

This is a deprecated alias for each_codepoint.

static VALUE
strio_codepoints(VALUE self)
{
    rb_warn("StringIO#codepoints is deprecated; use #each_codepoint instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_codepoint")), 0, 0);
    return strio_each_codepoint(self);
}
each(sep=$/) {|line| block } → strio click to toggle source
each(limit) {|line| block } → strio
each(sep, limit) {|line| block } → strio
each(...) → anEnumerator
each_line(sep=$/) {|line| block } → strio
each_line(limit) {|line| block } → strio
each_line(sep,limit) {|line| block } → strio
each_line(...) → anEnumerator

See IO#each.

static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
    VALUE line;

    StringIO(self);
    RETURN_ENUMERATOR(self, argc, argv);

    if (argc > 0 && !NIL_P(argv[argc-1]) && NIL_P(rb_check_string_type(argv[argc-1])) &&
        NUM2LONG(argv[argc-1]) == 0) {
        rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
    }

    while (!NIL_P(line = strio_getline(argc, argv, readable(self)))) {
        rb_yield(line);
    }
    return self;
}
each_byte {|byte| block } → strio click to toggle source
each_byte → anEnumerator

See IO#each_byte.

static VALUE
strio_each_byte(VALUE self)
{
    struct StringIO *ptr = readable(self);

    RETURN_ENUMERATOR(self, 0, 0);

    while (ptr->pos < RSTRING_LEN(ptr->string)) {
        char c = RSTRING_PTR(ptr->string)[ptr->pos++];
        rb_yield(CHR2FIX(c));
    }
    return self;
}
each_char {|char| block } → strio click to toggle source
each_char → anEnumerator

See IO#each_char.

static VALUE
strio_each_char(VALUE self)
{
    VALUE c;

    RETURN_ENUMERATOR(self, 0, 0);

    while (!NIL_P(c = strio_getc(self))) {
        rb_yield(c);
    }
    return self;
}
each_codepoint {|c| block } → strio click to toggle source
each_codepoint → anEnumerator

See IO#each_codepoint.

static VALUE
strio_each_codepoint(VALUE self)
{
    struct StringIO *ptr;
    rb_encoding *enc;
    unsigned int c;
    int n;

    RETURN_ENUMERATOR(self, 0, 0);

    ptr = readable(self);
    enc = get_enc(ptr);
    for (;;) {
        if (ptr->pos >= RSTRING_LEN(ptr->string)) {
            return self;
        }

        c = rb_enc_codepoint_len(RSTRING_PTR(ptr->string)+ptr->pos,
                                 RSTRING_END(ptr->string), &n, enc);
        rb_yield(UINT2NUM(c));
        ptr->pos += n;
    }
    return self;
}
each_line(sep=$/) {|line| block } → strio click to toggle source
each_line(limit) {|line| block } → strio
each_line(sep,limit) {|line| block } → strio
each_line(...) → anEnumerator

See IO#each.

static VALUE
strio_each(int argc, VALUE *argv, VALUE self)
{
    VALUE line;

    StringIO(self);
    RETURN_ENUMERATOR(self, argc, argv);

    if (argc > 0 && !NIL_P(argv[argc-1]) && NIL_P(rb_check_string_type(argv[argc-1])) &&
        NUM2LONG(argv[argc-1]) == 0) {
        rb_raise(rb_eArgError, "invalid limit: 0 for each_line");
    }

    while (!NIL_P(line = strio_getline(argc, argv, readable(self)))) {
        rb_yield(line);
    }
    return self;
}
eof → true or false click to toggle source
eof? → true or false

Returns true if strio is at end of file. The stringio must be opened for reading or an IOError will be raised.

static VALUE
strio_eof(VALUE self)
{
    struct StringIO *ptr = readable(self);
    if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
    return Qtrue;
}
eof? → true or false click to toggle source

Returns true if strio is at end of file. The stringio must be opened for reading or an IOError will be raised.

static VALUE
strio_eof(VALUE self)
{
    struct StringIO *ptr = readable(self);
    if (ptr->pos < RSTRING_LEN(ptr->string)) return Qfalse;
    return Qtrue;
}
external_encoding → encoding click to toggle source

Returns the Encoding object that represents the encoding of the file. If strio is write mode and no encoding is specified, returns nil.

static VALUE
strio_external_encoding(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    return rb_enc_from_encoding(get_enc(ptr));
}
fcntl(*args) click to toggle source

Raises NotImplementedError.

static VALUE
strio_unimpl(int argc, VALUE *argv, VALUE self)
{
    StringIO(self);
    rb_notimplement();

    UNREACHABLE;
}
fileno() click to toggle source

Returns nil. Just for compatibility to IO.

static VALUE
strio_nil(VALUE self)
{
    StringIO(self);
    return Qnil;
}
flush() click to toggle source

Returns strio itself. Just for compatibility to IO.

static VALUE
strio_self(VALUE self)
{
    StringIO(self);
    return self;
}
fsync() click to toggle source

Returns 0. Just for compatibility to IO.

static VALUE
strio_0(VALUE self)
{
    StringIO(self);
    return INT2FIX(0);
}
getbyte → fixnum or nil click to toggle source

See IO#getbyte.

static VALUE
strio_getbyte(VALUE self)
{
    struct StringIO *ptr = readable(self);
    int c;
    if (ptr->pos >= RSTRING_LEN(ptr->string)) {
        return Qnil;
    }
    c = RSTRING_PTR(ptr->string)[ptr->pos++];
    return CHR2FIX(c);
}
getc → string or nil click to toggle source

See IO#getc.

static VALUE
strio_getc(VALUE self)
{
    struct StringIO *ptr = readable(self);
    rb_encoding *enc = get_enc(ptr);
    int len;
    char *p;

    if (ptr->pos >= RSTRING_LEN(ptr->string)) {
        return Qnil;
    }
    p = RSTRING_PTR(ptr->string)+ptr->pos;
    len = rb_enc_mbclen(p, RSTRING_END(ptr->string), enc);
    ptr->pos += len;
    return rb_enc_str_new(p, len, enc);
}
gets(sep=$/) → string or nil click to toggle source
gets(limit) → string or nil
gets(sep, limit) → string or nil

See IO#gets.

static VALUE
strio_gets(int argc, VALUE *argv, VALUE self)
{
    VALUE str = strio_getline(argc, argv, readable(self));

    rb_lastline_set(str);
    return str;
}
internal_encoding → encoding click to toggle source

Returns the Encoding of the internal string if conversion is specified. Otherwise returns nil.

static VALUE
strio_internal_encoding(VALUE self)
{
     return Qnil;
}
isatty() click to toggle source

Returns false. Just for compatibility to IO.

static VALUE
strio_false(VALUE self)
{
    StringIO(self);
    return Qfalse;
}
length → integer click to toggle source

Returns the size of the buffer string.

static VALUE
strio_size(VALUE self)
{
    VALUE string = StringIO(self)->string;
    if (NIL_P(string)) {
        rb_raise(rb_eIOError, "not opened");
    }
    return ULONG2NUM(RSTRING_LEN(string));
}
lineno → integer click to toggle source

Returns the current line number in strio. The stringio must be opened for reading. lineno counts the number of times gets is called, rather than the number of newlines encountered. The two values will differ if gets is called with a separator other than newline. See also the $. variable.

static VALUE
strio_get_lineno(VALUE self)
{
    return LONG2NUM(StringIO(self)->lineno);
}
lineno = integer → integer click to toggle source

Manually sets the current line number to the given value. $. is updated only on the next read.

static VALUE
strio_set_lineno(VALUE self, VALUE lineno)
{
    StringIO(self)->lineno = NUM2LONG(lineno);
    return lineno;
}
lines(*args) click to toggle source

This is a deprecated alias for each_line.

static VALUE
strio_lines(int argc, VALUE *argv, VALUE self)
{
    rb_warn("StringIO#lines is deprecated; use #each_line instead");
    if (!rb_block_given_p())
        return rb_enumeratorize(self, ID2SYM(rb_intern("each_line")), argc, argv);
    return strio_each(argc, argv, self);
}
pid() click to toggle source

Returns nil. Just for compatibility to IO.

static VALUE
strio_nil(VALUE self)
{
    StringIO(self);
    return Qnil;
}
pos → integer click to toggle source
tell → integer

Returns the current offset (in bytes) of strio.

static VALUE
strio_get_pos(VALUE self)
{
    return LONG2NUM(StringIO(self)->pos);
}
pos = integer → integer click to toggle source

Seeks to the given position (in bytes) in strio.

static VALUE
strio_set_pos(VALUE self, VALUE pos)
{
    struct StringIO *ptr = StringIO(self);
    long p = NUM2LONG(pos);
    if (p < 0) {
        error_inval(0);
    }
    ptr->pos = p;
    return pos;
}
putc(obj) → obj click to toggle source

See IO#putc.

static VALUE
strio_putc(VALUE self, VALUE ch)
{
    struct StringIO *ptr = writable(self);
    VALUE str;

    check_modifiable(ptr);
    if (RB_TYPE_P(ch, T_STRING)) {
        str = rb_str_substr(ch, 0, 1);
    }
    else {
        char c = NUM2CHR(ch);
        str = rb_str_new(&c, 1);
    }
    strio_write(self, str);
    return ch;
}
read([length [, outbuf]]) → string, outbuf, or nil click to toggle source

See IO#read.

static VALUE
strio_read(int argc, VALUE *argv, VALUE self)
{
    struct StringIO *ptr = readable(self);
    VALUE str = Qnil;
    long len;
    int binary = 0;

    rb_check_arity(argc, 0, 2);
    switch (argc) {
      case 2:
        str = argv[1];
        if (!NIL_P(str)) {
            StringValue(str);
            rb_str_modify(str);
        }
      case 1:
        if (!NIL_P(argv[0])) {
            len = NUM2LONG(argv[0]);
            if (len < 0) {
                rb_raise(rb_eArgError, "negative length %ld given", len);
            }
            if (len > 0 && ptr->pos >= RSTRING_LEN(ptr->string)) {
                if (!NIL_P(str)) rb_str_resize(str, 0);
                return Qnil;
            }
            binary = 1;
            break;
        }
        /* fall through */
      case 0:
        len = RSTRING_LEN(ptr->string);
        if (len <= ptr->pos) {
            if (NIL_P(str)) {
                str = rb_str_new(0, 0);
            }
            else {
                rb_str_resize(str, 0);
            }
            return str;
        }
        else {
            len -= ptr->pos;
        }
        break;
    }
    if (NIL_P(str)) {
        str = strio_substr(ptr, ptr->pos, len);
        if (binary) rb_enc_associate(str, rb_ascii8bit_encoding());
    }
    else {
        long rest = RSTRING_LEN(ptr->string) - ptr->pos;
        if (len > rest) len = rest;
        rb_str_resize(str, len);
        MEMCPY(RSTRING_PTR(str), RSTRING_PTR(ptr->string) + ptr->pos, char, len);
        if (binary)
            rb_enc_associate(str, rb_ascii8bit_encoding());
        else
            rb_enc_copy(str, ptr->string);
    }
    ptr->pos += RSTRING_LEN(str);
    return str;
}
readlines(sep=$/) → array click to toggle source
readlines(limit) → array
readlines(sep,limit) → array

See IO#readlines.

static VALUE
strio_readlines(int argc, VALUE *argv, VALUE self)
{
    VALUE ary, line;

    StringIO(self);
    ary = rb_ary_new();
    if (argc > 0 && !NIL_P(argv[argc-1]) && NIL_P(rb_check_string_type(argv[argc-1])) &&
        NUM2LONG(argv[argc-1]) == 0) {
        rb_raise(rb_eArgError, "invalid limit: 0 for readlines");
    }

    while (!NIL_P(line = strio_getline(argc, argv, readable(self)))) {
        rb_ary_push(ary, line);
    }
    return ary;
}
reopen(other_StrIO) → strio click to toggle source
reopen(string, mode) → strio

Reinitializes strio with the given other_StrIO or string and mode (see StringIO#new).

static VALUE
strio_reopen(int argc, VALUE *argv, VALUE self)
{
    rb_io_taint_check(self);
    if (argc == 1 && !RB_TYPE_P(*argv, T_STRING)) {
        return strio_copy(self, *argv);
    }
    strio_init(argc, argv, StringIO(self), self);
    return self;
}
rewind → 0 click to toggle source

Positions strio to the beginning of input, resetting lineno to zero.

static VALUE
strio_rewind(VALUE self)
{
    struct StringIO *ptr = StringIO(self);
    ptr->pos = 0;
    ptr->lineno = 0;
    return INT2FIX(0);
}
seek(amount, whence=SEEK_SET) → 0 click to toggle source

Seeks to a given offset amount in the stream according to the value of whence (see IO#seek).

static VALUE
strio_seek(int argc, VALUE *argv, VALUE self)
{
    VALUE whence;
    struct StringIO *ptr = StringIO(self);
    long offset;

    rb_scan_args(argc, argv, "11", NULL, &whence);
    offset = NUM2LONG(argv[0]);
    if (CLOSED(self)) {
        rb_raise(rb_eIOError, "closed stream");
    }
    switch (NIL_P(whence) ? 0 : NUM2LONG(whence)) {
      case 0:
        break;
      case 1:
        offset += ptr->pos;
        break;
      case 2:
        offset += RSTRING_LEN(ptr->string);
        break;
      default:
        error_inval("invalid whence");
    }
    if (offset < 0) {
        error_inval(0);
    }
    ptr->pos = offset;
    return INT2FIX(0);
}
set_encoding(ext_enc, [int_enc[, opt]]) → strio click to toggle source

Specify the encoding of the StringIO as ext_enc. Use the default external encoding if ext_enc is nil. 2nd argument int_enc and optional hash opt argument are ignored; they are for API compatibility to IO.

static VALUE
strio_set_encoding(int argc, VALUE *argv, VALUE self)
{
    rb_encoding* enc;
    struct StringIO *ptr = StringIO(self);
    VALUE ext_enc, int_enc, opt;

    argc = rb_scan_args(argc, argv, "11:", &ext_enc, &int_enc, &opt);

    if (NIL_P(ext_enc)) {
        enc = rb_default_external_encoding();
    }
    else {
        enc = rb_to_encoding(ext_enc);
    }
    ptr->enc = enc;
    if (WRITABLE(self)) {
        rb_enc_associate(ptr->string, enc);
    }

    return self;
}
size → integer click to toggle source

Returns the size of the buffer string.

static VALUE
strio_size(VALUE self)
{
    VALUE string = StringIO(self)->string;
    if (NIL_P(string)) {
        rb_raise(rb_eIOError, "not opened");
    }
    return ULONG2NUM(RSTRING_LEN(string));
}
string → string click to toggle source

Returns underlying String object, the subject of IO.

static VALUE
strio_get_string(VALUE self)
{
    return StringIO(self)->string;
}
string = string → string click to toggle source

Changes underlying String object, the subject of IO.

static VALUE
strio_set_string(VALUE self, VALUE string)
{
    struct StringIO *ptr = StringIO(self);

    rb_io_taint_check(self);
    ptr->flags &= ~FMODE_READWRITE;
    StringValue(string);
    ptr->flags = OBJ_FROZEN(string) ? FMODE_READABLE : FMODE_READWRITE;
    ptr->pos = 0;
    ptr->lineno = 0;
    return ptr->string = string;
}
sync → true click to toggle source

Returns true always.

static VALUE
strio_get_sync(VALUE self)
{
    StringIO(self);
    return Qtrue;
}
sync=(p1) click to toggle source

Returns the argument unchanged. Just for compatibility to IO.

static VALUE
strio_first(VALUE self, VALUE arg)
{
    StringIO(self);
    return arg;
}
pos → integer click to toggle source
tell → integer

Returns the current offset (in bytes) of strio.

static VALUE
strio_get_pos(VALUE self)
{
    return LONG2NUM(StringIO(self)->pos);
}
truncate(integer) → 0 click to toggle source

Truncates the buffer string to at most integer bytes. The strio must be opened for writing.

static VALUE
strio_truncate(VALUE self, VALUE len)
{
    VALUE string = writable(self)->string;
    long l = NUM2LONG(len);
    long plen = RSTRING_LEN(string);
    if (l < 0) {
        error_inval("negative length");
    }
    rb_str_resize(string, l);
    if (plen < l) {
        MEMZERO(RSTRING_PTR(string) + plen, char, l - plen);
    }
    return len;
}
tty?() click to toggle source

Returns false. Just for compatibility to IO.

static VALUE
strio_false(VALUE self)
{
    StringIO(self);
    return Qfalse;
}
ungetbyte(fixnum) → nil click to toggle source

See IO#ungetbyte

static VALUE
strio_ungetbyte(VALUE self, VALUE c)
{
    struct StringIO *ptr = readable(self);
    char buf[1], *cp = buf;
    long cl = 1;

    check_modifiable(ptr);
    if (NIL_P(c)) return Qnil;
    if (FIXNUM_P(c)) {
        buf[0] = (char)FIX2INT(c);
        return strio_unget_bytes(ptr, buf, 1);
    }
    else {
        SafeStringValue(c);
        cp = RSTRING_PTR(c);
        cl = RSTRING_LEN(c);
        if (cl == 0) return Qnil;
        strio_unget_bytes(ptr, cp, cl);
        RB_GC_GUARD(c);
        return Qnil;
    }
}
ungetc(string) → nil click to toggle source

Pushes back one character (passed as a parameter) onto strio such that a subsequent buffered read will return it. There is no limitation for multiple pushbacks including pushing back behind the beginning of the buffer string.

static VALUE
strio_ungetc(VALUE self, VALUE c)
{
    struct StringIO *ptr = readable(self);
    rb_encoding *enc, *enc2;

    check_modifiable(ptr);
    if (NIL_P(c)) return Qnil;
    if (RB_INTEGER_TYPE_P(c)) {
        int len, cc = NUM2INT(c);
        char buf[16];

        enc = rb_enc_get(ptr->string);
        len = rb_enc_codelen(cc, enc);
        if (len <= 0) rb_enc_uint_chr(cc, enc);
        rb_enc_mbcput(cc, buf, enc);
        return strio_unget_bytes(ptr, buf, len);
    }
    else {
        SafeStringValue(c);
        enc = rb_enc_get(ptr->string);
        enc2 = rb_enc_get(c);
        if (enc != enc2 && enc != rb_ascii8bit_encoding()) {
            c = rb_str_conv_enc(c, enc2, enc);
        }
        strio_unget_bytes(ptr, RSTRING_PTR(c), RSTRING_LEN(c));
        RB_GC_GUARD(c);
        return Qnil;
    }
}
write(string) → integer click to toggle source
syswrite(string) → integer

Appends the given string to the underlying buffer string of strio. The stream must be opened for writing. If the argument is not a string, it will be converted to a string using to_s. Returns the number of bytes written. See IO#write.

static VALUE
strio_write(VALUE self, VALUE str)
{
    struct StringIO *ptr = writable(self);
    long len, olen;
    rb_encoding *enc, *enc2;
    rb_encoding *const ascii8bit = rb_ascii8bit_encoding();

    if (!RB_TYPE_P(str, T_STRING))
        str = rb_obj_as_string(str);
    enc = get_enc(ptr);
    enc2 = rb_enc_get(str);
    if (enc != enc2 && enc != ascii8bit) {
        str = rb_str_conv_enc(str, enc2, enc);
    }
    len = RSTRING_LEN(str);
    if (len == 0) return INT2FIX(0);
    check_modifiable(ptr);
    olen = RSTRING_LEN(ptr->string);
    if (ptr->flags & FMODE_APPEND) {
        ptr->pos = olen;
    }
    if (ptr->pos == olen) {
        if (enc == ascii8bit || enc2 == ascii8bit) {
            rb_enc_str_buf_cat(ptr->string, RSTRING_PTR(str), len, enc);
            OBJ_INFECT(ptr->string, str);
        }
        else {
            rb_str_buf_append(ptr->string, str);
        }
    }
    else {
        strio_extend(ptr, ptr->pos, len);
        memmove(RSTRING_PTR(ptr->string)+ptr->pos, RSTRING_PTR(str), len);
        OBJ_INFECT(ptr->string, str);
    }
    OBJ_INFECT(ptr->string, self);
    RB_GC_GUARD(str);
    ptr->pos += len;
    return LONG2NUM(len);
}