locating runtime files automatically (fixes #96)

lib/src/options.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.
 
 /// Set of flags and options passed to the compiler
 library dev_compiler.src.options;
 
 import 'dart:io';
 
 import 'package:args/args.dart';
 import 'package:cli_util/cli_util.dart' show getSdkDir;
 import 'package:dev_compiler/config.dart';
 import 'package:logging/logging.dart' show Level;
+import 'package:path/path.dart' as path;
+import 'package:yaml/yaml.dart';
 
 /// Options used by our TypeResolver.
 class ResolverOptions {
   /// Whether to resolve 'package:' uris using the multi-package resolver.
   final bool useMultiPackage;
 
   /// Package root when resolving 'package:' urls the standard way.
   final String packageRoot;
 
   /// List of paths used for the multi-package resolver.
@@ skipping 160 matching lines @@
   final List<String> nonnullableTypes;
 
   /// Whether to use static types for code generation.
   @override
   final bool ignoreTypes;
 
   /// Whether to emit the source map files.
   @override
   final bool emitSourceMaps;
 
+  /// Location for runtime files, such as `dart_core.js`. By default this is
+  /// inferred to be under `lib/runtime/` in the location of the `dev_compiler`
+  /// package (if we can infer where that is located).
+  final String runtimeDir;
+
   CompilerOptions({this.allowConstCasts: true, this.checkSdk: false,
       this.dumpInfo: false, this.dumpInfoFile, this.dumpSrcDir,
       this.forceCompile: false, this.formatOutput: false,
       this.cheapTestFormat: false, this.ignoreTypes: false, this.outputDir,
       this.outputDart: false, this.useColors: true,
       this.covariantGenerics: true, this.relaxedCasts: true,
       this.useMultiPackage: false, this.packageRoot: 'packages/',
       this.packagePaths: const <String>[],
       this.inferFromOverrides: ResolverOptions.inferFromOverridesDefault,
       this.inferTransitively: ResolverOptions.inferTransitivelyDefault,
       this.onlyInferConstsAndFinalFields: ResolverOptions.onlyInferConstAndFinalFieldsDefault,
       this.nonnullableTypes: TypeOptions.NONNULLABLE_TYPES, this.help: false,
       this.useMockSdk: false, this.dartSdkPath, this.logLevel: Level.SEVERE,
       this.emitSourceMaps: true, this.entryPointFile: null,
-      this.serverMode: false, this.port: 8080});
+      this.serverMode: false, this.port: 8080, this.runtimeDir});
 }
 
 /// Parses options from the command-line
 CompilerOptions parseOptions(List<String> argv) {
   ArgResults args = argParser.parse(argv);
   var levelName = args['log'].toUpperCase();
   var useColors = stdioType(stdout) == StdioType.TERMINAL;
   var sdkPath = args['dart-sdk'];
   if (sdkPath == null && !args['mock-sdk']) {
     sdkPath = getSdkDir(argv).path;
   }
+  var runtimeDir = args['runtime-dir'];
+  if (runtimeDir == null) {
+    runtimeDir = _computeRuntimeDir();
+  }
   return new CompilerOptions(
       allowConstCasts: args['allow-const-casts'],
       checkSdk: args['sdk-check'],
       dumpInfo: args['dump-info'],
       dumpInfoFile: args['dump-info-file'],
       dumpSrcDir: args['dump-src-to'],
       forceCompile: args['force-compile'],
       formatOutput: args['dart-gen-fmt'],
       ignoreTypes: args['ignore-types'],
       outputDart: args['dart-gen'],
@@ skipping 10 matching lines @@
       nonnullableTypes: optionsToList(args['nonnullable'],
           defaultValue: TypeOptions.NONNULLABLE_TYPES),
       help: args['help'],
       useMockSdk: args['mock-sdk'],
       dartSdkPath: sdkPath,
       logLevel: Level.LEVELS.firstWhere((Level l) => l.name == levelName,
           orElse: () => Level.SEVERE),
       emitSourceMaps: args['source-maps'],
       entryPointFile: args.rest.length == 0 ? null : args.rest.first,
       serverMode: args['server'],
-      port: int.parse(args['port']));
+      port: int.parse(args['port']),
+      runtimeDir: runtimeDir);
 }
 
 final ArgParser argParser = new ArgParser()
   // resolver/checker options
   ..addFlag('allow-const-casts',
       help: 'Allow casts in const contexts', defaultsTo: true)
   ..addFlag('sdk-check',
       abbr: 's', help: 'Typecheck sdk libs', defaultsTo: false)
   ..addFlag('mock-sdk',
       abbr: 'm', help: 'Use a mock Dart SDK', defaultsTo: false)
@@ skipping 30 matching lines @@
       abbr: 'p',
       help: 'Package root to resolve "package:" imports',
       defaultsTo: 'packages/')
   ..addFlag('use-multi-package',
       help: 'Whether to use the multi-package resolver for "package:" imports',
       defaultsTo: false)
   ..addOption('package-paths', help: 'if using the multi-package resolver, '
       'the list of directories where to look for packages.', defaultsTo: '')
   ..addFlag('source-maps',
       help: 'Whether to emit source map files', defaultsTo: true)
+  ..addOption('runtime-dir',
+      help: 'Where to find dev_compiler\'s runtime files', defaultsTo: null)
 
   // general options
   ..addFlag('help', abbr: 'h', help: 'Display this message')
   ..addFlag('server', help: 'Run as a development server.', defaultsTo: false)
   ..addOption('port',
       help: 'Port where to serve files from (used only when --serve is on)',
       defaultsTo: '8080')
   ..addFlag('force-compile',
       help: 'Compile code with static errors', defaultsTo: false)
   ..addOption('log', abbr: 'l', help: 'Logging level', defaultsTo: 'severe')
   ..addFlag('dump-info',
       abbr: 'i', help: 'Dump summary information', defaultsTo: false)
   ..addOption('dump-info-file',
       abbr: 'f',
       help: 'Dump info json file (requires dump-info)',
       defaultsTo: null);
+
+/// Tries to find the `lib/runtime/` directory of the dev_compiler package. This
+/// works when running devc from it's sources or from a snapshot that is
+/// activated via `pub global activate`.
+String _computeRuntimeDir() {
+  var scriptUri = Platform.script;
+  var scriptPath = scriptUri.path;
+  var file = path.basename(scriptPath);
+  var dir = path.dirname(scriptPath);
+  var lastdir = path.basename(dir);
+  dir = path.dirname(dir);
+
+  // Both the source devc.dart and the snapshot generated by pub global activate
+  // are under a bin folder.
+  if (lastdir != 'bin') return null;
+
+  // And both under a project directory containing a pubspec.lock file.
+  var lockfile = path.join(dir, 'pubspec.lock');
+  if (!new File(lockfile).existsSync()) return null;
+
+  // If running from sources we found it!
+  if (file == 'devc.dart') return path.join(dir, 'lib', 'runtime');
+
+  // If running from a pub global snapshot, we need to read the lock file to
+  // find where the actual sources are located in the pub cache.
+  if (file == 'devc.dart.snapshot') {
+    // Note: this depends on implementation details of pub.
+    var yaml = loadYaml(new File(lockfile).readAsStringSync());
+    var info = yaml['packages']['dev_compiler'];
+    if (info == null) return null;
+
+    var cacheDir;
+    if (info['source'] == 'hosted') {
+      cacheDir = path.join(
+          'hosted', 'pub.dartlang.org', 'dev_compiler-${info["version"]}');
+    } else if (info['source'] == 'git') {
+      var ref = info['description']['resolved-ref'];
+      cacheDir = path.join('git', 'dev_compiler-${ref}');
+    }
+
+    // We should be under "/path/to/pub-cache/global_packages/dev_compiler".
+    // The pub-cache directory is two levels up, but we verify that the layout
+    // looks correct.
+    if (path.basename(dir) != 'dev_compiler') return null;
+    dir = path.dirname(dir);
+    if (path.basename(dir) != 'global_packages') return null;
+    dir = path.dirname(dir);
+    return path.join(dir, cacheDir, 'lib', 'runtime');
+  }
+  return null;
+}