Make JSON encoder take extra function argument to use instead of toJson calls.

sdk/lib/json/json.dart

 // Copyright (c) 2012, 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.
 
 /**
  * Utilities for encoding and decoding JSON (JavaScript Object Notation) data.
  */
 
 library dart.json;
 
 import "dart:convert";
+import "dart:collection" show HashSet;
 export "dart:convert" show JsonUnsupportedObjectError, JsonCyclicError;
 
 // JSON parsing and serialization.
 
 /**
  * Parses [json] and build the corresponding parsed JSON value.
  *
  * Parsed JSON values are of the types [num], [String], [bool], [Null],
  * [List]s of parsed JSON values or [Map]s from [String] to parsed
  * JSON values.
@@ skipping 15 matching lines @@
 }
 
 /**
  * Serializes [object] into a JSON string.
  *
  * 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, a "toJson()" method
- * is invoked on the object and the result, which must be a directly
- * serializable value, is serialized instead of the original value.
+ * If a value is any other type is attempted serialized, the [convert] method
+ * is called with the object as argument, and the result, which must be a
+ * directly serializable value, is serialized instead of the original value.
+ * If [convert] is omitted, the default is to call `object.toJson()` on the
+ * object.
  *
- * If the object does not support this method, throws, or returns a
- * value that is not directly serializable, a [JsonUnsupportedObjectError]
- * exception is thrown. If the call throws (including the case where there
- * is no nullary "toJson" method, the error is caught and stored in the
+ * If the conversion throws, or returns a value that is not directly
+ * serializable, a [JsonUnsupportedObjectError] exception is thrown.
+ * If the call throws (including the case where there
+ * is no nullary "toJson" method), 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.
+ * The objects being serialized 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 stringify(Object object) {
-  return _JsonStringifier.stringify(object);
+String stringify(Object object, [convert(object)]) {

[floitsch, 2013/10/04 15:25:08]

You don't have the latest version (which now has deprecation notices).

But you should copy your changes into the json-package.

[Lasse Reichstein Nielsen, 2013/10/07 12:46:59]

Merging .... please hold. :)

I don't want to support the json package with new functionality.
We moved it to a package in case someone was using it, but that was mainly for
the custom parser, not the stringifier. Eventually we could make the stringifier
in pkg/json use the convert library instead.

I changed the lib/json version because that's the one we use in convert, and the
one we'll eventually move into the convert library when we drop the json
library.

New users of the json library at this time will know it's deprecated, and can
use the convert library instead.

+  if (convert == null) convert = _defaultConvert;
+  return _JsonStringifier.stringify(object, convert);
 }
 
 /**
  * Serializes [object] into [output] stream.
  *
  * Performs the same operations as [stringify] but outputs the resulting
  * string to an existing [StringSink] instead of creating a new [String].
  *
  * If serialization fails by throwing, some data might have been added to
  * [output], but it won't contain valid JSON text.
  */
-void printOn(Object object, StringSink output) {
-  return _JsonStringifier.printOn(object, output);
+void printOn(Object object, StringSink output, [ convert(object) ]) {
+  if (convert == null) convert = _defaultConvert;
+  return _JsonStringifier.printOn(object, output, convert);
 }
 
 //// Implementation ///////////////////////////////////////////////////////////
 
 // Simple API for JSON parsing.
 
 abstract class JsonListener {
   void handleString(String value) {}
   void handleNumber(num value) {}
   void handleBool(bool value) {}
@@ skipping 525 matching lines @@
     int sliceEnd = position + 20;
     if (sliceEnd > source.length) {
       slice = "'${source.substring(position)}'";
     } else {
       slice = "'${source.substring(position, sliceEnd)}...'";
     }
     throw new FormatException("Unexpected character at $position: $slice");
   }
 }
 
+Object _defaultConvert(object) => object.toJson();
 
 class _JsonStringifier {
-  StringSink sink;
-  List<Object> seen;  // TODO: that should be identity set.
+  final Function converter;
+  final StringSink sink;
+  final Set<Object> seen;
 
-  _JsonStringifier(this.sink) : seen = [];
+  _JsonStringifier(this.sink, this.converter)
+      : this.seen = new HashSet.identity();
 
-  static String stringify(final object) {
+  static String stringify(final object, convert(object)) {
     StringBuffer output = new StringBuffer();
-    _JsonStringifier stringifier = new _JsonStringifier(output);
+    _JsonStringifier stringifier = new _JsonStringifier(output, convert);
     stringifier.stringifyValue(object);
     return output.toString();
   }
 
-  static void printOn(final object, StringSink output) {
-    _JsonStringifier stringifier = new _JsonStringifier(output);
+  static void printOn(final object, StringSink output, convert(object)) {
+    _JsonStringifier stringifier = new _JsonStringifier(output, convert);
     stringifier.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;
 
@@ skipping 36 matching lines @@
         charCodes.add(JsonParser.BACKSLASH);
         charCodes.add(charCode);
       } else {
         charCodes.add(charCode);
       }
     }
     sb.write(needsEscape ? new String.fromCharCodes(charCodes) : s);
   }
 
   void checkCycle(final object) {
-    // TODO: use Iterables.
-    for (int i = 0; i < seen.length; i++) {
-      if (identical(seen[i], object)) {
-        throw new JsonCyclicError(object);
-      }
+    if (seen.contains(object)) {
+      throw new JsonCyclicError(object);
     }
     seen.add(object);
   }
 
   void stringifyValue(final object) {
     // Tries stringifying object directly. If it's not a simple value, List or
     // Map, call toJson() to get a custom representation and try serializing
     // that.
     if (!stringifyJsonValue(object)) {
       checkCycle(object);
       try {
-        var customJson = object.toJson();
+        var customJson = converter(object);
         if (!stringifyJsonValue(customJson)) {
           throw new JsonUnsupportedObjectError(object);
         }
-        seen.removeLast();
+        seen.remove(object);
       } catch (e) {
         throw new JsonUnsupportedObjectError(object, cause: e);
       }
     }
   }
 
   /**
    * Serializes a [num], [String], [bool], [Null], [List] or [Map] value.
    *
    * Returns true if the value is one of these types, and false if not.
@@ skipping 24 matching lines @@
       sink.write('[');
       if (a.length > 0) {
         stringifyValue(a[0]);
         // TODO: switch to Iterables.
         for (int i = 1; i < a.length; i++) {
           sink.write(',');
           stringifyValue(a[i]);
         }
       }
       sink.write(']');
-      seen.removeLast();
+      seen.remove(object);
       return true;
     } else if (object is Map) {
       checkCycle(object);
       Map<String, Object> m = object;
       sink.write('{');
       bool first = true;
       m.forEach((String key, Object value) {
         if (!first) {
           sink.write(',"');
         } else {
           sink.write('"');
         }
         escape(sink, key);
         sink.write('":');
         stringifyValue(value);
         first = false;
       });
       sink.write('}');
-      seen.removeLast();
+      seen.remove(object);
       return true;
     } else {
       return false;
     }
   }
 }