Collapse successful GET messages together.

lib/src/log.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.
 
 /// Message logging.
 library pub.log;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
@@ skipping 30 matching lines @@
 
 /// The list of recorded log messages. Will only be recorded if
 /// [recordTranscript()] is called.
 Transcript<Entry> _transcript;
 
 /// The currently-animated progress indicator, if any.
 ///
 /// This will also be in [_progresses].
 Progress _animatedProgress;
 
+_Collapser _collapser;
+
 final _cyan = getSpecial('\u001b[36m');
 final _green = getSpecial('\u001b[32m');
 final _magenta = getSpecial('\u001b[35m');
 final _red = getSpecial('\u001b[31m');
 final _yellow = getSpecial('\u001b[33m');
 final _gray = getSpecial('\u001b[1;30m');
 final _none = getSpecial('\u001b[0m');
 final _noColor = getSpecial('\u001b[39m');
 final _bold = getSpecial('\u001b[1m');
 
@@ skipping 141 matching lines @@
 void io(message) => write(Level.IO, message);
 
 /// Logs [message] at [Level.SOLVER].
 void solver(message) => write(Level.SOLVER, message);
 
 /// Logs [message] at [Level.FINE].
 void fine(message) => write(Level.FINE, message);
 
 /// Logs [message] at [level].
 void write(Level level, message) {
+  // Don't allow interleaving collapsible messages with other kinds.
+  if (_collapser != null) _collapser.end();
+
   message = message.toString();
   var lines = splitLines(message);
 
   // Discard a trailing newline. This is useful since StringBuffers often end
   // up with an extra newline at the end from using [writeln].
   if (lines.isNotEmpty && lines.last == "") {
     lines.removeLast();
   }
 
   var entry = new Entry(level, lines.map(format).toList());
@@ skipping 180 matching lines @@
   _numMutes++;
 }
 
 /// Resumes animating any ongoing progress once all calls to [muteProgress]
 /// have made their matching [unmuteProgress].
 void unmuteProgress() {
   assert(_numMutes > 0);
   _numMutes--;
 }
 
+/// Logs a collapsible [message].
+///
+/// If a number of collapsible messages are printed in short succession, they
+/// are collapsed to just showing [template] with "##" replaced with the number
+/// of collapsed messages. Avoids spamming the output with not-very-interesting
+/// output.
+void collapsible(String message, String template) {
+  // Only collapse messages when the output is not verbose.
+  if (verbosity._loggers[Level.MESSAGE] != _logToStdout) {
+    write(Level.MESSAGE, message);
+    return;
+  }
+
+  // If this is a different set of collapsed messages, end the previous ones.
+  if (_collapser != null && _collapser._template != template) {
+    _collapser.end();
+  }
+
+  if (_collapser != null) {
+    _collapser.increment();
+  } else {
+    _collapser = new _Collapser(message, template);
+  }
+}
+
 /// Wraps [text] in the ANSI escape codes to make it bold when on a platform
 /// that supports that.
 ///
 /// Use this to highlight the most important piece of a long chunk of text.
 ///
 /// This is disabled under [withPrejudice] since all text is bold with
 /// prejudice.
 String bold(text) => withPrejudice ? text : "$_bold$text$_none";
 
 /// Wraps [text] in the ANSI escape codes to make it gray when on a platform
@@ skipping 116 matching lines @@
     this.message(errorJson);
   }
 
   /// Encodes [message] to JSON and prints it if JSON output is enabled.
   void message(message) {
     if (!enabled) return;
 
     print(JSON.encode(message));
   }
 }
+
+/// Collapses a series of collapsible messages into a single line of output if
+/// they happen within a short window of time.
+class _Collapser {
+  /// The window of time where a series of calls to [collapsible] will be
+  /// collapsed to a single message.
+  static final _window = new Duration(milliseconds: 100);
+
+  /// The Timer used to coalesce a number of collapsible messages.
+  ///
+  /// This is `null` if no collapsible messages are waiting to be displayed.
+  Timer _timer;
+
+  /// The first collapsible message waiting to be displayed.
+  String _firstMessage;
+
+  /// The template used to display the number of collapsed messages when more
+  /// than one collapsible message is logged within the window of time.
+  ///
+  /// Inside the template, "##" will be replaced with the number of collapsed
+  /// messages.
+  String _template;
+
+  /// The number of collapsible messages that are waiting to be logged.
+  int _count = 1;
+
+  _Collapser(this._firstMessage, this._template) {
+    _initTimer();
+  }
+
+  void increment() {
+    // Reset the timer.
+    _timer.cancel();
+    _initTimer();
+
+    _count++;
+  }
+
+  void end() {
+    // Clear this first so we don't stack overflow when we call message() below.
+    _collapser = null;
+
+    _timer.cancel();
+    if (_count == 1) {
+      message(_firstMessage);
+    } else {
+      message(_template.replaceAll("##", _count.toString()));

[nweiz, 2015/08/05 22:57:14]

I'd still really like to have this dynamically update with "\r" on OSes that
support it, especially since the template is now small enough to ensure that
this won't break.

[Bob Nystrom, 2015/08/05 23:49:23]

Leaving as-is per our discussion.

+    }
+  }
+
+  void _initTimer() {
+    _timer = new Timer(_window, end);
+  }
+}