oj 3.13.8 → 3.13.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 182e77505f61b9f1327d36552a04ac18a960831d01d675b02ec00ec6e33d3239
-  data.tar.gz: 4b56206268f665fe45a8cbd63b605bab35a0adf834e2ad1d603d4e99a1d8b118
+  metadata.gz: dcb5f80ad6384640d44889424c39f91ee2db778b17c91b9505b5b3b4c280abf1
+  data.tar.gz: 85b70200f48f46019ecf1020ca8e1b8ea604bca1161120b3747a8aeac2903682
 SHA512:
-  metadata.gz: cc57186d14210b95b7875948ceb2e1782f7a3223cfabcf7e45a5cad617eba67fe506bfe17820decf1881d341e6233c114f617c3ad8395033d75c7be8b72804b9
-  data.tar.gz: cc069dec094cde64f098fa65131d81f6552f2302af87730e19442ad027ad5722f7d6555de1e4a888196b994fcbb8f809f3892a10b05afd955b805851e7d53928
+  metadata.gz: f96776be4f9431b160f1d9f588e8688fb7e0c4a431c58a10fa43a71f5a6f95781456287f40db5dfba03bb69350946ad36f246d0b59c196f9dc95218f51005f7a
+  data.tar.gz: e106b88134f86d82b9740f3e836ecb2aaa4af7ad643b96a4600eaa09392ba5f630c402101a6fb476823c41bc127b5c3d9625c6900a033cf6f9830ca01e57d459

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # CHANGELOG
 
+## 3.13.11 - 2022-01-05
+
+- Fixed write blocking failures on writes to a slow stream with larger writes.
+
+## 3.13.10 - 2021-12-12
+
+- Fixed Oj::Doc re-entrant issue with each_child.
+- Fixed each_child on empty Oj::Doc.
+
+## 3.13.9 - 2021-10-06
+
+- Fix mimic JSON load so that it honors the `:symbolize_names` option.
 
 ## 3.13.8 - 2021-09-27
 

data/README.md

@@ -43,6 +43,15 @@ or in Bundler:
 gem 'oj'
 ```
 
+## Rails and json quickstart
+
+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).

data/ext/oj/custom.c

@@ -282,7 +282,7 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     Out out   = (Out)ov;
     int depth = out->depth;
 
-    if (oj_dump_ignore(out->opts, value)) {
+    if (dump_ignore(out->opts, value)) {
         return ST_CONTINUE;
     }
     if (out->omit_nil && Qnil == value) {
@@ -577,7 +577,7 @@ static int dump_attr_cb(ID key, VALUE value, VALUE ov) {
     size_t      size;
     const char *attr;
 
-    if (oj_dump_ignore(out->opts, value)) {
+    if (dump_ignore(out->opts, value)) {
         return ST_CONTINUE;
     }
     if (out->omit_nil && Qnil == value) {
@@ -749,7 +749,7 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
             } else {
                 fill_indent(out, d2);
             }
-            oj_dump_custom_val(rb_ary_entry(a, i), d2, out, true);
+            oj_dump_custom_val(RARRAY_AREF(a, i), d2, out, true);
             if (i < cnt) {
                 *out->cur++ = ',';
             }
@@ -833,7 +833,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
             v = rb_struct_aref(obj, INT2FIX(i));
 #endif
             if (ma != Qnil) {
-                volatile VALUE s = rb_sym2str(rb_ary_entry(ma, i));
+                volatile VALUE s = rb_sym2str(RARRAY_AREF(ma, i));
 
                 name = RSTRING_PTR(s);
                 len  = (int)RSTRING_LEN(s);

data/ext/oj/dump.c

@@ -10,6 +10,9 @@
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
+#if !IS_WINDOWS
+#include <poll.h>
+#endif
 
 #include "cache8.h"
 #include "odd.h"
@@ -113,49 +116,39 @@ static char rails_friendly_chars[256] = "\
 11111111111111111111111111111111";
 
 static void raise_strict(VALUE obj) {
-    rb_raise(rb_eTypeError,
-             "Failed to dump %s Object to JSON in strict mode.",
-             rb_class2name(rb_obj_class(obj)));
+    rb_raise(rb_eTypeError, "Failed to dump %s Object to JSON in strict mode.", rb_class2name(rb_obj_class(obj)));
 }
 
-inline static size_t newline_friendly_size(const uint8_t *str, size_t len) {
+inline static size_t calculate_string_size(const uint8_t *str, size_t len, const char *table) {
     size_t size = 0;
     size_t i    = len;
 
-    for (; 0 < i; str++, i--) {
-        size += newline_friendly_chars[*str];
+    for (; 3 < i; i -= 4) {
+        size += table[*str++];
+        size += table[*str++];
+        size += table[*str++];
+        size += table[*str++];
+    }
+    for (; 0 < i; i--) {
+        size += table[*str++];
     }
     return size - len * (size_t)'0';
 }
 
-inline static size_t hibit_friendly_size(const uint8_t *str, size_t len) {
-    size_t size = 0;
-    size_t i    = len;
+inline static size_t newline_friendly_size(const uint8_t *str, size_t len) {
+    return calculate_string_size(str, len, newline_friendly_chars);
+}
 
-    for (; 0 < i; str++, i--) {
-        size += hibit_friendly_chars[*str];
-    }
-    return size - len * (size_t)'0';
+inline static size_t hibit_friendly_size(const uint8_t *str, size_t len) {
+    return calculate_string_size(str, len, hibit_friendly_chars);
 }
 
 inline static size_t ascii_friendly_size(const uint8_t *str, size_t len) {
-    size_t size = 0;
-    size_t i    = len;
-
-    for (; 0 < i; str++, i--) {
-        size += ascii_friendly_chars[*str];
-    }
-    return size - len * (size_t)'0';
+    return calculate_string_size(str, len, ascii_friendly_chars);
 }
 
 inline static size_t xss_friendly_size(const uint8_t *str, size_t len) {
-    size_t size = 0;
-    size_t i    = len;
-
-    for (; 0 < i; str++, i--) {
-        size += xss_friendly_chars[*str];
-    }
-    return size - len * (size_t)'0';
+    return calculate_string_size(str, len, xss_friendly_chars);
 }
 
 inline static size_t hixss_friendly_size(const uint8_t *str, size_t len) {
@@ -188,13 +181,7 @@ inline static long rails_xss_friendly_size(const uint8_t *str, size_t len) {
 }
 
 inline static size_t rails_friendly_size(const uint8_t *str, size_t len) {
-    size_t size = 0;
-    size_t i    = len;
-
-    for (; 0 < i; str++, i--) {
-        size += rails_friendly_chars[*str];
-    }
-    return size - len * (size_t)'0';
+    return calculate_string_size(str, len, rails_friendly_chars);
 }
 
 const char *oj_nan_str(VALUE obj, int opt, int mode, bool plus, int *lenp) {
@@ -535,14 +522,7 @@ void oj_dump_xml_time(VALUE obj, Out out) {
     }
     if ((0 == nsec && !out->opts->sec_prec_set) || 0 == out->opts->sec_prec) {
         if (0 == tzsecs && rb_funcall2(obj, oj_utcq_id, 0, 0)) {
-            int len = sprintf(buf,
-                              "%04d-%02d-%02dT%02d:%02d:%02dZ",
-                              ti.year,
-                              ti.mon,
-                              ti.day,
-                              ti.hour,
-                              ti.min,
-                              ti.sec);
+            int len = sprintf(buf, "%04d-%02d-%02dT%02d:%02d:%02dZ", ti.year, ti.mon, ti.day, ti.hour, ti.min, ti.sec);
             oj_dump_cstr(buf, len, 0, 0, out);
         } else {
             int len = sprintf(buf,
@@ -574,18 +554,7 @@ void oj_dump_xml_time(VALUE obj, Out out) {
         if (9 > out->opts->sec_prec) {
             format[32] = '0' + out->opts->sec_prec;
         }
-        len = sprintf(buf,
-                      format,
-                      ti.year,
-                      ti.mon,
-                      ti.day,
-                      ti.hour,
-                      ti.min,
-                      ti.sec,
-                      (long)nsec,
-                      tzsign,
-                      tzhour,
-                      tzmin);
+        len = sprintf(buf, format, ti.year, ti.mon, ti.day, ti.hour, ti.min, ti.sec, (long)nsec, tzsign, tzhour, tzmin);
         oj_dump_cstr(buf, len, 0, 0, out);
     }
 }
@@ -666,6 +635,21 @@ void oj_write_obj_to_file(VALUE obj, const char *path, Options copts) {
     }
 }
 
+static void write_ready(int fd) {
+    struct pollfd pp;
+    int           i;
+
+    pp.fd      = fd;
+    pp.events  = POLLERR | POLLOUT;
+    pp.revents = 0;
+    if (0 >= (i = poll(&pp, 1, 5000))) {
+        if (0 == i || EAGAIN == errno) {
+            rb_raise(rb_eIOError, "write timed out");
+        }
+        rb_raise(rb_eIOError, "write failed. %d %s.", errno, strerror(errno));
+    }
+}
+
 void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
     char        buf[4096];
     struct _out out;
@@ -685,13 +669,24 @@ void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
     if (oj_stringio_class == clas) {
         rb_funcall(stream, oj_write_id, 1, rb_str_new(out.buf, size));
 #if !IS_WINDOWS
-    } else if (rb_respond_to(stream, oj_fileno_id) &&
-               Qnil != (s = rb_funcall(stream, oj_fileno_id, 0)) && 0 != (fd = FIX2INT(s))) {
-        if (size != write(fd, out.buf, size)) {
-            if (out.allocated) {
-                xfree(out.buf);
+    } else if (rb_respond_to(stream, oj_fileno_id) && Qnil != (s = rb_funcall(stream, oj_fileno_id, 0)) &&
+               0 != (fd = FIX2INT(s))) {
+        ssize_t cnt;
+        ssize_t total = 0;
+
+        while (true) {
+            if (0 > (cnt = write(fd, out.buf + total, size - total))) {
+                if (EAGAIN != errno) {
+                    rb_raise(rb_eIOError, "write failed. %d %s.", errno, strerror(errno));
+                    break;
+                }
+            }
+            total += cnt;
+            if (size <= total) {
+                // Completed
+                break;
             }
-            rb_raise(rb_eIOError, "Write failed. [%d:%s]", errno, strerror(errno));
+            write_ready(fd);
         }
 #endif
     } else if (rb_respond_to(stream, oj_write_id)) {
@@ -835,8 +830,7 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         for (; str < end; str++) {
             switch (cmap[(uint8_t)*str]) {
             case '1':
-                if ((JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) &&
-                    check_start <= str) {
+                if ((JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) && check_start <= str) {
                     if (0 != (0x80 & (uint8_t)*str)) {
                         if (0xC0 == (0xC0 & (uint8_t)*str)) {
                             check_start = check_unicode(str, end, orig);
@@ -860,11 +854,9 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
                 }
                 break;
             case '3':  // Unicode
-                if (0xe2 == (uint8_t)*str &&
-                    (JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) &&
+                if (0xe2 == (uint8_t)*str && (JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) &&
                     2 <= end - str) {
-                    if (0x80 == (uint8_t)str[1] &&
-                        (0xa8 == (uint8_t)str[2] || 0xa9 == (uint8_t)str[2])) {
+                    if (0x80 == (uint8_t)str[1] && (0xa8 == (uint8_t)str[2] || 0xa9 == (uint8_t)str[2])) {
                         str = dump_unicode(str, end, out, orig);
                     } else {
                         check_start = check_unicode(str, end, orig);
@@ -883,10 +875,8 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
                     dump_hex((uint8_t)*str, out);
                 } else {
                     if (0xe2 == (uint8_t)*str &&
-                        (JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) &&
-                        2 <= end - str) {
-                        if (0x80 == (uint8_t)str[1] &&
-                            (0xa8 == (uint8_t)str[2] || 0xa9 == (uint8_t)str[2])) {
+                        (JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) && 2 <= end - str) {
+                        if (0x80 == (uint8_t)str[1] && (0xa8 == (uint8_t)str[2] || 0xa9 == (uint8_t)str[2])) {
                             str = dump_unicode(str, end, out, orig);
                         } else {
                             check_start = check_unicode(str, end, orig);
@@ -902,8 +892,8 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         }
         *out->cur++ = '"';
     }
-    if ((JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) &&
-        0 < str - orig && 0 != (0x80 & *(str - 1))) {
+    if ((JXEsc == out->opts->escape_mode || RailsXEsc == out->opts->escape_mode) && 0 < str - orig &&
+        0 != (0x80 & *(str - 1))) {
         uint8_t c = (uint8_t) * (str - 1);
         int     i;
         int     scnt = (int)(str - orig);
@@ -1064,8 +1054,7 @@ void oj_dump_bignum(VALUE obj, int depth, Out out, bool as_ok) {
     int            cnt            = (int)RSTRING_LEN(rs);
     bool           dump_as_string = false;
 
-    if (out->opts->int_range_max != 0 ||
-        out->opts->int_range_min != 0) {  // Bignum cannot be inside of Fixnum range
+    if (out->opts->int_range_max != 0 || out->opts->int_range_min != 0) {  // Bignum cannot be inside of Fixnum range
         dump_as_string = true;
         assure_size(out, cnt + 2);
         *out->cur++ = '"';
@@ -1225,17 +1214,3 @@ int oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char
     }
     return cnt;
 }
-
-bool oj_dump_ignore(Options opts, VALUE obj) {
-    if (NULL != opts->ignore && (ObjectMode == opts->mode || CustomMode == opts->mode)) {
-        VALUE *vp   = opts->ignore;
-        VALUE  clas = rb_obj_class(obj);
-
-        for (; Qnil != *vp; vp++) {
-            if (clas == *vp) {
-                return true;
-            }
-        }
-    }
-    return false;
-}

data/ext/oj/dump.h

@@ -50,7 +50,6 @@ extern VALUE oj_remove_to_json(int argc, VALUE *argv, VALUE self);
 
 extern int oj_dump_float_printf(char *buf, size_t blen, VALUE obj, double d, const char *format);
 
-extern bool   oj_dump_ignore(Options opts, VALUE obj);
 extern time_t oj_sec_from_time_hard_way(VALUE obj);
 
 inline static void assure_size(Out out, size_t len) {
@@ -69,6 +68,20 @@ inline static void fill_indent(Out out, int cnt) {
     }
 }
 
+inline static bool dump_ignore(Options opts, VALUE obj) {
+    if (NULL != opts->ignore && (ObjectMode == opts->mode || CustomMode == opts->mode)) {
+        VALUE *vp   = opts->ignore;
+        VALUE  clas = rb_obj_class(obj);
+
+        for (; Qnil != *vp; vp++) {
+            if (clas == *vp) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
 inline static void dump_ulong(unsigned long num, Out out) {
     char  buf[32];
     char *b = buf + sizeof(buf) - 1;

data/ext/oj/dump_compat.c

@@ -182,7 +182,7 @@ dump_array(VALUE a, int depth, Out out, bool as_ok) {
 	    } else {
 		fill_indent(out, d2);
 	    }
-	    oj_dump_compat_val(rb_ary_entry(a, i), d2, out, true);
+	    oj_dump_compat_val(RARRAY_AREF(a, i), d2, out, true);
 	    if (i < cnt) {
 		*out->cur++ = ',';
 	    }

data/ext/oj/dump_object.c

@@ -157,7 +157,7 @@ static void dump_array_class(VALUE a, VALUE clas, int depth, Out out) {
             } else {
                 fill_indent(out, d2);
             }
-            oj_dump_obj_val(rb_ary_entry(a, i), d2, out);
+            oj_dump_obj_val(RARRAY_AREF(a, i), d2, out);
             if (i < cnt) {
                 *out->cur++ = ',';
             }
@@ -218,7 +218,7 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     int  depth = out->depth;
     long size  = depth * out->indent + 1;
 
-    if (oj_dump_ignore(out->opts, value)) {
+    if (dump_ignore(out->opts, value)) {
         return ST_CONTINUE;
     }
     if (out->omit_nil && Qnil == value) {
@@ -226,47 +226,54 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
     }
     assure_size(out, size);
     fill_indent(out, depth);
-    if (rb_type(key) == T_STRING) {
+    switch (rb_type(key)) {
+    case T_STRING:
         dump_str_class(key, Qundef, depth, out);
         *out->cur++ = ':';
         oj_dump_obj_val(value, depth, out);
-    } else if (rb_type(key) == T_SYMBOL) {
+        break;
+
+    case T_SYMBOL:
         dump_sym(key, 0, out, false);
         *out->cur++ = ':';
         oj_dump_obj_val(value, depth, out);
-    } else {
-        int     d2 = depth + 1;
-        long    s2 = size + out->indent + 1;
-        int     i;
-        int     started = 0;
-        uint8_t b;
+        break;
 
-        assure_size(out, s2 + 15);
-        *out->cur++ = '"';
-        *out->cur++ = '^';
-        *out->cur++ = '#';
-        out->hash_cnt++;
-        for (i = 28; 0 <= i; i -= 4) {
-            b = (uint8_t)((out->hash_cnt >> i) & 0x0000000F);
-            if ('\0' != b) {
-                started = 1;
-            }
-            if (started) {
-                *out->cur++ = hex_chars[b];
+    default:
+        {
+            int     d2 = depth + 1;
+            long    s2 = size + out->indent + 1;
+            int     i;
+            int     started = 0;
+            uint8_t b;
+
+            assure_size(out, s2 + 15);
+            *out->cur++ = '"';
+            *out->cur++ = '^';
+            *out->cur++ = '#';
+            out->hash_cnt++;
+            for (i = 28; 0 <= i; i -= 4) {
+                b = (uint8_t)((out->hash_cnt >> i) & 0x0000000F);
+                if ('\0' != b) {
+                    started = 1;
+                }
+                if (started) {
+                    *out->cur++ = hex_chars[b];
+                }
             }
+            *out->cur++ = '"';
+            *out->cur++ = ':';
+            *out->cur++ = '[';
+            fill_indent(out, d2);
+            oj_dump_obj_val(key, d2, out);
+            assure_size(out, s2);
+            *out->cur++ = ',';
+            fill_indent(out, d2);
+            oj_dump_obj_val(value, d2, out);
+            assure_size(out, size);
+            fill_indent(out, depth);
+            *out->cur++ = ']';
         }
-        *out->cur++ = '"';
-        *out->cur++ = ':';
-        *out->cur++ = '[';
-        fill_indent(out, d2);
-        oj_dump_obj_val(key, d2, out);
-        assure_size(out, s2);
-        *out->cur++ = ',';
-        fill_indent(out, d2);
-        oj_dump_obj_val(value, d2, out);
-        assure_size(out, size);
-        fill_indent(out, depth);
-        *out->cur++ = ']';
     }
     out->depth  = depth;
     *out->cur++ = ',';
@@ -342,7 +349,7 @@ static int dump_attr_cb(ID key, VALUE value, VALUE ov) {
     size_t      size  = depth * out->indent + 1;
     const char *attr  = rb_id2name(key);
 
-    if (oj_dump_ignore(out->opts, value)) {
+    if (dump_ignore(out->opts, value)) {
         return ST_CONTINUE;
     }
     if (out->omit_nil && Qnil == value) {
@@ -605,7 +612,7 @@ static void dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out)
             }
             value = rb_ivar_get(obj, vid);
 
-            if (oj_dump_ignore(out->opts, value)) {
+            if (dump_ignore(out->opts, value)) {
                 continue;
             }
             if (out->omit_nil && Qnil == value) {
@@ -694,7 +701,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
 
         *out->cur++ = '[';
         for (i = 0; i < cnt; i++) {
-            volatile VALUE s = rb_sym2str(rb_ary_entry(ma, i));
+            volatile VALUE s = rb_sym2str(RARRAY_AREF(ma, i));
 
             name = RSTRING_PTR(s);
             len  = (int)RSTRING_LEN(s);
@@ -730,7 +737,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
 
         for (i = 0; i < cnt; i++) {
             v = RSTRUCT_GET(obj, i);
-            if (oj_dump_ignore(out->opts, v)) {
+            if (dump_ignore(out->opts, v)) {
                 v = Qnil;
             }
             assure_size(out, size);
@@ -748,7 +755,7 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
         for (i = 0; i < slen; i++) {
             assure_size(out, size);
             fill_indent(out, d3);
-            if (oj_dump_ignore(out->opts, v)) {
+            if (dump_ignore(out->opts, v)) {
                 v = Qnil;
             }
             oj_dump_obj_val(rb_struct_aref(obj, INT2FIX(i)), d3, out, 0, 0, true);

data/ext/oj/dump_strict.c

@@ -153,9 +153,9 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
                 fill_indent(out, d2);
             }
             if (NullMode == out->opts->mode) {
-                oj_dump_null_val(rb_ary_entry(a, i), d2, out);
+                oj_dump_null_val(RARRAY_AREF(a, i), d2, out);
             } else {
-                oj_dump_strict_val(rb_ary_entry(a, i), d2, out);
+                oj_dump_strict_val(RARRAY_AREF(a, i), d2, out);
             }
             if (i < cnt) {
                 *out->cur++ = ',';

data/ext/oj/encoder.c

@@ -0,0 +1,43 @@
+// Copyright (c) 2011, 2022 Peter Ohler. All rights reserved.
+// Licensed under the MIT License. See LICENSE file in the project root for license details.
+
+#include "oj.h"
+
+typedef struct _encoder {
+    int              indent;         // indention for dump, default 2
+    char             circular;       // YesNo
+    char             escape_mode;    // Escape_Mode
+    char             mode;           // Mode
+    char             time_format;    // TimeFormat
+    char             bigdec_as_num;  // YesNo
+    char             to_hash;        // YesNo
+    char             to_json;        // YesNo
+    char             as_json;        // YesNo
+    char             raw_json;       // YesNo
+    char             trace;          // YesNo
+    char             sec_prec_set;   // boolean (0 or 1)
+    char             ignore_under;   // YesNo - ignore attrs starting with _ if true in object and custom modes
+    int64_t          int_range_min;  // dump numbers below as string
+    int64_t          int_range_max;  // dump numbers above as string
+    const char*      create_id;      // 0 or string
+    size_t           create_id_len;  // length of create_id
+    int              sec_prec;       // second precision when dumping time
+    char             float_prec;     // float precision, linked to float_fmt
+    char             float_fmt[7];   // float format for dumping, if empty use Ruby
+    struct _dumpOpts dump_opts;
+    struct _rxClass  str_rx;
+    VALUE*           ignore;  // Qnil terminated array of classes or NULL
+} * Encoder;
+
+/*
+    rb_define_module_function(Oj, "encode", encode, -1);
+    rb_define_module_function(Oj, "to_file", to_file, -1); // or maybe just write
+    rb_define_module_function(Oj, "to_stream", to_stream, -1);
+*/
+
+// write(to, obj)
+//  if to is a string then open file
+//  else if stream then write to stream
+//  handle non-blocking
+
+// should each mode have a different encoder or use delegates like the parser?

data/ext/oj/fast.c

@@ -771,7 +771,7 @@ static VALUE parse_json(VALUE clas, char *json, bool given, bool allocated) {
     pi.doc = doc;
 #if IS_WINDOWS
     // assume a 1M stack and give half to ruby
-    pi.stack_min = (void*)((char*)&pi - (512 * 1024));
+    pi.stack_min = (void *)((char *)&pi - (512 * 1024));
 #else
     {
         struct rlimit lim;
@@ -1492,6 +1492,7 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
         Doc         doc  = self_doc(self);
         const char *path = 0;
         size_t      wlen;
+        Leaf *      where_orig = doc->where;
 
         wlen = doc->where - doc->where_path;
         if (0 < wlen) {
@@ -1508,9 +1509,13 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
                 if (0 < wlen) {
                     memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
                 }
+                doc->where = where_orig;
                 return Qnil;
             }
         }
+        if (NULL == doc->where || NULL == *doc->where) {
+            return Qnil;
+        }
         if (COL_VAL == (*doc->where)->value_type && 0 != (*doc->where)->elements) {
             Leaf first = (*doc->where)->elements->next;
             Leaf e     = first;
@@ -1525,6 +1530,7 @@ static VALUE doc_each_child(int argc, VALUE *argv, VALUE self) {
         if (0 < wlen) {
             memcpy(doc->where_path, save_path, sizeof(Leaf) * (wlen + 1));
         }
+        doc->where = where_orig;
     }
     return Qnil;
 }