Restrict the set of files that will be pub lished.

utils/pub/command_lish.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.
 
 library command_lish;
 
 import 'dart:io';
 import 'dart:json';
 import 'dart:uri';
 
@@ skipping 95 matching lines @@
       }
 
       if (e is! oauth2.ExpirationException) throw e;
 
       printError("Pub's authorization to upload packages has expired and can't "
           "be automatically refreshed.");
       return onRun();
     });
   }
 
+  /// The basenames of files that are automatically excluded from archives.
+  final _BLACKLISTED_FILES = const ['pubspec.lock'];
+
+  /// The basenames of directories that are automatically excluded from
+  /// archives.
+  final _BLACKLISTED_DIRECTORIES = const ['packages'];
+
   /// Returns a list of files that should be included in the published package.
   /// If this is a Git repository, this will respect .gitignore; otherwise, it
   /// will return all non-hidden files.
   Future<List<String>> get _filesToPublish {
     var rootDir = entrypoint.root.dir;
     return Futures.wait([
       dirExists(join(rootDir, '.git')),
       git.isInstalled
     ]).chain((results) {
       if (results[0] && results[1]) {
         // List all files that aren't gitignored, including those not checked in
         // to Git.
         return git.run(["ls-files", "--cached", "--others"]);
       }
 
       return listDir(rootDir, recursive: true).chain((entries) {
         return Futures.wait(entries.map((entry) {
           return fileExists(entry).transform((isFile) => isFile ? entry : null);
         }));
       });
     }).transform((files) => files.filter((file) {
-      return file != null && basename(file) != 'packages';
+      if (file == null || _BLACKLISTED_FILES.contains(basename(file))) {
+        return false;
+      }
+      return !splitPath(file).some(_BLACKLISTED_DIRECTORIES.contains);
     }));
   }
 
   /// Parses a response body, assuming it's JSON-formatted. Throws a
   /// user-friendly error if the response body is invalid JSON, or if it's not a
   /// map.
   Map _parseJson(http.Response response) {
     var value;
     try {
       value = JSON.parse(response.body);
@@ skipping 10 matching lines @@
   _expectField(Map map, String key, http.Response response) {
     if (map.containsKey(key)) return map[key];
     _invalidServerResponse(response);
   }
 
   /// Throws an error describing an invalid response from the server.
   void _invalidServerResponse(http.Response response) {
     throw 'Invalid server response:\n${response.body}';
   }
 }