simplify computing of runtime file locations

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 'dart:mirrors' show reflectClass, LibraryMirror;
 
 import 'package:args/args.dart';
 import 'package:cli_util/cli_util.dart' show getSdkDir;
 import 'package:logging/logging.dart' show Level;
 import 'package:path/path.dart' as path;
-import 'package:yaml/yaml.dart';
 
 import 'package:dev_compiler/strong_mode.dart' show StrongModeOptions;
 
 /// Options used to set up Source URI resolution in the analysis context.
 class SourceResolverOptions {
   /// Whether to resolve 'package:' uris using the multi-package resolver.
   final bool useMultiPackage;
 
   /// Custom URI mappings, such as "dart:foo" -> "path/to/foo.dart"
   final Map<String, String> customUrlMappings;
@@ skipping 118 matching lines @@
     logLevel = Level.LEVELS.firstWhere((l) => l.name == levelName,
         orElse: () => logLevel);
   }
   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();
+    // Figure out this library's path
+    LibraryMirror thisLibrary = reflectClass(CompilerOptions).owner;
+    var thisUri = thisLibrary.uri;
+    assert(thisUri.scheme == 'package');
+    var libDir = path.dirname(path.dirname(thisLibrary.uri.path));
+    var packageRoot = Platform.packageRoot;
+    if (packageRoot == '') packageRoot = 'packages';
+    runtimeDir = path.join(packageRoot, libDir, 'runtime');
   }
   var outputDir = args['out'];
   if (outputDir == null && serverMode) {
     outputDir = Directory.systemTemp.createTempSync("dev_compiler_out_").path;
   }
   var dumpInfo = args['dump-info'];
   if (dumpInfo == null) dumpInfo = serverMode;
 
   var customUrlMappings = <String, String>{};
   for (var mapping in args['url-mapping']) {
@@ skipping 89 matching lines @@
       defaultsTo: '8080')
   ..addFlag('force-compile',
       help: 'Compile code with static errors', defaultsTo: false)
   ..addOption('log', abbr: 'l', help: 'Logging level (defaults to severe)')
   ..addFlag('dump-info',
       abbr: 'i', help: 'Dump summary information', defaultsTo: null)
   ..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`.

[vsm, 2015/07/14 23:52:30]

Will this still work in the `pub global activate` case?

[Jennifer Messerly, 2015/07/15 00:29:41]

It should, but folks will need to add an explicit dependency on dev_compiler
package if they want to use --server. Because in a snapshot I don't think we can
get access to our resources ... 

The code below depends on all kinds of `pub` implementation details. It's
guessing that if we're running from a snapshot, maybe `pub` created the
snapshot, and hey let's check for git source and all this stuff to replicate
what Pub does. That's rather fragile logic.

The new code just says "hey look for package:dev_compiler/runtime" ... seemed
easy enough for now.

Is that good enough for now?

Longer term we have so many options. If we did want to emit our runtime .js
files when compiling HTML files, instead of having the user import them, and we
want it to use a pub global install, and we don't want to recompile against the
actual Dart SDK you're using, then we probably want something more like
https://api.dartlang.org/apidocs/channels/dev/dartdoc-viewer/dart:core.Resource

But I guess, it seems like we're in the mode now where we're more about clean
analyzer integration, and I don't see how we can easily do that with code of
this nature...

[vsm, 2015/07/15 00:45:29]

Hmm, how do you add an explicit dep in this case?  E.g., our current usage doc:

https://github.com/dart-lang/dev_compiler/blob/master/USAGE.md

Will that still work?  

[Jennifer Messerly, 2015/07/15 15:30:43]

For checking/compiling: yes

For running --server: you'll need to add a "dev_compiler" to your pubspec
dev_dependencies, that gets you access to the runtime files.

This really boils down to "how do we distribute our precompiled SDK JS files?"
Right now, we use pub implementation details to guess: "hey if we're running our
compiled binary, probably our original sources are still somewhere in Pub's
cache" ... I mean, it does work in practice, but it's fragile w.r.t. the
refactoring we need to do. A package is the logical place to look for runtime
files.

Here's another proposal ... I can see how Phil feels about moving this code in
the "cli_util" package. Then at some point, replace it with the Resources class
that Lasse is implementing. At least that moves this Resources workaround away
from our compiler code. 

The downside is, I still don't see how this code will work correctly in an
analyzer_cli/analysis_server environment. In the short term, I think we're
better off asking users to add the dev dependency...

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