Add a "terse" argument to foldFrames().

lib/src/chain.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 stack_trace.chain;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'frame.dart';
@@ skipping 118 matching lines @@
     new Chain(chain.split(_GAP).map((trace) => new Trace.parseFriendly(trace)));
 
   /// Returns a new [Chain] comprised of [traces].
   Chain(Iterable<Trace> traces)
       : traces = new UnmodifiableListView<Trace>(traces.toList());
 
   /// Returns a terser version of [this].
   ///
   /// This calls [Trace.terse] on every trace in [traces], and discards any
   /// trace that contain only internal frames.
-  Chain get terse {
-    var terseTraces = traces.map((trace) => trace.terse);
-    var nonEmptyTraces = terseTraces.where((trace) {
-      // Ignore traces that contain only internal processing.
-      return trace.frames.length > 1;
-    });
-
-    // If all the traces contain only internal processing, preserve the last
-    // (top-most) one so that the chain isn't empty.
-    if (nonEmptyTraces.isEmpty && terseTraces.isNotEmpty) {
-      return new Chain([terseTraces.last]);
-    }
-
-    return new Chain(nonEmptyTraces);
-  }
+  Chain get terse => foldFrames((_) => false, terse: true);
 
   /// Returns a new [Chain] based on [this] where multiple stack frames matching
   /// [predicate] are folded together.
   ///
   /// This means that whenever there are multiple frames in a row that match
   /// [predicate], only the last one is kept. In addition, traces that are
   /// composed entirely of frames matching [predicate] are omitted.
   ///
   /// This is useful for limiting the amount of library code that appears in a
   /// stack trace by only showing user code and code that's called by user code.
-  Chain foldFrames(bool predicate(Frame frame)) {
-    var foldedTraces = traces.map((trace) => trace.foldFrames(predicate));
+  ///
+  /// If [terse] is true, this will also fold together frames from the core
+  /// library or from this package, and simplify core library frames as in
+  /// [Trace.terse].
+  Chain foldFrames(bool predicate(Frame frame), {bool terse: false}) {
+    var foldedTraces = traces.map(
+        (trace) => trace.foldFrames(predicate, terse: terse));
     var nonEmptyTraces = foldedTraces.where((trace) {
       // Ignore traces that contain only folded frames. These traces will be
       // folded into a single frame each.
       return trace.frames.length > 1;
     });
 
     // If all the traces contain only internal processing, preserve the last
     // (top-most) one so that the chain isn't empty.
     if (nonEmptyTraces.isEmpty && foldedTraces.isNotEmpty) {
       return new Chain([foldedTraces.last]);
     }
 
     return new Chain(nonEmptyTraces);
   }
 
   /// Converts [this] to a [Trace].
   ///
   /// The trace version of a chain is just the concatenation of all the traces
   /// in the chain.
   Trace toTrace() => new Trace(flatten(traces.map((trace) => trace.frames)));
 
   String toString() => traces.join(_GAP);
 }