Handle relative paths where the trailing directory has an extension.

utils/pub/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 316 matching lines @@
     pathParsed.removeTrailingSeparator();
 
     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);
-    parsed.extension = null;
+    if (parsed.hasTrailingSeparator) return parsed.toString();
+
+    if (!parsed.parts.isEmpty) {
+      parsed.parts[parsed.parts.length - 1] = parsed.basenameWithoutExtension;
+    }
+
     return parsed.toString();
   }
 
   _ParsedPath _parse(String path) {
     var before = path;
 
     // Remove the root prefix, if any.
     var root = style.getRoot(path);
     if (root != null) path = path.substring(root.length);
 
     // Split the parts on path separators.
     var parts = [];
     var separators = [];
     var start = 0;
     for (var match in style.separatorPattern.allMatches(path)) {
       parts.add(path.substring(start, match.start));
       separators.add(match[0]);
       start = match.end;
     }
 
     // Add the final part, if any.
     if (start < path.length) {
       parts.add(path.substring(start));
       separators.add('');
     }
 
-    // Separate out the file extension.
-    var extension = '';
-    if (parts.length > 0) {
-      var file = parts.last;
-      if (file != '..') {
-        var lastDot = file.lastIndexOf('.');
-
-        // If there is a dot (and it's not the first character, like '.bashrc').
-        if (lastDot > 0) {
-          parts[parts.length - 1] = file.substring(0, lastDot);
-          extension = file.substring(lastDot);
-        }
-      }
-    }
-
-    return new _ParsedPath(style, root, parts, separators, extension);
+    return new _ParsedPath(style, root, parts, separators);
   }
 }
 
 /// An enum type describing a "flavor" of path.
 class Style {
   /// POSIX-style paths use "/" (forward slash) as separators. Absolute paths
   /// start with "/". Used by UNIX, Linux, Mac OS X, and others.
   static final posix = new Style._('posix', '/', '/', '/');
 
   /// Windows paths use "\" (backslash) as separators. Absolute paths start with
@@ skipping 41 matching lines @@
   /// The [Style] that was used to parse this path.
   Style style;
 
   /// The absolute root portion of the path, or `null` if the path is relative.
   /// On POSIX systems, this will be `null` or "/". On Windows, it can be
   /// `null`, "//" for a UNC path, or something like "C:\" for paths with drive
   /// letters.
   String root;
 
   /// The path-separated parts of the path. All but the last will be
-  /// directories. The last could be a directory, or could be the file name
-  /// without its extension.
+  /// 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's extension, or "" if it doesn't have one.
-  String extension;
+  /// 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,
-              this.extension);
+  _ParsedPath(this.style, this.root, this.parts, this.separators);
 
   String get basename {
     if (parts.length == 0) return extension;
     if (hasTrailingSeparator) return '';
-    return '${parts.last}$extension';
+    return parts.last;
   }
 
-  String get basenameWithoutExtension {
-    if (parts.length == 0) return '';
-    if (hasTrailingSeparator) return '';
-    return parts.last;
-  }
+  String get basenameWithoutExtension => _splitExtension()[0];
 
   void removeTrailingSeparator() {
     if (separators.length > 0) {
       separators[separators.length - 1] = '';
     }
   }
 
   void normalize() {
     // Handle '.', '..', and empty parts.
     var leadingDoubles = 0;
@@ skipping 32 matching lines @@
     separators = newSeparators;
 
     removeTrailingSeparator();
   }
 
   String toString() {
     var builder = new StringBuffer();
     if (root != null) builder.add(root);
     for (var i = 0; i < parts.length; i++) {
       builder.add(parts[i]);
-      if (extension != null && i == parts.length - 1) builder.add(extension);
       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)];
+  }
 }