oj 3.16.16 → 3.17.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07c7a6ebc6baf4f02b93760ed3d7440cdc9b2af85d0976e525f34978ab823c45
-  data.tar.gz: ed5a5a2e16f8df836a098de0da60657688049cfcf820d3142b4122302ae4e946
+  metadata.gz: e7458dcdf494ef6b1b283ca86d51fba0b3102ecf5cec13f43682878c01708c80
+  data.tar.gz: ab8099b8b275aa5acab45a012bbc96ef0c860e041be2c4ae7d6f7cd331da1755
 SHA512:
-  metadata.gz: d8f5c73fbc30a2985c2352e466f8ef9762f831d15b9c0a8b9394d66a5613910fd5aca4c4bdc49c40230128d791244ad67f6f9852c4778e89828a4358bb997c11
-  data.tar.gz: dbc5fe50d1ad89cb23918c950ac849052a95defb7e5509d7653236eb3569c811685e2c4c6546a8ab38c5a346aad0ccdd9770c855bc53f96c0c5312c7d61fab3e
+  metadata.gz: 60d445fd27bbea120359c21d0c1b0ac1d4fbbd678c8fd28efe620706d382a2f0cc434645967c9bac0b6d08d1065fe99dc4b15e2623d98ca0e15a61eb591a993b
+  data.tar.gz: b7736fd3a7b27f98ef3e4df05464000849403ff33a3f82ecd6d8c51b40d0c2753d23ed14c078eb26506d504de991e35ebe68e5703225c80aab6ebbd28b7a80dc

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # CHANGELOG
 
+## 3.17.3 - 2026-06-04
+
+- Fixed issue in intern.c and fast.c.
+
+## 3.17.2 - 2026-05-27
+
+- Fixed multiple issues related to extreme sizes.
+
+## 3.17.1 - 2026-05-15
+
+- Fixed "quoted string not terminated" error.
+
+## 3.17.0 - 2026-04-19
+
+- A "safe" parser has been added as a variation of the Oj:Parser thanks to @meinac.
+
+## 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/README.md

@@ -46,11 +46,6 @@ gem 'oj'
 
 See the Quickstart sections of the [Rails](pages/Rails.md) and [json](pages/JsonGem.md) docs.
 
-## multi_json
-
-Code which uses [multi_json](https://github.com/intridea/multi_json)
-will automatically prefer Oj if it is installed.
-
 ## Support
 
 [Get supported Oj with a Tidelift Subscription.](https://tidelift.com/subscription/pkg/rubygems-oj?utm_source=rubygems-oj&utm_medium=referral&utm_campaign=readme) Security updates are [supported](https://tidelift.com/security).
@@ -83,17 +78,6 @@ See [{file:CHANGELOG.md}](CHANGELOG.md) and [{file:RELEASE_NOTES.md}](RELEASE_NO
 
 - *RubyGems* *repo*: https://rubygems.org/gems/oj
 
-Follow [@peterohler on Twitter](http://twitter.com/peterohler) for announcements and news about the Oj gem.
-
-#### Performance Comparisons
-
- - [Oj Strict Mode Performance](http://www.ohler.com/dev/oj_misc/performance_strict.html) compares Oj strict mode parser performance to other JSON parsers.
-
- - [Oj Compat Mode Performance](http://www.ohler.com/dev/oj_misc/performance_compat.html) compares Oj compat mode parser performance to other JSON parsers.
-
- - [Oj Object Mode Performance](http://www.ohler.com/dev/oj_misc/performance_object.html) compares Oj object mode parser performance to other marshallers.
-
- - [Oj Callback Performance](http://www.ohler.com/dev/oj_misc/performance_callback.html) compares Oj callback parser performance to other JSON parsers.
 
 #### Links of Interest
 

data/ext/oj/compat.c

@@ -27,7 +27,7 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
         volatile VALUE rkey = oj_calc_hash_key(pi, kval);
 
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
-            VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
+            VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
             if (Qnil != clas) {
                 rstr = rb_funcall(clas, oj_json_create_id, 1, rstr);
@@ -84,7 +84,7 @@ static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
     if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
-        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
+        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
         if (Qnil != clas) {
             pi->stack.head->val = rb_funcall(clas, oj_json_create_id, 1, rstr);
@@ -155,7 +155,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
     if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
-        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
+        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
         if (Qnil != clas) {
             rb_ary_push(stack_peek(&pi->stack)->val, rb_funcall(clas, oj_json_create_id, 1, rstr));

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);
@@ -910,7 +915,7 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
         volatile VALUE rkey = oj_calc_hash_key(pi, kval);
 
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
-            VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
+            VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
             if (Qnil != clas) {
                 rstr = rb_funcall(clas, oj_json_create_id, 1, rstr);
@@ -1015,7 +1020,7 @@ static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const c
     volatile VALUE rstr = rb_utf8_str_new(str, len);
 
     if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
-        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
+        VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, len);
 
         if (Qnil != clas) {
             rb_ary_push(stack_peek(&pi->stack)->val, rb_funcall(clas, oj_json_create_id, 1, rstr));

data/ext/oj/dump.c

@@ -40,7 +40,7 @@ static size_t ascii_friendly_size(const uint8_t *str, size_t len);
 static const char hex_chars[17] = "0123456789abcdef";
 
 // JSON standard except newlines are no escaped
-static char newline_friendly_chars[256] = "\
+static char newline_friendly_chars[257] = "\
 66666666221622666666666666666666\
 11211111111111111111111111111111\
 11111111111111111111111111112111\
@@ -51,7 +51,7 @@ static char newline_friendly_chars[256] = "\
 11111111111111111111111111111111";
 
 // JSON standard
-static char hibit_friendly_chars[256] = "\
+static char hibit_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211111111111111111111111111111\
 11111111111111111111111111112111\
@@ -62,7 +62,7 @@ static char hibit_friendly_chars[256] = "\
 11111111111111111111111111111111";
 
 // JSON standard but escape forward slashes `/`
-static char slash_friendly_chars[256] = "\
+static char slash_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211111111111121111111111111111\
 11111111111111111111111111112111\
@@ -74,7 +74,7 @@ static char slash_friendly_chars[256] = "\
 
 // High bit set characters are always encoded as unicode. Worse case is 3
 // bytes per character in the output. That makes this conservative.
-static char ascii_friendly_chars[256] = "\
+static char ascii_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211111111111111111111111111111\
 11111111111111111111111111112111\
@@ -85,7 +85,7 @@ static char ascii_friendly_chars[256] = "\
 33333333333333333333333333333333";
 
 // XSS safe mode
-static char xss_friendly_chars[256] = "\
+static char xss_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211161111111121111111111116161\
 11111111111111111111111111112111\
@@ -96,7 +96,7 @@ static char xss_friendly_chars[256] = "\
 33333333333333333333333333333333";
 
 // JSON XSS combo
-static char hixss_friendly_chars[256] = "\
+static char hixss_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211111111111111111111111111111\
 11111111111111111111111111112111\
@@ -107,7 +107,7 @@ static char hixss_friendly_chars[256] = "\
 11611111111111111111111111111111";
 
 // Rails XSS combo
-static char rails_xss_friendly_chars[256] = "\
+static char rails_xss_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211161111111111111111111116161\
 11111111111111111111111111112111\
@@ -118,7 +118,7 @@ static char rails_xss_friendly_chars[256] = "\
 11611111111111111111111111111111";
 
 // Rails HTML non-escape
-static char rails_friendly_chars[256] = "\
+static char rails_friendly_chars[257] = "\
 66666666222622666666666666666666\
 11211111111111111111111111111111\
 11111111111111111111111111112111\
@@ -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/fast.c

@@ -80,21 +80,10 @@ static void  each_leaf(Doc doc, VALUE self);
 static int   move_step(Doc doc, const char *path, int loc);
 static Leaf  get_doc_leaf(Doc doc, const char *path);
 static Leaf  get_leaf(Leaf *stack, Leaf *lp, const char *path);
-static void  each_value(Doc doc, Leaf leaf);
+static void  each_value(Doc doc, Leaf leaf, VALUE self);
 
 VALUE oj_doc_class = Qundef;
 
-// This is only for CentOS 5.4 with Ruby 1.9.3-p0.
-#ifndef HAVE_STPCPY
-char *stpcpy(char *dest, const char *src) {
-    size_t cnt = strlen(src);
-
-    strcpy(dest, src);
-
-    return dest + cnt;
-}
-#endif
-
 inline static void next_non_white(ParseInfo pi) {
     for (; 1; pi->s++) {
         switch (*pi->s) {
@@ -246,6 +235,19 @@ static void skip_comment(ParseInfo pi) {
 #define NUM_MAX (FIXNUM_MAX >> 8)
 #endif
 
+static void validate_integer_size(size_t limit, char *head, char *tail) {
+    size_t total       = (size_t)(tail - head);
+    bool   has_sign    = (head[0] == '-' || head[0] == '+');
+    size_t digit_count = total - (has_sign ? 1 : 0);
+
+    if (digit_count > limit) {
+        rb_raise(oj_parse_error_class,
+                 "integer exceeds :max_integer_digits (%lu > %lu)",
+                 (unsigned long)digit_count,
+                 (unsigned long)limit);
+    }
+}
+
 static void leaf_fixnum_value(Leaf leaf) {
     char   *s   = leaf->str;
     int64_t n   = 0;
@@ -265,7 +267,12 @@ static void leaf_fixnum_value(Leaf leaf) {
         }
     }
     if (big) {
-        char c = *s;
+        size_t limit = oj_default_options.max_integer_digits;
+        char   c     = *s;
+
+        if (0 < limit) {
+            validate_integer_size(limit, leaf->str, s);
+        }
 
         *s          = '\0';
         leaf->value = rb_cstr_to_inum(leaf->str, 10, 0);
@@ -950,6 +957,9 @@ static void each_leaf(Doc doc, VALUE self) {
         }
     } else {
         rb_yield(self);
+        if (NULL == DATA_PTR(self)) {
+            rb_raise(rb_eIOError, "Document closed.");
+        }
     }
 }
 
@@ -1043,19 +1053,22 @@ static int move_step(Doc doc, const char *path, int loc) {
     return loc;
 }
 
-static void each_value(Doc doc, Leaf leaf) {
+static void each_value(Doc doc, Leaf leaf, VALUE self) {
     if (COL_VAL == leaf->value_type) {
         if (0 != leaf->elements) {
             Leaf first = leaf->elements->next;
             Leaf e     = first;
 
             do {
-                each_value(doc, e);
+                each_value(doc, e, self);
                 e = e->next;
             } while (e != first);
         }
     } else {
         rb_yield(leaf_value(doc, leaf));
+        if (NULL == DATA_PTR(self)) {
+            rb_raise(rb_eIOError, "Document closed.");
+        }
     }
 }
 
@@ -1491,12 +1504,19 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
             Leaf first = (*doc->where)->elements->next;
             Leaf e     = first;
 
+            if (MAX_STACK <= (doc->where + 1) - doc->where_path) {
+                rb_raise(rb_const_get_at(Oj, rb_intern("DepthError")), "Path too deep. Limit is %d levels.", MAX_STACK);
+            }
             doc->where++;
             do {
                 *doc->where = e;
                 rb_yield(self);
+                if (NULL == DATA_PTR(self)) {
+                    rb_raise(rb_eIOError, "Document closed.");
+                }
                 e = e->next;
             } while (e != first);
+            doc->where--;
         }
         if (0 < wlen) {
             memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
@@ -1540,7 +1560,7 @@ static VALUE doc_each_value(int argc, VALUE *argv, VALUE self) {
             path = StringValuePtr(*argv);
         }
         if (0 != (leaf = get_doc_leaf(doc, path))) {
-            each_value(doc, leaf);
+            each_value(doc, leaf, self);
         }
     }
     return Qnil;

data/ext/oj/intern.c

@@ -69,7 +69,7 @@ static VALUE form_attr(const char *str, size_t len) {
             memcpy(b + 1, str, len);
             b[len + 1] = '\0';
         }
-        id = rb_intern3(buf, len + 1, oj_utf8_encoding);
+        id = rb_intern3(b, len + 1, oj_utf8_encoding);
         OJ_R_FREE(b);
         return id;
     }

data/ext/oj/mimic_json.c

@@ -711,6 +711,7 @@ static struct _options mimic_object_to_json_options = {0,              // indent
                                                        0,              // cache_str
                                                        0,              // int_range_min
                                                        0,              // int_range_max
+                                                       0,              // max_integer_digits
                                                        oj_json_class,  // create_id
                                                        10,             // create_id_len
                                                        3,              // sec_prec
@@ -735,6 +736,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