Adds a --include-dependent-packages option to docgen

pkg/docgen/lib/docgen.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.
 
 /// **docgen** is a tool for creating machine readable representations of Dart
 /// code metadata, including: classes, members, comments and annotations.
 ///
 /// docgen is run on a `.dart` file or a directory containing `.dart` files.
 ///
 ///      $ dart docgen.dart [OPTIONS] [FILE/DIR]
@@ skipping 48 matching lines @@
 List<markdown.InlineSyntax> markdownSyntaxes =
   [new markdown.CodeSyntax(r'\[:\s?((?:.|\n)*?)\s?:\]')];
 
 /// Index of all indexable items. This also ensures that no class is
 /// created more than once.
 Map<String, Indexable> entityMap = new Map<String, Indexable>();
 
 /// This is set from the command line arguments flag --include-private
 bool _includePrivate = false;
 
+/// This is set from the command line flag --include-dependent-packages
+bool _includeDependentPackages = false;
+
 /// Library names to explicitly exclude.
 ///
 ///   Set from the command line option
 /// --exclude-lib.
 List<String> _excluded;
 
 // TODO(janicejl): Make MDN content generic or pluggable. Maybe move
 // MDN-specific code to its own library that is imported into the default impl?
 /// Map of all the comments for dom elements from MDN.
 Map _mdn;
 
 /// Docgen constructor initializes the link resolver for markdown parsing.
 /// Also initializes the command line arguments.
 ///
 /// [packageRoot] is the packages directory of the directory being analyzed.
 /// If [includeSdk] is `true`, then any SDK libraries explicitly imported will
 /// also be documented.
 /// If [parseSdk] is `true`, then all Dart SDK libraries will be documented.
 /// This option is useful when only the SDK libraries are needed.
 ///
 /// Returned Future completes with true if document generation is successful.
 Future<bool> docgen(List<String> files, {String packageRoot,
     bool outputToYaml: true, bool includePrivate: false, bool includeSdk: false,
     bool parseSdk: false, bool append: false, String introduction: '',
-    out: DEFAULT_OUTPUT_DIRECTORY, List<String> excludeLibraries}) {
+    out: DEFAULT_OUTPUT_DIRECTORY, List<String> excludeLibraries,
+    bool includeDependentPackages}) {
   _excluded = excludeLibraries;
   _includePrivate = includePrivate;
   _outputDirectory = out;
+  _includeDependentPackages = includeDependentPackages;
   if (!append) {
     var dir = new Directory(_outputDirectory);
     if (dir.existsSync()) dir.deleteSync(recursive: true);
   }
 
   if (packageRoot == null && !parseSdk) {
     var type = FileSystemEntity.typeSync(files.first);
     if (type == FileSystemEntityType.DIRECTORY) {
       packageRoot = _findPackageRoot(files.first);
     } else if (type == FileSystemEntityType.FILE) {
       logger.warning('WARNING: No package root defined. If Docgen fails, try '
           'again by setting the --package-root option.');
     }
   }
   logger.info('Package Root: ${packageRoot}');
+  if (_includeDependentPackages) {
+    files.addAll(allDependentPackageDirs(files.first));
+  }
   var requestedLibraries = _listLibraries(files);
   var allLibraries = []..addAll(requestedLibraries);
   if (includeSdk) {
     allLibraries.addAll(_listSdk());
   }
 
   return getMirrorSystem(allLibraries, packageRoot: packageRoot,
       parseSdk: parseSdk)
     .then((MirrorSystem mirrorSystem) {
       if (mirrorSystem.libraries.isEmpty) {
@@ skipping 13 matching lines @@
               () => throw "Missing library $each")).toList();
       librariesToDocument.addAll((includeSdk || parseSdk) ? _sdkLibraries : []);
       librariesToDocument.removeWhere((x) => _excluded.contains(x.simpleName));
       _documentLibraries(librariesToDocument, includeSdk: includeSdk,
           outputToYaml: outputToYaml, append: append, parseSdk: parseSdk,
           introduction: introduction);
       return true;
     });
 }
 
+/// All of the directories for our dependent packages
+List<String> allDependentPackageDirs(String packageDirectory) {
+  var dependentsJson = Process.runSync('pub', ['list-package-dirs'],
+      workingDirectory: packageDirectory, runInShell: true);
+  if (dependentsJson.exitCode != 0) {
+    print(dependentsJson.stderr);
+  }
+  var dependents = JSON.decode(dependentsJson.stdout)['packages'];
+  return dependents.values.toList();
+}
+
 /// For a library's [mirror], determine the name of the package (if any) we
 /// believe it came from (because of its file URI).
 ///
 /// If [library] is specified, we set the packageName field. If no package could
 /// be determined, we return an empty string.
 String _findPackage(LibraryMirror mirror, [Library library]) {
   if (mirror == null) return '';
   if (library == null) {
     library = entityMap[docName(mirror)];
   }
@@ skipping 1527 matching lines @@
 /// Remove statics from the map of inherited items before adding them.
 Map _filterStatics(Map items) {
   var result = {};
   items.forEach((name, item) {
     if (!item.isStatic) {
       result[name] = item;
     }
   });
   return result;
 }