Respect gitignore for packages in subdirectories.

lib/src/package.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 pub.package;
 
 import 'dart:io';
 
 import 'package:barback/barback.dart';
 import 'package:path/path.dart' as p;
@@ skipping 90 matching lines @@
 
     return p.join(dir, readmes.reduce((readme1, readme2) {
       var extensions1 = ".".allMatches(readme1).length;
       var extensions2 = ".".allMatches(readme2).length;
       var comparison = extensions1.compareTo(extensions2);
       if (comparison == 0) comparison = readme1.compareTo(readme2);
       return (comparison <= 0) ? readme1 : readme2;
     }));
   }
 
+  /// Returns whether or not this package is in a Git repo.
+  bool get _inGitRepo {
+    if (_inGitRepoCache != null) return _inGitRepoCache;
+
+    if (dir == null || !git.isInstalled) {
+      _inGitRepoCache = false;
+    } else {
+      try {
+        git.runSync(['rev-parse'], workingDir: dir);
+        _inGitRepoCache = true;
+      } on git.GitException catch (_) {
+        _inGitRepoCache = false;
+      }
+    }
+
+    return _inGitRepoCache;
+  }
+  bool _inGitRepoCache;
+
   /// Loads the package whose root directory is [packageDir].
   ///
   /// [name] is the expected name of that package (e.g. the name given in the
   /// dependency), or `null` if the package being loaded is the entrypoint
   /// package.
   Package.load(String name, String packageDir, SourceRegistry sources)
       : dir = packageDir,
         pubspec = new Pubspec.load(packageDir, sources, expectedName: name);
 
   /// Constructs a package with the given pubspec.
@@ skipping 56 matching lines @@
   ///
   /// If this is a Git repository, this will respect .gitignore; otherwise, it
   /// will return all non-hidden, non-blacklisted files.
   ///
   /// If [beneath] is passed, this will only return files beneath that path,
   /// which is expected to be relative to the package's root directory. If
   /// [recursive] is true, this will return all files beneath that path;
   /// otherwise, it will only return files one level beneath it.
   ///
   /// If [useGitIgnore] is passed, this will take the .gitignore rules into
   /// account if the package's root directory is a Git repository.

[kustermann, 2015/08/26 12:55:52]

dbc: This sentence is no longer correct. It also looks into the parent directory
chain.

[nweiz, 2015/08/26 22:58:07]

Done in https://codereview.chromium.org/1310253007

   ///
   /// Note that the returned paths won't always be beneath [dir]. To safely
   /// convert them to paths relative to the package root, use [relative].
   List<String> listFiles({String beneath, bool recursive: true,
       bool useGitIgnore: false}) {
     // An in-memory package has no files.
     if (dir == null) return [];
 
     if (beneath == null) {
       beneath = dir;
     } else {
       beneath = p.join(dir, beneath);
     }
 
     if (!dirExists(beneath)) return [];
 
     // This is used in some performance-sensitive paths and can list many, many
     // files. As such, it leans more havily towards optimization as opposed to
     // readability than most code in pub. In particular, it avoids using the
     // path package, since re-parsing a path is very expensive relative to
     // string operations.
     var files;
-    if (useGitIgnore && git.isInstalled && dirExists(path('.git'))) {
+    if (useGitIgnore && _inGitRepo) {
       // Later versions of git do not allow a path for ls-files that appears to
       // be outside of the repo, so make sure we give it a relative path.
       var relativeBeneath = p.relative(beneath, from: dir);
 
       // List all files that aren't gitignored, including those not checked in
       // to Git.
       files = git.runSync(
           ["ls-files", "--cached", "--others", "--exclude-standard",
            relativeBeneath],
           workingDir: dir);
@@ skipping 195 matching lines @@
 
   bool operator ==(other) {
     // TODO(rnystrom): We're assuming here that we don't need to delve into the
     // description.
     return other is PackageDep &&
            other.name == name &&
            other.source == source &&
            other.constraint == constraint;
   }
 }