mirror of
https://github.com/jesseduffield/lazygit.git
synced 2026-11-18 03:49:50 -06:00
Checking for an update with `u` has several problems: - It offers to download and install the new version for any build that has a version, including builds from Homebrew or a Linux distribution. Overwriting those makes the package manager report the wrong version. - It only logs its errors, so the user never learns why nothing happens. This includes "You already have the latest version". For a build from a git checkout, the version is a commit hash; comparing it with the release version fails, and the user sees nothing at all. - Installing always fails on Windows. Rewrite it on top of the functions from the previous commits. Show the result of the check in all cases. If there's an update, show a menu that depends on how lazygit was installed. We only offer "Install now" for our release archives, and only if we can write to the folder of the executable. For package managers that we know, we show the command that updates lazygit. Otherwise we tell the user where to get the new version. Disable `u` for dev builds and say why. Installing replaces the executable with a rename, so quitting during an update can no longer leave a broken binary behind. Instead of asking for confirmation, wait for the rename to finish before exiting. Remove the check at startup for now. It never ran, because it checked for the build source "buildBinary" while .goreleaser.yml sets "binaryRelease". A later commit adds a new one. Use os.Executable instead of the osext package; os.Executable didn't exist yet when this code was written. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
297 lines
7.6 KiB
Go
297 lines
7.6 KiB
Go
package app
|
|
|
|
import (
|
|
"bufio"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/go-errors/errors"
|
|
"github.com/sirupsen/logrus"
|
|
"github.com/spf13/afero"
|
|
|
|
appTypes "github.com/jesseduffield/lazygit/pkg/app/types"
|
|
"github.com/jesseduffield/lazygit/pkg/commands/direnv"
|
|
"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
|
|
"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
|
|
"github.com/jesseduffield/lazygit/pkg/common"
|
|
"github.com/jesseduffield/lazygit/pkg/config"
|
|
"github.com/jesseduffield/lazygit/pkg/constants"
|
|
"github.com/jesseduffield/lazygit/pkg/env"
|
|
"github.com/jesseduffield/lazygit/pkg/gui"
|
|
"github.com/jesseduffield/lazygit/pkg/i18n"
|
|
integrationTypes "github.com/jesseduffield/lazygit/pkg/integration/types"
|
|
"github.com/jesseduffield/lazygit/pkg/logs"
|
|
"github.com/jesseduffield/lazygit/pkg/updates"
|
|
)
|
|
|
|
// App is the struct that's instantiated from within main.go and it manages
|
|
// bootstrapping and running the application.
|
|
type App struct {
|
|
*common.Common
|
|
closers []io.Closer
|
|
Config config.AppConfigurer
|
|
OSCommand *oscommands.OSCommand
|
|
Gui *gui.Gui
|
|
}
|
|
|
|
func Run(
|
|
config config.AppConfigurer,
|
|
common *common.Common,
|
|
startArgs appTypes.StartArgs,
|
|
) {
|
|
app, err := NewApp(config, startArgs.IntegrationTest, common)
|
|
|
|
if err == nil {
|
|
err = app.Run(startArgs)
|
|
}
|
|
|
|
if err != nil {
|
|
if errorMessage, known := knownError(common.Tr, err); known {
|
|
log.Fatal(errorMessage)
|
|
}
|
|
newErr := errors.Wrap(err, 0)
|
|
stackTrace := newErr.ErrorStack()
|
|
app.Log.Error(stackTrace)
|
|
|
|
log.Fatalf("%s: %s\n\n%s", common.Tr.ErrorOccurred, constants.Links.Issues, stackTrace)
|
|
}
|
|
}
|
|
|
|
func NewCommon(config config.AppConfigurer, log *logrus.Entry) (*common.Common, error) {
|
|
userConfig := config.GetUserConfig()
|
|
// Initialize with English for the time being; the real translation set for
|
|
// the configured language will be read after reading the user config
|
|
tr := i18n.EnglishTranslationSet()
|
|
|
|
cmn := &common.Common{
|
|
Log: log,
|
|
Tr: tr,
|
|
Debug: config.GetDebug(),
|
|
Fs: afero.NewOsFs(),
|
|
}
|
|
cmn.SetUserConfig(userConfig)
|
|
return cmn, nil
|
|
}
|
|
|
|
func NewLogger(debug bool) *logrus.Entry {
|
|
if debug {
|
|
logPath, err := config.LogPath()
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
return logs.NewDevelopmentLogger(logPath)
|
|
}
|
|
|
|
return logs.NewProductionLogger()
|
|
}
|
|
|
|
// NewApp bootstrap a new application
|
|
func NewApp(config config.AppConfigurer, test integrationTypes.IntegrationTest, common *common.Common) (*App, error) {
|
|
app := &App{
|
|
closers: []io.Closer{},
|
|
Config: config,
|
|
Common: common,
|
|
}
|
|
|
|
app.OSCommand = oscommands.NewOSCommand(common, config, oscommands.GetPlatform(), oscommands.NewNullGuiIO(app.Log))
|
|
|
|
updater := updates.NewUpdater(common, config)
|
|
|
|
dirName, err := os.Getwd()
|
|
if err != nil {
|
|
return app, err
|
|
}
|
|
|
|
gitVersion, err := app.validateGitVersion()
|
|
if err != nil {
|
|
return app, err
|
|
}
|
|
|
|
// If we're not in a repo, GetRepoPaths will return an error. The error is moot for us
|
|
// at this stage, since we'll try to init a new repo in setupRepo(), below
|
|
repoPaths, err := git_commands.GetRepoPaths(app.OSCommand.Cmd, gitVersion)
|
|
if err != nil {
|
|
common.Log.Infof("Error getting repo paths: %v", err)
|
|
}
|
|
|
|
showRecentRepos, err := app.setupRepo(repoPaths)
|
|
if err != nil {
|
|
return app, err
|
|
}
|
|
|
|
// used for testing purposes
|
|
if os.Getenv("SHOW_RECENT_REPOS") == "true" {
|
|
showRecentRepos = true
|
|
}
|
|
|
|
app.Gui, err = gui.NewGui(common, config, gitVersion, updater, showRecentRepos, dirName, test)
|
|
if err != nil {
|
|
return app, err
|
|
}
|
|
return app, nil
|
|
}
|
|
|
|
const minGitVersionStr = "2.32.0"
|
|
|
|
func minGitVersionErrorMessage(tr *i18n.TranslationSet) string {
|
|
return fmt.Sprintf(tr.MinGitVersionError, minGitVersionStr)
|
|
}
|
|
|
|
func (app *App) validateGitVersion() (*git_commands.GitVersion, error) {
|
|
version, err := git_commands.GetGitVersion(app.OSCommand)
|
|
// if we get an error anywhere here we'll show the same status
|
|
minVersionError := errors.New(minGitVersionErrorMessage(app.Tr))
|
|
if err != nil {
|
|
return nil, minVersionError
|
|
}
|
|
|
|
minRequiredVersion, _ := git_commands.ParseGitVersion(minGitVersionStr)
|
|
if version.IsOlderThanVersion(minRequiredVersion) {
|
|
return nil, minVersionError
|
|
}
|
|
|
|
return version, nil
|
|
}
|
|
|
|
func isDirectoryAGitRepository(dir string) (bool, error) {
|
|
info, err := os.Stat(filepath.Join(dir, ".git"))
|
|
return info != nil, err
|
|
}
|
|
|
|
func openRecentRepo(app *App) bool {
|
|
appState, err := app.Config.ReadAppState()
|
|
if err != nil {
|
|
app.Log.Errorf("error when reading app state: %v", err)
|
|
}
|
|
for _, repoDir := range appState.RecentRepos {
|
|
if isRepo, _ := isDirectoryAGitRepository(repoDir); isRepo {
|
|
if err := os.Chdir(repoDir); err == nil {
|
|
// We're still in setup, before the gui exists, so we can't show the approval popup
|
|
// that DispatchSwitchTo offers for blocked .envrc files; just log and move on.
|
|
// Also, the logs only go to the debug log, not the Command Log, because that's not
|
|
// available yet, either.
|
|
result := direnv.Load(app.OSCommand.Cmd)
|
|
if result.Message != "" {
|
|
app.Log.WithField("message", result.Message).Info("direnv")
|
|
}
|
|
if result.Err != nil {
|
|
app.Log.WithError(result.Err).Warn("direnv load failed")
|
|
}
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func (app *App) setupRepo(
|
|
repoPaths *git_commands.RepoPaths,
|
|
) (bool, error) {
|
|
if env.GetGitDirEnv() != "" {
|
|
// we've been given the git dir directly. Skip setup
|
|
return false, nil
|
|
}
|
|
|
|
// if we are not in a git repo, we ask if we want to `git init`
|
|
if repoPaths == nil {
|
|
cwd, err := os.Getwd()
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
if isRepo, err := isDirectoryAGitRepository(cwd); isRepo {
|
|
return false, err
|
|
}
|
|
|
|
var shouldInitRepo bool
|
|
initialBranchArg := ""
|
|
switch app.UserConfig().NotARepository {
|
|
case "prompt":
|
|
// Offer to initialize a new repository in current directory.
|
|
fmt.Print(app.Tr.CreateRepo)
|
|
response, _ := bufio.NewReader(os.Stdin).ReadString('\n')
|
|
shouldInitRepo = (strings.Trim(response, " \r\n") == "y")
|
|
if shouldInitRepo {
|
|
// Ask for the initial branch name
|
|
fmt.Print(app.Tr.InitialBranch)
|
|
response, _ := bufio.NewReader(os.Stdin).ReadString('\n')
|
|
if trimmedResponse := strings.Trim(response, " \r\n"); len(trimmedResponse) > 0 {
|
|
initialBranchArg += "--initial-branch=" + trimmedResponse
|
|
}
|
|
}
|
|
case "create":
|
|
shouldInitRepo = true
|
|
case "skip":
|
|
shouldInitRepo = false
|
|
case "quit":
|
|
fmt.Fprintln(os.Stderr, app.Tr.NotARepository)
|
|
os.Exit(1)
|
|
default:
|
|
fmt.Fprintln(os.Stderr, app.Tr.IncorrectNotARepository)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if shouldInitRepo {
|
|
args := []string{"git", "init"}
|
|
if initialBranchArg != "" {
|
|
args = append(args, initialBranchArg)
|
|
}
|
|
if err := app.OSCommand.Cmd.New(args).Run(); err != nil {
|
|
return false, err
|
|
}
|
|
|
|
return false, nil
|
|
}
|
|
|
|
// check if we have a recent repo we can open
|
|
if openRecentRepo(app) {
|
|
return true, nil
|
|
}
|
|
|
|
fmt.Fprintln(os.Stderr, app.Tr.NoRecentRepositories)
|
|
os.Exit(1)
|
|
}
|
|
|
|
// Run this afterward so that the previous repo creation steps can run without this interfering
|
|
if repoPaths.IsBareRepo() {
|
|
|
|
fmt.Print(app.Tr.BareRepo)
|
|
|
|
response, _ := bufio.NewReader(os.Stdin).ReadString('\n')
|
|
|
|
if shouldOpenRecent := strings.Trim(response, " \r\n") == "y"; !shouldOpenRecent {
|
|
os.Exit(0)
|
|
}
|
|
|
|
if openRecentRepo(app) {
|
|
return true, nil
|
|
}
|
|
|
|
fmt.Println(app.Tr.NoRecentRepositories)
|
|
os.Exit(1)
|
|
}
|
|
|
|
return false, nil
|
|
}
|
|
|
|
func (app *App) Run(startArgs appTypes.StartArgs) error {
|
|
err := app.Gui.RunAndHandleError(startArgs)
|
|
return err
|
|
}
|
|
|
|
// Close closes any resources
|
|
func (app *App) Close() error {
|
|
for _, closer := range app.closers {
|
|
if err := closer.Close(); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|