oj 3.13.7 → 3.13.23

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/extconf.rb

@@ -23,14 +23,10 @@ dflags = {
   'RSTRUCT_LEN_RETURNS_INTEGER_OBJECT' => ('ruby' == type && '2' == version[0] && '4' == version[1] && '1' >= version[2]) ? 1 : 0,
 }
 
-have_func('rb_time_timespec')
-have_func('rb_ivar_count')
-have_func('rb_ivar_foreach')
 # Support for compaction.
 have_func('rb_gc_mark_movable')
 have_func('stpcpy')
 have_func('pthread_mutex_init')
-have_func('rb_enc_associate')
 have_func('rb_enc_interned_str')
 have_func('rb_ext_ractor_safe', 'ruby.h')
 # rb_hash_bulk_insert is deep down in a header not included in normal build and that seems to fool have_func.
@@ -38,6 +34,11 @@ have_func('rb_hash_bulk_insert', 'ruby.h') unless '2' == version[0] && '6' == ve
 
 dflags['OJ_DEBUG'] = true unless ENV['OJ_DEBUG'].nil?
 
+if with_config('--with-sse42')
+  $CPPFLAGS += ' -msse4.2'
+  dflags['OJ_USE_SSE4_2'] = 1
+end
+
 dflags.each do |k,v|
   if v.nil?
     $CPPFLAGS += " -D#{k}"

data/ext/oj/fast.c

@@ -13,6 +13,7 @@
 
 #include "encode.h"
 #include "oj.h"
+#include "dump.h"
 
 // maximum to allocate on the stack, arbitrary limit
 #define SMALL_JSON 65536
@@ -676,21 +677,23 @@ static void free_doc_cb(void *x) {
 }
 
 static void mark_leaf(Leaf leaf) {
-    switch (leaf->value_type) {
-    case COL_VAL:
-        if (NULL != leaf->elements) {
-            Leaf first = leaf->elements->next;
-            Leaf e     = first;
+    if (NULL != leaf) {
+        switch (leaf->value_type) {
+        case COL_VAL:
+            if (NULL != leaf->elements) {
+                Leaf first = leaf->elements->next;
+                Leaf e     = first;
 
-            do {
-                mark_leaf(e);
-                e = e->next;
-            } while (e != first);
-        }
-        break;
-    case RUBY_VAL: mark(leaf->value); break;
+                do {
+                    mark_leaf(e);
+                    e = e->next;
+                } while (e != first);
+            }
+            break;
+        case RUBY_VAL: mark(leaf->value); break;
 
-    default: break;
+        default: break;
+        }
     }
 }
 
@@ -771,7 +774,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 - (512L * 1024L));
 #else
     {
         struct rlimit lim;
@@ -879,6 +882,10 @@ static Leaf get_leaf(Leaf *stack, Leaf *lp, const char *path) {
             }
         } else if (NULL == leaf->elements) {
             leaf = NULL;
+        } else if (STR_VAL == leaf->value_type || RUBY_VAL == leaf->value_type) {
+            // We are trying to get a children of a leaf, which
+            // doesn't exist.
+            leaf = NULL;
         } else if (COL_VAL == leaf->value_type) {
             Leaf first = leaf->elements->next;
             Leaf e     = first;
@@ -1373,8 +1380,8 @@ static VALUE doc_fetch(int argc, VALUE *argv, VALUE self) {
  * Returns true if the value at the location identified by the path exists.
  *   @param [String] path path to the location
  * @example
- *   Oj::Doc.open('[1,2]') { |doc| doc.exists('/1') }  #=> true
- *   Oj::Doc.open('[1,2]') { |doc| doc.exists('/3') }  #=> false
+ *   Oj::Doc.open('[1,2]') { |doc| doc.exists?('/1') }  #=> true
+ *   Oj::Doc.open('[1,2]') { |doc| doc.exists?('/3') }  #=> false
  */
 static VALUE doc_exists(VALUE self, VALUE str) {
     Doc  doc;
@@ -1488,6 +1495,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) {
@@ -1504,9 +1512,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;
@@ -1521,6 +1533,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;
 }
@@ -1600,18 +1613,15 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
         volatile VALUE rjson;
 
         if (0 == filename) {
-            char        buf[4096];
             struct _out out;
 
-            out.buf       = buf;
-            out.end       = buf + sizeof(buf) - 10;
-            out.allocated = false;
+            oj_out_init(&out);
+
             out.omit_nil  = oj_default_options.dump_opts.omit_nil;
             oj_dump_leaf_to_json(leaf, &oj_default_options, &out);
             rjson = rb_str_new2(out.buf);
-            if (out.allocated) {
-                xfree(out.buf);
-            }
+
+            oj_out_free(&out);
         } else {
             oj_write_leaf_to_file(leaf, filename, &oj_default_options);
             rjson = Qnil;
@@ -1707,8 +1717,10 @@ static VALUE doc_not_implemented(VALUE self) {
  *   # Now try again using a path to Oj::Doc.fetch() directly and not using a
  * block. doc = Oj::Doc.open(json) doc.fetch('/2/three')  #=> 3 doc.close()
  */
-void oj_init_doc() {
+void oj_init_doc(void) {
     oj_doc_class = rb_define_class_under(Oj, "Doc", rb_cObject);
+    rb_gc_register_address(&oj_doc_class);
+    rb_undef_alloc_func(oj_doc_class);
     rb_define_singleton_method(oj_doc_class, "open", doc_open, 1);
     rb_define_singleton_method(oj_doc_class, "open_file", doc_open_file, 1);
     rb_define_singleton_method(oj_doc_class, "parse", doc_open, 1);

data/ext/oj/intern.c

@@ -37,13 +37,10 @@ typedef struct _hash {
 struct _hash class_hash;
 struct _hash attr_hash;
 
-static struct _cache *str_cache = NULL;
 static VALUE          str_cache_obj;
 
-static struct _cache *sym_cache = NULL;
 static VALUE          sym_cache_obj;
 
-static struct _cache *attr_cache = NULL;
 static VALUE          attr_cache_obj;
 
 static VALUE form_str(const char *str, size_t len) {
@@ -86,18 +83,22 @@ static VALUE form_attr(const char *str, size_t len) {
     return (VALUE)rb_intern3(buf, len + 1, oj_utf8_encoding);
 }
 
-void oj_hash_init() {
+void oj_hash_init(void) {
     VALUE cache_class = rb_define_class_under(Oj, "Cache", rb_cObject);
+    rb_undef_alloc_func(cache_class);
 
-    str_cache     = cache_create(0, form_str, true, true);
+    rb_gc_register_address(&cache_class);
+    rb_undef_alloc_func(cache_class);
+
+    struct _cache *str_cache     = cache_create(0, form_str, true, true);
     str_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, str_cache);
     rb_gc_register_address(&str_cache_obj);
 
-    sym_cache     = cache_create(0, form_sym, true, true);
+    struct _cache *sym_cache     = cache_create(0, form_sym, true, true);
     sym_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, sym_cache);
     rb_gc_register_address(&sym_cache_obj);
 
-    attr_cache     = cache_create(0, form_attr, false, true);
+    struct _cache *attr_cache = cache_create(0, form_attr, false, true);
     attr_cache_obj = Data_Wrap_Struct(cache_class, cache_mark, cache_free, attr_cache);
     rb_gc_register_address(&attr_cache_obj);
 
@@ -118,18 +119,18 @@ oj_str_intern(const char *key, size_t len) {
 #if HAVE_RB_ENC_INTERNED_STR && 0
     return rb_enc_interned_str(key, len, rb_utf8_encoding());
 #else
-    return cache_intern(str_cache, key, len);
+    return cache_intern(DATA_PTR(str_cache_obj), key, len);
 #endif
 }
 
 VALUE
 oj_sym_intern(const char *key, size_t len) {
-    return cache_intern(sym_cache, key, len);
+  return cache_intern(DATA_PTR(sym_cache_obj), key, len);
 }
 
 ID
 oj_attr_intern(const char *key, size_t len) {
-    return cache_intern(attr_cache, key, len);
+  return cache_intern(DATA_PTR(attr_cache_obj), key, len);
 }
 
 static uint64_t hash_calc(const uint8_t *key, size_t len) {
@@ -186,6 +187,7 @@ static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int a
     char *      end = class_name + sizeof(class_name) - 1;
     char *      s;
     const char *n = name;
+    size_t	nlen = len;
 
     clas = rb_cObject;
     for (s = class_name; 0 < len; n++, len--) {
@@ -208,7 +210,12 @@ static VALUE resolve_classpath(ParseInfo pi, const char *name, size_t len, int a
     }
     *s = '\0';
     if (Qundef == (clas = resolve_classname(clas, class_name, auto_define))) {
-        oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class %s is not defined", name);
+	if (sizeof(class_name) <= nlen) {
+	    nlen = sizeof(class_name) - 1;
+	}
+	strncpy(class_name, name, nlen);
+	class_name[nlen] = '\0';
+        oj_set_error_at(pi, error_class, __FILE__, __LINE__, "class '%s' is not defined", class_name);
         if (Qnil != error_class) {
             pi->err_class = error_class;
         }
@@ -269,6 +276,7 @@ VALUE oj_class_intern(const char *key, size_t len, bool safe, ParseInfo pi, int
         bucket->len = len;
         bucket->val = resolve_classpath(pi, key, len, auto_define, error_class);
     }
+    rb_gc_register_mark_object(bucket->val);
     return bucket->val;
 }
 
@@ -281,8 +289,10 @@ char *oj_strndup(const char *s, size_t len) {
     return d;
 }
 
-void intern_cleanup() {
+/*
+void intern_cleanup(void) {
     cache_free(str_cache);
     cache_free(sym_cache);
     cache_free(attr_cache);
 }
+*/

data/ext/oj/intern.h

@@ -9,7 +9,7 @@
 
 struct _parseInfo;
 
-extern void oj_hash_init();
+extern void oj_hash_init(void);
 
 extern VALUE oj_str_intern(const char *key, size_t len);
 extern VALUE oj_sym_intern(const char *key, size_t len);

data/ext/oj/mimic_json.c

@@ -6,8 +6,6 @@
 #include "oj.h"
 #include "parse.h"
 
-static VALUE symbolize_names_sym = Qundef;
-
 extern const char oj_json_class[];
 
 VALUE oj_array_nl_sym;
@@ -200,7 +198,6 @@ static int mimic_limit_arg(VALUE a) {
  * Returns [_String_] a JSON string.
  */
 static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
-    char            buf[4096];
     struct _out     out;
     struct _options copts = oj_default_options;
     VALUE           rstr;
@@ -208,9 +205,9 @@ static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
 
     copts.str_rx.head = NULL;
     copts.str_rx.tail = NULL;
-    out.buf           = buf;
-    out.end           = buf + sizeof(buf) - 10;
-    out.allocated     = false;
+
+    oj_out_init(&out);
+
     out.caller        = CALLER_DUMP;
     copts.escape_mode = JXEsc;
     copts.mode        = CompatMode;
@@ -259,9 +256,9 @@ static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
         rb_funcall2(io, oj_write_id, 1, args);
         rstr = io;
     }
-    if (out.allocated) {
-        xfree(out.buf);
-    }
+
+    oj_out_free(&out);
+
     return rstr;
 }
 
@@ -274,7 +271,7 @@ static int mimic_walk(VALUE key, VALUE obj, VALUE proc) {
         size_t i;
 
         for (i = 0; i < cnt; i++) {
-            mimic_walk(Qnil, rb_ary_entry(obj, i), proc);
+            mimic_walk(Qnil, RARRAY_AREF(obj, i), proc);
         }
         break;
     }
@@ -360,15 +357,16 @@ static VALUE mimic_dump_load(int argc, VALUE *argv, VALUE self) {
 }
 
 static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
-    char        buf[4096];
     struct _out out;
     VALUE       rstr;
 
-    memset(buf, 0, sizeof(buf));
+    if (0 == argc) {
+        rb_raise(rb_eArgError, "wrong number of arguments (0))");
+    }
+    memset(out.stack_buffer, 0, sizeof(out.stack_buffer));
+
+    oj_out_init(&out);
 
-    out.buf       = buf;
-    out.end       = buf + sizeof(buf) - 10;
-    out.allocated = false;
     out.omit_nil  = copts->dump_opts.omit_nil;
     out.caller    = CALLER_GENERATE;
     // For obj.to_json or generate nan is not allowed but if called from dump
@@ -390,6 +388,10 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
         VALUE active_hack[1];
 
         if (Qundef == state_class) {
+            rb_warn(
+              "Oj::Rails.mimic_JSON was called implicitly. "
+              "Call it explicitly beforehand if you want to remove this warning."
+            );
             oj_define_mimic_json(0, NULL, Qnil);
         }
         active_hack[0] = rb_funcall(state_class, oj_new_id, 0);
@@ -400,9 +402,9 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
     }
     rstr = rb_str_new2(out.buf);
     rstr = oj_encode(rstr);
-    if (out.allocated) {
-        xfree(out.buf);
-    }
+
+    oj_out_free(&out);
+
     return rstr;
 }
 
@@ -459,9 +461,12 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
     // a Hash. I haven't dug deep enough to find out why but using a State
     // instance and not a Hash gives the desired behavior.
     *rargs = *argv;
-    if (1 == argc) {
+    if (0 == argc) {
+        rb_raise(rb_eArgError, "wrong number of arguments (0))");
+    }
+    if (1 == argc || Qnil == argv[1]) {
         h = rb_hash_new();
-    } else {
+    } else  {
         h = argv[1];
     }
     if (!oj_hash_has_key(h, oj_indent_sym)) {
@@ -480,6 +485,10 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
         rb_hash_aset(h, oj_array_nl_sym, rb_str_new2("\n"));
     }
     if (Qundef == state_class) {
+        rb_warn(
+          "Oj::Rails.mimic_JSON was called implicitly. "
+          "Call it explicitly beforehand if you want to remove this warning."
+        );
         oj_define_mimic_json(0, NULL, Qnil);
     }
     rargs[1] = rb_funcall(state_class, oj_new_id, 1, h);
@@ -501,6 +510,44 @@ oj_mimic_pretty_generate(int argc, VALUE *argv, VALUE self) {
     return mimic_generate_core(2, rargs, &copts);
 }
 
+static int parse_options_cb(VALUE k, VALUE v, VALUE info) {
+    struct _parseInfo *pi = (struct _parseInfo *)info;
+
+    if (oj_symbolize_names_sym == k) {
+        pi->options.sym_key = (Qtrue == v) ? Yes : No;
+    } else if (oj_quirks_mode_sym == k) {
+        pi->options.quirks_mode = (Qtrue == v) ? Yes : No;
+    } else if (oj_create_additions_sym == k) {
+        pi->options.create_ok = (Qtrue == v) ? Yes : No;
+    } else if (oj_allow_nan_sym == k) {
+        pi->options.allow_nan = (Qtrue == v) ? Yes : No;
+    } else if (oj_hash_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.hash_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.hash_class = v;
+        }
+    } else if (oj_object_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.hash_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.hash_class = v;
+        }
+    } else if (oj_array_class_sym == k) {
+        if (Qnil == v) {
+            pi->options.array_class = Qnil;
+        } else {
+            rb_check_type(v, T_CLASS);
+            pi->options.array_class = v;
+        }
+    } else if (oj_decimal_class_sym == k) {
+        pi->options.compat_bigdec = (oj_bigdecimal_class == v);
+    }
+    return ST_CONTINUE;
+}
+
 static VALUE mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
     struct _parseInfo pi;
     VALUE             ropts;
@@ -531,50 +578,8 @@ static VALUE mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
         if (T_HASH != rb_type(ropts)) {
             rb_raise(rb_eArgError, "options must be a hash.");
         }
-        if (Qundef == symbolize_names_sym) {
-            symbolize_names_sym = ID2SYM(rb_intern("symbolize_names"));
-            rb_gc_register_address(&symbolize_names_sym);
-        }
-        if (Qnil != (v = rb_hash_lookup(ropts, symbolize_names_sym))) {
-            pi.options.sym_key = (Qtrue == v) ? Yes : No;
-        }
-        if (Qnil != (v = rb_hash_lookup(ropts, oj_quirks_mode_sym))) {
-            pi.options.quirks_mode = (Qtrue == v) ? Yes : No;
-        }
-        if (Qnil != (v = rb_hash_lookup(ropts, oj_create_additions_sym))) {
-            pi.options.create_ok = (Qtrue == v) ? Yes : No;
-        }
-        if (Qnil != (v = rb_hash_lookup(ropts, oj_allow_nan_sym))) {
-            pi.options.allow_nan = (Qtrue == v) ? Yes : No;
-        }
 
-        if (oj_hash_has_key(ropts, oj_hash_class_sym)) {
-            if (Qnil == (v = rb_hash_lookup(ropts, oj_hash_class_sym))) {
-                pi.options.hash_class = Qnil;
-            } else {
-                rb_check_type(v, T_CLASS);
-                pi.options.hash_class = v;
-            }
-        }
-        if (oj_hash_has_key(ropts, oj_object_class_sym)) {
-            if (Qnil == (v = rb_hash_lookup(ropts, oj_object_class_sym))) {
-                pi.options.hash_class = Qnil;
-            } else {
-                rb_check_type(v, T_CLASS);
-                pi.options.hash_class = v;
-            }
-        }
-        if (oj_hash_has_key(ropts, oj_array_class_sym)) {
-            if (Qnil == (v = rb_hash_lookup(ropts, oj_array_class_sym))) {
-                pi.options.array_class = Qnil;
-            } else {
-                rb_check_type(v, T_CLASS);
-                pi.options.array_class = v;
-            }
-        }
-        if (oj_hash_has_key(ropts, oj_decimal_class_sym)) {
-            pi.options.compat_bigdec = (oj_bigdecimal_class == rb_hash_lookup(ropts, oj_decimal_class_sym));
-        }
+        rb_hash_foreach(ropts, parse_options_cb, (VALUE)&pi);
         v = rb_hash_lookup(ropts, oj_max_nesting_sym);
         if (Qtrue == v) {
             pi.max_depth = 100;
@@ -748,16 +753,15 @@ static struct _options mimic_object_to_json_options = {0,              // indent
                                                        }};
 
 static VALUE mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
-    char            buf[4096];
     struct _out     out;
     VALUE           rstr;
     struct _options copts = oj_default_options;
 
     copts.str_rx.head = NULL;
     copts.str_rx.tail = NULL;
-    out.buf           = buf;
-    out.end           = buf + sizeof(buf) - 10;
-    out.allocated     = false;
+
+    oj_out_init(&out);
+
     out.omit_nil      = copts.dump_opts.omit_nil;
     copts.mode        = CompatMode;
     copts.to_json     = No;
@@ -773,9 +777,9 @@ static VALUE mimic_object_to_json(int argc, VALUE *argv, VALUE self) {
     }
     rstr = rb_str_new2(out.buf);
     rstr = oj_encode(rstr);
-    if (out.allocated) {
-        xfree(out.buf);
-    }
+
+    oj_out_free(&out);
+
     return rstr;
 }
 
@@ -852,9 +856,6 @@ void oj_mimic_json_methods(VALUE json) {
     // Pull in the JSON::State mimic file.
     state_class = rb_const_get_at(generator, rb_intern("State"));
     rb_gc_register_mark_object(state_class);
-
-    symbolize_names_sym = ID2SYM(rb_intern("symbolize_names"));
-    rb_gc_register_address(&symbolize_names_sym);
 }
 
 /* Document-module: JSON