Server .packages support.

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;
 
 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/analysis_options_provider.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/source/path_filter.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:package_config/packages.dart';
+import 'package:package_config/packages_file.dart' as pkgfile show parse;
+import 'package:package_config/src/packages_impl.dart' show MapPackages;
 import 'package:path/path.dart' as pathos;
 import 'package:watcher/watcher.dart';
 import 'package:yaml/yaml.dart';
 
 /**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
  */
 abstract class AbstractContextManager implements ContextManager {
+
+  /**
+   * Temporary flag to hide WIP .packages support (DEP 5).
+   */
+  static bool ENABLE_PACKAGESPEC_SUPPORT = false;
+
   /**
    * 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';
 
   /**
+   * File name of package spec files.
+   */
+  static const String PACKAGE_SPEC_NAME = '.packages';
+
+  /**
    * [_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 48 matching lines @@
   final InstrumentationService _instrumentationService;
 
   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);
+  AnalysisContext addContext(
+      Folder folder, UriResolver packageUriResolver, Packages packages);
 
   /**
    * 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);
 
   /**
    * We are about to start computing the package map.
@@ skipping 36 matching lines @@
     return contexts;
   }
 
   /**
    * We have finished computing the package map.
    */
   void endComputePackageMap() {
     // Do nothing.
   }
 
-  /// Sets the [ignorePatterns] for the context [folder].
-  void setIgnorePatternsForContext(Folder folder, List<String> ignorePatterns) {
-    _ContextInfo info = _contexts[folder];
-    if (info == null) {
-      return;
+  @override
+  bool isInAnalysisRoot(String path) {
+    // check if excluded
+    if (_isExcluded(path)) {
+      return false;
     }
-    var pathFilter = info.pathFilter;
-    pathFilter.setIgnorePatterns(ignorePatterns);
+    // check if in of the roots
+    for (Folder root in _contexts.keys) {
+      if (root.contains(path)) {
+        return true;
+      }
+    }
+    // no
+    return false;
   }
 
   /// Process [options] for the context [folder].
   void processOptionsForContext(Folder folder, Map<String, YamlNode> options) {
     _ContextInfo info = _contexts[folder];
     if (info == null) {
       return;
     }
     YamlMap analyzer = options['analyzer'];
     if (analyzer == null) {
       // No options for analyzer.
       return;
     }
 
     // Set ignore patterns.
     YamlList exclude = analyzer['exclude'];
     if (exclude != null) {
       setIgnorePatternsForContext(folder, exclude);
     }
   }
 
   @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;
-  }
-
-  @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);
 
+  /// Sets the [ignorePatterns] for the context [folder].
+  void setIgnorePatternsForContext(Folder folder, List<String> ignorePatterns) {
+    _ContextInfo info = _contexts[folder];
+    if (info == null) {
+      return;
+    }
+    var pathFilter = info.pathFilter;
+    pathFilter.setIgnorePatterns(ignorePatterns);
+  }
+
   @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);
@@ skipping 74 matching lines @@
 
   /**
    * Return `true` if the given [file] should be analyzed.
    */
   bool shouldFileBeAnalyzed(File file);
 
   /**
    * Called when the package map for a context has changed.
    */
   void updateContextPackageUriResolver(
-      Folder contextFolder, UriResolver packageUriResolver);
+      Folder contextFolder, UriResolver packageUriResolver, Packages packages);
 
   /**
    * Resursively adds all Dart and HTML files to the [changeSet].
    */
   void _addPreviouslyExcludedSources(_ContextInfo info, ChangeSet changeSet,
       Folder folder, List<String> oldExcludedPaths) {
     if (info.excludesResource(folder)) {
       return;
     }
     List<Resource> children;
@@ skipping 76 matching lines @@
   /**
    * Cancel all dependency subscriptions for the given context.
    */
   void _cancelDependencySubscriptions(_ContextInfo info) {
     for (StreamSubscription<WatchEvent> s in info.dependencySubscriptions) {
       s.cancel();
     }
     info.dependencySubscriptions.clear();
   }
 
+  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) {
+          updateContextPackageUriResolver(folder, null, packages);
+        }
+      }
+    }
+  }
+
   /**
    * Compute the appropriate package URI resolver for [folder], and store
    * dependency information in [info]. Return `null` if no package map can
    * be computed.
    */
   UriResolver _computePackageUriResolver(Folder folder, _ContextInfo info) {
     _cancelDependencySubscriptions(info);
     if (info.packageRoot != null) {
       info.packageMapInfo = null;
       JavaFile packagesDir = new JavaFile(info.packageRoot);
@@ skipping 60 matching lines @@
           resourceProvider, packageMapInfo.packageMap);
       // TODO(paulberry): if any of the dependencies is outside of [folder],
       // we'll need to watch their parent folders as well.
     }
   }
 
   /**
    * Create a new empty context associated with [folder].
    */
   _ContextInfo _createContext(
-      Folder folder, File pubspecFile, List<_ContextInfo> children) {
+      Folder folder, File packagespecFile, List<_ContextInfo> children) {
     _ContextInfo info = new _ContextInfo(
-        folder, pubspecFile, children, normalizedPackageRoots[folder.path]);
+        folder, packagespecFile, children, normalizedPackageRoots[folder.path]);
     _contexts[folder] = info;
     var options = analysisOptionsProvider.getOptions(folder);
     processOptionsForContext(folder, options);
     info.changeSubscription = folder.changes.listen((WatchEvent event) {
       _handleWatchEvent(folder, info, event);
     });
     try {
-      UriResolver packageUriResolver = _computePackageUriResolver(folder, info);
-      info.context = addContext(folder, packageUriResolver);
+      Packages packages;
+      UriResolver packageUriResolver;
+
+      if (ENABLE_PACKAGESPEC_SUPPORT) {
+        // Try .packages first.
+        if (pathos.basename(packagespecFile.path) == PACKAGE_SPEC_NAME) {
+          packages = _readPackagespec(packagespecFile);
+        }
+      }
+
+      // Next resort to a package uri resolver.
+      if (packages == null) {
+        packageUriResolver = _computePackageUriResolver(folder, info);
+      }
+
+      info.context = addContext(folder, packageUriResolver, packages);
       info.context.name = folder.path;
     } catch (_) {
       info.changeSubscription.cancel();
       rethrow;
     }
     return info;
   }
 
   /**
    * Potentially create a new context associated with the given [folder].
    *
    * If there are subfolders with 'pubspec.yaml' files, separate contexts are
    * created for them and excluded from the context associated with the
    * [folder].
    *
-   * If [withPubspecOnly] is `true`, a context will be created only if there
-   * is a 'pubspec.yaml' file in the [folder].
+   * If [withPackageSpecOnly] is `true`, a context will be created only if there
+   * is a 'pubspec.yaml' or '.packages' file in the [folder].
    *
-   * Returns create pubspec-based contexts.
+   * Returns created contexts.
    */
-  List<_ContextInfo> _createContexts(Folder folder, bool withPubspecOnly) {
-    // try to find subfolders with pubspec files
+  List<_ContextInfo> _createContexts(Folder folder, bool withPackageSpecOnly) {
+    // Try to find subfolders with pubspecs or .packages files.
     List<_ContextInfo> children = <_ContextInfo>[];
     try {
       for (Resource child in folder.getChildren()) {
         if (child is Folder) {
           children.addAll(_createContexts(child, true));
         }
       }
     } on FileSystemException {
       // The directory either doesn't exist or cannot be read. Either way, there
       // are no subfolders that need to be added.
     }
-    // check whether there is a pubspec in the folder
-    File pubspecFile = folder.getChild(PUBSPEC_NAME);
-    if (pubspecFile.exists) {
+
+    File packageSpec;
+
+    if (ENABLE_PACKAGESPEC_SUPPORT) {
+      // Start by looking for .packages.
+      packageSpec = folder.getChild(PACKAGE_SPEC_NAME);
+    }
+
+    // Fall back to looking for a pubspec.
+    if (packageSpec == null || !packageSpec.exists) {
+      packageSpec = folder.getChild(PUBSPEC_NAME);
+    }
+
+    if (packageSpec.exists) {
       return <_ContextInfo>[
-        _createContextWithSources(folder, pubspecFile, children)
+        _createContextWithSources(folder, packageSpec, children)
       ];
     }
-    // no pubspec, done
-    if (withPubspecOnly) {
+    // No packagespec? Done.
+    if (withPackageSpecOnly) {
       return children;
     }
-    // OK, create a context without a pubspec
+    // OK, create a context without a packagespec.
     return <_ContextInfo>[
-      _createContextWithSources(folder, pubspecFile, children)
+      _createContextWithSources(folder, packageSpec, children)
     ];
   }
 
   /**
    * Create a new context associated with the given [folder]. The [pubspecFile]
    * is the `pubspec.yaml` file contained in the folder. Add any sources that
    * are not included in one of the [children] to the context.
    */
   _ContextInfo _createContextWithSources(
       Folder folder, File pubspecFile, List<_ContextInfo> children) {
     _ContextInfo info = _createContext(folder, pubspecFile, children);
     ChangeSet changeSet = new ChangeSet();
     _addSourceFiles(changeSet, folder, info);
     applyChangesToContext(folder, changeSet);
     return info;
   }
 
   /**
    * Clean up and destroy the context associated with the given folder.
    */
   void _destroyContext(Folder folder) {
     _ContextInfo info = _contexts[folder];
     info.changeSubscription.cancel();
     _cancelDependencySubscriptions(info);
     removeContext(folder);
     _contexts.remove(folder);
   }
 
   /**
-   * Extract a new [pubspecFile]-based context from [oldInfo].
+   * Extract a new [packagespecFile]-based context from [oldInfo].
    */
-  void _extractContext(_ContextInfo oldInfo, File pubspecFile) {
-    Folder newFolder = pubspecFile.parent;
-    _ContextInfo newInfo = _createContext(newFolder, pubspecFile, []);
+  void _extractContext(_ContextInfo oldInfo, File packagespecFile) {
+    Folder newFolder = packagespecFile.parent;
+    _ContextInfo newInfo = _createContext(newFolder, packagespecFile, []);
     newInfo.parent = oldInfo;
     // prepare sources to extract
     Map<String, Source> extractedSources = new HashMap<String, Source>();
     oldInfo.sources.forEach((path, source) {
       if (newFolder.contains(path)) {
         extractedSources[path] = source;
       }
     });
     // update new context
     {
@@ skipping 33 matching lines @@
     }
     if (info.ignored(path)) {
       return;
     }
     // handle the change
     switch (event.type) {
       case ChangeType.ADD:
         if (_isInPackagesDir(path, folder)) {
           return;
         }
+
         Resource resource = resourceProvider.getResource(path);
-        // pubspec was added in a sub-folder, extract a new context
-        if (_isPubspec(path) && info.isRoot && !info.isPubspec(path)) {
-          _extractContext(info, resource);
-          return;
+
+        if (ENABLE_PACKAGESPEC_SUPPORT) {
+          String directoryPath = pathContext.dirname(path);
+
+          // Check to see if we need to create a new context.
+          if (info.isRoot) {
+
+            // Only create a new context if this is not the same directory
+            // described by our info object.
+            if (info.folder.path != directoryPath) {
+              if (_isPubspec(path)) {
+                // Check for a sibling .packages file.
+                if (!resourceProvider.getFile(
+                    pathos.join(directoryPath, PACKAGE_SPEC_NAME)).exists) {
+                  _extractContext(info, resource);
+                  return;
+                }
+              }
+              if (_isPackagespec(path)) {
+                // Check for a sibling pubspec.yaml file.
+                if (!resourceProvider
+                    .getFile(pathos.join(directoryPath, PUBSPEC_NAME)).exists) {
+                  _extractContext(info, resource);
+                  return;
+                }
+              }
+            }
+          }
+        } else {
+          // pubspec was added in a sub-folder, extract a new context
+          if (_isPubspec(path) &&
+              info.isRoot &&
+              !info.isPathToPackageDescription(path)) {
+            _extractContext(info, resource);
+            return;
+          }
         }
+
         // If the file went away and was replaced by a folder before we
         // had a chance to process the event, resource might be a Folder.  In
         // that case don't add it.
         if (resource is File) {
           File file = resource;
           if (shouldFileBeAnalyzed(file)) {
             ChangeSet changeSet = new ChangeSet();
             Source source = createSourceInContext(info.context, file);
             changeSet.addedSource(source);
             applyChangesToContext(folder, changeSet);
             info.sources[path] = source;
           }
         }
         break;
       case ChangeType.REMOVE:
-        // pubspec was removed, merge the context into its parent
-        if (info.isPubspec(path) && !info.isRoot) {
-          _mergeContext(info);
-          return;
+
+        // If package spec info is removed, check to see if we can merge contexts.
+        // Note that it's important to verify that there is NEITHER a .packages nor a
+        // lingering pubspec.yaml before merging.
+        if (!info.isRoot) {
+          if (ENABLE_PACKAGESPEC_SUPPORT) {
+            String directoryPath = pathContext.dirname(path);
+
+            // Only merge if this is the same directory described by our info object.
+            if (info.folder.path == directoryPath) {
+              if (_isPubspec(path)) {
+                // Check for a sibling .packages file.
+                if (!resourceProvider.getFile(
+                    pathos.join(directoryPath, PACKAGE_SPEC_NAME)).exists) {
+                  _mergeContext(info);
+                  return;
+                }
+              }
+              if (_isPackagespec(path)) {
+                // Check for a sibling pubspec.yaml file.
+                if (!resourceProvider
+                    .getFile(pathos.join(directoryPath, PUBSPEC_NAME)).exists) {
+                  _mergeContext(info);
+                  return;
+                }
+              }
+            }
+          } else {
+            if (info.isPathToPackageDescription(path)) {
+              _mergeContext(info);
+              return;
+            }
+          }
         }
+
         List<Source> sources = info.context.getSourcesWithFullName(path);
         if (!sources.isEmpty) {
           ChangeSet changeSet = new ChangeSet();
           sources.forEach((Source source) {
             changeSet.removedSource(source);
           });
           applyChangesToContext(folder, changeSet);
           info.sources.remove(path);
         }
         break;
       case ChangeType.MODIFY:
         List<Source> sources = info.context.getSourcesWithFullName(path);
         if (!sources.isEmpty) {
           ChangeSet changeSet = new ChangeSet();
           sources.forEach((Source source) {
             changeSet.changedSource(source);
           });
           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);
     }
   }
 
   /**
    * Returns `true` if the given [path] is excluded by [excludedPaths].
    */
-  bool _isExcluded(String path) {
-    return _isExcludedBy(excludedPaths, path);
-  }
+  bool _isExcluded(String path) => _isExcludedBy(excludedPaths, path);
 
   /**
    * Returns `true` if the given [path] is excluded by [excludedPaths].
    */
   bool _isExcludedBy(List<String> excludedPaths, String path) {
     return excludedPaths.any((excludedPath) {
       if (pathContext.isWithin(excludedPath, path)) {
         return true;
       }
       return path == excludedPath;
     });
   }
 
   /**
    * Determine if the path from [folder] to [path] contains a 'packages'
    * directory.
    */
   bool _isInPackagesDir(String path, Folder folder) {
     String relativePath = pathContext.relative(path, from: folder.path);
     List<String> pathParts = pathContext.split(relativePath);
     return pathParts.contains(PACKAGES_NAME);
   }
 
-  /**
-   * Returns `true` if the given absolute [path] is a pubspec file.
-   */
-  bool _isPubspec(String path) {
-    return pathContext.basename(path) == PUBSPEC_NAME;
-  }
+  bool _isPackagespec(String path) =>
+      pathContext.basename(path) == PACKAGE_SPEC_NAME;
+
+  bool _isPubspec(String path) => pathContext.basename(path) == PUBSPEC_NAME;
 
   /**
    * Merges [info] context into its parent.
    */
   void _mergeContext(_ContextInfo info) {
     // destroy the context
     _destroyContext(info.folder);
     // add files to the parent context
     _ContextInfo parentInfo = info.parent;
     if (parentInfo != null) {
       parentInfo.children.remove(info);
       ChangeSet changeSet = new ChangeSet();
       info.sources.forEach((path, source) {
         parentInfo.sources[path] = source;
         changeSet.addedSource(source);
       });
       applyChangesToContext(parentInfo.folder, changeSet);
     }
   }
 
+  Packages _readPackagespec(File specFile) {
+    try {
+      String contents = specFile.readAsStringSync();
+      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],
    * and update the client appropriately.
    */
   void _recomputePackageUriResolver(_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);
-    updateContextPackageUriResolver(info.folder, packageUriResolver);
+    updateContextPackageUriResolver(info.folder, packageUriResolver, null);
   }
 
   /**
    * 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 125 matching lines @@
    * The package root for this context, or null if there is no package root.
    */
   String packageRoot;
 
   /**
    * The [_ContextInfo] that encloses this one.
    */
   _ContextInfo parent;
 
   /**
-   * The `pubspec.yaml` file path for this context.
+   * The package description file path for this context.
    */
-  String pubspecPath;
+  String packageDescriptionPath;
 
   /**
    * Stream subscription we are using to watch the context's directory for
    * changes.
    */
   StreamSubscription<WatchEvent> changeSubscription;
 
   /**
    * Stream subscriptions we are using to watch the files
    * used to determine the package map.
@@ skipping 12 matching lines @@
    */
   Map<String, Source> sources = new HashMap<String, Source>();
 
   /**
    * Info returned by the last call to
    * [OptimizingPubPackageMapProvider.computePackageMap], or `null` if the
    * package map hasn't been computed for this context yet.
    */
   OptimizingPubPackageMapInfo packageMapInfo;
 
-  _ContextInfo(Folder folder, File pubspecFile, this.children, this.packageRoot)
+  _ContextInfo(
+      Folder folder, File packagespecFile, this.children, this.packageRoot)
       : folder = folder,
         pathFilter = new PathFilter(folder.path, null) {
-    pubspecPath = pubspecFile.path;
+    packageDescriptionPath = packagespecFile.path;
     for (_ContextInfo child in children) {
       child.parent = this;
     }
   }
 
   /**
    * Returns `true` if this context is root folder based.
    */
   bool get isRoot => parent == null;
 
   /**
    * Returns `true` if [path] is excluded, as it is in one of the children.
    */
   bool excludes(String path) {
     return children.any((child) {
       return child.folder.contains(path);
     });
   }
 
+  /**
+   * Returns `true` if [resource] is excluded, as it is in one of the children.
+   */
+  bool excludesResource(Resource resource) => excludes(resource.path);
+
   /// Returns `true` if  [path] should be ignored.
   bool ignored(String path) => pathFilter.ignored(path);
 
   /**
-   * Returns `true` if [resource] is excluded, as it is in one of the children.
+   * Returns `true` if [path] is the package description file for this context 
+   * (pubspec.yaml or .packages).
    */
-  bool excludesResource(Resource resource) {
-    return excludes(resource.path);
-  }
-
-  /**
-   * Returns `true` if [path] is the pubspec file of this context.
-   */
-  bool isPubspec(String path) {
-    return path == pubspecPath;
-  }
+  bool isPathToPackageDescription(String path) =>
+      path == packageDescriptionPath;
 }