Line breaking plumbing (continued).

pkg/analyzer/lib/src/services/writer.dart

 // Copyright (c) 2013, 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 source_writer;
 
 
 class Line {
 
   final tokens = <LineToken>[];
@@ skipping 45 matching lines @@
 
 /// A simple line breaking [LinePrinter]
 class SimpleLineBreaker extends LinePrinter {
 
   final chunks = <Chunk>[];
   final int maxLength;
 
   SimpleLineBreaker(this.maxLength);
 
   String printLine(Line line) {
-    //TODO(pquitslund): implement
+    var buf = new StringBuffer();
+    var chunks = breakLine(line);
+    for (var i = 0; i < chunks.length; ++i) {
+      if (i > 0) {
+        buf.write(indent(chunks[i]));
+      } else {
+        buf.write(chunks[i]);
+      }
+    }
+    return buf.toString();
+  }
+
+  String indent(Chunk chunk) {
+    return '\n' + chunk.toString();
   }
 
   List<Chunk> breakLine(Line line) {
 
     var chunks = <Chunk>[];
 
     // The current unbroken line
     var current = new Chunk(maxLength: maxLength);
 
     // A tentative working chunk that will either start a new line or get
     // absorbed into 'current'
     var work = new Chunk(maxLength: maxLength);
 
     line.tokens.forEach((tok) {
 
       if (goodStart(tok, work)) {
         if (current.fits(work)) {
           current.add(work);
         } else {
           if (current.length > 0) {
             chunks.add(current);
           }
           current = work;
         }
         work = new Chunk(start: tok, maxLength: maxLength - current.length);
       } else {
         if (work.fits(tok)) {
           work.add(tok);
         } else {
-          current.add(work);
+          if (!isWhitespace(work)) {
+            current.add(work);
+          }
           if (current.length > 0) {
             chunks.add(current);
             current = new Chunk(maxLength: maxLength);
           }
           work = new Chunk(maxLength: maxLength);
           work.add(tok);
         }
       }
 
     });
 
     current.add(work);
     if (current.length > 0) {
       chunks.add(current);
     }
     return chunks;
   }
 
+  bool isWhitespace(Chunk chunk) {

[pquitslund, 2014/01/13 16:39:55]

This *can't* be the best way to test this...  Ideas most welcome! :)

+    var str = chunk.buffer.toString();
+    return str.lastIndexOf(new RegExp(r"(\w+)")) == str.length - 1;
+  }
+
   /// Test whether this token is a good start for a new working chunk
   bool goodStart(LineToken tok, Chunk workingChunk) =>
       tok is SpaceToken && tok.breakWeight >= workingChunk.start.breakWeight;
 
 }
 
 
 /// Special token indicating a line start
 final LINE_START = new SpaceToken(0);
 
@@ skipping 16 matching lines @@
 /// Describes a piece of text in a [Line].
 abstract class LineText {
   int get length;
   void addTo(Chunk chunk);
 }
 
 
 /// A working piece of text used in calculating line breaks
 class Chunk implements LineText {
 
-  final buffer = new StringBuffer();
+  final StringBuffer buffer = new StringBuffer();
 
   int maxLength;
   SpaceToken start;
 
   Chunk({this.start, this.maxLength}) {
     if (start == null) {
       start = LINE_START;
     }
   }
 
   bool fits(LineText text) => length + text.length < maxLength;
 
   int get length => start.value.length + buffer.length;
 
   void add(LineText text) {
     text.addTo(this);
   }
 
-  String toString() => buffer.toString().trim();
+  String toString() => buffer.toString();
 
   void addTo(Chunk chunk) {
     chunk.buffer.write(start.value);
     chunk.buffer.write(buffer.toString());
   }
 }
 
 
 class LineToken implements LineText {
 
@@ skipping 38 matching lines @@
   Line currentLine;
 
   final String lineSeparator;
   int indentCount = 0;
 
   LinePrinter linePrinter;
   LineToken _lastToken;
 
   SourceWriter({this.indentCount: 0, this.lineSeparator: NEW_LINE,
       int maxLineLength: 80}) {
-    linePrinter = new SimpleLinePrinter();
+    linePrinter = new SimpleLineBreaker(maxLineLength);
     currentLine = new Line(indent: indentCount, printer: linePrinter);
   }
 
   LineToken get lastToken => _lastToken;
 
   _addToken(LineToken token) {
     _lastToken = token;
     currentLine.addToken(token);
   }
 
@@ skipping 22 matching lines @@
 
   void println(String s) {
     print(s);
     newline();
   }
 
   void space() {
     spaces(1);
   }
 
-  void spaces(n, {breakWeight: null}) {
+  void spaces(n, {breakWeight: DEFAULT_SPACE_WEIGHT}) {
     currentLine.addSpaces(n, breakWeight: breakWeight);
   }
 
   void unindent() {
     --indentCount;
   }
 
   String toString() {
     var source = new StringBuffer(buffer.toString());
     if (!currentLine.isWhitespace()) {
@@ skipping 51 matching lines @@
 
 String getTabs(int n) => n < TABS.length ? TABS[n] : repeat('\t', n);
 
 String repeat(String ch, int times) {
   var sb = new StringBuffer();
   for (var i = 0; i < times; ++i) {
     sb.write(ch);
   }
   return sb.toString();
 }