oj 2.7.3 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86fa5360a8dad0be6218e5b707229d1123242f5c
-  data.tar.gz: bd7112345eca19080d314ef865db6d377a81596a
+  metadata.gz: 44d745373ae1530f6a0ae6ec981b62c84eac8f2d
+  data.tar.gz: c5c3c1506daf7f2ea35185d67fe1d469ced94fda
 SHA512:
-  metadata.gz: ccc6d971d9a8f0be85cb7c67b523a981d756c73fb1a2d1bd499f61bb1120a6da5925d8723cca8c008e8e2b281be7e81c20574358fb20b8b53340fb88f74439bc
-  data.tar.gz: 172de575b67abc4012818a9e526be9661bd78e0817bb62db6c060692f3dfd19fd29f5d40240d3d45e9557085fa34ebf9de2a1d23fe43daacf781cb7665d0b4eb
+  metadata.gz: ef8a3aee09c48dce3f3a8565b1f4412c3703c3c9aad396f08573fc978631ea364dd58d2bd684960b29ec2dfd2b989ea3145f93a994c75b2c1eb0d8a9e5ed1620
+  data.tar.gz: 95429819075ae22192b957da153ea1768eab8e93441e74e988daa4f994d7723e6947d8d6d341f05a3253717c08a3e800d7bd4b770e39ffc702028faf57b96025

data/README.md

@@ -26,9 +26,12 @@ 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.7.3
+### Current Release 2.8.0
 
- - Fixed bug where load and dump of Structs in modules did not work correctly.
+ - Added support for registering special encoding and decoding rules for
+   specific classes. This the ActiveSupport subclass of the String class for
+   safe strings. For an example look at the `test_object.rb` file,
+   `test_odd_string` test.
 
 [Older release notes](http://www.ohler.com/dev/oj_misc/release_notes.html).
 

data/ext/oj/dump.c

@@ -70,7 +70,7 @@ static void	dump_raw(const char *str, size_t cnt, Out out);
 static void	dump_cstr(const char *str, size_t cnt, int is_sym, int escape1, Out out);
 static void	dump_hex(uint8_t c, Out out);
 static void	dump_str_comp(VALUE obj, Out out);
-static void	dump_str_obj(VALUE obj, Out out);
+static void	dump_str_obj(VALUE obj, int depth, Out out);
 static void	dump_sym_comp(VALUE obj, Out out);
 static void	dump_sym_obj(VALUE obj, Out out);
 static void	dump_class_comp(VALUE obj, Out out);
@@ -545,12 +545,19 @@ dump_str_comp(VALUE obj, Out out) {
 }
 
 static void
-dump_str_obj(VALUE obj, Out out) {
-    const char	*s = rb_string_value_ptr((VALUE*)&obj);
-    size_t	len = RSTRING_LEN(obj);
-    char	s1 = s[1];
+dump_str_obj(VALUE obj, int depth, Out out) {
+    VALUE	clas = rb_obj_class(obj);
+    Odd		odd;
+    
+    if (rb_cString != clas && 0 != (odd = oj_get_odd(clas))) {
+	dump_odd(obj, odd, clas, depth + 1, out);
+    } else {
+	const char	*s = rb_string_value_ptr((VALUE*)&obj);
+	size_t		len = RSTRING_LEN(obj);
+	char		s1 = s[1];
 
-    dump_cstr(s, len, 0, (':' == *s || ('^' == *s && ('r' == s1 || 'i' == s1))), out);
+	dump_cstr(s, len, 0, (':' == *s || ('^' == *s && ('r' == s1 || 'i' == s1))), out);
+    }
 }
 
 static void
@@ -812,7 +819,7 @@ hash_cb_object(VALUE key, VALUE value, Out out) {
     }
     fill_indent(out, depth);
     if (rb_type(key) == T_STRING) {
-	dump_str_obj(key, out);
+	dump_str_obj(key, depth, out);
 	*out->cur++ = ':';
 	dump_val(value, depth, out);
     } else if (rb_type(key) == T_SYMBOL) {
@@ -1609,36 +1616,17 @@ raise_strict(VALUE obj) {
 
 static void
 dump_val(VALUE obj, int depth, Out out) {
+    int	type = rb_type(obj);
+
     if (MAX_DEPTH < depth) {
 	rb_raise(rb_eNoMemError, "Too deeply nested.\n");
     }
     switch (rb_type(obj)) {
-    case T_NIL:		dump_nil(out);			break;
-    case T_TRUE:	dump_true(out);			break;
-    case T_FALSE:	dump_false(out);		break;
-    case T_FIXNUM:	dump_fixnum(obj, out);		break;
-    case T_FLOAT:	dump_float(obj, out);		break;
-    case T_BIGNUM:	dump_bignum(obj, out);		break;
-    case T_STRING:
-	switch (out->opts->mode) {
-	case StrictMode:
-	case NullMode:
-	case CompatMode:	dump_str_comp(obj, out);	break;
-	case ObjectMode:
-	default:		dump_str_obj(obj, out);		break;
-	}
-	break;
-    case T_SYMBOL:
-	switch (out->opts->mode) {
-	case StrictMode:	raise_strict(obj);		break;
-	case NullMode:		dump_nil(out);			break;
-	case CompatMode:	dump_sym_comp(obj, out);	break;
-	case ObjectMode:
-	default:		dump_sym_obj(obj, out);		break;
-	}
-	break;
-    case T_ARRAY:	dump_array(obj, depth, out);		break;
-    case T_HASH:	dump_hash(obj, depth, out->opts->mode, out);	break;
+    case T_NIL:		dump_nil(out);				break;
+    case T_TRUE:	dump_true(out);				break;
+    case T_FALSE:	dump_false(out);			break;
+    case T_FIXNUM:	dump_fixnum(obj, out);			break;
+    case T_FLOAT:	dump_float(obj, out);			break;
     case T_CLASS:
 	switch (out->opts->mode) {
 	case StrictMode:	raise_strict(obj);		break;
@@ -1648,28 +1636,15 @@ dump_val(VALUE obj, int depth, Out out) {
 	default:		dump_class_obj(obj, out);	break;
 	}
 	break;
-#if (defined T_RATIONAL && defined RRATIONAL)
-    case T_RATIONAL:
-#endif
-    case T_OBJECT:
-	switch (out->opts->mode) {
-	case StrictMode:	dump_data_strict(obj, out);	break;
-	case NullMode:		dump_data_null(obj, out);	break;
-	case CompatMode:	dump_obj_comp(obj, depth, out);	break;
-	case ObjectMode:
-	default:		dump_obj_obj(obj, depth, out);	break;
-	}
-	break;
-    case T_DATA:
+    case T_SYMBOL:
 	switch (out->opts->mode) {
-	case StrictMode:	dump_data_strict(obj, out);	break;
-	case NullMode:		dump_data_null(obj, out);	break;
-	case CompatMode:	dump_data_comp(obj, depth, out);break;
+	case StrictMode:	raise_strict(obj);		break;
+	case NullMode:		dump_nil(out);			break;
+	case CompatMode:	dump_sym_comp(obj, out);	break;
 	case ObjectMode:
-	default:		dump_data_obj(obj, depth, out);	break;
+	default:		dump_sym_obj(obj, out);		break;
 	}
 	break;
-
     case T_STRUCT: // for Range
 	switch (out->opts->mode) {
 	case StrictMode:	raise_strict(obj);		break;
@@ -1679,23 +1654,70 @@ dump_val(VALUE obj, int depth, Out out) {
 	default:		dump_struct_obj(obj, depth, out);	break;
 	}
 	break;
-
+    default:
+	// Most developers have enough sense not to subclass primitive types but
+	// since these classes could potentially be subclassed a check for odd
+	// classes is performed.
+	{
+	    VALUE	clas = rb_obj_class(obj);
+	    Odd		odd;
+
+	    if (ObjectMode == out->opts->mode && 0 != (odd = oj_get_odd(clas))) {
+		dump_odd(obj, odd, clas, depth + 1, out);
+		return;
+	    }
+	    switch (type) {
+	    case T_BIGNUM:		dump_bignum(obj, out);		break;
+	    case T_STRING:
+		switch (out->opts->mode) {
+		case StrictMode:
+		case NullMode:
+		case CompatMode:	dump_str_comp(obj, out);	break;
+		case ObjectMode:
+		default:		dump_str_obj(obj, depth, out);	break;
+		}
+		break;
+	    case T_ARRAY:		dump_array(obj, depth, out);	break;
+	    case T_HASH:		dump_hash(obj, depth, out->opts->mode, out);	break;
+#if (defined T_RATIONAL && defined RRATIONAL)
+	    case T_RATIONAL:
+#endif
+	    case T_OBJECT:
+		switch (out->opts->mode) {
+		case StrictMode:	dump_data_strict(obj, out);	break;
+		case NullMode:		dump_data_null(obj, out);	break;
+		case CompatMode:	dump_obj_comp(obj, depth, out);	break;
+		case ObjectMode:
+		default:		dump_obj_obj(obj, depth, out);	break;
+		}
+		break;
+	    case T_DATA:
+		switch (out->opts->mode) {
+		case StrictMode:	dump_data_strict(obj, out);	break;
+		case NullMode:		dump_data_null(obj, out);	break;
+		case CompatMode:	dump_data_comp(obj, depth, out);break;
+		case ObjectMode:
+		default:		dump_data_obj(obj, depth, out);	break;
+		}
+		break;
 #if (defined T_COMPLEX && defined RCOMPLEX)
-    case T_COMPLEX:
+	    case T_COMPLEX:
 #endif
-    case T_REGEXP:
-	switch (out->opts->mode) {
-	case StrictMode:	raise_strict(obj);		break;
-	case NullMode:		dump_nil(out);			break;
-	case CompatMode:
-	case ObjectMode:
-	default:		dump_obj_comp(obj, depth, out);	break;
+	    case T_REGEXP:
+		switch (out->opts->mode) {
+		case StrictMode:	raise_strict(obj);		break;
+		case NullMode:		dump_nil(out);			break;
+		case CompatMode:
+		case ObjectMode:
+		default:		dump_obj_comp(obj, depth, out);	break;
+		}
+		break;
+	    default:
+		rb_raise(rb_eNotImpError, "Failed to dump '%s' Object (%02x)\n",
+			 rb_class2name(rb_obj_class(obj)), rb_type(obj));
+		break;
+	    }
 	}
-	break;
-    default:
-	rb_raise(rb_eNotImpError, "Failed to dump '%s' Object (%02x)\n",
-		 rb_class2name(rb_obj_class(obj)), rb_type(obj));
-	break;
     }
 }
 

data/ext/oj/odd.c

@@ -28,9 +28,13 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include <string.h>
+
 #include "odd.h"
 
-struct _Odd	odds[5]; // bump up if new Odd classes are added
+static struct _Odd	_odds[4]; // bump up if new initial Odd classes are added
+static struct _Odd	*odds = _odds;
+static int		odd_cnt = 0;
 
 static void
 set_class(Odd odd, const char *classname) {
@@ -96,16 +100,15 @@ oj_odd_init() {
     *np++ = 0;
     set_class(odd, "Range");
     odd->attr_cnt = 3;
-    // The end. bump up the size of odds if a new class is added.
-    odd++;
-    odd->clas = Qundef;
+
+    odd_cnt = odd - odds + 1;
 }
 
 Odd
 oj_get_odd(VALUE clas) {
-    Odd	odd = odds;
+    Odd	odd;
 
-    for (; Qundef != odd->clas; odd++) {
+    for (odd = odds + odd_cnt - 1; odds <= odd; odd--) {
 	if (clas == odd->clas) {
 	    return odd;
 	}
@@ -115,9 +118,9 @@ oj_get_odd(VALUE clas) {
 
 Odd
 oj_get_oddc(const char *classname, size_t len) {
-    Odd	odd = odds;
+    Odd	odd;
 
-    for (; Qundef != odd->clas; odd++) {
+    for (odd = odds + odd_cnt - 1; odds <= odd; odd--) {
 	if (len == odd->clen && 0 == strncmp(classname, odd->classname, len)) {
 	    return odd;
 	}
@@ -157,3 +160,42 @@ oj_odd_set_arg(OddArgs args, const char *key, size_t klen, VALUE value) {
     }
     return -1;
 }
+
+void
+oj_reg_odd(VALUE clas, VALUE create_method, int mcnt, VALUE *members) {
+    Odd		odd;
+    const char	**np;
+    ID		*ap;
+
+    if (_odds == odds) {
+	odds = ALLOC_N(struct _Odd, odd_cnt + 1);
+
+	memcpy(odds, _odds, sizeof(struct _Odd) * odd_cnt);
+    } else {
+	REALLOC_N(odds, struct _Odd, odd_cnt + 1);
+    }
+    odd = odds + odd_cnt;
+    odd->clas = clas;
+    odd->classname = strdup(rb_class2name(clas));
+    odd->clen = strlen(odd->classname);
+    odd->create_obj = clas;
+    odd->create_op = SYM2ID(create_method);
+    odd->attr_cnt = mcnt;
+    for (ap = odd->attrs, np = odd->attr_names; 0 < mcnt; mcnt--, ap++, np++, members++) {
+	switch (rb_type(*members)) {
+	case T_STRING:
+	    *np = strdup(rb_string_value_ptr(members));
+	    break;
+	case T_SYMBOL:
+	    *np = rb_id2name(SYM2ID(*members));
+	    break;
+	default:
+	    rb_raise(rb_eArgError, "registered member identifiers must be Strings or Symbols.");
+	    break;
+	}
+	*ap = rb_intern(*np);
+    }
+    *np = 0;
+    *ap = 0;
+    odd_cnt++;
+}

data/ext/oj/odd.h

@@ -57,5 +57,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_method, int mcnt, VALUE *members);
 
 #endif /* __OJ_ODD_H__ */

data/ext/oj/oj.c

@@ -841,6 +841,36 @@ to_stream(int argc, VALUE *argv, VALUE self) {
     return Qnil;
 }
 
+/* call-seq: register_odd(clas, create_method, *members)
+ *
+ * Registers a class as special. 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.
+ *
+ * @param [Class] clas Class to me made special
+ * @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] members methods used to get the member values from
+ *                        instances of the clas
+ */
+static VALUE
+register_odd(int argc, VALUE *argv, VALUE self) {
+    if (2 > argc) {
+	rb_raise(rb_eArgError, "incorrect number of arguments.");
+    }
+    Check_Type(argv[0], T_CLASS);
+    Check_Type(argv[1], T_SYMBOL);
+    if (MAX_ODD_ARGS < argc - 1) {
+	rb_raise(rb_eArgError, "too many members.");
+    }
+    oj_reg_odd(argv[0], argv[1], argc - 2, argv + 2);
+
+    return Qnil;
+}
+
 static void
 str_writer_free(void *ptr) {
     StrWriter	sw;
@@ -1804,6 +1834,7 @@ void Init_oj() {
     rb_define_module_function(Oj, "dump", dump, -1);
     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, "saj_parse", oj_saj_parse, -1);
     rb_define_module_function(Oj, "sc_parse", oj_sc_parse, -1);

data/lib/oj/version.rb

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

data/test/a.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby -wW1
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'pp'
+require 'oj'
+require 'perf'
+
+obj = [[1],[2],[3],[4],[5],[6],[7],[8],[9]]
+obj = [[],[],[],[],[],[],[],[],[]]
+obj = {
+  'a' => 'Alpha', # string
+  'b' => true,    # boolean
+  'c' => 12345,   # number
+  'd' => [ true, [false, [12345, nil], 3.967, ['something', false], nil]], # mix it up array
+  'e' => { 'one' => 1, 'two' => 2 }, # hash
+  'f' => nil,     # nil
+  'g' => 12345678901234567890123456789, # big number
+  'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
+  'i' => [[[[[[[nil]]]]]]]  # deep array, again, not that deep
+}
+
+json = Oj.dump(obj, mode: :compat)
+
+puts json
+#pp Oj.saj_parse(nil, json)
+pp Oj.t_parse(json)
+
+if true
+  perf = Perf.new()
+  perf.add('SAJ', 'oj') { Oj.saj_parse(nil, json) }
+  perf.add('T', 'oj') { Oj.t_parse(json) }
+  perf.add('load', 'oj') { Oj.load(json) }
+  perf.run(10000)
+end

data/test/bug.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
+# required. That can be set in the RUBYOPT environment variable.
+# export RUBYOPT=-w
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'oj'
+
+obj = Oj.load_file('bug.json', :mode => :object)
+
+puts Oj.dump(obj, :mode => :object, :indent => 0)

data/test/e.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'oj'
+
+json = %{"\xc2\xa9\xc3\x98"}
+puts "original:\n#{json}"
+
+str = Oj.load(json)
+puts "out: #{str}"

data/test/foo.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
+# required. That can be set in the RUBYOPT environment variable.
+# export RUBYOPT=-w
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'oj'
+
+reltypes={}
+Oj::Doc.open_file('foo.json') do |doc|
+  doc.each_child do |target|
+    puts "#{target.local_key} is #{target.local_key.class}"
+    target.each_leaf do |score|
+      reltype=score.local_key
+      reltypes[reltype] = (reltypes[reltype] || 0) + 1
+    end
+  end
+end

data/test/lots.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
+# required. That can be set in the RUBYOPT environment variable.
+# export RUBYOPT=-w
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'oj'
+
+module One
+  module Two
+    module Three
+      class Empty
+
+        def initialize()
+        end
+
+        def eql?(o)
+          self.class == o.class
+        end
+        alias == eql?
+
+        def to_hash()
+          {'json_class' => "#{self.class.name}"}
+        end
+
+        def to_json(*a)
+          %{{"json_class":"#{self.class.name}"}}
+        end
+
+        def self.json_create(h)
+          self.new()
+        end
+      end # Empty
+    end # Three
+  end # Two
+end # One
+
+$obj = {
+  'a' => 'Alpha', # string
+  'b' => true,    # boolean
+  'c' => 12345,   # number
+  'd' => [ true, [false, [-123456789, nil], 3.9676, ['Something else.', false], nil]], # mix it up array
+  'e' => { 'zero' => nil, 'one' => 1, 'two' => 2, 'three' => [3], 'four' => [0, 1, 2, 3, 4] }, # hash
+  'f' => nil,     # nil
+  'g' => One::Two::Three::Empty.new(),
+  'h' => { 'a' => { 'b' => { 'c' => { 'd' => {'e' => { 'f' => { 'g' => nil }}}}}}}, # deep hash, not that deep
+  'i' => [[[[[[[nil]]]]]]]  # deep array, again, not that deep
+}
+
+$obj = [$obj]*10000
+
+Oj.default_options = { :indent => 2, :mode => :compat }
+
+$json = Oj.dump($obj, :mode => :compat)
+
+$result = nil
+100.times { |i|
+  print(".") if (0 == i % 10)
+  $result = Oj.compat_load($json)
+}
+
+

data/test/mj.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+# $: << File.join(File.dirname(__FILE__), "../../multi_json/lib")
+
+require 'multi_json'
+require 'benchmark'
+require 'yajl'
+require 'json'
+require 'oj'
+
+iter = 1_000_000
+iter = 100_000
+
+json = %({"k1":"val1","k2":"val2","k3":"val3"})
+obj = { k1: "val1", k2: "val2", k3: "val3" }
+
+puts "Benchmarks for different JSON handlers with MultiJson."
+puts "  Ruby #{RUBY_VERSION}"
+puts "  #{iter} iterations"
+
+MultiJson.engine = :oj
+dt = Benchmark.realtime { iter.times { MultiJson.decode(json) }}
+et = Benchmark.realtime { iter.times { MultiJson.encode(obj) }}
+puts "    Oj decode: #{dt}  encode: #{et}"
+
+MultiJson.engine = :yajl
+dt = Benchmark.realtime { iter.times { MultiJson.decode(json) }}
+et = Benchmark.realtime { iter.times { MultiJson.encode(obj) }}
+puts "  Yajl decode: #{dt}  encode: #{et}"
+
+MultiJson.engine = :json_gem
+dt = Benchmark.realtime { iter.times { MultiJson.decode(json) }}
+et = Benchmark.realtime { iter.times { MultiJson.encode(obj) }}
+puts "  Json decode: #{dt}  encode: #{et}"
+
+Oj.default_options = { :mode => :compat, :time_format => :ruby }
+dt = Benchmark.realtime { iter.times { Oj.load(json) }}
+et = Benchmark.realtime { iter.times { Oj.dump(obj) }}
+puts "Raw Oj decode: #{dt}  encode: #{et}"
+
+ye = Yajl::Encoder.new
+dt = Benchmark.realtime { iter.times { Yajl::Parser.parse(json) }}
+et = Benchmark.realtime { iter.times { Yajl::Encoder.encode(obj) }}
+e2 = Benchmark.realtime { iter.times { ye.encode(obj) }}
+puts "Raw Yajl decode: #{dt} encode: #{et}, encoder: #{e2}"

data/test/struct.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
+# required. That can be set in the RUBYOPT environment variable.
+# export RUBYOPT=-w
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'oj'
+
+A = Struct.new(:a,:b,:c,:d)
+B = Struct.new(:e,:f)
+
+obj = [A.new(55, B.new(1, 'X'), B.new(2, 'Y'), 3)]
+
+s = Oj.dump(obj, :mode => :object)
+
+100000.times do
+  Oj.load(s, :mode => :object)
+  # ds = Oj.dump(o, :mode => :object)
+  # if ds != s
+  #   puts ds
+  #   raise "holy crap"
+  # end
+end

data/test/test_object.rb

@@ -77,6 +77,31 @@ end # One
 class Stuck < Struct.new(:a, :b)
 end
 
+class Strung < String
+
+  def initialize(str, safe)
+    super(str)
+    @safe = safe
+  end
+
+  def safe?()
+    @safe
+  end
+
+  def self.create(str, safe)
+    new(str, safe)
+  end
+
+  def eql?(o)
+    super && self.class == o.class && @safe == o.safe?
+  end
+  alias == eql?
+
+  def inspect()
+    return super + '(' + @safe + ')'
+  end
+end
+
 def hash_eql(h1, h2)
   return false if h1.size != h2.size
   h1.keys.each do |k|
@@ -390,6 +415,12 @@ class ObjectJuice < ::Test::Unit::TestCase
     dump_and_load(Date.new(2012, 6, 19), false)
   end
 
+  def test_odd_string
+    Oj.register_odd(Strung, :create, :to_s, 'safe?')
+    s = Strung.new("Pete", true)
+    dump_and_load(Strung.new("Pete", true), false)
+  end
+
   def dump_and_load(obj, trace=false)
     json = Oj.dump(obj, :indent => 2, :mode => :object)
     puts json if trace

data/test/x.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
+# required. That can be set in the RUBYOPT environment variable.
+# export RUBYOPT=-w
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+$: << File.join(File.dirname(__FILE__), "../ext")
+
+require 'oj'
+
+# Oj is not able to deserialize all classes that are a subclass of a Ruby
+# Exception. Only exception that take one required string argument in the
+# initialize() method are supported. This is an example of how to write an
+# Exception subclass that supports both a single string intializer and an
+# Exception as an argument. Additional optional arguments can be added as well.
+#
+# The reason for this restriction has to do with a design decision on the part
+# of the Ruby developers. Exceptions are special Objects. They do not follow the
+# rules of other Objects. Exceptions have 'mesg' and a 'bt' attribute. Note that
+# these are not '@mesg' and '@bt'. They can not be set using the normal C or
+# Ruby calls. The only way I have found to set the 'mesg' attribute is through
+# the initializer. Unfortunately that means any subclass that provides a
+# different initializer can not be automatically decoded. A way around this is
+# to use a create function but this example shows an alternative.
+
+class WrapException < StandardError
+  attr_reader :original
+
+  def initialize(msg_or_err)
+    if msg_or_err.is_a?(Exception)
+      super(msg_or_err.message)
+      @original = msg_or_err
+      set_backtrace(msg_or_err.backtrace)
+    else
+      super(message)
+      @original = nil
+    end
+  end
+end
+
+e = WrapException.new(RuntimeError.new("Something broke."))
+
+json = Oj.dump(e, :mode => :object)
+puts "original:\n#{json}"
+# outputs:
+# original:
+# {"^o":"WrapException","original":{"^o":"RuntimeError","~mesg":"Something broke.","~bt":null},"~mesg":"Something broke.","~bt":null}
+
+e2 = Oj.load(json, :mode => :object)
+puts "dumped, loaded, and dumped again:\n#{Oj.dump(e2, :mode => :object)}"
+# outputs:
+# original: {"^o":"WrapException","original":{"^o":"RuntimeError","~mesg":"Something broke.","~bt":null},"~mesg":"Something broke.","~bt":null}
+# dumped, loaded, and dumped again:
+# {"^o":"WrapException","original":{"^o":"RuntimeError","~mesg":"Something broke.","~bt":null},"~mesg":"Something broke.","~bt":null}
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 2.7.3
+  version: 2.8.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-11 00:00:00.000000000 Z
+date: 2014-04-20 00:00:00.000000000 Z
 dependencies: []
 description: 'The fastest JSON parser and object serializer. '
 email: peter@ohler.com
@@ -56,14 +56,17 @@ files:
 - lib/oj/saj.rb
 - lib/oj/schandler.rb
 - lib/oj/version.rb
+- test/a.rb
+- test/bug.rb
 - test/debian_test.rb
+- test/e.rb
 - test/files.rb
+- test/foo.rb
+- test/lots.rb
+- test/mj.rb
 - test/perf.rb
-- test/perf1.rb
-- test/perf2.rb
 - test/perf_compat.rb
 - test/perf_fast.rb
-- test/perf_obj_old.rb
 - test/perf_object.rb
 - test/perf_saj.rb
 - test/perf_scp.rb
@@ -83,6 +86,7 @@ files:
 - test/sample/shape.rb
 - test/sample/text.rb
 - test/sample_json.rb
+- test/struct.rb
 - test/test_compat.rb
 - test/test_fast.rb
 - test/test_gc.rb
@@ -94,6 +98,7 @@ files:
 - test/test_strict.rb
 - test/test_writer.rb
 - test/tests.rb
+- test/x.rb
 homepage: http://www.ohler.com/oj
 licenses:
 - MIT
@@ -123,3 +128,4 @@ signing_key:
 specification_version: 4
 summary: A fast JSON parser and serializer.
 test_files: []
+has_rdoc: true

data/test/perf1.rb

@@ -1,64 +0,0 @@
-#!/usr/bin/env ruby -wW1
-# encoding: UTF-8
-
-$: << File.join(File.dirname(__FILE__), "../lib")
-$: << File.join(File.dirname(__FILE__), "../ext")
-
-#require 'test/unit'
-require 'optparse'
-require 'oj'
-require 'ox'
-
-$indent = 2
-
-opts = OptionParser.new
-opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
-files = opts.parse(ARGV)
-
-iter = 100000
-s = %{
-{ "class": "Foo::Bar",
-  "attr1": [ true, [false, [12345, null], 3.967, ["something", false], null]],
-  "attr2": { "one": 1 }
-}
-}
-#s = File.read('sample.json')
-
-Oj.default_options = { :indent => 0 }
-
-obj = Oj.load(s)
-xml = Ox.dump(obj, :indent => 0)
-
-puts xml
-
-start = Time.now
-iter.times do
-  Oj.load(s)
-end
-dt = Time.now - start
-puts "%d Oj.load()s in %0.3f seconds or %0.1f loads/msec" % [iter, dt, iter/dt/1000.0]
-
-start = Time.now
-iter.times do
-  Ox.load(xml)
-end
-dt = Time.now - start
-puts "%d Ox.load()s in %0.3f seconds or %0.1f loads/msec" % [iter, dt, iter/dt/1000.0]
-
-puts
-
-start = Time.now
-iter.times do
-  Oj.dump(obj)
-end
-dt = Time.now - start
-puts "%d Oj.dump()s in %0.3f seconds or %0.1f dumps/msec" % [iter, dt, iter/dt/1000.0]
-
-start = Time.now
-iter.times do
-  Ox.dump(obj)
-end
-dt = Time.now - start
-puts "%d Ox.dump()s in %0.3f seconds or %0.1f dumps/msec" % [iter, dt, iter/dt/1000.0]
-
-puts

data/test/perf2.rb

@@ -1,76 +0,0 @@
-#!/usr/bin/env ruby -wW1
-# encoding: UTF-8
-
-$: << File.join(File.dirname(__FILE__), "../lib")
-$: << File.join(File.dirname(__FILE__), "../ext")
-
-#require 'test/unit'
-require 'optparse'
-require 'yajl'
-require 'oj'
-
-$indent = 2
-
-opts = OptionParser.new
-opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
-files = opts.parse(ARGV)
-
-class Foo
-  def initialize()
-    @x = true
-    @y = 58
-  end
-  def to_json()
-    %{{"x":#{@x},"y":#{@y}}}
-  end
-  def to_hash()
-    { 'x' => @x, 'y' => @y }
-  end
-end
-
-iter = 100000
-s = %{
-{ "class": "Foo::Bar",
-  "attr1": [ true, [false, [12345, null], 3.967, ["something", false], null]],
-  "attr2": { "one": 1 }
-}
-}
-
-obj = Oj.load(s)
-obj["foo"] = Foo.new()
-
-Oj.default_options = { :indent => 0, :effort => :internal }
-
-puts
-
-start = Time.now
-iter.times do
-  Oj.load(s)
-end
-dt = Time.now - start
-puts "%d Oj.load()s in %0.3f seconds or %0.1f loads/msec" % [iter, dt, iter/dt/1000.0]
-
-start = Time.now
-iter.times do
-  Yajl::Parser.parse(s)
-end
-dt = Time.now - start
-puts "%d Yajl::Parser.parse()s in %0.3f seconds or %0.1f parses/msec" % [iter, dt, iter/dt/1000.0]
-
-puts
-
-start = Time.now
-iter.times do
-  Oj.dump(obj)
-end
-dt = Time.now - start
-puts "%d Oj.dump()s in %0.3f seconds or %0.1f dumps/msec" % [iter, dt, iter/dt/1000.0]
-
-start = Time.now
-iter.times do
-  Yajl::Encoder.encode(obj)
-end
-dt = Time.now - start
-puts "%d Yajl::Encoder.encode()s in %0.3f seconds or %0.1f encodes/msec" % [iter, dt, iter/dt/1000.0]
-
-puts

data/test/perf_obj_old.rb

@@ -1,213 +0,0 @@
-#!/usr/bin/env ruby -wW1
-
-$: << '.'
-$: << '..'
-$: << '../lib'
-$: << '../ext'
-
-if __FILE__ == $0
-  if (i = ARGV.index('-I'))
-    x,path = ARGV.slice!(i, 2)
-    $: << path
-  end
-end
-
-require 'optparse'
-require 'ox'
-require 'oj'
-require 'perf'
-require 'sample'
-require 'files'
-
-$verbose = 0
-$circular = false
-$indent = 0
-
-do_sample = false
-do_files = false
-
-do_load = false
-do_dump = false
-do_read = false
-do_write = false
-$iter = 1000
-
-opts = OptionParser.new
-opts.on("-v", "increase verbosity")                         { $verbose += 1 }
-
-opts.on("-c", "circular options")                           { $circular = true }
-
-opts.on("-s", "load and dump as sample Ruby object")        { do_sample = true }
-opts.on("-f", "load and dump as files Ruby object")         { do_files = true }
-
-opts.on("-l", "load")                                       { do_load = true }
-opts.on("-d", "dump")                                       { do_dump = true }
-opts.on("-r", "read")                                       { do_read = true }
-opts.on("-w", "write")                                      { do_write = true }
-opts.on("-a", "load, dump, read and write")                 { do_load = true; do_dump = true; do_read = true; do_write = true }
-
-opts.on("-i", "--iterations [Int]", Integer, "iterations")  { |i| $iter = i }
-
-opts.on("-h", "--help", "Show this display")                { puts opts; Process.exit!(0) }
-files = opts.parse(ARGV)
-
-if files.empty?
-  data = []
-  obj = do_sample ? sample_doc(2) : files('..')
-  mars = Marshal.dump(obj)
-  xml = Ox.dump(obj, :indent => $indent, circular: $circular)
-  json = Oj.dump(obj, :indent => $indent, circular: $circular)
-  File.open('sample.xml', 'w') { |f| f.write(xml) }
-  File.open('sample.json', 'w') { |f| f.write(json) }
-  File.open('sample.marshal', 'w') { |f| f.write(mars) }
-  data << { :file => 'sample.xml', :obj => obj, :xml => xml, :marshal => mars, :json => json }
-else
-  puts "loading and parsing #{files}\n\n"
-  # TBD change to allow xml and json
-  data = files.map do |f|
-    xml = File.read(f)
-    obj = Ox.load(xml);
-    mars = Marshal.dump(obj)
-    json = Oj.dump(obj, :indent => $indent, circular: $circular)
-    { :file => f, :obj => obj, :xml => xml, :marshal => mars, :json => json }
-  end
-end
-
-$ox_load_time = 0
-$mars_load_time = 0
-$ox_dump_time = 0
-$oj_dump_time = 0
-$mars_dump_time = 0
-
-def perf_load(d)
-  filename = d[:file]
-  marshal_filename = 'sample.marshal'
-  xml = d[:xml]
-  mars = d[:marshal]
-  json = d[:json]
-
-  if 0 < $verbose
-    obj = Ox.load(xml, :mode => :object, :trace => $verbose)
-    return
-  end
-  start = Time.now
-  (1..$iter).each do
-    obj = Ox.load(xml, :mode => :object)
-  end
-  $ox_load_time = Time.now - start
-  puts "Parsing #{$iter} times with Ox took #{$ox_load_time} seconds."
-
-  start = Time.now
-  (1..$iter).each do
-    obj = Oj.load(json, :mode => :object)
-  end
-  $oj_load_time = Time.now - start
-  puts "Parsing #{$iter} times with Oj took #{$oj_load_time} seconds."
-  
-  start = Time.now
-  (1..$iter).each do
-    obj = Marshal.load(mars)
-  end
-  $mars_load_time = Time.now - start
-  puts "Marshalling #{$iter} times took #{$mars_load_time} seconds."
-  puts ">>> Ox is %0.1f faster than Marshal loading.\n\n" % [$mars_load_time/$ox_load_time]
-end
-
-def perf_dump(d)
-  obj = d[:obj]
-
-  start = Time.now
-  (1..$iter).each do
-    xml = Ox.dump(obj, :indent => $indent, :circular => $circular)
-    #puts "*** ox:\n#{xml}"
-  end
-  $ox_dump_time = Time.now - start
-  puts "Ox dumping #{$iter} times with ox took #{$ox_dump_time} seconds."
-
-  Oj.default_options = {:indent => $indent}
-  start = Time.now
-  (1..$iter).each do
-    json = Oj.dump(obj)
-  end
-  $oj_dump_time = Time.now - start
-  puts "Oj dumping #{$iter} times with oj took #{$oj_dump_time} seconds."
-
-  obj = d[:obj]
-  start = Time.now
-  (1..$iter).each do
-    m = Marshal.dump(obj)
-  end
-  $mars_dump_time = Time.now - start
-  puts "Marshal dumping #{$iter} times took #{$mars_dump_time} seconds."
-  puts ">>> Ox is %0.1f faster than Marshal dumping.\n\n" % [$mars_dump_time/$ox_dump_time]
-end
-
-def perf_read(d)
-  ox_read_time = 0
-  mars_read_time = 0
-
-  filename = d[:file]
-  marshal_filename = 'sample.marshal'
-  xml = d[:xml]
-  mars = d[:marshal]
-
-  # now load from the file
-  start = Time.now
-  (1..$iter).each do
-    obj = Ox.load_file(filename, :mode => :object)
-  end
-  ox_read_time = Time.now - start
-  puts "Loading and parsing #{$iter} times with ox took #{ox_read_time} seconds."
-
-  start = Time.now
-  (1..$iter).each do
-    m = File.read(marshal_filename)
-    obj = Marshal.load(m)
-  end
-  mars_read_time = Time.now - start
-  puts "Reading and marshalling #{$iter} times took #{mars_read_time} seconds."
-  puts ">>> Ox is %0.1f faster than Marshal loading and parsing.\n\n" % [mars_read_time/ox_read_time]
-
-end
-
-def perf_write(d)
-  ox_write_time = 0
-  mars_write_time = 0
-  
-  ox_filename = 'out.xml'
-  marshal_filename = 'out.marshal'
-  obj = d[:obj]
-
-  start = Time.now
-  (1..$iter).each do
-    xml = Ox.to_file(ox_filename, obj, :indent => $indent)
-  end
-  ox_write_time = Time.now - start
-  puts "Ox dumping #{$iter} times with ox took #{ox_write_time} seconds."
-
-  start = Time.now
-  (1..$iter).each do
-    m = Marshal.dump(obj, circular: $circular)
-    File.open(marshal_filename, "w") { |f| f.write(m) }
-  end
-  mars_write_time = Time.now - start
-  puts "Marshal dumping and writing #{$iter} times took #{mars_write_time} seconds."
-  puts ">>> Ox is %0.1f faster than Marshal dumping.\n\n" % [mars_write_time/ox_write_time]
-
-end
-
-#if do_sample or do_files
-  data.each do |d|
-    puts "Using file #{d[:file]}."
-    
-    perf_load(d) if do_load
-    perf_dump(d) if do_dump
-    if do_load and do_dump
-      puts ">>> Ox is %0.1f faster than Marshal dumping and loading.\n\n" % [($mars_load_time + $mars_dump_time)/($ox_load_time + $ox_dump_time)] unless 0 == $mars_load_time
-    end
-
-    perf_read(d) if do_read
-    perf_write(d) if do_write
-
-  end
-#end