oj 3.13.10 → 3.13.13

data/ext/oj/rails.c

@@ -167,17 +167,14 @@ static void dump_struct(VALUE obj, int depth, Out out, bool as_ok) {
         }
         fill_indent(out, d3);
         *out->cur++ = '"';
-        memcpy(out->cur, name, len);
-        out->cur += len;
+        APPEND_CHARS(out->cur, name, len);
         *out->cur++ = '"';
         if (0 < out->opts->dump_opts.before_size) {
-            strcpy(out->cur, out->opts->dump_opts.before_sep);
-            out->cur += out->opts->dump_opts.before_size;
+            APPEND_CHARS(out->cur, out->opts->dump_opts.before_sep, out->opts->dump_opts.before_size);
         }
         *out->cur++ = ':';
         if (0 < out->opts->dump_opts.after_size) {
-            strcpy(out->cur, out->opts->dump_opts.after_sep);
-            out->cur += out->opts->dump_opts.after_size;
+            APPEND_CHARS(out->cur, out->opts->dump_opts.after_sep, out->opts->dump_opts.after_size);
         }
 #ifdef RSTRUCT_LEN
         v = RSTRUCT_GET(obj, i);
@@ -330,12 +327,12 @@ static void dump_time(VALUE obj, int depth, Out out, bool as_ok) {
         sec  = (long long)ts.tv_sec;
         nsec = ts.tv_nsec;
     } else {
-        sec  = rb_num2ll(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
-        nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
+        sec  = NUM2LL(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
+        nsec = NUM2LL(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
     }
 #else
-    sec  = rb_num2ll(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
-    nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
+    sec  = NUM2LL(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
+    nsec = NUM2LL(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
 #endif
     dump_sec_nano(obj, sec, nsec, out);
 }
@@ -345,9 +342,9 @@ static void dump_timewithzone(VALUE obj, int depth, Out out, bool as_ok) {
     long long nsec = 0;
 
     if (rb_respond_to(obj, oj_tv_nsec_id)) {
-        nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
+        nsec = NUM2LL(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
     } else if (rb_respond_to(obj, oj_tv_usec_id)) {
-        nsec = rb_num2ll(rb_funcall2(obj, oj_tv_usec_id, 0, 0)) * 1000;
+        nsec = NUM2LL(rb_funcall2(obj, oj_tv_usec_id, 0, 0)) * 1000;
     }
     dump_sec_nano(obj, sec, nsec, out);
 }
@@ -405,14 +402,12 @@ static void dump_row(VALUE row, StrLen cols, int ccnt, int depth, Out out) {
         assure_size(out, size);
         if (out->opts->dump_opts.use) {
             if (0 < out->opts->dump_opts.array_size) {
-                strcpy(out->cur, out->opts->dump_opts.array_nl);
-                out->cur += out->opts->dump_opts.array_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
             }
             if (0 < out->opts->dump_opts.indent_size) {
                 int i;
                 for (i = d2; 0 < i; i--) {
-                    strcpy(out->cur, out->opts->dump_opts.indent_str);
-                    out->cur += out->opts->dump_opts.indent_size;
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
                 }
             }
         } else {
@@ -429,15 +424,13 @@ static void dump_row(VALUE row, StrLen cols, int ccnt, int depth, Out out) {
     assure_size(out, size);
     if (out->opts->dump_opts.use) {
         if (0 < out->opts->dump_opts.array_size) {
-            strcpy(out->cur, out->opts->dump_opts.array_nl);
-            out->cur += out->opts->dump_opts.array_size;
+            APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
         }
         if (0 < out->opts->dump_opts.indent_size) {
             int i;
 
             for (i = depth; 0 < i; i--) {
-                strcpy(out->cur, out->opts->dump_opts.indent_str);
-                out->cur += out->opts->dump_opts.indent_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
             }
         }
     } else {
@@ -477,14 +470,12 @@ static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok)
         assure_size(out, size);
         if (out->opts->dump_opts.use) {
             if (0 < out->opts->dump_opts.array_size) {
-                strcpy(out->cur, out->opts->dump_opts.array_nl);
-                out->cur += out->opts->dump_opts.array_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
             }
             if (0 < out->opts->dump_opts.indent_size) {
                 int i;
                 for (i = d2; 0 < i; i--) {
-                    strcpy(out->cur, out->opts->dump_opts.indent_str);
-                    out->cur += out->opts->dump_opts.indent_size;
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
                 }
             }
         } else {
@@ -500,15 +491,13 @@ static void dump_activerecord_result(VALUE obj, int depth, Out out, bool as_ok)
     assure_size(out, size);
     if (out->opts->dump_opts.use) {
         if (0 < out->opts->dump_opts.array_size) {
-            strcpy(out->cur, out->opts->dump_opts.array_nl);
-            out->cur += out->opts->dump_opts.array_size;
+            APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
         }
         if (0 < out->opts->dump_opts.indent_size) {
             int i;
 
             for (i = depth; 0 < i; i--) {
-                strcpy(out->cur, out->opts->dump_opts.indent_str);
-                out->cur += out->opts->dump_opts.indent_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
             }
         }
     } else {
@@ -908,7 +897,6 @@ static VALUE protect_dump(VALUE ov) {
 }
 
 static VALUE encode(VALUE obj, ROptTable ropts, Options opts, int argc, VALUE *argv) {
-    char            buf[4096];
     struct _out     out;
     struct _options copts = *opts;
     volatile VALUE  rstr  = Qnil;
@@ -925,9 +913,9 @@ static VALUE encode(VALUE obj, ROptTable ropts, Options opts, int argc, VALUE *a
     } else {
         copts.escape_mode = RailsEsc;
     }
-    out.buf       = buf;
-    out.end       = buf + sizeof(buf) - 10;
-    out.allocated = false;
+
+    oj_out_init(&out);
+
     out.omit_nil  = copts.dump_opts.omit_nil;
     out.caller    = 0;
     out.cur       = out.buf;
@@ -963,9 +951,9 @@ static VALUE encode(VALUE obj, ROptTable ropts, Options opts, int argc, VALUE *a
     if (Yes == copts.circular) {
         oj_cache8_delete(out.circ_cache);
     }
-    if (out.allocated) {
-        xfree(out.buf);
-    }
+
+    oj_out_free(&out);
+
     if (0 != line) {
         rb_jump_tag(line);
     }
@@ -1175,12 +1163,15 @@ oj_optimize_rails(VALUE self) {
  *
  * The Oj ActiveSupport compliant encoder.
  */
-void oj_mimic_rails_init() {
+void oj_mimic_rails_init(void) {
     VALUE rails = rb_define_module_under(Oj, "Rails");
 
     rb_define_module_function(rails, "encode", rails_encode, -1);
 
     encoder_class = rb_define_class_under(rails, "Encoder", rb_cObject);
+    rb_gc_register_address(&encoder_class);
+    rb_undef_alloc_func(encoder_class);
+
     rb_define_module_function(encoder_class, "new", encoder_new, -1);
     rb_define_module_function(rails, "optimize", rails_optimize, -1);
     rb_define_module_function(rails, "deoptimize", rails_deoptimize, -1);
@@ -1263,19 +1254,17 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         } else {
             size = d2 * out->indent + 2;
         }
+        assure_size(out, size * cnt);
         cnt--;
         for (i = 0; i <= cnt; i++) {
-            assure_size(out, size);
             if (out->opts->dump_opts.use) {
                 if (0 < out->opts->dump_opts.array_size) {
-                    strcpy(out->cur, out->opts->dump_opts.array_nl);
-                    out->cur += out->opts->dump_opts.array_size;
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
                 }
                 if (0 < out->opts->dump_opts.indent_size) {
                     int i;
                     for (i = d2; 0 < i; i--) {
-                        strcpy(out->cur, out->opts->dump_opts.indent_str);
-                        out->cur += out->opts->dump_opts.indent_size;
+                        APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
                     }
                 }
             } else {
@@ -1290,15 +1279,13 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         assure_size(out, size);
         if (out->opts->dump_opts.use) {
             if (0 < out->opts->dump_opts.array_size) {
-                strcpy(out->cur, out->opts->dump_opts.array_nl);
-                out->cur += out->opts->dump_opts.array_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.array_nl, out->opts->dump_opts.array_size);
             }
             if (0 < out->opts->dump_opts.indent_size) {
                 int i;
 
                 for (i = depth; 0 < i; i--) {
-                    strcpy(out->cur, out->opts->dump_opts.indent_str);
-                    out->cur += out->opts->dump_opts.indent_size;
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
                 }
             }
         } else {
@@ -1336,14 +1323,12 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
         size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
         assure_size(out, size);
         if (0 < out->opts->dump_opts.hash_size) {
-            strcpy(out->cur, out->opts->dump_opts.hash_nl);
-            out->cur += out->opts->dump_opts.hash_size;
+            APPEND_CHARS(out->cur, out->opts->dump_opts.hash_nl, out->opts->dump_opts.hash_size);
         }
         if (0 < out->opts->dump_opts.indent_size) {
             int i;
             for (i = depth; 0 < i; i--) {
-                strcpy(out->cur, out->opts->dump_opts.indent_str);
-                out->cur += out->opts->dump_opts.indent_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
             }
         }
         if (rtype == T_STRING) {
@@ -1354,13 +1339,11 @@ static int hash_cb(VALUE key, VALUE value, VALUE ov) {
         size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
         assure_size(out, size);
         if (0 < out->opts->dump_opts.before_size) {
-            strcpy(out->cur, out->opts->dump_opts.before_sep);
-            out->cur += out->opts->dump_opts.before_size;
+            APPEND_CHARS(out->cur, out->opts->dump_opts.before_sep, out->opts->dump_opts.before_size);
         }
         *out->cur++ = ':';
         if (0 < out->opts->dump_opts.after_size) {
-            strcpy(out->cur, out->opts->dump_opts.after_sep);
-            out->cur += out->opts->dump_opts.after_size;
+            APPEND_CHARS(out->cur, out->opts->dump_opts.after_sep, out->opts->dump_opts.after_size);
         }
     }
     dump_rails_val(value, depth, out, true);
@@ -1403,15 +1386,13 @@ static void dump_hash(VALUE obj, int depth, Out out, bool as_ok) {
             size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
             assure_size(out, size);
             if (0 < out->opts->dump_opts.hash_size) {
-                strcpy(out->cur, out->opts->dump_opts.hash_nl);
-                out->cur += out->opts->dump_opts.hash_size;
+                APPEND_CHARS(out->cur, out->opts->dump_opts.hash_nl, out->opts->dump_opts.hash_size);
             }
             if (0 < out->opts->dump_opts.indent_size) {
                 int i;
 
                 for (i = depth; 0 < i; i--) {
-                    strcpy(out->cur, out->opts->dump_opts.indent_str);
-                    out->cur += out->opts->dump_opts.indent_size;
+                    APPEND_CHARS(out->cur, out->opts->dump_opts.indent_str, out->opts->dump_opts.indent_size);
                 }
             }
         }

data/ext/oj/rails.h

@@ -6,7 +6,7 @@
 
 #include "dump.h"
 
-extern void oj_mimic_rails_init();
+extern void oj_mimic_rails_init(void);
 extern ROpt oj_rails_get_opt(ROptTable rot, VALUE clas);
 
 extern bool oj_rails_hash_opt;

data/ext/oj/reader.c

@@ -6,9 +6,11 @@
 #include <stdlib.h>
 #include <strings.h>
 #include <sys/types.h>
+#ifdef NEEDS_UIO
 #if NEEDS_UIO
 #include <sys/uio.h>
 #endif
+#endif
 #include <time.h>
 #include <unistd.h>
 

data/ext/oj/saj.c

@@ -210,10 +210,7 @@ static void read_hash(ParseInfo pi, const char *key) {
                 pi->s++;
             } else {
                 if (pi->has_error) {
-                    call_error("invalid format, expected , or } while in an object",
-                               pi,
-                               __FILE__,
-                               __LINE__);
+                    call_error("invalid format, expected , or } while in an object", pi, __FILE__, __LINE__);
                 }
                 raise_error("invalid format, expected , or } while in an object", pi->str, pi->s);
             }
@@ -243,10 +240,7 @@ static void read_array(ParseInfo pi, const char *key) {
                 break;
             } else {
                 if (pi->has_error) {
-                    call_error("invalid format, expected , or ] while in an array",
-                               pi,
-                               __FILE__,
-                               __LINE__);
+                    call_error("invalid format, expected , or ] while in an array", pi, __FILE__, __LINE__);
                 }
                 raise_error("invalid format, expected , or ] while in an array", pi->str, pi->s);
             }
@@ -276,7 +270,7 @@ static void read_str(ParseInfo pi, const char *key) {
 #endif
 
 static void read_num(ParseInfo pi, const char *key) {
-    char *  start = pi->s;
+    char   *start = pi->s;
     int64_t n     = 0;
     long    a     = 0;
     long    div   = 1;
@@ -351,9 +345,7 @@ static void read_num(ParseInfo pi, const char *key) {
 
             *pi->s = '\0';
             if (pi->has_add_value) {
-                call_add_value(pi->handler,
-                               rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new2(start)),
-                               key);
+                call_add_value(pi->handler, rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new2(start)), key);
             }
             *pi->s = c;
         } else {
@@ -371,9 +363,7 @@ static void read_num(ParseInfo pi, const char *key) {
 
             *pi->s = '\0';
             if (pi->has_add_value) {
-                call_add_value(pi->handler,
-                               rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new2(start)),
-                               key);
+                call_add_value(pi->handler, rb_funcall(rb_cObject, oj_bigdecimal_id, 1, rb_str_new2(start)), key);
             }
             *pi->s = c;
         } else {
@@ -505,9 +495,9 @@ static char *unicode_to_chars(ParseInfo pi, char *t, uint32_t code) {
  * reached again. Do not read the character after the terminating quote.
  */
 static char *read_quoted_value(ParseInfo pi) {
-    char *   value = 0;
-    char *   h     = pi->s; /* head */
-    char *   t     = h;     /* tail */
+    char    *value = 0;
+    char    *h     = pi->s; /* head */
+    char    *t     = h;     /* tail */
     uint32_t code;
 
     h++; /* skip quote character */
@@ -588,15 +578,13 @@ static void saj_parse(VALUE handler, char *json) {
     pi.str = json;
     pi.s   = json;
 #if IS_WINDOWS
-    pi.stack_min = (void *)((char *)&obj -
-                            (512 * 1024)); /* assume a 1M stack and give half to ruby */
+    pi.stack_min = (void *)((char *)&obj - (512L * 1024L)); /* assume a 1M stack and give half to ruby */
 #else
     {
         struct rlimit lim;
 
         if (0 == getrlimit(RLIMIT_STACK, &lim) && RLIM_INFINITY != lim.rlim_cur) {
-            pi.stack_min = (void *)((char *)&obj - (lim.rlim_cur / 4 *
-                                                    3)); /* let 3/4ths of the stack be used only */
+            pi.stack_min = (void *)((char *)&obj - (lim.rlim_cur / 4 * 3)); /* let 3/4ths of the stack be used only */
         } else {
             pi.stack_min = 0; /* indicates not to check stack limit */
         }
@@ -633,7 +621,7 @@ static void saj_parse(VALUE handler, char *json) {
  */
 VALUE
 oj_saj_parse(int argc, VALUE *argv, VALUE self) {
-    char * json  = 0;
+    char  *json  = 0;
     size_t len   = 0;
     VALUE  input = argv[1];
 

data/ext/oj/stream_writer.c

@@ -315,8 +315,10 @@ static VALUE stream_writer_flush(VALUE self) {
  * will create that element in the JSON document and subsequent pushes will add
  * the elements to that array or object until a pop() is called.
  */
-void oj_stream_writer_init() {
+void oj_stream_writer_init(void) {
     oj_stream_writer_class = rb_define_class_under(Oj, "StreamWriter", rb_cObject);
+    rb_gc_register_address(&oj_stream_writer_class);
+    rb_undef_alloc_func(oj_stream_writer_class);
     rb_define_module_function(oj_stream_writer_class, "new", stream_writer_new, -1);
     rb_define_method(oj_stream_writer_class, "push_key", stream_writer_push_key, 1);
     rb_define_method(oj_stream_writer_class, "push_object", stream_writer_push_object, -1);

data/ext/oj/string_writer.c

@@ -53,10 +53,13 @@ void oj_str_writer_init(StrWriter sw, int buf_size) {
     } else if (buf_size < 1024) {
         buf_size = 1024;
     }
+    // Must be allocated. Using the out.stack_buffer results in double frees
+    // and I haven't figured out why yet.
     sw->out.buf        = ALLOC_N(char, buf_size);
-    sw->out.end        = sw->out.buf + buf_size - 10;
-    sw->out.allocated  = true;
     sw->out.cur        = sw->out.buf;
+    sw->out.end        = sw->out.buf + buf_size - BUFFER_EXTRA;
+    sw->out.allocated  = true;
+
     *sw->out.cur       = '\0';
     sw->out.circ_cache = NULL;
     sw->out.circ_cnt   = 0;
@@ -229,7 +232,9 @@ static void str_writer_free(void *ptr) {
         return;
     }
     sw = (StrWriter)ptr;
-    xfree(sw->out.buf);
+
+    oj_out_free(&sw->out);
+
     xfree(sw->types);
     xfree(ptr);
 }
@@ -449,7 +454,7 @@ static VALUE str_writer_to_s(VALUE self) {
  * Returns the contents of the writer as a JSON element. If called from inside
  * an array or hash by Oj the raw buffer will be used othersize a more
  * inefficient parse of the contents and a return of the result is
- * completed. The parse uses the trict mode.
+ * completed. The parse uses the strict mode.
  *
  * *return* [_Hash_|_Array_|_String_|_Integer_|_Float_|_True_|_False_|_nil|)
  */
@@ -469,8 +474,10 @@ static VALUE str_writer_as_json(VALUE self) {
  * calling to_s() will return the JSON document. Note that calling to_s() before
  * construction is complete will return the document in it's current state.
  */
-void oj_string_writer_init() {
+void oj_string_writer_init(void) {
     oj_string_writer_class = rb_define_class_under(Oj, "StringWriter", rb_cObject);
+    rb_gc_register_address(&oj_string_writer_class);
+    rb_undef_alloc_func(oj_string_writer_class);
     rb_define_module_function(oj_string_writer_class, "new", str_writer_new, -1);
     rb_define_method(oj_string_writer_class, "push_key", str_writer_push_key, 1);
     rb_define_method(oj_string_writer_class, "push_object", str_writer_push_object, -1);

data/ext/oj/wab.c

@@ -35,7 +35,7 @@ static VALUE uri_http_clas = Qundef;
 
 ///// dump functions /////
 
-static VALUE resolve_wab_uuid_class() {
+static VALUE resolve_wab_uuid_class(void) {
     if (Qundef == wab_uuid_clas) {
         volatile VALUE wab_module;
 
@@ -50,7 +50,7 @@ static VALUE resolve_wab_uuid_class() {
     return wab_uuid_clas;
 }
 
-static VALUE resolve_uri_class() {
+static VALUE resolve_uri_class(void) {
     if (Qundef == uri_clas) {
         uri_clas = Qnil;
         if (rb_const_defined_at(rb_cObject, rb_intern("URI"))) {
@@ -60,7 +60,7 @@ static VALUE resolve_uri_class() {
     return uri_clas;
 }
 
-static VALUE resolve_uri_http_class() {
+static VALUE resolve_uri_http_class(void) {
     if (Qundef == uri_http_clas) {
         volatile VALUE uri_module;
 
@@ -124,9 +124,9 @@ static void dump_array(VALUE a, int depth, Out out, bool as_ok) {
         *out->cur++ = ']';
     } else {
         size = d2 * out->indent + 2;
+        assure_size(out, size * cnt);
         cnt--;
         for (i = 0; i <= cnt; i++) {
-            assure_size(out, size);
             fill_indent(out, d2);
             oj_dump_wab_val(RARRAY_AREF(a, i), d2, out);
             if (i < cnt) {
@@ -201,12 +201,12 @@ static void dump_time(VALUE obj, Out out) {
         sec  = ts.tv_sec;
         nsec = ts.tv_nsec;
     } else {
-        sec  = rb_num2ll(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
-        nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
+        sec  = NUM2LL(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
+        nsec = NUM2LL(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
     }
 #else
-    sec  = rb_num2ll(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
-    nsec = rb_num2ll(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
+    sec  = NUM2LL(rb_funcall2(obj, oj_tv_sec_id, 0, 0));
+    nsec = NUM2LL(rb_funcall2(obj, oj_tv_nsec_id, 0, 0));
 #endif
 
     assure_size(out, 36);

data/lib/oj/version.rb

@@ -1,5 +1,5 @@
 
 module Oj
   # Current version of the module.
-  VERSION = '3.13.10'
+  VERSION = '3.13.13'
 end

data/test/bar.rb

@@ -6,11 +6,4 @@ $: << File.join(File.dirname(__FILE__), "../ext")
 
 require 'oj'
 
-json = %|[{"x12345678901234567890": true}]|
-
-p = Oj::Parser.new(:usual)
-p.cache_keys = false
-p.symbol_keys = true
-x = p.parse(json)
-
-pp x
+Oj.load(%|{"time":"2021-08-16 12:12:15","a":"5","b":"5"|)

data/test/foo.rb

@@ -4,32 +4,74 @@ $: << '.'
 $: << File.join(File.dirname(__FILE__), "../lib")
 $: << File.join(File.dirname(__FILE__), "../ext")
 
-require 'rails'
-require 'oj'
+require "oj"
+require "socket"
+require 'io/nonblock'
 
-$data = {:ticker=>"ASAI3", :price=>18.7, :rate=>-0.8.to_d}
-
-def encode
-  p "JSON.generate: #{JSON.generate($data)}"
-  p "Oj.generate: #{Oj.generate($data)}"
-  p "Oj.dump: #{Oj.dump($data)}"
-  p "to_json: #{$data.to_json}"
-  p "ActiveSupport::JSON.encode: #{ActiveSupport::JSON.encode($data)}"
+#pid = spawn("nc -d 0.1 -l 5000", out: "/dev/null")
+pid = spawn("nc -i 1 -l 7777", out: "/dev/null")
+at_exit { Process.kill 9, pid }
+sleep 0.2
+s = Socket.tcp("localhost", 7777)
+s.nonblock = false
+1_000_000.times do |x|
+  Oj.to_stream(s, { x: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]})
 end
 
-puts "With Oj version (#{Oj::VERSION})"
-
-puts
-puts "Before optimizing"
-encode
-
-Oj.optimize_rails
-Oj.default_options = {
-  mode: :rails,
-  bigdecimal_as_decimal: true,
-  bigdecimal_load: true
-}
+=begin
+IO.pipe do |r, w|
+  if fork
+    r.close
+    #w.nonblock = false
+    1_000_000.times do |i|
+      begin
+	Oj.to_stream(w, { x: i})
+      rescue IOError => e
+	puts "*** #{i} raised #{e.class}: #{e}"
+	IO.select(nil, [w])
+	retry
+      end
+      w.puts
+    end
+  else
+    w.close
+    sleep(0.1)
+    r.each_line { |b|
+      #print b
+    }
+    r.close
+    Process.exit(0)
+  end
+end
+=end
 
-puts
-puts "After optimizing"
-encode
+=begin
+IO.pipe do |r, w|
+  if fork
+    r.close
+    #w.nonblock = false
+    a = []
+    10_000.times do |i|
+      a << i
+    end
+    begin
+      Oj.to_stream(w, a, indent: 2)
+    rescue IOError => e
+      puts "*** raised #{e.class}: #{e}"
+      puts "*** fileno: #{w.fileno}"
+      puts "*** is an IO?: #{w.kind_of?(IO)}"
+      IO.select(nil, [w])
+      retry
+    end
+    w.puts
+  else
+    w.close
+    sleep(0.5)
+    r.each_line { |b|
+      #print b
+    }
+    r.close
+    Process.exit(0)
+  end
+end
+=end

data/test/perf_dump.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << '.'
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'optparse'
+require 'oj'
+
+$verbose = false
+$indent = 2
+$iter = 100_000
+$size = 2
+
+opts = OptionParser.new
+opts.on("-v", "verbose")                                    { $verbose = true }
+opts.on("-c", "--count [Int]", Integer, "iterations")       { |i| $iter = i }
+opts.on("-i", "--indent [Int]", Integer, "indentation")     { |i| $indent = i }
+opts.on("-s", "--size [Int]", Integer, "size (~Kbytes)")    { |i| $size = i }
+opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
+files = opts.parse(ARGV)
+
+$obj = {
+  'a' => 'Alpha', # string
+  'b' => true,    # boolean
+  'c' => 12345,   # number
+  'd' => [ true, [false, [-123456789, nil], 3.9676, ['Something else.', false], nil]], # mix it up array
+  'e' => { 'zero' => nil, 'one' => 1, 'two' => 2, 'three' => [3], 'four' => [0, 1, 2, 3, 4] }, # hash
+  'f' => nil,     # nil
+  'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
+  'i' => [[[[[[[nil]]]]]]]  # deep array, again, not that deep
+}
+
+Oj.default_options = { :indent => $indent, :mode => :strict }
+
+if 0 < $size
+  o = $obj
+  $obj = []
+  (4 * $size).times do
+    $obj << o
+  end
+end
+
+$json = Oj.dump($obj)
+GC.start
+start = Time.now
+$iter.times { Oj.dump($obj) }
+duration = Time.now - start
+puts "Dumped #{$json.length} byte JSON #{$iter} times in %0.3f seconds or %0.3f iteration/sec." % [duration, $iter / duration]