oj 3.11.5 → 3.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 964a9272c141179cf6f61317e89bc8dab43184b0d143355dc2212b89f123ccad
-  data.tar.gz: 53a3b3cd773a87953cec71a649f491682b022c13d56ebcc4eb5653bc9cbb560e
+  metadata.gz: 7316e25014cf4268799f3f1e4a01a74fada832b1d68bf64d82cbeb42b2caf1dd
+  data.tar.gz: a02fdb9676efeacfec86475ff35afdb88cfef33e0c94188355cad69401ee2304
 SHA512:
-  metadata.gz: 947dad8a5cfc4d5adb3efbd40218439c984ae6084ef304f6b3012e26e047438a03b6f149b7c224982fc8fd0a699b56fa0e6b9a174e8b00d6567dd911f601f227
-  data.tar.gz: 536b05addb483b631883ccfb9269c6cd93b3e988ea9845021be3e2383a708974ff4e63a9d64a1a76bd8a9934969c42aa16495eccd75e88b7cf4704f619e7b693
+  metadata.gz: 8f83d20545998db46a7dd0bd0e2560f47198fbb0f192bc80f17ffbce046e38727e0c143e022f8d00ba2332e2cb0be27ddda294b6a96d6f4b091ec95e282d2f01
+  data.tar.gz: e62a125cf992f510296bbe6b3eeeaaadaa8ccd2891b764a290518f785b706a797af7fbd247ac360364cd610e67ad038488d6eefb55e4dc028a3b20540995e4df

data/README.md

@@ -1,6 +1,10 @@
 # [![{}j](http://www.ohler.com/dev/images/oj_comet_64.svg)](http://www.ohler.com/oj) gem
 
-[![Build Status](https://img.shields.io/travis/ohler55/oj/master.svg?logo=travis)](http://travis-ci.org/ohler55/oj?branch=master) ![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)
+[![Build Status](https://img.shields.io/github/workflow/status/ohler55/oj/CI?logo=github)](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/compat.c

@@ -23,14 +23,34 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
         parent->classname = oj_strndup(str, len);
         parent->clen      = len;
     } else {
-        volatile VALUE rstr = rb_str_new(str, len);
+        volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
         if (Qundef == rkey) {
-            rkey = rb_str_new(key, klen);
-            rstr = oj_encode(rstr);
-            rkey = oj_encode(rkey);
-            if (Yes == pi->options.sym_key) {
-                rkey = rb_str_intern(rkey);
+            if (Yes != pi->options.cache_keys) {
+                rkey = rb_str_new(key, klen);
+                rkey = oj_encode(rkey);
+                if (Yes == pi->options.sym_key) {
+                    rkey = rb_str_intern(rkey);
+                }
+            } else {
+                VALUE *slot;
+
+                if (Yes == pi->options.sym_key) {
+                    if (Qnil == (rkey = oj_sym_hash_get(key, klen, &slot))) {
+                        rkey  = rb_str_new(key, klen);
+                        rkey  = oj_encode(rkey);
+                        rkey  = rb_str_intern(rkey);
+                        *slot = rkey;
+                        rb_gc_register_address(slot);
+                    }
+                } else {
+                    if (Qnil == (rkey = oj_str_hash_get(key, klen, &slot))) {
+                        rkey  = rb_str_new(key, klen);
+                        rkey  = oj_encode(rkey);
+                        *slot = rkey;
+                        rb_gc_register_address(slot);
+                    }
+                }
             }
         }
         if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
@@ -93,23 +113,9 @@ static void end_hash(struct _parseInfo *pi) {
     }
 }
 
-static VALUE calc_hash_key(ParseInfo pi, Val parent) {
-    volatile VALUE rkey = parent->key_val;
-
-    if (Qundef == rkey) {
-        rkey = rb_str_new(parent->key, parent->klen);
-    }
-    rkey = oj_encode(rkey);
-    if (Yes == pi->options.sym_key) {
-        rkey = rb_str_intern(rkey);
-    }
-    return rkey;
-}
-
 static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE rstr = rb_str_new(str, len);
+    volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    rstr = oj_encode(rstr);
     if (Yes == pi->options.create_ok && NULL != pi->options.str_rx.head) {
         VALUE clas = oj_rxclass_match(&pi->options.str_rx, str, (int)len);
 
@@ -142,10 +148,10 @@ static void hash_set_num(struct _parseInfo *pi, Val parent, NumInfo ni) {
         rb_funcall(stack_peek(&pi->stack)->val,
                    rb_intern("[]="),
                    2,
-                   calc_hash_key(pi, parent),
+                   oj_calc_hash_key(pi, parent),
                    rval);
     } else {
-        rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), rval);
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), rval);
     }
     if (Yes == pi->options.trace) {
         oj_trace_parse_call("set_number", pi, __FILE__, __LINE__, rval);
@@ -161,10 +167,10 @@ static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
         rb_funcall(stack_peek(&pi->stack)->val,
                    rb_intern("[]="),
                    2,
-                   calc_hash_key(pi, parent),
+                   oj_calc_hash_key(pi, parent),
                    value);
     } else {
-        rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), value);
+        rb_hash_aset(stack_peek(&pi->stack)->val, oj_calc_hash_key(pi, parent), value);
     }
     if (Yes == pi->options.trace) {
         oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, value);
@@ -199,9 +205,8 @@ static void array_append_num(ParseInfo pi, NumInfo ni) {
 }
 
 static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE rstr = rb_str_new(str, len);
+    volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    rstr = oj_encode(rstr);
     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

@@ -955,6 +955,7 @@ 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_str_new(str, len);
 
         if (Qundef == rkey) {
@@ -1010,19 +1011,6 @@ static void end_hash(struct _parseInfo *pi) {
     }
 }
 
-static VALUE calc_hash_key(ParseInfo pi, Val parent) {
-    volatile VALUE rkey = parent->key_val;
-
-    if (Qundef == rkey) {
-        rkey = rb_str_new(parent->key, parent->klen);
-    }
-    rkey = oj_encode(rkey);
-    if (Yes == pi->options.sym_key) {
-        rkey = rb_str_intern(rkey);
-    }
-    return rkey;
-}
-
 static void hash_set_num(struct _parseInfo *pi, Val kval, NumInfo ni) {
     Val            parent = stack_peek(&pi->stack);
     volatile VALUE rval   = oj_num_as_value(ni);
@@ -1067,7 +1055,7 @@ static void hash_set_num(struct _parseInfo *pi, Val kval, NumInfo ni) {
             }
             rval = parent->val;
         } else {
-            rb_hash_aset(parent->val, calc_hash_key(pi, kval), rval);
+            rb_hash_aset(parent->val, oj_calc_hash_key(pi, kval), rval);
         }
         break;
     default: break;
@@ -1082,7 +1070,7 @@ static void hash_set_value(ParseInfo pi, Val kval, VALUE value) {
 
     switch (rb_type(parent->val)) {
     case T_OBJECT: oj_set_obj_ivar(parent, kval, value); break;
-    case T_HASH: rb_hash_aset(parent->val, calc_hash_key(pi, kval), value); break;
+    case T_HASH: rb_hash_aset(parent->val, oj_calc_hash_key(pi, kval), value); break;
     default: break;
     }
     if (Yes == pi->options.trace) {

data/ext/oj/fast.c

@@ -80,22 +80,6 @@ static Leaf  get_doc_leaf(Doc doc, const char *path);
 static Leaf  get_leaf(Leaf *stack, Leaf *lp, const char *path);
 static void  each_value(Doc doc, Leaf leaf);
 
-static void  doc_init(Doc doc);
-static void  doc_free(Doc doc);
-static VALUE doc_open(VALUE clas, VALUE str);
-static VALUE doc_open_file(VALUE clas, VALUE filename);
-static VALUE doc_where(VALUE self);
-static VALUE doc_local_key(VALUE self);
-static VALUE doc_home(VALUE self);
-static VALUE doc_type(int argc, VALUE *argv, VALUE self);
-static VALUE doc_fetch(int argc, VALUE *argv, VALUE self);
-static VALUE doc_each_leaf(int argc, VALUE *argv, VALUE self);
-static VALUE doc_move(VALUE self, VALUE str);
-static VALUE doc_each_child(int argc, VALUE *argv, VALUE self);
-static VALUE doc_each_value(int argc, VALUE *argv, VALUE self);
-static VALUE doc_dump(int argc, VALUE *argv, VALUE self);
-static VALUE doc_size(VALUE self);
-
 VALUE oj_doc_class = Qundef;
 
 // This is only for CentOS 5.4 with Ruby 1.9.3-p0.
@@ -899,12 +883,14 @@ static Leaf get_leaf(Leaf *stack, Leaf *lp, const char *path) {
             } else {
                 return 0;
             }
-        } else if (COL_VAL == leaf->value_type && 0 != leaf->elements) {
+        } else if (NULL == leaf->elements) {
+            leaf = NULL;
+        } else if (COL_VAL == leaf->value_type) {
             Leaf first = leaf->elements->next;
             Leaf e     = first;
             int  type  = leaf->rtype;
 
-            leaf = 0;
+            leaf = NULL;
             if (T_ARRAY == type) {
                 int cnt = 0;
 
@@ -929,6 +915,7 @@ static Leaf get_leaf(Leaf *stack, Leaf *lp, const char *path) {
                 const char *slash = next_slash(path);
                 int         klen;
 
+                leaf = NULL;
                 if (0 == slash) {
                     klen = (int)strlen(key);
                     path += klen;
@@ -1217,7 +1204,7 @@ static char *append_key(char *p, const char *key) {
  * @see Oj::Doc.open
  */
 
-/* @overload where?() => String
+/* @overload where() => String
  *
  * Returns a String that describes the absolute path to the current location
  * in the JSON document.
@@ -1259,6 +1246,25 @@ static VALUE doc_where(VALUE self) {
     }
 }
 
+/* @overload where?() => String
+ * @deprecated
+ * Returns a String that describes the absolute path to the current location
+ * in the JSON document.
+ */
+static VALUE doc_where_q(VALUE self) {
+    return doc_where(self);
+}
+
+/* @overload path() => String
+ *
+ * Returns a String that describes the absolute path to the current location
+ * in the JSON document.
+ */
+static VALUE doc_path(VALUE self) {
+    return doc_where(self);
+}
+
+
 /* @overload local_key() => String, Fixnum, nil
  *
  * Returns the final key to the current location.
@@ -1340,14 +1346,14 @@ static VALUE doc_type(int argc, VALUE *argv, VALUE self) {
     return type;
 }
 
-/* @overload fetch(path=nil) => nil, true, false, Fixnum, Float, String, Array,
+/* @overload fetch(path=nil,default=nil) => nil, true, false, Fixnum, Float, String, Array,
  * Hash
  *
  * Returns the value at the location identified by the path or the current
  * location if the path is nil or not provided. This method will create and
  * return an Array or Hash if that is the type of Object at the location
  * specified. This is more expensive than navigating to the leaves of the JSON
- * document.
+ * document. If a default is provided that is used if no value if found.
  *   @param [String] path path to the location to get the type of if provided
  * @example
  *   Oj::Doc.open('[1,2]') { |doc| doc.fetch() }      #=> [1, 2]
@@ -1373,6 +1379,28 @@ static VALUE doc_fetch(int argc, VALUE *argv, VALUE self) {
     return val;
 }
 
+/* @overload exists?(path) => true, false
+ *
+ * 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
+ */
+static VALUE doc_exists(VALUE self, VALUE str) {
+    Doc  doc;
+    Leaf leaf;
+
+    doc = self_doc(self);
+    Check_Type(str, T_STRING);
+    if (0 != (leaf = get_doc_leaf(doc, StringValuePtr(str)))) {
+        if (NULL != leaf) {
+            return Qtrue;
+        }
+    }
+    return Qfalse;
+}
+
 /* @overload each_leaf(path=nil) => nil
  *
  * Yields to the provided block for each leaf node with the identified
@@ -1695,11 +1723,14 @@ void oj_init_doc() {
     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);
-    rb_define_method(oj_doc_class, "where?", doc_where, 0);
+    rb_define_method(oj_doc_class, "where?", doc_where_q, 0);
+    rb_define_method(oj_doc_class, "where", doc_where, 0);
+    rb_define_method(oj_doc_class, "path", doc_path, 0);
     rb_define_method(oj_doc_class, "local_key", doc_local_key, 0);
     rb_define_method(oj_doc_class, "home", doc_home, 0);
     rb_define_method(oj_doc_class, "type", doc_type, -1);
     rb_define_method(oj_doc_class, "fetch", doc_fetch, -1);
+    rb_define_method(oj_doc_class, "exists?", doc_exists, 1);
     rb_define_method(oj_doc_class, "each_leaf", doc_each_leaf, -1);
     rb_define_method(oj_doc_class, "move", doc_move, 1);
     rb_define_method(oj_doc_class, "each_child", doc_each_child, -1);

data/ext/oj/hash.c

@@ -5,8 +5,8 @@
 
 #include <stdint.h>
 
-#define HASH_MASK 0x000003FF
-#define HASH_SLOT_CNT 1024
+#define HASH_SLOT_CNT ((uint32_t)8192)
+#define HASH_MASK (HASH_SLOT_CNT - 1)
 
 typedef struct _keyVal {
     struct _keyVal *next;
@@ -20,6 +20,8 @@ struct _hash {
 };
 
 struct _hash class_hash;
+struct _hash str_hash;
+struct _hash sym_hash;
 struct _hash intern_hash;
 
 // almost the Murmur hash algorithm
@@ -64,6 +66,8 @@ static uint32_t hash_calc(const uint8_t *key, size_t len) {
 
 void oj_hash_init() {
     memset(class_hash.slots, 0, sizeof(class_hash.slots));
+    memset(str_hash.slots, 0, sizeof(str_hash.slots));
+    memset(sym_hash.slots, 0, sizeof(sym_hash.slots));
     memset(intern_hash.slots, 0, sizeof(intern_hash.slots));
 }
 
@@ -100,8 +104,8 @@ static VALUE hash_get(Hash hash, const char *key, size_t len, VALUE **slotp, VAL
 }
 
 void oj_hash_print() {
-    int    i;
-    KeyVal b;
+    uint32_t i;
+    KeyVal   b;
 
     for (i = 0; i < HASH_SLOT_CNT; i++) {
         printf("%4d:", i);
@@ -112,11 +116,44 @@ void oj_hash_print() {
     }
 }
 
+void oj_hash_sizes() {
+    uint32_t i;
+    KeyVal   b;
+    int      max = 0;
+    int      min = 1000000;
+
+    for (i = 0; i < HASH_SLOT_CNT; i++) {
+        int cnt = 0;
+
+        for (b = str_hash.slots + i; 0 != b && 0 != b->key; b = b->next) {
+            cnt++;
+        }
+        // printf(" %4d\n", cnt);
+        if (max < cnt) {
+            max = cnt;
+        }
+        if (cnt < min) {
+            min = cnt;
+        }
+    }
+    printf("min: %d  max: %d\n", min, max);
+}
+
 VALUE
 oj_class_hash_get(const char *key, size_t len, VALUE **slotp) {
     return hash_get(&class_hash, key, len, slotp, Qnil);
 }
 
+VALUE
+oj_str_hash_get(const char *key, size_t len, VALUE **slotp) {
+    return hash_get(&str_hash, key, len, slotp, Qnil);
+}
+
+VALUE
+oj_sym_hash_get(const char *key, size_t len, VALUE **slotp) {
+    return hash_get(&sym_hash, key, len, slotp, Qnil);
+}
+
 ID oj_attr_hash_get(const char *key, size_t len, ID **slotp) {
     return (ID)hash_get(&intern_hash, key, len, (VALUE **)slotp, 0);
 }

data/ext/oj/hash.h

@@ -11,6 +11,8 @@ typedef struct _hash *Hash;
 extern void oj_hash_init();
 
 extern VALUE oj_class_hash_get(const char *key, size_t len, VALUE **slotp);
+extern VALUE oj_str_hash_get(const char *key, size_t len, VALUE **slotp);
+extern VALUE oj_sym_hash_get(const char *key, size_t len, VALUE **slotp);
 extern ID    oj_attr_hash_get(const char *key, size_t len, ID **slotp);
 
 extern void  oj_hash_print();

data/ext/oj/mimic_json.c

@@ -389,9 +389,9 @@ static VALUE mimic_generate_core(int argc, VALUE *argv, Options copts) {
     } else {
         VALUE active_hack[1];
 
-	if (Qundef == state_class) {
-	    oj_define_mimic_json(0, NULL, Qnil);
-	}
+        if (Qundef == state_class) {
+            oj_define_mimic_json(0, NULL, Qnil);
+        }
         active_hack[0] = rb_funcall(state_class, oj_new_id, 0);
         oj_dump_obj_to_json_using_params(*argv, copts, &out, 1, active_hack);
     }
@@ -480,7 +480,7 @@ 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) {
-	oj_define_mimic_json(0, NULL, Qnil);
+        oj_define_mimic_json(0, NULL, Qnil);
     }
     rargs[1] = rb_funcall(state_class, oj_new_id, 1, h);
 
@@ -713,6 +713,8 @@ static struct _options mimic_object_to_json_options = {0,              // indent
                                                        No,             // safe
                                                        false,          // sec_prec_set
                                                        No,             // ignore_under
+                                                       Yes,            // cache_keys
+                                                       3,              // cache_str
                                                        0,              // int_range_min
                                                        0,              // int_range_max
                                                        oj_json_class,  // create_id

data/ext/oj/object.c

@@ -30,11 +30,38 @@ inline static long read_long(const char *str, size_t len) {
 
 static VALUE calc_hash_key(ParseInfo pi, Val kval, char k1) {
     volatile VALUE rkey;
+#if 0
+    VALUE *slot;
 
+    if (':' == k1) {
+        if (Qnil == (rkey = oj_sym_hash_get(kval->key + 1, kval->klen - 1, &slot))) {
+            rkey  = rb_str_new(kval->key + 1, kval->klen - 1);
+            rkey  = oj_encode(rkey);
+            rkey  = rb_str_intern(rkey);
+            *slot = rkey;
+            rb_gc_register_address(slot);
+        }
+    } else if (Yes == pi->options.sym_key) {
+        if (Qnil == (rkey = oj_sym_hash_get(kval->key, kval->klen, &slot))) {
+            rkey  = rb_str_new(kval->key, kval->klen);
+            rkey  = oj_encode(rkey);
+            rkey  = rb_str_intern(rkey);
+            *slot = rkey;
+            rb_gc_register_address(slot);
+        }
+    } else {
+        if (Qnil == (rkey = oj_str_hash_get(kval->key, kval->klen, &slot))) {
+            rkey  = rb_str_new(kval->key, kval->klen);
+            rkey  = oj_encode(rkey);
+            *slot = rkey;
+            rb_gc_register_address(slot);
+        }
+    }
+#else
     if (':' == k1) {
         rkey = rb_str_new(kval->key + 1, kval->klen - 1);
         rkey = oj_encode(rkey);
-        rkey = rb_funcall(rkey, oj_to_sym_id, 0);
+	rkey  = rb_str_intern(rkey);
     } else {
         rkey = rb_str_new(kval->key, kval->klen);
         rkey = oj_encode(rkey);
@@ -42,6 +69,7 @@ static VALUE calc_hash_key(ParseInfo pi, Val kval, char k1) {
             rkey = rb_str_intern(rkey);
         }
     }
+#endif
     return rkey;
 }
 

data/ext/oj/oj.c

@@ -106,6 +106,8 @@ static VALUE auto_sym;
 static VALUE bigdecimal_as_decimal_sym;
 static VALUE bigdecimal_load_sym;
 static VALUE bigdecimal_sym;
+static VALUE cache_keys_sym;
+static VALUE cache_str_sym;
 static VALUE circular_sym;
 static VALUE class_cache_sym;
 static VALUE compat_bigdecimal_sym;
@@ -186,6 +188,8 @@ struct _options oj_default_options = {
     No,             // safe
     false,          // sec_prec_set
     No,             // ignore_under
+    Yes,            // cache_keys
+    3,              // cache_str
     0,              // int_range_min
     0,              // int_range_max
     oj_json_class,  // create_id
@@ -279,9 +283,11 @@ struct _options oj_default_options = {
  *used
  * - *:array_class* [_Class_|_nil_] Class to use instead of Array on load
  * - *:omit_nil* [_true_|_false_] if true Hash and Object attributes with nil values are omitted
- * - *:ignore* [_nil_|Array] either nil or an Array of classes to ignore when dumping
- * - *:ignore_under* [Boolean] if true then attributes that start with _ are ignored when dumping in
+ * - *:ignore* [_nil_|_Array_] either nil or an Array of classes to ignore when dumping
+ * - *:ignore_under* [_Boolean_] if true then attributes that start with _ are ignored when dumping in
  *object or custom mode.
+ * - *:cache_keys* [_Boolean_] if true then hash keys are cached
+ * - *:cache_str* [_Fixnum_] maximum string value length to cache
  * - *:integer_range* [_Range_] Dump integers outside range as strings.
  * - *:trace* [_true,_|_false_] Trace all load and dump calls, default is false (trace is off)
  * - *:safe* [_true,_|_false_] Safe mimic breaks JSON mimic to be safer, default is false (safe is
@@ -389,11 +395,17 @@ static VALUE get_def_opts(VALUE self) {
                      ? Qtrue
                      : ((No == oj_default_options.safe) ? Qfalse : Qnil));
     rb_hash_aset(opts, float_prec_sym, INT2FIX(oj_default_options.float_prec));
+    rb_hash_aset(opts, cache_str_sym, INT2FIX(oj_default_options.cache_str));
     rb_hash_aset(opts,
                  ignore_under_sym,
                  (Yes == oj_default_options.ignore_under)
                      ? Qtrue
                      : ((No == oj_default_options.ignore_under) ? Qfalse : Qnil));
+    rb_hash_aset(opts,
+                 cache_keys_sym,
+                 (Yes == oj_default_options.cache_keys)
+                     ? Qtrue
+                     : ((No == oj_default_options.cache_keys) ? Qfalse : Qnil));
     switch (oj_default_options.mode) {
     case StrictMode: rb_hash_aset(opts, mode_sym, strict_sym); break;
     case CompatMode: rb_hash_aset(opts, mode_sym, compat_sym); break;
@@ -557,6 +569,8 @@ static VALUE get_def_opts(VALUE self) {
  *   - *:ignore* [_nil_|Array] either nil or an Array of classes to ignore when dumping
  *   - *:ignore_under* [_Boolean_] if true then attributes that start with _ are ignored when
  *dumping in object or custom mode.
+ *   - *:cache_keys* [_Boolean_] if true then hash keys are cached
+ *   - *:cache_str* [_Fixnum_] maximum string vsalue length to cache
  *   - *:integer_range* [_Range_] Dump integers outside range as strings.
  *   - *:trace* [_Boolean_] turn trace on or off.
  *   - *:safe* [_Boolean_] turn safe mimic on or off.
@@ -589,6 +603,7 @@ void oj_parse_options(VALUE ropts, Options copts) {
                                {oj_safe_sym, &copts->safe},
                                {ignore_under_sym, &copts->ignore_under},
                                {oj_create_additions_sym, &copts->create_ok},
+                               {cache_keys_sym, &copts->cache_keys},
                                {Qnil, 0}};
     YesNoOpt         o;
     volatile VALUE   v;
@@ -647,6 +662,28 @@ void oj_parse_options(VALUE ropts, Options copts) {
             copts->float_prec = n;
         }
     }
+    if (Qnil != (v = rb_hash_lookup(ropts, cache_str_sym))) {
+        int n;
+
+#ifdef RUBY_INTEGER_UNIFICATION
+        if (rb_cInteger != rb_obj_class(v)) {
+            rb_raise(rb_eArgError, ":cache_str must be a Integer.");
+        }
+#else
+        if (T_FIXNUM != rb_type(v)) {
+            rb_raise(rb_eArgError, ":cache_str must be a Fixnum.");
+        }
+#endif
+        n = FIX2INT(v);
+        if (0 >= n) {
+            copts->cache_str = 0;
+        } else {
+            if (32 < n) {
+                n = 32;
+            }
+            copts->cache_str = (char)n;
+        }
+    }
     if (Qnil != (v = rb_hash_lookup(ropts, sec_prec_sym))) {
         int n;
 
@@ -1636,13 +1673,20 @@ extern VALUE oj_optimize_rails(VALUE self);
 
 /*
 extern void	oj_hash_test();
-
 static VALUE
 hash_test(VALUE self) {
     oj_hash_test();
     return Qnil;
 }
 */
+/*
+extern void oj_hash_sizes();
+static VALUE
+hash_test(VALUE self) {
+    oj_hash_sizes();
+    return Qnil;
+}
+*/
 
 static VALUE protect_require(VALUE x) {
     rb_require("time");
@@ -1816,6 +1860,10 @@ void Init_oj() {
     rb_gc_register_address(&bigdecimal_load_sym);
     bigdecimal_sym = ID2SYM(rb_intern("bigdecimal"));
     rb_gc_register_address(&bigdecimal_sym);
+    cache_keys_sym = ID2SYM(rb_intern("cache_keys"));
+    rb_gc_register_address(&cache_keys_sym);
+    cache_str_sym = ID2SYM(rb_intern("cache_str"));
+    rb_gc_register_address(&cache_str_sym);
     circular_sym = ID2SYM(rb_intern("circular"));
     rb_gc_register_address(&circular_sym);
     class_cache_sym = ID2SYM(rb_intern("class_cache"));

data/ext/oj/oj.h

@@ -143,6 +143,8 @@ typedef struct _options {
     char safe;           // YesNo
     char sec_prec_set;   // boolean (0 or 1)
     char ignore_under;   // YesNo - ignore attrs starting with _ if true in object and custom modes
+    char cache_keys;     // YexNo
+    char cache_str;      // string short than or equal to this are cache
     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

data/ext/oj/parse.c

@@ -1129,7 +1129,7 @@ CLEANUP:
         if (Qnil != pi->err_class) {
             pi->err.clas = pi->err_class;
         }
-        if (CompatMode == pi->options.mode && Yes != pi->options.safe) {
+        if ((CompatMode == pi->options.mode || RailsMode == pi->options.mode) && Yes != pi->options.safe) {
             // The json gem requires the error message be UTF-8 encoded. In
             // additional the complete JSON source must be returned. There
             // does not seem to be a size limit.

data/ext/oj/parse.h

@@ -90,6 +90,9 @@ extern void oj_set_wab_callbacks(ParseInfo pi);
 extern void  oj_sparse2(ParseInfo pi);
 extern VALUE oj_pi_sparse(int argc, VALUE *argv, ParseInfo pi, int fd);
 
+extern VALUE oj_cstr_to_value(const char *str, size_t len, size_t cache_str);
+extern VALUE oj_calc_hash_key(ParseInfo pi, Val parent);
+
 static inline void parse_info_init(ParseInfo pi) {
     memset(pi, 0, sizeof(struct _parseInfo));
 }

data/ext/oj/rails.c

@@ -828,7 +828,8 @@ rails_mimic_json(VALUE self) {
         json = rb_define_module("JSON");
     }
     oj_mimic_json_methods(json);
-    // oj_default_options.mode = RailsMode;
+    // Setting the default mode breaks the prmoise in the docs not to.
+    //oj_default_options.mode = RailsMode;
 
     return Qnil;
 }

data/ext/oj/scp.c

@@ -9,6 +9,7 @@
 #include <unistd.h>
 
 #include "encode.h"
+#include "hash.h"
 #include "oj.h"
 #include "parse.h"
 
@@ -82,19 +83,6 @@ static void end_array(ParseInfo pi) {
     rb_funcall(pi->handler, oj_array_end_id, 0);
 }
 
-static VALUE calc_hash_key(ParseInfo pi, Val kval) {
-    volatile VALUE rkey = kval->key_val;
-
-    if (Qundef == rkey) {
-        rkey = rb_str_new(kval->key, kval->klen);
-        rkey = oj_encode(rkey);
-        if (Yes == pi->options.sym_key) {
-            rkey = rb_str_intern(rkey);
-        }
-    }
-    return rkey;
-}
-
 static VALUE hash_key(ParseInfo pi, const char *key, size_t klen) {
     return rb_funcall(pi->handler, oj_hash_key_id, 1, rb_str_new(key, klen));
 }
@@ -107,7 +95,7 @@ static void hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, c
                oj_hash_set_id,
                3,
                stack_peek(&pi->stack)->val,
-               calc_hash_key(pi, kval),
+               oj_calc_hash_key(pi, kval),
                rstr);
 }
 
@@ -116,7 +104,7 @@ static void hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
                oj_hash_set_id,
                3,
                stack_peek(&pi->stack)->val,
-               calc_hash_key(pi, kval),
+               oj_calc_hash_key(pi, kval),
                oj_num_as_value(ni));
 }
 
@@ -125,7 +113,7 @@ static void hash_set_value(ParseInfo pi, Val kval, VALUE value) {
                oj_hash_set_id,
                3,
                stack_peek(&pi->stack)->val,
-               calc_hash_key(pi, kval),
+               oj_calc_hash_key(pi, kval),
                value);
 }
 

data/ext/oj/strict.c

@@ -8,10 +8,65 @@
 
 #include "encode.h"
 #include "err.h"
+#include "hash.h"
 #include "oj.h"
 #include "parse.h"
 #include "trace.h"
 
+VALUE oj_cstr_to_value(const char *str, size_t len, size_t cache_str) {
+    volatile VALUE rstr = Qnil;
+
+    if (len <= cache_str) {
+        VALUE *slot;
+
+        if (Qnil == (rstr = oj_str_hash_get(str, len, &slot))) {
+            rstr  = rb_str_new(str, len);
+            rstr  = oj_encode(rstr);
+            *slot = rstr;
+            rb_gc_register_address(slot);
+        }
+    } else {
+        rstr = rb_str_new(str, len);
+        rstr = oj_encode(rstr);
+    }
+    return rstr;
+}
+
+VALUE oj_calc_hash_key(ParseInfo pi, Val parent) {
+    volatile VALUE rkey = parent->key_val;
+
+    if (Qundef != rkey) {
+        return rkey;
+    }
+    if (Yes != pi->options.cache_keys) {
+        rkey = rb_str_new(parent->key, parent->klen);
+        rkey = oj_encode(rkey);
+        if (Yes == pi->options.sym_key) {
+            rkey = rb_str_intern(rkey);
+        }
+        return rkey;
+    }
+    VALUE *slot;
+
+    if (Yes == pi->options.sym_key) {
+        if (Qnil == (rkey = oj_sym_hash_get(parent->key, parent->klen, &slot))) {
+            rkey  = rb_str_new(parent->key, parent->klen);
+            rkey  = oj_encode(rkey);
+            rkey  = rb_str_intern(rkey);
+            *slot = rkey;
+            rb_gc_register_address(slot);
+        }
+    } else {
+        if (Qnil == (rkey = oj_str_hash_get(parent->key, parent->klen, &slot))) {
+            rkey  = rb_str_new(parent->key, parent->klen);
+            rkey  = oj_encode(rkey);
+            *slot = rkey;
+            rb_gc_register_address(slot);
+        }
+    }
+    return rkey;
+}
+
 static void hash_end(ParseInfo pi) {
     if (Yes == pi->options.trace) {
         oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
@@ -36,9 +91,8 @@ static void add_value(ParseInfo pi, VALUE val) {
 }
 
 static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE rstr = rb_str_new(str, len);
+    volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    rstr                = oj_encode(rstr);
     pi->stack.head->val = rstr;
     if (Yes == pi->options.trace) {
         oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, rstr);
@@ -65,24 +119,12 @@ static VALUE start_hash(ParseInfo pi) {
     return rb_hash_new();
 }
 
-static VALUE calc_hash_key(ParseInfo pi, Val parent) {
-    volatile VALUE rkey = parent->key_val;
-
-    if (Qundef == rkey) {
-        rkey = rb_str_new(parent->key, parent->klen);
-    }
-    rkey = oj_encode(rkey);
-    if (Yes == pi->options.sym_key) {
-        rkey = rb_str_intern(rkey);
-    }
-    return rkey;
-}
-
 static void hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len, const char *orig) {
-    volatile VALUE rstr = rb_str_new(str, len);
+    volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    rstr = oj_encode(rstr);
-    rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), rstr);
+    rb_hash_aset(stack_peek(&pi->stack)->val,
+                 oj_calc_hash_key(pi, parent),
+                 rstr);
     if (Yes == pi->options.trace) {
         oj_trace_parse_call("set_string", pi, __FILE__, __LINE__, rstr);
     }
@@ -95,14 +137,18 @@ static void hash_set_num(ParseInfo pi, Val parent, NumInfo ni) {
         oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "not a number or other value");
     }
     v = oj_num_as_value(ni);
-    rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), v);
+    rb_hash_aset(stack_peek(&pi->stack)->val,
+                 oj_calc_hash_key(pi, parent),
+                 v);
     if (Yes == pi->options.trace) {
         oj_trace_parse_call("set_number", pi, __FILE__, __LINE__, v);
     }
 }
 
 static void hash_set_value(ParseInfo pi, Val parent, VALUE value) {
-    rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), value);
+    rb_hash_aset(stack_peek(&pi->stack)->val,
+                 oj_calc_hash_key(pi, parent),
+                 value);
     if (Yes == pi->options.trace) {
         oj_trace_parse_call("set_value", pi, __FILE__, __LINE__, value);
     }
@@ -116,9 +162,8 @@ static VALUE start_array(ParseInfo pi) {
 }
 
 static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE rstr = rb_str_new(str, len);
+    volatile VALUE rstr = oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 
-    rstr = oj_encode(rstr);
     rb_ary_push(stack_peek(&pi->stack)->val, rstr);
     if (Yes == pi->options.trace) {
         oj_trace_parse_call("append_string", pi, __FILE__, __LINE__, rstr);

data/ext/oj/wab.c

@@ -10,6 +10,7 @@
 #include "dump.h"
 #include "encode.h"
 #include "err.h"
+#include "hash.h"
 #include "oj.h"
 #include "parse.h"
 #include "trace.h"
@@ -292,6 +293,34 @@ void oj_dump_wab_val(VALUE obj, int depth, Out out) {
 
 ///// load functions /////
 
+static VALUE calc_hash_key(ParseInfo pi, Val parent) {
+    volatile VALUE rkey = parent->key_val;
+
+    if (Qundef != rkey) {
+        rkey = oj_encode(rkey);
+        rkey = rb_str_intern(rkey);
+
+        return rkey;
+    }
+    if (Yes != pi->options.cache_keys) {
+        rkey = rb_str_new(parent->key, parent->klen);
+        rkey = oj_encode(rkey);
+	rkey = rb_str_intern(rkey);
+
+        return rkey;
+    }
+    VALUE *slot;
+
+    if (Qnil == (rkey = oj_sym_hash_get(parent->key, parent->klen, &slot))) {
+        rkey  = rb_str_new(parent->key, parent->klen);
+        rkey  = oj_encode(rkey);
+        rkey  = rb_str_intern(rkey);
+        *slot = rkey;
+        rb_gc_register_address(slot);
+    }
+    return rkey;
+}
+
 static void hash_end(ParseInfo pi) {
     if (Yes == pi->options.trace) {
         oj_trace_parse_hash_end(pi, __FILE__, __LINE__);
@@ -432,7 +461,7 @@ static VALUE protect_uri(VALUE rstr) {
     return rb_funcall(resolve_uri_class(), oj_parse_id, 1, rstr);
 }
 
-static VALUE cstr_to_rstr(const char *str, size_t len) {
+static VALUE cstr_to_rstr(ParseInfo pi, const char *str, size_t len) {
     volatile VALUE v = Qnil;
 
     if (30 == len && '-' == str[4] && '-' == str[7] && 'T' == str[10] && ':' == str[13] &&
@@ -445,20 +474,20 @@ static VALUE cstr_to_rstr(const char *str, size_t len) {
         uuid_check(str, (int)len) && Qnil != resolve_wab_uuid_class()) {
         return rb_funcall(wab_uuid_clas, oj_new_id, 1, rb_str_new(str, len));
     }
-    v = rb_str_new(str, len);
     if (7 < len && 0 == strncasecmp("http://", str, 7)) {
         int            err = 0;
+	v = rb_str_new(str, len);
         volatile VALUE uri = rb_protect(protect_uri, v, &err);
 
         if (0 == err) {
             return uri;
         }
     }
-    return oj_encode(v);
+    return oj_cstr_to_value(str, len, (size_t)pi->options.cache_str);
 }
 
 static void add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    pi->stack.head->val = cstr_to_rstr(str, len);
+    pi->stack.head->val = cstr_to_rstr(pi, str, len);
     if (Yes == pi->options.trace) {
         oj_trace_parse_call("add_string", pi, __FILE__, __LINE__, pi->stack.head->val);
     }
@@ -484,20 +513,8 @@ static VALUE start_hash(ParseInfo pi) {
     return rb_hash_new();
 }
 
-static VALUE calc_hash_key(ParseInfo pi, Val parent) {
-    volatile VALUE rkey = parent->key_val;
-
-    if (Qundef == rkey) {
-        rkey = rb_str_new(parent->key, parent->klen);
-    }
-    rkey = oj_encode(rkey);
-    rkey = rb_str_intern(rkey);
-
-    return rkey;
-}
-
 static void hash_set_cstr(ParseInfo pi, Val parent, const char *str, size_t len, const char *orig) {
-    volatile VALUE rval = cstr_to_rstr(str, len);
+    volatile VALUE rval = cstr_to_rstr(pi, str, len);
 
     rb_hash_aset(stack_peek(&pi->stack)->val, calc_hash_key(pi, parent), rval);
     if (Yes == pi->options.trace) {
@@ -533,7 +550,7 @@ static VALUE start_array(ParseInfo pi) {
 }
 
 static void array_append_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
-    volatile VALUE rval = cstr_to_rstr(str, len);
+    volatile VALUE rval = cstr_to_rstr(pi, str, len);
 
     rb_ary_push(stack_peek(&pi->stack)->val, rval);
     if (Yes == pi->options.trace) {

data/lib/oj/mimic.rb

@@ -23,6 +23,8 @@ module Oj
     bigdecimal_load: :auto,
     circular: false,
     class_cache: false,
+    cache_keys: true,
+    cache_str: false,
     create_additions: false,
     create_id: "json_class",
     empty_string: false,

data/lib/oj/version.rb

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

data/test/foo.rb

@@ -8,48 +8,13 @@ end
 
 require 'oj'
 
-class Foo
-  def initialize
-    @x = 123
-  end
+Oj.default_options = {cache_keys: false, cache_str: 0}
 
-  def xto_json(opt=nil, options=nil)
-    "---to_json---"
-  end
-end
-
-class Bar < Foo
-  def initialize
-    @x = 321
-  end
-end
-
-foo = Foo.new
-bar = Bar.new
-
-require 'json'
-
-puts "JSON: #{JSON.generate(foo)}"
-puts "to_json: #{foo.to_json}"
-puts "bar JSON: #{JSON.generate(bar)}"
-puts "bar to_json: #{bar.to_json}"
-
-m = bar.method('to_json')
-puts "*** method: #{m} owner: #{m.owner.name}"
-
-puts "---- rails"
-require 'rails'
-
-m = bar.method('to_json')
-puts "*** method: #{m} owner: #{m.owner} params: #{m.parameters}"
-
-puts "JSON: #{JSON.generate(foo)}"
-puts "to_json: #{foo.to_json}"
-
-puts "---- Oj.mimic_JSON"
-Oj.mimic_JSON()
-puts "Oj JSON: #{JSON.generate(foo)}"
-puts "Oj to_json: #{foo.to_json}"
+[:compat, :strict, :object].each { |mode|
+  GC.start
+  t = Time.now
+  Oj.load_file('pt_lemma_lookup.json', mode: mode)
+  puts "#{mode}: #{Time.now - t}"
+}
 
-m = bar.method('to_json')
-puts "*** method: #{m} owner: #{m.owner} params: #{m.parameters}"
+# check saj and scp

data/test/perf.rb

@@ -17,7 +17,7 @@ class Perf
       end
     end
   end
-  
+
   def run(iter)
     base = Item.new(nil, nil) { }
     base.run(iter, 0.0)

data/test/perf_scp.rb

@@ -14,16 +14,16 @@ require 'oj'
 
 $verbose = false
 $indent = 0
-$iter = 50000
+$iter = 50_000
 $with_bignum = false
-$size = 0
+$size = 1
 
 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("-b", "with bignum")                                { $with_bignum = true }
+opts.on("-s", "--size [Int]", Integer, "size (~Kbytes)")  { |i| $size = i }
+opts.on("-b", "with bignum")                              { $with_bignum = true }
 opts.on("-h", "--help", "Show this display")              { puts opts; Process.exit!(0) }
 files = opts.parse(ARGV)
 
@@ -47,7 +47,7 @@ if 0 < $size
   end
 end
 
-Oj.default_options = { :indent => $indent, :mode => :compat }
+Oj.default_options = { :indent => $indent, :mode => :strict, cache_keys: true, cache_str: 5 }
 
 $json = Oj.dump($obj)
 $failed = {} # key is same as String used in tests later
@@ -105,7 +105,7 @@ class AllHandler < Oj::ScHandler
 
   def hash_set(h, key, value)
   end
-  
+
   def array_append(a, value)
   end
 
@@ -137,10 +137,11 @@ end
 puts '-' * 80
 puts "Parse Performance"
 perf = Perf.new()
-perf.add('Oj::Saj', 'all') { Oj.saj_parse(saj_handler, $json) }
-perf.add('Oj::Saj', 'none') { Oj.saj_parse(no_saj, $json) }
-perf.add('Oj::Scp', 'all') { Oj.sc_parse(sc_handler, $json) }
-perf.add('Oj::Scp', 'none') { Oj.sc_parse(no_handler, $json) }
+perf.add('Oj::Saj.all', 'all') { Oj.saj_parse(saj_handler, $json) }
+perf.add('Oj::Saj.none', 'none') { Oj.saj_parse(no_saj, $json) }
+perf.add('Oj::Scp.all', 'all') { Oj.sc_parse(sc_handler, $json) }
+perf.add('Oj::Scp.none', 'none') { Oj.sc_parse(no_handler, $json) }
+perf.add('Oj::load', 'none') { Oj.wab_load($json) }
 perf.add('Yajl', 'parse') { Yajl::Parser.parse($json) } unless $failed.has_key?('Yajl')
 perf.add('JSON::Ext', 'parse') { JSON::Ext::Parser.new($json).parse } unless $failed.has_key?('JSON::Ext')
 perf.run($iter)

data/test/perf_strict.rb

@@ -15,6 +15,8 @@ $iter = 20000
 $with_bignum = false
 $with_nums = true
 $size = 0
+$symbolize = false
+$cache_keys = true
 
 opts = OptionParser.new
 opts.on("-v", "verbose")                                    { $verbose = true }
@@ -23,6 +25,8 @@ opts.on("-i", "--indent [Int]", Integer, "indentation")     { |i| $indent = i }
 opts.on("-s", "--size [Int]", Integer, "size (~Kbytes)")    { |i| $size = i }
 opts.on("-b", "with bignum")                                { $with_bignum = true }
 opts.on("-n", "without numbers")                            { $with_nums = false }
+opts.on("-z", "--symbolize", "symbolize keys")              { $symbolize = true }
+opts.on("-k", "--no-cache", "turn off key caching")         { $cache_keys = false }
 opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
 files = opts.parse(ARGV)
 
@@ -51,7 +55,7 @@ else
   }
 end
 
-Oj.default_options = { :indent => $indent, :mode => :strict }
+Oj.default_options = { :indent => $indent, :mode => :strict, cache_keys: $cache_keys, cache_str: 5 }
 
 if 0 < $size
   o = $obj
@@ -62,9 +66,6 @@ if 0 < $size
 end
 
 $json = Oj.dump($obj)
-$obj_json = Oj.dump($obj, :mode => :object)
-#puts "*** size: #{$obj_json.size}"
-#puts "*** #{$obj_json}"
 $failed = {} # key is same as String used in tests later
 
 def capture_error(tag, orig, load_key, dump_key, &blk)
@@ -77,8 +78,13 @@ def capture_error(tag, orig, load_key, dump_key, &blk)
 end
 
 # Verify that all packages dump and load correctly and return the same Object as the original.
-capture_error('Oj:strict', $obj, 'load', 'dump') { |o| Oj.strict_load(Oj.dump(o, :mode => :strict)) }
-capture_error('Yajl', $obj, 'encode', 'parse') { |o| require 'yajl'; Yajl::Parser.parse(Yajl::Encoder.encode(o)) }
+capture_error('Oj:strict', $obj, 'load', 'dump') { |o|
+  Oj.strict_load(Oj.dump(o))
+}
+capture_error('Yajl', $obj, 'encode', 'parse') { |o|
+  require 'yajl'
+  Yajl::Parser.parse(Yajl::Encoder.encode(o))
+}
 capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o|
   require 'json'
   require 'json/ext'
@@ -86,16 +92,11 @@ capture_error('JSON::Ext', $obj, 'generate', 'parse') { |o|
   JSON.parser = JSON::Ext::Parser
   JSON.parse(JSON.generate(o))
 }
-capture_error('JSON::Pure', $obj, 'generate', 'parse') { |o|
-  require 'json/pure'
-  JSON.generator = JSON::Pure::Generator
-  JSON.parser = JSON::Pure::Parser
-  JSON.parse(JSON.generate(o))
-}
+
+Oj.default_options = { symbol_keys: $symbolize }
 
 if $verbose
   puts "json:\n#{$json}\n"
-  puts "object json:\n#{$obj_json}\n"
   puts "Oj loaded object:\n#{Oj.strict_load($json)}\n"
   puts "Yajl loaded object:\n#{Yajl::Parser.parse($json)}\n"
   puts "JSON loaded object:\n#{JSON::Ext::Parser.new($json).parse}\n"
@@ -105,15 +106,12 @@ puts '-' * 80
 puts "Strict Parse Performance"
 perf = Perf.new()
 unless $failed.has_key?('JSON::Ext')
-  perf.add('JSON::Ext', 'parse') { JSON.parse($json) }
+  perf.add('JSON::Ext', 'parse') { JSON.parse($json, symbolize_names: $symbolize) }
   perf.before('JSON::Ext') { JSON.parser = JSON::Ext::Parser }
 end
-unless $failed.has_key?('JSON::Pure')
-  perf.add('JSON::Pure', 'parse') { JSON.parse($json) }
-  perf.before('JSON::Pure') { JSON.parser = JSON::Pure::Parser }
-end
 unless $failed.has_key?('Oj:strict')
   perf.add('Oj:strict', 'strict_load') { Oj.strict_load($json) }
+  perf.add('Oj:wab', 'wab_load') { Oj.wab_load($json) }
 end
 perf.add('Yajl', 'parse') { Yajl::Parser.parse($json) } unless $failed.has_key?('Yajl')
 perf.run($iter)
@@ -125,12 +123,8 @@ unless $failed.has_key?('JSON::Ext')
   perf.add('JSON::Ext', 'dump') { JSON.generate($obj) }
   perf.before('JSON::Ext') { JSON.generator = JSON::Ext::Generator }
 end
-unless $failed.has_key?('JSON::Pure')
-  perf.add('JSON::Pure', 'generate') { JSON.generate($obj) }
-  perf.before('JSON::Pure') { JSON.generator = JSON::Pure::Generator }
-end
 unless $failed.has_key?('Oj:strict')
-  perf.add('Oj:strict', 'dump') { Oj.dump($obj, :mode => :strict) }
+  perf.add('Oj:strict', 'dump') { Oj.dump($obj) }
 end
 perf.add('Yajl', 'encode') { Yajl::Encoder.encode($obj) } unless $failed.has_key?('Yajl')
 perf.run($iter)

data/test/test_fast.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# encoding: UTF-8
+# encoding: utf-8
 
 $: << File.dirname(__FILE__)
 
@@ -279,10 +279,26 @@ class DocTest < Minitest::Test
        ['/array/1', {'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}],
        ['/array', [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}]],
        ['/', {'array' => [{'num' => 3, 'string' => 'message', 'hash' => {'h2' => {'a' => [1, 2, 3]}}}], 'boolean' => true}],
+       ['/nothing', nil],
+       ['/array/10', nil],
       ].each do |path,val|
-        assert_equal(val, doc.fetch(path))
+	if val.nil?
+	  assert_nil(doc.fetch(path))
+	else
+          assert_equal(val, doc.fetch(path))
+	end
       end
     end
+    # verify empty hash and arrays return nil when a member is requested
+    Oj::Doc.open('{}') do |doc|
+      assert_nil(doc.fetch('/x'))
+      assert_nil(doc.fetch('/0'))
+    end
+    Oj::Doc.open('[]') do |doc|
+      assert_nil(doc.fetch('/x'))
+      assert_nil(doc.fetch('/0'))
+    end
+
   end
 
   def test_move_fetch_path
@@ -297,6 +313,20 @@ class DocTest < Minitest::Test
     end
   end
 
+  def test_exisits
+    Oj::Doc.open(@json1) do |doc|
+      [['/array/1', true],
+       ['/array/1', true],
+       ['/array/1/hash', true],
+       ['/array/1/dash', false],
+       ['/array/3', false],
+       ['/nothing', false],
+      ].each do |path,val|
+        assert_equal(val, doc.exists?(path))
+      end
+    end
+  end
+
   def test_home
     Oj::Doc.open(@json1) do |doc|
       doc.move('/array/1/num')

data/test/test_various.rb

@@ -123,6 +123,8 @@ class Juice < Minitest::Test
       compat_bigdecimal: true,
       create_id: 'classy',
       create_additions: true,
+      cache_keys: false,
+      cache_str: 5,
       space: 'z',
       array_nl: 'a',
       object_nl: 'o',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 3.11.5
+  version: 3.12.1
 platform: ruby
 authors:
 - Peter Ohler
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-15 00:00:00.000000000 Z
+date: 2021-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler