oj 2.2.3 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf666d35187060e360daf53c2d0bedd178d3c686
-  data.tar.gz: 3e855525649cf4cec80eaa2e49b1d895f2db9eee
+  metadata.gz: 0ac1090fe61f4056ff0fb5c838297e76f356fe8c
+  data.tar.gz: e75c5ddbce19b8846c1cac9f5dca6994194aa9e7
 SHA512:
-  metadata.gz: 7b6c183e662e435f8eaf00079f8caa2e306d20f8fbfafcd30b7d86e8e5f715d8fe3ebf6ceaadc4e217ce140df7b572807cb5a980af22836b76a8cd971a540440
-  data.tar.gz: fa4fe7655132ab085ce93ca6604dcfba71cfa925480c279db93dc2baf2ede9fe5d8592c101af7045587656d6e418d2ee7e7049ef49ef681a066e95a80ed9f372
+  metadata.gz: f509d7b7dfbd8b848a0ce4b388e962853e3db6b7e2c050639a559a837964f767e1e279b53ef3cd29c7a6ceb569ac10522f9f3726f892f7a0c13e586688a28540
+  data.tar.gz: f7bdb0ae179ac0e796625445447f1f0dbce85ff3b2d3af1181e16fea2128077112056c9e104b15a06e4d13b48ff630bec7fe675e316ea16500b4869edbf69287

data/README.md

@@ -20,31 +20,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.2.3
 
- - Fixed struct segfault on load.
+### Current Release 2.3.0
 
- - Added option to force float on load if a decimal number.
+ - JRuby is no longer supported.
 
-### Current Release 2.2.2
+ - Thanks to Stefan Kaes the support for structs has been optimized.
 
- - Added mutex support for Windows.
+ - Better support for Rubinous
 
- - Protected SCP parser for GC.
+ - Added option to disable GG during parsing.
 
-### Current Release 2.2.1
-
- - Made all VALUEs in parse volatile to avoid garbage collection while in use.
-
-### Current Release 2.2.0
-
- - All 1.8.x versions of Ruby now have require 'rational' called.
-
- - Removed the temporary GC disable and implemented mark strategy instead.
-
- - Added new character encoding mode to support the Rails 4 escape characters of &, <, and > as xss_safe mode. The :encoding option replaces the :ascii_only option.
-
- - Change parsing of NaN to not use math.h which on older systems does not define NAN.
+ - Added StringWriter that allows building a JSON document one element at a time.
 
 [Older release notes](http://www.ohler.com/dev/oj_misc/release_notes.html).
 
@@ -76,10 +63,9 @@ is the :object mode.
   preference over the to_json() method. If neither the to_json() or to_hash()
   methods exist then the Oj internal Object variable encoding is used.
 
-Oj is compatible with Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0, JRuby, and RBX. Note that JRuby now disables support
-for extentions by default and is no longer supporting C extensions. Bugs reported in the JRuby MRI are no longer being
-fixed and there is at least one that has caused a test to be commented out for JRuby in the Oj test suite. JRuby can be
-build with extensions enabled. Check the documenation for JRuby installs in your environment.
+Oj is compatible with Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0, and RBX. Support for
+JRuby has been removed as JRuby no longer supports C extensions and there are
+bugs in the older versions that are not being fixed.
 
 Oj is also compatible with Rails. Just make sure the Oj gem is installed and
 [multi_json](https://github.com/intridea/multi_json) will pick it up and use it.

data/ext/oj/dump.c

@@ -84,10 +84,8 @@ static void	dump_data_comp(VALUE obj, int depth, Out out);
 static void	dump_data_obj(VALUE obj, int depth, Out out);
 static void	dump_obj_comp(VALUE obj, int depth, Out out);
 static void	dump_obj_obj(VALUE obj, int depth, Out out);
-#if HAS_RSTRUCT
 static void	dump_struct_comp(VALUE obj, int depth, Out out);
 static void	dump_struct_obj(VALUE obj, int depth, Out out);
-#endif
 #if HAS_IVAR_HELPERS
 static int	dump_attr_cb(ID key, VALUE value, Out out);
 #endif
@@ -1484,7 +1482,6 @@ dump_obj_attrs(VALUE obj, VALUE clas, slot_t id, int depth, Out out) {
     *out->cur = '\0';
 }
 
-#if HAS_RSTRUCT
 static void
 dump_struct_comp(VALUE obj, int depth, Out out) {
     if (rb_respond_to(obj, oj_to_hash_id)) {
@@ -1515,13 +1512,12 @@ static void
 dump_struct_obj(VALUE obj, int depth, Out out) {
     VALUE	clas = rb_obj_class(obj);
     const char	*class_name = rb_class2name(clas);
-    VALUE	*vp;
     int		i;
     int		d2 = depth + 1;
     int		d3 = d2 + 1;
     size_t	len = strlen(class_name);
     size_t	size = d2 * out->indent + d3 * out->indent + 10 + len;
-	    
+
     if (out->end - out->cur <= (long)size) {
 	grow(out, size);
     }
@@ -1540,20 +1536,40 @@ dump_struct_obj(VALUE obj, int depth, Out out) {
     *out->cur++ = '"';
     *out->cur++ = ',';
     size = d3 * out->indent + 2;
-    for (i = (int)RSTRUCT_LEN(obj), vp = RSTRUCT_PTR(obj); 0 < i; i--, vp++) {
-	if (out->end - out->cur <= (long)size) {
-	    grow(out, size);
+#ifdef RSTRUCT_LEN
+    {
+	VALUE	*vp;
+
+	for (i = (int)RSTRUCT_LEN(obj), vp = RSTRUCT_PTR(obj); 0 < i; i--, vp++) {
+	    if (out->end - out->cur <= (long)size) {
+		grow(out, size);
+	    }
+	    fill_indent(out, d3);
+	    dump_val(*vp, d3, out);
+	    *out->cur++ = ',';
+	}
+    }
+#else
+    {
+	// This is a bit risky as a struct in C ruby is not the same as a Struct
+	// class in interpreted Ruby so length() may not be defined.
+	int	slen = FIX2INT(rb_funcall2(obj, oj_length_id, 0, 0));
+
+	for (i = 0; i < slen; i++) {
+	    if (out->end - out->cur <= (long)size) {
+		grow(out, size);
+	    }
+	    fill_indent(out, d3);
+	    dump_val(rb_struct_aref(obj, INT2FIX(i)), d3, out);
+	    *out->cur++ = ',';
 	}
-	fill_indent(out, d3);
-	dump_val(*vp, d3, out);
-	*out->cur++ = ',';
     }
+#endif
     out->cur--;
     *out->cur++ = ']';
     *out->cur++ = '}';
     *out->cur = '\0';
 }
-#endif
 
 static void
 dump_odd(VALUE obj, Odd odd, VALUE clas, int depth, Out out) {
@@ -1669,7 +1685,7 @@ dump_val(VALUE obj, int depth, Out out) {
 	default:		dump_data_obj(obj, depth, out);	break;
 	}
 	break;
-#if HAS_RSTRUCT
+
     case T_STRUCT: // for Range
 	switch (out->opts->mode) {
 	case StrictMode:	raise_strict(obj);		break;
@@ -1679,7 +1695,7 @@ dump_val(VALUE obj, int depth, Out out) {
 	default:		dump_struct_obj(obj, depth, out);	break;
 	}
 	break;
-#endif
+
 #if (defined T_COMPLEX && defined RCOMPLEX)
     case T_COMPLEX:
 #endif
@@ -2010,3 +2026,133 @@ oj_write_leaf_to_file(Leaf leaf, const char *path, Options copts) {
     }
     fclose(f);
 }
+
+// string writer functions
+
+static void
+key_check(StrWriter sw, const char *key) {
+    DumpType	type = sw->types[sw->depth];
+
+    if (0 == key && (ObjectNew == type || ObjectType == type)) {
+	rb_raise(rb_eStandardError, "Can not push onto an Object without a key.");
+    } else if (0 != key && (ArrayNew == type || ArrayType == type)) {
+	rb_raise(rb_eStandardError, "No key is needed to push into an array.");
+    }
+}
+
+static void
+push_type(StrWriter sw, DumpType type) {
+    if (sw->types_end <= sw->types + sw->depth + 1) {
+	size_t	size = (sw->types_end - sw->types) * 2;
+
+	REALLOC_N(sw->types, char, size);
+	sw->types_end = sw->types + size;
+    }
+    sw->depth++;
+    sw->types[sw->depth] = type;
+}
+
+static void
+maybe_comma(StrWriter sw) {
+    switch (sw->types[sw->depth]) {
+    case ObjectNew:
+	sw->types[sw->depth] = ObjectType;
+	break;
+    case ArrayNew:
+	sw->types[sw->depth] = ArrayType;
+	break;
+    case ObjectType:
+    case ArrayType:
+	// Always have a few characters available in the out.buf.
+	*sw->out.cur++ = ',';
+	break;
+    }
+}
+
+void
+oj_str_writer_push_object(StrWriter sw, const char *key) {
+    size_t	size;
+
+    key_check(sw, key);
+    size = sw->depth * sw->out.indent + 3;
+    if (sw->out.end - sw->out.cur <= size) {
+	grow(&sw->out, size);
+    }
+    maybe_comma(sw);
+    fill_indent(&sw->out, sw->depth);
+    if (0 != key) {
+	dump_cstr(key, strlen(key), 0, 0, &sw->out);
+	*sw->out.cur++ = ':';
+    }
+    *sw->out.cur++ = '{';
+    push_type(sw, ObjectNew);
+}
+
+void
+oj_str_writer_push_array(StrWriter sw, const char *key) {
+    size_t	size;
+
+    key_check(sw, key);
+    size = sw->depth * sw->out.indent + 3;
+    if (sw->out.end - sw->out.cur <= size) {
+	grow(&sw->out, size);
+    }
+    maybe_comma(sw);
+    if (0 != key) {
+	dump_cstr(key, strlen(key), 0, 0, &sw->out);
+	*sw->out.cur++ = ':';
+    }
+    *sw->out.cur++ = '[';
+    push_type(sw, ArrayNew);
+}
+
+void
+oj_str_writer_push_value(StrWriter sw, VALUE val, const char *key) {
+    size_t	size;
+
+    key_check(sw, key);
+    size = sw->depth * sw->out.indent + 3;
+    if (sw->out.end - sw->out.cur <= size) {
+	grow(&sw->out, size);
+    }
+    maybe_comma(sw);
+    if (0 != key) {
+	dump_cstr(key, strlen(key), 0, 0, &sw->out);
+	*sw->out.cur++ = ':';
+    }
+    dump_val(val, sw->depth, &sw->out);
+}
+
+void
+oj_str_writer_pop(StrWriter sw) {
+    size_t	size;
+    DumpType	type = sw->types[sw->depth];
+
+    sw->depth--;
+    if (0 > sw->depth) {
+	rb_raise(rb_eStandardError, "Can not pop with no open array or object.");
+    }
+    size = sw->depth * sw->out.indent + 2;
+    if (sw->out.end - sw->out.cur <= size) {
+	grow(&sw->out, size);
+    }
+    fill_indent(&sw->out, sw->depth);
+    switch (type) {
+    case ObjectNew:
+    case ObjectType:
+	*sw->out.cur++ = '}';
+	break;
+    case ArrayNew:
+    case ArrayType:
+	*sw->out.cur++ = ']';
+	break;
+    }
+}
+
+void
+oj_str_writer_pop_all(StrWriter sw) {
+    while (0 < sw->depth) {
+	oj_str_writer_pop(sw);
+    }
+}
+

data/ext/oj/extconf.rb

@@ -24,7 +24,6 @@ dflags = {
   'HAS_ENCODING_SUPPORT' => (('ruby' == type || 'rubinius' == type) &&
                              (('1' == version[0] && '9' == version[1]) || '2' <= version[0])) ? 1 : 0,
   'HAS_NANO_TIME' => ('ruby' == type && ('1' == version[0] && '9' == version[1]) || '2' <= version[0]) ? 1 : 0,
-  'HAS_RSTRUCT' => ('ruby' == type || 'ree' == type || 'tcs-ruby' == type) ? 1 : 0,
   'HAS_IVAR_HELPERS' => ('ruby' == type && !is_windows && (('1' == version[0] && '9' == version[1]) || '2' <= version[0])) ? 1 : 0,
   'HAS_EXCEPTION_MAGIC' => ('ruby' == type && ('1' == version[0] && '9' == version[1])) ? 0 : 1,
   'HAS_PROC_WITH_BLOCK' => ('ruby' == type && (('1' == version[0] && '9' == version[1]) || '2' <= version[0])) ? 1 : 0,

data/ext/oj/object.c

@@ -185,17 +185,39 @@ 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]) {
-	    volatile VALUE	sc;
+            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.
+	    // If struct is not defined then we 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);
-
+            // Create a properly initialized struct instance without calling the initialize method.
+            parent->val = rb_obj_alloc(sc);
+            // If the JSON array has more entries than the struct class allows, we record an error.
+#ifdef RSTRUCT_LEN
+            // MRI >= 1.9
+            if (len - 1 > RSTRUCT_LEN(parent->val)) {
+		oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
+            } else {
+                MEMCPY(RSTRUCT_PTR(parent->val), RARRAY_PTR(value) + 1, VALUE, len - 1);
+            }
+#else
+            {
+		// MRI < 1.9 or Rubinius
+		int	slen = FIX2INT(rb_funcall2(parent->val, oj_length_id, 0, 0));
+		int	i;
+
+		if (len - 1 > slen) {
+		    oj_set_error_at(pi, oj_parse_error_class, __FILE__, __LINE__, "Invalid struct data");
+		} else {
+		    for (i = 0; i < slen; i++) {
+			rb_struct_aset(parent->val, INT2FIX(i), RARRAY_PTR(value)[i + 1]);
+		    }
+		}
+            }
+#endif
 	    return 1;
 	} else if (3 <= klen && '#' == key[1]) {
 	    volatile VALUE	*a;

data/ext/oj/oj.c

@@ -64,6 +64,7 @@ ID	oj_hash_start_id;
 ID	oj_iconv_id;
 ID	oj_instance_variables_id;
 ID	oj_json_create_id;
+ID	oj_length_id;
 ID	oj_new_id;
 ID	oj_read_id;
 ID	oj_string_id;
@@ -84,12 +85,15 @@ VALUE	oj_cstack_class;
 VALUE	oj_date_class;
 VALUE	oj_datetime_class;
 VALUE	oj_parse_error_class;
+VALUE	oj_stream_writer_class;
+VALUE	oj_string_writer_class;
 VALUE	oj_stringio_class;
 VALUE	oj_struct_class;
 VALUE	oj_time_class;
 
 VALUE	oj_slash_string;
 
+static VALUE	allow_gc_sym;
 static VALUE	ascii_only_sym;
 static VALUE	ascii_sym;
 static VALUE	auto_define_sym;
@@ -153,6 +157,7 @@ struct _Options	oj_default_options = {
     json_class,		// create_id
     10,			// create_id_len
     9,			// sec_prec
+    Yes,		// allow_gc
     0,			// dump_opts
 };
 
@@ -173,6 +178,7 @@ static VALUE	define_mimic_json(int argc, VALUE *argv, VALUE self);
  * - 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
+ * - allow_gc: [true|false|nil] allow or prohibit GC during parsing, default is true (allow)
  * @return [Hash] all current option settings.
  */
 static VALUE
@@ -186,6 +192,7 @@ 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, allow_gc_sym, (Yes == oj_default_options.allow_gc) ? Qtrue : ((No == oj_default_options.allow_gc) ? 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;
@@ -244,6 +251,7 @@ get_def_opts(VALUE self) {
  *        :ruby Time.to_s formatted String
  * @param [String|nil] :create_id create id for json compatible object encoding
  * @param [Fixnum|nil] :second_precision number of digits after the decimal when dumping the seconds portion of time
+ * @param [true|false|nil] :allow_gc allow or prohibit GC during parsing, default is true (allow)
  * @return [nil]
  */
 static VALUE
@@ -254,6 +262,7 @@ 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 },
+	{ allow_gc_sym, &oj_default_options.allow_gc },
 	{ Qnil, 0 }
     };
     YesNoOpt	o;
@@ -383,6 +392,7 @@ 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 },
+	{ allow_gc_sym, &copts->allow_gc },
 	{ Qnil, 0 }
     };
     YesNoOpt	o;
@@ -817,6 +827,179 @@ to_stream(int argc, VALUE *argv, VALUE self) {
     return Qnil;
 }
 
+static void
+str_writer_free(void *ptr) {
+    StrWriter	sw;
+
+    if (0 == ptr) {
+	return;
+    }
+    sw = (StrWriter)ptr;
+    xfree(sw->out.buf);
+    xfree(sw->types);
+    xfree(ptr);
+}
+
+/* Document-class: Oj::StringWriter
+ * 
+ * Supports building a JSON document one element at a time. Build the document
+ * by pushing values into the document. Pushing an array or an object will
+ * create that element in the JSON document and subsequent pushes will add the
+ * elements to that array or object until a pop() is called. When complete
+ * calling to_s() will return the JSON document. Note tha calling to_s() before
+ * construction is complete will return the document in it's current state.
+ */
+
+/* call-seq: new(options)
+ *
+ * Creates a new StringWriter.
+ * @param [Hash] options formating options
+ */
+static VALUE
+str_writer_new(int argc, VALUE *argv, VALUE self) {
+    StrWriter	sw = ALLOC(struct _StrWriter);
+    
+    sw->opts = oj_default_options;
+    sw->depth = 0;
+    sw->types = ALLOC_N(char, 256);
+    sw->types_end = sw->types + 256;
+    *sw->types = '\0';
+    sw->out.buf = ALLOC_N(char, 4096);
+    sw->out.end = sw->out.buf + 4086;
+    sw->out.allocated = 1;
+    sw->out.cur = sw->out.buf;
+    *sw->out.cur = '\0';
+    sw->out.circ_cnt = 0;
+    sw->out.hash_cnt = 0;
+    if (1 == argc) {
+	oj_parse_options(argv[0], &sw->opts);
+    }
+    sw->out.opts = &sw->opts;
+    sw->out.indent = sw->opts.indent;
+
+    return Data_Wrap_Struct(oj_string_writer_class, 0, str_writer_free, sw);
+}
+
+/* call-seq: push_object(key=nil)
+ *
+ * Pushes an object onto the JSON document. Future pushes will be to this object
+ * until a pop() is called.
+ * @param [String] key the key if adding to an object in the JSON document
+ */
+static VALUE
+str_writer_push_object(int argc, VALUE *argv, VALUE self) {
+    switch (argc) {
+    case 0:
+	oj_str_writer_push_object((StrWriter)DATA_PTR(self), 0);
+	break;
+    case 1:
+	rb_check_type(argv[0], T_STRING);
+	oj_str_writer_push_object((StrWriter)DATA_PTR(self), StringValuePtr(argv[0]));
+	break;
+    default:
+	rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
+	break;
+    }
+    return Qnil;
+}
+
+/* call-seq: push_array(key=nil)
+ *
+ * Pushes an array onto the JSON document. Future pushes will be to this object
+ * until a pop() is called.
+ * @param [String] key the key if adding to an object in the JSON document
+ */
+static VALUE
+str_writer_push_array(int argc, VALUE *argv, VALUE self) {
+    switch (argc) {
+    case 0:
+	oj_str_writer_push_array((StrWriter)DATA_PTR(self), 0);
+	break;
+    case 1:
+	rb_check_type(argv[0], T_STRING);
+	oj_str_writer_push_array((StrWriter)DATA_PTR(self), StringValuePtr(argv[0]));
+	break;
+    default:
+	rb_raise(rb_eArgError, "Wrong number of argument to 'push_object'.");
+	break;
+    }
+    return Qnil;
+}
+
+/* call-seq: push_value(value, key=nil)
+ *
+ * Pushes a value onto the JSON document.
+ * @param [Object] value value to add to the JSON document
+ * @param [String] key the key if adding to an object in the JSON document
+ */
+static VALUE
+str_writer_push_value(int argc, VALUE *argv, VALUE self) {
+    switch (argc) {
+    case 1:
+	oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, 0);
+	break;
+    case 2:
+	rb_check_type(argv[1], T_STRING);
+	oj_str_writer_push_value((StrWriter)DATA_PTR(self), *argv, StringValuePtr(argv[1]));
+	break;
+    default:
+	rb_raise(rb_eArgError, "Wrong number of argument to 'push_value'.");
+	break;
+    }
+    return Qnil;
+}
+
+/* call-seq: pop()
+ *
+ * Pops up a level in the JSON document closing the array or object that is
+ * currently open.
+ */
+static VALUE
+str_writer_pop(VALUE self) {
+    oj_str_writer_pop((StrWriter)DATA_PTR(self));
+    return Qnil;
+}
+
+/* call-seq: pop_all()
+ *
+ * Pops all level in the JSON document closing all the array or object that is
+ * currently open.
+ */
+static VALUE
+str_writer_pop_all(VALUE self) {
+    oj_str_writer_pop_all((StrWriter)DATA_PTR(self));
+
+    return Qnil;
+}
+
+/* call-seq: reset()
+ *
+ * Reset the writer back to the empty state.
+ */
+static VALUE
+str_writer_reset(VALUE self) {
+    StrWriter	sw = (StrWriter)DATA_PTR(self);
+
+    sw->depth = 0;
+    *sw->types = '\0';
+    sw->out.cur = sw->out.buf;
+    *sw->out.cur = '\0';
+
+    return Qnil;
+}
+
+/* call-seq: to_s()
+ *
+ * Returns the JSON document string in what ever state the construction is at.
+ */
+static VALUE
+str_writer_to_s(VALUE self) {
+    StrWriter	sw = (StrWriter)DATA_PTR(self);
+    VALUE	rstr = rb_str_new(sw->out.buf, sw->out.cur - sw->out.buf);
+
+    return oj_encode(rstr);
+}
+
 // Mimic JSON section
 
 static VALUE
@@ -1195,14 +1378,35 @@ iconv_rescue(VALUE x) {
 }
 #endif
 
+static VALUE
+protect_require(VALUE x) {
+    rb_require("bigdecimal");
+    return Qnil;
+}
+
 void Init_oj() {
+    int	err = 0;
+
     Oj = rb_define_module("Oj");
 
     oj_cstack_class = rb_define_class_under(Oj, "CStack", rb_cObject);
 
+    oj_string_writer_class = rb_define_class_under(Oj, "StringWriter", rb_cObject);
+    rb_define_module_function(oj_string_writer_class, "new", str_writer_new, -1);
+    rb_define_method(oj_string_writer_class, "push_object", str_writer_push_object, -1);
+    rb_define_method(oj_string_writer_class, "push_array", str_writer_push_array, -1);
+    rb_define_method(oj_string_writer_class, "push_value", str_writer_push_value, -1);
+    rb_define_method(oj_string_writer_class, "pop", str_writer_pop, 0);
+    rb_define_method(oj_string_writer_class, "pop_all", str_writer_pop_all, 0);
+    rb_define_method(oj_string_writer_class, "reset", str_writer_reset, 0);
+    rb_define_method(oj_string_writer_class, "to_s", str_writer_to_s, 0);
+
+    //oj_stream_writer_class = rb_define_class_under(Oj, "StreamWriter", rb_cObject);
+
     rb_require("time");
     rb_require("date");
-    rb_require("bigdecimal");
+    // On Rubinius the require fails but can be done from a ruby file.
+    rb_protect(protect_require, Qnil, &err);
 #if NEEDS_RATIONAL
     rb_require("rational");
 #endif
@@ -1248,6 +1452,7 @@ void Init_oj() {
     oj_iconv_id = rb_intern("iconv");
     oj_instance_variables_id = rb_intern("instance_variables");
     oj_json_create_id = rb_intern("json_create");
+    oj_length_id = rb_intern("length");
     oj_new_id = rb_intern("new");
     oj_read_id = rb_intern("read");
     oj_string_id = rb_intern("string");
@@ -1271,6 +1476,7 @@ 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"));
 
+    allow_gc_sym = ID2SYM(rb_intern("allow_gc"));	rb_gc_register_address(&allow_gc_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);

data/ext/oj/oj.h

@@ -98,6 +98,13 @@ typedef enum {
     AutoDec	= 'a'
 } BigLoad;
 
+typedef enum {
+    ArrayNew	= 'A',
+    ArrayType	= 'a',
+    ObjectNew	= 'O',
+    ObjectType	= 'o',
+} DumpType;
+
 typedef struct _DumpOpts {
     const char	*indent;
     const char	*before_sep;
@@ -125,6 +132,7 @@ typedef struct _Options {
     const char	*create_id;	// 0 or string
     size_t	create_id_len;	// length of create_id
     int		sec_prec;	// second precision when dumping time
+    char	allow_gc;	// allow GC during parse
     DumpOpts	dump_opts;
 } *Options;
 
@@ -141,6 +149,14 @@ typedef struct _Out {
     int		allocated;
 } *Out;
 
+typedef struct _StrWriter {
+    struct _Out		out;
+    struct _Options	opts;
+    int			depth;
+    char		*types;	// DumpType
+    char		*types_end;
+} *StrWriter;
+
 enum {
     STR_VAL  = 0x00,
     COL_VAL  = 0x01,
@@ -182,6 +198,12 @@ extern void	oj_write_obj_to_stream(VALUE obj, VALUE stream, Options copts);
 extern void	oj_dump_leaf_to_json(Leaf leaf, Options copts, Out out);
 extern void	oj_write_leaf_to_file(Leaf leaf, const char *path, Options copts);
 
+extern void	oj_str_writer_push_object(StrWriter sw, const char *key);
+extern void	oj_str_writer_push_array(StrWriter sw, const char *key);
+extern void	oj_str_writer_push_value(StrWriter sw, VALUE val, const char *key);
+extern void	oj_str_writer_pop(StrWriter sw);
+extern void	oj_str_writer_pop_all(StrWriter sw);
+
 extern void	oj_init_doc(void);
 
 extern VALUE	Oj;
@@ -198,6 +220,8 @@ extern VALUE	oj_cstack_class;
 extern VALUE	oj_date_class;
 extern VALUE	oj_datetime_class;
 extern VALUE	oj_doc_class;
+extern VALUE	oj_stream_writer_class;
+extern VALUE	oj_string_writer_class;
 extern VALUE	oj_stringio_class;
 extern VALUE	oj_struct_class;
 extern VALUE	oj_time_class;
@@ -217,6 +241,7 @@ extern ID	oj_hash_start_id;
 extern ID	oj_iconv_id;
 extern ID	oj_instance_variables_id;
 extern ID	oj_json_create_id;
+extern ID	oj_length_id;
 extern ID	oj_new_id;
 extern ID	oj_read_id;
 extern ID	oj_string_id;

data/ext/oj/parse.c

@@ -747,9 +747,7 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json) {
 	if (oj_stringio_class == clas) {
 	    s = rb_funcall2(input, oj_string_id, 0, 0);
 	    pi->json = rb_string_value_cstr((VALUE*)&s);
-#ifndef JRUBY_RUBY
 #if !IS_WINDOWS
-	    // JRuby gets confused with what is the real fileno.
 	} else if (rb_respond_to(input, oj_fileno_id) && Qnil != (s = rb_funcall(input, oj_fileno_id, 0))) {
 	    int		fd = FIX2INT(s);
 	    ssize_t	cnt;
@@ -769,7 +767,6 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json) {
 	    if (0xEF == (uint8_t)*pi->json && 0xBB == (uint8_t)pi->json[1] && 0xBF == (uint8_t)pi->json[2]) {
 		pi->json += 3;
 	    }
-#endif
 #endif
 	} else if (rb_respond_to(input, oj_read_id)) {
 	    s = rb_funcall2(input, oj_read_id, 0, 0);
@@ -783,6 +780,9 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json) {
     } else {
 	pi->circ_array = 0;
     }
+    if (No == pi->options.allow_gc) {
+	rb_gc_disable();
+    }
     // GC can run at any time. When it runs any Object created by C will be
     // freed. We protect against this by wrapping the value stack in a ruby
     // data object and poviding a mark function for ruby objects on the
@@ -791,7 +791,9 @@ oj_pi_parse(int argc, VALUE *argv, ParseInfo pi, char *json) {
     rb_protect(protect_parse, (VALUE)pi, &line);
     result = stack_head_val(&pi->stack);
     DATA_PTR(wrapped_stack) = 0;
-
+    if (No == pi->options.allow_gc) {
+	rb_gc_enable();
+    }
     // proceed with cleanup
     if (0 != pi->circ_array) {
 	oj_circ_array_free(pi->circ_array);

data/ext/oj/scp.c

@@ -102,7 +102,7 @@ noop_array_append_value(ParseInfo pi, VALUE value) {
 
 static void
 add_value(ParseInfo pi, VALUE val) {
-     rb_funcall((VALUE)pi->cbc, oj_add_value_id, 1, val);
+    rb_funcall((VALUE)pi->cbc, oj_add_value_id, 1, val);
 }
 
 static void
@@ -110,7 +110,7 @@ add_cstr(ParseInfo pi, const char *str, size_t len, const char *orig) {
     volatile VALUE	rstr = rb_str_new(str, len);
 
     rstr = oj_encode(rstr);
-     rb_funcall((VALUE)pi->cbc, oj_add_value_id, 1, rstr);
+    rb_funcall((VALUE)pi->cbc, oj_add_value_id, 1, rstr);
 }
 
 static void

data/lib/oj/version.rb

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

data/test/perf_object.rb

@@ -20,6 +20,7 @@ require 'files'
 
 $circular = false
 $indent = 0
+$allow_gc = true
 
 do_sample = false
 do_files = false
@@ -35,6 +36,7 @@ opts = OptionParser.new
 opts.on("-c", "circular options")                           { $circular = true }
 
 opts.on("-x", "use sample instead of files")                { do_sample = true }
+opts.on("-g", "no GC during parsing")                       { $allow_gc = false }
 
 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 }
@@ -86,7 +88,7 @@ else
   end
 end
 
-Oj.default_options = { :mode => :object, :indent => $indent, :circular => $circular }
+Oj.default_options = { :mode => :object, :indent => $indent, :circular => $circular, :allow_gc => $allow_gc }
 #puts "json: #{$json.size}"
 #puts "xml: #{$xml.size}"
 #puts "marshal: #{$mars.size}"

data/test/test_fast.rb

@@ -11,6 +11,7 @@ $: << File.join(File.dirname(__FILE__), "../lib")
 $: << File.join(File.dirname(__FILE__), "../ext")
 
 require 'test/unit'
+require 'bigdecimal'
 require 'oj'
 
 $json1 = %{{

data/test/test_gc.rb

@@ -12,6 +12,7 @@ $: << File.join(File.dirname(__FILE__), "../lib")
 $: << File.join(File.dirname(__FILE__), "../ext")
 
 require 'test/unit'
+require 'bigdecimal'
 require 'oj'
 
 class Goo

data/test/test_mimic.rb

@@ -12,6 +12,7 @@ $: << File.join(File.dirname(__FILE__), "../ext")
 
 require 'test/unit'
 require 'stringio'
+require 'bigdecimal'
 require 'oj'
 
 $ruby = RUBY_DESCRIPTION.split(' ')[0]

data/test/test_saj.rb

@@ -11,6 +11,7 @@ $: << File.join(File.dirname(__FILE__), "../lib")
 $: << File.join(File.dirname(__FILE__), "../ext")
 
 require 'test/unit'
+require 'bigdecimal'
 require 'oj'
 require 'pp'
 

data/test/test_scp.rb

@@ -11,6 +11,7 @@ $: << File.join(File.dirname(__FILE__), "../lib")
 $: << File.join(File.dirname(__FILE__), "../ext")
 
 require 'test/unit'
+require 'bigdecimal'
 require 'oj'
 require 'pp'
 

data/test/test_writer.rb

@@ -0,0 +1,148 @@
+#!/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 'test/unit'
+require 'stringio'
+require 'date'
+require 'bigdecimal'
+require 'oj'
+
+class OjWriter < ::Test::Unit::TestCase
+
+  def test_string_writer_empty_array
+    w = Oj::StringWriter.new(:indent => 0)
+    w.push_array()
+    w.pop()
+    assert_equal('[]', w.to_s)
+
+  end
+
+  def test_string_writer_nested_array
+    w = Oj::StringWriter.new(:indent => 0)
+    w.push_array()
+    w.push_array()
+    w.pop()
+    w.push_array()
+    w.push_array()
+    w.pop()
+    w.pop()
+    w.push_array()
+    w.pop()
+    w.pop()
+    assert_equal('[[],[[]],[]]', w.to_s)
+  end
+
+  def test_string_writer_empty_object
+    w = Oj::StringWriter.new(:indent => 0)
+    w.push_object()
+    w.pop()
+    assert_equal('{}', w.to_s)
+  end
+
+  def test_string_writer_nested_object
+    w = Oj::StringWriter.new(:indent => 0)
+    w.push_object()
+    w.push_object("a1")
+    w.pop()
+    w.push_object("a2")
+    w.push_object("b")
+    w.pop()
+    w.pop()
+    w.push_object("a3")
+    w.pop()
+    w.pop()
+    assert_equal('{"a1":{},"a2":{"b":{}},"a3":{}}', w.to_s)
+  end
+
+  def test_string_writer_value_array
+    w = Oj::StringWriter.new(:indent => 0)
+    w.push_array()
+    w.push_value(7)
+    w.push_value(7.3)
+    w.push_value(true)
+    w.push_value(nil)
+    w.push_value("a string")
+    w.push_value({'a' => 65})
+    w.push_value([1,2])
+    w.pop()
+    assert_equal('[7,7.3,true,null,"a string",{"a":65},[1,2]]', w.to_s)
+  end
+
+  def test_string_writer_pop_excess
+    w = Oj::StringWriter.new(:indent => 0)
+    begin
+      w.pop()
+    rescue Exception
+      assert(true)
+      return
+    end
+    assert(false, "*** expected an exception")
+  end
+
+  def test_string_writer_obj_no_key
+    w = Oj::StringWriter.new(:indent => 0)
+    w.push_object()
+    begin
+      w.push_value(59)
+    rescue Exception
+      assert(true)
+      return
+    end
+    assert(false, "*** expected an exception")
+  end
+
+  def test_string_writer_array_with_key
+    w = Oj::StringWriter.new(:indent => 0)
+    w.push_array()
+    begin
+      w.push_value(59, 'x')
+    rescue Exception
+      assert(true)
+      return
+    end
+    assert(false, "*** expected an exception")
+  end
+
+  def test_string_writer_deep
+    cnt = 1000
+    w = Oj::StringWriter.new(:indent => 0)
+    cnt.times do
+      w.push_array()
+    end
+    cnt.times do
+      w.pop()
+    end
+    # if no exception then passed
+    assert(true)
+  end
+
+  def test_string_writer_pop_all
+    w = Oj::StringWriter.new(:indent => 0)
+    w.push_object()
+    w.push_object("a1")
+    w.pop()
+    w.push_array("a2")
+    w.push_value(3)
+    w.push_array()
+    w.pop_all()
+    assert_equal('{"a1":{},"a2":[3,[]]}', w.to_s)
+  end
+
+  def test_string_writer_reset
+    w = Oj::StringWriter.new(:indent => 0)
+    w.push_array()
+    w.pop()
+    w.reset()
+    assert_equal('', w.to_s)
+  end
+
+end # OjWriter

data/test/tests.rb

@@ -134,6 +134,7 @@ class Juice < ::Test::Unit::TestCase
                    :time_format=>:unix,
                    :bigdecimal_as_decimal=>true,
                    :bigdecimal_load=>:auto,
+                   :allow_gc=>true,
                    :create_id=>'json_class'}, opts)
   end
 
@@ -150,6 +151,7 @@ class Juice < ::Test::Unit::TestCase
       :time_format=>:unix,
       :bigdecimal_as_decimal=>true,
       :bigdecimal_load=>:auto,
+      :allow_gc=>true,
       :create_id=>'json_class'}
     o2 = {
       :indent=>4,
@@ -163,6 +165,7 @@ class Juice < ::Test::Unit::TestCase
       :time_format=>:ruby,
       :bigdecimal_as_decimal=>false,
       :bigdecimal_load=>:bigdecimal,
+      :allow_gc=>false,
       :create_id=>nil}
     o3 = { :indent => 4 }
     Oj.default_options = o2
@@ -765,8 +768,7 @@ class Juice < ::Test::Unit::TestCase
       Oj.default_options = { :mode => :object }
       json = Oj.dump(1..7, :mode => :object, :indent => 0)
       if 'rubinius' == $ruby
-        assert(%{{"^o":"Range","excl":false,"begin":1,"end":7}} == json ||
-               %{{"^o":"Range","begin":1,"end":7,"excl":false}} == json)
+        assert(%{{"^O":"Range","begin":1,"end":7,"exclude_end?":false}} == json)
       elsif 'jruby' == $ruby
         assert(%{{"^O":"Range","begin":1,"end":7,"exclude_end?":false}} == json)
       else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oj
 version: !ruby/object:Gem::Version
-  version: 2.2.3
+  version: 2.3.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-19 00:00:00.000000000 Z
+date: 2013-12-01 00:00:00.000000000 Z
 dependencies: []
 description: 'The fastest JSON parser and object serializer. '
 email: peter@ohler.com
@@ -93,6 +93,7 @@ files:
 - test/test_saj.rb
 - test/test_scp.rb
 - test/test_strict.rb
+- test/test_writer.rb
 - test/tests.rb
 - test/x.rb
 - LICENSE