added "pub deps --executables" command to show all available executables

* removed "run --list" command
* buffer is used to output executables
* tests were adapted to verify --dev/--no-dev flag

Author: akhomchenko

lib/src/command/deps.dart

@@ -4,12 +4,26 @@
 
 import 'dart:collection';
 
+import 'package:analyzer/analyzer.dart' as analyzer;
+import 'package:path/path.dart' as p;
+
 import '../ascii_tree.dart' as tree;
 import '../command.dart';
+import '../dart.dart';
 import '../log.dart' as log;
 import '../package.dart';
 import '../utils.dart';
 
+/// Returns `true` if [path] looks like a Dart entrypoint.
+bool _isDartExecutable(String path) {
+  try {
+    var unit = analyzer.parseDartFile(path, parseFunctionBodies: false);
+    return isEntrypoint(unit);
+  } on analyzer.AnalyzerErrorGroup {
+    return false;
+  }
+}
+
 /// Handles the `deps` pub command.
 class DepsCommand extends PubCommand {
   String get name => "deps";
@@ -36,6 +50,9 @@ class DepsCommand extends PubCommand {
         negatable: true,
         help: "Whether to include dev dependencies.",
         defaultsTo: true);
+
+    argParser.addFlag("executables",
+        negatable: false, help: "List all available executables.");
   }
 
   void run() {
@@ -44,18 +61,22 @@ class DepsCommand extends PubCommand {
 
     _buffer = new StringBuffer();
 
-    _buffer.writeln(_labelPackage(entrypoint.root));
-
-    switch (argResults["style"]) {
-      case "compact":
-        _outputCompact();
-        break;
-      case "list":
-        _outputList();
-        break;
-      case "tree":
-        _outputTree();
-        break;
+    if (argResults['executables']) {
+      _outputExecutables();
+    } else {
+      _buffer.writeln(_labelPackage(entrypoint.root));
+
+      switch (argResults["style"]) {
+        case "compact":
+          _outputCompact();
+          break;
+        case "list":
+          _outputList();
+          break;
+        case "tree":
+          _outputTree();
+          break;
+      }
     }
 
     log.message(_buffer);
@@ -231,4 +252,60 @@ class DepsCommand extends PubCommand {
         'was generated, please run "pub get" again.');
     return null;
   }
+
+  /// Outputs all executables reachable from [entrypoint].
+  void _outputExecutables() {
+    var packages = []
+      ..add(entrypoint.root)
+      ..addAll((_includeDev
+              ? entrypoint.root.immediateDependencies
+              : entrypoint.root.dependencies)
+          .map((dep) => entrypoint.packageGraph.packages[dep.name]));
+
+    for (var package in packages) {
+      var executables = _getExecutablesFor(package);
+      if (executables.isNotEmpty) {
+        _buffer.writeln(_formatExecutables(package.name, executables.toList()));
+      }
+    }
+  }
+
+  /// Lists all Dart files in the `bin` directory of the [package].
+  ///
+  /// Returns file names without extensions.
+  List<String> _getExecutablesFor(Package package) => package.executableIds
+      .where((e) => _isDartExecutable(p.absolute(package.dir, e.path)))
+      .map((e) => p.basenameWithoutExtension(e.path));
+
+  /// Returns formatted string that lists [executables] for the [packageName].
+  /// Examples:
+  ///
+  ///     _formatExecutables('foo', ['foo'])        // -> 'foo'
+  ///     _formatExecutables('foo', ['bar'])        // -> 'foo:bar'
+  ///     _formatExecutables('foo', ['bar', 'foo']) // -> 'foo: foo, bar'
+  ///
+  /// Note the leading space before first executable and sorting order in the
+  /// last example.
+  String _formatExecutables(String packageName, List<String> executables) {
+    if (executables.length == 1) {
+      // If executable matches the package name omit the name of executable in
+      // the output.
+      return executables.first != packageName
+          ? '${packageName}:${log.bold(executables.first)}'
+          : log.bold(executables.first);
+    }
+
+    // Sort executables to make executable that matches the package name to be
+    // the first in the list.
+    executables.sort((e1, e2) {
+      if (e1 == packageName)
+        return -1;
+      else if (e2 == packageName)
+        return 1;
+      else
+        return e1.compareTo(e2);
+    });
+
+    return '${packageName}: ${executables.map(log.bold).join(', ')}';
+  }
 }

lib/src/command/run.dart

@@ -10,8 +10,6 @@ import 'package:path/path.dart' as p;
 import '../command.dart';
 import '../executable.dart';
 import '../io.dart';
-import '../log.dart' as log;
-import '../package.dart';
 import '../utils.dart';
 
 /// Handles the `run` pub command.
@@ -24,20 +22,13 @@ class RunCommand extends PubCommand {
   RunCommand() {
     argParser.addFlag("checked",
         abbr: "c", help: "Enable runtime type checks and assertions.");
-    argParser.addFlag('list', negatable: false,
-        help: 'List all available executables.');
     argParser.addOption("mode",
         help: 'Mode to run transformers in.\n'
             '(defaults to "release" for dependencies, "debug" for '
             'entrypoint)');
   }
 
   Future run() async {
-    if (argResults['list']) {
-      _listExecutables();
-      return;
-    }
-
     if (argResults.rest.isEmpty) {
       usageException("Must specify an executable to run.");
     }
@@ -78,58 +69,4 @@ class RunCommand extends PubCommand {
         checked: argResults['checked'], mode: mode);
     await flushThenExit(exitCode);
   }
-
-  /// Lists all executables reachable from [entrypoint].
-  void _listExecutables() {
-    var packages = []
-      ..add(entrypoint.root)
-      ..addAll(entrypoint.root.immediateDependencies
-          .map((dep) => entrypoint.packageGraph.packages[dep.name]));
-
-    packages.forEach((Package package) {
-      var executables = _listExecutablesFor(package);
-      if (executables.isNotEmpty) {
-        log.message(_formatExecutables(package.name, executables.toList()));
-      }
-    });
-  }
-
-  /// Lists all Dart files in the `bin` directory of the [package].
-  ///
-  /// Returns file names without extensions.
-  List<String> _listExecutablesFor(Package package) {
-    return package
-        .listFiles(beneath: 'bin', recursive: false)
-        .where((executable) => p.extension(executable) == '.dart')
-        .map(p.basenameWithoutExtension);
-  }
-
-  /// Returns formatted string that lists [executables] for the [packageName].
-  /// Examples:
-  ///
-  ///     _formatExecutables('foo', ['foo'])        // -> 'foo'
-  ///     _formatExecutables('foo', ['bar'])        // -> 'foo:bar'
-  ///     _formatExecutables('foo', ['bar', 'foo']) // -> 'foo: foo, bar'
-  ///
-  /// Note the leading space before first executable and sorting order in the
-  /// last example.
-  String _formatExecutables(String packageName, List<String> executables) {
-    if (executables.length == 1) {
-      // If executable matches the package name omit the name of executable in
-      // the output.
-      return executables.first != packageName
-          ? '${log.bold(packageName)}:${executables.first}'
-          : log.bold(packageName);
-    } else {
-      // Sort executables to make executable that matches the package name to be
-      // the first in the list.
-      executables.sort((e1, e2) {
-        if (e1 == packageName) return -1;
-        else if (e2 == packageName) return 1;
-        else return e1.compareTo(e2);
-      });
-
-      return '${log.bold(packageName)}: ${executables.join(', ')}';
-    }
-  }
 }