A minimal status file formatter and canonicalizer.

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';
@@ skipping 27 matching lines @@
 ///
 /// Each entry is a glob-like file path followed by a colon and then a
 /// 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 = [];
+  final List<String> _comments = [];
+
+  int _lineCount = 0;
 
   StatusFile(this.path);
 
   /// 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();
+    _comments.length = lines.length + 1;
 
     // The current section whose rules are being parsed.
     StatusSection section;
 
-    var lineNumber = 0;
-
     for (var line in lines) {
-      lineNumber++;
+      _lineCount++;
 
       fail(String message, [List<String> errors]) {
-        throw new SyntaxError(_shortPath, lineNumber, line, message, errors);
+        throw new SyntaxError(_shortPath, _lineCount, 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);
+        comment = line.substring(hashIndex + 1);
+        _comments[_lineCount] = comment;
       }
       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());
-          section = new StatusSection(condition, lineNumber);
+          section = new StatusSection(condition, _lineCount);
           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 12 matching lines @@
         var issue = _issueNumber(comment);
 
         // If we haven't found a section header yet, create an implicit section
         // that matches everything.
         if (section == null) {
           section = new StatusSection(null, -1);
           sections.add(section);
         }
 
         section.entries
-            .add(new StatusEntry(path, lineNumber, expectations, issue));
+            .add(new StatusEntry(path, _lineCount, expectations, issue));
         continue;
       }
 
       fail("Unrecognized input");
     }
   }
 
   bool get isEmpty => sections.isEmpty;
 
   /// Validates that the variables and values used in all of the section
@@ skipping 40 matching lines @@
         buffer.write("${entry.path}: ${entry.expectations.join(', ')}");
         if (entry.issue != null) buffer.write(" # Issue ${entry.issue}");
         buffer.writeln();
       }
 
       buffer.writeln();
     }
 
     return buffer.toString();
   }
+
+  /// Serialize the status file to a string.
+  ///
+  /// Unlike [toString()], this preserves comments and gives a "canonical"
+  /// rendering of the status file that can be saved back to disc.
+  String serialize() {
+    var buffer = new StringBuffer();
+
+    var lastLine = 0;
+    var needBlankLine = false;
+
+    void writeLine(String text, int line) {
+      var comment = _comments[line];
+      if (text == null && comment == null) {
+        // There's no comment on this line, so it's blank.
+        needBlankLine = true;
+        return;
+      }
+
+      if (needBlankLine) buffer.writeln();
+      needBlankLine = false;
+
+      if (text != null) {
+        buffer.write(text);
+      }
+
+      if (comment != null) {
+        if (text != null) buffer.write(" ");
+        buffer.write("#$comment");
+      }
+
+      buffer.writeln();
+    }
+
+    void writeText(String text, int line) {
+      if (line != null) {
+        while (++lastLine < line) {
+          writeLine(null, lastLine);
+        }
+      }
+
+      writeLine(text, line);
+    }
+
+    for (var section in sections) {
+      if (section.condition != null) {
+        writeText("[ ${section.condition} ]", section.lineNumber);
+      }
+
+      for (var entry in section.entries) {

[Bill Hesse, 2017/08/03 14:24:07]

Not in the printing, but as a separate stage, I think you need to sort the
entries and eliminate duplicates.  So the comments should go with the entries,
not just line numbers.

[Bob Nystrom, 2017/08/03 20:28:49]

Yeah, I thought of that after I sent this out. I may do that at some point, but
this CL marked an easy point where I had something that worked. Sorting adds
complexity since you have to deal with comments and blank lines in the middle of
sections.
Yeah, I considered that too. I'll probably re-work the way comments are tracked
if we support sorting or modifying status files programmatically. The latter was
my real motivation for adding this.

+        writeText("${entry.path}: ${entry.expectations.join(', ')}",
+            entry.lineNumber);
+      }
+
+      needBlankLine = true;
+    }
+
+    // Write any trailing comments.
+    while (++lastLine <= _lineCount) {
+      writeLine(null, lastLine);
+    }
+
+    return buffer.toString();
+  }
 }
 
 /// One section in a status file.
 ///
 /// Contains the condition from the header that begins the section, then all of
 /// the entries within the section.
 class StatusSection {
   /// The expression that determines when this section is applied.
   ///
   /// May be `null` for paths that appear before any section header in the file.
@@ skipping 42 matching lines @@
 
     if (errors != null) {
       for (var error in errors) {
         buffer.writeln("- ${error.replaceAll('\n', '\n  ')}");
       }
     }
 
     return buffer.toString().trimRight();
   }
 }