oj 2.18.5 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '0680538f0b702ac222fce52dacf832b743d99578'
-  data.tar.gz: 13a74b36cf681763823e8ca0f93a53704feafc41
+  metadata.gz: 7b5e26434d67518ead10da0ffb7f97ca0d05a0de
+  data.tar.gz: cdd5a57251a116ba7e7f1d16136821a5baa04869
 SHA512:
-  metadata.gz: a73409be107f9c6b262ad17cf6051401602910270c1d7a2929b4e9877b2b29651fb9e4f08c0436462f37d55f04d8d7c2f5fdb6cb43817ad121bdda8f3056cfdd
-  data.tar.gz: 21b43f4f2ebe1af8d84ece21671ea42178bdfe9b8ac9125d3b326695e792c3882490f654f62bb0a77345e43bd5658fd6e2e9fdff9d8b2d5275f561a456aa4236
+  metadata.gz: 1a9ab31bbf01cd8794e88a25adcbb989dead17ac17c76ea792d0580211e516f67b9224aaa64e85af62b1ba5a1a230693c6e14415443f33e04f683e2e0cb632f0
+  data.tar.gz: 6656a40ec3b1aea8de039062f76f00124c0af96e4679df3975c97e495ced5aa5811f628304ec23c52baa17b18780eee6f2705cd9dedc23e75626e733e3777872

data/README.md

@@ -1,7 +1,13 @@
-# Oj gem
+# [![{}j](http://www.ohler.com/dev/images/oj_hel_fire_64.png)](http://www.ohler.com/oj) gem
+
 [![Build Status](https://img.shields.io/travis/ohler55/oj/master.svg)](http://travis-ci.org/ohler55/oj?branch=master) ![Gem](https://img.shields.io/gem/v/oj.svg) ![Gem](https://img.shields.io/gem/dt/oj.svg)
 
-A fast JSON parser and Object marshaller as a Ruby gem.
+A *fast* JSON parser and Object marshaller as a Ruby gem.
+
+Version 3.0 is out! 3.0 provides better json gem and Rails compatibility. It
+also provides additional optimization options.
+
+Please check out issue #364 and help pick or suggest a image to represent Oj.
 
 ## Using
 
@@ -25,11 +31,6 @@ puts "Same? #{h == h2}"
 # true
 ```
 
-By default Oj uses the :object mode which is used to marshal and unmarshal Ruby
-objects. Deserialize arbitrary JSON in object mode may lead to unexpected
-results. :compat mode is a better choice for rails and :strict mode is a better
-choice for general JSON parsing. See the options section below for details.
-
 ## Installation
 ```
 gem install oj
@@ -41,247 +42,53 @@ or in Bundler:
 gem 'oj'
 ```
 
-## Advanced
-
-Optimized JSON (Oj), as the name implies, was written to provide speed optimized
-JSON handling. It was designed as a faster alternative to Yajl and other
-common Ruby JSON parsers. So far it has achieved that, and is about 2 times faster
-than any other Ruby JSON parser, and 3 or more times faster at serializing JSON.
-
-Oj has several `dump` or serialization modes which control how Ruby `Object`s are
-converted to JSON. These modes are set with the `:mode` option in either the
-default options or as one of the options to the `dump` method. In addition to
-the various options there are also alternative APIs for parsing JSON.
-
-The fastest alternative parser API is the `Oj::Doc` API. The `Oj::Doc` API takes
-a completely different approach by opening a JSON document and providing calls
-to navigate around the JSON while it is open. With this approach, JSON access
-can be well over 20 times faster than conventional JSON parsing.
-
-The `Oj::Saj` and `Oj::ScHandler` APIs are callback parsers that
-walk the JSON document depth first and makes callbacks for each element.
-Both callback parser are useful when only portions of the JSON are of
-interest. Performance up to 20 times faster than conventional JSON is
-possible if only a few elements of the JSON are of interest.
-
-### Options
-
-To change default serialization mode use the following form. Attempting to
-modify the Oj.default_options Hash directly will not set the changes on the
-actual default options but on a copy of the Hash:
-
-```ruby
-Oj.default_options = {:mode => :compat }
-```
-
-### Common (for serializer and parser) options
-
- * `:mode` [Symbol] mode for dumping and loading JSON. **Important format details [here](http://www.ohler.com/dev/oj_misc/encoding_format.html)**
-
-    - `:object` mode will dump any `Object` as a JSON `Object` with keys that
-      match the Ruby `Object`'s variable names without the '@' prefix
-      character. This mode has the best performance and is the default
-
-    - `:strict` mode will only allow the 7 basic JSON types to be serialized. Any
-      other `Object` will raise an `Exception`
-
-    - `:null` mode replaces any `Object` that is not one of the JSON types with a JSON `null`
-
-    - `:compat` mode attempts to be compatible with other systems. It will
-      serialize any `Object`, but will check to see if the `Object` implements an
-      `to_hash` or `to_json` method. If either exists, that method is used for
-      serializing the `Object`.  Since `as_json` is more flexible and produces
-      more consistent output, it is preferred over the `to_json` method. If
-      neither the `to_json` or `to_hash` methods exists, then the Oj internal
-      `Object` variable encoding is used
-
- * `:time_format` [Symbol] time format when dumping in :compat and :object mode
-
-    - `:unix` time is output as a decimal number in seconds since epoch including
-      fractions of a second.
-
-    - `:unix_zone` similar to the `:unix` format but with the timezone encoded in
-      the exponent of the decimal number of seconds since epoch.
-
-    - `:xmlschema` time is output as a string that follows the XML schema definition.
-
-    - `:ruby` time is output as a string formatted using the Ruby `to_s` conversion.
-
- * `:second_precision` [Fixnum] number of digits after the decimal when dumping
-   the seconds portion of time
-
- * `:bigdecimal_as_decimal` [Boolean] dump BigDecimal as a decimal number
-   or as a String
-
- * `:create_id` [String] create id for json compatible object encoding,
-   default is `json_create`.
-
- * `:allow_gc` [Boolean] allow or prohibit GC during parsing, default is
-   true (allow).
-
- * `:quirks_mode` [Boolean] Allow single JSON values instead of
-   documents, default is true (allow).
-
- * `:allow_invalid_unicode` [Boolean] Allow invalid unicode, default is
-   false (don't allow)
-
- * `:omit_nil` [Boolean] If true, Hash and Object attributes with nil values
-   are omitted
-
-### Serializer options
-
- * `:indent` [Fixnum] number of spaces to indent each element in an JSON
-   document, zero is no newline between JSON elements, negative indicates no
-   newline between top level JSON elements in a stream
-   
- * `:circular` [Boolean] support circular references while dumping
-
- * `:escape_mode` [Symbol] determines the characters to escape
-
-    - `:newline` allows unescaped newlines in the output
-
-    - `:json` follows the JSON specification. This is the default mode
+## Further Reading
 
-    - `:xss_safe` escapes HTML and XML characters such as `&` and `<`
+For more details on options, modes, advanced features, and more follow these
+links.
 
-    - `:ascii` escapes all non-ascii or characters with the hi-bit set
-
- * `:use_to_json` [Boolean] call `to_json()` methods on dump, default is
-   false
-
- * `:use_as_json` [Boolean] call `as_json()` methods on dump, default is
-   false
-
- * `:nan` [Symbol] How to dump Infinity, -Infinity, and
-   NaN in :null, :strict, and :compat mode. Default is :auto
-
-    - `:null` places a null
-
-    - `:huge` places a huge number
-
-    - `:word` places Infinity or NaN
-
-    - `:raise` raises and exception
-
-    - `:auto` uses default for each mode which are `:raise` for `:strict`, `:null` for `:null`, and `:word` for `:compat`
-
-### Parser options
-
- * `:auto_define` [Boolean] automatically define classes if they do not
-   exist
-
- * `:symbol_keys` [Boolean] use symbols instead of strings for hash keys
-
- * `:class_cache` [Boolean] cache classes for faster parsing (if
-   dynamically modifying classes or reloading classes then don't use this)
-
- * `:bigdecimal_load` [Symbol] load decimals as BigDecimal instead of as a
-   Float
-
-    - `:bigdecimal` convert all decimal numbers to BigDecimal
-
-    - `:float` convert all decimal numbers to Float
-
-    - `:auto` the most precise for the number of digits is used
-
- * `:float_precision` [Fixnum] number of digits of precision when dumping
-   floats, 0 indicates use Ruby
-
- * `:nilnil` [Boolean] if true a nil input to load will return nil and
-   not raise an Exception
-
- * `:empty_string` [Boolean] if true an empty input will not raise an
-   Exception, default is true (allow). When Oj.mimic_JSON is used,
-   default is false (raise exception when empty string is encountered)
-
- * `:hash_class` [Class] Class to use instead of Hash on load
+ - [{file:Options.md}](pages/Options.md) for parse and dump options.
+ - [{file:Modes.md}](pages/Modes.md) for details on modes for strict JSON compliance, mimicing the JSON gem, and mimicing Rails and ActiveSupport behavior.
+ - [{file:JsonGem.md}](pages/JsonGem.md) includes more details on json gem compatibility and use.
+ - [{file:Rails.md}](pages/Rails.md) includes more details on Rails and ActiveSupport compatibility and use.
+ - [{file:Custom.md}](pages/Custom.md) includes more details on Custom mode.
+ - [{file:Encoding.md}](pages/Encoding.md) describes the :object encoding format.
+ - [{file:Compatibility.md}](pages/Compatibility.md) lists current compatibility with Rubys and Rails.
+ - [{file:Advanced.md}](pages/Advanced.md) for fast parser and marshalling features.
+ - [{file:Security.md}](pages/Security.md) for security considerations.
 
 ## Releases
 
-See [CHANGELOG.md](CHANGELOG.md)
-
-## Compatibility
-
-**Ruby**
-
-Oj is compatible with Ruby 1.9.3, 2.0.0, 2.1, 2.2, 2.3, 2.4 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.
-
-**Rails**
-
-Although up until 4.1 Rails uses [multi_json](https://github.com/intridea/multi_json), an [issue in Rails](https://github.com/rails/rails/issues/9212) causes ActiveSupport to fail to make use Oj for JSON handling.
-There is a
-[gem to patch this](https://github.com/GoodLife/rails-patch-json-encode) for
-Rails 3.2 and 4.0. As of the Oj 2.6.0 release the default behavior is to not use
-the `to_json()` method unless the `:use_to_json` option is set. This provides
-another work around to the rails older and newer behavior.
-
-The latest ActiveRecord is able to work with Oj by simply using the line:
-
-```
-serialize :metadata, Oj
-```
-
-In version Rails 4.1, multi_json has been removed, and this patch is unnecessary and will no longer work.
-Instead, use the `oj_mimic_json` [gem](https://github.com/ohler55/oj_mimic_json) along with `oj` in your `Gemfile` to have Oj mimic the JSON gem and be used in its place by `ActiveSupport` JSON handling:
-
-```
-gem 'oj'
-gem 'oj_mimic_json'
-```
-
-## Security and Optimization
-
-Two settings in Oj are useful for parsing but do expose a vulnerability if used
-from an untrusted source. Symbolized keys can cause memory to be filled with
-previous versions of ruby. Ruby 2.1 and below does not garbage collect
-Symbols. The same is true for auto defining classes in all versions of ruby;
-memory will also be exhausted if too many classes are automatically
-defined. Auto defining is a useful feature during development and from trusted
-sources but it allows too many classes to be created in the object load mode and
-auto defined is used with an untrusted source. The `Oj.strict_load()` method
-sets and uses the most strict and safest options. It should be used by
-developers who find it difficult to understand the options available in Oj.
-
-The options in Oj are designed to provide flexibility to the developer. This
-flexibility allows Objects to be serialized and deserialized. No methods are
-ever called on these created Objects but that does not stop the developer from
-calling methods on them. As in any system, check your inputs before working with
-them. Taking an arbitrary `String` from a user and evaluating it is never a good
-idea from an unsecure source. The same is true for `Object` attributes as they
-are not more than `String`s. Always check inputs from untrusted sources.
+See [{file:CHANGELOG.md}](CHANGELOG.md)
 
 ## Links
 
-*Documentation*: http://www.ohler.com/oj, http://rubydoc.info/gems/oj
+ - *Documentation*: http://www.ohler.com/oj, http://rubydoc.info/gems/oj
 
-*GitHub* *repo*: https://github.com/ohler55/oj
+- *GitHub* *repo*: https://github.com/ohler55/oj
 
-*RubyGems* *repo*: https://rubygems.org/gems/oj
+- *RubyGems* *repo*: https://rubygems.org/gems/oj
 
 Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announcements and news about the Oj gem.
 
 #### Performance Comparisons
 
-[Oj Strict Mode Performance](http://www.ohler.com/dev/oj_misc/performance_strict.html) compares Oj strict mode parser performance to other JSON parsers.
+ - [Oj Strict Mode Performance](http://www.ohler.com/dev/oj_misc/performance_strict.html) compares Oj strict mode parser performance to other JSON parsers.
 
-[Oj Compat Mode Performance](http://www.ohler.com/dev/oj_misc/performance_compat.html) compares Oj compat mode parser performance to other JSON parsers.
+ - [Oj Compat Mode Performance](http://www.ohler.com/dev/oj_misc/performance_compat.html) compares Oj compat mode parser performance to other JSON parsers.
 
-[Oj Object Mode Performance](http://www.ohler.com/dev/oj_misc/performance_object.html) compares Oj object mode parser performance to other marshallers.
+ - [Oj Object Mode Performance](http://www.ohler.com/dev/oj_misc/performance_object.html) compares Oj object mode parser performance to other marshallers.
 
-[Oj Callback Performance](http://www.ohler.com/dev/oj_misc/performance_callback.html) compares Oj callback parser performance to other JSON parsers.
+ - [Oj Callback Performance](http://www.ohler.com/dev/oj_misc/performance_callback.html) compares Oj callback parser performance to other JSON parsers.
 
 #### Links of Interest
 
-*Fast XML parser and marshaller on RubyGems*: https://rubygems.org/gems/ox
-
-*Fast XML parser and marshaller on GitHub*: https://github.com/ohler55/ox
+ - *Fast XML parser and marshaller on RubyGems*: https://rubygems.org/gems/ox
 
-[Oj Object Encoding Format](http://www.ohler.com/dev/oj_misc/encoding_format.html) describes the OJ Object JSON encoding format.
+ - *Fast XML parser and marshaller on GitHub*: https://github.com/ohler55/ox
 
-[Need for Speed](http://www.ohler.com/dev/need_for_speed/need_for_speed.html) for an overview of how Oj::Doc was designed.
+ - [Need for Speed](http://www.ohler.com/dev/need_for_speed/need_for_speed.html) for an overview of how Oj::Doc was designed.
 
-*OjC, a C JSON parser*: https://www.ohler.com/ojc also at https://github.com/ohler55/ojc
+ - *OjC, a C JSON parser*: https://www.ohler.com/ojc also at https://github.com/ohler55/ojc
 
-*Piper Push Cache, push JSON to browsers*: http://www.piperpushcache.com
+ - *Piper Push Cache, push JSON to browsers*: http://www.piperpushcache.com

data/ext/oj/circarray.c

@@ -1,31 +1,6 @@
 /* circarray.c
  * Copyright (c) 2012, Peter Ohler
  * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- *  - Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 
- *  - Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- * 
- *  - Neither the name of Peter Ohler nor the names of its contributors may be
- *    used to endorse or promote products derived from this software without
- *    specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "circarray.h"

data/ext/oj/circarray.h

@@ -1,31 +1,6 @@
 /* circarray.h
  * Copyright (c) 2012, Peter Ohler
  * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- * 
- *  - Redistributions of source code must retain the above copyright notice, this
- *    list of conditions and the following disclaimer.
- * 
- *  - Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- * 
- *  - Neither the name of Peter Ohler nor the names of its contributors may be
- *    used to endorse or promote products derived from this software without
- *    specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef __OJ_CIRCARRAY_H__

data/ext/oj/code.c

@@ -0,0 +1,227 @@
+/* code.c
+ * Copyright (c) 2017, Peter Ohler
+ * All rights reserved.
+ */
+
+#include "code.h"
+#include "dump.h"
+
+inline static VALUE
+resolve_classname(VALUE mod, const char *classname) {
+    VALUE	clas = Qundef;
+    ID		ci = rb_intern(classname);
+
+    if (rb_const_defined_at(mod, ci)) {
+	clas = rb_const_get_at(mod, ci);
+    }
+    return clas;
+}
+
+static VALUE
+path2class(const char *name) {
+    char	class_name[1024];
+    VALUE	clas;
+    char	*end = class_name + sizeof(class_name) - 1;
+    char	*s;
+    const char	*n = name;
+
+    clas = rb_cObject;
+    for (s = class_name; '\0' != *n; n++) {
+	if (':' == *n) {
+	    *s = '\0';
+	    n++;
+	    if (':' != *n) {
+		return Qundef;
+	    }
+	    if (Qundef == (clas = resolve_classname(clas, class_name))) {
+		return Qundef;
+	    }
+	    s = class_name;
+	} else if (end <= s) {
+	    return Qundef;
+	} else {
+	    *s++ = *n;
+	}
+    }
+    *s = '\0';
+
+    return resolve_classname(clas, class_name);
+}
+
+bool
+oj_code_dump(Code codes, VALUE obj, int depth, Out out) {
+    VALUE	clas = rb_obj_class(obj);
+    Code	c = codes;
+
+    for (; NULL != c->name; c++) {
+	if (Qundef == c->clas) { // indicates not defined
+	    continue;
+	}
+	if (Qnil == c->clas) {
+	    c->clas = path2class(c->name);
+	}
+	if (clas == c->clas && c->active) {
+	    c->encode(obj, depth, out);
+	    return true;
+	}
+    }
+    return false;
+}
+
+VALUE
+oj_code_load(Code codes, VALUE clas, VALUE args) {
+    Code	c = codes;
+
+    for (; NULL != c->name; c++) {
+	if (Qundef == c->clas) { // indicates not defined
+	    continue;
+	}
+	if (Qnil == c->clas) {
+	    c->clas = path2class(c->name);
+	}
+	if (clas == c->clas) {
+	    if (NULL == c->decode) {
+		break;
+	    }
+	    return c->decode(clas, args);
+	}
+    }
+    return Qnil;
+}
+
+void
+oj_code_set_active(Code codes, VALUE clas, bool active) {
+    Code	c = codes;
+
+    for (; NULL != c->name; c++) {
+	if (Qundef == c->clas) { // indicates not defined
+	    continue;
+	}
+	if (Qnil == c->clas) {
+	    c->clas = path2class(c->name);
+	}
+	if (clas == c->clas || Qnil == clas) {
+	    c->active = active;
+	    if (Qnil != clas) {
+		break;
+	    }
+	}
+    }
+}
+
+bool
+oj_code_has(Code codes, VALUE clas, bool encode) {
+    Code	c = codes;
+
+    for (; NULL != c->name; c++) {
+	if (Qundef == c->clas) { // indicates not defined
+	    continue;
+	}
+	if (Qnil == c->clas) {
+	    c->clas = path2class(c->name);
+	}
+	if (clas == c->clas) {
+	    if (encode) {
+		return c->active && NULL != c->encode;
+	    } else {
+		return c->active && NULL != c->decode;
+	    }
+	}
+    }
+    return false;
+}
+
+void
+oj_code_attrs(VALUE obj, Attr attrs, int depth, Out out) {
+    int		d2 = depth + 1;
+    int		d3 = d2 + 1;
+    size_t	sep_len = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
+    const char	*classname = rb_obj_classname(obj);
+    size_t	len = strlen(classname);
+    size_t	size = d2 * out->indent + 10 + len + out->opts->create_id_len + sep_len;
+
+    assure_size(out, size);
+    *out->cur++ = '{';
+    fill_indent(out, d2);
+    *out->cur++ = '"';
+    memcpy(out->cur, out->opts->create_id, out->opts->create_id_len);
+    out->cur += out->opts->create_id_len;
+    *out->cur++ = '"';
+    if (0 < out->opts->dump_opts.before_size) {
+	strcpy(out->cur, out->opts->dump_opts.before_sep);
+	out->cur += out->opts->dump_opts.before_size;
+    }
+    *out->cur++ = ':';
+    if (0 < out->opts->dump_opts.after_size) {
+	strcpy(out->cur, out->opts->dump_opts.after_sep);
+	out->cur += out->opts->dump_opts.after_size;
+    }
+    *out->cur++ = '"';
+    memcpy(out->cur, classname, len);
+    out->cur += len;
+    *out->cur++ = '"';
+
+    size = d3 * out->indent + 2;
+    for (; NULL != attrs->name; attrs++) {
+	assure_size(out, size + attrs->len + sep_len + 2);
+	*out->cur++ = ',';
+	fill_indent(out, d3);
+	*out->cur++ = '"';
+	memcpy(out->cur, attrs->name, attrs->len);
+	out->cur += attrs->len;
+	*out->cur++ = '"';
+	if (0 < out->opts->dump_opts.before_size) {
+	    strcpy(out->cur, out->opts->dump_opts.before_sep);
+	    out->cur += out->opts->dump_opts.before_size;
+	}
+	*out->cur++ = ':';
+	if (0 < out->opts->dump_opts.after_size) {
+	    strcpy(out->cur, out->opts->dump_opts.after_sep);
+	    out->cur += out->opts->dump_opts.after_size;
+	}
+	if (Qundef == attrs->value) {
+	    if (Qundef != attrs->time) {
+		switch (out->opts->time_format) {
+		case RubyTime:	oj_dump_ruby_time(attrs->time, out);	break;
+		case XmlTime:	oj_dump_xml_time(attrs->time, out);	break;
+		case UnixZTime:	oj_dump_time(attrs->time, out, true);	break;
+		case UnixTime:
+		default:	oj_dump_time(attrs->time, out, false);	break;
+		}
+	    } else {
+		char	buf[32];
+		char	*b = buf + sizeof(buf) - 1;
+		int	neg = 0;
+		long	num = attrs->num;
+	    
+		if (0 > num) {
+		    neg = 1;
+		    num = -num;
+		}
+		*b-- = '\0';
+		if (0 < num) {
+		    for (; 0 < num; num /= 10, b--) {
+			*b = (num % 10) + '0';
+		    }
+		    if (neg) {
+			*b = '-';
+		    } else {
+			b++;
+		    }
+		} else {
+		    *b = '0';
+		}
+		assure_size(out, (sizeof(buf) - (b - buf)));
+		for (; '\0' != *b; b++) {
+		    *out->cur++ = *b;
+		}
+	    }
+	} else {
+	    oj_dump_compat_val(attrs->value, d3, out, true);
+	}
+    }
+    assure_size(out, depth * out->indent + 2);
+    fill_indent(out, depth);
+    *out->cur++ = '}';
+    *out->cur = '\0';
+}