mirror of
https://github.com/jesseduffield/lazygit.git
synced 2024-12-12 11:15:00 +02:00
14ecc15e71
The global counter approach is easy to understand but it's brittle and depends on implicit behaviour that is not very discoverable. With a global counter, if any goroutine accidentally decrements the counter twice, we'll think lazygit is idle when it's actually busy. Likewise if a goroutine accidentally increments the counter twice we'll think lazygit is busy when it's actually idle. With the new approach we have a map of tasks where each task can either be busy or not. We create a new task and add it to the map when we spawn a worker goroutine (among other things) and we remove it once the task is done. The task can also be paused and continued for situations where we switch back and forth between running a program and asking for user input. In order for this to work with `git push` (and other commands that require credentials) we need to obtain the task from gocui when we create the worker goroutine, and then pass it along to the commands package to pause/continue the task as required. This is MUCH more discoverable than the old approach which just decremented and incremented the global counter from within the commands package, but it's at the cost of expanding some function signatures (arguably a good thing). Likewise, whenever you want to call WithWaitingStatus or WithLoaderPanel the callback will now have access to the task for pausing/ continuing. We only need to actually make use of this functionality in a couple of places so it's a high price to pay, but I don't know if I want to introduce a WithWaitingStatusTask and WithLoaderPanelTask function (open to suggestions).
56 lines
2.0 KiB
Go
56 lines
2.0 KiB
Go
package oscommands
|
|
|
|
import (
|
|
"io"
|
|
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
// this struct captures some IO stuff
|
|
type guiIO struct {
|
|
// this is for logging anything we want. It'll be written to a log file for the sake
|
|
// of debugging.
|
|
log *logrus.Entry
|
|
|
|
// this is for us to log the command we're about to run e.g. 'git push'. The GUI
|
|
// will write this to a log panel so that the user can see which commands are being
|
|
// run.
|
|
// The isCommandLineCommand arg is there so that we can style the log differently
|
|
// depending on whether we're directly outputting a command we're about to run that
|
|
// will be run on the command line, or if we're using something from Go's standard lib.
|
|
logCommandFn func(str string, isCommandLineCommand bool)
|
|
// this is for us to directly write the output of a command. We will do this for
|
|
// certain commands like 'git push'. The GUI will write this to a command output panel.
|
|
// We need a new cmd writer per command, hence it being a function.
|
|
newCmdWriterFn func() io.Writer
|
|
// this allows us to request info from the user like username/password, in the event
|
|
// that a command requests it.
|
|
// the 'credential' arg is something like 'username' or 'password'
|
|
promptForCredentialFn func(credential CredentialType) <-chan string
|
|
}
|
|
|
|
func NewGuiIO(
|
|
log *logrus.Entry,
|
|
logCommandFn func(string, bool),
|
|
newCmdWriterFn func() io.Writer,
|
|
promptForCredentialFn func(CredentialType) <-chan string,
|
|
) *guiIO {
|
|
return &guiIO{
|
|
log: log,
|
|
logCommandFn: logCommandFn,
|
|
newCmdWriterFn: newCmdWriterFn,
|
|
promptForCredentialFn: promptForCredentialFn,
|
|
}
|
|
}
|
|
|
|
// we use this function when we want to access the functionality of our OS struct but we
|
|
// don't have anywhere to log things, or request input from the user.
|
|
func NewNullGuiIO(log *logrus.Entry) *guiIO {
|
|
return &guiIO{
|
|
log: log,
|
|
logCommandFn: func(string, bool) {},
|
|
newCmdWriterFn: func() io.Writer { return io.Discard },
|
|
promptForCredentialFn: failPromptFn,
|
|
}
|
|
}
|