oj 2.2.2 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 01dd99731dba1d9feeffe3135e41b282718c6342
-  data.tar.gz: 0c635bcad7be8c0a8b86a074dc2cc42946a4938a
+  metadata.gz: bf666d35187060e360daf53c2d0bedd178d3c686
+  data.tar.gz: 3e855525649cf4cec80eaa2e49b1d895f2db9eee
 SHA512:
-  metadata.gz: 9cabf96957642d870530a33ed6b4236505d6e67e06d6cddbb7f2b29e2dcc567a12b844a5fe7abe317bb0f3a65cccadf81240c8af23aa4ff7c45363c744bfc045
-  data.tar.gz: 2e2b979fbe2a517b04bca9eb3144b9c3edfeccfd33a3849b4d175a882036b3dff2631de3c888fa608fdbc13a1f3e3b97cbd71fef3f5b87d3ac27074d70606109
+  metadata.gz: 7b6c183e662e435f8eaf00079f8caa2e306d20f8fbfafcd30b7d86e8e5f715d8fe3ebf6ceaadc4e217ce140df7b572807cb5a980af22836b76a8cd971a540440
+  data.tar.gz: fa4fe7655132ab085ce93ca6604dcfba71cfa925480c279db93dc2baf2ede9fe5d8592c101af7045587656d6e418d2ee7e7049ef49ef681a066e95a80ed9f372

data/README.md

@@ -20,6 +20,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.2.3
+
+ - Fixed struct segfault on load.
+
+ - Added option to force float on load if a decimal number.
+
 ### Current Release 2.2.2
 
  - Added mutex support for Windows.

data/ext/oj/object.c

@@ -181,50 +181,35 @@ hat_num(ParseInfo pi, Val parent, const char *key, size_t klen, NumInfo ni) {
 
 static int
 hat_value(ParseInfo pi, Val parent, const char *key, size_t klen, volatile VALUE value) {
-    if (2 == klen && 'u' == key[1] && T_ARRAY == rb_type(value)) {
-#if HAS_RSTRUCT
-	long			len = RARRAY_LEN(value);
-	volatile VALUE		*a = RARRAY_PTR(value);
-	volatile VALUE		sc;
-	volatile VALUE		s;
-	volatile VALUE		*sv;
-
-	if (0 == len) {
-	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
-	    return 1;
-	}
-	sc = rb_const_get(oj_struct_class, rb_to_id(*a));
-	//sc = rb_const_get(oj_struct_class, rb_intern_str(*a));
-	// use encoding as the indicator for Ruby 1.8.7 or 1.9.x
-#if HAS_ENCODING_SUPPORT
-	s = rb_struct_alloc_noinit(sc);
-#else
-	s = rb_struct_new(sc, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil);
-#endif
-	sv = RSTRUCT_PTR(s);
-	if (RSTRUCT_LEN(s) < len - 1) {
-	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Too many elements for Struct");
+    if (T_ARRAY == rb_type(value)) {
+	int	len = (int)RARRAY_LEN(value);
+
+	if (2 == klen && 'u' == key[1]) {
+	    volatile VALUE	sc;
+
+	    if (0 == len) {
+		oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
+		return 1;
+	    }
+	    // If struct is not defined of new is not supported on the class then
+	    // let this fail and raise an exception.
+	    sc = rb_const_get(oj_struct_class, rb_to_id(*RARRAY_PTR(value)));
+	    parent->val = rb_funcall2(sc, oj_new_id, len - 1, RARRAY_PTR(value) + 1);
+
 	    return 1;
-	}
-	for (a++; 0 < len; len--, a++, sv++) {
-	    *sv = *a;
-	}
-	parent->val = s;
-#else
-	oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Ruby structs not supported with this version of Ruby");
-#endif
-	return 1;
-    } else if (3 <= klen && '#' == key[1] && T_ARRAY == rb_type(value)) {
-	long		len = RARRAY_LEN(value);
-	volatile VALUE	*a = RARRAY_PTR(value);
+	} else if (3 <= klen && '#' == key[1]) {
+	    volatile VALUE	*a;
 	
-	if (2 != len) {
-	    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hash pair");
+	    if (2 != len) {
+		oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "invalid hash pair");
+		return 1;
+	    }
+	    parent->val = rb_hash_new();
+	    a = RARRAY_PTR(value);
+	    rb_hash_aset(parent->val, *a, a[1]);
+
 	    return 1;
 	}
-	parent->val = rb_hash_new();
-	rb_hash_aset(parent->val, *a, a[1]);
-	return 1;
     }
     return 0;
 }

data/ext/oj/oj.c

@@ -90,22 +90,24 @@ VALUE	oj_time_class;
 
 VALUE	oj_slash_string;
 
-static VALUE	ascii_sym;
 static VALUE	ascii_only_sym;
+static VALUE	ascii_sym;
 static VALUE	auto_define_sym;
+static VALUE	auto_sym;
 static VALUE	bigdecimal_as_decimal_sym;
 static VALUE	bigdecimal_load_sym;
+static VALUE	bigdecimal_sym;
 static VALUE	circular_sym;
 static VALUE	class_cache_sym;
 static VALUE	compat_sym;
 static VALUE	create_id_sym;
 static VALUE	escape_mode_sym;
+static VALUE	float_sym;
 static VALUE	indent_sym;
 static VALUE	json_sym;
 static VALUE	mode_sym;
 static VALUE	null_sym;
 static VALUE	object_sym;
-static VALUE	xss_safe_sym;
 static VALUE	ruby_sym;
 static VALUE	sec_prec_sym;
 static VALUE	strict_sym;
@@ -113,6 +115,7 @@ static VALUE	symbol_keys_sym;
 static VALUE	time_format_sym;
 static VALUE	unix_sym;
 static VALUE	xmlschema_sym;
+static VALUE	xss_safe_sym;
 
 static VALUE	array_nl_sym;
 static VALUE	create_additions_sym;
@@ -146,7 +149,7 @@ struct _Options	oj_default_options = {
     Yes,		// class_cache
     UnixTime,		// time_format
     Yes,		// bigdec_as_num
-    No,			// bigdec_load
+    AutoDec,		// bigdec_load
     json_class,		// create_id
     10,			// create_id_len
     9,			// sec_prec
@@ -167,7 +170,7 @@ static VALUE	define_mimic_json(int argc, VALUE *argv, VALUE self);
  * - mode: [:object|:strict|:compat|:null] load and dump modes to use for JSON
  * - time_format: [:unix|:xmlschema|:ruby] time format when dumping in :compat mode
  * - bigdecimal_as_decimal: [true|false|nil] dump BigDecimal as a decimal number or as a String
- * - bigdecimal_load: [true|false|nil] load decimals as BigDecimal instead of as a Float
+ * - bigdecimal_load: [:bigdecimal|:float|:auto] load decimals as BigDecimal instead of as a Float. :auto pick the most precise for the number of digits.
  * - create_id: [String|nil] create id for json compatible object encoding, default is 'json_create'
  * - second_precision: [Fixnum|nil] number of digits after the decimal when dumping the seconds portion of time
  * @return [Hash] all current option settings.
@@ -183,7 +186,6 @@ get_def_opts(VALUE self) {
     rb_hash_aset(opts, auto_define_sym, (Yes == oj_default_options.auto_define) ? Qtrue : ((No == oj_default_options.auto_define) ? Qfalse : Qnil));
     rb_hash_aset(opts, symbol_keys_sym, (Yes == oj_default_options.sym_key) ? Qtrue : ((No == oj_default_options.sym_key) ? Qfalse : Qnil));
     rb_hash_aset(opts, bigdecimal_as_decimal_sym, (Yes == oj_default_options.bigdec_as_num) ? Qtrue : ((No == oj_default_options.bigdec_as_num) ? Qfalse : Qnil));
-    rb_hash_aset(opts, bigdecimal_load_sym, (Yes == oj_default_options.bigdec_load) ? Qtrue : ((No == oj_default_options.bigdec_load) ? 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;
@@ -203,6 +205,12 @@ get_def_opts(VALUE self) {
     case UnixTime:
     default:		rb_hash_aset(opts, time_format_sym, unix_sym);		break;
     }
+    switch (oj_default_options.bigdec_load) {
+    case BigDec:	rb_hash_aset(opts, bigdecimal_load_sym, bigdecimal_sym);	break;
+    case FloatDec:	rb_hash_aset(opts, bigdecimal_load_sym, float_sym);	break;
+    case AutoDec:
+    default:		rb_hash_aset(opts, bigdecimal_load_sym, auto_sym);	break;
+    }
     rb_hash_aset(opts, create_id_sym, (0 == oj_default_options.create_id) ? Qnil : rb_str_new2(oj_default_options.create_id));
 
     return opts;
@@ -221,7 +229,7 @@ get_def_opts(VALUE self) {
  *        escaped sequences if :ascii, :json is standand UTF-8 JSON encoding,
  *        and :xss_safe escapes &, <, and >, and some others.
  * @param [true|false|nil] :bigdecimal_as_decimal dump BigDecimal as a decimal number or as a String
- * @param [true|false|nil] :bigdecimal_load load decimals as a BigDecimal instead of as a Float
+ * @param [:bigdecimal|:float|:auto|nil] :bigdecimal_load load decimals as BigDecimal instead of as a Float. :auto pick the most precise for the number of digits.
  * @param [:object|:strict|:compat|:null] load and dump mode to use for JSON
  *	  :strict raises an exception when a non-supported Object is
  *	  encountered. :compat attempts to extract variable values from an
@@ -246,7 +254,6 @@ set_def_opts(VALUE self, VALUE opts) {
 	{ symbol_keys_sym, &oj_default_options.sym_key },
 	{ class_cache_sym, &oj_default_options.class_cache },
 	{ bigdecimal_as_decimal_sym, &oj_default_options.bigdec_as_num },
-	{ bigdecimal_load_sym, &oj_default_options.bigdec_load },
 	{ Qnil, 0 }
     };
     YesNoOpt	o;
@@ -313,6 +320,19 @@ set_def_opts(VALUE self, VALUE opts) {
 	rb_raise(rb_eArgError, ":encoding must be :json, :rails, or :ascii.");
     }
 
+    v = rb_hash_lookup(opts, bigdecimal_load_sym);
+    if (Qnil == v) {
+	// ignore
+    } else if (bigdecimal_sym == v || Qtrue == v) {
+	oj_default_options.bigdec_load = BigDec;
+    } else if (float_sym == v) {
+	oj_default_options.bigdec_load = FloatDec;
+    } else if (auto_sym == v || Qfalse == v) {
+	oj_default_options.bigdec_load = AutoDec;
+    } else {
+	rb_raise(rb_eArgError, ":bigdecimal_load must be :bigdecimal, :float, or :auto.");
+    }
+
     if (Qtrue == rb_funcall(opts, rb_intern("has_key?"), 1, create_id_sym)) {
 	if (0 != oj_default_options.create_id) {
 	    if (json_class != oj_default_options.create_id) {
@@ -363,7 +383,6 @@ oj_parse_options(VALUE ropts, Options copts) {
 	{ symbol_keys_sym, &copts->sym_key },
 	{ class_cache_sym, &copts->class_cache },
 	{ bigdecimal_as_decimal_sym, &copts->bigdec_as_num },
-	{ bigdecimal_load_sym, &copts->bigdec_load },
 	{ Qnil, 0 }
     };
     YesNoOpt	o;
@@ -428,6 +447,18 @@ oj_parse_options(VALUE ropts, Options copts) {
 	    }
 	}
 
+	if (Qnil != (v = rb_hash_lookup(ropts, bigdecimal_load_sym))) {
+	    if (bigdecimal_sym == v || Qtrue == v) {
+		copts->bigdec_load = BigDec;
+	    } else if (float_sym == v) {
+		copts->bigdec_load = FloatDec;
+	    } else if (auto_sym == v || Qfalse == v) {
+		copts->bigdec_load = AutoDec;
+	    } else {
+		rb_raise(rb_eArgError, ":bigdecimal_load must be :bigdecimal, :float, or :auto.");
+	    }
+	}
+
 	if (Qtrue == rb_funcall(ropts, rb_intern("has_key?"), 1, create_id_sym)) {
 	    v = rb_hash_lookup(ropts, create_id_sym);
 	    if (Qnil == v) {
@@ -1240,22 +1271,24 @@ void Init_oj() {
     oj_struct_class = rb_const_get(rb_cObject, rb_intern("Struct"));
     oj_time_class = rb_const_get(rb_cObject, rb_intern("Time"));
 
-    ascii_sym = ID2SYM(rb_intern("ascii"));		rb_gc_register_address(&ascii_sym);
     ascii_only_sym = ID2SYM(rb_intern("ascii_only"));	rb_gc_register_address(&ascii_only_sym);
+    ascii_sym = ID2SYM(rb_intern("ascii"));		rb_gc_register_address(&ascii_sym);
     auto_define_sym = ID2SYM(rb_intern("auto_define"));	rb_gc_register_address(&auto_define_sym);
+    auto_sym = ID2SYM(rb_intern("auto"));		rb_gc_register_address(&auto_sym);
     bigdecimal_as_decimal_sym = ID2SYM(rb_intern("bigdecimal_as_decimal"));rb_gc_register_address(&bigdecimal_as_decimal_sym);
     bigdecimal_load_sym = ID2SYM(rb_intern("bigdecimal_load"));rb_gc_register_address(&bigdecimal_load_sym);
+    bigdecimal_sym = ID2SYM(rb_intern("bigdecimal"));	rb_gc_register_address(&bigdecimal_sym);
     circular_sym = ID2SYM(rb_intern("circular"));	rb_gc_register_address(&circular_sym);
     class_cache_sym = ID2SYM(rb_intern("class_cache"));	rb_gc_register_address(&class_cache_sym);
     compat_sym = ID2SYM(rb_intern("compat"));		rb_gc_register_address(&compat_sym);
     create_id_sym = ID2SYM(rb_intern("create_id"));	rb_gc_register_address(&create_id_sym);
     escape_mode_sym = ID2SYM(rb_intern("escape_mode"));	rb_gc_register_address(&escape_mode_sym);
+    float_sym = ID2SYM(rb_intern("float"));		rb_gc_register_address(&float_sym);
     indent_sym = ID2SYM(rb_intern("indent"));		rb_gc_register_address(&indent_sym);
     json_sym = ID2SYM(rb_intern("json"));		rb_gc_register_address(&json_sym);
     mode_sym = ID2SYM(rb_intern("mode"));		rb_gc_register_address(&mode_sym);
     null_sym = ID2SYM(rb_intern("null"));		rb_gc_register_address(&null_sym);
     object_sym = ID2SYM(rb_intern("object"));		rb_gc_register_address(&object_sym);
-    xss_safe_sym = ID2SYM(rb_intern("xss_safe"));	rb_gc_register_address(&xss_safe_sym);
     ruby_sym = ID2SYM(rb_intern("ruby"));		rb_gc_register_address(&ruby_sym);
     sec_prec_sym = ID2SYM(rb_intern("second_precision"));rb_gc_register_address(&sec_prec_sym);
     strict_sym = ID2SYM(rb_intern("strict"));		rb_gc_register_address(&strict_sym);
@@ -1263,6 +1296,7 @@ void Init_oj() {
     time_format_sym = ID2SYM(rb_intern("time_format"));	rb_gc_register_address(&time_format_sym);
     unix_sym = ID2SYM(rb_intern("unix"));		rb_gc_register_address(&unix_sym);
     xmlschema_sym = ID2SYM(rb_intern("xmlschema"));	rb_gc_register_address(&xmlschema_sym);
+    xss_safe_sym = ID2SYM(rb_intern("xss_safe"));	rb_gc_register_address(&xss_safe_sym);
 
     oj_slash_string = rb_str_new2("/");			rb_gc_register_address(&oj_slash_string);
 

data/ext/oj/oj.h

@@ -92,6 +92,12 @@ typedef enum {
     ASCIIEsc	= 'a'
 } Encoding;
 
+typedef enum {
+    BigDec	= 'b',
+    FloatDec	= 'f',
+    AutoDec	= 'a'
+} BigLoad;
+
 typedef struct _DumpOpts {
     const char	*indent;
     const char	*before_sep;
@@ -115,7 +121,7 @@ typedef struct _Options {
     char	class_cache;	// YesNo
     char	time_format;	// TimeFormat
     char	bigdec_as_num;	// YesNo
-    char	bigdec_load;	// YesNo
+    char	bigdec_load;	// BigLoad
     const char	*create_id;	// 0 or string
     size_t	create_id_len;	// length of create_id
     int		sec_prec;	// second precision when dumping time

data/ext/oj/parse.c

@@ -389,6 +389,7 @@ read_num(ParseInfo pi) {
     ni.infinity = 0;
     ni.nan = 0;
     ni.neg = 0;
+    ni.no_big = (FloatDec == pi->options.bigdec_load);
 
     if ('-' == *pi->cur) {
 	pi->cur++;
@@ -470,7 +471,7 @@ read_num(ParseInfo pi) {
 	ni.dec_cnt -= zero_cnt;
 	ni.len = pi->cur - ni.str;
     }
-    if (Yes == pi->options.bigdec_load) {
+    if (BigDec == pi->options.bigdec_load) {
 	ni.big = 1;
     }
     if (0 == parent) {
@@ -680,6 +681,9 @@ oj_num_as_value(NumInfo ni) {
     } else { // decimal
 	if (ni->big) {
 	    rnum = rb_funcall(oj_bigdecimal_class, oj_new_id, 1, rb_str_new(ni->str, ni->len));
+	    if (ni->no_big) {
+		rnum = rb_funcall(rnum, rb_intern("to_f"), 0);
+	    }
 	} else {
 	    double	d = (double)ni->i + (double)ni->num / (double)ni->div;
 

data/ext/oj/parse.h

@@ -50,6 +50,7 @@ typedef struct _NumInfo {
     int		infinity;
     int		nan;
     int		neg;
+    int		no_big;
 } *NumInfo;
 
 typedef struct _ParseInfo {

data/ext/oj/scp.c

@@ -281,7 +281,8 @@ oj_sc_parse(int argc, VALUE *argv, VALUE self) {
 #endif
 	} else if (rb_respond_to(input, oj_read_id)) {
 	    s = rb_funcall2(input, oj_read_id, 0, 0);
-	    pi.json = StringValuePtr(s);
+	    pi.json = rb_string_value_cstr((VALUE*)&s);
+
 	} else {
 	    rb_raise(rb_eArgError, "saj_parse() expected a String or IO Object.");
 	}

data/ext/oj/val_stack.c

@@ -36,8 +36,9 @@ mark(void *ptr) {
     ValStack	stack = (ValStack)ptr;
     Val		v;
 
-    if (ptr == NULL) return;
-
+    if (0 == ptr) {
+	return;
+    }
 #if USE_PTHREAD_MUTEX
     pthread_mutex_lock(&stack->mutex);
 #elif USE_RB_MUTEX

data/lib/oj/version.rb

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

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_scp.rb

@@ -217,7 +217,7 @@ class ScpTest < ::Test::Unit::TestCase
     begin
       Oj.sc_parse(handler, json)
     rescue Exception => e
-      assert_equal("unexpected character at line 1, column 6 [parse.c:636]", e.message)
+      assert_equal("unexpected character at line 1, column 6 [parse.c:637]", e.message)
     end
   end
 

data/test/tests.rb

@@ -133,7 +133,7 @@ class Juice < ::Test::Unit::TestCase
                    :mode=>:object,
                    :time_format=>:unix,
                    :bigdecimal_as_decimal=>true,
-                   :bigdecimal_load=>false,
+                   :bigdecimal_load=>:auto,
                    :create_id=>'json_class'}, opts)
   end
 
@@ -149,7 +149,7 @@ class Juice < ::Test::Unit::TestCase
       :mode=>:object,
       :time_format=>:unix,
       :bigdecimal_as_decimal=>true,
-      :bigdecimal_load=>false,
+      :bigdecimal_load=>:auto,
       :create_id=>'json_class'}
     o2 = {
       :indent=>4,
@@ -162,7 +162,7 @@ class Juice < ::Test::Unit::TestCase
       :mode=>:compat,
       :time_format=>:ruby,
       :bigdecimal_as_decimal=>false,
-      :bigdecimal_load=>true,
+      :bigdecimal_load=>:bigdecimal,
       :create_id=>nil}
     o3 = { :indent => 4 }
     Oj.default_options = o2
@@ -826,6 +826,13 @@ class Juice < ::Test::Unit::TestCase
     assert_equal(BigDecimal, bg.class)
     assert_equal(orig, bg)
   end
+  def test_float_load
+    orig = BigDecimal.new('80.51')
+    json = Oj.dump(orig, :mode => :compat, :bigdecimal_as_decimal => true)
+    bg = Oj.load(json, :mode => :compat, :bigdecimal_load => :float)
+    assert_equal(Float, bg.class)
+    assert_equal(orig.to_f, bg)
+  end
   def test_bigdecimal_compat_to_json
     orig = BigDecimal.new('80.51')
     BigDecimal.send(:define_method, :to_json) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.3
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-17 00:00:00.000000000 Z
+date: 2013-11-19 00:00:00.000000000 Z
 dependencies: []
 description: 'The fastest JSON parser and object serializer. '
 email: peter@ohler.com
@@ -83,6 +83,7 @@ files:
 - test/sample/text.rb
 - test/sample.rb
 - test/sample_json.rb
+- test/struct.rb
 - test/test_compat.rb
 - test/test_fast.rb
 - test/test_gc.rb