Merge pull request git-lfs#3296 from bk2204/checkout-conflict

Checkout options for conflicts

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()                    {}
 

docs/man/git-lfs-checkout.1.ronn

@@ -4,14 +4,13 @@ git-lfs-checkout(1) -- Update working copy with file content if available
 ## SYNOPSIS
 
 `git lfs checkout` <filespec>...
+`git lfs checkout` --to <path> { --ours | --theirs | --base } <file>...
 
 ## DESCRIPTION
 
-This command is deprecated, and should be replaced with `git checkout`.
-
 Try to ensure that the working copy contains file content for Git LFS objects
 for the current ref, if the object data is available. Does not download any
-content, see git-lfs-fetch(1) for that. 
+content, see git-lfs-fetch(1) for that.
 
 Checkout scans the current ref for all LFS objects that would be required, then
 where a file is either missing in the working copy, or contains placeholder
@@ -20,6 +19,28 @@ we have it in the local store. Modified files are never overwritten.
 
 Filespecs can be provided as arguments to restrict the files which are updated.
 
+When used with `--to` and the working tree is in a conflicted state due to a
+merge, this option checks out one of the three stages of the conflict into a
+separate file. This can make using diff tools to inspect and resolve merges
+easier.
+
+## OPTIONS
+
+* `--base`:
+  Check out the merge base of the specified file.
+
+* `--ours`:
+  Check out our side (that of the current branch) of the conflict for the
+  specified file.
+
+* `--theirs`:
+  Check out their side (that of the other branch) of the conflict for the
+  specified file.
+
+* `--to` <path>:
+  If the working tree is in a conflicted state, check out the portion of the
+  conflict specified by `--base`, `--ours`, or `--theirs` to the given path.
+
 ## EXAMPLES
 
 * Checkout all files that are missing or placeholders

git/git.go

@@ -38,6 +38,15 @@ const (
 	RefBeforeFirstCommit = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
 )
 
+type IndexStage int
+
+const (
+	IndexStageDefault IndexStage = iota
+	IndexStageBase
+	IndexStageOurs
+	IndexStageTheirs
+)
+
 // Prefix returns the given RefType's prefix, "refs/heads", "ref/remotes",
 // etc. It returns an additional value of either true/false, whether or not this
 // given ref type has a prefix.

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