Use boolean selector syntax for tags.

lib/src/backend/metadata.dart

 // Copyright (c) 2015, 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.
 
 import 'dart:collection';
 
+import 'package:boolean_selector/boolean_selector.dart';
 import 'package:collection/collection.dart';
 
 import '../frontend/skip.dart';
 import '../frontend/timeout.dart';
 import '../utils.dart';
 import 'operating_system.dart';
 import 'platform_selector.dart';
 import 'test_platform.dart';
 
 /// Metadata for a test or test suite.
@@ skipping 24 matching lines @@
   /// Each key identifies a platform, and its value identifies the specific
   /// metadata for that platform. These can be applied by calling [forPlatform].
   final Map<PlatformSelector, Metadata> onPlatform;
 
   /// Metadata that applies only when specific tags are applied.
   ///
   /// Tag-specific metadata is applied when merging this with other metadata.
   /// Note that unlike [onPlatform], the base metadata takes precedence over any
   /// tag-specific metadata.
   ///
-  /// This is guaranteed not to have any keys that appear in [tags]; those are
+  /// This is guaranteed not to have any keys that match [tags]; those are
   /// resolved when the metadata is constructed.
-  final Map<String, Metadata> forTag;
+  final Map<BooleanSelector, Metadata> forTag;
 
   /// Parses a user-provided map into the value for [onPlatform].
   static Map<PlatformSelector, Metadata> _parseOnPlatform(
       Map<String, dynamic> onPlatform) {
     if (onPlatform == null) return {};
 
     var result = {};
     onPlatform.forEach((platform, metadata) {
       if (metadata is Timeout || metadata is Skip) {
         metadata = [metadata];
@@ skipping 47 matching lines @@
       throw new ArgumentError.value(tags, "tags", "must contain only Strings.");
     }
 
     return new Set.from(tags);
   }
 
   /// Creates new Metadata.
   ///
   /// [testOn] defaults to [PlatformSelector.all].
   ///
-  /// If [forTag] contains metadata for any tags in [tags], that metadata is
+  /// If [forTag] contains metadata that applies to [tags], that metadata is
   /// included inline in the returned value. The values directly passed to the
   /// constructor take precedence over tag-specific metadata.
   factory Metadata({PlatformSelector testOn, Timeout timeout, bool skip: false,
           bool verboseTrace: false, String skipReason, Iterable<String> tags,
           Map<PlatformSelector, Metadata> onPlatform,
-          Map<String, Metadata> forTag}) {
-    // If there's no tag-specific metadata, or if none of it applies, just
-    // return the metadata as-is.
-    if (forTag == null || tags == null || !tags.any(forTag.containsKey)) {
-      return new Metadata._(
-          testOn: testOn,
-          timeout: timeout,
-          skip: skip,
-          verboseTrace: verboseTrace,
-          skipReason: skipReason,
-          tags: tags,
-          onPlatform: onPlatform,
-          forTag: forTag);
-    }
-
-    // Otherwise, resolve the tag-specific components. Doing this eagerly means
-    // we only have to resolve suite- or group-level tags once, rather than
-    // doing it for every test individually.
-    forTag = new Map.from(forTag);
-    var merged = tags.fold(new Metadata._(), (merged, tag) {
-      var tagMetadata = forTag.remove(tag);
-      return tagMetadata == null ? merged : merged.merge(tagMetadata);
-    });
-
-    return merged.merge(new Metadata._(
+          Map<BooleanSelector, Metadata> forTag}) {
+    // Returns metadata without forTag resolved at all.
+    _unresolved() => new Metadata._(
         testOn: testOn,
         timeout: timeout,
         skip: skip,
         verboseTrace: verboseTrace,
         skipReason: skipReason,
         tags: tags,
         onPlatform: onPlatform,
-        forTag: forTag));
+        forTag: forTag);
+
+    // If there's no tag-specific metadata, or if none of it applies, just
+    // return the metadata as-is.
+    if (forTag == null || tags == null) return _unresolved();
+
+    // Otherwise, resolve the tag-specific components. Doing this eagerly means
+    // we only have to resolve suite- or group-level tags once, rather than
+    // doing it for every test individually.
+    var empty = new Metadata._();
+    var merged = forTag.keys.toList().fold(empty, (merged, selector) {
+      if (!selector.evaluate(tags)) return merged;
+      return merged.merge(forTag.remove(selector));
+    });
+
+    if (merged == empty) return _unresolved();
+    return merged.merge(_unresolved());
   }
 
   /// Creates new Metadata.
   ///
   /// Unlike [new Metadata], this assumes [forTag] is already resolved.
   Metadata._({PlatformSelector testOn, Timeout timeout, bool skip: false,
           this.verboseTrace: false, this.skipReason, Iterable<String> tags,
           Map<PlatformSelector, Metadata> onPlatform,
-          Map<String, Metadata> forTag})
+          Map<BooleanSelector, Metadata> forTag})
       : testOn = testOn == null ? PlatformSelector.all : testOn,
         timeout = timeout == null ? const Timeout.factor(1) : timeout,
         skip = skip,
         tags = new UnmodifiableSetView(
             tags == null ? new Set() : tags.toSet()),
         onPlatform = onPlatform == null
             ? const {}
             : new UnmodifiableMapView(onPlatform),
         forTag = forTag == null
             ? const {}
@@ skipping 32 matching lines @@
             : new PlatformSelector.parse(serialized['testOn']),
         timeout = _deserializeTimeout(serialized['timeout']),
         skip = serialized['skip'],
         skipReason = serialized['skipReason'],
         verboseTrace = serialized['verboseTrace'],
         tags = new Set.from(serialized['tags']),
         onPlatform = new Map.fromIterable(serialized['onPlatform'],
             key: (pair) => new PlatformSelector.parse(pair.first),
             value: (pair) => new Metadata.deserialize(pair.last)),
         forTag = mapMap(serialized['forTag'],
+            key: (key, _) => new BooleanSelector.parse(key),
             value: (_, nested) => new Metadata.deserialize(nested));
 
   /// Deserializes timeout from the format returned by [_serializeTimeout].
   static _deserializeTimeout(serialized) {
     if (serialized == 'none') return Timeout.none;
     var scaleFactor = serialized['scaleFactor'];
     if (scaleFactor != null) return new Timeout.factor(scaleFactor);
     return new Timeout(
         new Duration(microseconds: serialized['duration']));
   }
@@ skipping 70 matching lines @@
     });
 
     return {
       'testOn': testOn == PlatformSelector.all ? null : testOn.toString(),
       'timeout': _serializeTimeout(timeout),
       'skip': skip,
       'skipReason': skipReason,
       'verboseTrace': verboseTrace,
       'tags': tags.toList(),
       'onPlatform': serializedOnPlatform,
-      'forTag': mapMap(forTag, value: (_, metadata) => metadata.serialize())
+      'forTag': mapMap(forTag,
+          key: (selector, _) => selector.toString(),
+          value: (_, metadata) => metadata.serialize())
     };
   }
 
   /// Serializes timeout into a JSON-safe object.
   _serializeTimeout(Timeout timeout) {
     if (timeout == Timeout.none) return 'none';
     return {
       'duration': timeout.duration == null
           ? null
           : timeout.duration.inMicroseconds,
       'scaleFactor': timeout.scaleFactor
     };
   }
 }