Added functionality to dump relevant status file entries to a single file to make it easier to see …

tools/migration/lib/src/path.dart

+// Copyright (c) 2017, 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 legacy_path;

[jcollins, 2017/07/24 18:24:51]

Did this module get copied from somewhere else?

[bkonyi, 2017/07/24 19:16:04]

Yes, this is from the test runner code. I grabbed the status_file.dart from
there and removed a lot of the extra stuff to make things simpler, but there was
still a dependency on this file.

[Bob Nystrom, 2017/07/24 21:47:47]

Oof, this is tricky.

We don't want to copy/paste files inside the repo since it will make our future
lives hell. (Note that our current task is exactly related to unforking a set of
copy/pasted files...)

However, test.dart is not designed to make it easy for you to reuse any of its
code. This is somewhat deliberate: we want it to have as few dependencies as
possible so that our testing infrastructure isn't itself reliant on all of the
things it exists to test. But I'm not convinced that we should be so dogmatic.
I'll start a thread with the relevant folks and you to see how we want to handle
this.

+
+import 'dart:io';
+import 'dart:math';
+
+// TODO: Remove this class, and use the URI class for all path manipulation.
+class Path {
+  final String _path;
+  final bool isWindowsShare;
+
+  Path(String source)
+      : _path = _clean(source),
+        isWindowsShare = _isWindowsShare(source);
+
+  Path.raw(String source)
+      : _path = source,
+        isWindowsShare = false;
+
+  Path._internal(String this._path, bool this.isWindowsShare);
+
+  static String _clean(String source) {
+    if (Platform.operatingSystem == 'windows') return _cleanWindows(source);
+    // Remove trailing slash from directories:
+    if (source.length > 1 && source.endsWith('/')) {
+      return source.substring(0, source.length - 1);
+    }
+    return source;
+  }
+
+  static String _cleanWindows(String source) {
+    // Change \ to /.
+    var clean = source.replaceAll('\\', '/');
+    // Add / before initial [Drive letter]:
+    if (clean.length >= 2 && clean[1] == ':') {
+      clean = '/$clean';
+    }
+    if (_isWindowsShare(source)) {
+      return clean.substring(1, clean.length);
+    }
+    return clean;
+  }
+
+  static bool _isWindowsShare(String source) {
+    return Platform.operatingSystem == 'windows' && source.startsWith('\\\\');
+  }
+
+  int get hashCode => _path.hashCode;
+  bool get isEmpty => _path.isEmpty;
+  bool get isAbsolute => _path.startsWith('/');
+  bool get hasTrailingSeparator => _path.endsWith('/');
+
+  String toString() => _path;
+
+  Path relativeTo(Path base) {
+    // Returns a path "relative" such that
+    // base.join(relative) == this.canonicalize.
+    // Throws exception if an impossible case is reached.
+    if (base.isAbsolute != isAbsolute ||
+        base.isWindowsShare != isWindowsShare) {
+      throw new ArgumentError("Invalid case of Path.relativeTo(base):\n"
+          "  Path and base must both be relative, or both absolute.\n"
+          "  Arguments: $_path.relativeTo($base)");
+    }
+
+    var basePath = base.toString();
+    // Handle drive letters specially on Windows.
+    if (base.isAbsolute && Platform.operatingSystem == 'windows') {
+      bool baseHasDrive =
+          basePath.length >= 4 && basePath[2] == ':' && basePath[3] == '/';
+      bool pathHasDrive =
+          _path.length >= 4 && _path[2] == ':' && _path[3] == '/';
+      if (baseHasDrive && pathHasDrive) {
+        int baseDrive = basePath.codeUnitAt(1) | 32; // Convert to uppercase.
+        if (baseDrive >= 'a'.codeUnitAt(0) &&
+            baseDrive <= 'z'.codeUnitAt(0) &&
+            baseDrive == (_path.codeUnitAt(1) | 32)) {
+          if (basePath[1] != _path[1]) {
+            // Replace the drive letter in basePath with that from _path.
+            basePath = '/${_path[1]}:/${basePath.substring(4)}';
+            base = new Path(basePath);
+          }
+        } else {
+          throw new ArgumentError("Invalid case of Path.relativeTo(base):\n"
+              "  Base path and target path are on different Windows drives.\n"
+              "  Arguments: $_path.relativeTo($base)");
+        }
+      } else if (baseHasDrive != pathHasDrive) {
+        throw new ArgumentError("Invalid case of Path.relativeTo(base):\n"
+            "  Base path must start with a drive letter if and "
+            "only if target path does.\n"
+            "  Arguments: $_path.relativeTo($base)");
+      }
+    }
+    if (_path.startsWith(basePath)) {
+      if (_path == basePath) return new Path('.');
+      // There must be a '/' at the end of the match, or immediately after.
+      int matchEnd = basePath.length;
+      if (_path[matchEnd - 1] == '/' || _path[matchEnd] == '/') {
+        // Drop any extra '/' characters at matchEnd
+        while (matchEnd < _path.length && _path[matchEnd] == '/') {
+          matchEnd++;
+        }
+        return new Path(_path.substring(matchEnd)).canonicalize();
+      }
+    }
+
+    List<String> baseSegments = base.canonicalize().segments();
+    List<String> pathSegments = canonicalize().segments();
+    if (baseSegments.length == 1 && baseSegments[0] == '.') {
+      baseSegments = [];
+    }
+    if (pathSegments.length == 1 && pathSegments[0] == '.') {
+      pathSegments = [];
+    }
+    int common = 0;
+    int length = min(pathSegments.length, baseSegments.length);
+    while (common < length && pathSegments[common] == baseSegments[common]) {
+      common++;
+    }
+    final segments = new List<String>();
+
+    if (common < baseSegments.length && baseSegments[common] == '..') {
+      throw new ArgumentError("Invalid case of Path.relativeTo(base):\n"
+          "  Base path has more '..'s than path does.\n"
+          "  Arguments: $_path.relativeTo($base)");
+    }
+    for (int i = common; i < baseSegments.length; i++) {
+      segments.add('..');
+    }
+    for (int i = common; i < pathSegments.length; i++) {
+      segments.add('${pathSegments[i]}');
+    }
+    if (segments.isEmpty) {
+      segments.add('.');
+    }
+    if (hasTrailingSeparator) {
+      segments.add('');
+    }
+    return new Path(segments.join('/'));
+  }
+
+  Path join(Path further) {

[jcollins, 2017/07/24 18:24:51]

Ordinarily, methods named "join" take an Iterable as a parameter, so calling
this method join makes uses of the class harder to read.  Can we either make
this take an iterable or call it something else?  Maybe joinWith?

[bkonyi, 2017/07/24 19:16:04]

To be honest, this is only here because status_file.dart depends on it. I didn't
write this, so I don't really know much about it myself.

+    if (further.isAbsolute) {
+      throw new ArgumentError(
+          "Path.join called with absolute Path as argument.");
+    }
+    if (isEmpty) {
+      return further.canonicalize();
+    }
+    if (hasTrailingSeparator) {

[jcollins, 2017/07/24 18:24:51]

This looks very much like append() from here out

[bkonyi, 2017/07/24 19:16:04]

See above.

+      var joined = new Path._internal('$_path${further}', isWindowsShare);
+      return joined.canonicalize();
+    }
+    var joined = new Path._internal('$_path/${further}', isWindowsShare);
+    return joined.canonicalize();
+  }
+
+  // Note: The URI RFC names for canonicalize, join, and relativeTo
+  // are normalize, resolve, and relativize.  But resolve and relativize
+  // drop the last segment of the base path (the filename), on URIs.
+  Path canonicalize() {
+    if (isCanonical) return this;
+    return makeCanonical();
+  }
+
+  bool get isCanonical {
+    // Contains no consecutive path separators.
+    // Contains no segments that are '.'.
+    // Absolute paths have no segments that are '..'.
+    // All '..' segments of a relative path are at the beginning.
+    if (isEmpty) return false; // The canonical form of '' is '.'.
+    if (_path == '.') return true;
+    var segs = _path.split('/'); // Don't mask the getter 'segments'.
+    if (segs[0] == '') {
+      // Absolute path
+      segs[0] = null; // Faster than removeRange().
+    } else {
+      // A canonical relative path may start with .. segments.
+      for (int pos = 0; pos < segs.length && segs[pos] == '..'; ++pos) {
+        segs[pos] = null;
+      }
+    }
+    if (segs.last == '') segs.removeLast(); // Path ends with /.
+    // No remaining segments can be ., .., or empty.
+    return !segs.any((s) => s == '' || s == '.' || s == '..');
+  }
+
+  Path makeCanonical() {
+    var isAbs = isAbsolute;
+    var segs = segments();
+    String drive;
+    if (isAbs && !segs.isEmpty && segs[0].length == 2 && segs[0][1] == ':') {
+      drive = segs[0];
+      segs.removeRange(0, 1);
+    }
+    var newSegs = <String>[];
+    for (var segment in segs) {
+      switch (segment) {
+        case '..':
+          // Absolute paths drop leading .. markers, including after a drive.
+          if (newSegs.isEmpty) {
+            if (isAbs) {
+              // Do nothing: drop the segment.
+            } else {
+              newSegs.add('..');
+            }
+          } else if (newSegs.last == '..') {
+            newSegs.add('..');
+          } else {
+            newSegs.removeLast();
+          }
+          break;
+        case '.':
+        case '':
+          // Do nothing - drop the segment.
+          break;
+        default:
+          newSegs.add(segment);
+          break;
+      }
+    }
+
+    var segmentsToJoin = <String>[];
+    if (isAbs) {
+      segmentsToJoin.add('');
+      if (drive != null) {
+        segmentsToJoin.add(drive);
+      }
+    }
+
+    if (newSegs.isEmpty) {
+      if (isAbs) {
+        segmentsToJoin.add('');
+      } else {
+        segmentsToJoin.add('.');
+      }
+    } else {
+      segmentsToJoin.addAll(newSegs);
+      if (hasTrailingSeparator) {
+        segmentsToJoin.add('');
+      }
+    }
+    return new Path._internal(segmentsToJoin.join('/'), isWindowsShare);
+  }
+
+  String toNativePath() {
+    if (isEmpty) return '.';
+    if (Platform.operatingSystem == 'windows') {
+      String nativePath = _path;
+      // Drop '/' before a drive letter.
+      if (nativePath.length >= 3 &&
+          nativePath.startsWith('/') &&
+          nativePath[2] == ':') {
+        nativePath = nativePath.substring(1);
+      }
+      nativePath = nativePath.replaceAll('/', '\\');
+      if (isWindowsShare) {
+        return '\\$nativePath';
+      }
+      return nativePath;
+    }
+    return _path;
+  }
+
+  List<String> segments() {
+    var result = _path.split('/');
+    if (isAbsolute) result.removeRange(0, 1);
+    if (hasTrailingSeparator) result.removeLast();
+    return result;
+  }
+
+  Path append(String finalSegment) {
+    if (isEmpty) {
+      return new Path._internal(finalSegment, isWindowsShare);
+    } else if (hasTrailingSeparator) {
+      return new Path._internal('$_path$finalSegment', isWindowsShare);
+    } else {
+      return new Path._internal('$_path/$finalSegment', isWindowsShare);
+    }
+  }
+
+  String get filenameWithoutExtension {
+    var name = filename;
+    if (name == '.' || name == '..') return name;
+    int pos = name.lastIndexOf('.');
+    return (pos < 0) ? name : name.substring(0, pos);
+  }
+
+  String get extension {
+    var name = filename;
+    int pos = name.lastIndexOf('.');
+    return (pos < 0) ? '' : name.substring(pos + 1);
+  }
+
+  Path get directoryPath {
+    int pos = _path.lastIndexOf('/');
+    if (pos < 0) return new Path('');
+    while (pos > 0 && _path[pos - 1] == '/') --pos;
+    var dirPath = (pos > 0) ? _path.substring(0, pos) : '/';
+    return new Path._internal(dirPath, isWindowsShare);
+  }
+
+  String get filename {
+    int pos = _path.lastIndexOf('/');
+    return _path.substring(pos + 1);
+  }
+}