Fix delay with flicking through files or commits when git diff is very slow

One reason why git diff can be very slow is when "diff.algorithm = histogram" is
being used. In this case, showing a very long single-file diff can take seconds
to load, and you'll see the "loading..." message in the main view until we got
the first lines of the diff to show. There's nothing really we can do about this
delay; however, when switching to another, shorter file (or commit) while the
"loading..." message is still showing, this switch should be instantaneous. And
it was before 0.54.0, but we broke this in 0.54.0 with 8d7740a (#4782); now
users have to wait for the slow git diff command to output more text before the
switch occurs. Fix this by sending the git process a TERM signal.

Unfortunately, this signal is not supported on Windows, so Windows users will
still have to live with the delay for now. The recommended workaround is to not
use "diff.algorithm = histogram".

Author: stefanhaller

pkg/commands/oscommands/os_default_platform.go

@@ -5,8 +5,10 @@ package oscommands
 
 import (
 	"os"
+	"os/exec"
 	"runtime"
 	"strings"
+	"syscall"
 )
 
 func GetPlatform() *Platform {
@@ -38,3 +40,11 @@ func getUserShell() string {
 func (c *OSCommand) UpdateWindowTitle() error {
 	return nil
 }
+
+func TerminateProcessGracefully(cmd *exec.Cmd) error {
+	if cmd.Process == nil {
+		return nil
+	}
+
+	return cmd.Process.Signal(syscall.SIGTERM)
+}

pkg/commands/oscommands/os_windows.go

@@ -3,6 +3,7 @@ package oscommands
 import (
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
 )
 
@@ -22,3 +23,8 @@ func (c *OSCommand) UpdateWindowTitle() error {
 	argString := fmt.Sprint("title ", filepath.Base(path), " - Lazygit")
 	return c.Cmd.NewShell(argString, c.UserConfig().OS.ShellFunctionsFile).Run()
 }
+
+func TerminateProcessGracefully(cmd *exec.Cmd) error {
+	// Signals other than SIGKILL are not supported on Windows
+	return nil
+}

pkg/tasks/tasks.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 	"github.com/sasha-s/go-deadlock"
 	"github.com/sirupsen/logrus"
@@ -165,7 +166,22 @@ func (self *ViewBufferManager) NewCmdTask(start func() (*exec.Cmd, io.Reader), p
 				// and the user is flicking through a bunch of items.
 				self.throttle = time.Since(startTime) < THROTTLE_TIME && timeToStart > COMMAND_START_THRESHOLD
 
-				// close the task's stdout pipe (or the pty if we're using one) to make the command terminate
+				// Kill the still-running command. We only need to do this for the case that the git
+				// command is not yet done producing the initial part of the output; this can happen
+				// for very long diffs when diff.algorithm = histogram is being used. In this case,
+				// closing the output pipe will cause the git command to terminate only the next
+				// time it tries to output something, which might still take a while. But we want to
+				// kill it immediately, so that we can show the next thing the user selected without
+				// delay.
+				//
+				// Unfortunately this will do nothing on Windows, so we'll have to live with the
+				// delay there.
+				if err := oscommands.TerminateProcessGracefully(cmd); err != nil {
+					self.Log.Errorf("error when trying to terminate cmd task: %v; Command: %v %v", err, cmd.Path, cmd.Args)
+				}
+
+				// close the task's stdout pipe (or the pty if we're using one) to make the command
+				// terminate on Windows, and so that the Wait call below doesn't block.
 				onDone()
 			}
 		})