string_view 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1863511a34dcabaa7da8cb19b974f943e8e9609c01a5b43369bae27ed2685e6
-  data.tar.gz: eb82ce2fab5f85083e156143cbd27f8bff2df10bc532d107dbc7a30de0d3a989
+  metadata.gz: '0203685aa4c5ed043ac5056a55ff02ef2a66b1c1e1dea855863f76c5630f2729'
+  data.tar.gz: 3fb4104605525004fb295f301ccd082250cd2a5c6adf6b121250ebbf02d8931e
 SHA512:
-  metadata.gz: f43e32e7e5fe70e66f1e3eb0431706bbf07506daab0ee157eff68e1b3d61bda1c4144e161a7cf41291f032f5f90696696867854463ba65ac57af215979238eb4
-  data.tar.gz: d6598af6460da6cc103e4634ea68b5e412ab8642263ecfb39c24d88c9309f0a3983a1364a600e0e20cdf210d3c63892d7832e78d06795c4e59c97734a8a62676
+  metadata.gz: a8fe9e3f44a6bf76fe291dbec179fc6cd4bccd9cda4d494f2b064e7e6285568544ced4f8be2d31f54d51bcf0428059b17cfdd169738297d1b96a16f88647c3c8
+  data.tar.gz: aba06aefc6e28749d5693167005f1271993067fd1bee28ffcff7a7953c7d9c9dd4cf431e09e996a62fb8d7e622cedb605a4019012f6a20e639557fcb906117e7

data/ext/string_view/string_view.c

@@ -50,10 +50,7 @@ static void sv_compact(void *ptr) {
 
 static void sv_free(void *ptr) {
     string_view_t *sv = (string_view_t *)ptr;
-    if (sv->stride_idx) {
-        xfree(sv->stride_idx->offsets);
-        xfree(sv->stride_idx);
-    }
+    sv_clear_stride_index(sv);
 }
 
 static size_t sv_memsize(const void *ptr) {
@@ -74,7 +71,9 @@ const rb_data_type_t string_view_type = {
 /* Forward declarations for functions defined later in this file */
 static long sv_char_count(string_view_t *sv);
 static long sv_char_to_byte_offset(string_view_t *sv, long char_idx);
+static long sv_char_count_partial(string_view_t *sv, const char *p, long len);
 SV_INLINE int sv_single_byte_optimizable(string_view_t *sv);
+SV_INLINE int sv_is_7bit(string_view_t *sv);
 SV_INLINE int sv_is_utf8(string_view_t *sv);
 static long sv_utf8_char_count(const char *p, long len);
 
@@ -119,6 +118,8 @@ SV_INLINE VALUE sv_new_from_parent_obj(VALUE parent_obj, string_view_t *parent,
     sv->offset      = offset;
     sv->length      = length;
     sv->single_byte = parent->single_byte;
+    sv->valid_encoding = sv->single_byte == 1 ? 1 : -1;
+    sv->pooled      = 0;
     sv->charlen     = -1;
     sv->stride_idx  = NULL;
     /* Not frozen — see sv_initialize comment for rationale */
@@ -140,6 +141,8 @@ static VALUE sv_alloc(VALUE klass) {
     sv->offset      = 0;
     sv->length      = 0;
     sv->single_byte = -1;
+    sv->valid_encoding = -1;
+    sv->pooled      = 0;
     sv->charlen     = -1;
     sv->stride_idx  = NULL;
     return obj;
@@ -217,6 +220,11 @@ static VALUE sv_reset(VALUE self, VALUE new_backing, VALUE voffset, VALUE vlengt
     rb_check_frozen(self);
     string_view_t *sv = sv_get_struct(self);
 
+    if (SV_UNLIKELY(sv->pooled)) {
+        rb_raise(rb_eRuntimeError,
+                 "can't reset a pooled StringView directly; call StringView::Pool#reset! instead");
+    }
+
     sv_check_frozen_string(new_backing);
 
     long off = NUM2LONG(voffset);
@@ -224,10 +232,7 @@ static VALUE sv_reset(VALUE self, VALUE new_backing, VALUE voffset, VALUE vlengt
     sv_check_bounds(off, len, RSTRING_LEN(new_backing));
 
     /* Free old stride index before reinitializing */
-    if (sv->stride_idx) {
-        xfree(sv->stride_idx->offsets);
-        xfree(sv->stride_idx);
-    }
+    sv_clear_stride_index(sv);
 
     sv_init_fields(self, sv, new_backing, RSTRING_PTR(new_backing),
                    rb_enc_get(new_backing), off, len);
@@ -274,6 +279,94 @@ static VALUE sv_ascii_only_p(VALUE self) {
     return Qtrue;
 }
 
+SV_INLINE long sv_precise_char_len(const char *p, const char *e, rb_encoding *enc) {
+    int len = rb_enc_precise_mbclen(p, e, enc);
+    if (MBCLEN_CHARFOUND_P(len)) return MBCLEN_CHARFOUND_LEN(len);
+    return 1;
+}
+
+static int sv_compute_valid_encoding_slice(string_view_t *sv) {
+    if (sv_single_byte_optimizable(sv)) return 1;
+
+    if (SV_LIKELY(sv_is_utf8(sv))) {
+        return simdutf_validate_utf8(sv_ptr(sv), (size_t)sv->length) ? 1 : 0;
+    }
+
+    rb_encoding *enc = sv_enc(sv);
+    const char *p = sv_ptr(sv);
+    const char *e = p + sv->length;
+
+    while (p < e) {
+        int len = rb_enc_precise_mbclen(p, e, enc);
+        if (!MBCLEN_CHARFOUND_P(len)) return 0;
+        p += MBCLEN_CHARFOUND_LEN(len);
+    }
+
+    return 1;
+}
+
+SV_INLINE int sv_valid_encoding_cached(string_view_t *sv) {
+    if (SV_LIKELY(sv->valid_encoding >= 0)) return sv->valid_encoding;
+    sv->valid_encoding = sv_compute_valid_encoding_slice(sv);
+    return sv->valid_encoding;
+}
+
+static long sv_tolerant_char_count(const char *p, const char *e, rb_encoding *enc) {
+    long count = 0;
+
+    while (p < e) {
+        p += sv_precise_char_len(p, e, enc);
+        count++;
+    }
+
+    return count;
+}
+
+static long sv_tolerant_char_to_byte_offset(string_view_t *sv, long char_idx) {
+    rb_encoding *enc = sv_enc(sv);
+    const char *p = sv_ptr(sv);
+    const char *e = p + sv->length;
+    const char *start = p;
+    long i = 0;
+
+    while (i < char_idx && p < e) {
+        p += sv_precise_char_len(p, e, enc);
+        i++;
+    }
+
+    if (i < char_idx) return -1;
+    return p - start;
+}
+
+static long sv_tolerant_chars_to_bytes(string_view_t *sv, long byte_off, long n) {
+    rb_encoding *enc = sv_enc(sv);
+    const char *start = sv_ptr(sv) + byte_off;
+    const char *p = start;
+    const char *e = sv_ptr(sv) + sv->length;
+    long i = 0;
+
+    while (i < n && p < e) {
+        p += sv_precise_char_len(p, e, enc);
+        i++;
+    }
+
+    return p - start;
+}
+
+SV_INLINE void sv_check_compatible_string(string_view_t *sv, VALUE other) {
+    rb_encoding *oenc = rb_enc_get(other);
+
+    if (sv->enc == oenc) return;
+    if (rb_enc_asciicompat(sv->enc) && rb_enc_asciicompat(oenc) &&
+        (sv_is_7bit(sv) || rb_enc_str_asciionly_p(other))) {
+        return;
+    }
+
+    rb_raise(rb_eEncCompatError,
+             "incompatible character encodings: %s and %s",
+             rb_enc_name(sv->enc), rb_enc_name(oenc));
+}
+
 /* ========================================================================= */
 /* Tier 1: Searching                                                         */
 /* ========================================================================= */
@@ -284,6 +377,7 @@ static VALUE sv_include_p(VALUE self, VALUE substr) {
     const char *p = sv_ptr(sv);
     long slen = RSTRING_LEN(substr);
     if (slen == 0) return Qtrue;
+    sv_check_compatible_string(sv, substr);
     if (slen > sv->length) return Qfalse;
 
     long pos = rb_memsearch(RSTRING_PTR(substr), slen, p, sv->length, sv_enc(sv));
@@ -299,6 +393,8 @@ static VALUE sv_start_with_p(int argc, VALUE *argv, VALUE self) {
         VALUE prefix = argv[i];
         StringValue(prefix);
         long plen = RSTRING_LEN(prefix);
+        if (plen == 0) return Qtrue;
+        sv_check_compatible_string(sv, prefix);
         if (plen > sv->length) continue;
         if (memcmp(p, RSTRING_PTR(prefix), plen) == 0) return Qtrue;
     }
@@ -314,6 +410,8 @@ static VALUE sv_end_with_p(int argc, VALUE *argv, VALUE self) {
         VALUE suffix = argv[i];
         StringValue(suffix);
         long slen = RSTRING_LEN(suffix);
+        if (slen == 0) return Qtrue;
+        sv_check_compatible_string(sv, suffix);
         if (slen > sv->length) continue;
         if (memcmp(p + sv->length - slen, RSTRING_PTR(suffix), slen) == 0)
             return Qtrue;
@@ -348,12 +446,13 @@ VALUE sv_index(int argc, VALUE *argv, VALUE self) {
 
     if (char_off < 0) char_off += total_chars;
     if (char_off < 0 || char_off > total_chars) return Qnil;
+    if (plen == 0) return LONG2NUM(char_off);
+    sv_check_compatible_string(sv, pattern);
 
     /* Convert char offset to byte offset */
     long byte_off = sv_char_to_byte_offset(sv, char_off);
     if (byte_off < 0) return Qnil;
 
-    if (plen == 0) return LONG2NUM(char_off);
     if (plen > sv->length - byte_off) return Qnil;
 
     long pos = rb_memsearch(RSTRING_PTR(pattern), plen,
@@ -365,16 +464,8 @@ VALUE sv_index(int argc, VALUE *argv, VALUE self) {
     if (sv_single_byte_optimizable(sv)) {
         return LONG2NUM(char_off + pos);
     }
-    /* Count chars from byte_off to byte_off+pos */
-    if (sv_is_utf8(sv)) {
-        long chars = sv_utf8_char_count(p + byte_off, pos);
-        return LONG2NUM(char_off + chars);
-    }
-    rb_encoding *enc = sv_enc(sv);
-    const char *s = p + byte_off;
-    const char *e = s + pos;
-    long chars = rb_enc_strlen(s, e, enc);
-    return LONG2NUM(char_off + chars);
+
+    return LONG2NUM(char_off + sv_char_count_partial(sv, p + byte_off, pos));
 }
 
 /*
@@ -413,6 +504,7 @@ VALUE sv_rindex(int argc, VALUE *argv, VALUE self) {
     if (plen == 0) {
         return LONG2NUM(max_char > total_chars ? total_chars : max_char);
     }
+    sv_check_compatible_string(sv, pattern);
     if (plen > sv->length) return Qnil;
 
     /* Convert max_char to a byte limit */
@@ -435,11 +527,7 @@ VALUE sv_rindex(int argc, VALUE *argv, VALUE self) {
             if (sv_single_byte_optimizable(sv)) {
                 return LONG2NUM(byte_pos);
             }
-            if (sv_is_utf8(sv)) {
-                return LONG2NUM(sv_utf8_char_count(p, byte_pos));
-            }
-            rb_encoding *enc = sv_enc(sv);
-            return LONG2NUM(rb_enc_strlen(p, s, enc));
+            return LONG2NUM(sv_char_count_partial(sv, p, byte_pos));
         }
         /* Move back one character */
         if (s == p) break;
@@ -486,6 +574,7 @@ VALUE sv_byteindex(int argc, VALUE *argv, VALUE self) {
     if (byte_off < 0) byte_off += sv->length;
     if (byte_off < 0 || byte_off > sv->length) return Qnil;
     if (plen == 0) return LONG2NUM(byte_off);
+    sv_check_compatible_string(sv, pattern);
     if (plen > sv->length - byte_off) return Qnil;
 
     long pos = rb_memsearch(RSTRING_PTR(pattern), plen,
@@ -526,6 +615,7 @@ VALUE sv_byterindex(int argc, VALUE *argv, VALUE self) {
     }
 
     if (plen == 0) return LONG2NUM(max_byte > sv->length ? sv->length : max_byte);
+    sv_check_compatible_string(sv, pattern);
     if (plen > sv->length) return Qnil;
 
     long search_end = max_byte;
@@ -633,6 +723,11 @@ typedef struct {
     char *ptr;
 } sv_cstr_t;
 
+typedef struct {
+    sv_cstr_t *cs;
+    int base;
+} sv_inum_args_t;
+
 SV_INLINE void sv_cstr_init(sv_cstr_t *cs, string_view_t *sv) {
     const char *p = sv_ptr(sv);
     long len = sv->length;
@@ -653,6 +748,22 @@ SV_INLINE void sv_cstr_free(sv_cstr_t *cs) {
     }
 }
 
+static VALUE sv_cstr_free_ensure(VALUE arg) {
+    sv_cstr_free((sv_cstr_t *)arg);
+    return Qnil;
+}
+
+static VALUE sv_to_i_body(VALUE arg) {
+    sv_inum_args_t *args = (sv_inum_args_t *)arg;
+    return rb_cstr_to_inum(args->cs->ptr, args->base, 0);
+}
+
+static VALUE sv_to_f_body(VALUE arg) {
+    sv_cstr_t *cs = (sv_cstr_t *)arg;
+    double d = rb_cstr_to_dbl(cs->ptr, 0);
+    return DBL2NUM(d);
+}
+
 /*
  * to_i([base]) — parse integer directly from byte pointer, zero allocations.
  * Uses rb_cstr_to_inum which parses from a NUL-terminated C string.
@@ -663,10 +774,12 @@ static VALUE sv_to_i(int argc, VALUE *argv, VALUE self) {
     if (argc > 0) base = NUM2INT(argv[0]);
 
     sv_cstr_t cs;
+    sv_inum_args_t args;
     sv_cstr_init(&cs, sv);
-    VALUE result = rb_cstr_to_inum(cs.ptr, base, 0);
-    sv_cstr_free(&cs);
-    return result;
+    args.cs = &cs;
+    args.base = base;
+    return rb_ensure(sv_to_i_body, (VALUE)&args,
+                     sv_cstr_free_ensure, (VALUE)&cs);
 }
 
 /*
@@ -676,9 +789,8 @@ static VALUE sv_to_f(VALUE self) {
     string_view_t *sv = sv_get_struct(self);
     sv_cstr_t cs;
     sv_cstr_init(&cs, sv);
-    double d = rb_cstr_to_dbl(cs.ptr, 0);
-    sv_cstr_free(&cs);
-    return DBL2NUM(d);
+    return rb_ensure(sv_to_f_body, (VALUE)&cs,
+                     sv_cstr_free_ensure, (VALUE)&cs);
 }
 
 /*
@@ -687,10 +799,12 @@ static VALUE sv_to_f(VALUE self) {
 static VALUE sv_hex(VALUE self) {
     string_view_t *sv = sv_get_struct(self);
     sv_cstr_t cs;
+    sv_inum_args_t args;
     sv_cstr_init(&cs, sv);
-    VALUE result = rb_cstr_to_inum(cs.ptr, 16, 0);
-    sv_cstr_free(&cs);
-    return result;
+    args.cs = &cs;
+    args.base = 16;
+    return rb_ensure(sv_to_i_body, (VALUE)&args,
+                     sv_cstr_free_ensure, (VALUE)&cs);
 }
 
 /*
@@ -699,10 +813,12 @@ static VALUE sv_hex(VALUE self) {
 static VALUE sv_oct(VALUE self) {
     string_view_t *sv = sv_get_struct(self);
     sv_cstr_t cs;
+    sv_inum_args_t args;
     sv_cstr_init(&cs, sv);
-    VALUE result = rb_cstr_to_inum(cs.ptr, 8, 0);
-    sv_cstr_free(&cs);
-    return result;
+    args.cs = &cs;
+    args.base = 8;
+    return rb_ensure(sv_to_i_body, (VALUE)&args,
+                     sv_cstr_free_ensure, (VALUE)&cs);
 }
 
 /* ========================================================================= */
@@ -714,11 +830,10 @@ static VALUE sv_oct(VALUE self) {
  * Uses the single_byte cache when available.
  */
 SV_INLINE int sv_is_7bit(string_view_t *sv) {
-    if (sv_single_byte_optimizable(sv)) return 1;
-    const char *p = sv_ptr(sv);
+    const unsigned char *p = (const unsigned char *)sv_ptr(sv);
     long i;
     for (i = 0; i < sv->length; i++) {
-        if ((unsigned char)p[i] > 127) return 0;
+        if (p[i] > 127) return 0;
     }
     return 1;
 }
@@ -1008,22 +1123,11 @@ static long sv_char_to_byte_offset(string_view_t *sv, long char_idx) {
         return char_idx;
     }
 
-    if (SV_LIKELY(sv_is_utf8(sv))) {
+    if (SV_LIKELY(sv_is_utf8(sv)) && sv_valid_encoding_cached(sv)) {
         return sv_utf8_char_to_byte_offset_indexed(sv, char_idx);
     }
 
-    rb_encoding *enc = sv_enc(sv);
-    const char *p = sv_ptr(sv);
-    const char *e = p + sv->length;
-    const char *start = p;
-    long i;
-
-    for (i = 0; i < char_idx && p < e; i++) {
-        p += rb_enc_fast_mbclen(p, e, enc);
-    }
-
-    if (i < char_idx) return -1;
-    return p - start;
+    return sv_tolerant_char_to_byte_offset(sv, char_idx);
 }
 
 static long sv_char_count(string_view_t *sv) {
@@ -1033,12 +1137,11 @@ static long sv_char_count(string_view_t *sv) {
     long count;
     if (sv_single_byte_optimizable(sv)) {
         count = sv->length;
-    } else if (SV_LIKELY(sv_is_utf8(sv))) {
+    } else if (SV_LIKELY(sv_is_utf8(sv)) && sv_valid_encoding_cached(sv)) {
         count = sv_utf8_char_count(sv_ptr(sv), sv->length);
     } else {
-        rb_encoding *enc = sv_enc(sv);
-        const char *p = sv_ptr(sv);
-        count = rb_enc_strlen(p, p + sv->length, enc);
+        count = sv_tolerant_char_count(sv_ptr(sv), sv_ptr(sv) + sv->length,
+                                       sv_enc(sv));
     }
 
     sv->charlen = count;
@@ -1051,20 +1154,20 @@ static long sv_chars_to_bytes(string_view_t *sv, long byte_off, long n) {
         return n < remaining ? n : remaining;
     }
 
-    if (SV_LIKELY(sv_is_utf8(sv))) {
+    if (SV_LIKELY(sv_is_utf8(sv)) && sv_valid_encoding_cached(sv)) {
         return sv_utf8_chars_to_bytes(sv_ptr(sv), sv->length, byte_off, n);
     }
 
-    rb_encoding *enc = sv_enc(sv);
-    const char *p = sv_ptr(sv) + byte_off;
-    const char *e = sv_ptr(sv) + sv->length;
-    long i;
-    const char *start = p;
+    return sv_tolerant_chars_to_bytes(sv, byte_off, n);
+}
 
-    for (i = 0; i < n && p < e; i++) {
-        p += rb_enc_fast_mbclen(p, e, enc);
+static long sv_char_count_partial(string_view_t *sv, const char *p, long len) {
+    if (len <= 0) return 0;
+    if (sv_single_byte_optimizable(sv)) return len;
+    if (SV_LIKELY(sv_is_utf8(sv)) && sv_valid_encoding_cached(sv)) {
+        return sv_utf8_char_count(p, len);
     }
-    return p - start;
+    return sv_tolerant_char_count(p, p + len, sv_enc(sv));
 }
 
 static VALUE sv_aref(int argc, VALUE *argv, VALUE self) {
@@ -1086,7 +1189,7 @@ static VALUE sv_aref(int argc, VALUE *argv, VALUE self) {
             long total = sv->length;
             if (idx < 0) idx += total;
             if (SV_UNLIKELY(idx < 0 || idx > total || len < 0)) return Qnil;
-            if (idx + len > total) len = total - idx;
+            if (len > total - idx) len = total - idx;
             return sv_new_from_parent_obj(self, sv,
                                        sv->offset + idx,
                                        len);
@@ -1108,7 +1211,7 @@ static VALUE sv_aref(int argc, VALUE *argv, VALUE self) {
 
         /* Clamp len to remaining characters */
         long total_chars = sv_char_count(sv);
-        if (idx + len > total_chars) len = total_chars - idx;
+        if (len > total_chars - idx) len = total_chars - idx;
 
         long byte_end = sv_char_to_byte_offset(sv, idx + len);
         long byte_len = byte_end - byte_off;
@@ -1159,6 +1262,7 @@ static VALUE sv_aref(int argc, VALUE *argv, VALUE self) {
         if (slen == 0) {
             return sv_new_from_parent_obj(self, sv, sv->offset, 0);
         }
+        sv_check_compatible_string(sv, arg1);
         if (slen > sv->length) return Qnil;
 
         long pos = rb_memsearch(RSTRING_PTR(arg1), slen, p, sv->length, sv_enc(sv));
@@ -1206,7 +1310,7 @@ static VALUE sv_byteslice(int argc, VALUE *argv, VALUE self) {
         if (off < 0) off += sv->length;
         if (off < 0 || off > sv->length) return Qnil;
         if (len < 0) return Qnil;
-        if (off + len > sv->length) len = sv->length - off;
+        if (len > sv->length - off) len = sv->length - off;
 
         return sv_new_from_parent_obj(self, sv, sv->offset + off, len);
     }
@@ -1435,8 +1539,9 @@ static VALUE sv_delete_prefix(VALUE self, VALUE prefix) {
     const char *p = sv_ptr(sv);
     long plen = RSTRING_LEN(prefix);
 
-    if (plen > sv->length) return self;
     if (plen == 0) return self;
+    sv_check_compatible_string(sv, prefix);
+    if (plen > sv->length) return self;
     if (memcmp(p, RSTRING_PTR(prefix), plen) != 0) return self;
 
     return sv_new_from_parent_obj(self, sv, sv->offset + plen, sv->length - plen);
@@ -1453,8 +1558,9 @@ static VALUE sv_delete_suffix(VALUE self, VALUE suffix) {
     const char *p = sv_ptr(sv);
     long slen = RSTRING_LEN(suffix);
 
-    if (slen > sv->length) return self;
     if (slen == 0) return self;
+    sv_check_compatible_string(sv, suffix);
+    if (slen > sv->length) return self;
     if (memcmp(p + sv->length - slen, RSTRING_PTR(suffix), slen) != 0) return self;
 
     return sv_new_from_parent_obj(self, sv, sv->offset, sv->length - slen);
@@ -1505,16 +1611,7 @@ static VALUE sv_ord(VALUE self) {
  */
 static VALUE sv_valid_encoding_p(VALUE self) {
     string_view_t *sv = sv_get_struct(self);
-    rb_encoding *enc = sv_enc(sv);
-    const char *p = sv_ptr(sv);
-    const char *e = p + sv->length;
-
-    while (p < e) {
-        int len = rb_enc_precise_mbclen(p, e, enc);
-        if (!MBCLEN_CHARFOUND_P(len)) return Qfalse;
-        p += MBCLEN_CHARFOUND_LEN(len);
-    }
-    return Qtrue;
+    return sv_valid_encoding_cached(sv) ? Qtrue : Qfalse;
 }
 
 /*

data/ext/string_view/string_view.h

@@ -39,6 +39,8 @@ typedef struct {
     long   length;      /* byte length of this view */
     long   charlen;     /* cached character count; -1 = not yet computed */
     int    single_byte; /* cached: 1 if char==byte (ASCII/single-byte enc), 0 if multibyte, -1 unknown */
+    int    valid_encoding; /* cached slice validity: 1 valid, 0 invalid, -1 unknown */
+    int    pooled;      /* 1 if owned by StringView::Pool and subject to reuse */
     stride_index_t *stride_idx; /* lazily built stride index for multibyte, NULL if not built */
 } string_view_t;
 
@@ -83,6 +85,14 @@ SV_INLINE void sv_check_bounds(long off, long len, long backing_len) {
     }
 }
 
+SV_INLINE void sv_clear_stride_index(string_view_t *sv) {
+    if (sv->stride_idx) {
+        xfree(sv->stride_idx->offsets);
+        xfree(sv->stride_idx);
+        sv->stride_idx = NULL;
+    }
+}
+
 /*
  * Initialize (or reinitialize) a string_view_t's fields from a frozen backing
  * string. Caller is responsible for freeing any prior stride_idx.
@@ -96,6 +106,8 @@ SV_INLINE void sv_init_fields(VALUE obj, string_view_t *sv, VALUE backing,
     sv->offset      = offset;
     sv->length      = length;
     sv->single_byte = sv_compute_single_byte(backing, enc);
+    sv->valid_encoding = sv->single_byte == 1 ? 1 : -1;
+    sv->pooled      = 0;
     sv->charlen     = -1;
     sv->stride_idx  = NULL;
 }

data/ext/string_view/string_view_core_ext.c

@@ -4,41 +4,26 @@
 /* StringView::CoreExt — module with String#view, included on demand         */
 /* ========================================================================= */
 
-/* ObjectSpace::WeakKeyMap caching String → Pool.
- * Keys (strings) are held weakly — when a string is GC'd, its entry
- * is automatically removed. Values (pools) are held strongly. */
-static VALUE pool_cache;
-static ID id_aref;
-static ID id_aset;
-
 /*
  * view(byte_offset, byte_length) → StringView
  *
  * Returns a StringView into this string at the given byte range.
- * Lazily creates a StringView::Pool and caches it in a global
- * WeakKeyMap for automatic cleanup when the string is GC'd.
+ * The backing string is frozen in place so StringView can safely reference it.
+ * Each call returns a fresh StringView; callers that want explicit object reuse
+ * should opt into StringView::Pool directly.
  */
 static VALUE string_view_method(VALUE self, VALUE voffset, VALUE vlength) {
+    VALUE args[3];
+
     rb_str_freeze(self);
 
-    VALUE pool = rb_funcall(pool_cache, id_aref, 1, self);
-    if (NIL_P(pool)) {
-        pool = rb_class_new_instance(1, &self, cStringViewPool);
-        rb_funcall(pool_cache, id_aset, 2, self, pool);
-    }
-    return pool_view(pool, voffset, vlength);
+    args[0] = self;
+    args[1] = voffset;
+    args[2] = vlength;
+    return rb_class_new_instance(3, args, cStringView);
 }
 
 void Init_string_view_core_ext(void) {
-    id_aref = rb_intern("[]");
-    id_aset = rb_intern("[]=");
-
-    VALUE cWeakKeyMap = rb_const_get(
-        rb_const_get(rb_cObject, rb_intern("ObjectSpace")),
-        rb_intern("WeakKeyMap"));
-    pool_cache = rb_class_new_instance(0, NULL, cWeakKeyMap);
-    rb_gc_register_mark_object(pool_cache);
-
     VALUE mCoreExt = rb_define_module_under(cStringView, "CoreExt");
     rb_define_method(mCoreExt, "view", string_view_method, 2);
 }

data/ext/string_view/string_view_pool.c

@@ -73,6 +73,7 @@ static void pool_grow(sv_pool_t *pool, VALUE pool_obj) {
         VALUE obj = TypedData_Make_Struct(cStringView, string_view_t,
                                          &string_view_type, sv);
         sv_init_fields(obj, sv, pool->backing, pool->base, pool->enc, 0, 0);
+        sv->pooled = 1;
         rb_ary_push(pool->views, obj);
     }
 
@@ -145,12 +146,15 @@ VALUE pool_view(VALUE self, VALUE voffset, VALUE vlength) {
     VALUE view = RARRAY_AREF(pool->views, pool->next_idx);
     pool->next_idx++;
 
+    if (SV_UNLIKELY(OBJ_FROZEN(view))) {
+        rb_raise(rb_eFrozenError,
+                 "can't reuse a frozen pooled StringView; materialize it before freezing");
+    }
+
     string_view_t *sv = (string_view_t *)RTYPEDDATA_GET_DATA(view);
-    sv->base    = pool->base;   /* refresh in case backing was mutated */
-    sv->offset  = off;
-    sv->length  = len;
-    sv->charlen = -1;           /* invalidate cached char count */
-    sv->stride_idx = NULL;      /* invalidate stride index */
+    sv_clear_stride_index(sv);
+    sv_init_fields(view, sv, pool->backing, pool->base, pool->enc, off, len);
+    sv->pooled = 1;
 
     return view;
 }

data/lib/string_view/version.rb

@@ -4,5 +4,5 @@
 # without requiring the C extension.
 # The C extension defines StringView as a class, so we use `class` here.
 class StringView
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: string_view
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-03-19 00:00:00.000000000 Z
+date: 2026-04-13 00:00:00.000000000 Z
 dependencies: []
 description: StringView provides a read-only, zero-copy view into a frozen Ruby String,
   avoiding intermediate allocations for slicing, searching, and delegation of transform