Add in basic logging system.

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 '../../pkg/args/lib/args.dart';
 import 'dart:io';
 import 'dart:math';
 import 'io.dart';
 import 'command_help.dart';
 import 'command_install.dart';
 import 'command_lish.dart';
 import 'command_update.dart';
 import 'command_version.dart';
 import 'entrypoint.dart';
 import 'exit_codes.dart' as exit_codes;
+import 'log.dart' as log;
 import 'package.dart';
 import 'pubspec.dart';
 import 'source.dart';
 import 'source_registry.dart';
 import 'system_cache.dart';
 import 'utils.dart';
 import 'version.dart';
 
 Version get pubVersion => new Version(0, 0, 0);
 
@@ skipping 16 matching lines @@
   return commands;
 }
 
 /**
  * The parser for arguments that are global to Pub rather than specific to a
  * single command.
  */
 ArgParser get pubArgParser {
   var parser = new ArgParser();
   parser.addFlag('help', abbr: 'h', negatable: false,
-    help: 'Prints this usage information');
+      help: 'print this usage information');
   parser.addFlag('version', negatable: false,
-    help: 'Prints the version of Pub');
-  parser.addFlag('trace', help: 'Prints a stack trace when an error occurs');
+      help: 'print the version of pub');
+  parser.addFlag('trace',
+       help: 'print debugging information when an error occurs');
+  parser.addOption('verbosity',
+      help: 'control output verbosity',
+      allowed: ['normal', 'io', 'all'],
+      allowedHelp: {
+        'normal': 'errors, warnings, and user messages are shown',
+        'io':     'IO operations are also shown',
+        'all':    'all output including internal tracing messages are shown'
+      });
+  parser.addFlag('verbose', abbr: 'v', negatable: false,
+      help: 'shortcut for "--verbosity=all"');
   return parser;
 }
 
 main() {
   var globalOptions;
   try {
     globalOptions = pubArgParser.parse(new Options().arguments);
   } on FormatException catch (e) {
-    printError(e.message);
-    printError('Run "pub help" to see available options.');
+    log.error(e.message);
+    log.error('Run "pub help" to see available options.');
     exit(exit_codes.USAGE);
   }
 
   if (globalOptions['version']) {
     printVersion();
     return;
   }
 
   if (globalOptions['help'] || globalOptions.rest.isEmpty) {
     printUsage();
     return;
   }
 
+  if (globalOptions['trace']) {
+    log.recordTranscript();
+  }
+
+  switch (globalOptions['verbosity']) {
+    case 'normal': log.showNormal(); break;
+    case 'io': log.showIO(); break;
+    case 'all': log.showAll(); break;
+    default:
+      // No specific verbosity given, so check for the shortcut.
+      if (globalOptions['verbose']) {
+        log.showAll();
+      } else {
+        log.showNormal();
+      }
+      break;
+  }
+
   // TODO(nweiz): Have a fallback for this this out automatically once 1145 is
   // fixed.
   var sdkDir = Platform.environment['DART_SDK'];
   var cacheDir;
   if (Platform.environment.containsKey('PUB_CACHE')) {
     cacheDir = Platform.environment['PUB_CACHE'];
   } else if (Platform.operatingSystem == 'windows') {
     var appData = Platform.environment['APPDATA'];
     cacheDir = join(appData, 'Pub', 'Cache');
   } else {
     cacheDir = '${Platform.environment['HOME']}/.pub-cache';
   }
 
   var cache = new SystemCache.withSources(cacheDir, sdkDir);
 
   // Select the command.
   var command = pubCommands[globalOptions.rest[0]];
   if (command == null) {
-    printError('Could not find a command named "${globalOptions.rest[0]}".');
-    printError('Run "pub help" to see available commands.');
+    log.error('Could not find a command named "${globalOptions.rest[0]}".');
+    log.error('Run "pub help" to see available commands.');
     exit(exit_codes.USAGE);
     return;
   }
 
   var commandArgs =
       globalOptions.rest.getRange(1, globalOptions.rest.length - 1);
   command.run(cache, globalOptions, commandArgs);
 }
 
 /** Displays usage information for the app. */
 void printUsage([String description = 'Pub is a package manager for Dart.']) {
-  print(description);
-  print('');
-  print('Usage: pub command [arguments]');
-  print('');
-  print('Global options:');
-  print(pubArgParser.getUsage());
-  print('');
+  // Build up a buffer so it shows up as a single log entry.
+  var buffer = new StringBuffer();
+  buffer.add(description);
+  buffer.add('\n\n');
+  buffer.add('Usage: pub command [arguments]\n\n');
+  buffer.add('Global options:\n');
+  buffer.add('${pubArgParser.getUsage()}\n\n');
 
   // Show the commands sorted.
-  print('Available commands:');
+  buffer.add('Available commands:\n');
 
   // TODO(rnystrom): A sorted map would be nice.
   int length = 0;
   var names = <String>[];
   for (var command in pubCommands.keys) {
     // Hide aliases.
     if (pubCommands[command].aliases.indexOf(command) >= 0) continue;
     length = max(length, command.length);
     names.add(command);
   }
 
   names.sort((a, b) => a.compareTo(b));
 
   for (var name in names) {
-    print('  ${padRight(name, length)}   ${pubCommands[name].description}');
+    buffer.add('  ${padRight(name, length)}   '
+        '${pubCommands[name].description}\n');
   }
 
-  print('');
-  print('Use "pub help [command]" for more information about a command.');
+  buffer.add('\n');
+  buffer.add('Use "pub help [command]" for more information about a command.');
+  log.message(buffer.toString());
 }
 
 void printVersion() {
-  print('Pub $pubVersion');
+  log.message('Pub $pubVersion');
 }
 
 abstract class PubCommand {
   SystemCache cache;
   ArgResults globalOptions;
   ArgResults commandOptions;
 
   Entrypoint entrypoint;
 
   /**
@@ skipping 22 matching lines @@
   ArgParser get commandParser => new ArgParser();
 
   void run(SystemCache cache_, ArgResults globalOptions_,
       List<String> commandArgs) {
     cache = cache_;
     globalOptions = globalOptions_;
 
     try {
      commandOptions = commandParser.parse(commandArgs);
     } on FormatException catch (e) {
-      printError(e.message);
-      printError('Use "pub help" for more information.');
+      log.error(e.message);
+      log.error('Use "pub help" for more information.');
       exit(exit_codes.USAGE);
     }
 
     handleError(error, trace) {
       // This is basically the top-level exception handler so that we don't
       // spew a stack trace on our users.
       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);
+      log.error(message);
       if (globalOptions['trace'] && trace != null) {
-        printError(trace);
+        log.error(trace);
+        log.dumpTranscript();
       }
 
       exit(_chooseExitCode(error));
     }
 
     var future = new Future.immediate(null);
     if (requiresEntrypoint) {
       // 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.
@@ skipping 35 matching lines @@
   /**
    * 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`.
    */
   Future onRun();
 
   /** Displays usage information for this command. */
   void printUsage([String description]) {
     if (description == null) description = this.description;
-    print(description);
-    print('');
-    print('Usage: $usage');
+
+    var buffer = new StringBuffer();
+    buffer.add(description);
+    buffer.add('');
+    buffer.add('Usage: $usage');
 
     var commandUsage = commandParser.getUsage();
     if (!commandUsage.isEmpty) {
-      print('');
-      print(commandUsage);
+      buffer.add('');
+      buffer.add(commandUsage);
     }
+
+    log.message(buffer.toString());
   }
 
   /// Returns the appropriate exit code for [exception], falling back on 1 if no
   /// appropriate exit code could be found.
   int _chooseExitCode(exception) {
     if (exception is HttpException || exception is HttpParserException ||
         exception is SocketIOException || exception is PubHttpException) {
       return exit_codes.UNAVAILABLE;
     } else if (exception is FormatException) {
       return exit_codes.DATA;
     } else {
       return 1;
     }
   }
 }