commands: add flags to get conflicted contents

When there's a conflict with a file in Git LFS, it's difficult to get
the LFS contents of the conflicted files so that they can be run through
an appropriate diff tool.  To make this easier, teach git lfs checkout
the --base, --theirs, and --ours flags to check out the base, theirs,
and ours outputs to a given path (specified with --to).

Be sure not to print a deprecation message in this case, since this is
not a deprecated use.

Note that we use three different variables for the base, theirs, and
ours flags because Cobra doesn't offer a command mode option that can
parse all of the flags into one variable.

Author: bk2204

commands/command_checkout.go

@@ -13,9 +13,28 @@ import (
 	"github.com/spf13/cobra"
 )
 
+var (
+	checkoutTo     string
+	checkoutBase   bool
+	checkoutOurs   bool
+	checkoutTheirs bool
+)
+
 func checkoutCommand(cmd *cobra.Command, args []string) {
 	requireInRepo()
 
+	stage, err := whichCheckout()
+	if err != nil {
+		Exit("Error parsing args: %v", err)
+	}
+
+	if checkoutTo != "" && stage != git.IndexStageDefault {
+		checkoutConflict(rootedPaths(args)[0], stage)
+		return
+	} else if checkoutTo != "" || stage != git.IndexStageDefault {
+		Exit("--to and exactly one of --theirs, --ours, and --base must be used together")
+	}
+
 	msg := []string{
 		"WARNING: 'git lfs checkout' is deprecated and will be removed in v3.0.0.",
 
@@ -75,6 +94,63 @@ func checkoutCommand(cmd *cobra.Command, args []string) {
 	singleCheckout.Close()
 }
 
+func checkoutConflict(file string, stage git.IndexStage) {
+	singleCheckout := newSingleCheckout(cfg.Git, "")
+	if singleCheckout.Skip() {
+		fmt.Println("Cannot checkout LFS objects, Git LFS is not installed.")
+		return
+	}
+
+	ref, err := git.ResolveRef(fmt.Sprintf(":%d:%s", stage, file))
+	if err != nil {
+		Exit("Could not checkout (are you not in the middle of a merge?): %v", err)
+	}
+
+	scanner, err := git.NewObjectScanner()
+	if err != nil {
+		Exit("Could not create object scanner: %v", err)
+	}
+
+	if !scanner.Scan(ref.Sha) {
+		Exit("Could not find object %q", ref.Sha)
+	}
+
+	ptr, err := lfs.DecodePointer(scanner.Contents())
+	if err != nil {
+		Exit("Could not find decoder pointer for object %q: %v", ref.Sha, err)
+	}
+
+	p := &lfs.WrappedPointer{Name: file, Pointer: ptr}
+
+	if err := singleCheckout.RunToPath(p, checkoutTo); err != nil {
+		Exit("Error checking out %v to %q: %v", ref.Sha, checkoutTo, err)
+	}
+	singleCheckout.Close()
+}
+
+func whichCheckout() (stage git.IndexStage, err error) {
+	seen := 0
+	stage = git.IndexStageDefault
+
+	if checkoutBase {
+		seen++
+		stage = git.IndexStageBase
+	}
+	if checkoutOurs {
+		seen++
+		stage = git.IndexStageOurs
+	}
+	if checkoutTheirs {
+		seen++
+		stage = git.IndexStageTheirs
+	}
+
+	if seen > 1 {
+		return 0, fmt.Errorf("At most one of --base, --theirs, and --ours is allowed")
+	}
+	return stage, nil
+}
+
 // Parameters are filters
 // firstly convert any pathspecs to the root of the repo, in case this is being
 // executed in a sub-folder
@@ -92,5 +168,10 @@ func rootedPaths(args []string) []string {
 }
 
 func init() {
-	RegisterCommand("checkout", checkoutCommand, nil)
+	RegisterCommand("checkout", checkoutCommand, func(cmd *cobra.Command) {
+		cmd.Flags().StringVar(&checkoutTo, "to", "", "Checkout a conflicted file to this path")
+		cmd.Flags().BoolVar(&checkoutOurs, "ours", false, "Checkout our version of a conflicted file")
+		cmd.Flags().BoolVar(&checkoutTheirs, "theirs", false, "Checkout their version of a conflicted file")
+		cmd.Flags().BoolVar(&checkoutBase, "base", false, "Checkout the base version of a conflicted file")
+	})
 }

commands/pull.go

@@ -43,6 +43,7 @@ type abstractCheckout interface {
 	Manifest() *tq.Manifest
 	Skip() bool
 	Run(*lfs.WrappedPointer)
+	RunToPath(*lfs.WrappedPointer, string) error
 	Close()
 }
 
@@ -81,9 +82,7 @@ func (c *singleCheckout) Run(p *lfs.WrappedPointer) {
 		return
 	}
 
-	gitfilter := lfs.NewGitFilter(cfg)
-	err = gitfilter.SmudgeToFile(cwdfilepath, p.Pointer, false, c.manifest, nil)
-	if err != nil {
+	if err := c.RunToPath(p, cwdfilepath); err != nil {
 		if errors.IsDownloadDeclinedError(err) {
 			// acceptable error, data not local (fetch not run or include/exclude)
 			LoggedError(err, "Skipped checkout for %q, content not local. Use fetch to download.", p.Name)
@@ -99,6 +98,13 @@ func (c *singleCheckout) Run(p *lfs.WrappedPointer) {
 	}
 }
 
+// RunToPath checks out the pointer specified by p to the given path.  It does
+// not perform any sort of sanity checking or add the path to the index.
+func (c *singleCheckout) RunToPath(p *lfs.WrappedPointer, path string) error {
+	gitfilter := lfs.NewGitFilter(cfg)
+	return gitfilter.SmudgeToFile(path, p.Pointer, false, c.manifest, nil)
+}
+
 func (c *singleCheckout) Close() {
 	if err := c.gitIndexer.Close(); err != nil {
 		LoggedError(err, "Error updating the git index:\n%s", c.gitIndexer.Output())
@@ -117,6 +123,10 @@ func (c *noOpCheckout) Skip() bool {
 	return true
 }
 
+func (c *noOpCheckout) RunToPath(p *lfs.WrappedPointer, path string) error {
+	return nil
+}
+
 func (c *noOpCheckout) Run(p *lfs.WrappedPointer) {}
 func (c *noOpCheckout) Close()                    {}
 

t/t-checkout.sh

@@ -182,3 +182,43 @@ begin_test "checkout: write-only file"
   popd > /dev/null
 )
 end_test
+
+begin_test "checkout: conflicts"
+(
+  set -e
+
+  reponame="checkout-conflicts"
+  filename="file1.dat"
+
+  setup_remote_repo_with_file "$reponame" "$filename"
+
+  pushd "$TRASHDIR" > /dev/null
+    clone_repo "$reponame" "${reponame}_checkout"
+
+    git tag base
+    git checkout -b first
+    echo "abc123" > file1.dat
+    git add -u
+    git commit -m "first"
+
+    git lfs checkout --to base.txt --base file1.dat 2>&1 | tee output.txt
+    grep 'Could not checkout.*not in the middle of a merge' output.txt
+
+    git checkout -b second master
+    echo "def456" > file1.dat
+    git add -u
+    git commit -m "second"
+
+    # This will cause a conflict.
+    ! git merge first
+
+    git lfs checkout --to base.txt --base file1.dat
+    git lfs checkout --to ours.txt --ours file1.dat
+    git lfs checkout --to theirs.txt --theirs file1.dat
+
+    echo "file1.dat" | cmp - base.txt
+    echo "abc123" | cmp - theirs.txt
+    echo "def456" | cmp - ours.txt
+  popd > /dev/null
+)
+end_test