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/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: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';
 
 /**
  * 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 {
   /**
    * 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 44 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 171 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 72 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);
+        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) {

[Brian Wilkerson, 2015/07/17 18:02:57]

Perhaps rename 'pubspecFile' to 'packageSpec' for consistency?

[pquitslund, 2015/07/17 19:30:02]

Done.

     _ContextInfo info = new _ContextInfo(
         folder, pubspecFile, children, normalizedPackageRoots[folder.path]);
     _contexts[folder] = info;
     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;
+
+      // Try .packages first.
+      if (pathos.basename(pubspecFile.path) == PACKAGE_SPEC_NAME) {
+        packages = _readPackagespec(pubspecFile);
+      }
+
+      // 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) {
+
+    // Start by looking for .packages.
+    File packageSpec = folder.getChild(PACKAGE_SPEC_NAME);
+
+    // Fall back to looking for a pubspec.
+    if (!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) {
@@ skipping 65 matching lines @@
     if (info.excludes(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;
+
+        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) {

[Brian Wilkerson, 2015/07/17 18:02:57]

If a .packages file is added to the context's root directory we need to update
the context to use the .packages file to resolve URI's. I think this misses that
case.

[pquitslund, 2015/07/17 19:30:02]

Actually, I think this is handled in _createContext(..) which is called by
_extractContext(..).  The fact remains that this is not well under-test...  I
added a TODO in the tests and hope that we can address it better after Paul's
rethink.

+            if (pathContext.basename(path) == PUBSPEC_NAME) {
+              // Check for a sibling .packages file.
+              if (!resourceProvider
+                  .getFile(pathos.join(directoryPath, '.packages')).exists) {

[Brian Wilkerson, 2015/07/17 18:02:58]

nit: use PACKAGE_SPEC_NAME (here and below)

[pquitslund, 2015/07/17 19:30:02]

Done.

+                _extractContext(info, resource);
+                return;
+              }
+            }
+            if (pathContext.basename(path) == PACKAGE_SPEC_NAME) {
+              // Check for a sibling pubspec.yaml file.
+              if (!resourceProvider
+                  .getFile(pathos.join(directoryPath, 'pubspec.yaml')).exists) {

[Brian Wilkerson, 2015/07/17 18:02:57]

nit: use PUBSPEC_NAME (here and below)

[pquitslund, 2015/07/17 19:30:02]

Done.

+                _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) {
+          String directoryPath = pathContext.dirname(path);
+
+          // Only merge if this is the same directory described by our info object.
+          if (info.folder.path == directoryPath) {
+            if (pathContext.basename(path) == PUBSPEC_NAME) {
+              // Check for a sibling .packages file.
+              if (!resourceProvider
+                  .getFile(pathos.join(directoryPath, '.packages')).exists) {
+                _mergeContext(info);
+                return;
+              }
+            }
+            if (pathContext.basename(path) == PACKAGE_SPEC_NAME) {
+              // Check for a sibling pubspec.yaml file.
+              if (!resourceProvider
+                  .getFile(pathos.join(directoryPath, 'pubspec.yaml')).exists) {
+                _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:

[Brian Wilkerson, 2015/07/17 18:02:57]

Do we handle changes to the .packages file somewhere else, or are we missing
that case?

[pquitslund, 2015/07/17 19:30:02]

Yes.  That's outside the switch.  (See below.)

Certainly needs a better home! :)

         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);

[pquitslund, 2015/07/17 19:30:02]

Here's where we test for .packages changes.

+
     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;
-  }
-
-  /**
    * 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) {
+    //TODO(pquitslund): error-handling?

[Brian Wilkerson, 2015/07/17 18:02:57]

Yes. If we cannot read the file, I think we should act as if the file doesn't
exist. It would be nice if we could create an error for the file indicating that
it's being ignored.

[pquitslund, 2015/07/17 19:30:02]

Cool.  Added a try/catch and a TODO to create an error down the road.

+    String contents = specFile.readAsStringSync();
+    Map<String, Uri> map =
+        pkgfile.parse(UTF8.encode(contents), new Uri.file(specFile.path));
+    return new MapPackages(map);
+  }
+
   /**
    * 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 122 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 13 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(this.folder, File pubspecFile, this.children, this.packageRoot) {
-    pubspecPath = pubspecFile.path;
+    packageDescriptionPath = pubspecFile.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) {
-    return excludes(resource.path);
-  }
+  bool excludesResource(Resource resource) => excludes(resource.path);
 
   /**
-   * Returns `true` if [path] is the pubspec file of this context.
+   * Returns `true` if [path] is the package description file for this context 
+   * (pubspec.yaml or .packages).
    */
-  bool isPubspec(String path) {
-    return path == pubspecPath;
-  }
+  bool isPathToPackageDescription(String path) =>
+      path == packageDescriptionPath;
 }