Rerun "pub list" when pubspec.lock changes.

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:analysis_server/src/analysis_logger.dart';
@@ skipping 26 matching lines @@
 final DirectoryBasedDartSdk SHARED_SDK = DirectoryBasedDartSdk.defaultSdk;
 
 class AnalysisServerContextDirectoryManager extends ContextDirectoryManager {
   final AnalysisServer analysisServer;
 
   /**
    * The default options used to create new analysis contexts.
    */
   AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
 
-  AnalysisServerContextDirectoryManager(this.analysisServer, ResourceProvider resourceProvider)
-      : super(resourceProvider);
+  AnalysisServerContextDirectoryManager(
+      this.analysisServer, ResourceProvider resourceProvider,
+      PackageMapProvider packageMapProvider)
+      : super(resourceProvider, packageMapProvider);
 
   @override
-  void addContext(Folder folder) {
-    Map<String, List<Folder>> packageMap =
-        analysisServer.packageMapProvider.computePackageMap(folder);
-    ContextDirectory contextDirectory = new ContextDirectory(
-        analysisServer.defaultSdk, resourceProvider, folder, packageMap);
-    analysisServer.folderMap[folder] = contextDirectory;
-    AnalysisContext context = contextDirectory.context;
+  void addContext(Folder folder, Map<String, List<Folder>> packageMap) {
+    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
+    analysisServer.folderMap[folder] = context;
+    context.sourceFactory = _createSourceFactory(packageMap);
     context.analysisOptions = new AnalysisOptionsImpl.con1(defaultOptions);
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
-    AnalysisContext context = analysisServer.folderMap[contextFolder].context;
+    AnalysisContext context = analysisServer.folderMap[contextFolder];
     context.applyChanges(changeSet);
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   @override
   void removeContext(Folder folder) {
     analysisServer.folderMap.remove(folder);
   }
+
+  @override
+  void updateContextPackageMap(Folder contextFolder,
+                               Map<String, List<Folder>> packageMap) {
+    AnalysisContext context = analysisServer.folderMap[contextFolder];
+    context.sourceFactory = _createSourceFactory(packageMap);
+    analysisServer.schedulePerformAnalysisOperation(context);
+  }
+
+  /**
+   * Set up a [SourceFactory] that resolves packages using the given
+   * [packageMap].
+   */
+  SourceFactory _createSourceFactory(Map<String, List<Folder>> packageMap) {

[Brian Wilkerson, 2014/06/30 16:53:16]

Do we need to handle the case where the package map is either null or empty (for
non-pub contexts)?

[Paul Berry, 2014/06/30 17:43:00]

We don't need special code to handle an empty package map--PackageMapUriResolver
handles that fine.

You're right that non-pub contexts aren't handled correctly, but fixing that is
going to be more complex than handling null here--I'll also need to handle null
being returned from computePackageMap() in
ContextDirectoryManager._createContext() and
ContextDirectoryManager._handleWatchEvent().  I'll add TODO's and address that
in a future CL.

+    List<UriResolver> resolvers = <UriResolver>[
+        new DartUriResolver(analysisServer.defaultSdk),
+        new ResourceUriResolver(resourceProvider),

[Brian Wilkerson, 2014/06/30 16:53:16]

I assume ResourceUriResolver handles file: URI's, in which case it probably
wants to be last in the list.

[Paul Berry, 2014/06/30 17:43:00]

You're correct that ResourceUriResolver only handles "file:" URIs, but I think
this means that the order doesn't matter.  DartUriResolver handles only "dart:"
URIs, and PackageMapUriResolver handles only "package:" URIs, so the only
consequence of changing the order would be a negligible performance difference.

+        new PackageMapUriResolver(resourceProvider, packageMap)
+    ];
+    return new SourceFactory(resolvers);
+  }
 }
 
 /**
  * Instances of the class [AnalysisServer] implement a server that listens on a
  * [CommunicationChannel] for analysis requests and process them.
  */
 class AnalysisServer {
   /**
    * The channel from which requests are received and to which responses should
    * be sent.
    */
   final ServerCommunicationChannel channel;
 
   /**
    * The [Index] for this server.
    */
   final Index index;
 
   /**
    * [ContextDirectoryManager] which handles the mapping from analysis roots
    * to context directories.
    */
   AnalysisServerContextDirectoryManager contextDirectoryManager;
 
   /**
-   * Provider which is used to determine the mapping from package name to
-   * package folder.
-   */
-  final PackageMapProvider packageMapProvider;
-
-  /**
    * A flag indicating whether the server is running.  When false, contexts
    * will no longer be added to [contextWorkQueue], and [performOperation] will
    * discard any tasks it finds on [contextWorkQueue].
    */
   bool running;
 
   /**
    * A flag indicating the value of the 'analyzing' parameter sent in the last
    * status message to the client.
    */
   bool statusAnalyzing = false;
 
   /**
    * A list of the request handlers used to handle the requests sent to this
    * server.
    */
   List<RequestHandler> handlers;
 
   /**
    * The current default [DartSdk].
    */
   DartSdk defaultSdk = SHARED_SDK;
 
   /**
-   * A table mapping [Folder]s to the [ContextDirectory]s associated with them.
+   * A table mapping [Folder]s to the [AnalysisContext]s associated with them.
    */
-  final Map<Folder, ContextDirectory> folderMap =
-      new HashMap<Folder, ContextDirectory>();
+  final Map<Folder, AnalysisContext> folderMap =
+      new HashMap<Folder, AnalysisContext>();
 
   /**
    * A queue of the operations to perform in this server.
    *
    * Invariant: when this queue is non-empty, there is exactly one pending call
    * to [performOperation] on the event queue.  When this list is empty, there are
    * no calls to [performOperation] on the event queue.
    */
   ServerOperationQueue operationQueue;
 
@@ skipping 18 matching lines @@
   /**
    * 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, ResourceProvider resourceProvider,
-      this.packageMapProvider, this.index, {this.rethrowExceptions: true}) {
+      PackageMapProvider packageMapProvider, this.index,
+      {this.rethrowExceptions: true}) {
     operationQueue = new ServerOperationQueue(this);
-    contextDirectoryManager = new AnalysisServerContextDirectoryManager(this, resourceProvider);
+    contextDirectoryManager = new AnalysisServerContextDirectoryManager(
+        this, resourceProvider, packageMapProvider);
     AnalysisEngine.instance.logger = new AnalysisLogger();
     running = true;
     Notification notification = new Notification(SERVER_CONNECTED);
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
   }
 
   /**
    * Schedules execution of the given [ServerOperation].
    */
@@ skipping 38 matching lines @@
         }
         sourceList.add(_getSource(file));
       }
     });
     if (unanalyzed.isNotEmpty) {
       StringBuffer buffer = new StringBuffer();
       buffer.writeAll(unanalyzed, ', ');
       throw new RequestFailure(new Response.unanalyzedPriorityFiles(request,
           buffer.toString()));
     }
-    folderMap.forEach((Folder folder, ContextDirectory directory) {
-      AnalysisContext context = directory.context;
+    folderMap.forEach((Folder folder, AnalysisContext context) {
       List<Source> sourceList = sourceMap[context];
       if (sourceList == null) {
         sourceList = Source.EMPTY_ARRAY;
       }
       context.analysisPriorityOrder = sourceList;
     });
   }
 
   /**
    * Use the given updaters to update the values of the options in every
    * existing analysis context.
    */
   void updateOptions(List<OptionUpdater> optionUpdaters) {
     //
     // Update existing contexts.
     //
-    folderMap.forEach((Folder folder, ContextDirectory directory) {
-      AnalysisContext context = directory.context;
+    folderMap.forEach((Folder folder, AnalysisContext context) {
       AnalysisOptionsImpl options = new AnalysisOptionsImpl.con1(context.analysisOptions);
       optionUpdaters.forEach((OptionUpdater optionUpdater) {
         optionUpdater(options);
       });
       context.analysisOptions = options;
     });
     //
     // Update the defaults used to create new contexts.
     //
     AnalysisOptionsImpl options = contextDirectoryManager.defaultOptions;
@@ skipping 216 matching lines @@
     this.analysisServices = subscriptions;
   }
 
   /**
    * Return the [AnalysisContext] that is used to analyze the given [path].
    * Return `null` if there is no such context.
    */
   AnalysisContext _getAnalysisContext(String path) {
     for (Folder folder in folderMap.keys) {
       if (path.startsWith(folder.path)) {
-        return folderMap[folder].context;
+        return folderMap[folder];
       }
     }
     return null;
   }
 
   /**
    * Return the [Source] of the Dart file with the given [path].
    */
   Source _getSource(String path) {
     File file = contextDirectoryManager.resourceProvider.getResource(path);
@@ skipping 72 matching lines @@
   static const AnalysisService NAVIGATION = const AnalysisService('NAVIGATION', 2);
   static const AnalysisService OUTLINE = const AnalysisService('OUTLINE', 3);
 
   static const List<AnalysisService> VALUES =
       const [ERRORS, HIGHLIGHTS, NAVIGATION, OUTLINE];
 
   const AnalysisService(String name, int ordinal) : super(name, ordinal);
 }
 
 
-/**
- * Instances of [ContextDirectory] represents a [Folder] associated with an
- * analysis context.  The folder may or may not contain a Pub `pubspec.yaml`.
- *
- * TODO(scheglov) implement complete projects/contexts semantics.
- *
- * This class is intentionally simplified to serve as a base to start working
- * on services while work on complete semantics is being done in parallel.
- */
-class ContextDirectory {
-  /**
-   * The root [ResourceProvider] of this [ContextDirectory].
-   */
-  final ResourceProvider _resourceProvider;
-
-  /**
-   * The root [Folder] of this [ContextDirectory].
-   */
-  final Folder _folder;
-
-  /**
-   * The [AnalysisContext] of this [_folder].
-   */
-  AnalysisContext _context;
-
-  ContextDirectory(DartSdk sdk, this._resourceProvider, this._folder,
-      Map<String, List<Folder>> packageMap) {
-    // create AnalysisContext
-    _context = AnalysisEngine.instance.createAnalysisContext();
-    // TODO(scheglov) replace FileUriResolver with an Resource based resolver
-    List<UriResolver> resolvers = <UriResolver>[new DartUriResolver(sdk),
-        new ResourceUriResolver(_resourceProvider),
-    ];
-    if (packageMap != null) {
-      resolvers.add(new PackageMapUriResolver(_resourceProvider, packageMap));
-    }
-    _context.sourceFactory = new SourceFactory(resolvers);
-  }
-
-  /**
-   * Return the [AnalysisContext] of this folder.
-   */
-  AnalysisContext get context => _context;
-}
-
 typedef void OptionUpdater(AnalysisOptionsImpl options);
 
 /**
  * An enumeration of the services provided by the server domain.
  */
 class ServerService extends Enum2<ServerService> {
   static const ServerService STATUS = const ServerService('STATUS', 0);
 
   static const List<ServerService> VALUES = const [STATUS];
 
   const ServerService(String name, int ordinal) : super(name, ordinal);
 }