Change reflective serialization rules to be able to take type literals

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';
 import 'package:serialization/src/mirrors_helpers.dart';
 import 'dart:isolate';
 
 part 'test_models.dart';
 
 void main() {
   var p1 = new Person();
   var a1 = new Address();
   a1.street = 'N 34th';
   a1.city = 'Seattle';
 
   var formats = [const InternalMapFormat(),
                  const SimpleFlatFormat(), const SimpleMapFormat(),
                  const SimpleJsonFormat(storeRoundTripInfo: true)];
 
   test('Basic extraction of a simple object', () {
     // TODO(alanknight): Switch these to use literal types. Issue
     var s = new Serialization()
-        ..addRuleFor(a1).configureForMaps();
+        ..addRuleFor(Address).configureForMaps();
     Map extracted = states(a1, s).first;
     expect(extracted.length, 4);
     expect(extracted['street'], 'N 34th');
     expect(extracted['city'], 'Seattle');
     expect(extracted['state'], null);
     expect(extracted['zip'], null);
     Reader reader = setUpReader(s, extracted);
     Address a2 = readBackSimple(s, a1, reader);
     expect(a2.street, 'N 34th');
     expect(a2.city, 'Seattle');
     expect(a2.state,null);
     expect(a2.zip, null);
   });
 
   test('Slightly further with a simple object', () {
     var p1 = new Person()..name = 'Alice'..address = a1;
     var s = new Serialization()
-        ..addRuleFor(p1).configureForMaps()
-        ..addRuleFor(a1).configureForMaps();
+        ..addRuleFor(Person).configureForMaps()
+        ..addRuleFor(Address).configureForMaps();
     // TODO(alanknight): Need a better API for getting to flat state without
     // actually writing.
     var w = new Writer(s, const InternalMapFormat());
     w.write(p1);
     var personRule = s.rules.firstWhere(
         (x) => x is BasicRule && x.type == reflect(p1).type);
     var flatPerson = w.states[personRule.number].first;
     var primStates = w.states.first;
     expect(primStates.isEmpty, true);
     expect(flatPerson["name"], "Alice");
     var ref = flatPerson["address"];
     expect(ref is Reference, true);
     var addressRule = s.rules.firstWhere(
         (x) => x is BasicRule && x.type == reflect(a1).type);
     expect(ref.ruleNumber, addressRule.number);
     expect(ref.objectNumber, 0);
     expect(w.states[addressRule.number].first['street'], 'N 34th');
   });
 
   test('exclude fields', () {
     var s = new Serialization()
-        ..addRuleFor(a1,
+        ..addRuleFor(Address,
             excludeFields: ['state', 'zip']).configureForMaps();
     var extracted = states(a1, s).first;
     expect(extracted.length, 2);
     expect(extracted['street'], 'N 34th');
     expect(extracted['city'], 'Seattle');
     Reader reader = setUpReader(s, extracted);
     Address a2 = readBackSimple(s, a1, reader);
     expect(a2.state, null);
     expect(a2.city, 'Seattle');
   });
@@ skipping 10 matching lines @@
     var list2 = readBackSimple(s, list, reader);
     expect(list, list2);
   });
 
   test('different kinds of fields', () {
     var x = new Various.Foo("d", "e");
     x.a = "a";
     x.b = "b";
     x._c = "c";
     var s = new Serialization()
-      ..addRuleFor(x,
+      ..addRuleFor(Various,
           constructor: "Foo",
           constructorFields: ["d", "e"]);
     var state = states(x, s).first;
     expect(state.length, 4);
     var expected = "abde";
     for (var i in [0,1,2,3]) {
       expect(state[i], expected[i]);
     }
     Reader reader = setUpReader(s, state);
     Various y = readBackSimple(s, x, reader);
@@ skipping 14 matching lines @@
     expect((stream..next()).next(), 4);
     expect(stream.position, 2);
     // The Symbol class does not allow us to create symbols for private
     // variables. However, the mirror system uses them. So we get the symbol
     // we want from the mirror.
     // TODO(alanknight): Either delete this test and decide we shouldn't
     // attempt to access private variables or fix this properly.
     var _collectionSym = reflect(stream).type.variables.keys.firstWhere(
         (x) => MirrorSystem.getName(x) == "_collection");
     var s = new Serialization()
-      ..addRuleFor(stream,
+      ..addRuleFor(Stream,
           constructorFields: [_collectionSym]);
     var state = states(stream, s).first;
     // Define names for the variable offsets to make this more readable.
     var _collection = 0, position = 1;
     expect(state[_collection],[3,4,5]);
     expect(state[position], 2);
   });
 
   test('date', () {
     var date = new DateTime.now();
@@ skipping 135 matching lines @@
   test('round-trip with Node CustomRule, to maps', () {
     runRoundTripTest(nodeSerializerCustom);
   });
 
   test('eating your own tail', () {
     // Create a meta-serializer, that serializes serializations, then
     // use it to serialize a basic serialization, then run a test on the
     // the result.
     var s = new Serialization.blank()
       // Add the rules in a deliberately unusual order.
-      ..addRuleFor(new Node(''), constructorFields: ['name'])
+      ..addRuleFor(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, 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;
     var s = new Serialization()
-      ..addRuleFor(n1, constructorFields: ["name"]).
+      ..addRuleFor(Node, constructorFields: ["name"]).
           setFieldWith("children", (parent, child) =>
               parent.reflectee.children = child);
     var w = new Writer(s);
     w.write(n1);
     expect(w.rules[2] is ListRuleEssential, isTrue);
     expect(w.rules[1] is ListRule, isTrue);
     expect(w.states[1].length, 0);
     expect(w.states[2].length, 1);
     s = new Serialization()
-      ..addRuleFor(n1, constructorFields: ["name"]);
+      ..addRuleFor(Node, constructorFields: ["name"]);
     w = new Writer(s);
     w.write(n1);
     expect(w.states[1].length, 1);
     expect(w.states[2].length, 0);
   });
 
   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"]);
+      ..addRuleFor(NodeEqualByName, constructorFields: ["name"]);
     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()
       ..selfDescribing = false
-      ..addRuleFor(a1,
+      ..addRuleFor(Address,
           constructor: 'withData',
           constructorFields: ["street", "Kirkland", "WA", "98103"],
           fields: []);
     var out = s.write(a1);
     var newAddress = s.read(out);
     expect(newAddress.street, a1.street);
     expect(newAddress.city, "Kirkland");
     expect(newAddress.state, "WA");
     expect(newAddress.zip, "98103");
   });
 
   test("Straight JSON format", () {
     var s = new Serialization();
     var writer = s.newWriter(const SimpleJsonFormat());
     var out = json.stringify(writer.write(a1));
     var reconstituted = json.parse(out);
     expect(reconstituted.length, 4);
     expect(reconstituted[0], "Seattle");
   });
 
   test("Straight JSON format, nested objects", () {
     var p1 = new Person()..name = 'Alice'..address = a1;
     var s = new Serialization()..selfDescribing = false;
-    var addressRule = s.addRuleFor(a1)..configureForMaps();
-    var personRule = s.addRuleFor(p1)..configureForMaps();
+    var addressRule = s.addRuleFor(Address)..configureForMaps();
+    var personRule = s.addRuleFor(Person)..configureForMaps();
     var writer = s.newWriter(const SimpleJsonFormat(storeRoundTripInfo: true));
     var out = json.stringify(writer.write(p1));
     var reconstituted = json.parse(out);
     var expected = {
       "name" : "Alice",
       "rank" : null,
       "serialNumber" : null,
       "_rule" : personRule.number,
       "address" : {
         "street" : "N 34th",
         "city" : "Seattle",
         "state" : null,
         "zip" : null,
         "_rule" : addressRule.number
       }
     };
     expect(expected, reconstituted);
   });
 
   test("Straight JSON format, round-trip", () {
     // 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();
+      ..addRuleFor(Address)
+      ..addRuleFor(Person).configureForMaps();
     var p2 = writeAndReadBack(s,
         const SimpleJsonFormat(storeRoundTripInfo: true), p1);
     expect(p2.name, "Alice");
     var a2 = p2.address;
     expect(a2.street, "N 34th");
     expect(a2.city, "Seattle");
   });
 
   test("Straight JSON format, non-string key", () {
     // This tests what happens if we have a key that's not a string. That's
     // not allowed by json, so we don't actually turn it into a json string,
     // but someone might reasonably convert to a json-able structure without
     // going through the string representation.
     var p1 = new Person()..name = 'Alice'..address = a1;
     var s = new Serialization()
         ..addRule(new PersonRuleReturningMapWithNonStringKey());
     var p2 = writeAndReadBack(s,
         const SimpleJsonFormat(storeRoundTripInfo: true), p1);
     expect(p2.name, "Alice");
     expect(p2.address.street, "N 34th");
   });
 
   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()
+      // Deliberately left as passing instances to test backward-compatibility.
       ..addRuleFor(a1)
       ..addRuleFor(p1).configureForMaps();
     for (var eachFormat in formats) {
       var w = s.newWriter(eachFormat);
       var output = w.write({"stuff" : p1});
       var result = s.read(output, format: w.format);
       var p2 = result["stuff"];
       expect(p2.name, "Alice");
       var a2 = p2.address;
       expect(a2.street, "N 34th");
@@ skipping 26 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()
+      ..addRuleFor(Address)
+      ..addRuleFor(Person).configureForMaps()
       ..namedObjects["foo"] = a1;
     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", () {
@@ skipping 22 matching lines @@
         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 s = new Serialization()..addRuleFor(Person);
     var data = {"abc" : 1, "def" : "ghi"};
     data["person"] = new Person()..name = "Foo";
     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);
   });
@@ skipping 48 matching lines @@
 }
 
 /** 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
-    ..addRuleFor(new ListRule())
-    ..addRuleFor(new PrimitiveRule())
+    ..addRuleFor(ListRule)
+    ..addRuleFor(PrimitiveRule)
     // TODO(alanknight): Handle CustomRule as well.
     // Note that we're passing in a constant for one of the fields.
-    ..addRuleFor(basicRule,
+    ..addRuleFor(BasicRule,
         constructorFields: ['type',
           'constructorName',
           'constructorFields', 'regularFields', []],
         fields: [])
-     ..addRuleFor(new Serialization(), constructor: "blank")
+     ..addRuleFor(Serialization, constructor: "blank")
          .setFieldWith('rules',
            (InstanceMirror s, List rules) {
              rules.forEach((x) => s.reflectee.addRule(x));
            })
     ..addRule(new NamedObjectRule())
     ..addRule(new MirrorRule())
     ..addRule(new MapRule());
   return meta;
 }
 
@@ skipping 29 matching lines @@
   for (int i = 0; i < 10; i++) {
     data.add(fillValue);
   }
   reader.data = data;
   return reader;
 }
 
 /** Return a serialization for Node objects, using a reflective rule. */
 Serialization nodeSerializerReflective(Node n) {
   return new Serialization()
-    ..addRuleFor(n, constructorFields: ["name"])
+    ..addRuleFor(Node, constructorFields: ["name"])
     ..namedObjects['Node'] = reflect(new Node('')).type;
 }
 
 /**
  * Return a serialization for Node objects but using Maps for the internal
  * representation rather than lists.
  */
 Serialization nodeSerializerUsingMaps(Node n) {
   return new Serialization()
-    ..addRuleFor(n, constructorFields: ["name"]).configureForMaps()
+    // Get the type using runtimeType to verify that works.
+    ..addRuleFor(n.runtimeType, constructorFields: ["name"]).configureForMaps()
     ..namedObjects['Node'] = reflect(new Node('')).type;
 }
 
 /**
  * Return a serialization for Node objects but using Maps for the internal
  * representation rather than lists.
  */
 Serialization nodeSerializerCustom(Node n) {
   return new Serialization()
     ..addRule(new NodeRule());
 }
 
 /**
  * Return a serialization for Node objects where the "parent" instance
  * variable is considered essential state.
  */
 Serialization nodeSerializerWithEssentialParent(Node n) {
   // Force the node rule to be first, in order to make a cycle which would
   // not cause a problem if we handled the list first, because the list
   // considers all of its state non-essential, thus breaking the cycle.
   var s = new Serialization.blank()
     ..addRuleFor(
-        n,
+        Node,
         constructor: "parentEssential",
         constructorFields: ["parent"])
     ..addDefaultRules()
     ..namedObjects['Node'] = reflect(new Node('')).type
     ..selfDescribing = false;
   return s;
 }
 
 /** Return a serialization for Node objects using a ClosureToMapRule. */
 Serialization nodeSerializerNonReflective(Node n) {
@@ skipping 109 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);
   });
 }