Package map source factory support.

pkg/analyzer/lib/src/generated/source.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.source;
 
 import 'dart:collection';
+import 'dart:io';
 import "dart:math" as math;
 
 import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/task/model.dart';
+import 'package:package_config/packages.dart';
 import 'package:path/path.dart' as pathos;
 
 import 'engine.dart';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'java_io.dart' show JavaFile;
 import 'sdk.dart' show DartSdk;
 import 'source_io.dart' show FileBasedSource;
 
 /**
@@ skipping 542 matching lines @@
  * Instances of the class `SourceFactory` resolve possibly relative URI's against an existing
  * [Source].
  */
 class SourceFactory {
   /**
    * The analysis context that this source factory is associated with.
    */
   AnalysisContext context;
 
   /**
+   * URI processor used to find mappings for `package:` URIs found in a `.packages` config
+   * file.
+   */
+  final Packages _packages;
+
+  /**
+   * Resource provider used in working with package maps.
+   */
+  final ResourceProvider _resourceProvider;
+
+  /**
    * The resolvers used to resolve absolute URI's.
    */
   final List<UriResolver> _resolvers;
 
   /**
    * The predicate to determine is [Source] is local.
    */
   LocalSourcePredicate _localSourcePredicate = LocalSourcePredicate.NOT_SDK;
 
   /**
-   * Initialize a newly created source factory.
-   *
-   * @param resolvers the resolvers used to resolve absolute URI's
+   * Initialize a newly created source factory with the given absolute URI [resolvers] and
+   * optional [packages] resolution helper.
    */
-  SourceFactory(this._resolvers);
+  SourceFactory(this._resolvers,
+      [this._packages = Packages.noPackages, ResourceProvider resourceProvider])
+      : _resourceProvider = resourceProvider != null
+          ? resourceProvider
+          : PhysicalResourceProvider.INSTANCE;
 
   /**
    * Return the [DartSdk] associated with this [SourceFactory], or `null` if there
    * is no such SDK.
    *
    * @return the [DartSdk] associated with this [SourceFactory], or `null` if
    *         there is no such SDK
    */
   DartSdk get dartSdk {
     for (UriResolver resolver in _resolvers) {
@@ skipping 10 matching lines @@
    *
    * @param localSourcePredicate the predicate to determine is [Source] is local
    */
   void set localSourcePredicate(LocalSourcePredicate localSourcePredicate) {
     this._localSourcePredicate = localSourcePredicate;
   }
 
   /// A table mapping package names to paths of directories containing
   /// the package (or [null] if there is no registered package URI resolver).
   Map<String, List<Folder>> get packageMap {
+    // Start by looking in .packages.
+    if (_packages != Packages.noPackages) {
+      Map<String, List<Folder>> packageMap = <String, List<Folder>>{};
+      _packages.asMap().forEach((String name, Uri uri) {
+        if (uri.scheme == 'file' || uri.scheme == '' /* unspecified */) {
+          packageMap[name] =
+              <Folder>[_resourceProvider.getFolder(uri.toFilePath())];
+        }
+      });
+      return packageMap;
+    }
+
+    // Default to the PackageMapUriResolver.
     PackageMapUriResolver resolver = _resolvers.firstWhere(
         (r) => r is PackageMapUriResolver, orElse: () => null);
     return resolver != null ? resolver.packageMap : null;
   }
 
   /**
    * Return a source object representing the given absolute URI, or `null` if the URI is not a
    * valid URI or if it is not an absolute URI.
    *
    * @param absoluteUri the absolute URI to be resolved
@@ skipping 87 matching lines @@
   }
 
   /**
    * Return an absolute URI that represents the given source, or `null` if a valid URI cannot
    * be computed.
    *
    * @param source the source to get URI for
    * @return the absolute URI representing the given source
    */
   Uri restoreUri(Source source) {
+    // First see if a resolver can restore the URI.
     for (UriResolver resolver in _resolvers) {
       Uri uri = resolver.restoreAbsolute(source);
       if (uri != null) {
+        // Now see if there's a package mapping.
+        Uri packageMappedUri = _getPackageMapping(uri);
+        if (packageMappedUri != null) {
+          return packageMappedUri;
+        }
+        // Fall back to the resolver's computed URI.
         return uri;
       }
     }
-    return null;
+
+    // In case no resolver can restore the URI, default to a .packages look-up.
+    return _getPackageMapping(source.uri);

[Paul Berry, 2015/07/01 15:55:40]

I don't think we want this.  The idea of restoreUri is that it should look at
the source's file path only, and determine a URI that resolves to the given file
path.  Which is what the loop above does.  If the loop above fails to create a
URI, then we should return null because there is no possible URI that resolves
to the given source.

+  }
+
+  Uri _getPackageMapping(Uri uri) {

[Paul Berry, 2015/07/01 15:55:40]

I'm concerned about the algorithm for this function.  It seems to me that (a)
there's no need to restrict it to operating on just file URI's, and (b) we
shouldn't be converting the URI to a file path (because that will introduce
unintended behavioral differences between Windows and non-Windows environments).
 We should simply iterate through the key/value pairs in _packages seeing if any
of the values is a valid prefix for the passed-in URI, and then convert it as
appropriate.

+    if (uri.scheme != 'file') {
+      //TODO(pquitslund): add support for non-file URIs.
+      return null;
+    }
+
+    String sourcePath = uri.toFilePath();
+    Uri packageUri;
+    _packages.asMap().forEach((String name, Uri uri) {
+      if (packageUri == null) {
+        String uriPath = uri.toFilePath();
+        if (sourcePath.startsWith(uriPath)) {

[Paul Berry, 2015/07/01 15:55:40]

Is it guaranteed that "uriPath" will end with a trailing slash?  If not, this
won't work properly because it will falsely match a path like "/foobar/baz" to
the uriPath "/foo".

Consider instead using Uri.pathSegments on both URI's that you are comparing,
and then comparing the path segments one by one.

+          packageUri = Uri
+              .parse('package:$name/${sourcePath.substring(uriPath.length)}');
+        }
+      }
+    });
+    return packageUri;
   }
 
   /**
    * Return a source object representing the URI that results from resolving the given (possibly
    * relative) contained URI against the URI associated with an existing source object, or
    * `null` if the URI could not be resolved.
    *
    * @param containingSource the source containing the given URI
    * @param containedUri the (possibly relative) URI to be resolved against the containing source
    * @return the source representing the contained URI
    * @throws AnalysisException if either the contained URI is invalid or if it cannot be resolved
    *           against the source object's URI
    */
   Source _internalResolveUri(Source containingSource, Uri containedUri) {
+    // Check .packages first.

[Paul Berry, 2015/07/01 15:55:40]

This needs to go after the "if (!containedUri.isAbsolute)" block.  Otherwise we
will resolve relative URI's incorrectly.

+    if (containedUri.scheme == 'package') {
+      Uri packageUri = _packages.resolve(containedUri);
+      //TODO(pquitslund): package_config needs to be updated to set schemes for file URIs.
+      if (packageUri != null && packageUri.scheme == '') {

[Paul Berry, 2015/07/01 15:55:40]

To reduce churn once the TODO above is addressed, let's write this in a way that
it will do what we want once package_config has been updated.  E.g.:

if (packageUri != null) {
  if (packageUri.scheme = '') {
    packageUri = packageUri.replace(scheme: 'file');
  }
  containedUri = packageUri;
}

Also, it might be good to add a TODO to remind us of the problem that Brian
mentioned in his email this morning (this algorithm will cause us to create a
Source object that contains the wrong URI).

+        containedUri = new Uri.file(packageUri.toFilePath());
+      }
+    }
     if (!containedUri.isAbsolute) {
       if (containingSource == null) {
         throw new AnalysisException(
             "Cannot resolve a relative URI without a containing source: $containedUri");
       }
       containedUri = containingSource.resolveRelativeUri(containedUri);
     }
     for (UriResolver resolver in _resolvers) {
       Source result = resolver.resolveAbsolute(containedUri);
       if (result != null) {
@@ skipping 238 matching lines @@
 
   /**
    * Return an absolute URI that represents the given source, or `null` if a valid URI cannot
    * be computed.
    *
    * @param source the source to get URI for
    * @return the absolute URI representing the given source
    */
   Uri restoreAbsolute(Source source) => null;
 }