For git dependencies attempt to run git lfs pull to fetch binaries, if any.

lib/src/source/git.dart

@@ -350,10 +350,13 @@ class BoundGitSource extends CachedSource {
       var revisionCachePath = _revisionCachePath(id);
       await _revisionCacheClones.putIfAbsent(revisionCachePath, () async {
         if (!entryExists(revisionCachePath)) {
-          await _clone(_repoCachePath(ref), revisionCachePath);
+          await _clone(ref.description['url'], revisionCachePath,
+              reference: _repoCachePath(ref));
           await _checkOut(revisionCachePath, id.description['resolved-ref']);
+          await _pullLFS(revisionCachePath);
           _writePackageList(revisionCachePath, [id.description['path']]);
         } else {
+          await _pullLFS(revisionCachePath);
           _updatePackageList(revisionCachePath, id.description['path']);
         }
       });
@@ -584,24 +587,26 @@ class BoundGitSource extends CachedSource {
   ///
   /// If [shallow] is true, creates a shallow clone that contains no history
   /// for the repository.
-  Future _clone(
-    String from,
-    String to, {
-    bool mirror = false,
-    bool shallow = false,
-  }) {
+  ///
+  /// If [reference] is not null, we expect [from] to be a remote repository
+  ///  and [reference] to be the URI of a local filesystem repository.
+  /// This allows our clone to save network and filesystem resources while
+  /// still allowing Git LFS to fetch any binary files from the remote.
+  Future _clone(String from, String to,
+      {bool mirror = false, bool shallow = false, String reference}) {
     return Future.sync(() {
       // Git on Windows does not seem to automatically create the destination
       // directory.
       ensureDir(to);
+
       var args = [
         'clone',
+        if (reference != null) ['--reference', reference];
         if (mirror) '--mirror',
         if (shallow) ...['--depth', '1'],
         from,
-        to
+        to,
       ];
-
       return git.run(args);
     }).then((result) => null);
   }
@@ -612,6 +617,31 @@ class BoundGitSource extends CachedSource {
         .run(['checkout', ref], workingDir: repoPath).then((result) => null);
   }
 
+  /// Checks out any LFS binaries at the current ref to [repoPath].
+  /// Ignore errors if `git lfs` is not installed.
+  Future<void> _pullLFS(String repoPath) async {
+    var attributesPath = '$repoPath/.gitattributes';
+    // if there is no attributes file there won't be any LFS binaries
+    if (!fileExists(attributesPath)) return;
+    if (!readTextFile(attributesPath).toLowerCase().contains('=lfs')) return;
+
+    try {
+      // to avoid silent failure let's initialize git lfs hooks in the
+      // cloned repository in case the user has not globally ran `git lfs install`
+      await git.run(['lfs', 'install', '--local'], workingDir: repoPath);
+    } on git.GitException catch (e) {
+      if (e.message.contains('not a git command')) {
+        log.error('git lfs not found');
+        return;
+      } else {
+        rethrow;
+      }
+    }
+
+    return git
+        .run(['lfs', 'pull'], workingDir: repoPath).then((result) => null);
+  }
+
   String _revisionCachePath(PackageId id) => p.join(
       systemCacheRoot, "${_repoName(id)}-${id.description['resolved-ref']}");
 

test/get/git/git_lfs_test.dart

@@ -0,0 +1,153 @@
+// 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';
+
+@TestOn('linux')
+import 'package:test/test.dart';
+import 'package:test_descriptor/test_descriptor.dart' show sandbox;
+import 'package:path/path.dart' as p;
+import 'package:pub/src/exit_codes.dart' as exit_codes;
+import 'package:pub/src/io.dart' show runProcess;
+
+import '../../descriptor.dart' as d;
+import '../../test_pub.dart';
+
+const pubspec = 'name: foo\r\ndescription: test\r\nversion: 3.0.0';
+const gitattributes = 'foo.dylib filter=lfs diff=lfs merge=lfs -text';
+
+String fakeGit(hash, lfs) {
+  return '''
+#!/bin/bash -e
+case \$@ in
+  --version)
+    echo 'git version 2.16'
+    ;;
+  rev-list*)
+    echo '$hash'
+    ;;
+  show*)
+    echo '$pubspec'
+    ;;
+  checkout*)
+    mkdir -p $sandbox/cache/git/foo-$hash/.git
+    echo '$pubspec' > $sandbox/cache/git/foo-$hash/pubspec.yaml
+    echo '$gitattributes' > $sandbox/cache/git/foo-$hash/.gitattributes
+    ;;
+  $lfs
+esac
+''';
+}
+
+void main() {
+  test('reports failure if Git LFS is needed but is not installed', () async {
+    ensureGit();
+
+    final repo = d.git('foo.git', [
+      d.libDir('foo'),
+      d.file('pubspec.yaml', pubspec),
+      d.file('.gitattributes', gitattributes)
+    ]);
+
+    await repo.create();
+    final ref = await repo.runGit(['rev-list', '--max-count=1', 'HEAD']);
+    final hash = ref.first;
+
+    await d.appDir({
+      'foo': {
+        'git': {'url': '../foo.git'}
+      }
+    }).create();
+
+    const lfs = '''
+  lfs*)
+    echo "git: 'lfs' is not a git command. See 'git --help'."
+    exit 1
+    ;;
+  ''';
+
+    await d.dir('bin', [d.file('git', fakeGit(hash, lfs))]).create();
+    final binFolder = p.join(sandbox, 'bin');
+    // chmod the git script
+    if (!Platform.isWindows) {
+      await runProcess('chmod', ['+x', p.join(sandbox, 'bin', 'git')]);
+    }
+
+    final separator = Platform.isWindows ? ';' : ':';
+
+    await runPub(
+        args: ['get'],
+        error: contains('git lfs not found'),
+        environment: {
+          // Override 'PATH' to ensure that we are using our fake git executable
+          'PATH': '$binFolder$separator${Platform.environment['PATH']}'
+        });
+  });
+
+  test('reports success if Git proceeds as usual due to no .gitattributes',
+      () async {
+    ensureGit();
+
+    await d.git('foo.git', [
+      d.libDir('foo'),
+      d.libPubspec('foo', '3.0.0'),
+    ]).create();
+
+    await d.appDir({
+      'foo': {
+        'git': {'url': '../foo.git'}
+      }
+    }).create();
+
+    await runPub(args: ['get'], output: contains('Changed 1 dependency!'));
+  });
+
+  test('if Git LFS is installed then `git lfs pull` is executed', () async {
+    ensureGit();
+
+    final repo = d.git('foo.git', [
+      d.libDir('foo'),
+      d.file('pubspec.yaml', pubspec),
+      d.file('.gitattributes', gitattributes)
+    ]);
+
+    await repo.create();
+    final ref = await repo.runGit(['rev-list', '--max-count=1', 'HEAD']);
+    final hash = ref.first;
+
+    await d.appDir({
+      'foo': {
+        'git': {'url': '../foo.git'}
+      }
+    }).create();
+
+    const lfs = '''
+  'lfs install'*)
+    echo 'git lfs install'
+    ;;
+  'lfs pull')
+    echo 'git lfs pull was reached'
+    exit 1
+    ;;
+  ''';
+
+    await d.dir('bin', [d.file('git', fakeGit(hash, lfs))]).create();
+    final binFolder = p.join(sandbox, 'bin');
+    // chmod the git script
+    if (!Platform.isWindows) {
+      await runProcess('chmod', ['+x', p.join(sandbox, 'bin', 'git')]);
+    }
+
+    final separator = Platform.isWindows ? ';' : ':';
+
+    await runPub(
+        args: ['get'],
+        error: contains('git lfs pull was reached'),
+        environment: {
+          // Override 'PATH' to ensure that we are using our fake git executable
+          'PATH': '$binFolder$separator${Platform.environment['PATH']}'
+        },
+        exitCode: exit_codes.UNAVAILABLE);
+  });
+}