Add a --trace flag to make Pub print a stack trace on error.

utils/pub/pub.dart

 // Copyright (c) 2012, 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.
 
 /**
  * The main entrypoint for the pub command line application.
  */
 #library('pub');
 
 #import('../../lib/args/args.dart');
@@ skipping 30 matching lines @@
   var parser = new ArgParser();
   parser.addFlag('help', abbr: 'h', negatable: false,
     help: 'Prints this usage information');
   parser.addFlag('version', negatable: false,
     help: 'Prints the version of Pub');
   // TODO(rnystrom): Hack. These are temporary options to allow the pub tests to
   // pass in relevant paths. Eventually these should be environment variables.
   parser.addOption('cachedir', help: 'The directory containing the system-wide '
     'Pub cache');
   parser.addOption('sdkdir', help: 'The directory containing the Dart SDK');
+  parser.addFlag('trace', help: 'Prints a stack trace when an error occurs');
 
   var results;
   try {
     results = parser.parse(new Options().arguments);
   } catch (ArgFormatException e) {
     printUsage(parser, commands, description: e.message);
     return;
   }
 
   if (results['version']) {
@@ skipping 15 matching lines @@
 
   // Select the command.
   var command = commands[results.rest[0]];
   if (command == null) {
     printError('Unknown command "${results.rest[0]}".');
     printError('Run "pub help" to see available commands.');
     exit(64); // See http://www.freebsd.org/cgi/man.cgi?query=sysexits.
     return;
   }
 
-  command.run(cache, results.rest.getRange(1, results.rest.length - 1));
+  var args = results.rest.getRange(1, results.rest.length - 1);
+  command.run(cache, results, args);

[Bob Nystrom, 2012/07/09 23:00:36]

These names aren't very clear. How about:

results -> globalOptions
args -> commandArgs

[nweiz, 2012/07/09 23:38:09]

Done.

 }
 
 /** Displays usage information for the app. */
 void printUsage(ArgParser parser, Map<String, PubCommand> commands,
     [String description = 'Pub is a package manager for Dart.']) {
   print(description);
   print('');
   print('Usage: pub command [arguments]');
   print('');
   print('Global options:');
@@ skipping 24 matching lines @@
   print('Pub $pubVersion');
 }
 
 class PubCommand {
   SystemCache cache;
 
   Entrypoint entrypoint;
 
   abstract String get description();
 
-  void run(SystemCache cache_, List<String> args) {
+  void run(SystemCache cache_, ArgResults options, List<String> args) {
     cache = cache_;
 
     // TODO(rnystrom): Each command should define the arguments it expects and
     // we can handle them generically here.
 
-    handleError(error) {
+    handleError(error, trace) {
       // This is basically the top-level exception handler so that we don't
       // spew a stack trace on our users.
       // TODO(rnystrom): Add --trace flag so stack traces can be enabled for
       // debugging.
       var message = error.toString();
 
       // TODO(rnystrom): The default exception implementation class puts
       // "Exception:" in the output, so strip that off.
       if (message.startsWith("Exception: ")) {
         message = message.substring("Exception: ".length);
       }
 
       printError(message);
+      if (options['trace'] && trace != null) {
+        printError(trace);
+      }
       return true;
     }
 
     // TODO(rnystrom): Will eventually need better logic to walk up
     // subdirectories until we hit one that looks package-like. For now, just
     // assume the cwd is it.
-    Package.load(workingDir, cache.sources).chain((package) {
+    var future = Package.load(workingDir, cache.sources).chain((package) {
       entrypoint = new Entrypoint(package, cache);
 
       try {
         var commandFuture = onRun();
         if (commandFuture == null) return new Future.immediate(true);
 
         return commandFuture;
-      } catch (var error) {
-        handleError(error);
+      } catch (var error, var trace) {
+        handleError(error, trace);
         return new Future.immediate(null);
       }
-    }).handleException(handleError);
+    });
+    future.handleException((e) => handleError(e, future.stackTrace));
   }
 
   /**
    * Override this to perform the specific command. Return a future that
    * completes when the command is done or fails if the command fails. If the
    * command is synchronous, it may return `null`.
    */
   abstract Future onRun();
 }