Create a new class for managing the set of analysis roots.

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 'package:analysis_server/src/analysis_logger.dart';
 import 'package:analysis_server/src/channel.dart';
+import 'package:analysis_server/src/context_directory_manager.dart';
 import 'package:analysis_server/src/domain_analysis.dart';
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/resource.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/sdk_io.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 
 
 /**
  * An instance of [DirectoryBasedDartSdk] that is shared between
  * [AnalysisServer] instances to improve performance.
  */
 final DirectoryBasedDartSdk SHARED_SDK = DirectoryBasedDartSdk.defaultSdk;
 
+class AnalysisServerContextDirectoryManager extends ContextDirectoryManager {
+  final AnalysisServer analysisServer;
+
+  AnalysisServerContextDirectoryManager(this.analysisServer, ResourceProvider resourceProvider)
+      : super(resourceProvider);
+
+  void addContext(Folder folder) {
+    PubFolder pubFolder = new PubFolder(analysisServer.defaultSdk, folder);
+    analysisServer.folderMap[folder] = pubFolder;
+    analysisServer.addContextToWorkQueue(pubFolder.context);
+  }
+}
+
 /**
  * Instances of the class [AnalysisServer] implement a server that listens on a
  * [CommunicationChannel] for analysis requests and process them.
  */
 class AnalysisServer {
   /**
    * The name of the parameter whose value is a list of errors.
    */
   static const String ERRORS_PARAM = 'errors';
 
@@ skipping 12 matching lines @@
    */
   static const String STATUS_NOTIFICATION = 'server.status';
 
   /**
    * The channel from which requests are received and to which responses should
    * be sent.
    */
   final ServerCommunicationChannel channel;
 
   /**
-   * The [ResourceProvider] using which paths are converted into [Resource]s.
+   * [ContextDirectoryManager] which handles the mapping from analysis roots
+   * to context directories.
    */
-  final ResourceProvider resourceProvider;
+  AnalysisServerContextDirectoryManager contextDirectoryManager;
 
   /**
    * A flag indicating whether the server is running.  When false, contexts
    * will no longer be added to [contextWorkQueue], and [performTask] will
    * discard any tasks it finds on [contextWorkQueue].
    */
   bool running;
 
   /**
    * A list of the request handlers used to handle the requests sent to this
@@ skipping 39 matching lines @@
 
   /**
    * A set of the [ServerService]s to send notifications for.
    */
   Set<ServerService> serverServices = new Set<ServerService>();
 
   /**
    * Initialize a newly created server to receive requests from and send
    * responses to the given [channel].
    */
-  AnalysisServer(this.channel, this.resourceProvider) {
+  AnalysisServer(this.channel, ResourceProvider resourceProvider) {
+    contextDirectoryManager = new AnalysisServerContextDirectoryManager(this, resourceProvider);
     AnalysisEngine.instance.logger = new AnalysisLogger();
     running = true;
     Notification notification = new Notification(CONNECTED_NOTIFICATION);
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
   }
 
   /**
    * If [running] is true, add the given [context] to the list of analysis
    * contexts for which analysis work needs to be performed, and ensure that
@@ skipping 146 matching lines @@
    * The current implementation is intentionally simplified and expected
    * that only folders are given each given folder corresponds to the exactly
    * one context.
    *
    * So, we can start working in parallel on adding services and improving
    * projects/contexts support.
    */
   void setAnalysisRoots(String requestId,
                         List<String> includedPaths,
                         List<String> excludedPaths) {
-    // included
-    Set<Folder> includedFolders = new Set<Folder>();
-    for (int i = 0; i < includedPaths.length; i++) {
-      String path = includedPaths[i];
-      Resource resource = resourceProvider.getResource(path);
-      if (resource is Folder) {
-        includedFolders.add(resource);
-      } else {
-        // TODO(scheglov) implemented separate files analysis
-        throw new RequestFailure(
-            new Response.unsupportedFeature(
-                requestId,
-                '$path is not a folder. '
-                'Only support for folder analysis is implemented currently.'));
-      }
-    }
-    // excluded
-    // TODO(scheglov) remove when implemented
-    if (excludedPaths.isNotEmpty) {
+    try {
+      contextDirectoryManager.setRoots(includedPaths, excludedPaths);

[scheglov, 2014/05/28 20:28:41]

Does it still work for the simplest cases?

[Paul Berry, 2014/05/28 20:33:32]

AFAICT, yes.  This CL is just a refactor of existing code, and it still passes
unit tests.

+    } on UnimplementedError catch (e) {
       throw new RequestFailure(
-          new Response.unsupportedFeature(
-              requestId,
-              'Excluded paths are not supported yet'));
-    }
-    Set<Folder> excludedFolders = new Set<Folder>();
-    // diff
-    Set<Folder> currentFolders = new Set<Folder>.from(folderMap.keys);
-    Set<Folder> newFolders = includedFolders.difference(currentFolders);
-    Set<Folder> oldFolders = currentFolders.difference(includedFolders);
-    // remove old contexts
-    for (Folder folder in oldFolders) {
-      // TODO(scheglov) implement
-    }
-    // add new contexts
-    for (Folder folder in newFolders) {
-      PubFolder pubFolder = new PubFolder(defaultSdk, folder);
-      folderMap[folder] = pubFolder;
-      addContextToWorkQueue(pubFolder.context);
+                  new Response.unsupportedFeature(
+                      requestId, e.message));
     }
   }
 
   /**
    * Return the [AnalysisContext] that is used to analyze the given [path].
    * Return `null` if there is no such context.
    */
   AnalysisContext test_getAnalysisContext(String path) {
     for (Folder folder in folderMap.keys) {
       if (path.startsWith(folder.fullName)) {
         return folderMap[folder].context;
       }
     }
     return null;
   }
 
   /**
    * Return the [CompilationUnit] of the Dart file with the given [path].
    * Return `null` if the file is not a part of any context.
    */
   CompilationUnit test_getResolvedCompilationUnit(String path) {
     // prepare AnalysisContext
     AnalysisContext context = test_getAnalysisContext(path);
     if (context == null) {
       return null;
     }
     // prepare sources
-    File file = resourceProvider.getResource(path);
+    File file = contextDirectoryManager.resourceProvider.getResource(path);
     Source unitSource = file.createSource(UriKind.FILE_URI);
     List<Source> librarySources = context.getLibrariesContaining(unitSource);
     if (librarySources.isEmpty) {
       return null;
     }
     // get a resolved unit
     return context.getResolvedCompilationUnit2(unitSource, librarySources[0]);
   }
 
   /**
@@ skipping 127 matching lines @@
 /**
  * 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);
 }