Add a MapRule

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 29 matching lines @@
     // TODO(alanknight): Tests that rely on what index rules are going to be
     // at are very fragile. At least abstract it to something calculated.
     var p1 = new Person()..name = 'Alice'..address = a1;
     var s = new Serialization()
         ..addRuleFor(p1).configureForMaps()
         ..addRuleFor(a1).configureForMaps();
     // TODO(alanknight): Need a better API for getting to flat state without
     // actually writing.
     var w = new Writer(s);
     w.write(p1);
-    var flatPerson = w.states[3].first;
+    var personRule = s.rules.firstMatching(
+        (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);
-    expect(ref.ruleNumber, 4);
+    var addressRule = s.rules.firstMatching(
+        (x) => x is BasicRule && x.type == reflect(a1).type);
+    expect(ref.ruleNumber, addressRule.number);
     expect(ref.objectNumber, 0);
-    expect(w.states[4].first['street'], 'N 34th');
+    expect(w.states[addressRule.number].first['street'], 'N 34th');
   });
 
   test('exclude fields', () {
     var s = new Serialization()
         ..addRuleFor(a1,
             excludeFields: ['state', 'zip']).configureForMaps();
     var extracted = states(a1, s).first;
     expect(extracted.length, 2);
     expect(extracted['street'], 'N 34th');
     expect(extracted['city'], 'Seattle');
@@ skipping 130 matching lines @@
     expect(all.contains(n2), isTrue);
     expect(all.contains(n3), isTrue);
     expect(all.contains(n1.children), isTrue);
   });
 
   test('Flatten references in a cyclical structure', () {
     var s = new Serialization();
     var w = new Writer(s);
     w.trace = new Trace(w);
     w.write(n1);
-    expect(w.states.length, 4); // prims, lists, essential lists, basic
+    expect(w.states.length, 5); // prims, lists, essential lists, basic
     var children = 0, name = 1, parent = 2;
-    List rootNode = w.states[3].where((x) => x[name] == "1").toList();
+    var nodeRule = s.rules.firstMatching((x) => x is BasicRule);
+    List rootNode = w.states[nodeRule.number].where(
+        (x) => x[name] == "1").toList();
     rootNode = rootNode.first;
     expect(rootNode[parent], isNull);
     var list = w.states[1].first;
     expect(w.stateForReference(rootNode[children]), list);
     var parentNode = w.stateForReference(list[0])[parent];
     expect(w.stateForReference(parentNode), rootNode);
   });
 
   test('round-trip', () {
     runRoundTripTest(nodeSerializerReflective);
@@ skipping 143 matching lines @@
     var writer = s.newWriter(new SimpleJsonFormat(storeRoundTripInfo: true));
     var out = writer.write(p1);
     var reader = s.newReader(new SimpleJsonFormat(storeRoundTripInfo: true));
     var p2 = reader.read(out);
     expect(p2.name, "Alice");
     var a2 = p2.address;
     expect(a2.street, "N 34th");
     expect(a2.city, "Seattle");
   });
 
+  test("Straight JSON format, 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();
+    var format = new SimpleJsonFormat(storeRoundTripInfo: true);
+    var writer = s.newWriter(format);
+    var out = writer.write({"stuff" : p1});
+    var reader = s.newReader(format);
+    var p2 = reader.read(out)["stuff"];
+    expect(p2.name, "Alice");
+    var a2 = p2.address;
+    expect(a2.street, "N 34th");
+    expect(a2.city, "Seattle");
+  });
+
+
   test("Straight 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()
       ..addRule(new NamedObjectRule())
       ..addRuleFor(a1)
       ..addRuleFor(p1).configureForMaps()
       ..namedObjects["foo"] = a1;
     var writer = s.newWriter(new SimpleJsonFormat(storeRoundTripInfo: true));
     var out = writer.write(p1);
     var reader = s.newReader(new SimpleJsonFormat(storeRoundTripInfo: true));
     var p2 = reader.read(out, {"foo" : 12});
     expect(p2.name, "Alice");
     var a2 = p2.address;
     expect(a2, 12);
   });
+
+  test("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;
+    var formats = [new SimpleFlatFormat(), new SimpleMapFormat(),
+        new SimpleJsonFormat(storeRoundTripInfo: true)];
+    for (var eachFormat in formats) {
+      var output = s.write(data, eachFormat);
+      var reader = s.newReader(eachFormat);
+      var input = reader.read(output);
+      expect(input["simple data"], data["simple data"]);
+      var p2 = input.keys.firstMatching((x) => x is Person);
+      var a2 = input.keys.firstMatching((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, new SimpleMapFormat());
+    var mapRule = s.rules.firstMatching((x) => x is MapRule);
+    var map = json.parse(output)["data"][mapRule.number][0];
+    expect(map is Map, isTrue);
+    expect(map["abc"], 1);
+    expect(map["def"], "ghi");
+    expect(new Reader(s).asReference(map["person"]) is Reference, isTrue);
+  });
 }
 
 /******************************************************************************
  * The end of the tests and the beginning of various helper functions to make
  * it easier to write the repetitive sections.
  ******************************************************************************/
 
 /** 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())
     // TODO(alanknight): Handle CustomRule as well.
     // Note that we're passing in a constant for one of the fields.
     ..addRuleFor(basicRule,
         constructorFields: ['type',
           'constructorName',
           'constructorFields', 'regularFields', []],
         fields: [])
-     ..addRuleFor(new Serialization()).setFieldWith('rules',
-         (InstanceMirror s, List rules) {
+     ..addRuleFor(new Serialization(), constructor: "blank")
+         .setFieldWith('rules',
+           (InstanceMirror s, List rules) {
              rules.forEach((x) => s.reflectee.addRule(x));
-         })
+           })
     ..addRule(new NamedObjectRule())
     ..addRule(new MirrorRule());
   return meta;
 }
 
 /**
  * Read back a simple object, assumed to be the only one of its class in the
  * reader.
  */
 readBackSimple(Serialization s, object, Reader reader) {
   var rule = s.rulesFor(object, null).first;
   reader.inflateForRule(rule);
   var list2 = reader.allObjectsForRule(rule).first;
   return list2;
 }
 
 /**
  * Set up a basic reader with some fake data. Hard-codes the assumption
  * of how many rules there are.
  */
 Reader setUpReader(aSerialization, sampleData) {
   var reader = new Reader(aSerialization);
   // We're not sure which rule needs the sample data, so put it everywhere
   // and trust that the extra will just be ignored.
-  reader.data = [[sampleData], [sampleData], [sampleData], [sampleData]];
+  reader.data = new List.filled(10, [sampleData]);
   return reader;
 }
 
 /** Return a serialization for Node objects, using a reflective rule. */
 Serialization nodeSerializerReflective(Node n) {
   return new Serialization()
     ..addRuleFor(n, constructorFields: ["name"])
     ..namedObjects['Node'] = reflect(new Node('')).type;
 }
 
@@ skipping 112 matching lines @@
 
 /** A hard-coded rule for serializing Node instances. */
 class NodeRule extends CustomRule {
   bool appliesTo(instance, _) => instance.runtimeType == Node;
   getState(instance) => [instance.parent, instance.name, instance.children];
   create(state) => new Node(state[1]);
   setState(Node node, state) {
     node.parent = state[0];
     node.children = state[2];
   }
-}
+}