Array formatting customized to look like JS

tool/input_sdk/private/debugger.dart

 // Copyright (c) 2015, 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 dart._debugger;
 
 import 'dart:_foreign_helper' show JS;
 import 'dart:_runtime' as dart;
 import 'dart:core';
 import 'dart:collection';
 import 'dart:html' as html;
+import 'dart:math';
 
 /// JsonMLConfig object to pass to devtools to specify how an Object should
 /// be displayed. skipDart signals that an object should not be formatted
 /// by the Dart formatter. This is used to specify that an Object
 /// should just be displayed using the regular JavaScript view instead of a
 /// custom Dart view. For example, this is used to display the JavaScript view
 /// of a Dart Function as a child of the regular Function object. keyToString
 /// signals that a map key object should have its toString() displayed by
 /// the Dart formatter.
 ///
 /// We'd like this to be an enum, but we can't because it's a dev_compiler bug.
 class JsonMLConfig {
   const JsonMLConfig(this.name);
 
   final String name;
   static const none = const JsonMLConfig("none");
   static const skipDart = const JsonMLConfig("skipDart");
   static const keyToString = const JsonMLConfig("keyToString");
 }
 
-final int maxIterableChildrenToDisplay = 50;
+int maxSpanLength = 100;
 
 var _devtoolsFormatter = new JsonMLFormatter(new DartFormatter());
 
 String _typeof(object) => JS('String', 'typeof #', object);
 
 List<String> getOwnPropertyNames(object) => JS('List<String>',
     'dart.list(Object.getOwnPropertyNames(#), #)', object, String);
 
 List getOwnPropertySymbols(object) =>
     JS('List', 'Object.getOwnPropertySymbols(#)', object);
@@ skipping 48 matching lines @@
 bool hasMethod(object, String name) {
   try {
     return dart.hasMethod(object, name);
   } catch (e) {
     return false;
   }
 }
 
 /// [JsonMLFormatter] consumes [NameValuePair] objects and
 class NameValuePair {
-  NameValuePair({this.name, this.value, this.config: JsonMLConfig.none});
+  NameValuePair(
+      {this.name,
+      this.value,
+      this.config: JsonMLConfig.none,
+      this.hideName: false});
 
   // Define equality and hashCode so that NameValuePair can be used
   // in a Set to dedupe entries with duplicate names.
   operator ==(other) => other is NameValuePair && other.name == name;
   int get hashCode => name.hashCode;
 
   final String name;
   final Object value;
   final JsonMLConfig config;
+  final bool hideName;
+
+  String get displayName => hideName ? '' : name;
 }
 
 class MapEntry {
   MapEntry({this.key, this.value});
 
   final Object key;
   final Object value;
 }
 
+class IterableSpan {
+  IterableSpan({this.start, this.end, this.iterable});
+
+  final int start;
+  final int end;
+  final Iterable iterable;
+}
+
 class ClassMetadata {
   ClassMetadata(this.object);
 
   final Object object;
 }
 
 class HeritageClause {
   HeritageClause(this.name, this.types);
 
   final String name;
@@ skipping 101 matching lines @@
     var body = new JsonMLElement('ol')
       ..setStyle('list-style-type: none;'
           'padding-left: 0px;'
           'margin-top: 0px;'
           'margin-bottom: 0px;'
           'margin-left: 12px');
     var children = _simpleFormatter.children(object);
     for (NameValuePair child in children) {
       var li = body.createChild('li');
       var nameSpan = new JsonMLElement('span')
-        ..createTextChild(child.name != null ? child.name + ': ' : '')
+        ..createTextChild(
+            child.displayName.isNotEmpty ? '${child.displayName}: ' : '')
         ..setStyle('color: rgb(136, 19, 145);');
       if (_typeof(child.value) == 'object' ||
           _typeof(child.value) == 'function') {
         nameSpan.addStyle("padding-left: 13px;");
 
         li.appendChild(nameSpan);
         var objectTag = li.createObjectTag(child.value);
         objectTag.addAttribute('config', child.config);
         if (!_simpleFormatter.hasChildren(child.value)) {
           li.setStyle("padding-left: 13px;");
@@ skipping 20 matching lines @@
   List<Formatter> _formatters;
 
   DartFormatter() {
     // The order of formatters matters as formatters later in the list take
     // precidence.
     _formatters = [
       new FunctionFormatter(),
       new MapFormatter(),
       new IterableFormatter(),
       new MapEntryFormatter(),
+      new IterableSpanFormatter(),
       new ClassMetadataFormatter(),
       new HeritageClauseFormatter(),
-      new ObjectFormatter()
+      new ObjectFormatter(),
     ];
   }
 
   String preview(object) {
     try {
       if (object == null ||
           object is num ||
           object is String ||
           isNativeJavaScriptObject(object)) {
         return object.toString();
@@ skipping 192 matching lines @@
     }
   }
 
   bool hasChildren(object) => true;
 
   List<NameValuePair> children(object) {
     // TODO(jacobr): be lazier about enumerating contents of Iterables that
     // are not the built in Set or List types.
     // TODO(jacobr): handle large Iterables better.
     // TODO(jacobr): consider only using numeric indices
-    Iterable iterable = object;
     var ret = new LinkedHashSet<NameValuePair>();
-    var i = 0;
-    for (var entry in iterable) {
-      if (i > maxIterableChildrenToDisplay) {
-        ret.add(new NameValuePair(
-            name: 'Warning', value: 'Truncated Iterable display'));
-        // TODO(jacobr): provide an expandable entry to show more entries.
-        break;
-      }
-      ret.add(new NameValuePair(name: i.toString(), value: entry));
-      i++;
-    }
+    ret.addAll(childrenHelper(
+        new IterableSpan(start: 0, end: object.length, iterable: object)));
     // TODO(jacobr): provide a link to show regular class properties here.
     // required for subclasses of iterable, etc.
     addMetadataChildren(object, ret);
     return ret.toList();
   }
 }
 
 // This class does double duting displaying metadata for
 class ClassMetadataFormatter implements Formatter {
   accept(object) => object is ClassMetadata;
@@ skipping 80 matching lines @@
   List<NameValuePair> children(object) {
     HeritageClause clause = object;
     var ret = <NameValuePair>[];
     for (var type in clause.types) {
       ret.add(new NameValuePair(value: new ClassMetadata(type)));
     }
     return ret;
   }
 }
 
+/// Formatter for synthetic IterableSpan objects used to display contents of
+/// an Iterable cleanly.
+class IterableSpanFormatter implements Formatter {
+  accept(object) => object is IterableSpan;
+
+  String preview(object) {
+    IterableSpan entry = object;
+    return '[${object.start}...${object.end-1}]';
+  }
+
+  bool hasChildren(object) => true;
+
+  List<NameValuePair> children(object) => childrenHelper(object);
+}
+
+List<NameValuePair> childrenHelper(IterableSpan span) {
+  var length = span.end - span.start;
+  var ret = new List<NameValuePair>();
+  if (length <= maxSpanLength) {
+    for (var i = span.start; i < span.end; i++) {
+      /// TODO(bmilligan): Stop using elementAt if it becomes a performance
+      /// bottleneck in the future.
+      ret.add(new NameValuePair(
+          name: i.toString(), value: span.iterable.elementAt(i)));
+    }
+  } else {
+    /// Using length - .5, a list of length 10000 results in a
+    /// maxPowerOfSubsetSize of 1, so the list will be broken up into 100,
+    /// 100-length subsets. A list of length 10001 results in a
+    /// maxPowerOfSubsetSize of 2, so the list will be broken up into 1
+    /// 10000-length subset and 1 1-length subset.
+    var maxPowerOfSubsetSize =
+        (log(length - .5) / log(maxSpanLength)).truncate();
+    var subsetSize = pow(maxSpanLength, maxPowerOfSubsetSize);
+    for (var i = span.start; i < span.end; i += subsetSize) {
+      var endIndex = min(span.end, subsetSize + i);
+      if (endIndex - i == 1)
+        ret.add(new NameValuePair(
+            name: i.toString(), value: span.iterable.elementAt(i)));
+      else {
+        var entryWrapper =
+            new IterableSpan(start: i, end: endIndex, iterable: span.iterable);
+        ret.add(new NameValuePair(
+            name: '[${i}...${endIndex - 1}]',
+            value: entryWrapper,
+            hideName: true));
+      }
+    }
+  }
+  return ret;
+}
+
 /// This entry point is automatically invoked by the code generated by
 /// Dart Dev Compiler
 registerDevtoolsFormatter() {
   var formatters = [_devtoolsFormatter];
   JS('', 'dart.global.devtoolsFormatters = #', formatters);
 }