refactor to ensure code doesn't depend on integration code

Author: jesseduffield

main.go

@@ -1,151 +1,24 @@
 package main
 
 import (
-	"os"
-	"runtime/debug"
-
-	"github.com/integrii/flaggy"
 	"github.com/jesseduffield/lazygit/pkg/app"
-	"github.com/jesseduffield/lazygit/pkg/integration"
-	integrationTypes "github.com/jesseduffield/lazygit/pkg/integration/types"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/samber/lo"
 )
 
-const DEFAULT_VERSION = "unversioned"
-
-// These values may be set by the build script.
-// we'll overwrite them if they haven't been set by the build script and if Go itself has set corresponding values in the binary
+// These values may be set by the build script via the LDFLAGS argument
 var (
 	commit      string
-	version     = DEFAULT_VERSION
 	date        string
+	version     string
 	buildSource = "unknown"
 )
 
 func main() {
-	cliArgs := parseCliArgsAndEnvVars()
-	buildInfo := getBuildInfo()
-	integrationTest := getIntegrationTest()
-
-	app.Start(cliArgs, buildInfo, integrationTest)
-}
-
-func parseCliArgsAndEnvVars() *app.CliArgs {
-	flaggy.DefaultParser.ShowVersionWithVersionFlag = false
-
-	repoPath := ""
-	flaggy.String(&repoPath, "p", "path", "Path of git repo. (equivalent to --work-tree=<path> --git-dir=<path>/.git/)")
-
-	filterPath := ""
-	flaggy.String(&filterPath, "f", "filter", "Path to filter on in `git log -- <path>`. When in filter mode, the commits, reflog, and stash are filtered based on the given path, and some operations are restricted")
-
-	gitArg := ""
-	flaggy.AddPositionalValue(&gitArg, "git-arg", 1, false, "Panel to focus upon opening lazygit. Accepted values (based on git terminology): status, branch, log, stash. Ignored if --filter arg is passed.")
-
-	printVersionInfo := false
-	flaggy.Bool(&printVersionInfo, "v", "version", "Print the current version")
-
-	debug := false
-	flaggy.Bool(&debug, "d", "debug", "Run in debug mode with logging (see --logs flag below). Use the LOG_LEVEL env var to set the log level (debug/info/warn/error)")
-
-	tailLogs := false
-	flaggy.Bool(&tailLogs, "l", "logs", "Tail lazygit logs (intended to be used when `lazygit --debug` is called in a separate terminal tab)")
-
-	printDefaultConfig := false
-	flaggy.Bool(&printDefaultConfig, "c", "config", "Print the default config")
-
-	printConfigDir := false
-	flaggy.Bool(&printConfigDir, "cd", "print-config-dir", "Print the config directory")
-
-	useConfigDir := ""
-	flaggy.String(&useConfigDir, "ucd", "use-config-dir", "override default config directory with provided directory")
-
-	workTree := ""
-	flaggy.String(&workTree, "w", "work-tree", "equivalent of the --work-tree git argument")
-
-	gitDir := ""
-	flaggy.String(&gitDir, "g", "git-dir", "equivalent of the --git-dir git argument")
-
-	customConfigFile := ""
-	flaggy.String(&customConfigFile, "ucf", "use-config-file", "Comma separated list to custom config file(s)")
-
-	flaggy.Parse()
-
-	if os.Getenv("DEBUG") == "TRUE" {
-		debug = true
-	}
-
-	return &app.CliArgs{
-		RepoPath:           repoPath,
-		FilterPath:         filterPath,
-		GitArg:             gitArg,
-		PrintVersionInfo:   printVersionInfo,
-		Debug:              debug,
-		TailLogs:           tailLogs,
-		PrintDefaultConfig: printDefaultConfig,
-		PrintConfigDir:     printConfigDir,
-		UseConfigDir:       useConfigDir,
-		WorkTree:           workTree,
-		GitDir:             gitDir,
-		CustomConfigFile:   customConfigFile,
-	}
-}
-
-func getBuildInfo() *app.BuildInfo {
-	buildInfo := &app.BuildInfo{
+	ldFlagsBuildInfo := &app.BuildInfo{
 		Commit:      commit,
 		Date:        date,
 		Version:     version,
 		BuildSource: buildSource,
 	}
 
-	// if the version has already been set by build flags then we'll honour that.
-	// chances are it's something like v0.31.0 which is more informative than a
-	// commit hash.
-	if buildInfo.Version != DEFAULT_VERSION {
-		return buildInfo
-	}
-
-	goBuildInfo, ok := debug.ReadBuildInfo()
-	if !ok {
-		return buildInfo
-	}
-
-	revision, ok := lo.Find(goBuildInfo.Settings, func(setting debug.BuildSetting) bool {
-		return setting.Key == "vcs.revision"
-	})
-	if ok {
-		buildInfo.Commit = revision.Value
-		// if lazygit was built from source we'll show the version as the
-		// abbreviated commit hash
-		buildInfo.Version = utils.ShortSha(revision.Value)
-	}
-
-	// if version hasn't been set we assume that neither has the date
-	time, ok := lo.Find(goBuildInfo.Settings, func(setting debug.BuildSetting) bool {
-		return setting.Key == "vcs.time"
-	})
-	if ok {
-		buildInfo.Date = time.Value
-	}
-
-	return buildInfo
-}
-
-func getIntegrationTest() integrationTypes.IntegrationTest {
-	integrationTestName := os.Getenv("LAZYGIT_TEST_NAME")
-	if integrationTestName == "" {
-		return nil
-	}
-
-	// unsetting so that if we run lazygit in as a 'daemon' we don't think we're trying to run a test again
-	os.Unsetenv("LAZYGIT_TEST_NAME")
-	for _, candidateTest := range integration.Tests {
-		if candidateTest.Name() == integrationTestName {
-			return candidateTest
-		}
-	}
-
-	panic("Could not find integration test with name: " + integrationTestName)
+	app.Start(ldFlagsBuildInfo, nil)
 }

pkg/app/entry_point.go

@@ -7,18 +7,22 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"runtime/debug"
 	"strings"
 
+	"github.com/integrii/flaggy"
 	"github.com/jesseduffield/lazygit/pkg/app/daemon"
 	appTypes "github.com/jesseduffield/lazygit/pkg/app/types"
 	"github.com/jesseduffield/lazygit/pkg/config"
 	"github.com/jesseduffield/lazygit/pkg/env"
 	integrationTypes "github.com/jesseduffield/lazygit/pkg/integration/types"
 	"github.com/jesseduffield/lazygit/pkg/logs"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+	"github.com/samber/lo"
 	"gopkg.in/yaml.v3"
 )
 
-type CliArgs struct {
+type cliArgs struct {
 	RepoPath           string
 	FilterPath         string
 	GitArg             string
@@ -40,7 +44,10 @@ type BuildInfo struct {
 	BuildSource string
 }
 
-func Start(cliArgs *CliArgs, buildInfo *BuildInfo, integrationTest integrationTypes.IntegrationTest) {
+func Start(buildInfo *BuildInfo, integrationTest integrationTypes.IntegrationTest) {
+	cliArgs := parseCliArgsAndEnvVars()
+	mergeBuildInfo(buildInfo)
+
 	if cliArgs.RepoPath != "" {
 		if cliArgs.WorkTree != "" || cliArgs.GitDir != "" {
 			log.Fatal("--path option is incompatible with the --work-tree and --git-dir options")
@@ -132,6 +139,67 @@ func Start(cliArgs *CliArgs, buildInfo *BuildInfo, integrationTest integrationTy
 	Run(appConfig, common, appTypes.NewStartArgs(cliArgs.FilterPath, parsedGitArg, integrationTest))
 }
 
+func parseCliArgsAndEnvVars() *cliArgs {
+	flaggy.DefaultParser.ShowVersionWithVersionFlag = false
+
+	repoPath := ""
+	flaggy.String(&repoPath, "p", "path", "Path of git repo. (equivalent to --work-tree=<path> --git-dir=<path>/.git/)")
+
+	filterPath := ""
+	flaggy.String(&filterPath, "f", "filter", "Path to filter on in `git log -- <path>`. When in filter mode, the commits, reflog, and stash are filtered based on the given path, and some operations are restricted")
+
+	gitArg := ""
+	flaggy.AddPositionalValue(&gitArg, "git-arg", 1, false, "Panel to focus upon opening lazygit. Accepted values (based on git terminology): status, branch, log, stash. Ignored if --filter arg is passed.")
+
+	printVersionInfo := false
+	flaggy.Bool(&printVersionInfo, "v", "version", "Print the current version")
+
+	debug := false
+	flaggy.Bool(&debug, "d", "debug", "Run in debug mode with logging (see --logs flag below). Use the LOG_LEVEL env var to set the log level (debug/info/warn/error)")
+
+	tailLogs := false
+	flaggy.Bool(&tailLogs, "l", "logs", "Tail lazygit logs (intended to be used when `lazygit --debug` is called in a separate terminal tab)")
+
+	printDefaultConfig := false
+	flaggy.Bool(&printDefaultConfig, "c", "config", "Print the default config")
+
+	printConfigDir := false
+	flaggy.Bool(&printConfigDir, "cd", "print-config-dir", "Print the config directory")
+
+	useConfigDir := ""
+	flaggy.String(&useConfigDir, "ucd", "use-config-dir", "override default config directory with provided directory")
+
+	workTree := ""
+	flaggy.String(&workTree, "w", "work-tree", "equivalent of the --work-tree git argument")
+
+	gitDir := ""
+	flaggy.String(&gitDir, "g", "git-dir", "equivalent of the --git-dir git argument")
+
+	customConfigFile := ""
+	flaggy.String(&customConfigFile, "ucf", "use-config-file", "Comma separated list to custom config file(s)")
+
+	flaggy.Parse()
+
+	if os.Getenv("DEBUG") == "TRUE" {
+		debug = true
+	}
+
+	return &cliArgs{
+		RepoPath:           repoPath,
+		FilterPath:         filterPath,
+		GitArg:             gitArg,
+		PrintVersionInfo:   printVersionInfo,
+		Debug:              debug,
+		TailLogs:           tailLogs,
+		PrintDefaultConfig: printDefaultConfig,
+		PrintConfigDir:     printConfigDir,
+		UseConfigDir:       useConfigDir,
+		WorkTree:           workTree,
+		GitDir:             gitDir,
+		CustomConfigFile:   customConfigFile,
+	}
+}
+
 func parseGitArg(gitArg string) appTypes.GitArg {
 	typedArg := appTypes.GitArg(gitArg)
 
@@ -155,3 +223,43 @@ func parseGitArg(gitArg string) appTypes.GitArg {
 
 	panic("unreachable")
 }
+
+// the buildInfo struct we get passed in is based on what's baked into the lazygit
+// binary via the LDFLAGS argument. Some lazygit distributions will make use of these
+// arguments and some will not. Go recently started baking in build info
+// into the binary by default e.g. the git commit hash. So in this function
+// we merge the two together, giving priority to the stuff set by LDFLAGS.
+// Note: this mutates the argument passed in
+func mergeBuildInfo(buildInfo *BuildInfo) {
+	// if the version has already been set by build flags then we'll honour that.
+	// chances are it's something like v0.31.0 which is more informative than a
+	// commit hash.
+	if buildInfo.Version != "" {
+		return
+	}
+
+	buildInfo.Version = "unversioned"
+
+	goBuildInfo, ok := debug.ReadBuildInfo()
+	if !ok {
+		return
+	}
+
+	revision, ok := lo.Find(goBuildInfo.Settings, func(setting debug.BuildSetting) bool {
+		return setting.Key == "vcs.revision"
+	})
+	if ok {
+		buildInfo.Commit = revision.Value
+		// if lazygit was built from source we'll show the version as the
+		// abbreviated commit hash
+		buildInfo.Version = utils.ShortSha(revision.Value)
+	}
+
+	// if version hasn't been set we assume that neither has the date
+	time, ok := lo.Find(goBuildInfo.Settings, func(setting debug.BuildSetting) bool {
+		return setting.Key == "vcs.time"
+	})
+	if ok {
+		buildInfo.Date = time.Value
+	}
+}

pkg/gui/gui_adapter.go renamed to pkg/gui/gui_driver.go

@@ -14,13 +14,13 @@ import (
 
 // this gives our integration test a way of interacting with the gui for sending keypresses
 // and reading state.
-type GuiAdapter struct {
+type GuiDriver struct {
 	gui *Gui
 }
 
-var _ integrationTypes.GuiAdapter = &GuiAdapter{}
+var _ integrationTypes.GuiDriver = &GuiDriver{}
 
-func (self *GuiAdapter) PressKey(keyStr string) {
+func (self *GuiDriver) PressKey(keyStr string) {
 	key := keybindings.GetKey(keyStr)
 
 	var r rune
@@ -39,35 +39,35 @@ func (self *GuiAdapter) PressKey(keyStr string) {
 	)
 }
 
-func (self *GuiAdapter) Keys() config.KeybindingConfig {
+func (self *GuiDriver) Keys() config.KeybindingConfig {
 	return self.gui.Config.GetUserConfig().Keybinding
 }
 
-func (self *GuiAdapter) CurrentContext() types.Context {
+func (self *GuiDriver) CurrentContext() types.Context {
 	return self.gui.c.CurrentContext()
 }
 
-func (self *GuiAdapter) Model() *types.Model {
+func (self *GuiDriver) Model() *types.Model {
 	return self.gui.State.Model
 }
 
-func (self *GuiAdapter) Fail(message string) {
+func (self *GuiDriver) Fail(message string) {
 	self.gui.g.Close()
 	// need to give the gui time to close
 	time.Sleep(time.Millisecond * 100)
 	panic(message)
 }
 
 // logs to the normal place that you log to i.e. viewable with `lazygit --logs`
-func (self *GuiAdapter) Log(message string) {
+func (self *GuiDriver) Log(message string) {
 	self.gui.c.Log.Warn(message)
 }
 
 // logs in the actual UI (in the commands panel)
-func (self *GuiAdapter) LogUI(message string) {
+func (self *GuiDriver) LogUI(message string) {
 	self.gui.c.LogAction(message)
 }
 
-func (self *GuiAdapter) CheckedOutRef() *models.Branch {
+func (self *GuiDriver) CheckedOutRef() *models.Branch {
 	return self.gui.helpers.Refs.GetCheckedOutRef()
 }

pkg/gui/test_mode.go

@@ -14,15 +14,15 @@ import (
 )
 
 type IntegrationTest interface {
-	Run(guiAdapter *GuiAdapter)
+	Run(guiAdapter *GuiDriver)
 }
 
 func (gui *Gui) handleTestMode(test integrationTypes.IntegrationTest) {
 	if test != nil {
 		go func() {
 			time.Sleep(time.Millisecond * 100)
 
-			test.Run(&GuiAdapter{gui: gui})
+			test.Run(&GuiDriver{gui: gui})
 
 			gui.g.Update(func(*gocui.Gui) error {
 				return gocui.ErrQuit