add ContextsChangedEvent

pkg/analysis_server/lib/src/analysis_server.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 analysis.server;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 18 matching lines @@
 
 
 class ServerContextManager extends ContextManager {
   final AnalysisServer analysisServer;
 
   /**
    * The default options used to create new analysis contexts.
    */
   AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
 
+  /**
+   * The controller for sending [ContextsChangedEvent]s.
+   */
+  StreamController<ContextsChangedEvent> _onContextsChangedController;
+
   ServerContextManager(this.analysisServer, ResourceProvider resourceProvider,
       PackageMapProvider packageMapProvider)
-      : super(resourceProvider, packageMapProvider);
+      : super(resourceProvider, packageMapProvider) {
+    _onContextsChangedController = new StreamController<ContextsChangedEvent>();
+  }
+
+  /**
+   * The stream that is notified when contexts are added or removed.
+   */
+  Stream<ContextsChangedEvent> get onContextsChanged =>
+      _onContextsChangedController.stream;
 
   @override
   void addContext(Folder folder, UriResolver packageUriResolver) {
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     analysisServer.folderMap[folder] = context;
     context.sourceFactory = _createSourceFactory(packageUriResolver);
     context.analysisOptions = new AnalysisOptionsImpl.con1(defaultOptions);
+    _onContextsChangedController.add(
+        new ContextsChangedEvent(added: [context]));
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     if (context != null) {
       context.applyChanges(changeSet);
       analysisServer.schedulePerformAnalysisOperation(context);
     }
   }
 
   @override
   void removeContext(Folder folder) {
     AnalysisContext context = analysisServer.folderMap.remove(folder);
     if (analysisServer.index != null) {
       analysisServer.index.removeContext(context);
     }
+    _onContextsChangedController.add(
+        new ContextsChangedEvent(removed: [context]));
     analysisServer.sendContextAnalysisDoneNotifications(
         context,
         AnalysisDoneReason.CONTEXT_REMOVED);
   }
 
   @override
   void updateContextPackageUriResolver(Folder contextFolder,
-                                       UriResolver packageUriResolver) {
+      UriResolver packageUriResolver) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     context.sourceFactory = _createSourceFactory(packageUriResolver);
+    _onContextsChangedController.add(
+        new ContextsChangedEvent(changed: [context]));
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   /**
    * Set up a [SourceFactory] that resolves packages using the given
    * [packageUriResolver].
    */
   SourceFactory _createSourceFactory(UriResolver packageUriResolver) {
     List<UriResolver> resolvers = <UriResolver>[
         new DartUriResolver(analysisServer.defaultSdk),
         new ResourceUriResolver(resourceProvider),
         packageUriResolver];
     return new SourceFactory(resolvers);
   }
 }
 
 
 /**
+ * A [ContextsChangedEvent] indicate what contexts were added or removed.
+ *
+ * No context should be added to the event more than once. It does not make
+ * sense, for example, for a context to be both added and removed.
+ */
+class ContextsChangedEvent {
+
+  /**
+   * The contexts that were added to the server.
+   */
+  final List<AnalysisContext> added;
+
+  /**
+   * The contexts that were changed.
+   */
+  final List<AnalysisContext> changed;
+
+  /**
+   * The contexts that were removed from the server.
+   */
+  final List<AnalysisContext> removed;
+
+  ContextsChangedEvent({
+      this.added: AnalysisContext.EMPTY_LIST,
+      this.changed: AnalysisContext.EMPTY_LIST,
+      this.removed: AnalysisContext.EMPTY_LIST});
+}
+
+
+/**
  * Enum representing reasons why analysis might be done for a given file.
  */
 class AnalysisDoneReason {
   /**
    * Analysis of the file completed successfully.
    */
   static const AnalysisDoneReason COMPLETE =
       const AnalysisDoneReason._('COMPLETE');
 
   /**
@@ skipping 117 matching lines @@
    */
   StreamController<ChangeNotice> _onFileAnalyzedController;
 
   /**
    * True if any exceptions thrown by analysis should be propagated up the call
    * stack.
    */
   bool rethrowExceptions;
 
   /**
+   * The stream that is notified when contexts are added or removed.
+   */
+  Stream<ContextsChangedEvent> onContextsChanged;
+
+  /**
    * Initialize a newly created server to receive requests from and send
    * responses to the given [channel].
    *
    * If [rethrowExceptions] is true, then any exceptions thrown by analysis are
    * propagated up the call stack.  The default is true to allow analysis
    * exceptions to show up in unit tests, but it should be set to false when
    * running a full analysis server.
    */
   AnalysisServer(this.channel, this.resourceProvider,
       PackageMapProvider packageMapProvider, this.index, this.defaultSdk,
       {this.rethrowExceptions: true}) {
     searchEngine = createSearchEngine(index);
     operationQueue = new ServerOperationQueue(this);
     contextDirectoryManager =
         new ServerContextManager(this, resourceProvider, packageMapProvider);
+    onContextsChanged =
+        contextDirectoryManager.onContextsChanged.asBroadcastStream();
     AnalysisEngine.instance.logger = new AnalysisLogger();
     _onAnalysisStartedController = new StreamController.broadcast();
     _onAnalysisCompleteController = new StreamController.broadcast();
     _onFileAnalyzedController = new StreamController.broadcast();
     running = true;
     Notification notification = new ServerConnectedParams().toNotification();
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
   }
 
@@ skipping 171 matching lines @@
             return;
           }
           if (response != null) {
             channel.sendResponse(response);
             return;
           }
         } on RequestFailure catch (exception) {
           channel.sendResponse(exception.response);
           return;
         } catch (exception, stackTrace) {
-          RequestError error = new RequestError(
-              RequestErrorCode.SERVER_ERROR,
-              exception.toString());
+          RequestError error =
+              new RequestError(RequestErrorCode.SERVER_ERROR, exception.toString());
           if (stackTrace != null) {
             error.stackTrace = stackTrace.toString();
           }
           Response response = new Response(request.id, error: error);
           channel.sendResponse(response);
           return;
         }
       }
       channel.sendResponse(new Response.unknownRequest(request));
     }, onError: _sendServerErrorNotification);
@@ skipping 462 matching lines @@
       index.stop();
     }
     // Defer closing the channel so that the shutdown response can be sent.
     new Future(channel.close);
   }
 
   /**
    * Schedules [performOperation] exection.
    */
   void _schedulePerformOperation() {
-    assert (!performOperationPending);
+    assert(!performOperationPending);
     new Future(performOperation);
     performOperationPending = true;
   }
 
   /**
    * Sends a fatal `server.error` notification.
    */
   void _sendServerErrorNotification(exception, stackTrace) {
     // prepare exception.toString()
     String exceptionString;
@@ skipping 12 matching lines @@
     // send the notification
     channel.sendNotification(
         new ServerErrorParams(
             true,
             exceptionString,
             stackTraceString).toNotification());
   }
 }
 
 typedef void OptionUpdater(AnalysisOptionsImpl options);