Handle relative paths in the output of "pub list-package-dirs".

pkg/analysis_server/lib/src/resource.dart

 // Copyright (c) 2014, 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.
 
 library resource;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:io' as io;
 
@@ skipping 29 matching lines @@
    * Return a list of existing direct children [Resource]s (folders and files)
    * in this folder, in no particular order.
    */
   List<Resource> getChildren();
 
   /**
    * Watch for changes to the files inside this folder (and in any nested
    * folders, including folders reachable via links).
    */
   Stream<WatchEvent> get changes;
+
+  /**
+   * If the path [path] is a relative path, convert it to an absolute path
+   * by interpreting it relative to this folder.  If it is already an aboslute
+   * path, then don't change it.
+   *
+   * However, regardless of whether [path] is relative or absolute, normalize
+   * it by removing path components of the form '.' or '..'.
+   */
+  String canonicalizePath(String path);
 }
 
 
 /**
  * The abstract class [Resource] is an abstraction of file or folder.
  */
 abstract class Resource {
   /**
    * Return `true` if this resource exists.
    */
@@ skipping 171 matching lines @@
 
 
 /**
  * An in-memory implementation of [Folder].
  */
 class _MemoryFolder extends _MemoryResource implements Folder {
   _MemoryFolder(MemoryResourceProvider provider, String path) :
       super(provider, path);
   @override
   Resource getChild(String relPath) {
-    relPath = posix.normalize(relPath);
-    String childPath = posix.join(path, relPath);
-    childPath = posix.normalize(childPath);
+    String childPath = canonicalizePath(relPath);
     _MemoryResource resource = _provider._pathToResource[childPath];
     if (resource == null) {
       resource = new _MemoryFile(_provider, childPath);
     }
     return resource;
   }
 
   @override
   List<Resource> getChildren() {
     List<Resource> children = <Resource>[];
@@ skipping 13 matching lines @@
     }
     _provider._pathToWatchers[path].add(streamController);
     streamController.done.then((_) {
       _provider._pathToWatchers[path].remove(streamController);
       if (_provider._pathToWatchers[path].isEmpty) {
         _provider._pathToWatchers.remove(path);
       }
     });
     return streamController.stream;
   }
+
+  @override
+  String canonicalizePath(String relPath) {
+    relPath = posix.normalize(relPath);
+    String childPath = posix.join(path, relPath);
+    childPath = posix.normalize(childPath);
+    return childPath;
+  }
 }
 
 
 /**
  * An in-memory implementation of [ResourceProvider].
  * Use `/` as a path separator.
  */
 class MemoryResourceProvider implements ResourceProvider {
   final HashMap<String, _MemoryResource> _pathToResource =
       new HashMap<String, _MemoryResource>();
@@ skipping 103 matching lines @@
 
 
 /**
  * A `dart:io` based implementation of [Folder].
  */
 class _PhysicalFolder extends _PhysicalResource implements Folder {
   _PhysicalFolder(io.Directory directory) : super(directory);
 
   @override
   Resource getChild(String relPath) {
-    String childPath = join(_entry.absolute.path, relPath);
-    return PhysicalResourceProvider.INSTANCE.getResource(childPath);
+    return PhysicalResourceProvider.INSTANCE.getResource(canonicalizePath(relPath));
   }
 
   @override
   List<Resource> getChildren() {
     List<Resource> children = <Resource>[];
     io.Directory directory = _entry as io.Directory;
     List<io.FileSystemEntity> entries = directory.listSync(recursive: false);
     int numEntries = entries.length;
     for (int i = 0; i < numEntries; i++) {
       io.FileSystemEntity entity = entries[i];
       if (entity is io.Directory) {
         children.add(new _PhysicalFolder(entity));
       } else if (entity is io.File) {
         children.add(new _PhysicalFile(entity));
       }
     }
     return children;
   }
 
   @override
   Stream<WatchEvent> get changes => new DirectoryWatcher(_entry.path).events;
+
+  @override
+  String canonicalizePath(String relPath) {
+    return normalize(join(_entry.absolute.path, relPath));
+  }
 }
 
 
 /**
  * A `dart:io` based implementation of [Resource].
  */
 abstract class _PhysicalResource implements Resource {
   final io.FileSystemEntity _entry;
 
   _PhysicalResource(this._entry);
@@ skipping 85 matching lines @@
   }
 
   /**
    * Return `true` if the given URI is a `file` URI.
    *
    * @param uri the URI being tested
    * @return `true` if the given URI is a `file` URI
    */
   static bool _isFileUri(Uri uri) => uri.scheme == _FILE_SCHEME;
 }