oj 2.13.1 → 2.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 342383c1d1c0650dc81ad7a0f533e21b7ae67fa0
-  data.tar.gz: 7ba24a6ed5411eaef0c539076f0396cbed856489
+  metadata.gz: 3c5b4c3cba3688cc740907e024a5c586dc87ee8e
+  data.tar.gz: 779f5f0c8ca3485a69099c63bb7e9048f7c3b1cd
 SHA512:
-  metadata.gz: 0a80309e5fc8cd37f2d76f99567012697f5776f212bac9ffe38ee4bf4740853f19653cd49b4d0b7238688e89a857d28f7010a3ac5eaee576638175f63c8a3507
-  data.tar.gz: 4a191f0f8294dde6558d24445b5f01eacf5276a68a823467caf32599ef6691c1523ed5253686372cee3e322dfdc845d2f88ccac471f9990605afa81a3f6edad7
+  metadata.gz: 35a08d84c9b2e4cef975627ab66cb92ae5db9f1f9baf45cb2a9a10ecb21f3c96c5f3db15b5abff775cfdb56f99fdad21e6d5e65c74a4fbc76061d2cc7d3bb977
+  data.tar.gz: 89a87edcd3f140d729dd0de077fcd9a9d39f39b29106a3fd247b8293a722241a31e4a7140962737b5222e98bd9f9898b55c0415d66bd504235251728258bc62b

data/README.md

@@ -1,49 +1,42 @@
 # Oj gem
+[![Build Status](https://secure.travis-ci.org/ohler55/oj.png?branch=master)](http://travis-ci.org/ohler55/oj)
+
 A fast JSON parser and Object marshaller as a Ruby gem.
 
+## Using
+
+```ruby
+require 'oj'
+
+h = { 'one' => 1, 'array' => [ true, false ] }
+json = Oj.dump(h)
+
+# json =
+# {
+#   "one":1,
+#   "array":[
+#     true,
+#     false
+#   ]
+# }
+
+h2 = Oj.load(json)
+puts "Same? #{h == h2}"
+# true
+```
+
 ## Installation
 ```
 gem install oj
 ```
+
 or in Bundler:
+
 ```
 gem 'oj'
 ```
 
-## Documentation
-
-*Documentation*: http://www.ohler.com/oj, http://rubydoc.info/gems/oj
-
-## Source
-
-*GitHub* *repo*: https://github.com/ohler55/oj
-
-*RubyGems* *repo*: https://rubygems.org/gems/oj
-
-Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announcements and news about the Oj gem.
-
-## Build Status
-
-[![Build Status](https://secure.travis-ci.org/ohler55/oj.png?branch=master)](http://travis-ci.org/ohler55/oj)
-
-## Release 2.13.1
-
- - Thanks to Comboy for the fix to a large number rounding bug.
- 
-## Release 2.13.0
-
- - Oj no longer raises an exception if the to_hash method of an object does not
-   return a Hash. ActiveRecord has decided that to_hash should return an Array
-   instead so Oj now encodes what ever is returned.
-
- - Added a register_odd_raw function that allows odd marshal functions to return
-   raw JSON as a string to be included in the dumped JSON.
-
- - The register_odd function now supports modules in additions to classes.
-
-[Older release notes](http://www.ohler.com/dev/oj_misc/release_notes.html).
-
-## Description
+## 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
@@ -52,38 +45,139 @@ 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. The default mode
-is the `:object` mode.
+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.
 
-- `:strict` mode will only allow the 7 basic JSON types to be serialized. Any
-  other `Object` will raise an `Exception`.
+The fastest alternaive 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.
 
-- `:null` mode replaces any `Object` that is not one of the JSON types with a JSON `null`.
+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.
 
-- `: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 is the highest
-  performance mode.
+### Options
 
-- `: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.
+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:
 
-To change default serialization mode:
 ```ruby
 Oj.default_options = {:mode => :compat }
 ```
 
+ * `:mode` [Symbol] mode for dumping and loading JSON.
+
+  - `: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.
+
+ * `: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.
+ 
+ * `:auto_define` [Boolean] automatically define classes if they do not
+   exist.
+   
+ * `:symbol_keys` [Boolean] use symbols instead of strings for hash keys.
+ 
+ * `: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.
+  
+  - `:xss_safe` escapes HTML and XML characters such as `&` and `<`.
+  
+  - `:ascii` escapes all non-ascii or characters with the hi-bit set.
+   
+ * `:class_cache` [Boolean] cache classes for faster parsing (if
+   dynamically modifying classes or reloading classes then don't use this)
+   
+ * `: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.
+
+ * `:bigdecimal_as_decimal` [Boolean] dump BigDecimal as a decimal number
+   or as a String
+   
+ * `: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.
+   
+ * `:create_id` [String] create id for json compatible object encoding,
+   default is `json_create`.
+   
+ * `:second_precision` [Fixnum] number of digits after the decimal when dumping
+   the seconds portion of time
+   
+ * `:float_precision` [Fixnum] number of digits of precision when dumping
+   floats, 0 indicates use Ruby
+   
+ * `:use_to_json` [Boolean] call to_json() methods on dump, default is
+   false
+   
+ * `:nilnil` [Boolean] if true a nil input to load will return nil and
+   not raise an Exception
+   
+ * `: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).
+
+## Releases
+
+**Release 2.14.0**
+
+ - More tweaking on decimal rounding.
+
+ - Made dump options available in the default options and not only in the mimic
+   generate calls.
+  
+[Older release notes](http://www.ohler.com/dev/oj_misc/release_notes.html).
+
 ## Compatibility
 
-### Ruby
-Oj is compatible with Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0, 2.1, 2.2 and RBX.
+**Ruby**
+
+Oj is compatible with Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0, 2.1, 2.2, 2.3 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
+**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
@@ -92,72 +186,51 @@ 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 :my_attr, Oj
+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'
 ```
 
-## Proper Use
-
-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.
-
-
-## Simple JSON Writing and Parsing Example
-
-```ruby
-require 'oj'
-
-h = { 'one' => 1, 'array' => [ true, false ] }
-json = Oj.dump(h)
-
-# json =
-# {
-#   "one":1,
-#   "array":[
-#     true,
-#     false
-#   ]
-# }
-
-h2 = Oj.load(json)
-puts "Same? #{h == h2}"
-# true
-```
-
-## Alternative JSON Processing APIs
+## 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.
+
+## Links
 
-Oj offers a few alternative APIs for processing JSON. The fastest one 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.
+*Documentation*: http://www.ohler.com/oj, http://rubydoc.info/gems/oj
 
-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. The API is simple to use but does require a different approach than
-the conventional parse followed by access approach used by conventional JSON
-parsing.
+*GitHub* *repo*: https://github.com/ohler55/oj
 
+*RubyGems* *repo*: https://rubygems.org/gems/oj
 
-# Links
+Follow [@peterohler on Twitter](http://twitter.com/#!/peterohler) for announcements and news about the Oj gem.
 
-## Performance Comparisons
+#### 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.
 
@@ -167,7 +240,7 @@ parsing.
 
 [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
+#### Links of Interest
 
 *Fast XML parser and marshaller on RubyGems*: https://rubygems.org/gems/ox
 

data/ext/oj/dump.c

@@ -703,30 +703,30 @@ dump_array(VALUE a, VALUE clas, int depth, Out out) {
 	if (0 < id) {
 	    *out->cur++ = ',';
 	}
-	if (0 == out->opts->dump_opts) {
-	    size = d2 * out->indent + 2;
+	if (out->opts->dump_opts.use) {
+	    size = d2 * out->opts->dump_opts.indent_size + out->opts->dump_opts.array_size + 1;
 	} else {
-	    size = d2 * out->opts->dump_opts->indent_size + out->opts->dump_opts->array_size + 1;
+	    size = d2 * out->indent + 2;
 	}
 	cnt--;
 	for (i = 0; i <= cnt; i++) {
 	    if (out->end - out->cur <= (long)size) {
 		grow(out, size);
 	    }
-	    if (0 == out->opts->dump_opts) {
-		fill_indent(out, d2);
-	    } else {
-		if (0 < out->opts->dump_opts->array_size) {
-		    strcpy(out->cur, out->opts->dump_opts->array_nl);
-		    out->cur += out->opts->dump_opts->array_size;
+	    if (out->opts->dump_opts.use) {
+		if (0 < out->opts->dump_opts.array_size) {
+		    strcpy(out->cur, out->opts->dump_opts.array_nl);
+		    out->cur += out->opts->dump_opts.array_size;
 		}
-		if (0 < out->opts->dump_opts->indent_size) {
+		if (0 < out->opts->dump_opts.indent_size) {
 		    int	i;
 		    for (i = d2; 0 < i; i--) {
-			strcpy(out->cur, out->opts->dump_opts->indent);
-			out->cur += out->opts->dump_opts->indent_size;
+			strcpy(out->cur, out->opts->dump_opts.indent_str);
+			out->cur += out->opts->dump_opts.indent_size;
 		    }
 		}
+	    } else {
+		fill_indent(out, d2);
 	    }
 	    dump_val(rb_ary_entry(a, i), d2, out, 0, 0);
 	    if (i < cnt) {
@@ -737,22 +737,22 @@ dump_array(VALUE a, VALUE clas, int depth, Out out) {
 	if (out->end - out->cur <= (long)size) {
 	    grow(out, size);
 	}
-	if (0 == out->opts->dump_opts) {
-	    fill_indent(out, depth);
-	} else {
+	if (out->opts->dump_opts.use) {
 	    //printf("*** d2: %u  indent: %u '%s'\n", d2, out->opts->dump_opts->indent_size, out->opts->dump_opts->indent);
-	    if (0 < out->opts->dump_opts->array_size) {
-		strcpy(out->cur, out->opts->dump_opts->array_nl);
-		out->cur += out->opts->dump_opts->array_size;
+	    if (0 < out->opts->dump_opts.array_size) {
+		strcpy(out->cur, out->opts->dump_opts.array_nl);
+		out->cur += out->opts->dump_opts.array_size;
 	    }
-	    if (0 < out->opts->dump_opts->indent_size) {
+	    if (0 < out->opts->dump_opts.indent_size) {
 		int	i;
 
 		for (i = depth; 0 < i; i--) {
-		    strcpy(out->cur, out->opts->dump_opts->indent);
-		    out->cur += out->opts->dump_opts->indent_size;
+		    strcpy(out->cur, out->opts->dump_opts.indent_str);
+		    out->cur += out->opts->dump_opts.indent_size;
 		}
 	    }
+	} else {
+	    fill_indent(out, depth);
 	}
 	*out->cur++ = ']';
     }
@@ -767,7 +767,7 @@ hash_cb_strict(VALUE key, VALUE value, Out out) {
     if (rb_type(key) != T_STRING) {
 	rb_raise(rb_eTypeError, "In :strict mode all Hash keys must be Strings, not %s.\n", rb_class2name(rb_obj_class(key)));
     }
-    if (0 == out->opts->dump_opts) {
+    if (!out->opts->dump_opts.use) {
 	size = depth * out->indent + 1;
 	if (out->end - out->cur <= size) {
 	    grow(out, size);
@@ -776,34 +776,34 @@ hash_cb_strict(VALUE key, VALUE value, Out out) {
 	dump_str_comp(key, out);
 	*out->cur++ = ':';
     } else {
-	size = depth * out->opts->dump_opts->indent_size + out->opts->dump_opts->hash_size + 1;
+	size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
 	if (out->end - out->cur <= size) {
 	    grow(out, size);
 	}
-	if (0 < out->opts->dump_opts->hash_size) {
-	    strcpy(out->cur, out->opts->dump_opts->hash_nl);
-	    out->cur += out->opts->dump_opts->hash_size;
+	if (0 < out->opts->dump_opts.hash_size) {
+	    strcpy(out->cur, out->opts->dump_opts.hash_nl);
+	    out->cur += out->opts->dump_opts.hash_size;
 	}
-	if (0 < out->opts->dump_opts->indent_size) {
+	if (0 < out->opts->dump_opts.indent_size) {
 	    int	i;
 	    for (i = depth; 0 < i; i--) {
-		strcpy(out->cur, out->opts->dump_opts->indent);
-		out->cur += out->opts->dump_opts->indent_size;
+		strcpy(out->cur, out->opts->dump_opts.indent_str);
+		out->cur += out->opts->dump_opts.indent_size;
 	    }
 	}
 	dump_str_comp(key, out);
-	size = out->opts->dump_opts->before_size + out->opts->dump_opts->after_size + 2;
+	size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
 	if (out->end - out->cur <= size) {
 	    grow(out, size);
 	}
-	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;
+	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 (0 < out->opts->dump_opts.after_size) {
+	    strcpy(out->cur, out->opts->dump_opts.after_sep);
+	    out->cur += out->opts->dump_opts.after_size;
 	}
     }
     dump_val(value, depth, out, 0, 0);
@@ -818,26 +818,26 @@ hash_cb_compat(VALUE key, VALUE value, Out out) {
     int		depth = out->depth;
     long	size;
 
-    if (0 == out->opts->dump_opts) {
+    if (!out->opts->dump_opts.use) {
 	size = depth * out->indent + 1;
 	if (out->end - out->cur <= size) {
 	    grow(out, size);
 	}
 	fill_indent(out, depth);
     } else {
-	size = depth * out->opts->dump_opts->indent_size + out->opts->dump_opts->hash_size + 1;
+	size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
 	if (out->end - out->cur <= size) {
 	    grow(out, size);
 	}
-	if (0 < out->opts->dump_opts->hash_size) {
-	    strcpy(out->cur, out->opts->dump_opts->hash_nl);
-	    out->cur += out->opts->dump_opts->hash_size;
+	if (0 < out->opts->dump_opts.hash_size) {
+	    strcpy(out->cur, out->opts->dump_opts.hash_nl);
+	    out->cur += out->opts->dump_opts.hash_size;
 	}
-	if (0 < out->opts->dump_opts->indent_size) {
+	if (0 < out->opts->dump_opts.indent_size) {
 	    int	i;
 	    for (i = depth; 0 < i; i--) {
-		strcpy(out->cur, out->opts->dump_opts->indent);
-		out->cur += out->opts->dump_opts->indent_size;
+		strcpy(out->cur, out->opts->dump_opts.indent_str);
+		out->cur += out->opts->dump_opts.indent_size;
 	    }
 	}
     }
@@ -853,21 +853,21 @@ hash_cb_compat(VALUE key, VALUE value, Out out) {
 	dump_str_comp(rb_funcall(key, oj_to_s_id, 0), out);
 	break;
     }
-    if (0 == out->opts->dump_opts) {
+    if (!out->opts->dump_opts.use) {
 	*out->cur++ = ':';
     } else {
-	size = out->opts->dump_opts->before_size + out->opts->dump_opts->after_size + 2;
+	size = out->opts->dump_opts.before_size + out->opts->dump_opts.after_size + 2;
 	if (out->end - out->cur <= size) {
 	    grow(out, size);
 	}
-	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;
+	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 (0 < out->opts->dump_opts.after_size) {
+	    strcpy(out->cur, out->opts->dump_opts.after_sep);
+	    out->cur += out->opts->dump_opts.after_size;
 	}
     }
     dump_val(value, depth, out, 0, 0);
@@ -988,26 +988,26 @@ dump_hash(VALUE obj, VALUE clas, int depth, int mode, Out out) {
 	if (',' == *(out->cur - 1)) {
 	    out->cur--; // backup to overwrite last comma
 	}
-	if (0 == out->opts->dump_opts) {
+	if (!out->opts->dump_opts.use) {
 	    if (out->end - out->cur <= (long)size) {
 		grow(out, size);
 	    }
 	    fill_indent(out, depth);
 	} else {
-	    size = depth * out->opts->dump_opts->indent_size + out->opts->dump_opts->hash_size + 1;
+	    size = depth * out->opts->dump_opts.indent_size + out->opts->dump_opts.hash_size + 1;
 	    if (out->end - out->cur <= (long)size) {
 		grow(out, size);
 	    }
-	    if (0 < out->opts->dump_opts->hash_size) {
-		strcpy(out->cur, out->opts->dump_opts->hash_nl);
-		out->cur += out->opts->dump_opts->hash_size;
+	    if (0 < out->opts->dump_opts.hash_size) {
+		strcpy(out->cur, out->opts->dump_opts.hash_nl);
+		out->cur += out->opts->dump_opts.hash_size;
 	    }
-	    if (0 < out->opts->dump_opts->indent_size) {
+	    if (0 < out->opts->dump_opts.indent_size) {
 		int	i;
 
 		for (i = depth; 0 < i; i--) {
-		    strcpy(out->cur, out->opts->dump_opts->indent);
-		    out->cur += out->opts->dump_opts->indent_size;
+		    strcpy(out->cur, out->opts->dump_opts.indent_str);
+		    out->cur += out->opts->dump_opts.indent_size;
 		}
 	    }
 	}