Move the status file parser into its own package.

pkg/status_file/lib/status_file.dart

 // Copyright (c) 2017, 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:path/path.dart' as p;
+
 import 'environment.dart';
 import 'expectation.dart';
-import 'path.dart';
-import 'status_expression.dart';
+import 'src/expression.dart';
 
 /// Matches the header that begins a new section, like:
 ///
 ///     [ $compiler == dart2js && $minified ]
 final _sectionPattern = new RegExp(r"^\[(.+?)\]");
 
 /// Matches an entry that defines the status for a path in the current section,
 /// like:
 ///
 ///     some/path/to/some_test: Pass || Fail
@@ skipping 18 matching lines @@
 /// comma-separated list of [Expectation]s. The path may point to an individual
 /// file, or a directory, in which case it applies to all files under that path.
 ///
 /// Entries may also appear before any section header, in which case they
 /// always apply.
 class StatusFile {
   final String _path;
   final List<StatusSection> sections = [];
 
   /// Parses the status file at [_path].
+  ///
+  /// Throws a [SyntaxError] if the file could not be parsed.
   StatusFile.read(this._path) {
     var lines = new File(_path).readAsLinesSync();
 
     // The current section whose rules are being parsed.
     StatusSection section;
 
     var lineNumber = 0;
 
     for (var line in lines) {
       lineNumber++;
 
       fail(String message, [List<String> errors]) {
-        print('$message in "$_shortPath" line $lineNumber:\n$line');
-
-        if (errors != null) {
-          for (var error in errors) {
-            print("- ${error.replaceAll('\n', '\n  ')}");
-          }
-        }
-        exit(1);
+        throw new SyntaxError(_shortPath, lineNumber, line, message, errors);
       }
 
       // Strip off the comment and whitespace.
       var source = line;
       var comment = "";
       var hashIndex = line.indexOf('#');
       if (hashIndex >= 0) {
         source = line.substring(0, hashIndex);
         comment = line.substring(hashIndex);
       }
       source = source.trim();
 
       // Ignore empty (or comment-only) lines.
       if (source.isEmpty) continue;
 
       // See if we are starting a new section.
       var match = _sectionPattern.firstMatch(source);
       if (match != null) {
         try {
-          var condition = Expression.parse(match[1].trim());
-
-          var errors = <String>[];
-          condition.validate(errors);
-
-          if (errors.isNotEmpty) {
-            var s = errors.length > 1 ? "s" : "";
-            fail('Validation error$s', errors);
-          }
-
-          section = new StatusSection(condition);
+          section = new StatusSection(Expression.parse(match[1].trim()));
           sections.add(section);
         } on FormatException {
           fail("Status expression syntax error");
         }
         continue;
       }
 
       // Otherwise, it should be a new entry under the current section.
       match = _entryPattern.firstMatch(source);
       if (match != null) {
@@ skipping 19 matching lines @@
         }
 
         section.entries.add(new StatusEntry(path, expectations, issue));
         continue;
       }
 
       fail("Unrecognized input");
     }
   }
 
+  /// Validates that the variables and values used in all of the section
+  /// condition expressions are defined in [environment].
+  ///
+  /// Throws a [SyntaxError] on the first found error.
+  void validate(Environment environment) {
+    // TODO(rnystrom): It would be more useful if it reported all of the errors
+    // instead of stopping on the first.
+    for (var section in sections) {
+      if (section._condition == null) continue;
+
+      var errors = <String>[];
+      section._condition.validate(environment, errors);
+
+      if (errors.isNotEmpty) {
+        var s = errors.length > 1 ? "s" : "";
+        throw new SyntaxError(_shortPath, section.lineNumber,
+            "[ ${section._condition} ]", 'Validation error$s', errors);
+      }
+    }
+  }
+
   /// Gets the path to this status file relative to the Dart repo root.
   String get _shortPath {
-    var repoRoot = new Path(Platform.script
-            .toFilePath(windows: Platform.operatingSystem == "windows"))
-        .join(new Path("../../../../"));
-    return new Path(_path).relativeTo(repoRoot).toString();
+    var repoRoot = p.join(p.dirname(p.fromUri(Platform.script)), "../../../");
+    return p.normalize(p.relative(_path, from: repoRoot));
   }
 
   /// Returns the issue number embedded in [comment] or `null` if there is none.
   int _issueNumber(String comment) {
     var match = _issuePattern.firstMatch(comment);
     if (match == null) return null;
 
     return int.parse(match[1]);
   }
 
   String toString() {
     var buffer = new StringBuffer();
     for (var section in sections) {
-      buffer.writeln("[${section._condition}]");
+      buffer.writeln("[ ${section._condition} ]");
 
       for (var entry in section.entries) {
         buffer.write("${entry.path}: ${entry.expectations.join(', ')}");
         if (entry.issue != null) buffer.write(" # Issue ${entry.issue}");
         buffer.writeln();
       }
 
       buffer.writeln();
     }
 
@@ skipping 21 matching lines @@
 }
 
 /// Describes the test status of the file or files at a given path.
 class StatusEntry {
   final String path;
   final List<Expectation> expectations;
   final int issue;
 
   StatusEntry(this.path, this.expectations, this.issue);
 }
+
+/// Error thrown when a parse or validation error occurs in a [StatusFile].
+class SyntaxError implements Exception {
+  final String file;
+  final int lineNumber;
+  final String line;
+  final String message;
+  final List<String> errors;
+
+  SyntaxError(this.file, this.lineNumber, this.line, this.message, this.errors);
+
+  String toString() {
+    var buffer = new StringBuffer();
+    buffer.writeln('$message in "$file" line $lineNumber:');
+    buffer.writeln(line);
+
+    if (errors != null) {
+      for (var error in errors) {
+        buffer.writeln("- ${error.replaceAll('\n', '\n  ')}");
+      }
+    }
+
+    return buffer.toString().trimRight();
+  }
+}