oj 2.9.9 → 2.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0a5afd2bda72fb22d683e9a6ed9f3064b423e8fa
+  data.tar.gz: b15ae64080dedd08f70ae05fc9dcaff5212ae3c0
+SHA512:
+  metadata.gz: bbb37aa63c547484e68159b90896357b02af944abefbf391f4cafedf67baddc213f8592f9907be7c59a267008d43c8a3166ccc066ab60f68704daa854c183e0a
+  data.tar.gz: 9a4833e9d76eb017c5cf7b34c7a28c48c8e7d673c18a4df6839100102099558329e2bbe5173cf02955ab98ddcd049187c692bc49c7a24326df2a72cbf065bba4

data/README.md

@@ -12,7 +12,7 @@ gem 'oj'
 
 ## Documentation
 
-*Documentation*: http://www.ohler.com/oj
+*Documentation*: http://www.ohler.com/oj, http://rubydoc.info/gems/oj
 
 ## Source
 
@@ -26,31 +26,18 @@ Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announceme
 
 [![Build Status](https://secure.travis-ci.org/ohler55/oj.png?branch=master)](http://travis-ci.org/ohler55/oj)
 
-### Current Release 2.9.9
+### Current Release 2.10.0
 
- - Missed a character map entry. / in ascii mode is now output as / and not \/
+ - Using an indent of less than zero will not place newline characters between
+   JSON elements when using the string or stream writer.
 
- - Fixed SC parser to not treat all IO that respond to fileno as a file. It not
-   checks stat and asks if it is a file.
+ - new options callback method was added to the Simple Callback Parser. If
+   defined the prepare_key() method will be called when an JSON object ket is
+   first encountered. The return value is then used as the key in the key-value
+   pair.
 
- - Tightened object parsing of non-string hash keys so that just "^#x" is parsed
-   as a hash pair and not "~#x".
-
- - Using echo to STDIN as an IO input works around the exception raised when
-   asking the IO for it's position (IO.pos).
-
- - Simple Callback Parser now uses the new stream parser for handling files and
-   IO so that larger files are handled more efficiently and streams are read as
-   data arrives instead of on close.
-
- - Handles file FIFO pipes correctly now.
- 
-### Release 2.9.8
-
- - Changed escaping back to previous release and added a new escape mode.
-
- - Strict mode and compat mode no longer parse Infinity or NaN as a valid
-   number. Both are valid in object mode still.
+ - Increased significants digits to 16 from 15. On occasion there may be
+   unexpected round off results. Tou avoid those use the bigdecimal options.
 
 [Older release notes](http://www.ohler.com/dev/oj_misc/release_notes.html).
 

data/ext/oj/compat.c

@@ -38,10 +38,14 @@
 #include "encode.h"
 
 static void
-hash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_t len, const char *orig) {
-    Val	parent = stack_peek(&pi->stack);
+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;
 
-    if (0 != pi->options.create_id &&
+    if (Qundef == rkey &&
+	0 != pi->options.create_id &&
 	*pi->options.create_id == *key &&
 	pi->options.create_id_len == klen &&
 	0 == strncmp(pi->options.create_id, key, klen)) {
@@ -49,12 +53,14 @@ hash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_
 	parent->clen = len;
     } else {
 	volatile VALUE	rstr = rb_str_new(str, len);
-	volatile VALUE	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 (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);
+	    }
 	}
 	rb_hash_aset(parent->val, rkey, rstr);
     }

data/ext/oj/dump.c

@@ -468,7 +468,7 @@ dump_float(VALUE obj, Out out) {
     } else if (d == (double)(long long int)d) {
 	cnt = sprintf(buf, "%.1f", d); // used sprintf due to bug in snprintf
     } else {
-	cnt = sprintf(buf, "%0.15g", d); // used sprintf due to bug in snprintf
+	cnt = sprintf(buf, "%0.16g", d); // used sprintf due to bug in snprintf
     }
     if (out->end - out->cur <= (long)cnt) {
 	grow(out, cnt);
@@ -2340,7 +2340,7 @@ oj_str_writer_pop(StrWriter sw) {
 	*sw->out.cur++ = ']';
 	break;
     }
-    if (0 == sw->depth) {
+    if (0 == sw->depth && 0 <= sw->out.indent) {
 	*sw->out.cur++ = '\n';
     }
 }

data/ext/oj/object.c

@@ -53,15 +53,15 @@ read_long(const char *str, size_t len) {
 }
 
 static VALUE
-hash_key(ParseInfo pi, const char *key, size_t klen, char k1) {
+calc_hash_key(ParseInfo pi, Val kval, char k1) {
     VALUE	rkey;
 
     if (':' == k1) {
-	rkey = rb_str_new(key + 1, klen - 1);
+	rkey = rb_str_new(kval->key + 1, kval->klen - 1);
 	rkey = oj_encode(rkey);
 	rkey = rb_funcall(rkey, oj_to_sym_id, 0);
     } else {
-	rkey = rb_str_new(key, klen);
+	rkey = rb_str_new(kval->key, kval->klen);
 	rkey = oj_encode(rkey);
 	if (Yes == pi->options.sym_key) {
 	    rkey = rb_str_intern(rkey);
@@ -94,7 +94,10 @@ str_to_value(ParseInfo pi, const char *str, size_t len, const char *orig) {
 }
 
 static int
-hat_cstr(ParseInfo pi, Val parent, const char *key, size_t klen, const char *str, size_t len) {
+hat_cstr(ParseInfo pi, Val parent, Val kval, const char *str, size_t len) {
+    const char	*key = kval->key;
+    int		klen = kval->klen;
+
     if (2 == klen) {
 	switch (key[1]) {
 	case 'o': // object
@@ -139,9 +142,9 @@ hat_cstr(ParseInfo pi, Val parent, const char *key, size_t klen, const char *str
 }
 
 static int
-hat_num(ParseInfo pi, Val parent, const char *key, size_t klen, NumInfo ni) {
-    if (2 == klen) {
-	switch (key[1]) {
+hat_num(ParseInfo pi, Val parent, Val kval, NumInfo ni) {
+    if (2 == kval->klen) {
+	switch (kval->key[1]) {
 	case 't': // time as a float
 	    {
 		int64_t	nsec = ni->num * 1000000000LL / ni->div;
@@ -256,9 +259,11 @@ copy_ivars(VALUE target, VALUE src) {
 }
 
 static void
-set_obj_ivar(Val parent, const char *key, size_t klen, VALUE value) {
-    ID	var_id;
-    ID	*slot;
+set_obj_ivar(Val parent, Val kval, VALUE value) {
+    const char	*key = kval->key;
+    int		klen = kval->klen;
+    ID		var_id;
+    ID		*slot;
 
     if ('~' == *key && Qtrue == rb_obj_is_kind_of(parent->val, rb_eException)) {
 	if (5 == klen && 0 == strncmp("~mesg", key, klen)) {
@@ -315,36 +320,38 @@ set_obj_ivar(Val parent, const char *key, size_t klen, VALUE value) {
 }
 
 static void
-hash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_t len, const char *orig) {
-    Val	parent = stack_peek(&pi->stack);
+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);
 
  WHICH_TYPE:
     switch (rb_type(parent->val)) {
     case T_NIL:
 	parent->odd_args = 0; // make sure it is 0 in case not odd
-	if ('^' != *key || !hat_cstr(pi, parent, key, klen, str, len)) {
+	if ('^' != *key || !hat_cstr(pi, parent, kval, str, len)) {
 	    parent->val = rb_hash_new();
 	    goto WHICH_TYPE;
 	}
 	break;
     case T_HASH:
-	rb_hash_aset(parent->val, hash_key(pi, key, klen, parent->k1), str_to_value(pi, str, len, orig));
+	rb_hash_aset(parent->val, calc_hash_key(pi, kval, parent->k1), str_to_value(pi, str, len, orig));
 	break;
     case T_STRING:
 	if (4 == klen && 's' == *key && 'e' == key[1] && 'l' == key[2] && 'f' == key[3]) {
 	    rb_funcall(parent->val, oj_replace_id, 1, str_to_value(pi, str, len, orig));
 	} else {
-	    set_obj_ivar(parent, key, klen, str_to_value(pi, str, len, orig));
+	    set_obj_ivar(parent, kval, str_to_value(pi, str, len, orig));
 	}
 	break;
     case T_OBJECT:
-	set_obj_ivar(parent, key, klen, str_to_value(pi, str, len, orig));
+	set_obj_ivar(parent, kval, str_to_value(pi, str, len, orig));
 	break;
     case T_CLASS:
 	if (0 == parent->odd_args) {
 	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "%s is not an odd class", rb_class2name(rb_obj_class(parent->val)));
 	    return;
-	} else if (0 != oj_odd_set_arg(parent->odd_args, key, klen, str_to_value(pi, str, len, orig))) {
+	} else if (0 != oj_odd_set_arg(parent->odd_args, kval->key, kval->klen, str_to_value(pi, str, len, orig))) {
 	    char	buf[256];
 
 	    if (sizeof(buf) - 1 <= klen) {
@@ -362,27 +369,29 @@ hash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_
 }
 
 static void
-hash_set_num(ParseInfo pi, const char *key, size_t klen, NumInfo ni) {
-    Val	parent = stack_peek(&pi->stack);
+hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
+    const char	*key = kval->key;
+    int		klen = kval->klen;
+    Val		parent = stack_peek(&pi->stack);
 
  WHICH_TYPE:
     switch (rb_type(parent->val)) {
     case T_NIL:
 	parent->odd_args = 0; // make sure it is 0 in case not odd
-	if ('^' != *key || !hat_num(pi, parent, key, klen, ni)) {
+	if ('^' != *key || !hat_num(pi, parent, kval, ni)) {
 	    parent->val = rb_hash_new();
 	    goto WHICH_TYPE;
 	}
 	break;
     case T_HASH:
-	rb_hash_aset(parent->val, hash_key(pi, key, klen, parent->k1), oj_num_as_value(ni));
+	rb_hash_aset(parent->val, calc_hash_key(pi, kval, parent->k1), oj_num_as_value(ni));
 	break;
     case T_OBJECT:
 	if (2 == klen && '^' == *key && 'i' == key[1] &&
 	    !ni->infinity && !ni->neg && 1 == ni->div && 0 == ni->exp && 0 != pi->circ_array) { // fixnum
 	    oj_circ_array_set(pi->circ_array, parent->val, ni->i);
 	} else {
-	    set_obj_ivar(parent, key, klen, oj_num_as_value(ni));
+	    set_obj_ivar(parent, kval, oj_num_as_value(ni));
 	}
 	break;
     case T_CLASS:
@@ -407,8 +416,10 @@ hash_set_num(ParseInfo pi, const char *key, size_t klen, NumInfo ni) {
 }
 
 static void
-hash_set_value(ParseInfo pi, const char *key, size_t klen, VALUE value) {
-    Val	parent = stack_peek(&pi->stack);
+hash_set_value(ParseInfo pi, Val kval, VALUE value) {
+    const char	*key = kval->key;
+    int		klen = kval->klen;
+    Val		parent = stack_peek(&pi->stack);
 
  WHICH_TYPE:
     switch (rb_type(parent->val)) {
@@ -424,7 +435,7 @@ hash_set_value(ParseInfo pi, const char *key, size_t klen, VALUE value) {
 	    if (4 == klen && 's' == *key && 'e' == key[1] && 'l' == key[2] && 'f' == key[3]) {
 		rb_funcall(parent->val, oj_replace_id, 1, value);
 	    } else {
-		set_obj_ivar(parent, key, klen, value);
+		set_obj_ivar(parent, kval, value);
 	    }
 	} else {
 	    if (3 <= klen && '^' == *key && '#' == key[1] && T_ARRAY == rb_type(value)) {
@@ -437,7 +448,7 @@ hash_set_value(ParseInfo pi, const char *key, size_t klen, VALUE value) {
 		}
 		rb_hash_aset(parent->val, *a, a[1]);
 	    } else {
-		rb_hash_aset(parent->val, hash_key(pi, key, klen, parent->k1), value);
+		rb_hash_aset(parent->val, calc_hash_key(pi, kval, parent->k1), value);
 	    }
 	}
 	break;
@@ -445,12 +456,12 @@ hash_set_value(ParseInfo pi, const char *key, size_t klen, VALUE value) {
 	if (4 == klen && 's' == *key && 'e' == key[1] && 'l' == key[2] && 'f' == key[3]) {
 	    rb_funcall(parent->val, oj_replace_id, 1, value);
 	} else {
-	    set_obj_ivar(parent, key, klen, value);
+	    set_obj_ivar(parent, kval, value);
 	}
 	break;
     case T_STRING: // for subclassed strings
     case T_OBJECT:
-	set_obj_ivar(parent, key, klen, value);
+	set_obj_ivar(parent, kval, value);
 	break;
     case T_CLASS:
 	if (0 == parent->odd_args) {

data/ext/oj/oj.c

@@ -62,6 +62,7 @@ ID	oj_file_id;
 ID	oj_fileno_id;
 ID	oj_ftype_id;
 ID	oj_hash_end_id;
+ID	oj_hash_key_id;
 ID	oj_hash_set_id;
 ID	oj_hash_start_id;
 ID	oj_iconv_id;
@@ -180,7 +181,7 @@ static VALUE	define_mimic_json(int argc, VALUE *argv, VALUE self);
 /* call-seq: default_options() => Hash
  *
  * Returns the default load and dump options as a Hash. The options are
- * - indent: [Fixnum] number of spaces to indent each element in an JSON document
+ * - indent: [Fixnum] number of spaces to indent each element in an JSON document, zero is no newline between JSON elements, negative indicates no newline between top level JSON elements in a stream
  * - circular: [true|false|nil] support circular references while dumping
  * - auto_define: [true|false|nil] automatically define classes if they do not exist
  * - symbol_keys: [true|false|nil] use symbols instead of strings for hash keys
@@ -1959,6 +1960,7 @@ void Init_oj() {
     oj_fileno_id = rb_intern("fileno");
     oj_ftype_id = rb_intern("ftype");
     oj_hash_end_id = rb_intern("hash_end");
+    oj_hash_key_id = rb_intern("hash_key");
     oj_hash_set_id = rb_intern("hash_set");
     oj_hash_start_id = rb_intern("hash_start");
     oj_iconv_id = rb_intern("iconv");

data/ext/oj/oj.h

@@ -259,6 +259,7 @@ extern ID	oj_file_id;
 extern ID	oj_fileno_id;
 extern ID	oj_ftype_id;
 extern ID	oj_hash_end_id;
+extern ID	oj_hash_key_id;
 extern ID	oj_hash_set_id;
 extern ID	oj_hash_start_id;
 extern ID	oj_iconv_id;

data/ext/oj/parse.c

@@ -48,7 +48,7 @@
 #define NUM_MAX		(FIXNUM_MAX >> 8)
 #endif
 #define EXP_MAX		1023
-#define DEC_MAX		14
+#define DEC_MAX		15
 
 static void
 next_non_white(ParseInfo pi) {
@@ -110,8 +110,8 @@ add_value(ParseInfo pi, VALUE rval) {
 	    parent->next = NEXT_ARRAY_COMMA;
 	    break;
 	case NEXT_HASH_VALUE:
-	    pi->hash_set_value(pi, parent->key, parent->klen, rval);
-	    if (0 != parent->key && (parent->key < pi->json || pi->cur < parent->key)) {
+	    pi->hash_set_value(pi, parent, rval);
+	    if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
 		xfree((char*)parent->key);
 		parent->key = 0;
 	    }
@@ -295,15 +295,19 @@ read_escaped_str(ParseInfo pi, const char *start) {
 	    break;
 	case NEXT_HASH_NEW:
 	case NEXT_HASH_KEY:
-	    // key will not be between pi->json and pi->cur.
-	    parent->key = strdup(buf.head);
-	    parent->klen = buf_len(&buf);
+	    if (Qundef == (parent->key_val = pi->hash_key(pi, buf.head, buf_len(&buf)))) {
+		parent->key = strdup(buf.head);
+		parent->klen = buf_len(&buf);
+	    } else {
+		parent->key = "";
+		parent->klen = 0;
+	    }
 	    parent->k1 = *start;
 	    parent->next = NEXT_HASH_COLON;
 	    break;
 	case NEXT_HASH_VALUE:
-	    pi->hash_set_cstr(pi, parent->key, parent->klen, buf.head, buf_len(&buf), start);
-	    if (0 != parent->key && (parent->key < pi->json || pi->cur < parent->key)) {
+	    pi->hash_set_cstr(pi, parent, buf.head, buf_len(&buf), start);
+	    if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
 		xfree((char*)parent->key);
 		parent->key = 0;
 	    }
@@ -350,14 +354,19 @@ read_str(ParseInfo pi) {
 	    break;
 	case NEXT_HASH_NEW:
 	case NEXT_HASH_KEY:
-	    parent->key = str;
-	    parent->klen = pi->cur - str;
+	    if (Qundef == (parent->key_val = pi->hash_key(pi, str, pi->cur - str))) {
+		parent->key = str;
+		parent->klen = pi->cur - str;
+	    } else {
+		parent->key = "";
+		parent->klen = 0;
+	    }
 	    parent->k1 = *str;
 	    parent->next = NEXT_HASH_COLON;
 	    break;
 	case NEXT_HASH_VALUE:
-	    pi->hash_set_cstr(pi, parent->key, parent->klen, str, pi->cur - str, str);
-	    if (0 != parent->key && (parent->key < pi->json || pi->cur < parent->key)) {
+	    pi->hash_set_cstr(pi, parent, str, pi->cur - str, str);
+	    if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
 		xfree((char*)parent->key);
 		parent->key = 0;
 	    }
@@ -487,8 +496,8 @@ read_num(ParseInfo pi) {
 	    parent->next = NEXT_ARRAY_COMMA;
 	    break;
 	case NEXT_HASH_VALUE:
-	    pi->hash_set_num(pi, parent->key, parent->klen, &ni);
-	    if (0 != parent->key && (parent->key < pi->json || pi->cur < parent->key)) {
+	    pi->hash_set_num(pi, parent, &ni);
+	    if (0 != parent->key && 0 < parent->klen && (parent->key < pi->json || pi->cur < parent->key)) {
 		xfree((char*)parent->key);
 		parent->key = 0;
 	    }
@@ -702,13 +711,13 @@ oj_num_as_value(NumInfo ni) {
 		rnum = rb_funcall(rnum, rb_intern("to_f"), 0);
 	    }
 	} else {
-	    double	d = (double)ni->i + (double)ni->num / (double)ni->div;
+	    double	d = (double)ni->i + (double)ni->num * (1.0L / ni->div);
 
 	    if (ni->neg) {
 		d = -d;
 	    }
 	    if (0 != ni->exp) {
-		d *= pow(10.0, ni->exp);
+		d *= pow(10.0L, ni->exp);
 	    }
 	    rnum = rb_float_new(d);
 	}

data/ext/oj/parse.h

@@ -72,9 +72,10 @@ typedef struct _ParseInfo {
     VALUE		proc;
     VALUE		(*start_hash)(struct _ParseInfo *pi);
     void		(*end_hash)(struct _ParseInfo *pi);
-    void		(*hash_set_cstr)(struct _ParseInfo *pi, const char *key, size_t klen, const char *str, size_t len, const char *orig);
-    void		(*hash_set_num)(struct _ParseInfo *pi, const char *key, size_t klen, NumInfo ni);
-    void		(*hash_set_value)(struct _ParseInfo *pi, const char *key, size_t klen, VALUE value);
+    VALUE		(*hash_key)(struct _ParseInfo *pi, const char *key, size_t klen);
+    void		(*hash_set_cstr)(struct _ParseInfo *pi, Val kval, const char *str, size_t len, const char *orig);
+    void		(*hash_set_num)(struct _ParseInfo *pi, Val kval, NumInfo ni);
+    void		(*hash_set_value)(struct _ParseInfo *pi, Val kval, VALUE value);
 
     VALUE		(*start_array)(struct _ParseInfo *pi);
     void		(*end_array)(struct _ParseInfo *pi);

data/ext/oj/scp.c

@@ -60,16 +60,21 @@ static void
 noop_add_num(ParseInfo pi, NumInfo ni) {
 }
 
+static VALUE
+noop_hash_key(struct _ParseInfo *pi, const char *key, size_t klen) {
+    return Qundef;
+}
+
 static void
-noop_hash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_t len, const char *orig) {
+noop_hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
 }
 
 static void
-noop_hash_set_num(ParseInfo pi, const char *key, size_t klen, NumInfo ni) {
+noop_hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
 }
 
 static void
-noop_hash_set_value(ParseInfo pi, const char *key, size_t klen, VALUE value) {
+noop_hash_set_value(ParseInfo pi, Val kval, VALUE value) {
 }
 
 static void
@@ -123,32 +128,40 @@ end_array(ParseInfo pi) {
 }
 
 static VALUE
-hash_key(ParseInfo pi, const char *key, size_t klen) {
-    volatile VALUE	rkey = rb_str_new(key, klen);
-
-    rkey = oj_encode(rkey);
-    if (Yes == pi->options.sym_key) {
-	rkey = rb_str_intern(rkey);
+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(struct _ParseInfo *pi, const char *key, size_t klen) {
+    return rb_funcall(pi->handler, oj_hash_key_id, 1, rb_str_new(key, klen));
+}
+
 static void
-hash_set_cstr(ParseInfo pi, const char *key, size_t klen, const char *str, size_t len, const char *orig) {
+hash_set_cstr(ParseInfo pi, Val kval, const char *str, size_t len, const char *orig) {
     volatile VALUE	rstr = rb_str_new(str, len);
 
     rstr = oj_encode(rstr);
-    rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, hash_key(pi, key, klen), rstr);
+    rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, calc_hash_key(pi, kval), rstr);
 }
 
 static void
-hash_set_num(ParseInfo pi, const char *key, size_t klen, NumInfo ni) {
-    rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, hash_key(pi, key, klen), oj_num_as_value(ni));
+hash_set_num(ParseInfo pi, Val kval, NumInfo ni) {
+    rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, calc_hash_key(pi, kval), oj_num_as_value(ni));
 }
 
 static void
-hash_set_value(ParseInfo pi, const char *key, size_t klen, VALUE value) {
-    rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, hash_key(pi, key, klen), value);
+hash_set_value(ParseInfo pi, Val kval, VALUE value) {
+    rb_funcall(pi->handler, oj_hash_set_id, 3, stack_peek(&pi->stack)->val, calc_hash_key(pi, kval), value);
 }
 
 static void
@@ -187,6 +200,7 @@ oj_sc_parse(int argc, VALUE *argv, VALUE self) {
 
     pi.start_hash = rb_respond_to(pi.handler, oj_hash_start_id) ? start_hash : noop_start;
     pi.end_hash = rb_respond_to(pi.handler, oj_hash_end_id) ? end_hash : noop_end;
+    pi.hash_key = rb_respond_to(pi.handler, oj_hash_key_id) ? hash_key : noop_hash_key;
     pi.start_array = rb_respond_to(pi.handler, oj_array_start_id) ? start_array : noop_start;
     pi.end_array = rb_respond_to(pi.handler, oj_array_end_id) ? end_array : noop_end;
     if (rb_respond_to(pi.handler, oj_hash_set_id)) {