Restrict the set of files that will be pub lished.

utils/pub/io.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.
 
 /**
  * Helper functionality to make working with IO easier.
  */
 library io;
 
 import 'dart:io';
@@ skipping 44 matching lines @@
           parts.removeLast();
         }
         parts.add(piece);
       }
     }
   }
 
   return Strings.join(parts, Platform.pathSeparator);
 }
 
+List<String> splitPath(path) => _sanitizePath(path).split('/');

[Bob Nystrom, 2012/11/30 21:31:59]

Doc comment.

[nweiz, 2012/11/30 21:37:45]

Done.

+
 /**
  * Gets the basename, the file name without any leading directory path, for
  * [file], which can either be a [String], [File], or [Directory].
  */
 // TODO(rnystrom): Copied from file_system (so that we don't have to add
 // file_system to the SDK). Should unify.
 String basename(file) {
   file = _sanitizePath(file);
 
   int lastSlash = file.lastIndexOf('/', file.length);
@@ skipping 163 matching lines @@
  * [Directory]. Returns a [Future] that completes when the deletion is done.
  */
 Future<Directory> deleteDir(dir) {
   dir = _getDirectory(dir);
   return dir.delete(recursive: true);
 }
 
 /**
  * Asynchronously lists the contents of [dir], which can be a [String] directory
  * path or a [Directory]. If [recursive] is `true`, lists subdirectory contents
- * (defaults to `false`). If [includeHiddenFiles] is `true`, includes files
- * beginning with `.` (defaults to `false`).
+ * (defaults to `false`). If [includeHiddenFiles] is `true`, includes files and
+ * directories beginning with `.` (defaults to `false`).
  */
 Future<List<String>> listDir(dir,
     {bool recursive: false, bool includeHiddenFiles: false}) {
   final completer = new Completer<List<String>>();
   final contents = <String>[];
 
   dir = _getDirectory(dir);
   var lister = dir.list(recursive: recursive);
 
   lister.onDone = (done) {
     // TODO(rnystrom): May need to sort here if it turns out onDir and onFile
     // aren't guaranteed to be called in a certain order. So far, they seem to.
     if (done) completer.complete(contents);
   };
 
   // TODO(nweiz): remove this when issue 4061 is fixed.
   var stackTrace;
   try {
     throw "";
   } catch (_, localStackTrace) {
     stackTrace = localStackTrace;
   }
 
   lister.onError = (error) => completer.completeException(error, stackTrace);
-  lister.onDir = (file) => contents.add(file);
+  lister.onDir = (file) {
+    if (!includeHiddenFiles && basename(file).startsWith('.')) return;
+    contents.add(file);
+  };
   lister.onFile = (file) {
     if (!includeHiddenFiles && basename(file).startsWith('.')) return;
     contents.add(file);
   };
 
   return completer.future;
 }
 
 /**
  * Asynchronously determines if [dir], which can be a [String] directory path
@@ skipping 80 matching lines @@
     return new Future.immediate(to);
   });
 }
 
 /// Given [entry] which may be a [String], [File], or [Directory] relative to
 /// the current working directory, returns its full canonicalized path.
 String getFullPath(entry) {
   var path = _getPath(entry);
 
   // Don't do anything if it's already absolute.
-  if (Platform.operatingSystem == 'windows') {
-    // An absolute path on Windows is either UNC (two leading backslashes),
-    // or a drive letter followed by a colon and a slash.
-    var ABSOLUTE = new RegExp(r'^(\\\\|[a-zA-Z]:[/\\])');
-    if (ABSOLUTE.hasMatch(path)) return path;
-  } else {
-    if (path.startsWith('/')) return path;
-  }
+  if (isAbsolute(path)) return path;
 
   // Using Path.join here instead of File().fullPathSync() because the former
   // does not require an actual file to exist at that path.
   return new Path.fromNative(currentWorkingDir).join(new Path(path))
       .toNativePath();
 }
 
+bool isAbsolute(entry) => _splitAbsolute(entry).first != null;
+
+Pair<String, String> _splitAbsolute(entry) {
+  var path = _getPath(entry);
+
+  if (Platform.operatingSystem != 'windows') {
+    return !path.startsWith('/') ? new Pair(null, path)
+        : new Pair('/', path.substring(1));
+  }
+
+  // An absolute path on Windows is either UNC (two leading backslashes),
+  // or a drive letter followed by a colon and a slash.
+  var match = new RegExp(r'^(\\\\|[a-zA-Z]:[/\\])').firstMatch(path);
+  return match == null ? new Pair(null, path)
+      : new Pair(match.group(0), path.substring(match.end));
+}
+
 /// Resolves [path] relative to the location of pub.dart.
 String relativeToPub(String path) {
   var scriptPath = new File(new Options().script).fullPathSync();
 
   // Walk up until we hit the "util(s)" directory. This lets us figure out where
   // we are if this function is called from pub.dart, or one of the tests,
   // which also live under "utils", or from the SDK where pub is in "util".
   var utilDir = new Path.fromNative(scriptPath).directoryPath;
   while (utilDir.filename != 'utils' && utilDir.filename != 'util') {
     if (utilDir.filename == '') throw 'Could not find path to pub.';
@@ skipping 543 matching lines @@
   if (entry is String) return entry;
   if (entry is File) return entry.name;
   if (entry is Directory) return entry.path;
   throw 'Entry $entry is not a supported type.';
 }
 
 /// Gets the path string for [entry] as in [_getPath], but normalizes
 /// backslashes to forward slashes on Windows.
 String _sanitizePath(entry) {
   entry = _getPath(entry);
-  if (Platform.operatingSystem == 'windows') {
-    entry = entry.replaceAll('\\', '/');
-  }
-  return entry;
+  if (Platform.operatingSystem != 'windows') return entry;
+
+  var split = _splitAbsolute(entry);
+  if (split.first == null) return split.last.replaceAll('\\', '/');
+
+  // For absolute Windows paths, we don't want the prefix (either "\\" or e.g.
+  // "C:\") to look like a normal path component, so we ensure that it only
+  // contains backslashes.
+  return '${split.first.replaceAll('/', '\\')}'
+         '${split.last.replaceAll('\\', '/')}';
 }
 
 /**
  * Gets a [Directory] for [entry], which can either already be one, or be a
  * [String].
  */
 Directory _getDirectory(entry) {
   if (entry is Directory) return entry;
   return new Directory(entry);
 }
 
 /**
  * Gets a [Uri] for [uri], which can either already be one, or be a [String].
  */
 Uri _getUri(uri) {
   if (uri is Uri) return uri;
   return new Uri.fromString(uri);
 }