oj 3.14.2 → 3.14.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35277d429b423f078c9c259bc2f7d8fd5714f55bb67def193b2b58c1352f3d11
-  data.tar.gz: 337ca936375237d94a5e6a6ece01abd28ce367119fbb72b53dc41c3248c9e136
+  metadata.gz: ce52cbfa0a36f659877cda70d0376fdc19264f96ff8ff1f8085e8cb3560c8bae
+  data.tar.gz: 44b94e3e4174f1464dd7b4f025e28110dc273a353c42a4d8460c6e45846d1fab
 SHA512:
-  metadata.gz: e41c8ef241150e82943a92becc0ca0ec501d3ea9f9a2729abcb2529f2f5ac4360bb0a7684d46fd2357c0edb81d9347b5a6228129536c24157df5b0a788a4fc22
-  data.tar.gz: 6b69fcd20fe9956826865a8fafbca921ae0d9d39f43fbb3aa713b8411381852bcbfa16f7b3a3557e0c24e0545fb0a82c120c93c24bcd81ea8616b89fb6db2b47
+  metadata.gz: 465dd87a8c8e11b562de10d1ab60d78f8e2250c4c06f997455673ea67fb88c75e1c07dea01c01fa864ebfa39a2b0bee1371ee7551895ba6d125bee3af20975ee
+  data.tar.gz: 430a1f0a293fe87fd03af88b2e1f27e70ffae7b7ab8a2451dea1de5891ce6b9967f5475bd33f7cb37c728a7e4ed44b2b3c5051ebeb452c76f393f543a42d5dd1

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # CHANGELOG
 
+## 3.14.3 - 2023-04-07
+
+- Fixed compat parse with optimized Hash when parsing a JSON::GenericObject.
+
 ## 3.14.2 - 2023-02-10
 
 - Fixed check for \0 in strings.
@@ -14,7 +18,7 @@
 
 - Tracing is now a compile time option giving a 15 to 20% performance boost.
 
-- Some cleanup in teh fast parser.
+- Some cleanup in the fast parser.
 
 ## 3.13.23 - 2022-11-06
 

data/README.md

@@ -3,7 +3,6 @@
 [![CI](https://github.com/ohler55/oj/actions/workflows/CI.yml/badge.svg)](https://github.com/ohler55/oj/actions/workflows/CI.yml)
 ![Gem](https://img.shields.io/gem/v/oj.svg)
 ![Gem](https://img.shields.io/gem/dt/oj.svg)
-[![SemVer compatibility](https://api.dependabot.com/badges/compatibility_score?dependency-name=oj&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=oj&package-manager=bundler&version-scheme=semver)
 [![TideLift](https://tidelift.com/badges/github/ohler55/oj)](https://tidelift.com/subscription/pkg/rubygems-oj?utm_source=rubygems-oj&utm_medium=referral&utm_campaign=readme)
 
 A *fast* JSON parser and Object marshaller as a Ruby gem.

data/ext/oj/buf.h

@@ -4,15 +4,15 @@
 #ifndef OJ_BUF_H
 #define OJ_BUF_H
 
-#include "ruby.h"
 #include "mem.h"
+#include "ruby.h"
 
 typedef struct _buf {
     char *head;
     char *end;
     char *tail;
     char  base[1024];
-} * Buf;
+} *Buf;
 
 inline static void buf_init(Buf buf) {
     buf->head = buf->base;

data/ext/oj/cache.c

@@ -6,8 +6,8 @@
 #endif
 #include <stdlib.h>
 
-#include "mem.h"
 #include "cache.h"
+#include "mem.h"
 
 // The stdlib calloc, realloc, and free are used instead of the Ruby ALLOC,
 // ALLOC_N, REALLOC, and xfree since the later could trigger a GC which will
@@ -29,16 +29,16 @@
 #define M 0x5bd1e995
 
 typedef struct _slot {
-    struct _slot *    next;
+    struct _slot     *next;
     VALUE             val;
     uint64_t          hash;
     volatile uint32_t use_cnt;
     uint8_t           klen;
     char              key[CACHE_MAX_KEY];
-} * Slot;
+} *Slot;
 
 typedef struct _cache {
-    volatile Slot * slots;
+    volatile Slot  *slots;
     volatile size_t cnt;
     VALUE (*form)(const char *str, size_t len);
     uint64_t size;
@@ -53,7 +53,7 @@ typedef struct _cache {
 #endif
     uint8_t xrate;
     bool    mark;
-} * Cache;
+} *Cache;
 
 void cache_set_form(Cache c, VALUE (*form)(const char *str, size_t len)) {
     c->form = form;
@@ -95,8 +95,8 @@ static uint64_t hash_calc(const uint8_t *key, size_t len) {
 
 static void rehash(Cache c) {
     uint64_t osize;
-    Slot *   end;
-    Slot *   sp;
+    Slot    *end;
+    Slot    *sp;
 
     osize    = c->size;
     c->size  = osize * 4;
@@ -111,7 +111,7 @@ static void rehash(Cache c) {
         *sp = NULL;
         for (; NULL != s; s = next) {
             uint64_t h      = s->hash & c->mask;
-            Slot *   bucket = (Slot *)c->slots + h;
+            Slot    *bucket = (Slot *)c->slots + h;
 
             next    = s->next;
             s->next = *bucket;
@@ -122,7 +122,7 @@ static void rehash(Cache c) {
 
 static VALUE lockless_intern(Cache c, const char *key, size_t len) {
     uint64_t       h      = hash_calc((const uint8_t *)key, len);
-    Slot *         bucket = (Slot *)c->slots + (h & c->mask);
+    Slot          *bucket = (Slot *)c->slots + (h & c->mask);
     Slot           b;
     volatile VALUE rkey;
 
@@ -166,7 +166,7 @@ static VALUE lockless_intern(Cache c, const char *key, size_t len) {
 
 static VALUE locking_intern(Cache c, const char *key, size_t len) {
     uint64_t       h;
-    Slot *         bucket;
+    Slot          *bucket;
     Slot           b;
     uint64_t       old_size;
     volatile VALUE rkey;
@@ -242,12 +242,12 @@ Cache cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool
 #else
     c->mutex = rb_mutex_new();
 #endif
-    c->size    = 1 << shift;
-    c->mask    = c->size - 1;
-    c->slots   = OJ_CALLOC(c->size, sizeof(Slot));
-    c->form    = form;
-    c->xrate   = 1;  // low
-    c->mark    = mark;
+    c->size  = 1 << shift;
+    c->mask  = c->size - 1;
+    c->slots = OJ_CALLOC(c->size, sizeof(Slot));
+    c->form  = form;
+    c->xrate = 1;  // low
+    c->mark  = mark;
     if (locking) {
         c->intern = locking_intern;
     } else {

data/ext/oj/cache8.c

@@ -39,10 +39,12 @@ void oj_cache8_new(Cache8 *cache) {
     }
 }
 
-void oj_cache8_delete(Cache8 cache) { cache8_delete(cache, 0); }
+void oj_cache8_delete(Cache8 cache) {
+    cache8_delete(cache, 0);
+}
 
 static void cache8_delete(Cache8 cache, int depth) {
-    Bucket *     b;
+    Bucket      *b;
     unsigned int i;
 
     for (i = 0, b = cache->buckets; i < SLOT_CNT; i++, b++) {
@@ -80,7 +82,7 @@ void oj_cache8_print(Cache8 cache) {
 }
 
 static void slot_print(Cache8 c, sid_t key, unsigned int depth) {
-    Bucket *     b;
+    Bucket      *b;
     unsigned int i;
     sid_t        k8 = (sid_t)key;
     sid_t        k;
@@ -91,11 +93,9 @@ static void slot_print(Cache8 c, sid_t key, unsigned int depth) {
             /*printf("*** key: 0x%016llx  depth: %u  i: %u\n", k, depth, i); */
             if (DEPTH - 1 == depth) {
 #if IS_WINDOWS
-                printf("0x%016lx: %4lu\n", (long unsigned int)k,
-                       (long unsigned int)b->value);
+                printf("0x%016lx: %4lu\n", (long unsigned int)k, (long unsigned int)b->value);
 #else
-                printf("0x%016llx: %4llu\n", (long long unsigned int)k,
-                       (long long unsigned int)b->value);
+                printf("0x%016llx: %4llu\n", (long long unsigned int)k, (long long unsigned int)b->value);
 #endif
             } else {
                 slot_print(b->child, k, depth + 1);

data/ext/oj/circarray.c

@@ -1,9 +1,10 @@
 // Copyright (c) 2012 Peter Ohler. All rights reserved.
 // Licensed under the MIT License. See LICENSE file in the project root for license details.
 
-#include "mem.h"
 #include "circarray.h"
 
+#include "mem.h"
+
 CircArray oj_circ_array_new(void) {
     CircArray ca;
 

data/ext/oj/circarray.h

@@ -9,10 +9,10 @@
 
 typedef struct _circArray {
     VALUE         obj_array[1024];
-    VALUE *       objs;
+    VALUE*        objs;
     unsigned long size;  // allocated size or initial array size
     unsigned long cnt;
-} * CircArray;
+}* CircArray;
 
 extern CircArray oj_circ_array_new(void);
 extern void      oj_circ_array_free(CircArray ca);

data/ext/oj/code.c

@@ -18,8 +18,8 @@ inline static VALUE resolve_classname(VALUE mod, const char *classname) {
 static VALUE path2class(const char *name) {
     char        class_name[1024];
     VALUE       clas;
-    char *      end = class_name + sizeof(class_name) - 1;
-    char *      s;
+    char       *end = class_name + sizeof(class_name) - 1;
+    char       *s;
     const char *n = name;
 
     clas = rb_cObject;

data/ext/oj/code.h

@@ -17,7 +17,7 @@ typedef struct _code {
     EncodeFunc  encode;
     DecodeFunc  decode;
     bool        active;  // For compat mode.
-} * Code;
+} *Code;
 
 // Used by encode functions.
 typedef struct _attr {
@@ -26,7 +26,7 @@ typedef struct _attr {
     VALUE       value;
     long        num;
     VALUE       time;
-} * Attr;
+} *Attr;
 
 extern bool  oj_code_dump(Code codes, VALUE obj, int depth, Out out);
 extern VALUE oj_code_load(Code codes, VALUE clas, VALUE args);

data/ext/oj/compat.c

@@ -3,17 +3,17 @@
 
 #include <stdio.h>
 
-#include "mem.h"
 #include "encode.h"
 #include "err.h"
 #include "intern.h"
+#include "mem.h"
 #include "oj.h"
 #include "parse.h"
 #include "resolve.h"
 #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;
+    const char    *key    = kval->key;
     int            klen   = kval->klen;
     Val            parent = stack_peek(&pi->stack);
     volatile VALUE rkey   = kval->key_val;
@@ -31,7 +31,7 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
                 if (Yes == pi->options.sym_key) {
                     rkey = ID2SYM(rb_intern3(key, klen, oj_utf8_encoding));
                 } else {
-		    rkey = rb_utf8_str_new(key, klen);
+                    rkey = rb_utf8_str_new(key, klen);
                 }
             } else if (Yes == pi->options.sym_key) {
                 rkey = oj_sym_intern(key, klen);
@@ -116,16 +116,12 @@ static void add_num(ParseInfo pi, NumInfo ni) {
 static void hash_set_num(struct _parseInfo *pi, Val parent, NumInfo ni) {
     volatile VALUE rval = oj_num_as_value(ni);
 
-    if (!oj_use_hash_alt && rb_cHash != rb_obj_class(parent->val)) {
+    if (rb_cHash != rb_obj_class(parent->val)) {
         // The rb_hash_set would still work but the unit tests for the
         // json gem require the less efficient []= method be called to set
         // values. Even using the store method to set the values will fail
         // the unit tests.
-        rb_funcall(stack_peek(&pi->stack)->val,
-                   rb_intern("[]="),
-                   2,
-                   oj_calc_hash_key(pi, parent),
-                   rval);
+        rb_funcall(stack_peek(&pi->stack)->val, rb_intern("[]="), 2, oj_calc_hash_key(pi, parent), rval);
     } else {
         rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), rval);
     }
@@ -138,11 +134,7 @@ static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
         // json gem require the less efficient []= method be called to set
         // values. Even using the store method to set the values will fail
         // the unit tests.
-        rb_funcall(stack_peek(&pi->stack)->val,
-                   rb_intern("[]="),
-                   2,
-                   oj_calc_hash_key(pi, parent),
-                   value);
+        rb_funcall(stack_peek(&pi->stack)->val, rb_intern("[]="), 2, oj_calc_hash_key(pi, parent), value);
     } else {
         rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), value);
     }

data/ext/oj/custom.c

@@ -4,12 +4,12 @@
 #include <stdint.h>
 #include <stdio.h>
 
-#include "mem.h"
 #include "code.h"
 #include "dump.h"
 #include "encode.h"
 #include "err.h"
 #include "intern.h"
+#include "mem.h"
 #include "odd.h"
 #include "oj.h"
 #include "parse.h"

data/ext/oj/debug.c

@@ -30,9 +30,7 @@ static void add_int(struct _ojParser *p) {
     switch (p->stack[p->depth]) {
     case TOP_FUN: printf("*** add_int %lld at top\n", (long long)p->num.fixnum); break;
     case ARRAY_FUN: printf("*** add_int %lld to array\n", (long long)p->num.fixnum); break;
-    case OBJECT_FUN:
-        printf("*** add_int %lld with '%s'\n", (long long)p->num.fixnum, buf_str(&p->key));
-        break;
+    case OBJECT_FUN: printf("*** add_int %lld with '%s'\n", (long long)p->num.fixnum, buf_str(&p->key)); break;
     }
 }
 
@@ -48,9 +46,7 @@ static void add_big(struct _ojParser *p) {
     switch (p->stack[p->depth]) {
     case TOP_FUN: printf("*** add_big %s at top\n", buf_str(&p->buf)); break;
     case ARRAY_FUN: printf("*** add_big %s to array\n", buf_str(&p->buf)); break;
-    case OBJECT_FUN:
-        printf("*** add_big %s with '%s'\n", buf_str(&p->buf), buf_str(&p->key));
-        break;
+    case OBJECT_FUN: printf("*** add_big %s with '%s'\n", buf_str(&p->buf), buf_str(&p->key)); break;
     }
 }
 
@@ -58,9 +54,7 @@ static void add_str(struct _ojParser *p) {
     switch (p->stack[p->depth]) {
     case TOP_FUN: printf("*** add_str '%s' at top\n", buf_str(&p->buf)); break;
     case ARRAY_FUN: printf("*** add_str '%s' to array\n", buf_str(&p->buf)); break;
-    case OBJECT_FUN:
-        printf("*** add_str '%s' with '%s'\n", buf_str(&p->buf), buf_str(&p->key));
-        break;
+    case OBJECT_FUN: printf("*** add_str '%s' with '%s'\n", buf_str(&p->buf), buf_str(&p->key)); break;
     }
 }
 

data/ext/oj/dump.c

@@ -14,8 +14,8 @@
 #include <poll.h>
 #endif
 
-#include "mem.h"
 #include "cache8.h"
+#include "mem.h"
 #include "odd.h"
 #include "oj.h"
 #include "trace.h"
@@ -306,8 +306,8 @@ static const char *dump_unicode(const char *str, const char *end, Out out, const
         uint32_t c1;
 
         code -= 0x00010000;
-        c1          = ((code >> 10) & 0x000003FF) + 0x0000D800;
-        code        = (code & 0x000003FF) + 0x0000DC00;
+        c1   = ((code >> 10) & 0x000003FF) + 0x0000D800;
+        code = (code & 0x000003FF) + 0x0000DC00;
         APPEND_CHARS(out->cur, "\\u", 2);
         for (i = 3; 0 <= i; i--) {
             *out->cur++ = hex_chars[(uint8_t)(c1 >> (i * 4)) & 0x0F];
@@ -610,7 +610,7 @@ void oj_write_obj_to_file(VALUE obj, const char *path, Options copts) {
 
     oj_out_init(&out);
 
-    out.omit_nil  = copts->dump_opts.omit_nil;
+    out.omit_nil = copts->dump_opts.omit_nil;
     oj_dump_obj_to_json(obj, copts, &out);
     size = out.cur - out.buf;
     if (0 == (f = fopen(path, "w"))) {
@@ -658,7 +658,7 @@ void oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts) {
 
     oj_out_init(&out);
 
-    out.omit_nil  = copts->dump_opts.omit_nil;
+    out.omit_nil = copts->dump_opts.omit_nil;
     oj_dump_obj_to_json(obj, copts, &out);
     size = out.cur - out.buf;
     if (oj_stringio_class == clas) {
@@ -698,7 +698,7 @@ void oj_dump_str(VALUE obj, int depth, Out out, bool as_ok) {
 
     if (oj_utf8_encoding_index != idx) {
         rb_encoding *enc = rb_enc_from_index(idx);
-        obj = rb_str_conv_enc(obj, enc, oj_utf8_encoding);
+        obj              = rb_str_conv_enc(obj, enc, oj_utf8_encoding);
     }
     oj_dump_cstr(RSTRING_PTR(obj), (int)RSTRING_LEN(obj), 0, 0, out);
 }
@@ -761,8 +761,8 @@ void oj_dump_cstr(const char *str, size_t cnt, bool is_sym, bool escape1, Out ou
         break;
     case SlashEsc:
         has_hi = true;
-        cmap = slash_friendly_chars;
-        size = slash_friendly_size((uint8_t *)str, cnt);
+        cmap   = slash_friendly_chars;
+        size   = slash_friendly_size((uint8_t *)str, cnt);
         break;
     case XSSEsc:
         cmap = xss_friendly_chars;
@@ -941,15 +941,15 @@ void oj_dump_raw(const char *str, size_t cnt, Out out) {
 }
 
 void oj_out_init(Out out) {
-    out->buf = out->stack_buffer;
-    out->cur = out->buf;
-    out->end = out->buf + sizeof(out->stack_buffer) - BUFFER_EXTRA;
+    out->buf       = out->stack_buffer;
+    out->cur       = out->buf;
+    out->end       = out->buf + sizeof(out->stack_buffer) - BUFFER_EXTRA;
     out->allocated = false;
 }
 
 void oj_out_free(Out out) {
     if (out->allocated) {
-        OJ_R_FREE(out->buf); // TBD
+        OJ_R_FREE(out->buf);  // TBD
     }
 }
 
@@ -980,24 +980,24 @@ void oj_grow_out(Out out, size_t len) {
 void oj_dump_nil(VALUE obj, int depth, Out out, bool as_ok) {
     assure_size(out, 4);
     APPEND_CHARS(out->cur, "null", 4);
-    *out->cur   = '\0';
+    *out->cur = '\0';
 }
 
 void oj_dump_true(VALUE obj, int depth, Out out, bool as_ok) {
     assure_size(out, 4);
     APPEND_CHARS(out->cur, "true", 4);
-    *out->cur   = '\0';
+    *out->cur = '\0';
 }
 
 void oj_dump_false(VALUE obj, int depth, Out out, bool as_ok) {
     assure_size(out, 5);
     APPEND_CHARS(out->cur, "false", 5);
-    *out->cur   = '\0';
+    *out->cur = '\0';
 }
 
 void oj_dump_fixnum(VALUE obj, int depth, Out out, bool as_ok) {
     char      buf[32];
-    char *    b              = buf + sizeof(buf) - 1;
+    char     *b              = buf + sizeof(buf) - 1;
     long long num            = NUM2LL(obj);
     int       neg            = 0;
     size_t    cnt            = 0;