Hook for overriding the ContextManager and some code clean-up (with more to follow)

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:core' hide Resource;
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/source/optimizing_pub_package_map_provider.dart';
 import 'package:analysis_server/uri/resolver_provider.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:path/path.dart' as pathos;
 import 'package:watcher/watcher.dart';
 
 /**
- * The name of `packages` folders.
- */
-const String PACKAGES_NAME = 'packages';
-
-/**
- * File name of pubspec files.
- */
-const String PUBSPEC_NAME = 'pubspec.yaml';
-
-/**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
  */
-abstract class ContextManager {
+abstract class AbstractContextManager implements ContextManager {
   /**
    * The name of the `lib` directory.
    */
   static const String LIB_DIR_NAME = 'lib';
 
   /**
+   * The name of `packages` folders.
+   */
+  static const String PACKAGES_NAME = 'packages';
+
+  /**
+   * File name of pubspec files.
+   */
+  static const String PUBSPEC_NAME = 'pubspec.yaml';
+
+  /**
    * [_ContextInfo] object for each included directory in the most
    * recent successful call to [setRoots].
    */
   Map<Folder, _ContextInfo> _contexts = new HashMap<Folder, _ContextInfo>();
 
   /**
    * The [ResourceProvider] using which paths are converted into [Resource]s.
    */
   final ResourceProvider resourceProvider;
 
@@ skipping 36 matching lines @@
    * Provider which is used to determine the mapping from package name to
    * package folder.
    */
   final OptimizingPubPackageMapProvider _packageMapProvider;
 
   /**
    * The instrumentation service used to report instrumentation data.
    */
   final InstrumentationService _instrumentationService;
 
-  ContextManager(this.resourceProvider, this.packageResolverProvider,
+  AbstractContextManager(this.resourceProvider, this.packageResolverProvider,
       this._packageMapProvider, this._instrumentationService) {
     pathContext = resourceProvider.pathContext;
   }
 
   /**
    * Create and return a new analysis context.
    */
   AnalysisContext addContext(Folder folder, UriResolver packageUriResolver);
 
   /**
@@ skipping 26 matching lines @@
       AnalysisContext contextN = contextInfo.context;
       if (context != contextN) {
         for (Source source in contextN.sources) {
           flushedFiles.remove(source.fullName);
         }
       }
     }
     return flushedFiles.toList(growable: false);
   }
 
-  /**
-   * Return a list containing all of the contexts contained in the given
-   * [analysisRoot].
-   */
+  @override
   List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot) {
     List<AnalysisContext> contexts = <AnalysisContext>[];
     _contexts.forEach((Folder contextFolder, _ContextInfo info) {
       if (analysisRoot.isOrContains(contextFolder.path)) {
         contexts.add(info.context);
       }
     });
     return contexts;
   }
 
   /**
    * We have finished computing the package map.
    */
   void endComputePackageMap() {
     // Do nothing.
   }
 
-  /**
-   * Returns `true` if the given absolute [path] is in one of the current
-   * root folders and is not excluded.
-   */
+  @override
   bool isInAnalysisRoot(String path) {
     // check if excluded
     if (_isExcluded(path)) {
       return false;
     }
     // check if in of the roots
     for (Folder root in _contexts.keys) {
       if (root.contains(path)) {
         return true;
       }
     }
     // no
     return false;
   }
 
-  /**
-   * Rebuild the set of contexts from scratch based on the data last sent to
-   * setRoots(). Only contexts contained in the given list of analysis [roots]
-   * will be rebuilt, unless the list is `null`, in which case every context
-   * will be rebuilt.
-   */
+  @override
   void refresh(List<Resource> roots) {
     // Destroy old contexts
     List<Folder> contextFolders = _contexts.keys.toList();
     if (roots == null) {
       contextFolders.forEach(_destroyContext);
     } else {
       roots.forEach((Resource resource) {
         contextFolders.forEach((Folder contextFolder) {
           if (resource is Folder && resource.isOrContains(contextFolder.path)) {
             _destroyContext(contextFolder);
           }
         });
       });
     }
 
     // Rebuild contexts based on the data last sent to setRoots().
     setRoots(includedPaths, excludedPaths, packageRoots);
   }
 
   /**
    * Remove the context associated with the given [folder].
    */
   void removeContext(Folder folder);
 
-  /**
-   * Change the set of paths which should be used as starting points to
-   * determine the context directories.
-   */
+  @override
   void setRoots(List<String> includedPaths, List<String> excludedPaths,
       Map<String, String> packageRoots) {
     this.packageRoots = packageRoots;
 
     // Normalize all package root sources by mapping them to folders on the
     // filesystem.  Ignore any package root sources that aren't folders.
     normalizedPackageRoots = <String, String>{};
     packageRoots.forEach((String sourcePath, String targetPath) {
       Resource resource = resourceProvider.getResource(sourcePath);
       if (resource is Folder) {
@@ skipping 527 matching lines @@
     Source source = file.createSource();
     if (context == null) {
       return source;
     }
     Uri uri = context.sourceFactory.restoreUri(source);
     return file.createSource(uri);
   }
 }
 
 /**
+ * Class that maintains a mapping from included/excluded paths to a set of
+ * folders that should correspond to analysis contexts.
+ */
+abstract class ContextManager {
+  // TODO(brianwilkerson) Support:
+  //   setting the default analysis options
+  //   setting the default content cache
+  //   setting the default SDK
+  //   maintaining AnalysisContext.folderMap (or remove it)
+  //   telling server when a context has been added or removed (see onContextsChanged)
+  //   telling server when a context needs to be re-analyzed
+  //   notifying the client when results should be flushed
+  //   using analyzeFileFunctions to determine which files to analyze
+  //
+  // TODO(brianwilkerson) Move this class to a public library.
+
+//  /**
+//   * The default options used to create new analysis contexts.
+//   */
+//  AnalysisOptionsImpl get defaultOptions;
+
+  /**
+   * Return the list of excluded paths (folders and files) most recently passed
+   * to [setRoots].
+   */
+  List<String> get excludedPaths;
+
+  /**
+   * Return the list of included paths (folders and files) most recently passed
+   * to [setRoots].
+   */
+  List<String> get includedPaths;
+
+//  /**
+//   * A stream that is notified when contexts are added or removed.
+//   */
+//  Stream<ContextsChangedEvent> get onContextsChanged;
+
+  /**
+   * Return a list containing all of the contexts contained in the given
+   * [analysisRoot].
+   */
+  List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot);
+
+  /**
+   * Return `true` if the given absolute [path] is in one of the current
+   * root folders and is not excluded.
+   */
+  bool isInAnalysisRoot(String path);
+
+  /**
+   * Rebuild the set of contexts from scratch based on the data last sent to
+   * [setRoots]. Only contexts contained in the given list of analysis [roots]
+   * will be rebuilt, unless the list is `null`, in which case every context
+   * will be rebuilt.
+   */
+  void refresh(List<Resource> roots);
+
+  /**
+   * Change the set of paths which should be used as starting points to
+   * determine the context directories.
+   */
+  void setRoots(List<String> includedPaths, List<String> excludedPaths,
+      Map<String, String> packageRoots);
+}
+
+/**
+ * An indication that one or more contexts were added, changed, or removed.
+ *
+ * The lists of [added], [changed] and [removed] contexts will not contain
+ * duplications (that is, a single context will not be in any list multiple
+ * times), nor will there be any overlap between the lists (that is, a single
+ * context will not be in more than one list).
+ */
+abstract class ContextsChangedEvent {
+  /**
+   * Return the contexts that were added to the server.
+   */
+  List<AnalysisContext> get added;
+
+  /**
+   * Return the contexts that were changed.
+   */
+  List<AnalysisContext> get changed;
+
+  /**
+   * Return the contexts that were removed from the server.
+   */
+  List<AnalysisContext> get removed;
+}
+
+/**
  * Information tracked by the [ContextManager] for each context.
  */
 class _ContextInfo {
   /**
    * The [Folder] for which this information object is created.
    */
   final Folder folder;
 
   /**
    * The enclosed pubspec-based contexts.
@@ skipping 74 matching lines @@
     return excludes(resource.path);
   }
 
   /**
    * Returns `true` if [path] is the pubspec file of this context.
    */
   bool isPubspec(String path) {
     return path == pubspecPath;
   }
 }