Resolve symlinks when publishing from Git repos.

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.
 
 import 'dart:io';
 
 import 'package:barback/barback.dart';
 import 'package:path/path.dart' as p;
 import 'package:pub_semver/pub_semver.dart';
 
@@ skipping 234 matching lines @@
             relativeBeneath.length + 1;
         files = files.where((file) => !file.contains('/', relativeStart));
       }
 
       // Git always prints files relative to the repository root, but we want
       // them relative to the working directory. It also prints forward slashes
       // on Windows which we normalize away for easier testing.
       files = files.map((file) {
         if (Platform.operatingSystem != 'windows') return "$dir/$file";
         return "$dir\\${file.replaceAll("/", "\\")}";
-      }).where((file) {
-        // Filter out broken symlinks, since git doesn't do so automatically.
-        return fileExists(file);
+      }).expand((file) {
+        if (fileExists(file)) return [file];
+        if (!dirExists(file)) return [];
+
+        // `git ls-files` only returns files, except in the case of a symlink to
+        // a directory. So if we're here, [file] refers to a valid symlink to a
+        // directory.
+        return recursive ? _listSymlinkedDir(file) : [file];
       });
     } else {
       files = listDir(beneath, recursive: recursive, includeDirs: false,
           whitelist: _WHITELISTED_FILES);
     }
 
     return files.where((file) {
       // Using substring here is generally problematic in cases where dir has
       // one or more trailing slashes. If you do listDir("foo"), you'll get back
       // paths like "foo/bar". If you do listDir("foo/"), you'll get "foo/bar"
       // (note the trailing slash was dropped. If you do listDir("foo//"),
       // you'll get "foo//bar".
       //
       // This means if you strip off the prefix, the resulting string may have a
       // leading separator (if the prefix did not have a trailing one) or it may
       // not. However, since we are only using the results of that to call
       // contains() on, the leading separator is harmless.
       assert(file.startsWith(beneath));
       file = file.substring(beneath.length);
       return !_blacklistedFiles.any(file.endsWith) &&
           !_blacklistedDirs.any(file.contains);
     }).toList();
   }
 
+  /// List all files recursively beneath [link], which should be a symlink to a
+  /// directory.
+  ///
+  /// This is used by [list] when listing a Git repository, since `git ls-files`
+  /// can't natively follow symlinks.
+  Iterable<String> _listSymlinkedDir(String link) {
+    assert(linkExists(link));
+    assert(dirExists(link));
+    assert(p.isWithin(dir, link));
+
+    var target = new Directory(link).resolveSymbolicLinksSync();
+
+    List<String> targetFiles;
+    if (p.isWithin(dir, target)) {
+      // If the link points within this repo, use git to list the target
+      // location so we respect .gitignore.
+      targetFiles = listFiles(
+          beneath: p.relative(target, from: dir),
+          recursive: true,
+          useGitIgnore: true);
+    } else {
+      // If the link points outside this repo, just use the default listing
+      // logic.
+      targetFiles = listDir(target, recursive: true, includeDirs: false,
+          whitelist: _WHITELISTED_FILES);
+    }
+
+    // Re-write the paths so they're underneath the symlink.
+    return targetFiles.map((targetFile) =>
+        p.join(link, p.relative(targetFile, from: target)));
+  }
+
   /// Returns a debug string for the package.
   String toString() => '$name $version ($dir)';
 }
 
 /// This is the private base class of [PackageRef], [PackageID], and
 /// [PackageDep].
 ///
 /// It contains functionality and state that those classes share but is private
 /// so that from outside of this library, there is no type relationship between
 /// those three types.
@@ skipping 157 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;
   }
 }