Several new features and improvements for dartdoc.

lib/dartdoc/dartdoc.dart

 // Copyright (c) 2012, 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.
 
 /**
  * To generate docs for a library, run this script with the path to an
  * entrypoint .dart file, like:
  *
  *     $ dart dartdoc.dart foo.dart
  *
  * This will create a "docs" directory with the docs for your libraries. To
  * create these beautiful docs, dartdoc parses your library and every library
  * it imports (recursively). From each library, it parses all classes and
  * members, finds the associated doc comments and builds crosslinked docs from
  * them.
  */
 #library('dartdoc');
 
 #import('dart:io');
 #import('dart:uri');
 #import('dart:json');
 #import('mirrors/mirrors.dart');
 #import('mirrors/mirrors_util.dart');
 #import('mirrors/dart2js_mirror.dart', prefix: 'dart2js');
 #import('classify.dart');
 #import('markdown.dart', prefix: 'md');
 #import('../compiler/implementation/scanner/scannerlib.dart',
         prefix: 'dart2js');
+#import('../compiler/implementation/library_map.dart');
 
 #source('comment_map.dart');
 #source('utils.dart');
 
 // TODO(johnniwinther): Note that [IN_SDK] gets initialized to true when this
 // file is modified by the SDK deployment script. If you change, be sure to test
 // that dartdoc still works when run from the built SDK directory.
 final bool IN_SDK = false;
 
 /**
@@ skipping 10 matching lines @@
  *
  * This dramatically reduces the generated size of the HTML since a large
  * fraction of each static page is just redundant navigation links.
  *
  * In this mode, the browser will do a XHR for nav.json which means that to
  * preview docs locally, you will need to enable requesting file:// links in
  * your browser or run a little local server like `python -m SimpleHTTPServer`.
  */
 final MODE_LIVE_NAV = 1;
 
+final API_LOCATION = 'http://api.dartlang.org/';
+
 /**
  * Run this from the `lib/dartdoc` directory.
  */
 void main() {
   final args = new Options().arguments;
 
-  // Parse the dartdoc options.
-  bool includeSource;
-  int mode;
-  Path outputDir;
-  bool generateAppCache;
-  bool omitGenerationTime;
-  bool verbose;
+  final dartdoc = new Dartdoc();
 
   if (args.isEmpty()) {
     print('No arguments provided.');
     printUsage();
     return;
   }
 
-  for (int i = 0; i < args.length - 1; i++) {
+  final entrypoints = <Path>[];
+
+  var i = 0;
+  while (i < args.length) {
     final arg = args[i];
+    if (!arg.startsWith('--')) {
+      // The remaining arguments must be entry points.
+      break;
+    }
 
     switch (arg) {
       case '--no-code':
-        includeSource = false;
+        dartdoc.includeSource = false;
         break;
 
       case '--mode=static':
-        mode = MODE_STATIC;
+        dartdoc.mode = MODE_STATIC;
         break;
 
       case '--mode=live-nav':
-        mode = MODE_LIVE_NAV;
+        dartdoc.mode = MODE_LIVE_NAV;
         break;
 
       case '--generate-app-cache':
       case '--generate-app-cache=true':
-        generateAppCache = true;
+        dartdoc.generateAppCache = true;
         break;
 
       case '--omit-generation-time':
-        omitGenerationTime = true;
+        dartdoc.omitGenerationTime = true;
         break;
       case '--verbose':
-        verbose = true;
+        dartdoc.verbose = true;
+        break;
+      case '--include-api':
+        dartdoc.includeApi = true;
+        break;
+      case '--link-api':
+        dartdoc.linkToApi = true;
         break;
 
       default:
         if (arg.startsWith('--out=')) {
-          outputDir = new Path.fromNative(arg.substring('--out='.length));
+          dartdoc.outputDir =
+              new Path.fromNative(arg.substring('--out='.length));
+        } else if (arg.startsWith('--include-lib=')) {
+          dartdoc.includedLibraries =
+              arg.substring('--include-lib='.length).split(',');
+        } else if (arg.startsWith('--exclude-lib=')) {
+          dartdoc.excludedLibraries =
+              arg.substring('--exclude-lib='.length).split(',');
         } else {
           print('Unknown option: $arg');
           printUsage();
           return;
         }
         break;
     }
+    i++;
+  }
+  while (i < args.length) {
+    final arg = args[i];
+    entrypoints.add(new Path.fromNative(arg));
+    i++;
   }
 
-  final entrypoint = new Path.fromNative(args[args.length - 1]);
-
-  final dartdoc = new Dartdoc();
-
-  if (includeSource != null) dartdoc.includeSource = includeSource;
-  if (mode != null) dartdoc.mode = mode;
-  if (outputDir != null) dartdoc.outputDir = outputDir;
-  if (generateAppCache != null) dartdoc.generateAppCache = generateAppCache;
-  if (omitGenerationTime != null) {
-    dartdoc.omitGenerationTime = omitGenerationTime;
+  if (entrypoints.isEmpty()) {
+    print('No entrypoints provided.');
+    printUsage();
+    return;
   }
-  if (verbose != null) dartdoc.verbose = verbose;
 
   cleanOutputDirectory(dartdoc.outputDir);
 
-  dartdoc.documentEntryPoint(entrypoint, libPath);
+  dartdoc.documentLibraries(entrypoints, libPath);
 
   // Compile the client-side code to JS.
   final clientScript = (dartdoc.mode == MODE_STATIC) ? 'static' : 'live-nav';
   Future compiled = compileScript(
     scriptDir.append('client-$clientScript.dart'),
     dartdoc.outputDir.append('client-$clientScript.js'));
 
   Future filesCopied = copyDirectory(scriptDir.append('static'),
                                      dartdoc.outputDir);
 
   Futures.wait([compiled, filesCopied]).then((_) {
     print('Documented ${dartdoc._totalLibraries} libraries, '
           '${dartdoc._totalTypes} types, and '
           '${dartdoc._totalMembers} members.');
   });
 }
 
 void printUsage() {
   print('''
-Usage dartdoc [options] <entrypoint>
+Usage dartdoc [options] <entrypoint(s)>
 [options] include
  --no-code                   Do not include source code in the documentation.
 
  --mode=static               Generates completely static HTML containing
                              everything you need to browse the docs. The only
                              client side behavior is trivial stuff like syntax
                              highlighting code.
 
  --mode=live-nav             (default) Generated docs do not include baked HTML
                              navigation. Instead, a single `nav.json` file is
                              created and the appropriate navigation is generated
                              client-side by parsing that and building HTML.
                                 This dramatically reduces the generated size of
                              the HTML since a large fraction of each static page
                              is just redundant navigation links.
                                 In this mode, the browser will do a XHR for
                              nav.json which means that to preview docs locally,
                              you will need to enable requesting file:// links in
                              your browser or run a little local server like
                              `python -m SimpleHTTPServer`.
 
  --generate-app-cache        Generates the App Cache manifest file, enabling
                              offline doc viewing.
 
  --out=<dir>                 Generates files into directory <dir>. If omitted
                              the files are generated into ./docs/
 
+ --link-api                  Link to the online language API in the generated
+                             documentation. The option overrides inclusion
+                             through --include-api or --include-lib.
+
+ --include-api               Include the used API libraries in the generated
+                             documentation.  If the --link-api option is used,
+                             this option is ignored.
+
+ --include-lib=<libs>        Use this option to explicitly specify which
+                             libraries to include in the documentation. If
+                             omitted, all used libraries are included by
+                             default. <libs> is comma-separated list of library
+                             names.
+
+ --exclude-lib=<libs>        Use this option to explicitly specify which
+                             libraries to exclude from the documentation. If
+                             omitted, no libraries are excluded. <libs> is
+                             comma-separated list of library names.
+
  --verbose                   Print verbose information during generation.
 ''');
 }
 
 /**
  * Gets the full path to the directory containing the entrypoint of the current
  * script. In other words, if you invoked dartdoc, directly, it will be the
  * path to the directory containing `dartdoc.dart`. If you're running a script
  * that imports dartdoc, it will be the path to that script.
  */
@@ skipping 113 matching lines @@
 
   /** Set this to add content before the footer */
   String preFooterText = '';
 
   /** Set this to omit generation timestamp from output */
   bool omitGenerationTime = false;
 
   /** Set by Dartdoc user to print extra information during generation. */
   bool verbose = false;
 
-  /** Set this to select the libraries to document */
-  List<String> libraries = null;
+  /** Set this to include API libraries in the documentation. */
+  bool includeApi = false;
+
+  /** Set this to generate links to the online API. */
+  bool linkToApi = false;
+
+  /** Set this to select the libraries to include in the documentation. */
+  List<String> includedLibraries = const <String>[];
+
+  /** Set this to select the libraries to exclude from the documentation. */
+  List<String> excludedLibraries = const <String>[];
 
   /**
    * This list contains the libraries sorted in by the library name.
    */
   List<LibraryMirror> _sortedLibraries;
 
   CommentMap _comments;
 
   /** The library that we're currently generating docs for. */
   LibraryMirror _currentLibrary;
@@ skipping 19 matching lines @@
     // Patch in support for [:...:]-style code to the markdown parser.
     // TODO(rnystrom): Markdown already has syntax for this. Phase this out?
     md.InlineParser.syntaxes.insertRange(0, 1,
         new md.CodeSyntax(@'\[\:((?:.|\n)*?)\:\]'));
 
     md.setImplicitLinkResolver((name) => resolveNameReference(name,
             currentLibrary: _currentLibrary, currentType: _currentType,
             currentMember: _currentMember));
   }
 
-  bool includeLibrary(LibraryMirror library) {
-    if (libraries != null) {
-      return libraries.indexOf(library.simpleName()) != -1;
+  /**
+   * Returns `true` if [library] is included in the generated documentation.
+   */
+  bool shouldIncludeLibrary(LibraryMirror library) {
+    if (shouldLinkToPublicApi(library)) {
+      return false;
     }
-    return true;
+    var includeByDefault = true;
+    String libraryName = library.simpleName();
+    if (!includedLibraries.isEmpty()) {
+      includeByDefault = false;
+      if (includedLibraries.indexOf(libraryName) != -1) {
+        return true;
+      }
+    }
+    if (excludedLibraries.indexOf(libraryName) != -1) {
+      return false;
+    }
+    if (libraryName.startsWith('dart:')) {
+      String suffix = libraryName.substring('dart:'.length);
+      LibraryInfo info = DART2JS_LIBRARY_MAP[suffix];
+      if (info != null) {
+        return !info.isInternal && includeApi;
+      }
+    }
+    return includeByDefault;
+  }
+
+  /**
+   * Returns `true` if links to the public API should be generated for
+   * [library].
+   */
+  bool shouldLinkToPublicApi(LibraryMirror library) {
+    if (linkToApi) {
+      String libraryName = library.simpleName();
+      if (libraryName.startsWith('dart:')) {
+        String suffix = libraryName.substring('dart:'.length);
+        LibraryInfo info = DART2JS_LIBRARY_MAP[suffix];
+        if (info != null) {
+          return !info.isInternal;
+        }
+      }
+    }
+    return false;
   }
 
   String get footerContent(){
     var footerItems = [];
     if(!omitGenerationTime) {
       footerItems.add("This page was generated at ${new Date.now()}");
     }
     if(footerText != null) {
       footerItems.add(footerText);
     }
@@ skipping 13 matching lines @@
   }
 
   void documentLibraries(List<Path> libraryList, Path libPath) {
     final compilation = new Compilation.library(libraryList, libPath);
     _document(compilation);
   }
 
   void _document(Compilation compilation) {
     // Sort the libraries by name (not key).
     _sortedLibraries = new List<LibraryMirror>.from(
-        compilation.mirrors().libraries().getValues().filter(includeLibrary));
+        compilation.mirrors().libraries().getValues().filter(
+            shouldIncludeLibrary));
     _sortedLibraries.sort((x, y) {
       return x.simpleName().toUpperCase().compareTo(
           y.simpleName().toUpperCase());
     });
 
     // Generate the docs.
     if (mode == MODE_LIVE_NAV) docNavigationJson();
 
     docIndex();
     for (final library in _sortedLibraries) {
@@ skipping 869 matching lines @@
     if (type.isTypeVariable) {
       // If we're using a type parameter within the body of a generic class then
       // just link back up to the class.
       write(a(typeUrl(enclosingType), type.simpleName()));
       return;
     }
 
     assert(type is InterfaceMirror);
 
     // Link to the type.
-    if (includeLibrary(type.library())) {
+    if (shouldLinkToPublicApi(type.library())) {
+      write('<a href="$API_LOCATION${typeUrl(type)}">${type.simpleName()}</a>');
+    } else if (shouldIncludeLibrary(type.library())) {
       write(a(typeUrl(type), type.simpleName()));
     } else {
       write(type.simpleName());
     }
 
     if (type.isDeclaration) {
       // Avoid calling [:typeArguments():] on a declaration.
       return;
     }
 
@@ skipping 203 matching lines @@
   }
 
   /**
    * Returns [:true:] if [type] should be regarded as an exception.
    */
   bool isException(TypeMirror type) {
     return type.simpleName().endsWith('Exception');
   }
 }