Revert "Add logging system to pub and sprinkle some logging in."

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 'git_source.dart';
-import 'hosted_source.dart';
-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: 'print this usage information');
+    help: 'Prints this usage information');
   parser.addFlag('version', negatable: false,
-      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"');
+    help: 'Prints the version of Pub');
+  parser.addFlag('trace', help: 'Prints a stack trace when an error occurs');
   return parser;
 }
 
 main() {
   var globalOptions;
   try {
     globalOptions = pubArgParser.parse(new Options().arguments);
   } on FormatException catch (e) {
-    log.error(e.message);
-    log.error('Run "pub help" to see available options.');
+    printError(e.message);
+    printError('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) {
-    log.error('Could not find a command named "${globalOptions.rest[0]}".');
-    log.error('Run "pub help" to see available commands.');
+    printError('Could not find a command named "${globalOptions.rest[0]}".');
+    printError('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.']) {
-  // 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');
+  print(description);
+  print('');
+  print('Usage: pub command [arguments]');
+  print('');
+  print('Global options:');
+  print(pubArgParser.getUsage());
+  print('');
 
   // Show the commands sorted.
-  buffer.add('Available commands:\n');
+  print('Available commands:');
 
   // 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) {
-    buffer.add('  ${padRight(name, length)}   '
-        '${pubCommands[name].description}\n');
+    print('  ${padRight(name, length)}   ${pubCommands[name].description}');
   }
 
-  buffer.add('\n');
-  buffer.add('Use "pub help [command]" for more information about a command.');
-  log.message(buffer.toString());
+  print('');
+  print('Use "pub help [command]" for more information about a command.');
 }
 
 void printVersion() {
-  log.message('Pub $pubVersion');
+  print('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) {
-      log.error(e.message);
-      log.error('Use "pub help" for more information.');
+      printError(e.message);
+      printError('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);
       }
 
-      log.error(message);
+      printError(message);
       if (globalOptions['trace'] && trace != null) {
-        log.error(trace);
-        log.dumpTranscript();
+        printError(trace);
       }
 
       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;
-    log.message(description);
-    log.message('');
-    log.message('Usage: $usage');
+    print(description);
+    print('');
+    print('Usage: $usage');
 
     var commandUsage = commandParser.getUsage();
     if (!commandUsage.isEmpty) {
-      log.message('');
-      log.message(commandUsage);
+      print('');
+      print(commandUsage);
     }
   }
 
   /// 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;
     }
   }
 }