Update pub to use the new command runner API in args.

sdk/lib/_internal/pub/lib/src/command_runner.dart

Index: sdk/lib/_internal/pub/lib/src/command_runner.dart
diff --git a/sdk/lib/_internal/pub/lib/src/command_runner.dart b/sdk/lib/_internal/pub/lib/src/command_runner.dart
new file mode 100644
index 0000000000000000000000000000000000000000..287a469d3c7afab37ae8cae062586b9023f1c47a
--- /dev/null
+++ b/sdk/lib/_internal/pub/lib/src/command_runner.dart
@@ -0,0 +1,182 @@
+// 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.
+
+library pub.command_runner;
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:args/args.dart';
+import 'package:args/command_runner.dart';
+import 'package:http/http.dart' as http;
+import 'package:stack_trace/stack_trace.dart';
+
+import 'command/build.dart';
+import 'command/cache.dart';
+import 'command/deps.dart';
+import 'command/downgrade.dart';
+import 'command/get.dart';
+import 'command/global.dart';
+import 'command/lish.dart';
+import 'command/list_package_dirs.dart';
+import 'command/run.dart';
+import 'command/serve.dart';
+import 'command/upgrade.dart';
+import 'command/uploader.dart';
+import 'command/version.dart';
+import 'exceptions.dart';
+import 'exit_codes.dart' as exit_codes;
+import 'http.dart';
+import 'io.dart';
+import 'log.dart' as log;
+import 'sdk.dart' as sdk;
+import 'solver/version_solver.dart';
+import 'utils.dart';
+
+class PubCommandRunner extends CommandRunner {
+  String get usageFooter => "See http://dartlang.org/tools/pub for detailed "
+      "documentation.";
+
+  PubCommandRunner()
+      : super("pub", "Pub is a package manager for Dart.") {
+    argParser.addFlag('version', negatable: false,
+        help: 'Print pub version.');
+    argParser.addFlag('trace',
+         help: 'Print debugging information when an error occurs.');
+    argParser.addOption('verbosity',
+        help: 'Control output verbosity.',
+        allowed: ['normal', 'io', 'solver', 'all'],
+        allowedHelp: {
+          'normal': 'Show errors, warnings, and user messages.',
+          'io':     'Also show IO operations.',
+          'solver': 'Show steps during version resolution.',
+          'all':    'Show all output including internal tracing messages.'
+        });
+    argParser.addFlag('verbose', abbr: 'v', negatable: false,
+        help: 'Shortcut for "--verbosity=all".');
+    argParser.addFlag('with-prejudice', hide: !isAprilFools,
+        negatable: false, help: 'Execute commands with prejudice.');
+    argParser.addFlag('package-symlinks', hide: true, negatable: true,
+        defaultsTo: true);
+
+    addCommand(new BuildCommand());
+    addCommand(new CacheCommand());
+    addCommand(new DepsCommand());
+    addCommand(new DowngradeCommand());
+    addCommand(new GlobalCommand());
+    addCommand(new GetCommand());
+    addCommand(new ListPackageDirsCommand());
+    addCommand(new LishCommand());
+    addCommand(new RunCommand());
+    addCommand(new ServeCommand());
+    addCommand(new UpgradeCommand());
+    addCommand(new UploaderCommand());
+    addCommand(new VersionCommand());
+  }
+
+  Future run(List<String> arguments) async {
+    var options;
+    try {
+      options = super.parse(arguments);
+    } on UsageException catch (error) {
+      log.error(error.message);
+      await flushThenExit(exit_codes.USAGE);
+    }
+    await runCommand(options);
+  }
+
+  Future runCommand(ArgResults options) async {
+    log.withPrejudice = options['with-prejudice'];
+
+    if (options['version']) {
+      log.message('Pub ${sdk.version}');
+      return;
+    }
+
+    if (options['trace']) {
+      log.recordTranscript();
+    }
+
+    switch (options['verbosity']) {
+      case 'normal': log.verbosity = log.Verbosity.NORMAL; break;
+      case 'io':     log.verbosity = log.Verbosity.IO; break;
+      case 'solver': log.verbosity = log.Verbosity.SOLVER; break;
+      case 'all':    log.verbosity = log.Verbosity.ALL; break;
+      default:
+        // No specific verbosity given, so check for the shortcut.
+        if (options['verbose']) log.verbosity = log.Verbosity.ALL;
+        break;
+    }
+
+    log.fine('Pub ${sdk.version}');
+
+    await _validatePlatform();
+
+    var captureStackChains =
+        options['trace'] ||
+        options['verbose'] ||
+        options['verbosity'] == 'all';
+
+    try {
+      await captureErrors(() => super.runCommand(options),
+          captureStackChains: captureStackChains);
+
+      // Explicitly exit on success to ensure that any dangling dart:io handles
+      // don't cause the process to never terminate.
+      await flushThenExit(exit_codes.SUCCESS);
+    } catch (error, chain) {
+      log.exception(error, chain);
+
+      if (options['trace']) {
+        log.dumpTranscript();
+      } else if (!isUserFacingException(error)) {
+        log.error("""
+This is an unexpected error. Please run
+
+    pub --trace ${options.arguments.map((arg) => "'$arg'").join(' ')}
+
+and include the results in a bug report on http://dartbug.com/new.
+""");
+      }
+
+      await flushThenExit(_chooseExitCode(error));
+    }
+  }
+
+  void printUsage() {
+    log.message(usage);
+  }
+
+  /// Returns the appropriate exit code for [exception], falling back on 1 if no
+  /// appropriate exit code could be found.
+  int _chooseExitCode(exception) {
+    while (exception is WrappedException) exception = exception.innerError;
+
+    if (exception is HttpException || exception is http.ClientException ||
+        exception is SocketException || exception is PubHttpException ||
+        exception is DependencyNotFoundException) {
+      return exit_codes.UNAVAILABLE;
+    } else if (exception is FormatException || exception is DataException) {
+      return exit_codes.DATA;
+    } else if (exception is UsageException) {
+      return exit_codes.USAGE;
+    } else {
+      return 1;
+    }
+  }
+
+  /// Checks that pub is running on a supported platform.
+  ///
+  /// If it isn't, it prints an error message and exits. Completes when the
+  /// validation is done.
+  Future _validatePlatform() async {
+    if (Platform.operatingSystem != 'windows') return;
+
+    var result = await runProcess('ver', []);
+    if (result.stdout.join('\n').contains('XP')) {
+      log.error('Sorry, but pub is not supported on Windows XP.');
+      await flushThenExit(exit_codes.USAGE);
+    }
+  }
+}