Introduce FolderDisposition class hierarchy for use in ContextManagerCallback.

pkg/analysis_server/lib/src/context_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 context.directory.manager;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:core' hide Resource;
@@ skipping 226 matching lines @@
  * created, destroyed or updated, (b) inform the client when "pub list"
  * operations are in progress, and (c) determine which files should be
  * analyzed.
  *
  * TODO(paulberry): eliminate this interface, and instead have [ContextManager]
  * operations return data structures describing how context state should be
  * modified.
  */
 abstract class ContextManagerCallbacks {
   /**
-   * Create and return a new analysis context.
+   * Create and return a new analysis context, allowing [disposition] to govern
+   * details of how the context is to be created.
    */
-  AnalysisContext addContext(
-      Folder folder, UriResolver packageUriResolver, Packages packages);
+  AnalysisContext addContext(Folder folder, FolderDisposition disposition);
 
   /**
    * Called when the set of files associated with a context have changed (or
    * some of those files have been modified).  [changeSet] is the set of
    * changes that need to be applied to the context.
    */
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet);
 
   /**
    * Called when the ContextManager is about to start computing the package
@@ skipping 16 matching lines @@
    * (they will no longer be analyzed by any context).
    */
   void removeContext(Folder folder, List<String> flushedFiles);
 
   /**
    * Return `true` if the given [file] should be analyzed.
    */
   bool shouldFileBeAnalyzed(File file);
 
   /**
-   * Called when the package map for a context has changed.
+   * Called when the disposition for a context has changed.
    */
   void updateContextPackageUriResolver(
-      Folder contextFolder, UriResolver packageUriResolver, Packages packages);
+      Folder contextFolder, FolderDisposition disposition);
 }
 
 /**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
  */
 class ContextManagerImpl implements ContextManager {
   /**
    * Temporary flag to hide WIP .packages support (DEP 5).
    */
@@ skipping 225 matching lines @@
       });
       if (!isIncluded) {
         _destroyContext(contextInfo);
       }
     }
     // Update package roots for existing contexts
     for (ContextInfo info in _rootInfo.descendants) {
       String newPackageRoot = normalizedPackageRoots[info.folder.path];
       if (info.packageRoot != newPackageRoot) {
         info.packageRoot = newPackageRoot;
-        _recomputePackageUriResolver(info);
+        _recomputeFolderDisposition(info);
       }
     }
     // create new contexts
     for (Folder includedFolder in includedFolders) {
       bool wasIncluded = contextInfos.any((info) {
         return info.folder.isOrContains(includedFolder.path);
       });
       if (!wasIncluded) {
         _createContexts(_rootInfo, includedFolder, false);
       }
@@ skipping 123 matching lines @@
   void _checkForPackagespecUpdate(
       String path, ContextInfo info, Folder folder) {
     // Check to see if this is the .packages file for this context and if so,
     // update the context's source factory.
     if (pathContext.basename(path) == PACKAGE_SPEC_NAME &&
         info.isPathToPackageDescription(path)) {
       File packagespec = resourceProvider.getFile(path);
       if (packagespec.exists) {
         Packages packages = _readPackagespec(packagespec);
         if (packages != null) {
-          callbacks.updateContextPackageUriResolver(folder, null, packages);
+          callbacks.updateContextPackageUriResolver(
+              folder, new PackagesFileDisposition(packages));
         }
       }
     }
   }
 
   /**
    * Compute the set of files that are being flushed, this is defined as
    * the set of sources in the removed context (context.sources), that are
    * orphaned by this context being removed (no other context includes this
    * file.)
    */
   List<String> _computeFlushedFiles(ContextInfo info) {
     AnalysisContext context = info.context;
     HashSet<String> flushedFiles = new HashSet<String>();
     for (Source source in context.sources) {
       flushedFiles.add(source.fullName);
     }
     for (ContextInfo contextInfo in _rootInfo.descendants) {
       AnalysisContext contextN = contextInfo.context;
       if (context != contextN) {
         for (Source source in contextN.sources) {
           flushedFiles.remove(source.fullName);
         }
       }
     }
     return flushedFiles.toList(growable: false);
   }
 
   /**
-   * Compute the appropriate package URI resolver for [folder], and store
-   * dependency information in [info]. Return `null` if no package map can
-   * be computed.
+   * Compute the appropriate [FolderDisposition] for [folder], and store
+   * dependency information in [info].
    */
-  UriResolver _computePackageUriResolver(Folder folder, ContextInfo info) {
+  FolderDisposition _computeFolderDisposition(Folder folder, ContextInfo info) {
     _cancelDependencySubscriptions(info);
     if (info.packageRoot != null) {
       info.packageMapInfo = null;
       // TODO(paulberry): We shouldn't be using JavaFile here because it
       // makes the code untestable (see dartbug.com/23909).
       JavaFile packagesDir = new JavaFile(info.packageRoot);
       Map<String, List<Folder>> packageMap = new Map<String, List<Folder>>();
       if (packagesDir.isDirectory()) {
         for (JavaFile file in packagesDir.listFiles()) {
           // Ensure symlinks in packages directory are canonicalized
           // to prevent 'type X cannot be assigned to type X' warnings
           String path;
           try {
             path = file.getCanonicalPath();
           } catch (e, s) {
             // Ignore packages that do not exist
             _instrumentationService.logException(e, s);
             continue;
           }
           Resource res = resourceProvider.getResource(path);
           if (res is Folder) {
             packageMap[file.getName()] = <Folder>[res];
           }
         }
-        return new PackageMapUriResolver(resourceProvider, packageMap);
+        return new PackageMapDisposition(packageMap);
       }
       // The package root does not exist (or is not a folder).  Since
       // [setRoots] ignores any package roots that don't exist (or aren't
       // folders), the only way we should be able to get here is due to a race
       // condition.  In any case, the package root folder is gone, so we can't
       // resolve packages.
-      return null;
+      return new NoPackageFolderDisposition();
     } else {
       callbacks.beginComputePackageMap();
       if (packageResolverProvider != null) {
         UriResolver resolver = packageResolverProvider(folder);
         if (resolver != null) {
-          return resolver;
+          return new CustomPackageResolverDisposition(resolver);
         }
       }
       OptimizingPubPackageMapInfo packageMapInfo;
       ServerPerformanceStatistics.pub.makeCurrentWhile(() {
         packageMapInfo =
             _packageMapProvider.computePackageMap(folder, info.packageMapInfo);
       });
       callbacks.endComputePackageMap();
       for (String dependencyPath in packageMapInfo.dependencies) {
         Resource resource = resourceProvider.getResource(dependencyPath);
         if (resource is File) {
           StreamSubscription<WatchEvent> subscription;
           subscription = resource.changes.listen((WatchEvent event) {
             if (info.packageMapInfo != null &&
                 info.packageMapInfo.isChangedDependency(
                     dependencyPath, resourceProvider)) {
-              _recomputePackageUriResolver(info);
+              _recomputeFolderDisposition(info);
             }
           }, onError: (error, StackTrace stackTrace) {
             // Gracefully degrade if file is or becomes unwatchable
             _instrumentationService.logException(error, stackTrace);
             subscription.cancel();
             info.dependencySubscriptions.remove(subscription);
           });
           info.dependencySubscriptions.add(subscription);
         }
       }
       info.packageMapInfo = packageMapInfo;
       if (packageMapInfo.packageMap == null) {
-        return null;
+        return new NoPackageFolderDisposition();
       }
-      return new PackageMapUriResolver(
-          resourceProvider, packageMapInfo.packageMap);
-      // TODO(paulberry): if any of the dependencies is outside of [folder],
-      // we'll need to watch their parent folders as well.
+      return new PackageMapDisposition(packageMapInfo.packageMap);
     }
   }
 
   /**
    * Create a new empty context associated with [folder], having parent
    * [parent] and using [packagespecFile] to resolve package URI's.
    */
   ContextInfo _createContext(
       ContextInfo parent, Folder folder, File packagespecFile) {
     ContextInfo info = new ContextInfo(
         parent, folder, packagespecFile, normalizedPackageRoots[folder.path]);
     Map<String, YamlNode> options = analysisOptionsProvider.getOptions(folder);
     processOptionsForContext(info, options);
     info.changeSubscription = folder.changes.listen((WatchEvent event) {
       _handleWatchEvent(folder, info, event);
     });
     try {
-      Packages packages;
-      UriResolver packageUriResolver;
+      FolderDisposition disposition;
 
       if (ENABLE_PACKAGESPEC_SUPPORT) {
         // Try .packages first.
         if (pathos.basename(packagespecFile.path) == PACKAGE_SPEC_NAME) {
-          packages = _readPackagespec(packagespecFile);
+          Packages packages = _readPackagespec(packagespecFile);
+          disposition = new PackagesFileDisposition(packages);
         }
       }
 
       // Next resort to a package uri resolver.
-      if (packages == null) {
-        packageUriResolver = _computePackageUriResolver(folder, info);
+      if (disposition == null) {
+        disposition = _computeFolderDisposition(folder, info);
       }
 
-      info.context = callbacks.addContext(folder, packageUriResolver, packages);
+      info.context = callbacks.addContext(folder, disposition);
       info.context.name = folder.path;
     } catch (_) {
       info.changeSubscription.cancel();
       rethrow;
     }
     return info;
   }
 
   /**
    * Potentially create a new context associated with the given [folder].
@@ skipping 255 matching lines @@
           callbacks.applyChangesToContext(folder, changeSet);
         }
         break;
     }
 
     //TODO(pquitslund): find the right place for this
     _checkForPackagespecUpdate(path, info, folder);
 
     if (info.packageMapInfo != null &&
         info.packageMapInfo.isChangedDependency(path, resourceProvider)) {
-      _recomputePackageUriResolver(info);
+      _recomputeFolderDisposition(info);
     }
   }
 
   /**
    * Returns `true` if the given [path] is excluded by [excludedPaths].
    */
   bool _isExcluded(String path) => _isExcludedBy(excludedPaths, path);
 
   /**
    * Returns `true` if the given [path] is excluded by [excludedPaths].
@@ skipping 47 matching lines @@
       Map<String, Uri> map =
           pkgfile.parse(UTF8.encode(contents), new Uri.file(specFile.path));
       return new MapPackages(map);
     } catch (_) {
       //TODO(pquitslund): consider creating an error for the spec file.
       return null;
     }
   }
 
   /**
-   * Recompute the package URI resolver for the context described by [info],
+   * Recompute the [FolderDisposition] for the context described by [info],
    * and update the client appropriately.
    */
-  void _recomputePackageUriResolver(ContextInfo info) {
+  void _recomputeFolderDisposition(ContextInfo info) {
     // TODO(paulberry): when computePackageMap is changed into an
     // asynchronous API call, we'll want to suspend analysis for this context
     // while we're rerunning "pub list", since any analysis we complete while
     // "pub list" is in progress is just going to get thrown away anyhow.
-    UriResolver packageUriResolver =
-        _computePackageUriResolver(info.folder, info);
-    callbacks.updateContextPackageUriResolver(
-        info.folder, packageUriResolver, null);
+    FolderDisposition disposition =
+        _computeFolderDisposition(info.folder, info);
+    callbacks.updateContextPackageUriResolver(info.folder, disposition);
   }
 
   /**
    * Create and return a source representing the given [file] within the given
    * [context].
    */
   static Source createSourceInContext(AnalysisContext context, File file) {
     // TODO(brianwilkerson) Optimize this, by allowing support for source
     // factories to restore URI's from a file path rather than a source.
     Source source = file.createSource();
@@ skipping 29 matching lines @@
    */
   final List<AnalysisContext> removed;
 
   /**
    * Initialize a newly created event to indicate which contexts have changed.
    */
   ContextsChangedEvent({this.added: AnalysisContext.EMPTY_LIST,
       this.changed: AnalysisContext.EMPTY_LIST,
       this.removed: AnalysisContext.EMPTY_LIST});
 }
+
+/**
+ * Concrete [FolderDisposition] object indicating that the context for a given
+ * folder should resolve package URIs using a custom URI resolver.
+ */
+class CustomPackageResolverDisposition extends FolderDisposition {
+  /**
+   * The [UriResolver] that should be used to resolve package URIs.
+   */
+  UriResolver resolver;
+
+  CustomPackageResolverDisposition(this.resolver);
+
+  @override
+  Packages get packages => null;
+
+  @override
+  Iterable<UriResolver> createPackageUriResolvers(
+      ResourceProvider resourceProvider) => <UriResolver>[resolver];
+}
+
+/**
+ * An instance of the class [FolderDisposition] represents the information
+ * gathered by the [ContextManagerImpl] to determine how to create an
+ * [AnalysisContext] for a given folder.
+ *
+ * Note: [ContextManagerImpl] may use equality testing and hash codes to
+ * determine when two folders should share the same context, so derived classes
+ * may need to override operator== and hashCode() if object identity is
+ * insufficient.
+ *
+ * TODO(paulberry): consider adding a flag to indicate that it is not necessary
+ * to recurse into the given folder looking for additional contexts to create
+ * or files to analyze (this could help avoid unnecessarily weighing down the
+ * system with file watchers).
+ */
+abstract class FolderDisposition {
+  /**
+   * If contexts governed by this [FolderDisposition] should resolve packages
+   * using the ".packages" file mechanism (DEP 5), retrieve the [Packages]
+   * object that resulted from parsing the ".packages" file.
+   */
+  Packages get packages;
+
+  /**
+   * Create all the [UriResolver]s which should be used to resolve packages in
+   * contexts governed by this [FolderDisposition].
+   *
+   * [resourceProvider] is provided since it is needed to construct most
+   * [UriResolver]s.
+   */
+  Iterable<UriResolver> createPackageUriResolvers(
+      ResourceProvider resourceProvider);
+}
+
+/**
+ * Concrete [FolderDisposition] object indicating that the context for a given
+ * folder should not resolve "package:" URIs at all.
+ *
+ * TODO(paulberry): consider making this a singleton object (which would cause
+ * all folders that don't resolve "package:" URIs to share the same context).
+ */
+class NoPackageFolderDisposition extends FolderDisposition {
+  @override
+  Packages get packages => null;
+
+  @override
+  Iterable<UriResolver> createPackageUriResolvers(
+      ResourceProvider resourceProvider) => const <UriResolver>[];
+}
+
+/**
+ * Concrete [FolderDisposition] object indicating that the context for a given
+ * folder should resolve packages using a package map.
+ */
+class PackageMapDisposition extends FolderDisposition {
+  final Map<String, List<Folder>> packageMap;
+
+  PackageMapDisposition(this.packageMap);
+
+  @override
+  Packages get packages => null;
+
+  @override
+  Iterable<UriResolver> createPackageUriResolvers(
+          ResourceProvider resourceProvider) =>
+      <UriResolver>[new PackageMapUriResolver(resourceProvider, packageMap)];
+}
+
+/**
+ * Concrete [FolderDisposition] object indicating that the context for a given
+ * folder should resolve packages using a ".packages" file.
+ */
+class PackagesFileDisposition extends FolderDisposition {
+  @override
+  final Packages packages;
+
+  PackagesFileDisposition(this.packages) {}
+
+  @override
+  Iterable<UriResolver> createPackageUriResolvers(
+      ResourceProvider resourceProvider) => const <UriResolver>[];
+}