fix: improve backward compatibility

pkg/commands/git.go

@@ -128,7 +128,7 @@ func NewGitCommandAux(
 	reflogCommitLoader := git_commands.NewReflogCommitLoader(cmn, cmd)
 	remoteLoader := git_commands.NewRemoteLoader(cmn, cmd, repo.Remotes)
 	stashLoader := git_commands.NewStashLoader(cmn, cmd)
-	tagLoader := git_commands.NewTagLoader(cmn, cmd)
+	tagLoader := git_commands.NewTagLoader(cmn, version, cmd)
 
 	return &GitCommand{
 		Branch:      branchCommands,

pkg/commands/git_commands/tag_loader.go

@@ -1,6 +1,8 @@
 package git_commands
 
 import (
+	"fmt"
+
 	"github.com/jesseduffield/generics/slices"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
@@ -10,23 +12,31 @@ import (
 
 type TagLoader struct {
 	*common.Common
-	cmd oscommands.ICmdObjBuilder
+	version *GitVersion
+	cmd     oscommands.ICmdObjBuilder
 }
 
 func NewTagLoader(
 	common *common.Common,
+	version *GitVersion,
 	cmd oscommands.ICmdObjBuilder,
 ) *TagLoader {
 	return &TagLoader{
-		Common: common,
-		cmd:    cmd,
+		Common:  common,
+		version: version,
+		cmd:     cmd,
 	}
 }
 
 func (self *TagLoader) GetTags() ([]*models.Tag, error) {
 	// get remote branches, sorted  by creation date (descending)
 	// see: https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---sortltkeygt
-	tagsOutput, err := self.cmd.New(`git tag --list --sort=-creatordate`).DontLog().RunWithOutput()
+	sortKey := "-creatordate"
+	if self.version.IsOlderThan(2, 7, 0) {
+		sortKey = "-v:refname"
+	}
+
+	tagsOutput, err := self.cmd.New(fmt.Sprintf(`git tag --list --sort=%s`, sortKey)).DontLog().RunWithOutput()
 	if err != nil {
 		return nil, err
 	}

pkg/commands/git_commands/tag_loader_test.go

@@ -20,6 +20,7 @@ testtag
 func TestGetTags(t *testing.T) {
 	type scenario struct {
 		testName      string
+		gitVersion    *GitVersion
 		runner        *oscommands.FakeCmdObjRunner
 		expectedTags  []*models.Tag
 		expectedError error
@@ -27,14 +28,24 @@ func TestGetTags(t *testing.T) {
 
 	scenarios := []scenario{
 		{
-			testName: "should return no tags if there are none",
+			testName:   "should return no tags if there are none",
+			gitVersion: &GitVersion{2, 7, 0, ""},
 			runner: oscommands.NewFakeRunner(t).
 				Expect(`git tag --list --sort=-creatordate`, "", nil),
 			expectedTags:  []*models.Tag{},
 			expectedError: nil,
 		},
 		{
-			testName: "should return tags if present",
+			testName:   "should return no tags if there are none (< 2.7.0)",
+			gitVersion: &GitVersion{2, 6, 7, ""},
+			runner: oscommands.NewFakeRunner(t).
+				Expect(`git tag --list --sort=-v:refname`, "", nil),
+			expectedTags:  []*models.Tag{},
+			expectedError: nil,
+		},
+		{
+			testName:   "should return tags if present",
+			gitVersion: &GitVersion{2, 7, 0, ""},
 			runner: oscommands.NewFakeRunner(t).
 				Expect(`git tag --list --sort=-creatordate`, tagsOutput, nil),
 			expectedTags: []*models.Tag{
@@ -47,15 +58,31 @@ func TestGetTags(t *testing.T) {
 			},
 			expectedError: nil,
 		},
+		{
+			testName:   "should return tags if present (< 2.7.0)",
+			gitVersion: &GitVersion{2, 6, 7, ""},
+			runner: oscommands.NewFakeRunner(t).
+				Expect(`git tag --list --sort=-v:refname`, tagsOutput, nil),
+			expectedTags: []*models.Tag{
+				{Name: "v0.34"},
+				{Name: "v0.33"},
+				{Name: "v0.32.2"},
+				{Name: "v0.32.1"},
+				{Name: "v0.32"},
+				{Name: "testtag"},
+			},
+			expectedError: nil,
+		},
 	}
 
 	for _, scenario := range scenarios {
 		scenario := scenario
 		t.Run(scenario.testName, func(t *testing.T) {
-			loader := &TagLoader{
-				Common: utils.NewDummyCommon(),
-				cmd:    oscommands.NewDummyCmdObjBuilder(scenario.runner),
-			}
+			loader := NewTagLoader(
+				utils.NewDummyCommon(),
+				scenario.gitVersion,
+				oscommands.NewDummyCmdObjBuilder(scenario.runner),
+			)
 
 			tags, err := loader.GetTags()