pkg/serialization: add format param to Serialization.read method

pkg/serialization/test/serialization_test.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.
 
 library serialization_test;
 
 import 'dart:json' as json;
 import 'package:unittest/unittest.dart';
 import 'package:serialization/serialization.dart';
 import 'package:serialization/src/serialization_helpers.dart';
@@ skipping 279 matching lines @@
     var s = new Serialization.blank()
       // Add the rules in a deliberately unusual order.
       ..addRuleFor(new Node(''), constructorFields: ['name'])
       ..addRule(new ListRule())
       ..addRule(new PrimitiveRule())
       ..selfDescribing = false;
     var meta = metaSerialization();
     var metaWithMaps = metaSerializationUsingMaps();
     for (var eachFormat in formats) {
       for (var eachMeta in [meta, metaWithMaps]) {
-        var serialized = eachMeta.write(s, eachFormat);
-        var reader = new Reader(eachMeta, eachFormat);
-        var newSerialization = reader.read(serialized,
-           {"serialization_test.Node" : reflect(new Node('')).type});
+        var serialized = eachMeta.write(s, format: eachFormat);
+        var newSerialization = eachMeta.read(serialized, format: eachFormat,
+            externals: {"serialization_test.Node" : reflect(new Node('')).type}
+        );
         runRoundTripTest((x) => newSerialization);
       }
     }
   });
 
   test("Verify we're not serializing lists twice if they're essential", () {
     Node n1 = new Node("1"), n2 = new Node("2"), n3 = new Node("3");
     n1.children = [n2, n3];
     n2.parent = n1;
     n3.parent = n1;
@@ skipping 18 matching lines @@
   test('Identity of equal objects preserved', () {
     Node n1 = new NodeEqualByName("foo"),
          n2 = new NodeEqualByName("foo"),
          n3 = new NodeEqualByName("3");
     n1.children = [n2, n3];
     n2.parent = n1;
     n3.parent = n1;
     var s = new Serialization()
       ..selfDescribing = false
       ..addRuleFor(n1, constructorFields: ["name"]);
-    var w = new Writer(s);
-    var r = new Reader(s);
-    var m1 = r.read(w.write(n1));
+    var m1 = writeAndReadBack(s, null, n1);
     var m2 = m1.children.first;
     var m3 = m1.children.last;
     expect(m1, m2);
     expect(identical(m1, m2), isFalse);
     expect(m1 == m3, isFalse);
     expect(identical(m2.parent, m3.parent), isTrue);
   });
 
   test("Constant values as fields", () {
     var s = new Serialization()
@@ skipping 75 matching lines @@
   test("Root is a Map", () {
     // Note that we can't use the usual round-trip test because it has cycles.
     var p1 = new Person()..name = 'Alice'..address = a1;
     // Use maps for one rule, lists for the other.
     var s = new Serialization()
       ..addRuleFor(a1)
       ..addRuleFor(p1).configureForMaps();
     for (var eachFormat in formats) {
       var w = s.newWriter(eachFormat);
       var output = w.write({"stuff" : p1});
-      var r = s.newReader(w.format);
-      var result = r.read(output);
+      var result = s.read(output, format: w.format);

[Alan Knight, 2013/06/26 19:26:29]

I would say to leave a couple of these cases using newReader and newWriter so
that those APIs still get exercised.

       var p2 = result["stuff"];
       expect(p2.name, "Alice");
       var a2 = p2.address;
       expect(a2.street, "N 34th");
       expect(a2.city, "Seattle");
     }
   });
 
   test("Root is a List", () {
     var s = new Serialization();
@@ skipping 23 matching lines @@
   test("Simple JSON format, round-trip with named objects", () {
     // Note that we can't use the usual round-trip test because it has cycles.
     var p1 = new Person()..name = 'Alice'..address = a1;
     // Use maps for one rule, lists for the other.
     var s = new Serialization()
       ..selfDescribing = false
       ..addRule(new NamedObjectRule())
       ..addRuleFor(a1)
       ..addRuleFor(p1).configureForMaps()
       ..namedObjects["foo"] = a1;
-    var writer = s.newWriter(const SimpleJsonFormat(storeRoundTripInfo: true));
-    var out = writer.write(p1);
-    var reader = s.newReader(const SimpleJsonFormat(storeRoundTripInfo: true));
-    var p2 = reader.read(out, {"foo" : 12});
+    var format = const SimpleJsonFormat(storeRoundTripInfo: true);
+    var out = s.write(p1, format: format);
+    var p2 = s.read(out, format: format, externals: {"foo" : 12});
     expect(p2.name, "Alice");
     var a2 = p2.address;
     expect(a2, 12);
   });
 
   test("More complicated Maps", () {
     var s = new Serialization()..selfDescribing = false;
     var p1 = new Person()..name = 'Alice'..address = a1;
     var data = new Map();
     data["simple data"] = 1;
     data[p1] = a1;
     data[a1] = p1;
     for (var eachFormat in formats) {
-      var output = s.write(data, eachFormat);
-      var reader = s.newReader(eachFormat);
-      var input = reader.read(output);
+      var output = s.write(data, format: eachFormat);
+      var input = s.read(output, format: eachFormat);
       expect(input["simple data"], data["simple data"]);
       var p2 = input.keys.firstWhere((x) => x is Person);
       var a2 = input.keys.firstWhere((x) => x is Address);
       if (eachFormat is SimpleJsonFormat) {
         // JSON doesn't handle cycles, so these won't be identical.
         expect(input[p2] is Address, isTrue);
         expect(input[a2] is Person, isTrue);
         var a3 = input[p2];
         expect(a3.city, a2.city);
         expect(a3.state, a2.state);
         expect(a3.state, a2.state);
         var p3 = input[a2];
         expect(p3.name, p2.name);
         expect(p3.rank, p2.rank);
         expect(p3.address.city, a2.city);
       } else {
         expect(input[p2], same(a2));
         expect(input[a2], same(p2));
       }
     }
   });
 
   test("Map with string keys stays that way", () {
     var s = new Serialization()..addRuleFor(new Person());
     var data = {"abc" : 1, "def" : "ghi"};
     data["person"] = new Person()..name = "Foo";
-    var output = s.write(data, const InternalMapFormat());
+    var output = s.write(data, format: const InternalMapFormat());
     var mapRule = s.rules.firstWhere((x) => x is MapRule);
     var map = output["data"][mapRule.number][0];
     expect(map is Map, isTrue);
     expect(map["abc"], 1);
     expect(map["def"], "ghi");
     expect(map["person"] is Reference, isTrue);
   });
 
   test("MirrorRule with lookup by qualified name rather than named object", () {
     var s = new Serialization()..addRule(new MirrorRule());
@@ skipping 14 matching lines @@
       var port = spawnFunction(echo);
       return port.call(output).then(verify);
   });
 }
 
 /**
  * Verify serialized output that we have passed to an isolate and back.
  */
 void verify(input) {
   var s2 = nodeSerializerReflective(new Node("a"));
-  var reader = new Reader(s2);
-  var m2 = reader.read(input);
+  var m2 = s2.read(input);
   var m1 = m2.parent;
   expect(m1 is Node, isTrue);
   var children = m1.children;
   expect(m1.name,"1");
   var m3 = m1.children.last;
   expect(m2.name, "2");
   expect(m3.name, "3");
   expect(m2.parent, m1);
   expect(m3.parent, m1);
   expect(m1.parent, isNull);
 }
 
 /******************************************************************************
  * The end of the tests and the beginning of various helper functions to make
  * it easier to write the repetitive sections.
  ******************************************************************************/
 
 writeAndReadBack(Serialization s, Format format, object) {
-  var w = s.newWriter(format);
-  var output = w.write(object);
-  var r = s.newReader(w.format);
-  return r.read(output);
+  var output = s.write(object, format: format);
+  return s.read(output, format: format);
 }
 
 /** Create a Serialization for serializing Serializations. */
 Serialization metaSerialization() {
   // Make some bogus rule instances so we have something to feed rule creation
   // and get their types. If only we had class literals implemented...
   var basicRule = new BasicRule(reflect(null).type, '', [], [], []);
 
   var meta = new Serialization()
     ..selfDescribing = false
@@ skipping 119 matching lines @@
  * that's returned by the [serializerSetUp] function.
  */
 void runRoundTripTest(Function serializerSetUp) {
   Node n1 = new Node("1"), n2 = new Node("2"), n3 = new Node("3");
   n1.children = [n2, n3];
   n2.parent = n1;
   n3.parent = n1;
   var s = serializerSetUp(n1);
   var output = s.write(n2);
   var s2 = serializerSetUp(n1);
-  var reader = new Reader(s2);
-  var m2 = reader.read(output);
+  var m2 = s2.read(output);
   var m1 = m2.parent;
   expect(m1 is Node, isTrue);
   var children = m1.children;
   expect(m1.name,"1");
   var m3 = m1.children.last;
   expect(m2.name, "2");
   expect(m3.name, "3");
   expect(m2.parent, m1);
   expect(m3.parent, m1);
   expect(m1.parent, isNull);
 }
 
 /**
  * Run a round-trip test on a simple of nodes, but using the flat format
  * rather than the maps.
  */
 void runRoundTripTestFlat(serializerSetUp) {
   Node n1 = new Node("1"), n2 = new Node("2"), n3 = new Node("3");
   n1.children = [n2, n3];
   n2.parent = n1;
   n3.parent = n1;
   var s = serializerSetUp(n1);
-  var output = s.write(n2, const SimpleFlatFormat());
+  var output = s.write(n2, format: const SimpleFlatFormat());
   expect(output is List, isTrue);
   var s2 = serializerSetUp(n1);
-  var reader = new Reader(s2, const SimpleFlatFormat());
-  var m2 = reader.read(output);
+  var m2 = s2.read(output, format: const SimpleFlatFormat());
   var m1 = m2.parent;
   expect(m1 is Node, isTrue);
   var children = m1.children;
   expect(m1.name,"1");
   var m3 = m1.children.last;
   expect(m2.name, "2");
   expect(m3.name, "3");
   expect(m2.parent, m1);
   expect(m3.parent, m1);
   expect(m1.parent, isNull);
@@ skipping 46 matching lines @@
 
 /**
  * Function used in an isolate to make sure that the output passes through
  * isolate serialization properly.
  */
 void echo() {
   port.receive((msg, reply) {
     reply.send(msg);
   });
 }