| // Copyright (c) 2013, 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:io'; |
| |
| import 'package:async/async.dart'; |
| import 'package:barback/barback.dart'; |
| import 'package:collection/collection.dart'; |
| import 'package:path/path.dart' as p; |
| import 'package:package_resolver/package_resolver.dart'; |
| import 'package:pub_semver/pub_semver.dart'; |
| |
| import '../compiler.dart'; |
| import '../io.dart'; |
| import '../package.dart'; |
| import '../package_graph.dart'; |
| import '../preprocess.dart'; |
| import '../sdk.dart' as sdk; |
| |
| /// The path to the lib directory of the compiler_unsupported package used by |
| /// pub. |
| /// |
| /// This is used to make sure dart2js is running against its own version of its |
| /// internal libraries when running from the pub repo. It's `null` if we're |
| /// running from the Dart repo or from the built SDK. |
| final Future<String> _compilerUnsupportedLib = (() async { |
| if (runningFromSdk) return null; |
| if (runningFromDartRepo) return null; |
| |
| return p |
| .fromUri(await PackageResolver.current.urlFor('compiler_unsupported')); |
| })(); |
| |
| final _zlib = new ZLibCodec(); |
| |
| /// An implementation of barback's [PackageProvider] interface so that barback |
| /// can find assets within pub packages. |
| class PubPackageProvider implements StaticPackageProvider { |
| final PackageGraph _graph; |
| final List<String> staticPackages; |
| |
| Iterable<String> get packages => |
| _graph.packages.keys.toSet().difference(staticPackages.toSet()); |
| |
| PubPackageProvider(PackageGraph graph, Compiler compiler) |
| : _graph = graph, |
| staticPackages = [r"$pub", r"$sdk"]..addAll(graph.packages.keys |
| .where((p) => graph.isPackageStatic(p, compiler))); |
| |
| Future<Asset> getAsset(AssetId id) async { |
| // "$pub" is a psuedo-package that allows pub's transformer-loading |
| // infrastructure to share code with pub proper. |
| if (id.package == r'$pub') { |
| var components = p.url.split(id.path); |
| assert(components.isNotEmpty); |
| assert(components.first == 'lib'); |
| components[0] = 'dart'; |
| var file = assetPath(p.joinAll(components)); |
| _assertExists(file, id); |
| |
| // Barback may not be in the package graph if there are no user-defined |
| // transformers being used at all. The "$pub" sources are still provided, |
| // but will never be loaded. |
| if (!_graph.packages.containsKey("barback")) { |
| return new Asset.fromPath(id, file); |
| } |
| |
| var versions = mapMap<String, Package, String, Version>(_graph.packages, |
| value: (_, package) => package.version); |
| var contents = readTextFile(file); |
| contents = preprocess(contents, versions, p.toUri(file)); |
| return new Asset.fromString(id, contents); |
| } |
| |
| // "$sdk" is a pseudo-package that provides access to the Dart library |
| // sources and kernel .dill files in the SDK. The dart2js transformer uses |
| // this to locate the Dart sources for "dart:" libraries and the |
| // dart2js_platform.dill files. |
| if (id.package == r'$sdk') { |
| // The asset path contains two "lib" entries. The first represents pub's |
| // concept that all public assets are in "lib". The second comes from the |
| // organization of the SDK itself. Strip off the first. Leave the second |
| // since dart2js adds it and expects it to be there. |
| var parts = p.split(p.fromUri(id.path)); |
| assert(parts.isNotEmpty && parts[0] == 'lib'); |
| parts = parts.skip(1).toList(); |
| |
| var compilerUnsupportedLib = await _compilerUnsupportedLib; |
| if (compilerUnsupportedLib == null) { |
| var file = p.join(sdk.rootDirectory, p.joinAll(parts)); |
| _assertExists(file, id); |
| return new Asset.fromPath(id, file); |
| } |
| |
| // If we're running from pub's repo, our version of dart2js comes from |
| // compiler_unsupported and may expect different SDK sources than the |
| // actual SDK we're using. Handily, compiler_unsupported contains a full |
| // (ZLib-encoded) copy of the SDK, so we load sources from that instead. |
| var file = |
| p.join(compilerUnsupportedLib, 'sdk', p.joinAll(parts.skip(1))) + "_"; |
| _assertExists(file, id); |
| return new Asset.fromStream(id, |
| new LazyStream(() => _zlib.decoder.bind(new File(file).openRead()))); |
| } |
| |
| var nativePath = p.fromUri(id.path); |
| var file = _graph.packages[id.package].path(nativePath); |
| _assertExists(file, id); |
| return new Asset.fromPath(id, file); |
| } |
| |
| /// Throw an [AssetNotFoundException] for [id] if [path] doesn't exist. |
| void _assertExists(String path, AssetId id) { |
| if (!fileExists(path)) throw new AssetNotFoundException(id); |
| } |
| |
| Stream<AssetId> getAllAssetIds(String packageName) { |
| if (packageName == r'$pub') { |
| // "$pub" is a pseudo-package that allows pub's transformer-loading |
| // infrastructure to share code with pub proper. We provide it only during |
| // the initial transformer loading process. |
| var dartPath = assetPath('dart'); |
| return new Stream.fromIterable(listDir(dartPath, recursive: true) |
| // Don't include directories. |
| .where((file) => p.extension(file) == ".dart") |
| .map((library) { |
| var idPath = p.join('lib', p.relative(library, from: dartPath)); |
| return new AssetId('\$pub', p.toUri(idPath).toString()); |
| })); |
| } else if (packageName == r'$sdk') { |
| return StreamCompleter.fromFuture(() async { |
| var compilerUnsupportedLib = await _compilerUnsupportedLib; |
| // "$sdk" is a pseudo-package that allows the dart2js transformer to |
| // find the Dart core libraries without hitting the file system |
| // directly. This ensures they work with source maps. |
| var libPath = compilerUnsupportedLib == null |
| ? p.join(sdk.rootDirectory, "lib") |
| : p.join(compilerUnsupportedLib, "sdk"); |
| var files = listDir(libPath, recursive: true); |
| |
| if (compilerUnsupportedLib != null) { |
| // compiler_unsupported's SDK sources are ZLib-encoded; to indicate |
| // this, they end in "_". We serve them decoded, though, so we strip |
| // the underscore to get the asset paths. |
| var trailingUnderscore = new RegExp(r"_$"); |
| files = files.map((file) => file.replaceAll(trailingUnderscore, "")); |
| } |
| |
| return new Stream.fromIterable(files |
| .where((file) => |
| p.extension(file) == '.dart' || p.extension(file) == '.dill') |
| .map((file) { |
| var idPath = p.join("lib", "lib", p.relative(file, from: libPath)); |
| return new AssetId('\$sdk', p.toUri(idPath).toString()); |
| })); |
| }()); |
| } else { |
| var package = _graph.packages[packageName]; |
| return new Stream.fromIterable( |
| package.listFiles(beneath: 'lib').map((file) { |
| return new AssetId( |
| packageName, p.toUri(package.relative(file)).toString()); |
| })); |
| } |
| } |
| } |