Clean up the semantics of io.dart operations w.r.t. symlinks.

utils/pub/io.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.
 
 /// Helper functionality to make working with IO easier.
 library io;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
@@ skipping 10 matching lines @@
 export '../../pkg/http/lib/http.dart' show ByteStream;
 
 /// Returns whether or not [entry] is nested somewhere within [dir]. This just
 /// performs a path comparison; it doesn't look at the actual filesystem.
 bool isBeneath(String entry, String dir) {
   var relative = path.relative(entry, from: dir);
   return !path.isAbsolute(relative) && path.split(relative)[0] != '..';
 }
 
 /// Determines if a file or directory exists at [path].
-bool entryExists(String path) => dirExists(path) || fileExists(path);
+bool entryExists(String path) =>
+  dirExists(path) || fileExists(path) || linkExists(path);
 
-/// Determines if [file] exists on the file system. Will also return `true` if
-/// [file] points to a symlink, even a directory symlink.
-bool fileExists(String file) =>
-    new File(file).existsSync() || new Link(file).existsSync();
+/// Returns whether [link] exists on the file system. This will return `true`
+/// for any symlink, regardless of what it points at or whether it's broken.
+bool linkExists(String path) => new Link(path).existsSync();
+
+/// Returns whether [file] exists on the file system. This will return `true`
+/// for a symlink only if that symlink is unbroken and points to a file.
+bool fileExists(String file) => new File(file).existsSync();
 
 /// Reads the contents of the text file [file].
 String readTextFile(String file) =>
     new File(file).readAsStringSync(encoding: Encoding.UTF_8);
 
 /// Reads the contents of the binary file [file].
 List<int> readBinaryFile(String file) {
   log.io("Reading binary file $file.");
   var contents = new File(file).readAsBytesSync();
   log.io("Read ${contents.length} bytes from $file.");
   return contents;
 }
 
 /// Creates [file] and writes [contents] to it.
 ///
 /// If [dontLogContents] is true, the contents of the file will never be logged.
 String writeTextFile(String file, String contents, {dontLogContents: false}) {
   // Sanity check: don't spew a huge file.
   log.io("Writing ${contents.length} characters to text file $file.");
   if (!dontLogContents && contents.length < 1024 * 1024) {
     log.fine("Contents:\n$contents");
   }
 
   new File(file).writeAsStringSync(contents);
   return file;
 }
 
-/// Deletes [file].
-void deleteFile(String file) {
-  new File(file).deleteSync();
-}
-
 /// Creates [file] and writes [contents] to it.
 String writeBinaryFile(String file, List<int> contents) {
   log.io("Writing ${contents.length} bytes to binary file $file.");
   new File(file).openSync(mode: FileMode.WRITE)
       ..writeListSync(contents, 0, contents.length)
       ..closeSync();
   log.fine("Wrote text file $file.");
   return file;
 }
 
@@ skipping 40 matching lines @@
 /// Creates a temp directory whose name will be based on [dir] with a unique
 /// suffix appended to it. If [dir] is not provided, a temp directory will be
 /// created in a platform-dependent temporary location. Returns the path of the
 /// created directory.
 String createTempDir([dir = '']) {
   var tempDir = new Directory(dir).createTempSync();
   log.io("Created temp directory ${tempDir.path}");
   return tempDir.path;
 }
 
-/// Recursively deletes [dir].
-void deleteDir(String dir) {
-  log.io("Deleting directory $dir.");
-  new Directory(dir).deleteSync(recursive: true);
-}
-
 /// Asynchronously lists the contents of [dir]. 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(String dir,
     {bool recursive: false, bool includeHiddenFiles: false}) {
   Future<List<String>> doList(String dir, Set<String> listedDirectories) {
     var contents = <String>[];
@@ skipping 47 matching lines @@
       return Future.wait(children).then((childContents) {
         contents.addAll(flatten(childContents));
         return contents;
       });
     });
   }
 
   return doList(dir, new Set<String>());
 }
 
-/// Determines if [dir] exists on the file system.
+/// Returns whether [dir] exists on the file system. This will return `true` for
+/// a symlink only if that symlink is unbroken and points to a directory.
 bool dirExists(String dir) => new Directory(dir).existsSync();
 
+/// Deletes whatever's at [path], whether it's a file, directory, or symlink. If
+/// it's a directory, it will be deleted recursively.
+void deleteEntry(String path) {
+  if (linkExists(path)) {
+    log.io("Deleting link $path.");
+    new Link(path).deleteSync();
+  } else if (dirExists(path)) {
+    log.io("Deleting directory $path.");
+    new Directory(path).deleteSync(recursive: true);
+  } else {
+    log.io("Deleting file $path.");
+    new File(path).deleteSync();
+  }
+}
+
 /// "Cleans" [dir]. If that directory already exists, it will be deleted. Then a
 /// new empty directory will be created.
 void cleanDir(String dir) {
-  if (dirExists(dir)) {
-    // Delete it first.
-    deleteDir(dir);
-  } else if (fileExists(dir)) {
-    // If there is a non-directory there (file or symlink), delete it.
-    deleteFile(dir);
-  }
-
-  // Just create it.
+  if (entryExists(dir)) deleteEntry(dir);
   createDir(dir);
 }
 
 /// Renames (i.e. moves) the directory [from] to [to].
 void renameDir(String from, String to) {
   log.io("Renaming directory $from to $to.");
   new Directory(from).renameSync(to);
 }
 
 /// Creates a new symlink at path [symlink] that points to [target]. Returns a
@@ skipping 348 matching lines @@
 /// returned by [fn] completes, the temporary directory and all its contents
 /// will be deleted. [fn] can also return `null`, in which case the temporary
 /// directory is deleted immediately afterwards.
 ///
 /// Returns a future that completes to the value that the future returned from
 /// [fn] completes to.
 Future withTempDir(Future fn(String path)) {
   return defer(() {
     var tempDir = createTempDir();
     return new Future.of(() => fn(tempDir))
-        .whenComplete(() => deleteDir(tempDir));
+        .whenComplete(() => deleteEntry(tempDir));
   });
 }
 
 /// Extracts a `.tar.gz` file from [stream] to [destination]. Returns whether
 /// or not the extraction was successful.
 Future<bool> extractTarGz(Stream<List<int>> stream, String destination) {
   log.fine("Extracting .tar.gz stream to $destination.");
 
   if (Platform.operatingSystem == "windows") {
     return _extractTarGzWindows(stream, destination);
@@ skipping 169 matching lines @@
   const PubProcessResult(this.stdout, this.stderr, this.exitCode);
 
   bool get success => exitCode == 0;
 }
 
 /// 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 Uri.parse(uri);
 }