oj 3.16.16 → 3.16.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07c7a6ebc6baf4f02b93760ed3d7440cdc9b2af85d0976e525f34978ab823c45
-  data.tar.gz: ed5a5a2e16f8df836a098de0da60657688049cfcf820d3142b4122302ae4e946
+  metadata.gz: 8cea6645d77bacff66ea8a69d5c5211aa2e9366decc1e8dec909cc83f08933af
+  data.tar.gz: d286d46148ef014003a9a23a87cf33da532e09a6ce0228f4e5b47eff963d985f
 SHA512:
-  metadata.gz: d8f5c73fbc30a2985c2352e466f8ef9762f831d15b9c0a8b9394d66a5613910fd5aca4c4bdc49c40230128d791244ad67f6f9852c4778e89828a4358bb997c11
-  data.tar.gz: dbc5fe50d1ad89cb23918c950ac849052a95defb7e5509d7653236eb3569c811685e2c4c6546a8ab38c5a346aad0ccdd9770c855bc53f96c0c5312c7d61fab3e
+  metadata.gz: a66845146062e764671ed0556076590ecc6507f04e21613ed5514df9e19e35c5e48b2fe9095cd7376fd82376a9b055aa8fc9e17e74c2bfaaa80ba1cebef0ddfe
+  data.tar.gz: 8b4af7c9cc6fadf664ff643c081783921e05f793d03c512bcf178e47173fc0e620f851382cb423c99769f01fd6080ad376c663a781faa14249cfc66009a182d2

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # CHANGELOG
 
+## 3.16.17 - 2026-04-12
+
+- Rails optimize for Hash and Array now overrides `as_json` for those
+  classes. Note that when either is optimized with `Oj.optimize_rails`
+  the `Array.as_json` and `Hash.as_json` will not be called.
+
+- Add support for the rails encoder `:only` and `:except` options.
+
+- Handle unterminated strings in usual parser (#1002)
+
+- Fix read() not handling partial reads for large files (#1004)
+
+- Raise error for incomplete primitive literals (#1005)
+
 ## 3.16.16 - 2026-03-13
 
 - Not closed arrays and objects are reported corrected in the usual parser.

data/ext/oj/custom.c

@@ -287,6 +287,11 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     if (out->omit_nil && Qnil == value) {
         return ST_CONTINUE;
     }
+    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+        if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
+            return ST_CONTINUE;
+        }
+    }
     if (!out->opts->dump_opts.use) {
         assure_size(out, depth * out->indent + 1);
         fill_indent(out, depth);

data/ext/oj/dump.c

@@ -257,7 +257,30 @@ inline static size_t hibit_friendly_size(const uint8_t *str, size_t len) {
         size += tmp;
     }
 
+#ifdef HAVE_FAST_MEMCPY
+    size_t total = 0;
+    if (len - i > 4) {
+        size += (len - i);
+        unsigned char buf[sizeof(uint8x16_t)];
+        memset(buf, ' ', sizeof(buf));
+        fast_memcpy16(buf, str, len - i);
+
+        uint8x16_t chunk  = vld1q_u8((const unsigned char *)buf);
+        uint8x16_t tmp1   = vqtbl4q_u8(hibit_friendly_chars_neon[0], chunk);
+        uint8x16_t tmp2   = vqtbl4q_u8(hibit_friendly_chars_neon[1], veorq_u8(chunk, vdupq_n_u8(0x40)));
+        uint8x16_t result = vorrq_u8(tmp1, tmp2);
+        uint8_t    tmp    = vaddvq_u8(result);
+
+        size += tmp;
+
+        total = size;
+    } else {
+        total = size + calculate_string_size(str, len - i, hibit_friendly_chars);
+    }
+#else
     size_t total = size + calculate_string_size(str, len - i, hibit_friendly_chars);
+#endif
+
     return total;
 #elif defined(HAVE_SIMD_SSE4_2)
     if (SIMD_Impl == SIMD_SSE42) {
@@ -967,11 +990,12 @@ typedef struct _neon_match_result {
     uint8x16_t needs_escape;
     bool       has_some_hibit;
     bool       do_unicode_validation;
+    uint64_t   escape_mask;
 } neon_match_result;
 
 static inline FORCE_INLINE neon_match_result
 neon_update(const char *str, uint8x16x4_t *cmap_neon, int neon_table_size, bool do_unicode_validation, bool has_hi) {
-    neon_match_result result = {.has_some_hibit = false, .do_unicode_validation = false};
+    neon_match_result result = {.has_some_hibit = false, .do_unicode_validation = false, .escape_mask = 0};
 
     uint8x16_t chunk    = vld1q_u8((const unsigned char *)str);
     uint8x16_t tmp1     = vqtbl4q_u8(cmap_neon[0], chunk);
@@ -987,6 +1011,9 @@ neon_update(const char *str, uint8x16x4_t *cmap_neon, int neon_table_size, bool
         result.has_some_hibit        = vmaxvq_u8(has_some_hibit) != 0;
         result.do_unicode_validation = has_hi && do_unicode_validation && result.has_some_hibit;
     }
+    const uint8x8_t res  = vshrn_n_u16(vreinterpretq_u16_u8(vmvnq_u8(vceqq_u8(result.needs_escape, vdupq_n_u8(0)))), 4);
+    const uint64_t  mask = vget_lane_u64(vreinterpret_u64_u8(res), 0);
+    result.escape_mask   = mask & 0x8888888888888888ull;
     return result;
 }
 
@@ -1189,7 +1216,16 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         if (is_sym) {
             *out->cur++ = ':';
         }
+#ifdef HAVE_FAST_MEMCPY
+        if (cnt <= 16) {
+            fast_memcpy16(out->cur, str, cnt);
+            out->cur += size;
+        } else {
+            APPEND_CHARS(out->cur, str, cnt);
+        }
+#else
         APPEND_CHARS(out->cur, str, cnt);
+#endif
         *out->cur++ = '"';
     } else {
         const char *end         = str + cnt;
@@ -1223,6 +1259,17 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
 #endif
 
 #ifdef HAVE_SIMD_NEON
+
+#ifdef HAVE_FAST_MEMCPY
+#define APPEND_CHARS_SMALL(dst, src, length) \
+    fast_memcpy16((dst), (src), (length));   \
+    (dst) += (length);
+#define MEMCPY16 fast_memcpy16
+#else
+#define APPEND_CHARS_SMALL(dst, src, length) APPEND_CHARS(dst, str, length);
+#define MEMCPY16 memcpy
+#endif
+
         if (use_simd) {
             while (str < end) {
                 const char *chunk_ptr = NULL;
@@ -1231,8 +1278,8 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
                     chunk_start = str;
                     chunk_end   = str + sizeof(uint8x16_t);
                 } else if ((end - str) >= SIMD_MINIMUM_THRESHOLD) {
-                    memset(out->cur, 'A', sizeof(uint8x16_t));
-                    memcpy(out->cur, str, (end - str));
+                    memset(out->cur, ' ', sizeof(uint8x16_t));
+                    MEMCPY16(out->cur, str, (end - str));
                     chunk_ptr   = out->cur;
                     chunk_start = str;
                     chunk_end   = end;
@@ -1244,32 +1291,22 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
                                                        neon_table_size,
                                                        do_unicode_validation,
                                                        has_hi);
-                if ((result.do_unicode_validation) || vmaxvq_u8(result.needs_escape) != 0) {
+                if ((result.do_unicode_validation) || result.escape_mask != 0) {
                     SEARCH_FLUSH;
-                    uint8x16_t actions     = vaddq_u8(result.needs_escape, vdupq_n_u8('1'));
-                    uint8_t    num_matches = vaddvq_u8(vandq_u8(result.needs_escape, vdupq_n_u8(0x1)));
+                    bool       process_each = result.do_unicode_validation;
+                    uint8x16_t actions      = vaddq_u8(result.needs_escape, vdupq_n_u8('1'));
                     vst1q_u8((unsigned char *)matches, actions);
-                    bool process_each = result.do_unicode_validation || (num_matches > sizeof(uint8x16_t) / 2);
                     // If no byte in this chunk had the high bit set then we can skip
                     // all of the '1' bytes by directly copying them to the output.
                     if (!process_each) {
-                        while (str < chunk_end) {
-                            long i = str - chunk_start;
-                            char action;
-                            while (str < chunk_end && (action = matches[i++]) == '1') {
-                                *out->cur++ = *str++;
+                        while (result.escape_mask) {
+                            int  esc_pos = OJ_CTZ64(result.escape_mask) >> 2;
+                            long run_len = esc_pos - (str - chunk_start);
+                            if (run_len > 0) {
+                                APPEND_CHARS_SMALL(out->cur, str, run_len);
+                                str += run_len;
                             }
-                            cursor = str;
-                            if (str >= chunk_end) {
-                                break;
-                            }
-                            str = process_character(action, str, end, out, orig, do_unicode_validation, &check_start);
-                            str++;
-                        }
-                    } else {
-                        while (str < chunk_end) {
-                            long match_index = str - chunk_start;
-                            str              = process_character(matches[match_index],
+                            str = process_character(matches[esc_pos],
                                                     str,
                                                     end,
                                                     out,
@@ -1277,6 +1314,23 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
                                                     do_unicode_validation,
                                                     &check_start);
                             str++;
+                            result.escape_mask &= result.escape_mask - 1;
+                        }
+                        if (str < chunk_end) {
+                            APPEND_CHARS_SMALL(out->cur, str, chunk_end - str);
+                            str = chunk_end;
+                        }
+                    } else {
+                        while (str < chunk_end) {
+                            long match_index = str - chunk_start;
+                            str              = process_character(matches[match_index],
+                                                                 str,
+                                                                 end,
+                                                                 out,
+                                                                 orig,
+                                                                 do_unicode_validation,
+                                                                 &check_start);
+                            str++;
                         }
                     }
                     cursor = str;
@@ -1317,12 +1371,12 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
                         while (str < chunk_end) {
                             long match_index = str - chunk_start;
                             str              = process_character(matches[match_index],
-                                                    str,
-                                                    end,
-                                                    out,
-                                                    orig,
-                                                    do_unicode_validation,
-                                                    &check_start);
+                                                                 str,
+                                                                 end,
+                                                                 out,
+                                                                 orig,
+                                                                 do_unicode_validation,
+                                                                 &check_start);
                             str++;
                         }
                         cursor = str;
@@ -1687,3 +1741,25 @@ size_t oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const c
     }
     return cnt;
 }
+
+bool oj_key_skip(VALUE key, const char *only, const char *except) {
+    const char *skey;
+
+    switch (rb_type(key)) {
+    case RUBY_T_STRING: skey = StringValueCStr(key); break;
+    case RUBY_T_SYMBOL: skey = rb_id2name(rb_sym2id(key)); break;
+    default: skey = NULL; break;
+    }
+    if (NULL != skey && '\0' != *skey) {
+        size_t size = strlen(skey);
+        char  *buf  = alloca(size + 3);
+
+        buf[0] = ':';
+        strcpy(buf + 1, skey);
+        buf[size + 1] = ':';
+        buf[size + 2] = '\0';
+
+        return ((NULL != only && NULL == strstr(only, buf)) || (NULL != except && NULL != strstr(except, buf)));
+    }
+    return NULL != only;
+}

data/ext/oj/dump.h

@@ -62,6 +62,8 @@ extern size_t oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d,
 
 extern time_t oj_sec_from_time_hard_way(VALUE obj);
 
+extern bool oj_key_skip(VALUE key, const char *only, const char *except);
+
 inline static void assure_size(Out out, size_t len) {
     if (out->end - out->cur <= (long)len) {
         oj_grow_out(out, len);

data/ext/oj/dump_compat.c

@@ -605,6 +605,11 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     if (out->omit_nil && Qnil == value) {
         return ST_CONTINUE;
     }
+    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+        if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
+            return ST_CONTINUE;
+        }
+    }
     if (!out->opts->dump_opts.use) {
         assure_size(out, depth * out->indent + 1);
         fill_indent(out, depth);

data/ext/oj/dump_object.c

@@ -210,6 +210,11 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     if (out->omit_nil && Qnil == value) {
         return ST_CONTINUE;
     }
+    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+        if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
+            return ST_CONTINUE;
+        }
+    }
     assure_size(out, size);
     fill_indent(out, depth);
     switch (rb_type(key)) {

data/ext/oj/dump_strict.c

@@ -193,14 +193,19 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     if (out->omit_nil && Qnil == value) {
         return ST_CONTINUE;
     }
+    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+        if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
+            return ST_CONTINUE;
+        }
+    }
     if (!out->opts->dump_opts.use) {
         size = depth * out->indent + 1;
         assure_size(out, size);
         fill_indent(out, depth);
-        if (rtype == T_STRING) {
-            oj_dump_str(key, 0, out, false);
-        } else {
-            oj_dump_sym(key, 0, out, false);
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
         }
         *out->cur++ = ':';
     } else {
@@ -215,10 +220,10 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
                 APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
             }
         }
-        if (rtype == T_STRING) {
-            oj_dump_str(key, 0, out, false);
-        } else {
-            oj_dump_sym(key, 0, out, false);
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
         }
         size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
         assure_size(out, size);

data/ext/oj/mimic_json.c

@@ -735,6 +735,8 @@ static struct _options mimic_object_to_json_options = {0,              // indent
                                                            false,     // omit_nil
                                                            false,     // omit_null_byte
                                                            100,       // max_depth
+                                                           NULL,      // only
+                                                           NULL,      // except
                                                        },
                                                        {
                                                            // str_rx

data/ext/oj/oj.c

@@ -120,6 +120,7 @@ static VALUE create_id_sym;
 static VALUE custom_sym;
 static VALUE empty_string_sym;
 static VALUE escape_mode_sym;
+static VALUE except_sym;
 static VALUE integer_range_sym;
 static VALUE fast_sym;
 static VALUE float_prec_sym;
@@ -138,6 +139,7 @@ static VALUE null_sym;
 static VALUE object_sym;
 static VALUE omit_null_byte_sym;
 static VALUE omit_nil_sym;
+static VALUE only_sym;
 static VALUE rails_sym;
 static VALUE raise_sym;
 static VALUE ruby_sym;
@@ -228,6 +230,8 @@ struct _options oj_default_options = {
         false,      // omit_nil
         false,      // omit_null_byte
         MAX_DEPTH,  // max_depth
+        NULL,       // only
+        NULL,       // except
     },
     {
         // str_rx
@@ -238,6 +242,22 @@ struct _options oj_default_options = {
     NULL,
 };
 
+static VALUE only_array_from_string(const char *str) {
+    volatile VALUE a = Qnil;
+
+    if (NULL != str && 2 < strlen(str)) {
+        str++;
+        char *cp;
+
+        a = rb_ary_new();
+        while (NULL != (cp = strchr(str, ':'))) {
+            rb_ary_push(a, rb_id2sym(rb_intern2(str, cp - str)));
+            str = cp + 1;
+        }
+    }
+    return a;
+}
+
 /* Document-method: default_options()
  *	call-seq: default_options()
  *
@@ -318,6 +338,8 @@ struct _options oj_default_options = {
  *   (trace is off)
  * - *:safe* [_true,_|_false_] Safe mimic breaks JSON mimic to be safer, default
  *   is false (safe is off)
+ * - *:only* [_nil,_|_Array_] A list of the fields to encode. All others are skipped.
+ * - *:except* [_nil,_|_Array_] A list of the fields to not encode. All others are encoded.
  *
  * Return [_Hash_] all current option settings.
  */
@@ -483,6 +505,9 @@ static VALUE get_def_opts(VALUE self) {
     rb_hash_aset(opts, oj_hash_class_sym, oj_default_options.hash_class);
     rb_hash_aset(opts, oj_array_class_sym, oj_default_options.array_class);
 
+    rb_hash_aset(opts, only_sym, only_array_from_string(oj_default_options.dump_opts.only));
+    rb_hash_aset(opts, except_sym, only_array_from_string(oj_default_options.dump_opts.except));
+
     if (NULL == oj_default_options.ignore) {
         rb_hash_aset(opts, ignore_sym, Qnil);
     } else {
@@ -625,6 +650,95 @@ bool set_yesno_options(VALUE key, VALUE value, Options copts) {
     return false;
 }
 
+static const char *make_only_value(VALUE v) {
+    switch (rb_type(v)) {
+    case RUBY_T_NIL:
+    case RUBY_T_NONE: return NULL;
+    case RUBY_T_ARRAY: {
+        long  len = rb_array_len(v);
+        long  i;
+        long  size = 0;
+        char *buf;
+        char *bp;
+
+        for (i = 0; i < len; i++) {
+            VALUE x = rb_ary_entry(v, i);
+
+            switch (rb_type(x)) {
+            case RUBY_T_SYMBOL:
+                size += strlen(rb_id2name(rb_sym2id(x)));
+                size++;
+                break;
+            case RUBY_T_STRING:
+                size += strlen(StringValueCStr(x));
+                size++;
+                break;
+            default: rb_raise(rb_eArgError, ":only and :except must be nil, symbol, string, or array."); break;
+            }
+        }
+        if (0 == size) {
+            return NULL;
+        }
+        buf   = OJ_R_ALLOC_N(char, size + 2);
+        bp    = buf;
+        *bp++ = ':';
+        for (i = 0; i < len; i++) {
+            VALUE       x = rb_ary_entry(v, i);
+            const char *str;
+
+            switch (rb_type(x)) {
+            case RUBY_T_SYMBOL:
+                str  = rb_id2name(rb_sym2id(x));
+                size = strlen(str);
+                memcpy(bp, str, size);
+                bp += size;
+                *bp++ = ':';
+                break;
+            case RUBY_T_STRING:
+                str  = StringValueCStr(x);
+                size = strlen(str);
+                memcpy(bp, str, size);
+                bp += size;
+                *bp++ = ':';
+                break;
+            default:
+                // ignore
+                break;
+            }
+        }
+        *bp = '\0';
+
+        return buf;
+    }
+    case RUBY_T_STRING: {
+        const char *str  = StringValueCStr(v);
+        size_t      size = strlen(str);
+        char       *buf  = OJ_R_ALLOC_N(char, size + 3);
+
+        buf[0] = ':';
+        strcpy(buf + 1, str);
+        buf[size + 1] = ':';
+        buf[size + 2] = '\0';
+
+        return buf;
+    }
+    case RUBY_T_SYMBOL: {
+        const char *str  = rb_id2name(rb_sym2id(v));
+        size_t      size = strlen(str);
+        char       *buf  = OJ_R_ALLOC_N(char, size + 3);
+
+        buf[0] = ':';
+        strcpy(buf + 1, str);
+        buf[size + 1] = ':';
+        buf[size + 2] = '\0';
+
+        return buf;
+    }
+    default: rb_raise(rb_eArgError, ":only and zzz :except must be nil, symbol, string, or array."); break;
+    }
+    return NULL;
+}
+
 static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
     Options copts = (Options)opts;
     size_t  len;
@@ -981,6 +1095,18 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts) {
         }
         strncpy(copts->float_fmt, RSTRING_PTR(v), (size_t)RSTRING_LEN(v));
         copts->float_fmt[RSTRING_LEN(v)] = '\0';
+    } else if (only_sym == k) {
+        if (NULL != copts->dump_opts.only) {
+            OJ_R_FREE((void *)copts->dump_opts.only);
+            copts->dump_opts.only = NULL;
+        }
+        copts->dump_opts.only = make_only_value(v);
+    } else if (except_sym == k) {
+        if (NULL != copts->dump_opts.except) {
+            OJ_R_FREE((void *)copts->dump_opts.except);
+            copts->dump_opts.except = NULL;
+        }
+        copts->dump_opts.except = make_only_value(v);
     }
     return ST_CONTINUE;
 }
@@ -2133,6 +2259,10 @@ void Init_oj(void) {
     rb_gc_register_address(&xmlschema_sym);
     xss_safe_sym = ID2SYM(rb_intern("xss_safe"));
     rb_gc_register_address(&xss_safe_sym);
+    only_sym = ID2SYM(rb_intern("only"));
+    rb_gc_register_address(&only_sym);
+    except_sym = ID2SYM(rb_intern("except"));
+    rb_gc_register_address(&except_sym);
 
     oj_slash_string = rb_str_new2("/");
     rb_gc_register_address(&oj_slash_string);

data/ext/oj/oj.h

@@ -104,21 +104,23 @@ typedef enum {
 } StreamWriterType;
 
 typedef struct _dumpOpts {
-    bool    use;
-    char    indent_str[16];
-    char    before_sep[16];
-    char    after_sep[16];
-    char    hash_nl[16];
-    char    array_nl[16];
-    uint8_t indent_size;
-    uint8_t before_size;
-    uint8_t after_size;
-    uint8_t hash_size;
-    uint8_t array_size;
-    char    nan_dump;  // NanDump
-    bool    omit_nil;
-    bool    omit_null_byte;
-    int     max_depth;
+    bool        use;
+    char        indent_str[16];
+    char        before_sep[16];
+    char        after_sep[16];
+    char        hash_nl[16];
+    char        array_nl[16];
+    uint8_t     indent_size;
+    uint8_t     before_size;
+    uint8_t     after_size;
+    uint8_t     hash_size;
+    uint8_t     array_size;
+    char        nan_dump;  // NanDump
+    bool        omit_nil;
+    bool        omit_null_byte;
+    int         max_depth;
+    const char *only;
+    const char *except;
 } *DumpOpts;
 
 typedef struct _options {
@@ -143,7 +145,7 @@ typedef struct _options {
     char             quirks_mode;    // allow single JSON values instead of documents
     char             allow_invalid;  // YesNo - allow invalid unicode
     char             create_ok;      // YesNo allow create_id
-    char             allow_nan;      // YEsyNo for parsing only
+    char             allow_nan;      // YesNo for parsing only
     char             trace;          // YesNo
     char             safe;           // YesNo
     char             sec_prec_set;   // boolean (0 or 1)

data/ext/oj/parse.c

@@ -209,7 +209,7 @@ static inline const char *string_scan_neon(const char *str, const char *end) {
     while (str + sizeof(uint8x16_t) <= end) {
         uint8x16_t      chunk = vld1q_u8((const uint8_t *)str);
         uint8x16_t      tmp   = vorrq_u8(vorrq_u8(vceqq_u8(chunk, null_char), vceqq_u8(chunk, backslash)),
-                                  vceqq_u8(chunk, quote));
+                                         vceqq_u8(chunk, quote));
         const uint8x8_t res   = vshrn_n_u16(vreinterpretq_u16_u8(tmp), 4);
         uint64_t        mask  = vget_lane_u64(vreinterpret_u64_u8(res), 0);
         if (mask != 0) {
@@ -285,10 +285,10 @@ static OJ_TARGET_SSE42 const char *scan_string_SSE42(const char *str, const char
     for (; str <= safe_end_16; str += 16) {
         const __m128i string = _mm_loadu_si128((const __m128i *)str);
         const int     r      = _mm_cmpestri(terminate,
-                                   3,
-                                   string,
-                                   16,
-                                   _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
+                                            3,
+                                            string,
+                                            16,
+                                            _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT);
         if (r != 16)
             return str + r;
     }
@@ -611,7 +611,7 @@ static void read_num(ParseInfo pi) {
         ni.bigdec_load = pi->options.compat_bigdec;
     } else {
         ni.no_big      = (FloatDec == pi->options.bigdec_load || FastDec == pi->options.bigdec_load ||
-                     RubyDec == pi->options.bigdec_load);
+                          RubyDec == pi->options.bigdec_load);
         ni.bigdec_load = pi->options.bigdec_load;
     }
 
@@ -1193,11 +1193,19 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
             buf      = OJ_R_ALLOC_N(char, len + 1);
             pi->json = buf;
             pi->end  = buf + len;
-            if (0 >= (cnt = read(fd, (char *)pi->json, len)) || cnt != (ssize_t)len) {
-                if (0 != buf) {
-                    OJ_R_FREE(buf);
+            {
+                size_t total = 0;
+
+                while (total < len) {
+                    cnt = read(fd, (char *)pi->json + total, len - total);
+                    if (cnt <= 0) {
+                        if (0 != buf) {
+                            OJ_R_FREE(buf);
+                        }
+                        rb_raise(rb_eIOError, "failed to read from IO Object.");
+                    }
+                    total += cnt;
                 }
-                rb_raise(rb_eIOError, "failed to read from IO Object.");
             }
             ((char *)pi->json)[len] = '\0';
             /* skip UTF-8 BOM if present */

data/ext/oj/parser.c

@@ -635,6 +635,9 @@ static void parse(ojParser p, const byte *json) {
             if ('"' == *b) {
                 p->map = colon_map;
                 break;
+            } else if ('\0' == *b) {
+                parse_error(p, "quoted string not terminated");
+                break;
             }
             b--;
             p->map      = string_map;
@@ -659,6 +662,9 @@ static void parse(ojParser p, const byte *json) {
                 p->funcs[p->stack[p->depth]].add_str(p);
                 p->map = (0 == p->depth) ? value_map : after_map;
                 break;
+            } else if ('\0' == *b) {
+                parse_error(p, "quoted string not terminated");
+                break;
             }
             b--;
             p->map      = string_map;
@@ -1354,6 +1360,35 @@ static VALUE parser_missing(int argc, VALUE *argv, VALUE self) {
     return p->option(p, key, rv);
 }
 
+static void validate_primitives_are_complete(ojParser p) {
+    if (0 >= p->ri) {
+        return;
+    }
+
+    switch (p->map[256]) {
+    case 'N': parse_error(p, "expected null"); break;
+    case 'F': parse_error(p, "expected false"); break;
+    case 'T': parse_error(p, "expected true"); break;
+    }
+}
+
+static void validate_non_primitives_are_complete(ojParser p) {
+    if (0 >= p->depth) {
+        return;
+    }
+
+    if (OBJECT_FUN == p->stack[p->depth]) {
+        parse_error(p, "Object is not closed");
+    } else {
+        parse_error(p, "Array is not closed");
+    }
+}
+
+static void validate_document_end(ojParser p) {
+    validate_primitives_are_complete(p);
+    validate_non_primitives_are_complete(p);
+}
+
 /* Document-method: parse(json)
  * call-seq: parse(json)
  *
@@ -1371,13 +1406,8 @@ static VALUE parser_parse(VALUE self, VALUE json) {
     p->start(p);
     parse(p, ptr);
 
-    if (0 < p->depth) {
-        if (OBJECT_FUN == p->stack[p->depth]) {
-            parse_error(p, "Object is not closed");
-        } else {
-            parse_error(p, "Array is not closed");
-        }
-    }
+    validate_document_end(p);
+
     return p->result(p);
 }
 

data/ext/oj/rails.c

@@ -920,7 +920,7 @@ static VALUE encode(VALUE obj, ROptTable ropts, Options opts, int argc, VALUE *a
     if (Yes == copts.circular) {
         oj_cache8_new(&out.circ_cache);
     }
-    // dump_rails_val(*argv, 0, &out, true);
+
     rb_protect(protect_dump, (VALUE)&oo, &line);
 
     if (0 == line) {
@@ -1219,8 +1219,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
             return;
         }
     }
-    // if (!oj_rails_array_opt && as_ok && 0 < out->argc && rb_respond_to(a, oj_as_json_id)) {
-    if (as_ok && 0 < out->argc && rb_respond_to(a, oj_as_json_id)) {
+    if (!oj_rails_array_opt && as_ok && rb_respond_to(a, oj_as_json_id)) {
         dump_as_json(a, depth, out, false);
         return;
     }
@@ -1287,18 +1286,19 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     if (out->omit_nil && Qnil == value) {
         return ST_CONTINUE;
     }
-    if (rtype != T_STRING && rtype != T_SYMBOL) {
-        key   = oj_safe_string_convert(key);
-        rtype = rb_type(key);
+    if (NULL != out->opts->dump_opts.only || NULL != out->opts->dump_opts.except) {
+        if (oj_key_skip(key, out->opts->dump_opts.only, out->opts->dump_opts.except)) {
+            return ST_CONTINUE;
+        }
     }
     if (!out->opts->dump_opts.use) {
         size = depth * out->indent + 1;
         assure_size(out, size);
         fill_indent(out, depth);
-        if (rtype == T_STRING) {
-            oj_dump_str(key, 0, out, false);
-        } else {
-            oj_dump_sym(key, 0, out, false);
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
         }
         *out->cur++ = ':';
     } else {
@@ -1313,10 +1313,10 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
                 APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
             }
         }
-        if (rtype == T_STRING) {
-            oj_dump_str(key, 0, out, false);
-        } else {
-            oj_dump_sym(key, 0, out, false);
+        switch (rtype) {
+        case T_STRING: oj_dump_str(key, 0, out, false); break;
+        case T_SYMBOL: oj_dump_sym(key, 0, out, false); break;
+        default: oj_dump_str(oj_safe_string_convert(key), 0, out, false); break;
         }
         size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
         assure_size(out, size);
@@ -1345,7 +1345,7 @@ static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
             return;
         }
     }
-    if ((!oj_rails_hash_opt || 0 < out->argc) && as_ok && rb_respond_to(obj, oj_as_json_id)) {
+    if (!oj_rails_hash_opt && as_ok && rb_respond_to(obj, oj_as_json_id)) {
         dump_as_json(obj, depth, out, false);
         return;
     }

data/ext/oj/saj.c

@@ -648,8 +648,16 @@ oj_saj_parse(int argc, VALUE *argv, VALUE self) {
             len = lseek(fd, 0, SEEK_END);
             lseek(fd, 0, SEEK_SET);
             json = OJ_R_ALLOC_N(char, len + 1);
-            if (0 >= (cnt = read(fd, json, len)) || cnt != (ssize_t)len) {
-                rb_raise(rb_eIOError, "failed to read from IO Object.");
+            {
+                size_t total = 0;
+
+                while (total < len) {
+                    cnt = read(fd, json + total, len - total);
+                    if (cnt <= 0) {
+                        rb_raise(rb_eIOError, "failed to read from IO Object.");
+                    }
+                    total += cnt;
+                }
             }
             json[len] = '\0';
 #endif

data/ext/oj/simd.h

@@ -191,4 +191,29 @@ static inline OJ_TARGET_SSE42 __m128i vector_lookup_sse42(__m128i input, __m128i
 
 #endif
 
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+#if __has_builtin(__builtin_memcpy)
+#define HAVE_FAST_MEMCPY 1
+
+inline static void fast_memcpy16(void *dest, const void *src, size_t n) {
+    char *d = (char *)dest;
+    char *s = (char *)src;
+    if (n >= 8) {
+        __builtin_memcpy(d, s, 8);
+        __builtin_memcpy(d + n - 8, s + n - 8, 8);
+    } else if (n >= 4) {
+        __builtin_memcpy(d, s, 4);
+        __builtin_memcpy(d + n - 4, s + n - 4, 4);
+    } else if (n >= 2) {
+        __builtin_memcpy(d, s, 2);
+        __builtin_memcpy(d + n - 2, s + n - 2, 2);
+    } else if (n >= 1) {
+        *d = *s;
+    }
+}
+#endif
+
 #endif /* OJ_SIMD_H */

data/ext/oj/sparse.c

@@ -415,7 +415,7 @@ static void read_num(ParseInfo pi) {
         ni.bigdec_load = pi->options.compat_bigdec;
     } else {
         ni.no_big      = (FloatDec == pi->options.bigdec_load || FastDec == pi->options.bigdec_load ||
-                     RubyDec == pi->options.bigdec_load);
+                          RubyDec == pi->options.bigdec_load);
         ni.bigdec_load = pi->options.bigdec_load;
     }
 
@@ -565,7 +565,7 @@ static void read_nan(ParseInfo pi) {
         ni.bigdec_load = pi->options.compat_bigdec;
     } else {
         ni.no_big      = (FloatDec == pi->options.bigdec_load || FastDec == pi->options.bigdec_load ||
-                     RubyDec == pi->options.bigdec_load);
+                          RubyDec == pi->options.bigdec_load);
         ni.bigdec_load = pi->options.bigdec_load;
     }
 
@@ -761,7 +761,7 @@ void oj_sparse2(ParseInfo pi) {
                     ni.bigdec_load = pi->options.compat_bigdec;
                 } else {
                     ni.no_big      = (FloatDec == pi->options.bigdec_load || FastDec == pi->options.bigdec_load ||
-                                 RubyDec == pi->options.bigdec_load);
+                                      RubyDec == pi->options.bigdec_load);
                     ni.bigdec_load = pi->options.bigdec_load;
                 }
                 add_num_value(pi, &ni);

data/lib/oj/version.rb

@@ -1,4 +1,4 @@
 module Oj
   # Current version of the module.
-  VERSION = '3.16.16'
+  VERSION = '3.16.17'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 3.16.16
+  version: 3.16.17
 platform: ruby
 authors:
 - Peter Ohler