Rename XMatching to XWhere.

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 30 matching lines @@
 
   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();
     // TODO(alanknight): Need a better API for getting to flat state without
     // actually writing.
     var w = new Writer(s);
     w.write(p1);
-    var personRule = s.rules.firstMatching(
+    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.firstMatching(
+    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,
             excludeFields: ['state', 'zip']).configureForMaps();
@@ skipping 136 matching lines @@
     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, 5); // prims, lists, essential lists, basic
     var children = 0, name = 1, parent = 2;
-    var nodeRule = s.rules.firstMatching((x) => x is BasicRule);
+    var nodeRule = s.rules.firstWhere((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);
   });
 
@@ skipping 242 matching lines @@
     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);
       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);
+      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, new SimpleMapFormat());
-    var mapRule = s.rules.firstMatching((x) => x is MapRule);
+    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(new Reader(s).asReference(map["person"]) is Reference, isTrue);
   });
 
 }
 
 /******************************************************************************
@@ skipping 223 matching lines @@
   }
   findValue(String key, Map state) {
     var answer;
     for (var each in state.keys) {
       var value = state[each];
       if (value == key) return each;
     }
     return null;
   }
 }