dart:convert: support indented output w/ JsonEncoder

sdk/lib/convert/json.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.convert;
 
 /**
  * Error thrown by JSON serialization if an object cannot be serialized.
  *
  * The [unsupportedObject] field holds that object that failed to be serialized.
@@ skipping 139 matching lines @@
   JsonDecoder get decoder {
     if (_reviver == null) return const JsonDecoder();
     return new JsonDecoder(_reviver);
   }
 }
 
 /**
  * This class converts JSON objects to strings.
  */
 class JsonEncoder extends Converter<Object, String> {
+  /**
+   * How many spaces each level of the JSON output is indented.
+   *
+   * If `null`, the output is encoded in a single line.
+   */
+  final int indent;

[Lasse Reichstein Nielsen, 2014/04/03 18:18:17]

Consider letting "indent" be a string which will be repeated. Then you can pick
either space or tab indentation as you please.

+
   final _toEncodableFunction;
 
   /**
    * Creates a JSON encoder.
    *
    * The JSON encoder handles numbers, strings, booleans, null, lists and
    * maps directly.
    *
    * Any other object is attempted converted by [toEncodable] to an
    * object that is of one of the convertible types.
    *
    * If [toEncodable] is omitted, it defaults to calling `.toJson()` on
    * the object.
    */
   const JsonEncoder([Object toEncodable(Object nonSerializable)])
-      : this._toEncodableFunction = toEncodable;
+      : this.indent = null,
+        this._toEncodableFunction = toEncodable;
+
+  /**
+   * Creates a JSON encoder with each output level having a specified [indent].
+   *
+   * An encoder with a `null` [indent] encodes objects onto a single line.
+   *
+   * The JSON encoder handles numbers, strings, booleans, null, lists and
+   * maps directly.
+   *
+   * Any other object is attempted converted by [toEncodable] to an
+   * object that is of one of the convertible types.
+   *
+   * If [toEncodable] is omitted, it defaults to calling `.toJson()` on
+   * the object.
+   */
+  const JsonEncoder.withIndent(int indent,
+      [Object toEncodable(Object nonSerializable)])
+      : this.indent = indent != null && indent < 0 ? 0 : indent,
+        this._toEncodableFunction = toEncodable;
 
   /**
    * Converts the given object [o] to its JSON representation.
    *
    * Directly serializable values are [num], [String], [bool], and [Null], as
    * well as some [List] and [Map] values.
    * For [List], the elements must all be serializable.
    * For [Map], the keys must be [String] and the values must be serializable.
    *
    * If a value is any other type is attempted serialized, the conversion
    * function provided in the constructor is invoked with the object as argument
    * and the result, which must be a directly serializable value,
    * is serialized instead of the original value.
    *
    * If the conversion throws, or returns a value that is not directly
    * serializable, a [JsonUnsupportedObjectError] exception is thrown.
    * If the call throws, the error is caught and stored in the
    * [JsonUnsupportedObjectError]'s [:cause:] field.
    *
    * If a [List] or [Map] contains a reference to itself, directly or through
    * other lists or maps, it cannot be serialized and a [JsonCyclicError] is
    * thrown.
    *
    * Json Objects should not change during serialization.
    * If an object is serialized more than once, [stringify] is allowed to cache
    * the JSON text for it. I.e., if an object changes after it is first
    * serialized, the new values may or may not be reflected in the result.
    */
   String convert(Object o) =>
-      _JsonStringifier.stringify(o, _toEncodableFunction);
+      _JsonStringifier.stringify(o, _toEncodableFunction, indent);
 
   /**
    * Starts a chunked conversion.
    *
    * The converter works more efficiently if the given [sink] is a
    * [StringConversionSink].
    *
    * Returns a chunked-conversion sink that accepts at most one object. It is
    * an error to invoke `add` more than once on the returned sink.
    */
   ChunkedConversionSink<Object> startChunkedConversion(Sink<String> sink) {
     if (sink is! StringConversionSink) {
       sink = new StringConversionSink.from(sink);
     }
-    return new _JsonEncoderSink(sink, _toEncodableFunction);
+    return new _JsonEncoderSink(sink, _toEncodableFunction, indent);
   }
 
   // Override the base-classes bind, to provide a better type.
   Stream<String> bind(Stream<Object> stream) => super.bind(stream);
 }
 
 /**
  * Implements the chunked conversion from object to its JSON representation.
  *
  * The sink only accepts one value, but will produce output in a chunked way.
  */
 class _JsonEncoderSink extends ChunkedConversionSink<Object> {
+  final int _indent;
   final Function _toEncodableFunction;
   final StringConversionSink _sink;
   bool _isDone = false;
 
-  _JsonEncoderSink(this._sink, this._toEncodableFunction);
+  _JsonEncoderSink(this._sink, this._toEncodableFunction, this._indent);
 
   /**
    * Encodes the given object [o].
    *
    * It is an error to invoke this method more than once on any instance. While
    * this makes the input effectly non-chunked the output will be generated in
    * a chunked way.
    */
   void add(Object o) {
     if (_isDone) {
       throw new StateError("Only one call to add allowed");
     }
     _isDone = true;
     ClosableStringSink stringSink = _sink.asStringSink();
-    _JsonStringifier.printOn(o, stringSink, _toEncodableFunction);
+    _JsonStringifier.printOn(o, stringSink, _toEncodableFunction, _indent);
     stringSink.close();
   }
 
   void close() { /* do nothing */ }
 }
 
 /**
  * This class parses JSON strings and builds the corresponding objects.
  */
 class JsonDecoder extends Converter<String, Object> {
@@ skipping 83 matching lines @@
   static const int CHAR_f          = 0x66;
   static const int CHAR_n          = 0x6e;
   static const int CHAR_r          = 0x72;
   static const int CHAR_t          = 0x74;
   static const int CHAR_u          = 0x75;
 
   final Function _toEncodable;
   final StringSink _sink;
   final List _seen;
 
-  _JsonStringifier(this._sink, this._toEncodable)
+  factory _JsonStringifier(StringSink sink, Function toEncodable, int indent) {
+    if (indent == null) return new _JsonStringifier._(sink, toEncodable);
+    return new _JsonStringifierPretty(sink, toEncodable, indent);
+  }
+
+  _JsonStringifier._(this._sink, this._toEncodable)
       : this._seen = new List();
 
-  static String stringify(object, toEncodable(object)) {
+  static String stringify(object, toEncodable(object), int indent) {
     if (toEncodable == null) toEncodable = _defaultToEncodable;
     StringBuffer output = new StringBuffer();
-    printOn(object, output, toEncodable);
+    printOn(object, output, toEncodable, indent);
     return output.toString();
   }
 
-  static void printOn(object, StringSink output, toEncodable(object)) {
-    _JsonStringifier stringifier = new _JsonStringifier(output, toEncodable);
-    stringifier.stringifyValue(object);
+  static void printOn(object, StringSink output, toEncodable(object),
+      int indent) {
+    new _JsonStringifier(output, toEncodable, indent).stringifyValue(object);
   }
 
   static String numberToString(num x) {
     return x.toString();
   }
 
   // ('0' + x) or ('a' + x - 10)
   static int hexDigit(int x) => x < 10 ? 48 + x : 87 + x;
 
   void escape(String s) {
@@ skipping 129 matching lines @@
       return false;
     }
   }
 
   void _removeSeen(object) {
     assert(!_seen.isEmpty);
     assert(identical(_seen.last, object));
     _seen.removeLast();
   }
 }
+
+
+class _JsonStringifierPretty extends _JsonStringifier {
+
+  final String _indent;
+
+  int _indentLevel = 0;
+
+  _JsonStringifierPretty(_sink, _toEncodable, int indent)
+      : this._indent = _getIndent(indent),
+        super._(_sink, _toEncodable);
+
+  static String _getIndent(int indent) {
+    if (indent < 0) throw new ArgumentError('indent cannot be negative');
+    return ' ' * indent;
+  }
+
+  void _write([String value = '']) {
+    _sink.write(_indent * _indentLevel);
+    _sink.write(value);
+  }
+
+  /**
+   * Serializes a [num], [String], [bool], [Null], [List] or [Map] value.
+   *
+   * Returns true if the value is one of these types, and false if not.
+   * If a value is both a [List] and a [Map], it's serialized as a [List].
+   */
+  bool stringifyJsonValue(final object) {
+    if (object is List) {
+      checkCycle(object);
+      List a = object;
+      if (a.isEmpty) {
+        _sink.write('[]');
+      } else {
+        _sink.writeln('[');
+        _indentLevel++;
+        _write();
+        stringifyValue(a[0]);
+        for (int i = 1; i < a.length; i++) {
+          _sink.writeln(',');
+          _write();
+          stringifyValue(a[i]);
+        }
+        _sink.writeln();
+        _indentLevel--;
+        _write(']');
+      }
+      _seen.remove(object);
+      return true;
+    } else if (object is Map) {
+      checkCycle(object);
+      Map<String, Object> m = object;
+      if (m.isEmpty) {
+        _sink.write('{}');
+      } else {
+        _sink.write('{');
+        _sink.writeln();
+        _indentLevel++;
+        bool first = true;
+        m.forEach((String key, Object value) {
+          if (!first) {
+            _sink.writeln(',');
+          }
+          _write('"');
+          escape(key);
+          _sink.write('": ');
+          stringifyValue(value);
+          first = false;
+        });
+        _sink.writeln();
+        _indentLevel--;
+        _write('}');
+      }
+      _seen.remove(object);
+      return true;
+    }
+    return super.stringifyJsonValue(object);
+  }
+}