Introduce FolderDisposition class hierarchy for use in ContextManagerCallback.

pkg/analysis_server/test/context_manager_test.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 test.context.directory.manager;
 
 import 'dart:collection';
 
 import 'package:analysis_server/src/context_manager.dart';
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 125 matching lines @@
 
   UriResolver providePackageResolver(Folder folder) {
     return packageResolver;
   }
 
   void setUp() {
     resourceProvider = new MemoryResourceProvider();
     packageMapProvider = new MockPackageMapProvider();
     manager = new ContextManagerImpl(resourceProvider, providePackageResolver,
         packageMapProvider, InstrumentationService.NULL_SERVICE);
-    callbacks = new TestContextManagerCallbacks();
+    callbacks = new TestContextManagerCallbacks(resourceProvider);
     manager.callbacks = callbacks;
     resourceProvider.newFolder(projPath);
     ContextManagerImpl.ENABLE_PACKAGESPEC_SUPPORT = true;
   }
 
   void tearDown() {
     ContextManagerImpl.ENABLE_PACKAGESPEC_SUPPORT = false;
   }
 
   void test_contextsInAnalysisRoot_nestedContext() {
@@ skipping 1264 matching lines @@
     String filePath = '$projPath/bin/main.dart';
 
     resourceProvider.newFile(packagesPath, '');
     resourceProvider.newFile(filePath, 'library main;');
 
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
 
     Map<String, int> filePaths = callbacks.currentContextFilePaths[projPath];
     expect(filePaths, hasLength(1));
     expect(filePaths, contains(filePath));
-    Packages packages = callbacks.currentContextPackagespecs[projPath];
+    Packages packages = callbacks.currentContextDispositions[projPath].packages;
     expect(packages.packages, isEmpty);
 
     // update .packages
     callbacks.now++;
     resourceProvider.modifyFile(packagesPath, 'main:./lib/');
     return pumpEventQueue().then((_) {
       // verify new package info
-      packages = callbacks.currentContextPackagespecs[projPath];
+      packages = callbacks.currentContextDispositions[projPath].packages;
       expect(packages.packages, unorderedEquals(['main']));
     });
   }
 
   /**
    * Verify that package URI's for source files in [path] will be resolved
    * using a package map matching [expectation].
    */
   void _checkPackageMap(String path, expectation) {
-    UriResolver resolver = callbacks.currentContextPackageUriResolvers[path];
+    FolderDisposition disposition = callbacks.currentContextDispositions[path];
     Map<String, List<Folder>> packageMap =
-        resolver is PackageMapUriResolver ? resolver.packageMap : null;
+        disposition is PackageMapDisposition ? disposition.packageMap : null;
     expect(packageMap, expectation);
   }
 
   /**
    * Verify that package URI's for source files in [path] will be resolved
    * using a package root maching [expectation].
    */
   void _checkPackageRoot(String path, expectation) {
-    UriResolver resolver = callbacks.currentContextPackageUriResolvers[path];
-    expect(resolver, new isInstanceOf<PackageUriResolver>());
-    PackageUriResolver packageUriResolver = resolver;
-    expect(packageUriResolver.packagesDirectory_forTesting, expectation);
+    // TODO(paulberry): this code needs to be reworked, since the context
+    // manager inspects the contents of the package root directory and converts
+    // it to a package map.  The only reason this code used to work was due to
+    // dartbug.com/23909.
+    fail('Cannot verify package root');
   }
 }
 
 class TestContextManagerCallbacks extends ContextManagerCallbacks {
   /**
    * Source of timestamps stored in [currentContextFilePaths].
    */
   int now = 0;
 
   /**
@@ skipping 13 matching lines @@
       <String, Map<String, int>>{};
 
   /**
    * A map from the paths of contexts to a set of the sources that should be
    * explicitly analyzed in those contexts.
    */
   final Map<String, Set<Source>> currentContextSources = <String, Set<Source>>{
   };
 
   /**
-   * Map from context to package URI resolver.
+   * Map from context to folder disposition.
    */
-  final Map<String, UriResolver> currentContextPackageUriResolvers =
-      <String, UriResolver>{};
+  final Map<String, FolderDisposition> currentContextDispositions =
+      <String, FolderDisposition>{};
 
   /**
-   * Map from context to packages object.
+   * Resource provider used for this test.
    */
-  final Map<String, Packages> currentContextPackagespecs = <String, Packages>{};
+  final ResourceProvider resourceProvider;
+
+  TestContextManagerCallbacks(this.resourceProvider);
 
   /**
    * Iterable of the paths to contexts that currently exist.
    */
   Iterable<String> get currentContextPaths => currentContextTimestamps.keys;
 
   @override
-  AnalysisContext addContext(
-      Folder folder, UriResolver packageUriResolver, Packages packages) {
+  AnalysisContext addContext(Folder folder, FolderDisposition disposition) {
     String path = folder.path;
     expect(currentContextPaths, isNot(contains(path)));
     currentContextTimestamps[path] = now;
     currentContextFilePaths[path] = <String, int>{};
     currentContextSources[path] = new HashSet<Source>();
-    currentContextPackageUriResolvers[path] = packageUriResolver;
-    currentContextPackagespecs[path] = packages;
+    currentContextDispositions[path] = disposition;
     currentContext = AnalysisEngine.instance.createAnalysisContext();
     List<UriResolver> resolvers = [new FileUriResolver()];
-    if (packageUriResolver != null) {
-      resolvers.add(packageUriResolver);
-    }
-    currentContext.sourceFactory = new SourceFactory(resolvers, packages);
+    resolvers.addAll(disposition.createPackageUriResolvers(resourceProvider));
+    currentContext.sourceFactory =
+        new SourceFactory(resolvers, disposition.packages);
     return currentContext;
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     Map<String, int> filePaths = currentContextFilePaths[contextFolder.path];
     Set<Source> sources = currentContextSources[contextFolder.path];
 
     for (Source source in changeSet.addedSources) {
       expect(filePaths, isNot(contains(source.fullName)));
@@ skipping 22 matching lines @@
     expect(currentContextPaths, unorderedEquals(expected));
   }
 
   @override
   void removeContext(Folder folder, List<String> flushedFiles) {
     String path = folder.path;
     expect(currentContextPaths, contains(path));
     currentContextTimestamps.remove(path);
     currentContextFilePaths.remove(path);
     currentContextSources.remove(path);
-    currentContextPackageUriResolvers.remove(path);
+    currentContextDispositions.remove(path);
   }
 
   @override
   bool shouldFileBeAnalyzed(File file) {
     if (!(AnalysisEngine.isDartFileName(file.path) ||
         AnalysisEngine.isHtmlFileName(file.path))) {
       return false;
     }
     // Emacs creates dummy links to track the fact that a file is open for
     // editing and has unsaved changes (e.g. having unsaved changes to
     // 'foo.dart' causes a link '.#foo.dart' to be created, which points to the
     // non-existent file 'username@hostname.pid'.  To avoid these dummy links
     // causing the analyzer to thrash, just ignore links to non-existent files.
     return file.exists;
   }
 
   @override
   void updateContextPackageUriResolver(
-      Folder contextFolder, UriResolver packageUriResolver, Packages packages) {
-    currentContextPackageUriResolvers[contextFolder.path] = packageUriResolver;
-    currentContextPackagespecs[contextFolder.path] = packages;
+      Folder contextFolder, FolderDisposition disposition) {
+    currentContextDispositions[contextFolder.path] = disposition;
   }
 }
 
 /**
  * A [Source] that knows it's [fullName].
  */
 class TestSource implements Source {
   TestSource();
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 class TestUriResolver extends UriResolver {
   Map<Uri, Source> uriMap;
 
   TestUriResolver(this.uriMap);
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     return uriMap[uri];
   }
 }