Add CompilationUnit abstraction for tracking "project 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;
 
 import 'dart:math' show
     max,
     min;
 
+import 'dart:async' show
+    Future;
+
 import 'package:compiler/implementation/scanner/scannerlib.dart'
   show
     EOF_TOKEN,
     StringScanner,
     Token;
 
 import 'package:compiler/implementation/source_file.dart' show
     StringSourceFile;
 
 import 'compilation.dart' show
     scheduleCompilation;
 
 import 'ui.dart' show
     currentTheme,
     hackDiv,
     mainEditorPane,
     observer,
     outputDiv;
 
 import 'decoration.dart' show
     CodeCompletionDecoration,
     Decoration,
     DiagnosticDecoration,
     error,
     info,
     warning;
 
 import 'html_to_text.dart' show
     htmlToText;
+
+import 'compilation_unit.dart' show
+    CompilationUnit;
+
 import 'editor.dart' as editor;
 
 import 'mock.dart' as mock;
 
 import 'settings.dart' as settings;
 
 /**
  * UI interaction manager for the entire application.
  */
 abstract class InteractionManager {
@@ skipping 15 matching lines @@
 
   InteractionManager.internal();
 
   void onInput(Event 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();
+
+  /// Called when the user selected a new project file.
+  void onProjectFileSelected(String projectFile);
 }
 
+
 /**
  * State machine for UI interactions.
  */
 class InteractionContext extends InteractionManager {
   InteractionState state;
 
+  final Map<String, CompilationUnit> projectFiles = <String, CompilationUnit>{};
+
+  CompilationUnit currentCompilationUnit = new CompilationUnit('fake', '');
+
   InteractionContext()
       : super.internal() {
     state = new InitialState(this);
   }
 
   void onInput(Event event) => state.onInput(event);
 
   void onKeyUp(KeyboardEvent event) => state.onKeyUp(event);
 
   void onMutation(List<MutationRecord> mutations, MutationObserver observer) {
     return state.onMutation(mutations, observer);
   }
 
   void onSelectionChange(Event event) => state.onSelectionChange(event);
+
+  void onCompilationUnitChanged(CompilationUnit unit) {
+    return state.onCompilationUnitChanged(unit);
+  }
+
+  Future<List<String>> projectFileNames() => state.projectFileNames();
+
+  void onProjectFileSelected(String projectFile) {
+    return state.onProjectFileSelected(projectFile);
+  }
 }
 
 abstract class InteractionState implements InteractionManager {
   void onStateChanged(InteractionState previous) {
     print('State change ${previous.runtimeType} -> ${runtimeType}.');
   }
 }
 
 class InitialState extends InteractionState {
   final InteractionContext context;
@@ skipping 114 matching lines @@
       while (child != null) {
         walk4(child);
         if (hasSelection) return;
         child = child.nextNode;
       }
     }
     if (selection.isCollapsed) {
       walk4(mainEditorPane);
     }
 
-    editor.currentSource = mainEditorPane.text;
+    String currentText = mainEditorPane.text;
+    context.currentCompilationUnit.content = currentText;
     mainEditorPane.nodes.clear();
-    mainEditorPane.appendText(editor.currentSource);
+    mainEditorPane.appendText(currentText);
     if (hasSelection) {
       selection.collapse(mainEditorPane.firstChild, anchorOffset);
     }
 
     editor.isMalformedInput = false;
     for (var n in new List.from(mainEditorPane.nodes)) {
       if (n is! Text) continue;
       Text node = n;
       String text = node.text;
 
@@ skipping 24 matching lines @@
             selectionOffset -= str.length;
             selection.collapse(after, selectionOffset);
           } else {
             selection.collapse(str, selectionOffset);
           }
         }
         node = after;
       }
     }
 
-    window.localStorage['currentSource'] = editor.currentSource;
-    print('Saved source');
-
     // Discard highlighting mutations.
     observer.takeRecords();
   }
 
   void onSelectionChange(Event event) {
   }
 
   void onStateChanged(InteractionState previous) {
     super.onStateChanged(previous);
     scheduleCompilation();
   }
+
+  void onCompilationUnitChanged(CompilationUnit unit) {
+    if (unit == context.currentCompilationUnit) {
+      window.localStorage['currentSource'] = unit.content;
+      print('Saved source');
+      scheduleCompilation();
+    } else {
+      print("Unexpected change to compilation unit '${unit.name}'.");
+    }
+  }
+
+  Future<List<String>> projectFileNames() {
+    return getString('project?list').then((String response) {
+      return new List<String>.from(JSON.decode(response));
+    });
+  }
+
+  void onProjectFileSelected(String projectFile) {
+    // Disable editing.
+    mainEditorPane.contentEditable = 'false';

[lukechurch, 2014/03/27 16:08:23]

If I read the code below correctly, it's going to re-enable editing again after
it's been fetched? In which case probably adjust the comment in the code about
to 

//Disable editing whilst potentially fetching the project file

[ahe, 2014/03/27 23:32:34]

Good idea.

+
+    CompilationUnit unit = context.projectFiles[projectFile];
+    Future<CompilationUnit> future;
+    if (unit != null) {
+      // This project file had been fetched already.
+      future = new Future<CompilationUnit>.value(unit);
+    } else {
+      // This project file has to be fetched.
+      future = getString('project/$projectFile').then((String text) {
+        CompilationUnit unit = context.projectFiles[projectFile];
+        if (unit == null) {
+          // Only create a new unit if the value hadn't arrived already.
+          unit = new CompilationUnit(projectFile, text);
+          context.projectFiles[projectFile] = unit;
+        }
+        return unit;
+      });
+    }
+    future.then((CompilationUnit unit) {
+      mainEditorPane
+          ..contentEditable = 'true'
+          ..nodes.clear();
+      observer.takeRecords(); // Discard mutations.
+
+      // Install the code, which will trigger a call to onMutation.
+      mainEditorPane.appendText(unit.content);
+    });
+  }
+}
+
+Future<String> getString(uri) {
+  return new Future<String>.sync(() => HttpRequest.getString('$uri'));
 }
 
 class PendingInputState extends InitialState {
   PendingInputState(InteractionContext context)
       : super(context);
 
   void onInput(Event event) {
     // Do nothing.
   }
 
@@ skipping 286 matching lines @@
       event.getModifierState("Fn") ||
       event.getModifierState("Meta") ||
       event.getModifierState("NumLock") ||
       event.getModifierState("ScrollLock") ||
       event.getModifierState("Scroll") ||
       event.getModifierState("Win") ||
       event.getModifierState("Shift") ||
       event.getModifierState("SymbolLock") ||
       event.getModifierState("OS");
 }