dart:io | Change File.fullPath to FileSystemEntity.resolveSymbolicLinks.

sdk/lib/io/file_system_entity.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.
 
 part of dart.io;
 
 class FileSystemEntityType {
   static const FILE = const FileSystemEntityType._internal(0);
   static const DIRECTORY = const FileSystemEntityType._internal(1);
   static const LINK = const FileSystemEntityType._internal(2);
@@ skipping 203 matching lines @@
    * Synchronously renames this file system entity. Returns a [FileSystemEntity]
    * instance for the renamed entity.
    *
    * If [newPath] identifies an existing entity of the same type, that entity
    * is replaced. If [newPath] identifies an existing entity of a different
    * type, the operation fails and an exception is thrown.
    */
   FileSystemEntity renameSync(String newPath);
 
   /**
+   * Resolves the path of a file system object relative to the
+   * current working directory, resolving all symbolic links on
+   * the path and resolving all '..' and '.' path segments.
+   * [resolveSymbolicLinks] returns a [:Future<String>:]
+   *
+   * [resolveSymbolicLinks] uses the operating system's native filesystem api
+   * to resolve the path, using the realpath function on linux and
+   * Mac OS, and the GetFinalPathNameByHandle function on Windows.
+   * If the path does not point to an existing file system object,
+   * [resolveSymbolicLinks] completes the returned Future with an FileException.
+   *
+   * On Windows, symbolic links are resolved to their target before applying
+   * a '..' that follows, and on other platforms, the '..' is applied to the
+   * symbolic link without resolving it.  The second behavior can be emulated
+   * on Windows by processing any '..' segments before calling
+   * [resolveSymbolicLinks].  One way of doing this is with the URI class:
+   * [:new Uri.parse('.').resolveUri(new Uri.file(input)).toFilePath();],
+   * since [resolve] removes '..' segments.
+   */
+  Future<String> resolveSymbolicLinks() {
+    // Get a new file service port for each request.  We could also cache one.
+    var service = _FileUtils._newServicePort();
+    List request = new List(2);
+    request[0] = _RESOLVE_SYMBOLIC_LINKS_REQUEST;
+    request[1] = path;
+    return service.call(request).then((response) {
+      if (_isErrorResponse(response)) {
+        throw _exceptionFromResponse(response,
+                                     "Cannot resolve symbolic links",
+                                     path);
+      }
+      return response;
+    });
+  }
+
+  /**
+   * Resolves the path of a file system object relative to the
+   * current working directory, resolving all symbolic links on
+   * the path and resolving all '..' and '.' path segments.
+   *
+   * [resolveSymbolicLinksSync] uses the operating system's native
+   * filesystem api to resolve the path, using the realpath function
+   * on linux and Mac OS, and the GetFinalPathNameByHandle function on Windows.
+   * If the path does not point to an existing file system object,
+   * [resolveSymbolicLinksSync] throws a FileException.
+   *
+   * On Windows, symbolic links are resolved to their target before applying
+   * a '..' that follows, and on other platforms, the '..' is applied to the
+   * symbolic link without resolving it.  The second behavior can be emulated
+   * on Windows by processing any '..' segments before calling
+   * [resolveSymbolicLinks].  One way of doing this is with the URI class:
+   * [:new Uri.parse('.').resolveUri(new Uri.file(input)).toFilePath();],
+   * since [resolve] removes '..' segments.
+   */
+  String resolveSymbolicLinksSync() {
+    var result = _resolveSymbolicLinks(path);
+    _throwIfError(result, "Cannot resolve symbolic links", path);
+    return result;
+  }
+
+
+  /**
    * Calls the operating system's stat() function on the [path] of this
    * [FileSystemEntity].  Identical to [:FileStat.stat(this.path):].
    *
    * Returns a [:Future<FileStat>:] object containing the data returned by
    * stat().
    *
    * If the call fails, completes the future with a [FileStat] object
    * with .type set to
    * FileSystemEntityType.NOT_FOUND and the other fields invalid.
    */
@@ skipping 75 matching lines @@
   Stream<FileSystemEvent> watch({int events: FileSystemEvent.ALL,
                                  bool recursive: false})
      => new _FileSystemWatcher(_trimTrailingPathSeparators(path),
                                events,
                                recursive).stream;
 
   Future<FileSystemEntity> _delete({recursive: false});
   void _deleteSync({recursive: false});
 
   /**
-   * Synchronously checks whether two paths refer to the same object in the
+   * Checks whether two paths refer to the same object in the
    * file system. Returns a [:Future<bool>:] that completes with the result.
    *
    * Comparing a link to its target returns false, as does comparing two links
    * that point to the same target.  To check the target of a link, use
    * Link.target explicitly to fetch it.  Directory links appearing
    * inside a path are followed, though, to find the file system object.
    *
    * Completes the returned Future with an error if one of the paths points
    * to an object that does not exist.
    */
@@ skipping 105 matching lines @@
 
   /**
    * Synchronously checks if typeSync(path) returns
    * FileSystemEntityType.DIRECTORY.
    */
   static bool isDirectorySync(String path) =>
       (_getTypeSync(path, true) == FileSystemEntityType.DIRECTORY._type);
 
   external static _getType(String path, bool followLinks);
   external static _identical(String path1, String path2);
+  external static _resolveSymbolicLinks(String path);
 
   static int _getTypeSync(String path, bool followLinks) {
     var result = _getType(path, followLinks);
     _throwIfError(result, 'Error getting type of FileSystemEntity');
     return result;
   }
 
   static Future<int> _getTypeAsync(String path, bool followLinks) {
     // Get a new file service port for each request.  We could also cache one.
     var service = _FileUtils._newServicePort();
@@ skipping 125 matching lines @@
   }
 }
 
 
 abstract class _FileSystemWatcher {
   external factory _FileSystemWatcher(String path, int events, bool recursive);
   external static bool get isSupported;
 
   Stream<FileSystemEvent> get stream;
 }