oj 3.15.0 → 3.16.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 929e5766d8a556ed9590574901fe8268979fd6c165d10e1a2a8601a594dd6897
-  data.tar.gz: 966fedee6a16f73c004b56050474377ae48521f5858da962f0f0416b5636a4c3
+  metadata.gz: 3a6b15904386e7010fa071ecc27b8f3a6d5023c8162ea7042fc39e29c373a20a
+  data.tar.gz: b862e59cff0ba3a15eadec34fe807d5893c9c1d1e9fcce01ced66ab28e642181
 SHA512:
-  metadata.gz: f458f616c33c48d84cb0e1d2c1c45e8b677609c19251345328721fe3b7b6c4c5aa1fd4906da2234b60889a6e3bb45ee0371e7de7565bb6d1aa7d924e231e36dd
-  data.tar.gz: fbbf233fc1ce57739d2fe538c179a24282e4c043740c2b47cce29745e3847712afa7828d321b877a3c29ab7d2216e7185af9a85bb9c8eb96b6036f9e3e49c1d1
+  metadata.gz: f186fb40ebcc3792b4949f81ce3b2efb22bee9dce9b44785eeca37cc27e25b79e8afa4fc5872232001d28a3d0b279fc222d5f7d2f8aaa091fe3a135246139b64
+  data.tar.gz: 9c1536bfc15eb3fe02e92d803417ef1ccce5084036aaf8df5ae2b61995a429ab8ae00be5e9b7c79e11839d781c67523ed5bc534df36a40b59dcc61db6551158f

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # CHANGELOG
 
+## 3.16.3 - 2023-12-11
+
+- Fixed the gemspec to allow earlier versions of the bigdecimal gem.
+
+## 3.16.2 - 2023-12-06
+
+- Fixed documentation formatting.
+
+- Added option to the "usual" parser to raise an error on an empty input string.
+
+## 3.16.1 - 2023-09-01
+
+- Fixed exception type on number parsing. (thank you @jasonpenny)
+
+## 3.16.0 - 2023-08-16
+
+- Added the `float_format` option.
+
+- Expanded the `max_nesting` option to allow integer values as well as
+  the previous boolean (true or nil).
+
+- Skip nesting tests with Truffle Ruby in the json gem tests.
+
+## 3.15.1 - 2023-07-30
+
+- Add protection against some using `require 'oj/json`, an internal file.
+
+- Fixed non-json errors when in compat mode.
+
 ## 3.15.0 - 2023-06-02
 
 - Added `omit_null_byte` option when dumping.

data/ext/oj/cache.c

@@ -260,7 +260,8 @@ void cache_set_expunge_rate(Cache c, int rate) {
     c->xrate = (uint8_t)rate;
 }
 
-void cache_free(Cache c) {
+void cache_free(void *data) {
+    Cache    c = (Cache)data;
     uint64_t i;
 
     for (i = 0; i < c->size; i++) {
@@ -276,7 +277,8 @@ void cache_free(Cache c) {
     OJ_FREE(c);
 }
 
-void cache_mark(Cache c) {
+void cache_mark(void *data) {
+    Cache    c = (Cache)data;
     uint64_t i;
 
 #if !HAVE_PTHREAD_MUTEX_INIT

data/ext/oj/cache.h

@@ -10,10 +10,11 @@
 #define CACHE_MAX_KEY 35
 
 struct _cache;
+typedef struct _cache *Cache;
 
 extern struct _cache *cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool mark, bool locking);
-extern void           cache_free(struct _cache *c);
-extern void           cache_mark(struct _cache *c);
+extern void           cache_free(void *data);
+extern void           cache_mark(void *data);
 extern void           cache_set_form(struct _cache *c, VALUE (*form)(const char *str, size_t len));
 extern VALUE          cache_intern(struct _cache *c, const char *key, size_t len);
 extern void           cache_set_expunge_rate(struct _cache *c, int rate);

data/ext/oj/code.c

@@ -185,24 +185,17 @@ void oj_code_attrs(VALUE obj, Attr attrs, int depth, Out out, bool with_class) {
             } else {
                 char   buf[32];
                 char  *b   = buf + sizeof(buf) - 1;
-                int    neg = 0;
+                bool   neg = false;
                 long   num = attrs->num;
                 size_t cnt = 0;
 
                 if (0 > num) {
-                    neg = 1;
+                    neg = true;
                     num = -num;
                 }
                 *b-- = '\0';
                 if (0 < num) {
-                    for (; 0 < num; num /= 10, b--) {
-                        *b = (num % 10) + '0';
-                    }
-                    if (neg) {
-                        *b = '-';
-                    } else {
-                        b++;
-                    }
+                    b = oj_longlong_to_string(num, neg, b);
                 } else {
                     *b = '0';
                 }

data/ext/oj/compat.c

@@ -13,32 +13,19 @@
 #include "trace.h"
 
 static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    const char    *key    = kval->key;
-    int            klen   = kval->klen;
-    Val            parent = stack_peek(&pi->stack);
-    volatile VALUE rkey   = kval->key_val;
+    const char *key    = kval->key;
+    int         klen   = kval->klen;
+    Val         parent = stack_peek(&pi->stack);
 
-    if (Qundef == rkey && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
+    if (Qundef == kval->key_val && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
         *pi->options.create_id == *key && (int)pi->options.create_id_len == klen &&
         0 == strncmp(pi->options.create_id, key, klen)) {
         parent->classname = oj_strndup(str, len);
         parent->clen      = len;
     } else {
         volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
+        volatile VALUE rkey = oj_calc_hash_key(pi, kval);
 
-        if (Qundef == rkey) {
-            if (Yes != pi->options.cache_keys) {
-                if (Yes == pi->options.sym_key) {
-                    rkey = ID2SYM(rb_intern3(key, klen, oj_utf8_encoding));
-                } else {
-                    rkey = rb_utf8_str_new(key, klen);
-                }
-            } else if (Yes == pi->options.sym_key) {
-                rkey = oj_sym_intern(key, klen);
-            } else {
-                rkey = oj_str_intern(key, klen);
-            }
-        }
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
             VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
 

data/ext/oj/custom.c

@@ -889,12 +889,11 @@ void oj_dump_custom_val(VALUE obj, int depth, Out out, bool as_ok) {
 ///// load functions /////
 
 static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
-    const char    *key    = kval->key;
-    int            klen   = kval->klen;
-    Val            parent = stack_peek(&pi->stack);
-    volatile VALUE rkey   = kval->key_val;
+    const char *key    = kval->key;
+    int         klen   = kval->klen;
+    Val         parent = stack_peek(&pi->stack);
 
-    if (Qundef == rkey && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
+    if (Qundef == kval->key_val && Yes == pi->options.create_ok && NULL != pi->options.create_id &&
         *pi->options.create_id == *key && (int)pi->options.create_id_len == klen &&
         0 == strncmp(pi->options.create_id, key, klen)) {
         parent->clas = oj_name2class(pi, str, len, false, rb_eArgError);
@@ -907,15 +906,8 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
         }
     } else {
         volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
-        // volatile VALUE rstr = rb_utf8_str_new(str, len);
+        volatile VALUE rkey = oj_calc_hash_key(pi, kval);
 
-        if (Qundef == rkey) {
-            if (Yes == pi->options.sym_key) {
-                rkey = ID2SYM(rb_intern3(key, klen, oj_utf8_encoding));
-            } else {
-                rkey = rb_utf8_str_new(key, klen);
-            }
-        }
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
             VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
 

data/ext/oj/dump.c

@@ -727,8 +727,11 @@ static void debug_raise(const char *orig, size_t cnt, int line) {
 
 void oj_dump_raw_json(VALUE obj, int depth, Out out) {
     if (oj_string_writer_class == rb_obj_class(obj)) {
-        StrWriter sw  = (StrWriter)DATA_PTR(obj);
-        size_t    len = sw->out.cur - sw->out.buf;
+        StrWriter sw;
+        size_t    len;
+
+        sw  = oj_str_writer_unwrap(obj);
+        len = sw->out.cur - sw->out.buf;
 
         if (0 < len) {
             len--;
@@ -1010,11 +1013,33 @@ static const char digits_table[] = "\
 80818283848586878889\
 90919293949596979899";
 
+char *oj_longlong_to_string(long long num, bool negative, char *buf) {
+    while (100 <= num) {
+        unsigned idx = num % 100 * 2;
+        *buf--       = digits_table[idx + 1];
+        *buf--       = digits_table[idx];
+        num /= 100;
+    }
+    if (num < 10) {
+        *buf-- = num + '0';
+    } else {
+        *buf-- = digits_table[num * 2 + 1];
+        *buf-- = digits_table[num * 2];
+    }
+
+    if (negative) {
+        *buf = '-';
+    } else {
+        buf++;
+    }
+    return buf;
+}
+
 void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
     char      buf[32];
     char     *b              = buf + sizeof(buf) - 1;
     long long num            = NUM2LL(obj);
-    int       neg            = 0;
+    bool      neg            = false;
     size_t    cnt            = 0;
     bool      dump_as_string = false;
 
@@ -1023,7 +1048,7 @@ void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
         dump_as_string = true;
     }
     if (0 > num) {
-        neg = 1;
+        neg = true;
         num = -num;
     }
     *b-- = '\0';
@@ -1032,24 +1057,7 @@ void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
         *b-- = '"';
     }
     if (0 < num) {
-        while (100 <= num) {
-            unsigned idx = num % 100 * 2;
-            *b--         = digits_table[idx + 1];
-            *b--         = digits_table[idx];
-            num /= 100;
-        }
-        if (num < 10) {
-            *b-- = num + '0';
-        } else {
-            *b-- = digits_table[num * 2 + 1];
-            *b-- = digits_table[num * 2];
-        }
-
-        if (neg) {
-            *b = '-';
-        } else {
-            b++;
-        }
+        b = oj_longlong_to_string(num, neg, b);
     } else {
         *b = '0';
     }

data/ext/oj/dump.h

@@ -93,10 +93,7 @@ inline static void dump_ulong(unsigned long num, Out out) {
 
     *b-- = '\0';
     if (0 < num) {
-        for (; 0 < num; num /= 10, b--) {
-            *b = (num % 10) + '0';
-        }
-        b++;
+        b = oj_longlong_to_string((long long)num, false, b);
     } else {
         *b = '0';
     }

data/ext/oj/dump_compat.c

@@ -851,13 +851,18 @@ static DumpFunc compat_funcs[] = {
 };
 
 static void set_state_depth(VALUE state, int depth) {
-    VALUE json_module = rb_const_get_at(rb_cObject, rb_intern("JSON"));
-    VALUE ext         = rb_const_get(json_module, rb_intern("Ext"));
-    VALUE generator   = rb_const_get(ext, rb_intern("Generator"));
-    VALUE state_class = rb_const_get(generator, rb_intern("State"));
+    if (0 == rb_const_defined(rb_cObject, rb_intern("JSON"))) {
+        rb_require("oj/json");
+    }
+    {
+        VALUE json_module = rb_const_get_at(rb_cObject, rb_intern("JSON"));
+        VALUE ext         = rb_const_get(json_module, rb_intern("Ext"));
+        VALUE generator   = rb_const_get(ext, rb_intern("Generator"));
+        VALUE state_class = rb_const_get(generator, rb_intern("State"));
 
-    if (state_class == rb_obj_class(state)) {
-        rb_funcall(state, rb_intern("depth="), 1, INT2NUM(depth));
+        if (state_class == rb_obj_class(state)) {
+            rb_funcall(state, rb_intern("depth="), 1, INT2NUM(depth));
+        }
     }
 }
 
@@ -865,20 +870,15 @@ void oj_dump_compat_val(VALUE obj, int depth, Out out, bool as_ok) {
     int type = rb_type(obj);
 
     TRACE(out->opts->trace, "dump", obj, depth, TraceIn);
+    // The max_nesting logic is that an empty Array or Hash is assumed to have
+    // content so the max_nesting should fail but a non-collection value is
+    // okay. That means a check for a collectable value is needed before
+    // raising.
     if (out->opts->dump_opts.max_depth <= depth) {
-        // When JSON.dump is called then an ArgumentError is expected and the
-        // limit is the depth inclusive. If JSON.generate is called then a
-        // NestingError is expected and the limit is inclusive. Worse than
-        // that there are unit tests for both.
-        if (CALLER_DUMP == out->caller) {
+        if (RUBY_T_ARRAY == type || RUBY_T_HASH == type) {
             if (0 < out->argc) {
                 set_state_depth(*out->argv, depth);
             }
-            rb_raise(rb_eArgError, "Too deeply nested.");
-        } else if (out->opts->dump_opts.max_depth < depth) {
-            if (0 < out->argc) {
-                set_state_depth(*out->argv, depth - 1);
-            }
             raise_json_err("Too deeply nested", "NestingError");
         }
     }

data/ext/oj/extconf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mkmf'
 require 'rbconfig'
 
@@ -6,7 +8,7 @@ dir_config(extension_name)
 
 parts = RUBY_DESCRIPTION.split(' ')
 type = parts[0]
-type = type[4..-1] if type.start_with?('tcs-')
+type = type[4..] if type.start_with?('tcs-')
 is_windows = RbConfig::CONFIG['host_os'] =~ /(mingw|mswin)/
 platform = RUBY_PLATFORM
 version = RUBY_VERSION.split('.')
@@ -56,7 +58,7 @@ dflags.each do |k, v|
 end
 
 $CPPFLAGS += ' -Wall'
-#puts "*** $CPPFLAGS: #{$CPPFLAGS}"
+# puts "*** $CPPFLAGS: #{$CPPFLAGS}"
 # Adding the __attribute__ flag only works with gcc compilers and even then it
 # does not work to check args with varargs so just remove the check.
 CONFIG['warnflags'].slice!(/ -Wsuggest-attribute=format/)

data/ext/oj/fast.c

@@ -40,7 +40,7 @@ typedef struct _doc {
     Leaf         *where;                  // points to current location
     Leaf          where_path[MAX_STACK];  // points to head of path
     char         *json;
-    unsigned long size;  // number of leaves/branches in the doc
+    unsigned long size;                   // number of leaves/branches in the doc
     VALUE         self;
     Batch         batches;
     struct _batch batch0;
@@ -114,10 +114,7 @@ inline static char *ulong_fill(char *s, size_t num) {
     char *b = buf + sizeof(buf) - 1;
 
     *b-- = '\0';
-    for (; 0 < num; num /= 10, b--) {
-        *b = (num % 10) + '0';
-    }
-    b++;
+    b    = oj_longlong_to_string((long long)num, false, b);
     if ('\0' == *b) {
         b--;
         *b = '0';
@@ -576,7 +573,7 @@ static char *read_quoted_value(ParseInfo pi) {
     char *h     = pi->s;  // head
     char *t     = h;      // tail
 
-    h++;  // skip quote character
+    h++;                  // skip quote character
     t++;
     value = h;
     for (; '"' != *h; h++, t++) {
@@ -783,11 +780,10 @@ static VALUE parse_json(VALUE clas, char *json, bool given) {
         }
     }
 #endif
-    doc->json           = json;
-    self                = TypedData_Wrap_Struct(clas, &oj_doc_type, doc);
-    doc->self           = self;
-    DATA_PTR(doc->self) = doc;
-    result              = rb_protect(protect_open_proc, (VALUE)&pi, &ex);
+    doc->json = json;
+    self      = TypedData_Wrap_Struct(clas, &oj_doc_type, doc);
+    doc->self = self;
+    result    = rb_protect(protect_open_proc, (VALUE)&pi, &ex);
     if (given || 0 != ex) {
         DATA_PTR(doc->self) = NULL;
         // TBD is this needed?
@@ -1612,7 +1608,9 @@ static VALUE doc_dump(int argc, VALUE *argv, VALUE self) {
  *   Oj::Doc.open('[1,2,3]') { |doc| doc.size() }  #=> 4
  */
 static VALUE doc_size(VALUE self) {
-    return ULONG2NUM(((Doc)DATA_PTR(self))->size);
+    Doc d;
+    TypedData_Get_Struct(self, struct _doc, &oj_doc_type, d);
+    return ULONG2NUM(d->size);
 }
 
 /* @overload close() => nil

data/ext/oj/intern.c

@@ -85,20 +85,31 @@ static VALUE form_attr(const char *str, size_t len) {
     return (VALUE)rb_intern3(buf, len + 1, oj_utf8_encoding);
 }
 
+static const rb_data_type_t oj_cache_type = {
+    "Oj/cache",
+    {
+        cache_mark,
+        cache_free,
+        NULL,
+    },
+    0,
+    0,
+};
+
 void oj_hash_init(void) {
     VALUE cache_class = rb_define_class_under(Oj, "Cache", rb_cObject);
     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);
+    str_cache_obj            = TypedData_Wrap_Struct(cache_class, &oj_cache_type, str_cache);
     rb_gc_register_address(&str_cache_obj);
 
     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);
+    sym_cache_obj            = TypedData_Wrap_Struct(cache_class, &oj_cache_type, sym_cache);
     rb_gc_register_address(&sym_cache_obj);
 
     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);
+    attr_cache_obj            = TypedData_Wrap_Struct(cache_class, &oj_cache_type, attr_cache);
     rb_gc_register_address(&attr_cache_obj);
 
     memset(class_hash.slots, 0, sizeof(class_hash.slots));
@@ -118,17 +129,23 @@ 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(DATA_PTR(str_cache_obj), key, len);
+    Cache c;
+    TypedData_Get_Struct(str_cache_obj, struct _cache, &oj_cache_type, c);
+    return cache_intern(c, key, len);
 #endif
 }
 
 VALUE
 oj_sym_intern(const char *key, size_t len) {
-    return cache_intern(DATA_PTR(sym_cache_obj), key, len);
+    Cache c;
+    TypedData_Get_Struct(sym_cache_obj, struct _cache, &oj_cache_type, c);
+    return cache_intern(c, key, len);
 }
 
 ID oj_attr_intern(const char *key, size_t len) {
-    return cache_intern(DATA_PTR(attr_cache_obj), key, len);
+    Cache c;
+    TypedData_Get_Struct(attr_cache_obj, struct _cache, &oj_cache_type, c);
+    return cache_intern(c, key, len);
 }
 
 static uint64_t hash_calc(const uint8_t *key, size_t len) {

data/ext/oj/mimic_json.c

@@ -209,7 +209,6 @@ static VALUE mimic_dump(int argc, VALUE *argv, VALUE self) {
 
     oj_out_init(&out);
 
-    out.caller        = CALLER_DUMP;
     copts.escape_mode = JXEsc;
     copts.mode        = CompatMode;
 
@@ -368,7 +367,6 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
     oj_out_init(&out);
 
     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
     // it is.
     copts->dump_opts.nan_dump = RaiseNan;
@@ -427,7 +425,7 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
  *   - *:object_nl* [_String_] String placed after a JSON object
  *   - *:array_nl* [_String_] String placed after a JSON array
  *   - *:ascii_only* [_Boolean_] if not nil or false then use only ascii characters in the output.
- * Note JSON.generate does support this even if it is not documented.
+ *     Note JSON.generate does support this even if it is not documented.
  *
  * Returns [_String_] generated JSON.
  */
@@ -574,7 +572,6 @@ 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.");
         }
-
         rb_hash_foreach(ropts, parse_options_cb, (VALUE)&pi);
         v = rb_hash_lookup(ropts, oj_max_nesting_sym);
         if (Qtrue == v) {
@@ -608,9 +605,9 @@ static VALUE mimic_parse_core(int argc, VALUE *argv, VALUE self, bool bang) {
  * - *source* [_String_|IO] source to parse
  * - *opts* [_Hash_] options
  *   - *:symbolize* [Boolean] _names flag indicating JSON object keys should be Symbols instead of
- * Strings
+ *     Strings
  *   - *:create_additions* [Boolean] flag indicating a key matching +create_id+ in a JSON object
- * should trigger the creation of Ruby Object
+ *     should trigger the creation of Ruby Object
  *
  * Returns [Object]
  * @see create_id=

data/ext/oj/object.c

@@ -83,8 +83,9 @@ static int parse_num(const char *str, const char *end, int cnt) {
 
 VALUE
 oj_parse_xml_time(const char *str, int len) {
-    VALUE       args[8];
-    const char *end = str + len;
+    VALUE       args[7];
+    const char *end  = str + len;
+    const char *orig = str;
     int         n;
 
     // year
@@ -144,7 +145,9 @@ oj_parse_xml_time(const char *str, int len) {
         char c = *str++;
 
         if ('.' == c) {
-            long long nsec = 0;
+            unsigned long long       num            = 0;
+            unsigned long long       den            = 1;
+            const unsigned long long last_den_limit = ULLONG_MAX / 10;
 
             for (; str < end; str++) {
                 c = *str;
@@ -152,9 +155,14 @@ oj_parse_xml_time(const char *str, int len) {
                     str++;
                     break;
                 }
-                nsec = nsec * 10 + (c - '0');
+                if (den > last_den_limit) {
+                    // bail to Time.parse if there are more fractional digits than a ULLONG rational can hold
+                    return rb_funcall(rb_cTime, oj_parse_id, 1, rb_str_new(orig, len));
+                }
+                num = num * 10 + (c - '0');
+                den *= 10;
             }
-            args[5] = rb_float_new((double)n + ((double)nsec + 0.5) / 1000000000.0);
+            args[5] = rb_funcall(INT2NUM(n), oj_plus_id, 1, rb_rational_new(ULL2NUM(num), ULL2NUM(den)));
         } else {
             args[5] = rb_ll2inum(n);
         }