Make listDir always emit paths within the given directory.

utils/pub/io.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.
 
 /**
  * Helper functionality to make working with IO easier.
  */
 library io;
 
 import 'dart:io';
@@ skipping 227 matching lines @@
  * Asynchronously recursively deletes [dir], which can be a [String] or a
  * [Directory]. Returns a [Future] that completes when the deletion is done.
  */
 Future<Directory> deleteDir(dir) {
   dir = _getDirectory(dir);
 
   return _attemptRetryable(() => log.ioAsync("delete directory ${dir.path}",
       dir.delete(recursive: true)));
 }
 
-/**
- * Asynchronously lists the contents of [dir], which can be a [String] directory
- * path or a [Directory]. If [recursive] is `true`, lists subdirectory contents
- * (defaults to `false`). If [includeHiddenFiles] is `true`, includes files and
- * directories beginning with `.` (defaults to `false`).
- */
+/// Asynchronously lists the contents of [dir], which can be a [String]
+/// directory path or a [Directory]. If [recursive] is `true`, lists
+/// subdirectory contents (defaults to `false`). If [includeHiddenFiles] is
+/// `true`, includes files and directories beginning with `.` (defaults to
+/// `false`).
+///
+/// If [dir] is a string, the returned paths are guaranteed to begin with it.
 Future<List<String>> listDir(dir,
-    {bool recursive: false, bool includeHiddenFiles: false}) {
+    {bool recursive: false, bool includeHiddenFiles: false,
+     Set<String> _listedDirectories}) {

[Bob Nystrom, 2012/12/17 23:42:33]

Instead of making this an optional parameter, how about splitting this into the
public method without it, and a separate private method that requires this and
does the recursion. I find the nested recursive async control flow a bit hard to
read here.

[nweiz, 2012/12/18 18:38:43]

Done.

   final completer = new Completer<List<String>>();
   final contents = <String>[];
 
+  // Avoid recursive symlinks.
+  if (_listedDirectories == null) _listedDirectories = new Set<String>();
+  var resolvedPath = new File(dir).fullPathSync();
+  if (_listedDirectories.contains(resolvedPath)) {
+    return new Future.immediate([]);
+  }
+  _listedDirectories = new Set<String>.from(_listedDirectories);
+  _listedDirectories.add(resolvedPath);
+
   dir = _getDirectory(dir);
   log.io("Listing directory ${dir.path}.");
-  var lister = dir.list(recursive: recursive);
+  var lister = dir.list();
 
   lister.onDone = (done) {
     // TODO(rnystrom): May need to sort here if it turns out onDir and onFile
     // aren't guaranteed to be called in a certain order. So far, they seem to.
     if (done) {
       log.fine("Listed directory ${dir.path}:\n"
                 "${Strings.join(contents, '\n')}");
       completer.complete(contents);
     }
   };
 
   // TODO(nweiz): remove this when issue 4061 is fixed.
   var stackTrace;
   try {
     throw "";
   } catch (_, localStackTrace) {
     stackTrace = localStackTrace;
   }
 
+  var children = [];
   lister.onError = (error) => completer.completeException(error, stackTrace);
   lister.onDir = (file) {
     if (!includeHiddenFiles && basename(file).startsWith('.')) return;
+    file = join(dir, basename(file));
     contents.add(file);
+
+    // TODO(nweiz): don't manually recurse once issue 7358 is fixed.
+    if (recursive) {
+      children.add(listDir(file,
+          recursive: true,
+          includeHiddenFiles: includeHiddenFiles,
+          _listedDirectories: _listedDirectories));
+    }
   };
   lister.onFile = (file) {
     if (!includeHiddenFiles && basename(file).startsWith('.')) return;
-    contents.add(file);
+    contents.add(join(dir, basename(file)));
   };
 
-  return completer.future;
+  return completer.future.chain((contents) {
+    return Futures.wait(children).transform((childContents) {
+      contents.addAll(flatten(childContents));
+      return contents;
+    });
+  });
 }
 
 /**
  * Asynchronously determines if [dir], which can be a [String] directory path
  * or a [Directory], exists on the file system. Returns a [Future] that
  * completes with the result.
  */
 Future<bool> dirExists(dir) {
   dir = _getDirectory(dir);
   return log.ioAsync("Seeing if directory ${dir.path} exists.",
@@ skipping 765 matching lines @@
   return new Directory(entry);
 }
 
 /**
  * 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 new Uri.fromString(uri);
 }