stringio 3.1.0 → 3.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67351f85af240c4189d6d1eaf805bfade85b9aae65d930326ec1c6930c5ba9c9
-  data.tar.gz: 51016af4762d130788a7f80798fafd346225f67c86096f95e7f3f2f5244d8b17
+  metadata.gz: d32a3b9eb5ecb12a5c78c7a79418ed351272fe49a2fc1bbde837880a8e6a2a53
+  data.tar.gz: 8f965cb4f731147e7d6da44db5acbeda3a08ac51df419445d8001f35b17a1dc9
 SHA512:
-  metadata.gz: 6e15df64d01a1592cf7ca5f0024cdd693494c5db5c5cfcf9e7d4662c3f8a8c8cdadf2032e72c80d1baa2110c6310f4e6e0fdc96926eee53095ddf443caab9b5c
-  data.tar.gz: 50dafc1b4c0de2e659860b00b6d6e6ef43eedba1cf059956d86acc9f9bb6c28c3924ef5ff3e5b7ba8719afc5366bf1cebf9a0e67b1e1a918a1347aa28f18ea0c
+  metadata.gz: 6c3f11fa1dee2b8e00269cad5e99db7014ecdc7b1b7d99f5086d15fb3f04d17105dabd838887e5f87af817851e2a8a59260c7c7af26a5ea40f2ce103ad830775
+  data.tar.gz: c9e2afe1c8104c27591454cfeefdc71926c76196d3afc343f76052b9e465566f62df19ae25baaa1217839684910b0c94e4d05b7b08723f1960065f0c2d0844df

data/.document

@@ -0,0 +1,5 @@
+COPYING
+*.md
+*.txt
+docs/
+ext/stringio/

data/.rdoc_options

@@ -0,0 +1,2 @@
+---
+main_page: README.md

data/COPYING

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+1. You may make and give away verbatim copies of the source form of the
+   software without restriction, provided that you duplicate all of the
+   original copyright notices and associated disclaimers.
+
+2. You may modify your copy of the software in any way, provided that
+   you do at least ONE of the following:
+
+   a. place your modifications in the Public Domain or otherwise
+      make them Freely Available, such as by posting said
+      modifications to Usenet or an equivalent medium, or by allowing
+      the author to include your modifications in the software.
+
+   b. use the modified software only within your corporation or
+      organization.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+3. You may distribute the software in object code or binary form,
+   provided that you do at least ONE of the following:
+
+   a. distribute the binaries and library files of the software,
+      together with instructions (in the manual page or equivalent)
+      on where to get the original distribution.
+
+   b. accompany the distribution with the machine-readable source of
+      the software.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+4. You may modify and include the part of the software into any other
+   software (possibly commercial).  But some files in the distribution
+   are not written by the author, so that they are not under these terms.
+
+   For the list of those files and their copying conditions, see the
+   file LEGAL.
+
+5. The scripts and library files supplied as input to or produced as
+   output from the software do not automatically fall under the
+   copyright of the software, but belong to whomever generated them,
+   and may be sold commercially, and may be aggregated with this
+   software.
+
+6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   PURPOSE.

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/NEWS.md

@@ -0,0 +1,243 @@
+# News
+
+## 3.1.7 - 2025-04-21
+
+### Improvements
+
+  * CRuby: Added support for `rb_io_mode_t` that will be introduced in
+    Ruby 3.5 or later.
+    * GH-129
+    * Patch by Samuel Williams
+
+### Thanks
+
+  * Samuel Williams
+
+## 3.1.6 - 2025-03-25
+
+### Fixes
+
+  * CRuby: Fix SEGV at unget to a null device StringIO
+  * JRuby:
+    * Fix NullPointerException at unget to a null device StringIO
+    * Use proper checkEncoding signature
+    * Update strioWrite logic to match CRuby
+    * GH-124
+
+## 3.1.5 - 2025-02-21
+
+### Improvements
+
+  * JRuby: Improved compatibility with CRuby for `StringIO#seek` with
+    frozen string.
+    * GH-119
+    * GH-121
+
+## 3.1.4 - 2025-02-20
+
+### Improvements
+
+  * JRuby: Improved compatibility with CRuby.
+    * GH-116
+
+### Fixes
+
+  * CRuby: Fixed a bug that `StringIO` may mutate a shared string.
+    * GH-117
+
+## 3.1.3 - 2025-02-14
+
+### Fixes
+
+  * JRuby: Fixed a bug that JRuby may not be able to be started
+    * GH-112
+    * GH-113
+    * Reported by Karol Bucek
+
+### Thanks
+
+  * Karol Bucek
+
+## 3.1.2 - 2024-11-07
+
+### Improvements
+
+  * JRuby: Added support for detecting encoding by BOM.
+    * GH-100
+    * GH-101
+
+### Fixes
+
+  * CRuby: Fixed a bug that unknown memory may be used by
+    `StringIO#ungetc`/`StringIO#ungetbyte`.
+    * https://hackerone.com/reports/2805165
+    * Reported by manun.
+
+### Thanks
+
+  * manun
+
+## 3.1.1 - 2024-06-13
+
+### Improvements
+
+  * JRuby: Improved.
+    * GH-83
+    * GH-84
+    * GH-85
+
+  * Added `StringIO::MAX_LENGTH`.
+
+  * Added support for NULL `StringIO` by `StringIO.new(nil)`.
+
+  * Improved IO compatibility for partial read.
+    * GH-95
+    * https://bugs.ruby-lang.org/issues/20418
+
+### Fixes
+
+  * Fixed a bug that coderange isn't updated after overwrite.
+    * Reported by Tiago Cardoso.
+    * https://bugs.ruby-lang.org/issues/20185
+    * GH-77
+    * GH-79
+
+### Thanks
+
+  * Tiago Cardoso
+
+## 3.1.0 - 2023-11-28
+
+### Fixes
+
+  * TruffleRuby: Do not compile the C extension
+
+    GH-71
+
+## 3.0.9 - 2023-11-08
+
+### Improvements
+
+  * JRuby: Aligned `StringIO#gets` behavior with the C implementation.
+
+    GH-61
+
+### Fixes
+
+  * CRuby: Fixed `StringIO#pread` with the length 0.
+
+    Patch by Jean byroot Boussier.
+
+    GH-67
+
+  * CRuby: Fixed a bug that `StringIO#gets` with non ASCII compatible
+    encoding such as UTF-16 doesn't detect correct new line characters.
+
+    Reported by IWAMOTO Kouichi.
+
+    GH-68
+
+### Thanks
+
+  * Jean byroot Boussier
+
+  * IWAMOTO Kouichi
+
+## 3.0.8 - 2023-08-10
+
+### Improvements
+
+  * Added `StringIO#pread`.
+
+    Patch by Jean byroot Boussier.
+
+    GH-56
+
+  * JRuby: Added `StringIO::VERSION`.
+
+    GH-57 GH-59
+
+### Thanks
+
+  * Jean byroot Boussier
+
+## 3.0.7 - 2023-06-02
+
+  * CRuby: Avoid direct struct usage. This change is for supporting
+    Ruby 3.3.
+
+    GH-54
+
+## 3.0.6 - 2023-04-14
+
+### Improvements
+
+  * CRuby: Added support for write barrier.
+
+  * JRuby: Added missing arty-checking.
+
+    GH-48
+
+  * JRuby: Added support for `StringIO.new(encoding:)`.
+
+    GH-45
+
+## 3.0.5 - 2023-02-02
+
+### Improvements
+
+### Fixes
+
+  * Fixed a bug that `StringIO#gets("2+ character", chomp: true)` did not
+    remove the separator at the end.
+    [[Bug #19389](https://bugs.ruby-lang.org/issues/19389)]
+
+## 3.0.4 - 2022-12-09
+
+### Improvements
+
+  * JRuby: Changed to use flag registry.
+    [[GitHub#33](https://github.com/ruby/stringio/pull/26)]
+
+## 3.0.3 - 2022-12-08
+
+### Improvements
+
+  * Improved documents.
+    [[GitHub#33](https://github.com/ruby/stringio/pull/33)]
+    [[GitHub#34](https://github.com/ruby/stringio/pull/34)]
+    [[GitHub#35](https://github.com/ruby/stringio/pull/35)]
+    [[GitHub#36](https://github.com/ruby/stringio/pull/36)]
+    [[GitHub#37](https://github.com/ruby/stringio/pull/37)]
+    [Patch by Burdette Lamar]
+
+### Fixes
+
+  * Fixed a bug that large `StringIO#ungetc`/`StringIO#ungetbyte`
+    break internal buffer.
+
+  * Fixed a bug that `StringIO#each("2+ character", chomp: true)` cause
+    infinite loop.
+    [[Bug #18769](https://bugs.ruby-lang.org/issues/18769)]
+
+  * Fixed a bug that `StringIO#each(nil, chomp: true)` chomps.
+    [[Bug #18770](https://bugs.ruby-lang.org/issues/18770)]
+
+  * Fixed a bug that `StringIO#each("", chomp: true)` isn't compatible
+    with `IO#each("", chomp: true)`.
+    [[Bug #18768](https://bugs.ruby-lang.org/issues/18768)]
+
+  * Fixed a bug that `StringIO#set_encoding` doesn't accept external
+    and internal encodings pairo.
+    [[GitHub#16](https://github.com/ruby/stringio/issues/16)]
+    [Reported by Kenta Murata]
+
+  * Fixed a bug that `StringIO#truncate` isn't compatible with
+    `File#truncate`.
+
+### Thanks
+
+  * Kenta Murata
+
+  * Burdette Lamar
+

data/README.md

@@ -12,7 +12,7 @@ This library is based on MoonWolf version written in Ruby.  Thanks a lot.
 
 * `fileno` raises `NotImplementedError`.
 * encoding conversion is not implemented, and ignored silently.
-* there is no `#to_io` method because this is not an `IO.
+* there is no `#to_io` method because this is not an `IO`.
 
 ## Installation
 

data/docs/io.rb

@@ -0,0 +1,8 @@
+# :stopdoc:
+class IO
+  module generic_readable
+  end
+  module generic_writable
+  end
+end
+# :startdoc:

data/ext/stringio/.document

@@ -0,0 +1 @@
+*.[ch]

data/ext/stringio/extconf.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: false
 require 'mkmf'
 if RUBY_ENGINE == 'ruby'
+  have_type("rb_io_mode_t", "ruby/io.h")
+
   create_makefile('stringio')
 else
   File.write('Makefile', dummy_makefile("").join)

data/ext/stringio/stringio.c

@@ -13,7 +13,9 @@
 **********************************************************************/
 
 static const char *const
-STRINGIO_VERSION = "3.1.0";
+STRINGIO_VERSION = "3.1.7";
+
+#include <stdbool.h>
 
 #include "ruby.h"
 #include "ruby/io.h"
@@ -33,12 +35,16 @@ STRINGIO_VERSION = "3.1.0";
 # define rb_class_new_instance_kw(argc, argv, klass, kw_splat) rb_class_new_instance(argc, argv, klass)
 #endif
 
+#ifndef HAVE_TYPE_RB_IO_MODE_T
+typedef int rb_io_mode_t;
+#endif
+
 struct StringIO {
     VALUE string;
     rb_encoding *enc;
     long pos;
     long lineno;
-    int flags;
+    rb_io_mode_t flags;
     int count;
 };
 
@@ -48,7 +54,13 @@ static long strio_write(VALUE self, VALUE str);
 
 #define IS_STRIO(obj) (rb_typeddata_is_kind_of((obj), &strio_data_type))
 #define error_inval(msg) (rb_syserr_fail(EINVAL, msg))
-#define get_enc(ptr) ((ptr)->enc ? (ptr)->enc : rb_enc_get((ptr)->string))
+#define get_enc(ptr) ((ptr)->enc ? (ptr)->enc : !NIL_P((ptr)->string) ? rb_enc_get((ptr)->string) : NULL)
+
+static bool
+readonly_string_p(VALUE string)
+{
+    return OBJ_FROZEN_RAW(string);
+}
 
 static struct StringIO *
 strio_alloc(void)
@@ -166,9 +178,15 @@ writable(VALUE strio)
 static void
 check_modifiable(struct StringIO *ptr)
 {
-    if (OBJ_FROZEN(ptr->string)) {
+    if (NIL_P(ptr->string)) {
+	/* Null device StringIO */
+    }
+    else if (OBJ_FROZEN_RAW(ptr->string)) {
 	rb_raise(rb_eIOError, "not modifiable string");
     }
+    else {
+	rb_str_modify(ptr->string);
+    }
 }
 
 static VALUE
@@ -281,13 +299,14 @@ strio_init(int argc, VALUE *argv, struct StringIO *ptr, VALUE self)
 
     argc = rb_scan_args(argc, argv, "02:", &string, &vmode, &opt);
     rb_io_extract_modeenc(&vmode, 0, opt, &oflags, &ptr->flags, &convconfig);
-    if (argc) {
+    if (!NIL_P(string)) {
 	StringValue(string);
     }
-    else {
+    else if (!argc) {
 	string = rb_enc_str_new("", 0, rb_default_external_encoding());
     }
-    if (OBJ_FROZEN_RAW(string)) {
+
+    if (!NIL_P(string) && readonly_string_p(string)) {
 	if (ptr->flags & FMODE_WRITABLE) {
 	    rb_syserr_fail(EACCES, 0);
 	}
@@ -297,11 +316,11 @@ strio_init(int argc, VALUE *argv, struct StringIO *ptr, VALUE self)
 	    ptr->flags |= FMODE_WRITABLE;
 	}
     }
-    if (ptr->flags & FMODE_TRUNC) {
+    if (!NIL_P(string) && (ptr->flags & FMODE_TRUNC)) {
 	rb_str_resize(string, 0);
     }
     RB_OBJ_WRITE(self, &ptr->string, string);
-    if (argc == 1) {
+    if (argc == 1 && !NIL_P(string)) {
 	ptr->enc = rb_enc_get(string);
     }
     else {
@@ -481,7 +500,7 @@ strio_set_string(VALUE self, VALUE string)
     rb_io_taint_check(self);
     ptr->flags &= ~FMODE_READWRITE;
     StringValue(string);
-    ptr->flags = OBJ_FROZEN(string) ? FMODE_READABLE : FMODE_READWRITE;
+    ptr->flags = readonly_string_p(string) ? FMODE_READABLE : FMODE_READWRITE;
     ptr->pos = 0;
     ptr->lineno = 0;
     RB_OBJ_WRITE(self, &ptr->string, string);
@@ -595,6 +614,7 @@ static struct StringIO *
 strio_to_read(VALUE self)
 {
     struct StringIO *ptr = readable(self);
+    if (NIL_P(ptr->string)) return NULL;
     if (ptr->pos < RSTRING_LEN(ptr->string)) return ptr;
     return NULL;
 }
@@ -872,7 +892,7 @@ strio_getc(VALUE self)
     int len;
     char *p;
 
-    if (pos >= RSTRING_LEN(str)) {
+    if (NIL_P(str) || pos >= RSTRING_LEN(str)) {
 	return Qnil;
     }
     p = RSTRING_PTR(str)+pos;
@@ -893,7 +913,7 @@ strio_getbyte(VALUE self)
 {
     struct StringIO *ptr = readable(self);
     int c;
-    if (ptr->pos >= RSTRING_LEN(ptr->string)) {
+    if (NIL_P(ptr->string) || ptr->pos >= RSTRING_LEN(ptr->string)) {
 	return Qnil;
     }
     c = RSTRING_PTR(ptr->string)[ptr->pos++];
@@ -915,8 +935,17 @@ strio_extend(struct StringIO *ptr, long pos, long len)
 	if (pos > olen)
 	    MEMZERO(RSTRING_PTR(ptr->string) + olen, char, pos - olen);
     }
-    else {
-	rb_str_modify(ptr->string);
+}
+
+static void
+strio_unget_string(struct StringIO *ptr, VALUE c)
+{
+    const char *cp = NULL;
+    long cl = RSTRING_LEN(c);
+    if (cl > 0) {
+	if (c != ptr->string) cp = RSTRING_PTR(c);
+	strio_unget_bytes(ptr, cp, cl);
+	RB_GC_GUARD(c);
     }
 }
 
@@ -934,6 +963,7 @@ strio_ungetc(VALUE self, VALUE c)
     rb_encoding *enc, *enc2;
 
     check_modifiable(ptr);
+    if (NIL_P(ptr->string)) return Qnil;
     if (NIL_P(c)) return Qnil;
     if (RB_INTEGER_TYPE_P(c)) {
 	int len, cc = NUM2INT(c);
@@ -941,19 +971,22 @@ strio_ungetc(VALUE self, VALUE c)
 
 	enc = rb_enc_get(ptr->string);
 	len = rb_enc_codelen(cc, enc);
-	if (len <= 0) rb_enc_uint_chr(cc, enc);
+	if (len <= 0) {
+	    rb_enc_uint_chr(cc, enc); /* to raise an exception */
+	    UNREACHABLE;
+	}
 	rb_enc_mbcput(cc, buf, enc);
 	return strio_unget_bytes(ptr, buf, len);
     }
     else {
-	SafeStringValue(c);
+	StringValue(c);
+	if (RSTRING_LEN(c) == 0) return Qnil;
 	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);
+	strio_unget_string(ptr, c);
 	return Qnil;
     }
 }
@@ -971,21 +1004,17 @@ strio_ungetbyte(VALUE self, VALUE c)
     struct StringIO *ptr = readable(self);
 
     check_modifiable(ptr);
+    if (NIL_P(ptr->string)) return Qnil;
     if (NIL_P(c)) return Qnil;
     if (RB_INTEGER_TYPE_P(c)) {
-        /* rb_int_and() not visible from exts */
-        VALUE v = rb_funcall(c, '&', 1, INT2FIX(0xff));
-        const char cc = NUM2INT(v) & 0xFF;
-        strio_unget_bytes(ptr, &cc, 1);
+	/* rb_int_and() not visible from exts */
+	VALUE v = rb_funcall(c, '&', 1, INT2FIX(0xff));
+	const char cc = NUM2INT(v) & 0xFF;
+	strio_unget_bytes(ptr, &cc, 1);
     }
     else {
-	long cl;
-	SafeStringValue(c);
-	cl = RSTRING_LEN(c);
-	if (cl > 0) {
-	    strio_unget_bytes(ptr, RSTRING_PTR(c), cl);
-	    RB_GC_GUARD(c);
-	}
+	StringValue(c);
+	strio_unget_string(ptr, c);
     }
     return Qnil;
 }
@@ -1016,7 +1045,7 @@ strio_unget_bytes(struct StringIO *ptr, const char *cp, long cl)
 	if (rest > cl) memset(s + len, 0, rest - cl);
 	pos -= cl;
     }
-    memcpy(s + pos, cp, cl);
+    memcpy(s + pos, (cp ? cp : s), cl);
     ptr->pos = pos;
     return Qnil;
 }
@@ -1157,41 +1186,41 @@ prepare_getline_args(struct StringIO *ptr, struct getline_arg *arg, int argc, VA
 	break;
 
       case 1:
-        if (!NIL_P(rs) && !RB_TYPE_P(rs, T_STRING)) {
-            VALUE tmp = rb_check_string_type(rs);
+	if (!NIL_P(rs) && !RB_TYPE_P(rs, T_STRING)) {
+	    VALUE tmp = rb_check_string_type(rs);
 	    if (NIL_P(tmp)) {
-                limit = NUM2LONG(rs);
-                rs = rb_rs;
+		limit = NUM2LONG(rs);
+		rs = rb_rs;
 	    }
 	    else {
-                rs = tmp;
+		rs = tmp;
 	    }
 	}
 	break;
 
       case 2:
-        if (!NIL_P(rs)) StringValue(rs);
+	if (!NIL_P(rs)) StringValue(rs);
 	if (!NIL_P(lim)) limit = NUM2LONG(lim);
 	break;
     }
-    if (!NIL_P(rs)) {
-        rb_encoding *enc_rs, *enc_io;
-        enc_rs = rb_enc_get(rs);
-        enc_io = get_enc(ptr);
-        if (enc_rs != enc_io &&
-            (rb_enc_str_coderange(rs) != ENC_CODERANGE_7BIT ||
-             (RSTRING_LEN(rs) > 0 && !rb_enc_asciicompat(enc_io)))) {
-            if (rs == rb_rs) {
-                rs = rb_enc_str_new(0, 0, enc_io);
-                rb_str_buf_cat_ascii(rs, "\n");
-                rs = rs;
-            }
-            else {
-                rb_raise(rb_eArgError, "encoding mismatch: %s IO with %s RS",
-                         rb_enc_name(enc_io),
-                         rb_enc_name(enc_rs));
-            }
-        }
+    if (!NIL_P(ptr->string) && !NIL_P(rs)) {
+	rb_encoding *enc_rs, *enc_io;
+	enc_rs = rb_enc_get(rs);
+	enc_io = get_enc(ptr);
+	if (enc_rs != enc_io &&
+	    (rb_enc_str_coderange(rs) != ENC_CODERANGE_7BIT ||
+	     (RSTRING_LEN(rs) > 0 && !rb_enc_asciicompat(enc_io)))) {
+	    if (rs == rb_rs) {
+		rs = rb_enc_str_new(0, 0, enc_io);
+		rb_str_buf_cat_ascii(rs, "\n");
+		rs = rs;
+	    }
+	    else {
+		rb_raise(rb_eArgError, "encoding mismatch: %s IO with %s RS",
+			 rb_enc_name(enc_io),
+			 rb_enc_name(enc_rs));
+	    }
+	}
     }
     arg->rs = rs;
     arg->limit = limit;
@@ -1203,9 +1232,9 @@ prepare_getline_args(struct StringIO *ptr, struct getline_arg *arg, int argc, VA
 	    keywords[0] = rb_intern_const("chomp");
 	}
 	rb_get_kwargs(opts, keywords, 0, 1, &vchomp);
-        if (respect_chomp) {
+	if (respect_chomp) {
 	    arg->chomp = (vchomp != Qundef) && RTEST(vchomp);
-        }
+	}
     }
     return arg;
 }
@@ -1229,7 +1258,7 @@ strio_getline(struct getline_arg *arg, struct StringIO *ptr)
     long w = 0;
     rb_encoding *enc = get_enc(ptr);
 
-    if (ptr->pos >= (n = RSTRING_LEN(ptr->string))) {
+    if (NIL_P(ptr->string) || ptr->pos >= (n = RSTRING_LEN(ptr->string))) {
 	return Qnil;
     }
     s = RSTRING_PTR(ptr->string);
@@ -1245,7 +1274,7 @@ strio_getline(struct getline_arg *arg, struct StringIO *ptr)
 	str = strio_substr(ptr, ptr->pos, e - s - w, enc);
     }
     else if ((n = RSTRING_LEN(str)) == 0) {
-        const char *paragraph_end = NULL;
+	const char *paragraph_end = NULL;
 	p = s;
 	while (p[(p + 1 < e) && (*p == '\r') && 0] == '\n') {
 	    p += *p == '\r';
@@ -1255,18 +1284,18 @@ strio_getline(struct getline_arg *arg, struct StringIO *ptr)
 	}
 	s = p;
 	while ((p = memchr(p, '\n', e - p)) && (p != e)) {
-            p++;
-            if (!((p < e && *p == '\n') ||
-                  (p + 1 < e && *p == '\r' && *(p+1) == '\n'))) {
-                continue;
-            }
-            paragraph_end = p - ((*(p-2) == '\r') ? 2 : 1);
-            while ((p < e && *p == '\n') ||
-                   (p + 1 < e && *p == '\r' && *(p+1) == '\n')) {
-                p += (*p == '\r') ? 2 : 1;
-            }
-            e = p;
-            break;
+	    p++;
+	    if (!((p < e && *p == '\n') ||
+		  (p + 1 < e && *p == '\r' && *(p+1) == '\n'))) {
+		continue;
+	    }
+	    paragraph_end = p - ((*(p-2) == '\r') ? 2 : 1);
+	    while ((p < e && *p == '\n') ||
+		   (p + 1 < e && *p == '\r' && *(p+1) == '\n')) {
+		p += (*p == '\r') ? 2 : 1;
+	    }
+	    e = p;
+	    break;
 	}
 	if (arg->chomp && paragraph_end) {
 	    w = e - paragraph_end;
@@ -1326,6 +1355,7 @@ strio_gets(int argc, VALUE *argv, VALUE self)
     VALUE str;
 
     if (prepare_getline_args(ptr, &arg, argc, argv)->limit == 0) {
+	if (NIL_P(ptr->string)) return Qnil;
 	return rb_enc_str_new(0, 0, get_enc(ptr));
     }
 
@@ -1440,6 +1470,7 @@ strio_write(VALUE self, VALUE str)
     if (!RB_TYPE_P(str, T_STRING))
 	str = rb_obj_as_string(str);
     enc = get_enc(ptr);
+    if (!enc) return 0;
     enc2 = rb_enc_get(str);
     if (enc != enc2 && enc != ascii8bit && enc != (usascii = rb_usascii_encoding())) {
 	VALUE converted = rb_str_conv_enc(str, enc2, enc);
@@ -1465,6 +1496,7 @@ strio_write(VALUE self, VALUE str)
     }
     else {
 	strio_extend(ptr, ptr->pos, len);
+	rb_str_modify(ptr->string);
 	memmove(RSTRING_PTR(ptr->string)+ptr->pos, RSTRING_PTR(str), len);
     }
     RB_GC_GUARD(str);
@@ -1511,10 +1543,12 @@ strio_putc(VALUE self, VALUE ch)
 
     check_modifiable(ptr);
     if (RB_TYPE_P(ch, T_STRING)) {
+	if (NIL_P(ptr->string)) return ch;
 	str = rb_str_substr(ch, 0, 1);
     }
     else {
 	char c = NUM2CHR(ch);
+	if (NIL_P(ptr->string)) return ch;
 	str = rb_str_new(&c, 1);
     }
     strio_write(self, str);
@@ -1557,7 +1591,8 @@ strio_read(int argc, VALUE *argv, VALUE self)
 	    if (len < 0) {
 		rb_raise(rb_eArgError, "negative length %ld given", len);
 	    }
-	    if (len > 0 && ptr->pos >= RSTRING_LEN(ptr->string)) {
+	    if (len > 0 &&
+		(NIL_P(ptr->string) || ptr->pos >= RSTRING_LEN(ptr->string))) {
 		if (!NIL_P(str)) rb_str_resize(str, 0);
 		return Qnil;
 	    }
@@ -1566,6 +1601,7 @@ strio_read(int argc, VALUE *argv, VALUE self)
 	}
 	/* fall through */
       case 0:
+	if (NIL_P(ptr->string)) return Qnil;
 	len = RSTRING_LEN(ptr->string);
 	if (len <= ptr->pos) {
 	    rb_encoding *enc = get_enc(ptr);
@@ -1583,7 +1619,7 @@ strio_read(int argc, VALUE *argv, VALUE self)
 	}
 	break;
       default:
-        rb_error_arity(argc, 0, 2);
+	rb_error_arity(argc, 0, 2);
     }
     if (NIL_P(str)) {
 	rb_encoding *enc = binary ? rb_ascii8bit_encoding() : get_enc(ptr);
@@ -1594,10 +1630,9 @@ strio_read(int argc, VALUE *argv, VALUE self)
 	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
+	if (!binary) {
 	    rb_enc_copy(str, ptr->string);
+	}
     }
     ptr->pos += RSTRING_LEN(str);
     return str;
@@ -1619,28 +1654,28 @@ strio_pread(int argc, VALUE *argv, VALUE self)
     long offset = NUM2LONG(rb_offset);
 
     if (len < 0) {
-        rb_raise(rb_eArgError, "negative string size (or size too big): %" PRIsVALUE, rb_len);
+	rb_raise(rb_eArgError, "negative string size (or size too big): %" PRIsVALUE, rb_len);
     }
 
     if (len == 0) {
-        if (NIL_P(rb_buf)) {
-            return rb_str_new("", 0);
-        }
-        return rb_buf;
+	if (NIL_P(rb_buf)) {
+	    return rb_str_new("", 0);
+	}
+	return rb_buf;
     }
 
     if (offset < 0) {
-        rb_syserr_fail_str(EINVAL, rb_sprintf("pread: Invalid offset argument: %" PRIsVALUE, rb_offset));
+	rb_syserr_fail_str(EINVAL, rb_sprintf("pread: Invalid offset argument: %" PRIsVALUE, rb_offset));
     }
 
     struct StringIO *ptr = readable(self);
 
     if (offset >= RSTRING_LEN(ptr->string)) {
-        rb_eof_error();
+	rb_eof_error();
     }
 
     if (NIL_P(rb_buf)) {
-        return strio_substr(ptr, offset, len, rb_ascii8bit_encoding());
+	return strio_substr(ptr, offset, len, rb_ascii8bit_encoding());
     }
 
     long rest = RSTRING_LEN(ptr->string) - offset;
@@ -1700,8 +1735,14 @@ strio_read_nonblock(int argc, VALUE *argv, VALUE self)
     return val;
 }
 
+/*
+ * See IO#write
+ */
 #define strio_syswrite rb_io_write
 
+/*
+ * See IO#write_nonblock
+ */
 static VALUE
 strio_syswrite_nonblock(int argc, VALUE *argv, VALUE self)
 {
@@ -1729,7 +1770,7 @@ strio_size(VALUE self)
 {
     VALUE string = StringIO(self)->string;
     if (NIL_P(string)) {
-	rb_raise(rb_eIOError, "not opened");
+	return INT2FIX(0);
     }
     return ULONG2NUM(RSTRING_LEN(string));
 }
@@ -1746,10 +1787,12 @@ strio_truncate(VALUE self, VALUE len)
 {
     VALUE string = writable(self)->string;
     long l = NUM2LONG(len);
-    long plen = RSTRING_LEN(string);
+    long plen;
     if (l < 0) {
 	error_inval("negative length");
     }
+    if (NIL_P(string)) return 0;
+    plen = RSTRING_LEN(string);
     rb_str_resize(string, l);
     if (plen < l) {
 	MEMZERO(RSTRING_PTR(string) + plen, char, l - plen);
@@ -1813,20 +1856,30 @@ strio_set_encoding(int argc, VALUE *argv, VALUE self)
 	enc = rb_find_encoding(ext_enc);
 	if (!enc) {
 	    rb_io_enc_t convconfig;
-	    int oflags, fmode;
+	    int oflags;
+	    rb_io_mode_t fmode;
 	    VALUE vmode = rb_str_append(rb_str_new_cstr("r:"), ext_enc);
 	    rb_io_extract_modeenc(&vmode, 0, Qnil, &oflags, &fmode, &convconfig);
 	    enc = convconfig.enc2;
 	}
     }
     ptr->enc = enc;
-    if (WRITABLE(self)) {
+    if (!NIL_P(ptr->string) && WRITABLE(self)) {
 	rb_enc_associate(ptr->string, enc);
     }
 
     return self;
 }
 
+/*
+ *  call-seq:
+ *     strio.set_encoding_by_bom  => strio or nil
+ *
+ *  Sets the encoding according to the BOM (Byte Order Mark) in the
+ *  string.
+ *
+ *  Returns +self+ if the BOM is found, otherwise +nil.
+ */
 static VALUE
 strio_set_encoding_by_bom(VALUE self)
 {
@@ -1859,10 +1912,15 @@ Init_stringio(void)
 
     VALUE StringIO = rb_define_class("StringIO", rb_cObject);
 
+    /* The version string */
     rb_define_const(StringIO, "VERSION", rb_str_new_cstr(STRINGIO_VERSION));
 
     rb_include_module(StringIO, rb_mEnumerable);
     rb_define_alloc_func(StringIO, strio_s_allocate);
+
+    /* Maximum length that a StringIO instance can hold */
+    rb_define_const(StringIO, "MAX_LENGTH", LONG2NUM(LONG_MAX));
+
     rb_define_singleton_method(StringIO, "new", strio_s_new, -1);
     rb_define_singleton_method(StringIO, "open", strio_s_open, -1);
     rb_define_method(StringIO, "initialize", strio_initialize, -1);

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stringio
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.7
 platform: ruby
 authors:
 - Nobu Nakada
 - Charles Oliver Nutter
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-28 00:00:00.000000000 Z
+date: 2025-04-21 00:00:00.000000000 Z
 dependencies: []
 description: Pseudo `IO` class from/to `String`.
 email:
@@ -18,17 +17,32 @@ email:
 executables: []
 extensions:
 - ext/stringio/extconf.rb
-extra_rdoc_files: []
+extra_rdoc_files:
+- ".document"
+- ".rdoc_options"
+- COPYING
+- LICENSE.txt
+- NEWS.md
+- README.md
+- docs/io.rb
+- ext/stringio/.document
 files:
+- ".document"
+- ".rdoc_options"
+- COPYING
+- LICENSE.txt
+- NEWS.md
 - README.md
+- docs/io.rb
+- ext/stringio/.document
 - ext/stringio/extconf.rb
 - ext/stringio/stringio.c
 homepage: https://github.com/ruby/stringio
 licenses:
 - Ruby
 - BSD-2-Clause
-metadata: {}
-post_install_message:
+metadata:
+  changelog_uri: https://github.com/ruby/stringio/releases/tag/v3.1.7
 rdoc_options: []
 require_paths:
 - lib
@@ -43,8 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Pseudo IO on String
 test_files: []