Support tag configuration.

lib/src/runner/configuration/load.dart

 // Copyright (c) 2016, 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:io';
 
 import 'package:glob/glob.dart';
 import 'package:path/path.dart' as p;
 import 'package:source_span/source_span.dart';
 import 'package:yaml/yaml.dart';
@@ skipping 26 matching lines @@
 /// A helper for [load] that tracks the YAML document.
 class _ConfigurationLoader {
   /// The parsed configuration document.
   final YamlMap _document;
 
   /// The source string for [_document].
   ///
   /// Used for error reporting.
   final String _source;
 
-  _ConfigurationLoader(this._document, this._source);
+  /// Whether runner configuration is allowed at this level.
+  final bool _runnerConfig;
+
+  _ConfigurationLoader(this._document, this._source, {bool runnerConfig: true})
+      : _runnerConfig = runnerConfig;
 
   /// Loads the configuration in [_document].
-  Configuration load() {
+  Configuration load() => _loadTestConfig().merge(_loadRunnerConfig());
+
+  /// Loads test configuration (but not runner configuration).
+  Configuration _loadTestConfig() {
     var verboseTrace = _getBool("verbose_trace");
     var jsTrace = _getBool("js_trace");
 
+    var timeout = _parseValue("timeout", (value) => new Timeout.parse(value));
+
+    var tags = _getMap("tags", key: (keyNode) {
+      _validate(keyNode, "tags key must be a string.",
+          (value) => value is String);
+      _validate(
+          keyNode,
+          "Invalid tag. Tags must be (optionally hyphenated) Dart identifiers.",
+          (value) => value.contains(anchoredHyphenatedIdentifier));
+
+      return keyNode.value;
+    }, value: (valueNode) {
+      return _nestedConfig(valueNode, "tag value", runnerConfig: false);
+    });
+
+    return new Configuration(
+        verboseTrace: verboseTrace,
+        jsTrace: jsTrace,
+        timeout: timeout,
+        tags: tags);
+  }
+
+  /// Loads runner configuration (but not test configuration).
+  ///
+  /// If [_runnerConfig] is `false`, this will error if there are any
+  /// runner-level configuration fields.
+  Configuration _loadRunnerConfig() {
+    if (!_runnerConfig) {
+      _disallow("reporter");
+      _disallow("pub_serve");
+      _disallow("concurrency");
+      _disallow("platforms");
+      _disallow("paths");
+      _disallow("filename");
+      return new Configuration();
+    }
+
     var reporter = _getString("reporter");
     if (reporter != null && !allReporters.contains(reporter)) {
       _error('Unknown reporter "$reporter".', "reporter");
     }
 
     var pubServePort = _getInt("pub_serve");
     var concurrency = _getInt("concurrency");
-    var timeout = _parseValue("timeout", (value) => new Timeout.parse(value));
 
     var allPlatformIdentifiers =
         TestPlatform.all.map((platform) => platform.identifier).toSet();
     var platforms = _getList("platforms", (platformNode) {
       _validate(platformNode, "Platforms must be strings.",
           (value) => value is String);
       _validate(platformNode, 'Unknown platform "${platformNode.value}".',
           allPlatformIdentifiers.contains);
 
       return TestPlatform.find(platformNode.value);
     });
 
     var paths = _getList("paths", (pathNode) {
       _validate(pathNode, "Paths must be strings.", (value) => value is String);
       _validate(pathNode, "Paths must be relative.", p.url.isRelative);
 
       return _parseNode(pathNode, "path", p.fromUri);
     });
 
     var filename = _parseValue("filename", (value) => new Glob(value));
 
     return new Configuration(
-        verboseTrace: verboseTrace,
-        jsTrace: jsTrace,
         reporter: reporter,
         pubServePort: pubServePort,
         concurrency: concurrency,
-        timeout: timeout,
         platforms: platforms,
         paths: paths,
         filename: filename);
   }
 
   /// Throws an exception with [message] if [test] returns `false` when passed
   /// [node]'s value.
   void _validate(YamlNode node, String message, bool test(value)) {
     if (test(node.value)) return;
     throw new SourceSpanFormatException(message, node.span, _source);
@@ skipping 35 matching lines @@
   /// Asserts that [field] is a list and runs [forElement] for each element it
   /// contains.
   ///
   /// Returns a list of values returned by [forElement].
   List _getList(String field, forElement(YamlNode elementNode)) {
     var node = _getNode(field, "list", (value) => value is List);
     if (node == null) return [];
     return node.nodes.map(forElement).toList();
   }
 
+  /// Asserts that [field] is a map and runs [key] and [value] for each pair.
+  ///
+  /// Returns a map with the keys and values returned by [key] and [value]. Each
+  /// of these defaults to asserting that the value is a string.
+  Map _getMap(String field, {key(YamlNode keyNode),
+      value(YamlNode valueNode)}) {
+    var node = _getNode(field, "map", (value) => value is Map);
+    if (node == null) return {};
+
+    key ??= (keyNode) {
+      _validate(keyNode, "$field keys must be strings.",
+          (value) => value is String);
+
+      return keyNode.value;
+    };
+
+    value ??= (valueNode) {
+      _validate(valueNode, "$field values must be strings.",
+          (value) => value is String);
+
+      return valueNode.value;
+    };
+
+    return mapMap(node.nodes,
+        key: (keyNode, _) => key(keyNode),
+        value: (_, valueNode) => value(valueNode));
+  }
+
   /// Asserts that [node] is a string, passes its value to [parse], and returns
   /// the result.
   ///
   /// If [parse] throws a [FormatException], it's wrapped to include [node]'s
   /// span.
   _parseNode(YamlNode node, String name, parse(String value)) {
     _validate(node, "$name must be a string.", (value) => value is String);
 
     try {
       return parse(node.value);
     } on FormatException catch (error) {
       throw new SourceSpanFormatException(
           'Invalid $name: ${error.message}', node.span, _source);
     }
   }
 
   /// Asserts that [field] is a string, passes it to [parse], and returns the
   /// result.
   ///
   /// If [parse] throws a [FormatException], it's wrapped to include [field]'s
   /// span.
   _parseValue(String field, parse(String value)) {
     var node = _document.nodes[field];
     if (node == null) return null;
     return _parseNode(node, field, parse);
   }
 
+  /// Parses a nested configuration document.
+  ///
+  /// [name] is the name of the field, which is used for error-handling.
+  /// [runnerConfig] controls whether runner configuration is allowed in the
+  /// nested configuration. It defaults to [_runnerConfig].
+  Configuration _nestedConfig(YamlNode node, String name,
+      {bool runnerConfig}) {
+    if (node == null || node.value == null) return new Configuration();
+
+    _validate(node, "$name must be a map.", (value) => value is Map);
+    var loader = new _ConfigurationLoader(node, _source,
+        runnerConfig: runnerConfig ?? _runnerConfig);
+    return loader.load();
+  }
+
+  /// Throws an error if a field named [field] exists at this level.
+  void _disallow(String field) {
+    if (!_document.containsKey(field)) return;
+    _error("$field isn't supported here.", field);
+  }
+
   /// Throws a [SourceSpanFormatException] with [message] about [field].
   void _error(String message, String field) {
     throw new SourceSpanFormatException(
         message, _document.nodes[field].span, _source);
   }
 }