oj 2.12.14 → 2.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 625b764edc8ea14b9f037b18d5f5981097345231
-  data.tar.gz: 50d26c3238c9903708879f06ab25e5d9b94a2412
+  metadata.gz: bd957508587371c18e701b638fcf8191b3bc444d
+  data.tar.gz: aef52ecc143c4db76dfd1f9c64914a8a9021ad71
 SHA512:
-  metadata.gz: 10576bbf301ba650159eff911f7ba48eb3bec46ddb760ff49486da282229c9cd911298f86326a0cfb1b25143ffdc360ba634eabb9eb5b4e053a4d663a478564a
-  data.tar.gz: 8f96fe65d7c9c803957ae017a51d40e43cd186b1bad2473e8551cfdb68c06a91f2c3b3c62705f47f26f5b9cd58a06f9c9a01aeca8c0f9d06b75e52e735ca84a3
+  metadata.gz: 03d731a64121a180278f340025cb18e0644504ecb954a7a479a03f79fd6c46cd1ed00d48c850830433550ef968402f9f91a6903e888568075c3d38bb2626ed1d
+  data.tar.gz: 48f98ec630a2fe1f334de5eea37e952b549e7c97d98ab3f86e92a6608dd44e101da5fd853c3191ac76bf4e889609680ef5d97061330b67c7395e29a52cfae5d3

data/README.md

@@ -26,11 +26,16 @@ 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)
 
-## Release 2.12.14
+## Release 2.13.0
 
- - Change the failure mode for objects that can not be serialized such as a
-   socket. Now in compat mode the to_s of the object is placed in the output
-   instead of raising an exception.
+ - Oj no longer raises an exception if the to_hash method of an object does not
+   return a Hash. ActiveRecord has decided that to_hash should return an Array
+   instead so Oj now encodes what ever is returned.
+
+ - Added a register_odd_raw function that allows odd marshal functions to return
+   raw JSON as a string to be included in the dumped JSON.
+
+ - The register_odd function now supports modules in additions to classes.
 
 [Older release notes](http://www.ohler.com/dev/oj_misc/release_notes.html).
 

data/ext/oj/dump.c

@@ -1249,7 +1249,12 @@ dump_data_comp(VALUE obj, int depth, Out out) {
 	volatile VALUE	h = rb_funcall(obj, oj_to_hash_id, 0);
  
 	if (T_HASH != rb_type(h)) {
-	    rb_raise(rb_eTypeError, "%s.to_hash() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
+	    // It seems that ActiveRecord implemented to_hash so that it returns
+	    // an Array and not a Hash. To get around that any value returned
+	    // will be dumped.
+
+	    //rb_raise(rb_eTypeError, "%s.to_hash() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
+	    dump_val(h, depth, out, 0, 0);
 	}
 	dump_hash(h, Qundef, depth, out->opts->mode, out);
 
@@ -1354,7 +1359,12 @@ dump_obj_comp(VALUE obj, int depth, Out out, int argc, VALUE *argv) {
 	volatile VALUE	h = rb_funcall(obj, oj_to_hash_id, 0);
  
 	if (T_HASH != rb_type(h)) {
-	    rb_raise(rb_eTypeError, "%s.to_hash() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
+	    // It seems that ActiveRecord implemented to_hash so that it returns
+	    // an Array and not a Hash. To get around that any value returned
+	    // will be dumped.
+
+	    //rb_raise(rb_eTypeError, "%s.to_hash() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
+	    dump_val(h, depth, out, 0, 0);
 	}
 	dump_hash(h, Qundef, depth, out->opts->mode, out);
     } else if (rb_respond_to(obj, oj_as_json_id)) {
@@ -1684,7 +1694,12 @@ dump_struct_comp(VALUE obj, int depth, Out out) {
 	volatile VALUE	h = rb_funcall(obj, oj_to_hash_id, 0);
  
 	if (T_HASH != rb_type(h)) {
-	    rb_raise(rb_eTypeError, "%s.to_hash() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
+	    // It seems that ActiveRecord implemented to_hash so that it returns
+	    // an Array and not a Hash. To get around that any value returned
+	    // will be dumped.
+
+	    //rb_raise(rb_eTypeError, "%s.to_hash() did not return a Hash.\n", rb_class2name(rb_obj_class(obj)));
+	    dump_val(h, depth, out, 0, 0);
 	}
 	dump_hash(h, Qundef, depth, out->opts->mode, out);
     } else if (rb_respond_to(obj, oj_as_json_id)) {
@@ -1834,55 +1849,81 @@ dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
 	dump_cstr(class_name, clen, 0, 0, out);
 	*out->cur++ = ',';
     }
-    size = d2 * out->indent + 1;
-    for (idp = odd->attrs, fp = odd->attrFuncs; 0 != *idp; idp++, fp++) {
-	size_t	nlen;
-
-	if (out->end - out->cur <= (long)size) {
-	    grow(out, size);
+    if (odd->raw) {
+	v = rb_funcall(obj, *odd->attrs, 0);
+	if (Qundef == v || T_STRING != rb_type(v)) {
+	    rb_raise(rb_eEncodingError, "Invalid type for raw JSON.\n");
+	} else {	    
+	    const char	*s = rb_string_value_ptr((VALUE*)&v);
+	    int		len = RSTRING_LEN(v);
+	    const char	*name = rb_id2name(*odd->attrs);
+	    size_t	nlen = strlen(name);
+
+	    size = len + d2 * out->indent + nlen + 10;
+	    if (out->end - out->cur <= (long)size) {
+		grow(out, size);
+	    }
+	    fill_indent(out, d2);
+	    *out->cur++ = '"';
+	    memcpy(out->cur, name, nlen);
+	    out->cur += nlen;
+	    *out->cur++ = '"';
+	    *out->cur++ = ':';
+	    memcpy(out->cur, s, len);
+	    out->cur += len;
+	    *out->cur = '\0';
 	}
-	name = rb_id2name(*idp);
-	nlen = strlen(name);
-	if (0 != *fp) {
-	    v = (*fp)(obj);
-	} else if (0 == strchr(name, '.')) {
-	    v = rb_funcall(obj, *idp, 0);
-	} else {
-	    char	nbuf[256];
-	    char	*n2 = nbuf;
-	    char	*n;
-	    char	*end;
-	    ID		i;
-	    
-	    if (sizeof(nbuf) <= nlen) {
-		n2 = strdup(name);
-	    } else {
-		strcpy(n2, name);
+    } else {
+	size = d2 * out->indent + 1;
+	for (idp = odd->attrs, fp = odd->attrFuncs; 0 != *idp; idp++, fp++) {
+	    size_t	nlen;
+
+	    if (out->end - out->cur <= (long)size) {
+		grow(out, size);
 	    }
-	    n = n2;
-	    v = obj;
-	    while (0 != (end = strchr(n, '.'))) {
-		*end = '\0';
+	    name = rb_id2name(*idp);
+	    nlen = strlen(name);
+	    if (0 != *fp) {
+		v = (*fp)(obj);
+	    } else if (0 == strchr(name, '.')) {
+		v = rb_funcall(obj, *idp, 0);
+	    } else {
+		char	nbuf[256];
+		char	*n2 = nbuf;
+		char	*n;
+		char	*end;
+		ID		i;
+	    
+		if (sizeof(nbuf) <= nlen) {
+		    n2 = strdup(name);
+		} else {
+		    strcpy(n2, name);
+		}
+		n = n2;
+		v = obj;
+		while (0 != (end = strchr(n, '.'))) {
+		    *end = '\0';
+		    i = rb_intern(n);
+		    v = rb_funcall(v, i, 0);
+		    n = end + 1;
+		}
 		i = rb_intern(n);
 		v = rb_funcall(v, i, 0);
-		n = end + 1;
+		if (nbuf != n2) {
+		    free(n2);
+		}
 	    }
-	    i = rb_intern(n);
-	    v = rb_funcall(v, i, 0);
-	    if (nbuf != n2) {
-		free(n2);
+	    fill_indent(out, d2);
+	    dump_cstr(name, nlen, 0, 0, out);
+	    *out->cur++ = ':';
+	    dump_val(v, d2, out, 0, 0);
+	    if (out->end - out->cur <= 2) {
+		grow(out, 2);
 	    }
+	    *out->cur++ = ',';
 	}
-	fill_indent(out, d2);
-	dump_cstr(name, nlen, 0, 0, out);
-	*out->cur++ = ':';
-	dump_val(v, d2, out, 0, 0);
-	if (out->end - out->cur <= 2) {
-	    grow(out, 2);
-	}
-	*out->cur++ = ',';
+	out->cur--;
     }
-    out->cur--;
     *out->cur++ = '}';
     *out->cur = '\0';
 }

data/ext/oj/fast.c

@@ -1589,6 +1589,12 @@ doc_close(VALUE self) {
 Oj = rb_define_module("Oj");
 #endif
 
+static VALUE
+doc_not_implemented(VALUE self) {
+    rb_raise(rb_eNotImpError, "Not implemented.");
+    return Qnil;
+}
+
 /* Document-class: Oj::Doc
  *
  * The Doc class is used to parse and navigate a JSON document. The model it
@@ -1653,4 +1659,7 @@ oj_init_doc() {
     rb_define_method(oj_doc_class, "dump", doc_dump, -1);
     rb_define_method(oj_doc_class, "size", doc_size, 0);
     rb_define_method(oj_doc_class, "close", doc_close, 0);
+
+    rb_define_method(oj_doc_class, "clone", doc_not_implemented, 0);
+    rb_define_method(oj_doc_class, "dup", doc_not_implemented, 0);
 }

data/ext/oj/object.c

@@ -55,7 +55,7 @@ read_long(const char *str, size_t len) {
 
 static VALUE
 calc_hash_key(ParseInfo pi, Val kval, char k1) {
-    VALUE	rkey;
+    volatile VALUE	rkey;
 
     if (':' == k1) {
 	rkey = rb_str_new(kval->key + 1, kval->klen - 1);
@@ -388,8 +388,8 @@ hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, volatile VALUE
 	int	len = (int)RARRAY_LEN(value);
 
 	if (2 == klen && 'u' == key[1]) {
-            VALUE	sc;
-	    VALUE	e1;
+            volatile VALUE	sc;
+	    volatile VALUE	e1;
 
 	    if (0 == len) {
 		oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
@@ -398,9 +398,9 @@ hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, volatile VALUE
 	    e1 = *RARRAY_PTR(value);
 	    // check for anonymous Struct
 	    if (T_ARRAY == rb_type(e1)) {
-		VALUE	args[1024];
-		VALUE	rstr;
-		int	i, cnt = (int)RARRAY_LEN(e1);
+		VALUE		args[1024];
+		volatile VALUE	rstr;
+		int		i, cnt = (int)RARRAY_LEN(e1);
 
 		for (i = 0; i < cnt; i++) {
 		    rstr = rb_ary_entry(e1, i);
@@ -480,8 +480,8 @@ set_obj_ivar(Val parent, Val kval, VALUE value) {
 
     if ('~' == *key && Qtrue == rb_obj_is_kind_of(parent->val, rb_eException)) {
 	if (5 == klen && 0 == strncmp("~mesg", key, klen)) {
-	    VALUE	args[1];
-	    VALUE	prev = parent->val;
+	    VALUE		args[1];
+	    volatile VALUE	prev = parent->val;
 
 	    args[0] = value;
 	    parent->val = rb_class_new_instance(1, args, rb_class_of(parent->val));
@@ -652,8 +652,8 @@ hash_set_value(ParseInfo pi, Val kval, VALUE value) {
 	    }
 	} else {
 	    if (3 <= klen && '^' == *key && '#' == key[1] && T_ARRAY == rb_type(value)) {
-		long	len = RARRAY_LEN(value);
-		VALUE	*a = RARRAY_PTR(value);
+		long		len = RARRAY_LEN(value);
+		volatile VALUE	*a = RARRAY_PTR(value);
 	
 		if (2 != len) {
 		    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hash pair");
@@ -676,6 +676,7 @@ hash_set_value(ParseInfo pi, Val kval, VALUE value) {
     case T_OBJECT:
 	set_obj_ivar(parent, kval, value);
 	break;
+    case T_MODULE:
     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)));

data/ext/oj/odd.c

@@ -53,6 +53,8 @@ set_class(Odd odd, const char *classname) {
     odd->clas = rb_const_get(rb_cObject, rb_intern(classname));
     odd->create_obj = odd->clas;
     odd->create_op = rb_intern("new");
+    odd->is_module = (T_MODULE == rb_type(odd->clas));
+    odd->raw = 0;
     for (np = odd->attr_names, idp = odd->attrs; 0 != *np; np++, idp++) {
 	*idp = rb_intern(*np);
     }
@@ -139,14 +141,24 @@ oj_odd_init() {
 
 Odd
 oj_get_odd(VALUE clas) {
-    Odd	odd;
+    Odd		odd;
+    const char	*classname = NULL;
 
     for (odd = odds + odd_cnt - 1; odds <= odd; odd--) {
 	if (clas == odd->clas) {
 	    return odd;
 	}
+	if (odd->is_module) {
+	    if (NULL == classname) {
+		classname = rb_class2name(clas);
+	    }
+	    if (0 == strncmp(odd->classname, classname, odd->clen) &&
+		':' == classname[odd->clen]) {
+		return odd;
+	    }
+	}
     }
-    return 0;
+    return NULL;
 }
 
 Odd
@@ -157,6 +169,11 @@ oj_get_oddc(const char *classname, size_t len) {
 	if (len == odd->clen && 0 == strncmp(classname, odd->classname, len)) {
 	    return odd;
 	}
+	if (odd->is_module &&
+	    0 == strncmp(odd->classname, classname, odd->clen) &&
+	    ':' == classname[odd->clen]) {
+	    return odd;
+	}
     }
     return 0;
 }
@@ -195,7 +212,7 @@ oj_odd_set_arg(OddArgs args, const char *key, size_t klen, VALUE value) {
 }
 
 void
-oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt, VALUE *members) {
+oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt, VALUE *members, bool raw) {
     Odd		odd;
     const char	**np;
     ID		*ap;
@@ -215,6 +232,8 @@ oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt, VALUE
     odd->create_obj = create_object;
     odd->create_op = SYM2ID(create_method);
     odd->attr_cnt = mcnt;
+    odd->is_module = (T_MODULE == rb_type(clas));
+    odd->raw = raw;
     for (ap = odd->attrs, np = odd->attr_names, fp = odd->attrFuncs; 0 < mcnt; mcnt--, ap++, np++, members++, fp++) {
 	*fp = 0;
 	switch (rb_type(*members)) {

data/ext/oj/odd.h

@@ -31,6 +31,8 @@
 #ifndef __OJ_ODD_H__
 #define __OJ_ODD_H__
 
+#include <stdbool.h>
+
 #include "ruby.h"
 
 #define MAX_ODD_ARGS	10
@@ -40,10 +42,12 @@ typedef VALUE	(*AttrGetFunc)(VALUE obj);
 typedef struct _Odd {
     const char	*classname;
     size_t	clen;
-    VALUE	clas;			// Ruby class
+    VALUE	clas;			// Ruby class or module
     VALUE	create_obj;
     ID		create_op;
     int		attr_cnt;
+    bool	is_module;
+    bool	raw;
     const char	*attr_names[MAX_ODD_ARGS];	// 0 terminated attr IDs
     ID		attrs[MAX_ODD_ARGS];	// 0 terminated attr IDs
     AttrGetFunc	attrFuncs[MAX_ODD_ARGS];
@@ -60,6 +64,6 @@ extern Odd	oj_get_oddc(const char *classname, size_t len);
 extern OddArgs	oj_odd_alloc_args(Odd odd);
 extern void	oj_odd_free(OddArgs args);
 extern int	oj_odd_set_arg(OddArgs args, const char *key, size_t klen, VALUE value);
-extern void	oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt, VALUE *members);
+extern void	oj_reg_odd(VALUE clas, VALUE create_object, VALUE create_method, int mcnt, VALUE *members, bool raw);
 
 #endif /* __OJ_ODD_H__ */

data/ext/oj/oj.c

@@ -963,7 +963,7 @@ to_stream(int argc, VALUE *argv, VALUE self) {
  * normal way. It is not intended as a hook for changing the output of all
  * classes as it is not optimized for large numbers of classes.
  *
- * @param [Class] clas Class to be made special
+ * @param [Class|Module] clas Class or Module to be made special
  * @param [Object] create_object object to call the create method on
  * @param [Symbol] create_method method on the clas that will create a new
  *                 instance of the clas when given all the member values in the
@@ -976,12 +976,59 @@ register_odd(int argc, VALUE *argv, VALUE self) {
     if (3 > argc) {
 	rb_raise(rb_eArgError, "incorrect number of arguments.");
     }
-    Check_Type(argv[0], T_CLASS);
+    switch (rb_type(*argv)) {
+    case T_CLASS:
+    case T_MODULE:
+	break;
+    default:
+	rb_raise(rb_eTypeError, "expected a class or module.");
+	break;
+    }
+    Check_Type(argv[2], T_SYMBOL);
+    if (MAX_ODD_ARGS < argc - 2) {
+	rb_raise(rb_eArgError, "too many members.");
+    }
+    oj_reg_odd(argv[0], argv[1], argv[2], argc - 3, argv + 3, false);
+
+    return Qnil;
+}
+
+/* call-seq: register_odd_raw(clas, create_object, create_method, dump_method)
+ *
+ * Registers a class as special and expect the output to be a string that can be
+ * included in the dumped JSON directly. This is useful for working around
+ * subclasses of primitive types as is done with ActiveSupport classes. The use
+ * of this function should be limited to just classes that can not be handled in
+ * the normal way. It is not intended as a hook for changing the output of all
+ * classes as it is not optimized for large numbers of classes. Be careful with
+ * this option as the JSON may be incorrect if invalid JSON is returned.
+ *
+ * @param [Class|Module] clas Class or Module to be made special
+ * @param [Object] create_object object to call the create method on
+ * @param [Symbol] create_method method on the clas that will create a new
+ *                 instance of the clas when given all the member values in the
+ *                 order specified.
+ * @param [Symbol|String] dump_method method to call on the object being
+ *                        serialized to generate the raw JSON.
+ */
+static VALUE
+register_odd_raw(int argc, VALUE *argv, VALUE self) {
+    if (3 > argc) {
+	rb_raise(rb_eArgError, "incorrect number of arguments.");
+    }
+    switch (rb_type(*argv)) {
+    case T_CLASS:
+    case T_MODULE:
+	break;
+    default:
+	rb_raise(rb_eTypeError, "expected a class or module.");
+	break;
+    }
     Check_Type(argv[2], T_SYMBOL);
     if (MAX_ODD_ARGS < argc - 2) {
 	rb_raise(rb_eArgError, "too many members.");
     }
-    oj_reg_odd(argv[0], argv[1], argv[2], argc - 3, argv + 3);
+    oj_reg_odd(argv[0], argv[1], argv[2], 1, argv + 3, true);
 
     return Qnil;
 }
@@ -2032,6 +2079,7 @@ void Init_oj() {
     rb_define_module_function(Oj, "to_file", to_file, -1);
     rb_define_module_function(Oj, "to_stream", to_stream, -1);
     rb_define_module_function(Oj, "register_odd", register_odd, -1);
+    rb_define_module_function(Oj, "register_odd_raw", register_odd_raw, -1);
 
     rb_define_module_function(Oj, "saj_parse", oj_saj_parse, -1);
     rb_define_module_function(Oj, "sc_parse", oj_sc_parse, -1);

data/ext/oj/parse.c

@@ -519,7 +519,7 @@ read_num(ParseInfo pi) {
 
 static void
 array_start(ParseInfo pi) {
-    VALUE	v = pi->start_array(pi);
+    volatile VALUE	v = pi->start_array(pi);
 
     stack_push(&pi->stack, v, NEXT_ARRAY_NEW);
 }
@@ -688,7 +688,7 @@ oj_parse2(ParseInfo pi) {
 
 VALUE
 oj_num_as_value(NumInfo ni) {
-    VALUE	rnum = Qnil;
+    volatile VALUE	rnum = Qnil;
 
     if (ni->infinity) {
 	if (ni->neg) {
@@ -781,7 +781,7 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json, size_t len, int yie
     char		*buf = 0;
     volatile VALUE	input;
     volatile VALUE	wrapped_stack;
-    VALUE		result = Qnil;
+    volatile VALUE	result = Qnil;
     int			line = 0;
     int			free_json = 0;
 

data/lib/oj/version.rb

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

data/test/test_object.rb

@@ -131,6 +131,46 @@ class ObjectJuice < Minitest::Test
     alias == eql?
   end
 
+  class Raw
+    attr_accessor :json
+
+    def initialize(j)
+      @json = j
+    end
+
+    def to_json(*a)
+      @json
+    end
+
+    def self.create(h)
+      h
+    end
+  end # Raw
+
+  module Ichi
+    module Ni
+      def self.direct(h)
+        h
+      end
+
+      module San
+        class Shi
+
+          attr_accessor :hash
+
+          def initialize(h)
+            @hash = h
+          end
+
+          def dump()
+            @hash
+          end
+
+        end # Shi
+      end # San
+    end # Ni
+  end # Ichi
+
   def setup
     @default_options = Oj.default_options
   end
@@ -661,6 +701,22 @@ class ObjectJuice < Minitest::Test
     dump_and_load(Date.new(2012, 6, 19), false)
   end
 
+  def test_odd_raw
+    Oj.register_odd_raw(Raw, Raw, :create, :to_json)
+    json = Oj.dump(Raw.new(%|{"a":1}|), :mode => :object)
+    assert_equal(%|{"^O":"ObjectJuice::Raw","to_json":{"a":1}}|, json)
+    h = Oj.load(json, :mode => :object)
+    assert_equal({'a' => 1}, h)
+  end
+
+  def test_odd_mod
+    Oj.register_odd(Ichi::Ni, Ichi::Ni, :direct, :dump)
+    json = Oj.dump(Ichi::Ni::San::Shi.new({'a' => 1}), :mode => :object)
+    assert_equal(%|{"^O":"ObjectJuice::Ichi::Ni::San::Shi","dump":{"a":1}}|, json)
+    h = Oj.load(json, :mode => :object)
+    assert_equal({'a' => 1}, h)
+  end
+
   def test_auto_string
     s = AutoStrung.new("Pete", true)
     dump_and_load(s, false)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 2.12.14
+  version: 2.13.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-14 00:00:00.000000000 Z
+date: 2015-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler