Migrate pub away from throwing strings.

utils/pub/io.dart

 // Copyright (c) 2013, 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.
 
 /// Helper functionality to make working with IO easier.
 library io;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
@@ skipping 244 matching lines @@
 /// Resolves [target] relative to the location of pub.dart.
 String relativeToPub(String target) {
   var scriptPath = new File(new Options().script).fullPathSync();
 
   // Walk up until we hit the "util(s)" directory. This lets us figure out where
   // we are if this function is called from pub.dart, or one of the tests,
   // which also live under "utils", or from the SDK where pub is in "util".
   var utilDir = path.dirname(scriptPath);
   while (path.basename(utilDir) != 'utils' &&
          path.basename(utilDir) != 'util') {
-    if (path.basename(utilDir) == '') throw 'Could not find path to pub.';
+    if (path.basename(utilDir) == '') {
+      throw new Exception('Could not find path to pub.');
+    }
     utilDir = path.dirname(utilDir);
   }
 
   return path.normalize(path.join(utilDir, 'pub', target));
 }
 
 /// A line-by-line stream of standard input.
 final Stream<String> stdinLines = streamToLines(
     new ByteStream(stdin).toStringStream());
 
@@ skipping 261 matching lines @@
     // std{out,err}Sink.
     store(process.stdout.handleError((_) {}), stdout, closeSink: false);
     store(process.stderr.handleError((_) {}), stderr, closeSink: false);
     return Future.wait([
       store(stream, process.stdin),
       process.exitCode
     ]);
   }).then((results) {
     var exitCode = results[1];
     if (exitCode != 0) {
-      throw "Failed to extract .tar.gz stream to $destination (exit code "
-        "$exitCode).";
+      throw new Exception("Failed to extract .tar.gz stream to $destination "
+          "(exit code $exitCode).");
     }
     log.fine("Extracted .tar.gz stream to $destination. Exit code $exitCode.");
   });
 }
 
 Future<bool> _extractTarGzWindows(Stream<List<int>> stream,
     String destination) {
   // TODO(rnystrom): In the repo's history, there is an older implementation of
   // this that does everything in memory by piping streams directly together
   // instead of writing out temp files. The code is simpler, but unfortunately,
@@ skipping 10 matching lines @@
     // Write the archive to a temp file.
     var dataFile = path.join(tempDir, 'data.tar.gz');
     return createFileFromStream(stream, dataFile).then((_) {
       // 7zip can't unarchive from gzip -> tar -> destination all in one step
       // first we un-gzip it to a tar file.
       // Note: Setting the working directory instead of passing in a full file
       // path because 7zip says "A full path is not allowed here."
       return runProcess(command, ['e', 'data.tar.gz'], workingDir: tempDir);
     }).then((result) {
       if (result.exitCode != 0) {
-        throw 'Could not un-gzip (exit code ${result.exitCode}). Error:\n'
+        throw new Exception('Could not un-gzip (exit code ${result.exitCode}). '
+                'Error:\n'
             '${result.stdout.join("\n")}\n'
-            '${result.stderr.join("\n")}';
+            '${result.stderr.join("\n")}');
       }
 
       // Find the tar file we just created since we don't know its name.
       var tarFile = listDir(tempDir).firstWhere(
           (file) => path.extension(file) == '.tar',
           orElse: () {
-        throw 'The gzip file did not contain a tar file.';
+        throw new FormatException('The gzip file did not contain a tar file.');
       });
 
       // Untar the archive into the destination directory.
       return runProcess(command, ['x', tarFile], workingDir: destination);
     }).then((result) {
       if (result.exitCode != 0) {
-        throw 'Could not un-tar (exit code ${result.exitCode}). Error:\n'
+        throw new Exception('Could not un-tar (exit code ${result.exitCode}). '
+                'Error:\n'
             '${result.stdout.join("\n")}\n'
-            '${result.stderr.join("\n")}';
+            '${result.stderr.join("\n")}');
       }
       return true;
     });
   });
 }
 
 /// Create a .tar.gz archive from a list of entries. Each entry can be a
 /// [String], [Directory], or [File] object. The root of the archive is
 /// considered to be [baseDir], which defaults to the current working directory.
 /// Returns a [ByteStream] that will emit the contents of the archive.
 ByteStream createTarGz(List contents, {baseDir}) {
   var buffer = new StringBuffer();
   buffer.write('Creating .tag.gz stream containing:\n');
   contents.forEach((file) => buffer.write('$file\n'));
   log.fine(buffer.toString());
 
   var controller = new StreamController<List<int>>();
 
   if (baseDir == null) baseDir = path.current;
   baseDir = path.absolute(baseDir);
   contents = contents.map((entry) {
     entry = path.absolute(entry);
     if (!isBeneath(entry, baseDir)) {
-      throw 'Entry $entry is not inside $baseDir.';
+      throw new ArgumentError('Entry $entry is not inside $baseDir.');
     }
     return path.relative(entry, from: baseDir);
   }).toList();
 
   if (Platform.operatingSystem != "windows") {
     var args = ["--create", "--gzip", "--directory", baseDir];
     args.addAll(contents);
     // TODO(nweiz): It's possible that enough command-line arguments will make
     // the process choke, so at some point we should save the arguments to a
     // file and pass them in via --files-from for tar and -i@filename for 7zip.
@@ skipping 63 matching lines @@
   const PubProcessResult(this.stdout, this.stderr, this.exitCode);
 
   bool get success => exitCode == 0;
 }
 
 /// Gets a [Uri] for [uri], which can either already be one, or be a [String].
 Uri _getUri(uri) {
   if (uri is Uri) return uri;
   return Uri.parse(uri);
 }