Better handling of large files.

dart/site/try/src/interaction_manager.dart

 // Copyright (c) 2014, 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 trydart.interaction_manager;
 
 import 'dart:html';
 
 import 'dart:convert' show
     JSON;
@@ skipping 74 matching lines @@
 
   // Implementation note: The state machine is actually implemented by
   // [InteractionContext], this class represents public event handlers.
 
   factory InteractionManager() => new InteractionContext();
 
   InteractionManager.internal();
 
   void onInput(Event event);
 
+  // TODO(ahe): Rename to onKeyDown (as it is called in response to keydown
+  // event).
   void onKeyUp(KeyboardEvent event);
 
   void onMutation(List<MutationRecord> mutations, MutationObserver observer);
 
   void onSelectionChange(Event event);
 
   /// Called when the content of a CompilationUnit changed.
   void onCompilationUnitChanged(CompilationUnit unit);
 
   Future<List<String>> projectFileNames();
@@ skipping 116 matching lines @@
       onUnmodifiedKeyUp(event);
     }
   }
 
   void onModifiedKeyUp(KeyboardEvent event) {
   }
 
   void onUnmodifiedKeyUp(KeyboardEvent event) {
     switch (event.keyCode) {
       case KeyCode.ENTER: {
-        event.preventDefault();
         Selection selection = window.getSelection();
-        if (isCollapsed(selection) && selection.anchorNode is Text) {
-          Text text = selection.anchorNode;
-          int offset = selection.anchorOffset;
-          text.insertData(offset, '\n');
-          selection.collapse(text, offset + 1);
+        if (isCollapsed(selection)) {
+          event.preventDefault();
+          Node node = selection.anchorNode;
+          if (node is Text) {
+            Text text = node;
+            int offset = selection.anchorOffset;
+            // If at end-of-file, insert an extra newline.  The the extra
+            // newline ensures that the next line isn't empty.  At least Chrome
+            // behaves as if "\n" is just a single line. "\nc" (where c is any
+            // character) is two lines, according to Chrome.
+            String newline = isAtEndOfFile(text, offset) ? '\n\n' : '\n';
+            text.insertData(offset, newline);
+            selection.collapse(text, offset + 1);
+          } else if (node is Element) {
+            node.appendText('\n\n');
+            selection.collapse(node.firstChild, 1);
+          } else {
+            window.console
+                ..error('Unexpected node')
+                ..dir(node);
+          }
         }
         break;
       }
     }
 
     // editor.scheduleRemoveCodeCompletion();
 
     // This is a hack to get Safari (iOS) to send mutation events on
     // contenteditable.
     // TODO(ahe): Move to onInput?
     var newDiv = new DivElement();
     hackDiv.replaceWith(newDiv);
     hackDiv = newDiv;
   }
 
   void onMutation(List<MutationRecord> mutations, MutationObserver observer) {
     print('onMutation');
 
     List<Node> highlighting = mainEditorPane.querySelectorAll(
         'a.diagnostic>span, .dart-code-completion, .hazed-suggestion');
     for (Element element in highlighting) {
       element.remove();
     }
 
     Selection selection = window.getSelection();
     TrySelection trySelection = new TrySelection(mainEditorPane, selection);
 
+    Set<Node> normalizedNodes = new Set<Node>();
     for (MutationRecord record in mutations) {
-      normalizeMutationRecord(record, trySelection);
+      normalizeMutationRecord(record, trySelection, normalizedNodes);
+    }
+
+    if (normalizedNodes.length == 1) {
+      Node node = normalizedNodes.single;
+      if (node is Element && node.classes.contains('lineNumber')) {
+        print('Single line change: ${node.outerHtml}');
+
+        String currentText = node.text;
+
+        trySelection = new TrySelection(node, selection);
+        trySelection.updateText(currentText);
+
+        editor.isMalformedInput = false;
+        int offset = 0;
+        List<Node> nodes = <Node>[];
+
+        String state = '';
+        Element previousLine = node.previousElementSibling;
+        if (previousLine != null) {
+          state = previousLine.getAttribute('dart-state');
+        }
+        for (String line in splitLines(currentText)) {
+          List<Node> lineNodes = <Node>[];
+          state = tokenizeAndHighlight(
+              line, state, offset, trySelection, lineNodes);
+          offset += line.length;
+          nodes.add(makeLine(lineNodes, state));
+        }
+
+        node.parent.insertAllBefore(nodes, node);
+        node.remove();
+        trySelection.adjust(selection);
+
+        // Discard highlighting mutations.
+        observer.takeRecords();
+        return;
+      }
     }
 
     String currentText = mainEditorPane.text;
     trySelection.updateText(currentText);
 
     context.currentCompilationUnit.content = currentText;
 
     editor.seenIdentifiers = new Set<String>.from(mock.identifiers);
 
     editor.isMalformedInput = false;
     int offset = 0;
     List<Node> nodes = <Node>[];
 
     String state = '';
-    for (String line in currentText.split(new RegExp('^', multiLine: true))) {
+    for (String line in splitLines(currentText)) {
       List<Node> lineNodes = <Node>[];
       state =
           tokenizeAndHighlight(line, state, offset, trySelection, lineNodes);
       offset += line.length;
-      nodes.add(new SpanElement()
-          ..nodes.addAll(lineNodes)
-          ..classes.add('lineNumber'));
+      nodes.add(makeLine(lineNodes, state));
     }
 
     mainEditorPane
         ..nodes.clear()
         ..nodes.addAll(nodes);
     trySelection.adjust(selection);
 
     // Discard highlighting mutations.
     observer.takeRecords();
   }
@@ skipping 479 matching lines @@
 
 bool isUnterminatedMultiLineToken(UnterminatedToken token) {
   return
       token.start == '/*' ||
       token.start == "'''" ||
       token.start == '"""' ||
       token.start == "r'''" ||
       token.start == 'r"""';
 }
 
-void normalizeMutationRecord(MutationRecord record, TrySelection selection) {
-  if (record.addedNodes.isEmpty) return;
+void normalizeMutationRecord(MutationRecord record,
+                             TrySelection selection,
+                             Set<Node> normalizedNodes) {
   for (Node node in record.addedNodes) {
     if (node.parent == null) continue;
     StringBuffer buffer = new StringBuffer();
     int selectionOffset = htmlToText(node, buffer, selection);
     Text newNode = new Text('$buffer');
     node.replaceWith(newNode);
+    normalizedNodes.add(findLine(newNode));
     if (selectionOffset != -1) {
       selection.anchorNode = newNode;
       selection.anchorOffset = selectionOffset;
     }
   }
+  if (!record.removedNodes.isEmpty) {
+    normalizedNodes.add(findLine(record.target));
+  }
+  if (record.type == "characterData") {
+    normalizedNodes.add(findLine(record.target));
+  }
 }
+
+// Finds the line of [node] (a parent node with CSS class 'lineNumber').
+// If no such parent exists, return mainEditorPane if it is a parent.
+// Otherwise return [node].
+Node findLine(Node node) {
+  for (Node n = node; n != null; n = n.parent) {
+    if (n is Element && n.classes.contains('lineNumber')) return n;
+    if (n == mainEditorPane) return n;
+  }
+  return node;
+}
+
+Element makeLine(List<Node> lineNodes, String state) {
+  // Using a div element here (anything with display=block) generally messes up
+  // editing and navigation.  We would like to use a block element here so
+  // error messages show as expected.  But no such luck.  Fortunately, there
+  // are strong indications that the current solution for displaying errors
+  // isn't good enough anyways.
+  return new SpanElement()
+      ..setAttribute('dart-state', state)
+      ..nodes.addAll(lineNodes)
+      ..classes.add('lineNumber');
+}
+
+bool isAtEndOfFile(Text text, int offset) {
+  Node line = findLine(text);
+  return
+      line.nextNode == null &&
+      text.parent.nextNode == null &&
+      offset == text.length;
+}
+
+List<String> splitLines(String text) {
+  return text.split(new RegExp('^', multiLine: true));
+}