- Fix usability of coverage tool.

tools/full-coverage.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.
 
 import "dart:async";
 import "dart:convert";
 import "dart:io";
 import "dart:isolate";
 import "dart:mirrors";
 
 import "package:args/args.dart";
 import "package:path/path.dart";
 
 /// [Environment] stores gathered arguments information.
 class Environment {
   String sdkRoot;
   String pkgRoot;
   var input;
   var output;
   int workers;
   bool prettyPrint;
   bool lcov;
   bool expectMarkers;
   bool verbose;
 }
 
 /// [Resolver] resolves imports with respect to a given environment.
 class Resolver {
-  const DART_PREFIX = "dart:";
-  const PACKAGE_PREFIX = "package:";
-  const FILE_PREFIX = "file://";
-  const HTTP_PREFIX = "http://";
+  final DART_PREFIX = "dart:";
+  final PACKAGE_PREFIX = "package:";
+  final FILE_PREFIX = "file://";
+  final HTTP_PREFIX = "http://";

[siva, 2013/10/07 21:56:34]

Should these be 'static const' variables instead of 'final' instance variables.

[Ivan Posva, 2013/10/07 22:07:12]

Done.

 
   Map _env;
   List failed = [];
 
   Resolver(this._env);
 
   /// Returns the absolute path wrt. to the given environment or null, if the
   /// import could not be resolved.
   resolve(String import) {
     if (import.startsWith(DART_PREFIX)) {
@@ skipping 337 matching lines @@
     var start = files.length - filesPerWorker;
     var end = files.length;
     var workerFiles = files.getRange(start, end).toList();
     files.removeRange(start, end);
     p.send(new Message(Message.WORK, [sharedEnv, workerFiles]), port);
   }
   // Let the last worker deal with the rest of the files (which should be only
   // off by at max (#workers - 1).
   var p = spawnFunction(worker);
   workerPorts.add(p);
-  p.send(new Message(Message.WORK, [sharedEnv, files]), port);
+  p.send(new Message(Message.WORK, [sharedEnv, files]), port.toSendPort());
 
   return 0;
 }
 
 /// Checks the validity of the provided arguments. Does not initialize actual
 /// processing.
 parseArgs() {
   var parser = new ArgParser();
 
   parser.addOption("sdk-root", abbr: "s",
                    help: "path to the SDK root");
   parser.addOption("package-root", abbr: "p",
                    help: "path to the package root",
                    defaultsTo: ".");
   parser.addOption("in", abbr: "i",
-                   help: "input(s): may be file or directory",
-                   defaultsTo: "stdin");
+                   help: "input(s): may be file or directory");
   parser.addOption("out", abbr: "o",
                    help: "output: may be file or stdout",
                    defaultsTo: "stdout");
   parser.addOption("workers", abbr: "j",
                    help: "number of workers",
                    defaultsTo: "1");
   parser.addFlag("pretty-print", abbr: "r",
                  help: "convert coverage data to pretty print format",
                  negatable: false);
   parser.addFlag("lcov", abbr :"l",
                  help: "convert coverage data to lcov format",
                  negatable: false);
   parser.addFlag("verbose", abbr :"v",
                  help: "verbose output",
                  negatable: false);
   parser.addFlag("help", abbr: "h",
                  help: "show this help",
                  negatable: false);
 
   var args = parser.parse(new Options().arguments);
 
+  printUsage() {
+    print("Usage: dart full-coverage.dart [OPTION...]\n");
+    print(parser.getUsage());
+  }
+
+  fail(String msg) {
+    print("\n$msg\n");
+    printUsage();
+    exit(1);
+  }
+
   if (args["help"]) {
-    print("Usage: coverage [OPTION...]\n");
-    print(parser.getUsage());
+    printUsage();
     exit(0);
   }
 
   if (args["sdk-root"] == null) {
     if (Platform.environment.containsKey("SDK_ROOT")) {
       env.sdkRoot =
         join(absolute(normalize(Platform.environment["SDK_ROOT"])), "lib");
     } else {
-      throw "No SDK root found, please specify one using --sdk-root.";
+      fail("No SDK root found, please specify one using --sdk-root.");
     }
   } else {
     env.sdkRoot = join(absolute(normalize(args["sdk-root"])), "lib");
   }
   if (!FileSystemEntity.isDirectorySync(env.sdkRoot)) {
-    throw "Provided SDK root ${args["sdk-root"]} is not a valid SDK "
-          "top-level directory";
+    fail("Provided SDK root '${args["sdk-root"]}' is not a valid SDK "
+         "top-level directory");
   }
 
   if (args["package-root"] == null) {
     env.pkgRoot = absolute(normalize("./packages"));
   } else {
     env.pkgRoot = absolute(normalize(args["package-root"]));
     if (!FileSystemEntity.isDirectorySync(env.pkgRoot)) {
-      throw "Provided package root ${args["package-root"]} is not directory.";
+      fail("Provided package root '${args["package-root"]}' is not directory.");
     }
   }
 
-  if (args["in"] == "stdin") {
-    env.input = "stdin";
+  if (args["in"] == null) {
+    fail("No input files given.");
   } else {
     env.input = absolute(normalize(args["in"]));
     if (!FileSystemEntity.isDirectorySync(env.input) &&
         !FileSystemEntity.isFileSync(env.input)) {
-      throw "Provided input ${args["in"]} is neither a directory, nor a file.";
+      fail("Provided input '${args["in"]}' is neither a directory, nor a file.");
     }
   }
 
   if (args["out"] == "stdout") {
     env.output = stdout;
   } else {
     env.output = absolute(normalize(args["out"]));
     env.output = new File(env.output).openWrite();
   }
 
-  if (args["pretty-print"] &&
-      args["lcov"]) {
-    throw "Choose either pretty-print or lcov output";
+  if (args["pretty-print"] == args["lcov"]) {
+    fail("Choose either pretty-print or lcov output");
+  }
+  env.prettyPrint = args["pretty-print"];
+  env.lcov = args["lcov"];
+
+  try {
+    env.workers = int.parse("${args["workers"]}");
+  } catch (e) {
+    fail("Invalid worker count: $e");
   }
 
-  env.prettyPrint = args["pretty-print"];
-  env.lcov = args["lcov"];
   env.verbose = args["verbose"];
-  env.workers = int.parse("${args["workers"]}");
 }