Add package implementation.

See dart-lang/test#327

[email protected]

Review URL: https://codereview.chromium.org//2132443003 .

Author: nex3

lib/package_resolver.dart

@@ -0,0 +1,6 @@
+// Copyright (c) 2016, 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.
+
+export 'src/package_resolver.dart';
+export 'src/sync_package_resolver.dart';

lib/src/async_package_resolver.dart

@@ -0,0 +1,31 @@
+// Copyright (c) 2016, 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.
+
+import 'dart:async';
+
+import 'package_resolver.dart';
+import 'sync_package_resolver.dart';
+
+/// An implementation of [PackageResolver] that wraps a [SyncPackageResolver].
+class AsyncPackageResolver implements PackageResolver {
+  /// The wrapped [SyncPackageResolver].
+  final SyncPackageResolver _inner;
+
+  AsyncPackageResolver(this._inner);
+
+  Future<Map<String, Uri>> get packageConfigMap async =>
+      _inner.packageConfigMap;
+
+  Future<Uri> get packageConfigUri async => _inner.packageConfigUri;
+  Future<Uri> get packageRoot async => _inner.packageRoot;
+  Future<SyncPackageResolver> get asSync async => _inner;
+  Future<String> get processArgument async => _inner.processArgument;
+
+  Future<Uri> resolveUri(packageUri) async => _inner.resolveUri(packageUri);
+  Future<Uri> urlFor(String package, [String path]) async =>
+      _inner.urlFor(package, path);
+  Future<Uri> packageUriFor(url) async => _inner.packageUriFor(url);
+  Future<String> packagePath(String package) async =>
+      _inner.packagePath(package);
+}

lib/src/current_isolate_resolver.dart

@@ -0,0 +1,70 @@
+// Copyright (c) 2016, 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.
+
+import 'dart:async';
+import 'dart:isolate';
+
+import 'package:path/path.dart' as p;
+
+import 'package_config_resolver.dart';
+import 'package_resolver.dart';
+import 'package_root_resolver.dart';
+import 'sync_package_resolver.dart';
+import 'utils.dart';
+
+/// The package resolution strategy used by the current isolate.
+class CurrentIsolateResolver implements PackageResolver {
+  Future<Map<String, Uri>> get packageConfigMap async {
+    if (_packageConfigMap != null) return _packageConfigMap;
+
+    var url = await Isolate.packageConfig;
+    if (url == null) return null;
+
+    return await loadConfigMap(url);
+  }
+  Map<String, Uri> _packageConfigMap;
+
+  Future<Uri> get packageConfigUri => Isolate.packageConfig;
+
+  Future<Uri> get packageRoot => Isolate.packageRoot;
+
+  Future<SyncPackageResolver> get asSync async {
+    var root = await packageRoot;
+    if (root != null) return new PackageRootResolver(root);
+
+    var map = await packageConfigMap;
+
+    // It's hard to imagine how there would be no package resolution strategy
+    // for an Isolate that can load the package_resolver package, but it's easy
+    // to handle that case so we do.
+    if (map == null) return SyncPackageResolver.none;
+
+    return new PackageConfigResolver(map, uri: await packageConfigUri);
+  }
+
+  Future<String> get processArgument async {
+    var configUri = await packageConfigUri;
+    if (configUri != null) return "--packages=$configUri";
+
+    var root = await packageRoot;
+    if (root != null) return "--package-root=$root";
+
+    return null;
+  }
+
+  Future<Uri> resolveUri(packageUri) =>
+      Isolate.resolvePackageUri(asPackageUri(packageUri, "packageUri"));
+
+  Future<Uri> urlFor(String package, [String path]) =>
+      Isolate.resolvePackageUri(Uri.parse("package:$package/${path ?? ''}"));
+
+  Future<Uri> packageUriFor(url) async => (await asSync).packageUriFor(url);
+
+  Future<String> packagePath(String package) async {
+    var root = await packageRoot;
+    if (root != null) return new PackageRootResolver(root).packagePath(package);
+
+    return p.dirname(p.fromUri(await urlFor(package)));
+  }
+}

lib/src/no_package_resolver.dart

@@ -0,0 +1,34 @@
+// Copyright (c) 2016, 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.
+
+import 'async_package_resolver.dart';
+import 'package_resolver.dart';
+import 'sync_package_resolver.dart';
+import 'utils.dart';
+
+/// A package resolution strategy that is unable to resolve any `package:` URIs.
+class NoPackageResolver implements SyncPackageResolver {
+  Map<String, Uri> get packageConfigMap => null;
+  Uri get packageConfigUri => null;
+  Uri get packageRoot => null;
+  String get processArgument => null;
+
+  PackageResolver get asAsync => new AsyncPackageResolver(this);
+
+  Uri resolveUri(packageUri) {
+    // Verify that the URI is valid.
+    asPackageUri(packageUri, "packageUri");
+    return null;
+  }
+
+  Uri urlFor(String package, [String path]) => null;
+
+  Uri packageUriFor(url) {
+    // Verify that the URI is a valid type.
+    asUri(url, "url");
+    return null;
+  }
+
+  String packagePath(String package) => null;
+}

lib/src/package_config_resolver.dart

@@ -0,0 +1,94 @@
+// Copyright (c) 2016, 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.
+
+import 'dart:collection';
+
+import 'package:collection/collection.dart';
+import 'package:package_config/packages_file.dart' as packages_file;
+import 'package:path/path.dart' as p;
+
+import 'async_package_resolver.dart';
+import 'package_resolver.dart';
+import 'sync_package_resolver.dart';
+import 'utils.dart';
+
+/// A package resolution strategy based on a package config map.
+class PackageConfigResolver implements SyncPackageResolver {
+  final packageRoot = null;
+
+  final Map<String, Uri> packageConfigMap;
+
+  Uri get packageConfigUri {
+    if (_uri != null) return _uri;
+
+    var buffer = new StringBuffer();
+    packages_file.write(buffer, packageConfigMap, comment: "");
+    _uri = new UriData.fromString(buffer.toString(),
+            parameters: {"charset": "utf-8"})
+        .uri;
+    return _uri;
+  }
+  Uri _uri;
+
+  PackageResolver get asAsync => new AsyncPackageResolver(this);
+
+  String get processArgument => "--packages=$packageConfigUri";
+
+  PackageConfigResolver(Map<String, Uri> packageConfigMap, {uri})
+      : packageConfigMap = _normalizeMap(packageConfigMap),
+        _uri = uri == null ? null : asUri(uri, "uri");
+
+  /// Normalizes the URIs in [map] to ensure that they all end in a trailing
+  /// slash.
+  static Map<String, Uri> _normalizeMap(Map<String, Uri> map) =>
+      new UnmodifiableMapView(
+          mapMap(map, value: (_, uri) => ensureTrailingSlash(uri)));
+
+  Uri resolveUri(packageUri) {
+    var uri = asPackageUri(packageUri, "packageUri");
+
+    var baseUri = packageConfigMap[uri.pathSegments.first];
+    if (baseUri == null) return null;
+
+    var segments = baseUri.pathSegments.toList()
+      ..removeLast(); // Remove the trailing slash.
+
+    // Following [Isolate.resolvePackageUri], "package:foo" resolves to null.
+    if (uri.pathSegments.length == 1) return null;
+
+    segments.addAll(uri.pathSegments.skip(1));
+    return baseUri.replace(pathSegments: segments);        
+  }
+
+  Uri urlFor(String package, [String path]) {
+    var baseUri = packageConfigMap[package];
+    if (baseUri == null) return null;
+    if (path == null) return baseUri;
+    return baseUri.resolve(path);
+  }
+
+  Uri packageUriFor(url) {
+    url = asUri(url, "url").toString();
+
+    // Make sure isWithin works if [url] is exactly the base.
+    var nested = p.url.join(url, "_");
+    for (var package in packageConfigMap.keys) {
+      var base = packageConfigMap[package].toString();
+      if (!p.url.isWithin(base, nested)) continue;
+
+      var relative = p.url.relative(url, from: base);
+      if (relative == '.') relative = '';
+      return Uri.parse("package:$package/$relative");
+    }
+
+    return null;
+  }
+
+  String packagePath(String package) {
+    var lib = packageConfigMap[package];
+    if (lib == null) return null;
+    if (lib.scheme != 'file') return null;
+    return p.dirname(p.fromUri(lib));
+  }
+}