Make dirname and basename ignore trailing separators and double slashes.

pkg/path/lib/path.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.
 
 /// A comprehensive, cross-platform path manipulation library.
 library path;
 
 import 'dart:io' as io;
 
 /// An internal builder for the current OS so we can provide a straight
@@ skipping 10 matching lines @@
 /// Converts [path] to an absolute path by resolving it relative to the current
 /// working directory. If [path] is already an absolute path, just returns it.
 ///
 ///     path.absolute('foo/bar.txt'); // -> /your/current/dir/foo/bar.txt
 String absolute(String path) => join(current, path);
 
 /// Gets the part of [path] after the last separator.
 ///
 ///     path.basename('path/to/foo.dart'); // -> 'foo.dart'
 ///     path.basename('path/to');          // -> 'to'
+///
+/// Trailing separators are ignored.
+///
+///     builder.dirname('path/to/'); // -> 'to'
 String basename(String path) => _builder.basename(path);
 
 /// Gets the part of [path] after the last separator, and without any trailing
 /// file extension.
 ///
 ///     path.basenameWithoutExtension('path/to/foo.dart'); // -> 'foo'
+///
+/// Trailing separators are ignored.
+///
+///     builder.dirname('path/to/foo.dart/'); // -> 'foo'
 String basenameWithoutExtension(String path) =>
     _builder.basenameWithoutExtension(path);
 
 /// Gets the part of [path] before the last separator.
 ///
 ///     path.dirname('path/to/foo.dart'); // -> 'path/to'
 ///     path.dirname('path/to');          // -> 'to'
+///
+/// Trailing separators are ignored.
+///
+///     builder.dirname('path/to/'); // -> 'path'
 String dirname(String path) => _builder.dirname(path);
 
 /// Gets the file extension of [path]: the portion of [basename] from the last
 /// `.` to the end (including the `.` itself).
 ///
 ///     path.extension('path/to/foo.dart');    // -> '.dart'
 ///     path.extension('path/to/foo');         // -> ''
 ///     path.extension('path.to/foo');         // -> ''
 ///     path.extension('path/to/foo.dart.js'); // -> '.js'
 ///
@@ skipping 129 matching lines @@
 
   /// Gets the path separator for the builder's [style]. On Mac and Linux,
   /// this is `/`. On Windows, it's `\`.
   String get separator => style.separator;
 
   /// Gets the part of [path] after the last separator on the builder's
   /// platform.
   ///
   ///     builder.basename('path/to/foo.dart'); // -> 'foo.dart'
   ///     builder.basename('path/to');          // -> 'to'
+  ///
+  /// Trailing separators are ignored.
+  ///
+  ///     builder.dirname('path/to/'); // -> 'to'
   String basename(String path) => _parse(path).basename;
 
   /// Gets the part of [path] after the last separator on the builder's
   /// platform, and without any trailing file extension.
   ///
   ///     builder.basenameWithoutExtension('path/to/foo.dart'); // -> 'foo'
+  ///
+  /// Trailing separators are ignored.
+  ///
+  ///     builder.dirname('path/to/foo.dart/'); // -> 'foo'
   String basenameWithoutExtension(String path) =>
-      _parse(path).basenameWithoutExtension;
+    _parse(path).basenameWithoutExtension;
 
   /// Gets the part of [path] before the last separator.
   ///
   ///     builder.dirname('path/to/foo.dart'); // -> 'path/to'
-  ///     builder.dirname('path/to');          // -> 'to'
+  ///     builder.dirname('path/to');          // -> 'path'
+  ///
+  /// Trailing separators are ignored.
+  ///
+  ///     builder.dirname('path/to/'); // -> 'path'
   String dirname(String path) {
     var parsed = _parse(path);
+    parsed.removeTrailingSeparators();
     if (parsed.parts.isEmpty) return parsed.root == null ? '.' : parsed.root;
-    if (!parsed.hasTrailingSeparator) {
-      if (parsed.parts.length == 1) {
-        return parsed.root == null ? '.' : parsed.root;
-      }
-      parsed.parts.removeLast();
-      parsed.separators.removeLast();
+    if (parsed.parts.length == 1) {
+      return parsed.root == null ? '.' : parsed.root;
     }
-    parsed.separators[parsed.separators.length - 1] = '';
+    parsed.parts.removeLast();
+    parsed.separators.removeLast();
+    parsed.removeTrailingSeparators();

[Bob Nystrom, 2012/12/20 02:27:28]

Is this redundant with the above call to removeTrailingSeparators()?

[nweiz, 2012/12/20 20:54:49]

No. The first call removes the separators at the end of the input path
("path///to///" -> "path///to"), the second call removes the separators at the
end of the output path ("path///" -> "path").

     return parsed.toString();
   }
 
   /// Gets the file extension of [path]: the portion of [basename] from the last
   /// `.` to the end (including the `.` itself).
   ///
   ///     builder.extension('path/to/foo.dart'); // -> '.dart'
   ///     builder.extension('path/to/foo'); // -> ''
   ///     builder.extension('path.to/foo'); // -> ''
   ///     builder.extension('path/to/foo.dart.js'); // -> '.js'
@@ skipping 206 matching lines @@
     // out of them.
     pathParsed.parts.insertRange(0, fromParsed.parts.length, '..');
     pathParsed.separators.insertRange(0, fromParsed.parts.length,
         style.separator);
 
     // Corner case: the paths completely collapsed.
     if (pathParsed.parts.length == 0) return '.';
 
     // Make it relative.
     pathParsed.root = '';
-    pathParsed.removeTrailingSeparator();
+    pathParsed.removeTrailingSeparators();
 
     return pathParsed.toString();
   }
 
   /// Removes a trailing extension from the last part of [path].
   ///
   ///     builder.withoutExtension('path/to/foo.dart'); // -> 'path/to/foo'
   String withoutExtension(String path) {
     var parsed = _parse(path);
-    if (parsed.hasTrailingSeparator) return parsed.toString();
 
-    if (!parsed.parts.isEmpty) {
-      parsed.parts[parsed.parts.length - 1] = parsed.basenameWithoutExtension;
+    for (var i = parsed.parts.length - 1; i >= 0; i--) {

[Bob Nystrom, 2012/12/20 02:27:28]

This is pretty hairy. One option would to have _ParsedPath have a separate field
for the trailing slashes (if any) instead of having a bunch of empty parts.
Parsing gets a bit more complicated, but it localizes that complexity there.

Thoughts?

[nweiz, 2012/12/20 20:54:49]

It's not just trailing slashes that cause empty components; any path with
multiple slashes anywhere will have empty components. Leaving the trailing
slashes as empty components at least makes the handling uniform between those
two cases.

[Bob Nystrom, 2012/12/20 21:32:57]

Ah, right.

+      if (!parsed.parts[i].isEmpty) {
+        parsed.parts[i] = parsed.basenameWithoutExtension;
+        break;
+      }
     }
 
     return parsed.toString();
   }
 
   _ParsedPath _parse(String path) {
     var before = path;
 
     // Remove the root prefix, if any.
     var root = style.getRoot(path);
@@ skipping 81 matching lines @@
   /// directories.
   List<String> parts;
 
   /// The path separators following each part. The last one will be an empty
   /// string unless the path ends with a trailing separator.
   List<String> separators;
 
   /// The file extension of the last part, or "" if it doesn't have one.
   String get extension => _splitExtension()[1];
 
-  /// `true` if the path ends with a trailing separator.
-  bool get hasTrailingSeparator {
-    if (separators.length == 0) return false;
-    return separators[separators.length - 1] != '';
-  }
-
   /// `true` if this is an absolute path.
   bool get isAbsolute => root != null;
 
   _ParsedPath(this.style, this.root, this.parts, this.separators);
 
   String get basename {
-    if (parts.length == 0) return extension;
-    if (hasTrailingSeparator) return '';
-    return parts.last;
+    var copy = this.copy();
+    copy.removeTrailingSeparators();
+    if (copy.parts.isEmpty) return root == null ? '' : root;
+    return copy.parts.last;
   }
 
-  String get basenameWithoutExtension => _splitExtension()[0];
+  String get basenameWithoutExtension {
+    var copy = this.copy();
+    copy.removeTrailingSeparators();
+    if (copy.parts.isEmpty) return root == null ? '' : root;
+    return copy._splitExtension()[0];
+  }
 
-  void removeTrailingSeparator() {
-    if (separators.length > 0) {
-      separators[separators.length - 1] = '';
+  void removeTrailingSeparators() {
+    while (!parts.isEmpty && parts.last == '') {
+      parts.removeLast();
+      separators.removeLast();
     }
+    if (separators.length > 0) separators[separators.length - 1] = '';
   }
 
   void normalize() {
     // Handle '.', '..', and empty parts.
     var leadingDoubles = 0;
     var newParts = [];
     for (var part in parts) {
       if (part == '.' || part == '') {
         // Do nothing. Ignore it.
       } else if (part == '..') {
@@ skipping 19 matching lines @@
       newParts.add('.');
     }
 
     // Canonicalize separators.
     var newSeparators = [];
     newSeparators.insertRange(0, newParts.length, style.separator);
 
     parts = newParts;
     separators = newSeparators;
 
-    removeTrailingSeparator();
+    removeTrailingSeparators();
   }
 
   String toString() {
     var builder = new StringBuffer();
     if (root != null) builder.add(root);
     for (var i = 0; i < parts.length; i++) {
       builder.add(parts[i]);
       builder.add(separators[i]);
     }
 
     return builder.toString();
   }
 
   /// Splits the last part of the path into a two-element list. The first is
   /// the name of the file without any extension. The second is the extension
   /// or "" if it has none.
   List<String> _splitExtension() {
     if (parts.isEmpty) return ['', ''];
-    if (hasTrailingSeparator) return ['', ''];
 
     var file = parts.last;
     if (file == '..') return ['..', ''];
 
     var lastDot = file.lastIndexOf('.');
 
     // If there is no dot, or it's the first character, like '.bashrc', it
     // doesn't count.
     if (lastDot <= 0) return [file, ''];
 
     return [file.substring(0, lastDot), file.substring(lastDot)];
   }
+
+  _ParsedPath copy() => new _ParsedPath(

[Bob Nystrom, 2012/12/20 02:27:28]

Nit, but I would prefer "clone" for this.

[nweiz, 2012/12/20 20:54:49]

Done.

+      style, root, new List.from(parts), new List.from(separators));
 }