Find issue number from comment in status file.

tools/testing/dart/status_file_parser.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 status_file_parser;
 
 import "dart:async";
 import "dart:io";
 import "status_expression.dart";
 
 /** Possible outcomes of running a test. */
 const CRASH = "crash";
 const TIMEOUT = "timeout";
 const FAIL = "fail";
 const PASS = "pass";
 /**
  * An indication to skip the test.  The caller is responsible for skipping it.
  */
 const SKIP = "skip";
 const OK = "ok";
 /**
  * An indication that a test is slow and we should allow extra time for
  * completion.
  */
 const SLOW = "slow";
 
-final RegExp StripComment = new RegExp("^[^#]*");
+final RegExp SplitComment = new RegExp("(^[^#]*)(:?#(.*))?");

[kustermann, 2013/08/20 14:29:56]

"(^[^#]*)(:?#(.*))?"  -->  "^([^#]*)(#.*)?$" ?

This is maybe a bit easier to read.
The first one greedily matches all non '#' characters from the beginning of the
line, the second one will match '#' and everything else until the end of the
line.

[Søren Gjesse, 2013/08/20 14:55:49]

Done. I only did it the other way to avoid having the # as part of the comment,
but it does not matter.

 final RegExp HeaderPattern = new RegExp(r"^\[([^\]]+)\]");
 final RegExp RulePattern = new RegExp(r"\s*([^: ]*)\s*:(.*)");
+final RegExp IssueNumberPattern =
+    new RegExp("Issue ([0-9]+)|dartbug.com/([0-9]+)", caseSensitive: false);

[kustermann, 2013/08/20 14:29:56]

I think there are more patterns, like:
 "Issue: 123"
 "http://dartbug.com/123"
 ...

Maybe we should just have a list of regular expressions, it would definitely be
easier to read.

[Søren Gjesse, 2013/08/20 14:55:49]

I know, but I think we should stick to these two, and maybe in the end just have
one. http:// in front of dartbug.com/ should be found.

 
 // TODO(whesse): Implement configuration_info library that contains data
 // structures for test configuration, including Section.
 class Section {
   BooleanExpression condition;
   List<TestRule> testRules;
 
   Section.always() : condition = null, testRules = new List<TestRule>();
   Section(this.condition) : testRules = new List<TestRule>();
 
   bool isEnabled(environment) =>
       condition == null || condition.evaluate(environment);
+
+  String toString() {
+    return "Section: $condition";
+  }
 }
 
 void ReadTestExpectationsInto(TestExpectations expectations,
                               String statusFilePath,
                               environment,
                               onDone) {
   List<Section> sections = new List<Section>();
 
   void sectionsRead() {
     for (Section section in sections) {
@@ skipping 16 matching lines @@
   }
   Stream<String> lines =
       file.openRead()
           .transform(new StringDecoder())
           .transform(new LineTransformer());
 
   Section current = new Section.always();
   sections.add(current);
 
   lines.listen((String line) {
-    Match match = StripComment.firstMatch(line);
-    line = (match == null) ? "" : match[0];
+    Match match = SplitComment.firstMatch(line);
+    line = (match == null) ? "" : match[1];
     line = line.trim();
     if (line.isEmpty) return;
 
+    // Extract the comment to get the issue number if needed.
+    String comment = (match == null || match[2] == null) ? "" : match[2];
+
     match = HeaderPattern.firstMatch(line);
     if (match != null) {
       String condition_string = match[1].trim();
       List<String> tokens = new Tokenizer(condition_string).tokenize();
       ExpressionParser parser = new ExpressionParser(new Scanner(tokens));
       current = new Section(parser.parseBooleanExpression());
       sections.add(current);
       return;
     }
 
     match = RulePattern.firstMatch(line);
     if (match != null) {
       String name = match[1].trim();
       // TODO(whesse): Handle test names ending in a wildcard (*).
       String expression_string = match[2].trim();
       List<String> tokens = new Tokenizer(expression_string).tokenize();
       SetExpression expression =
           new ExpressionParser(new Scanner(tokens)).parseSetExpression();
-      current.testRules.add(new TestRule(name, expression));
+
+      // Look for issue number in comment.
+      String issueString = null;
+      match = IssueNumberPattern.firstMatch(comment);
+      if (match != null) {
+        issueString = match[1];
+        if (issueString == null) issueString = match[2];

[kustermann, 2013/08/20 14:29:56]

Are you sure that if a optional group was not matched it's null and not ""?

[Søren Gjesse, 2013/08/20 14:55:49]

Yes - I tested it manually.

+      }
+      int issue = issueString != null ? int.parse(issueString) : null;
+      current.testRules.add(new TestRule(name, expression, issue));
       return;
     }
 
     print("unmatched line: $line");
   },
   onDone: onDone);
 }
 
 
 class TestRule {
   String name;
   SetExpression expression;
+  int issue;
 
-  TestRule(this.name, this.expression);
+  TestRule(this.name, this.expression, this.issue);
 
-  String toString() => 'TestRule($name, $expression)';
+  bool get hasIssue => issue != null;
+
+  String toString() => 'TestRule($name, $expression, $issue)';
 }
 
 
 class TestExpectations {
   Map _map;
   bool _preprocessed = false;
   Map _regExpCache;
   Map _keyToRegExps;
 
   /**
@@ skipping 75 matching lines @@
         }
         regExps[i] = regExp;
       }
       _keyToRegExps[key] = regExps;
     });
 
     _regExpCache = null;
     _preprocessed = true;
   }
 }