add half and fullscreen modes

docs/Config.md

@@ -18,7 +18,7 @@ Default path for the config file:
         - white
         - bold
       inactiveBorderColor:
-        - green
+        - white
       optionsTextColor:
         - blue
       selectedLineBgColor:
@@ -53,8 +53,6 @@ Default path for the config file:
       nextBlock: '<right>' # goto the next block / panel
       prevBlock-alt: 'h' # goto the previous block / panel
       nextBlock-alt: 'l' # goto the next block / panel
-      nextMatch: 'n'
-      prevMatch: 'N'
       optionMenu: 'x' # show help menu
       optionMenu-alt1: '?' # show help menu
       select: '<space>'
@@ -219,8 +217,6 @@ For all possible keybinding options, check [Custom_Keybinding.md](https://github
       nextItem-alt: 'e'
       prevBlock-alt: 'n'
       nextBlock-alt: 'i'
-      nextMatch: '='
-      prevMatch: '-'
       new: 'k'
       edit: 'o'
       openFile: 'O'

pkg/commands/branch.go

@@ -1,5 +1,15 @@
 package commands
 
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/theme"
+
+	"github.com/fatih/color"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
 // Branch : A git branch
 // duplicating this for now
 type Branch struct {
@@ -7,4 +17,31 @@ type Branch struct {
 	Recency   string
 	Pushables string
 	Pullables string
+	Selected  bool
+}
+
+// GetDisplayStrings returns the display string of branch
+func (b *Branch) GetDisplayStrings(isFocused bool) []string {
+	displayName := utils.ColoredString(b.Name, GetBranchColor(b.Name))
+	if isFocused && b.Selected && b.Pushables != "" && b.Pullables != "" {
+		displayName = fmt.Sprintf("%s ↑%s↓%s", displayName, b.Pushables, b.Pullables)
+	}
+
+	return []string{b.Recency, displayName}
+}
+
+// GetBranchColor branch color
+func GetBranchColor(name string) color.Attribute {
+	branchType := strings.Split(name, "/")[0]
+
+	switch branchType {
+	case "feature":
+		return color.FgGreen
+	case "bugfix":
+		return color.FgYellow
+	case "hotfix":
+		return color.FgRed
+	default:
+		return theme.DefaultTextColor
+	}
 }

pkg/commands/commit.go

@@ -1,5 +1,13 @@
 package commands
 
+import (
+	"strings"
+
+	"github.com/fatih/color"
+	"github.com/jesseduffield/lazygit/pkg/theme"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
 // Commit : A git commit
 type Commit struct {
 	Sha           string
@@ -9,7 +17,53 @@ type Commit struct {
 	Action        string // one of "", "pick", "edit", "squash", "reword", "drop", "fixup"
 	Copied        bool   // to know if this commit is ready to be cherry-picked somewhere
 	Tags          []string
-	ExtraInfo     string // something like 'HEAD -> master, tag: v0.15.2'
-	Author        string
-	Date          string
+}
+
+// GetDisplayStrings is a function.
+func (c *Commit) GetDisplayStrings(isFocused bool) []string {
+	red := color.New(color.FgRed)
+	yellow := color.New(color.FgYellow)
+	green := color.New(color.FgGreen)
+	blue := color.New(color.FgBlue)
+	cyan := color.New(color.FgCyan)
+	defaultColor := color.New(theme.DefaultTextColor)
+	magenta := color.New(color.FgMagenta)
+
+	// for some reason, setting the background to blue pads out the other commits
+	// horizontally. For the sake of accessibility I'm considering this a feature,
+	// not a bug
+	copied := color.New(color.FgCyan, color.BgBlue)
+
+	var shaColor *color.Color
+	switch c.Status {
+	case "unpushed":
+		shaColor = red
+	case "pushed":
+		shaColor = yellow
+	case "merged":
+		shaColor = green
+	case "rebasing":
+		shaColor = blue
+	case "reflog":
+		shaColor = blue
+	case "selected":
+		shaColor = magenta
+	default:
+		shaColor = defaultColor
+	}
+
+	if c.Copied {
+		shaColor = copied
+	}
+
+	actionString := ""
+	tagString := ""
+	if c.Action != "" {
+		actionString = cyan.Sprint(utils.WithPadding(c.Action, 7)) + " "
+	} else if len(c.Tags) > 0 {
+		tagColor := color.New(color.FgMagenta, color.Bold)
+		tagString = utils.ColoredStringDirect(strings.Join(c.Tags, " "), tagColor) + " "
+	}
+
+	return []string{shaColor.Sprint(c.Sha[:8]), actionString + tagString + defaultColor.Sprint(c.Name)}
 }

pkg/commands/commit_file.go

@@ -1,5 +1,10 @@
 package commands
 
+import (
+	"github.com/fatih/color"
+	"github.com/jesseduffield/lazygit/pkg/theme"
+)
+
 // CommitFile : A git commit file
 type CommitFile struct {
 	Sha           string
@@ -17,3 +22,21 @@ const (
 	// PART is for when you're only talking about specific lines that have been modified
 	PART
 )
+
+// GetDisplayStrings is a function.
+func (f *CommitFile) GetDisplayStrings(isFocused bool) []string {
+	yellow := color.New(color.FgYellow)
+	green := color.New(color.FgGreen)
+	defaultColor := color.New(theme.DefaultTextColor)
+
+	var colour *color.Color
+	switch f.Status {
+	case UNSELECTED:
+		colour = defaultColor
+	case WHOLE:
+		colour = green
+	case PART:
+		colour = yellow
+	}
+	return []string{colour.Sprint(f.DisplayString)}
+}

pkg/commands/commit_list_builder.go

@@ -23,8 +23,6 @@ import (
 // if we find out we need to use one of these functions in the git.go file, we
 // can just pull them out of here and put them there and then call them from in here
 
-const SEPARATION_CHAR = "|"
-
 // CommitListBuilder returns a list of Branch objects for the current repo
 type CommitListBuilder struct {
 	Log                 *logrus.Entry
@@ -47,37 +45,42 @@ func NewCommitListBuilder(log *logrus.Entry, gitCommand *GitCommand, osCommand *
 	}, nil
 }
 
-// extractCommitFromLine takes a line from a git log and extracts the sha, message, date, and tag if present
-// then puts them into a commit object
-// example input:
-// 8ad01fe32fcc20f07bc6693f87aa4977c327f1e1|10 hours ago|Jesse Duffield| (HEAD -> master, tag: v0.15.2)|refresh commits when adding a tag
-func (c *CommitListBuilder) extractCommitFromLine(line string) *Commit {
-	split := strings.Split(line, SEPARATION_CHAR)
+// nameAndTag takes a line from a git log and extracts the sha, message and tag (if present)
+// example inputs:
+// 66e6369c284e96ed5af5 (tag: v0.14.4) allow fastforwarding the current branch
+// 32e650e0bb3f4327749f (HEAD -> show-tags) this is my commit
+// 32e650e0bb3f4327749e this is my other commit
+func (c *CommitListBuilder) commitLineParts(line string) (string, string, []string) {
+	re := regexp.MustCompile(`(\w+) (.*)`)
+	shaMatch := re.FindStringSubmatch(line)
 
-	sha := split[0]
-	date := split[1]
-	author := split[2]
-	extraInfo := strings.TrimSpace(split[3])
-	message := strings.Join(split[4:], SEPARATION_CHAR)
-	tags := []string{}
+	if len(shaMatch) <= 1 {
+		return line, "", nil
+	}
+	sha := shaMatch[1]
+	rest := shaMatch[2]
 
-	if extraInfo != "" {
-		re := regexp.MustCompile(`tag: ([^,\)]+)`)
-		tagMatch := re.FindStringSubmatch(extraInfo)
-		if len(tagMatch) > 1 {
-			tags = append(tags, tagMatch[1])
-		}
+	if !strings.HasPrefix(rest, "(") {
+		return sha, rest, nil
 	}
 
-	return &Commit{
-		Sha:           sha,
-		Name:          message,
-		DisplayString: line,
-		Tags:          tags,
-		ExtraInfo:     extraInfo,
-		Date:          date,
-		Author:        author,
+	re = regexp.MustCompile(`\((.*)\) (.*)`)
+
+	parensMatch := re.FindStringSubmatch(rest)
+	if len(parensMatch) <= 1 {
+		return sha, rest, nil
 	}
+
+	notes := parensMatch[1]
+	message := parensMatch[2]
+	re = regexp.MustCompile(`tag: ([^,]+)`)
+	tagMatch := re.FindStringSubmatch(notes)
+	if len(tagMatch) <= 1 {
+		return sha, message, nil
+	}
+
+	tag := tagMatch[1]
+	return sha, message, []string{tag}
 }
 
 // GetCommits obtains the commits of the current branch
@@ -104,10 +107,16 @@ func (c *CommitListBuilder) GetCommits(limit bool) ([]*Commit, error) {
 
 	// now we can split it up and turn it into commits
 	for _, line := range utils.SplitLines(log) {
-		commit := c.extractCommitFromLine(line)
-		_, unpushed := unpushedCommits[commit.Sha[:8]]
-		commit.Status = map[bool]string{true: "unpushed", false: "pushed"}[unpushed]
-		commits = append(commits, commit)
+		sha, name, tags := c.commitLineParts(line)
+		_, unpushed := unpushedCommits[sha]
+		status := map[bool]string{true: "unpushed", false: "pushed"}[unpushed]
+		commits = append(commits, &Commit{
+			Sha:           sha,
+			Name:          name,
+			Status:        status,
+			DisplayString: line,
+			Tags:          tags,
+		})
 	}
 	if rebaseMode != "" {
 		currentCommit := commits[len(rebasingCommits)]
@@ -316,8 +325,7 @@ func (c *CommitListBuilder) getLog(limit bool) string {
 		limitFlag = "-30"
 	}
 
-	result, err := c.OSCommand.RunCommandWithOutput(fmt.Sprintf("git log --oneline --pretty=format:\"%%H%s%%ar%s%%aN%s%%d%s%%s\" %s --abbrev=%d", SEPARATION_CHAR, SEPARATION_CHAR, SEPARATION_CHAR, SEPARATION_CHAR, limitFlag, 20))
-
+	result, err := c.OSCommand.RunCommandWithOutput(fmt.Sprintf("git log --decorate --oneline %s --abbrev=%d", limitFlag, 20))
 	if err != nil {
 		// assume if there is an error there are no commits yet for this branch
 		return ""

pkg/commands/commit_list_builder_test.go

@@ -149,3 +149,170 @@ func TestCommitListBuilderGetMergeBase(t *testing.T) {
 		})
 	}
 }
+
+// TestCommitListBuilderGetLog is a function.
+func TestCommitListBuilderGetLog(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		test     func(string)
+	}
+
+	scenarios := []scenario{
+		{
+			"Retrieves logs",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"log", "--decorate", "--oneline", "-30", "--abbrev=20"}, args)
+
+				return exec.Command("echo", "6f0b32f commands/git : add GetCommits tests refactor\n9d9d775 circle : remove new line")
+			},
+			func(output string) {
+				assert.EqualValues(t, "6f0b32f commands/git : add GetCommits tests refactor\n9d9d775 circle : remove new line\n", output)
+			},
+		},
+		{
+			"An error occurred when retrieving logs",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"log", "--decorate", "--oneline", "-30", "--abbrev=20"}, args)
+				return exec.Command("test")
+			},
+			func(output string) {
+				assert.Empty(t, output)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			c := NewDummyCommitListBuilder()
+			c.OSCommand.SetCommand(s.command)
+			s.test(c.getLog(true))
+		})
+	}
+}
+
+// TestCommitListBuilderGetCommits is a function.
+func TestCommitListBuilderGetCommits(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		test     func([]*Commit, error)
+	}
+
+	scenarios := []scenario{
+		{
+			"No data found",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "rev-list":
+					assert.EqualValues(t, []string{"rev-list", "@{u}..HEAD", "--abbrev-commit"}, args)
+					return exec.Command("echo")
+				case "log":
+					assert.EqualValues(t, []string{"log", "--decorate", "--oneline", "-30", "--abbrev=20"}, args)
+					return exec.Command("echo")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("test")
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "master")
+				}
+
+				return nil
+			},
+			func(commits []*Commit, err error) {
+				assert.NoError(t, err)
+				assert.Len(t, commits, 0)
+			},
+		},
+		{
+			"GetCommits returns 2 commits, 1 unpushed, the other merged",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "rev-list":
+					assert.EqualValues(t, []string{"rev-list", "@{u}..HEAD", "--abbrev-commit"}, args)
+					return exec.Command("echo", "8a2bb0e")
+				case "log":
+					assert.EqualValues(t, []string{"log", "--decorate", "--oneline", "-30", "--abbrev=20"}, args)
+					return exec.Command("echo", "8a2bb0e commit 1\n78976bc commit 2")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("echo", "78976bc")
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "master")
+				}
+
+				return nil
+			},
+			func(commits []*Commit, err error) {
+				assert.NoError(t, err)
+				assert.Len(t, commits, 2)
+				assert.EqualValues(t, []*Commit{
+					{
+						Sha:           "8a2bb0e",
+						Name:          "commit 1",
+						Status:        "unpushed",
+						DisplayString: "8a2bb0e commit 1",
+					},
+					{
+						Sha:           "78976bc",
+						Name:          "commit 2",
+						Status:        "merged",
+						DisplayString: "78976bc commit 2",
+					},
+				}, commits)
+			},
+		},
+		{
+			"GetCommits bubbles up an error from setCommitMergedStatuses",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "rev-list":
+					assert.EqualValues(t, []string{"rev-list", "@{u}..HEAD", "--abbrev-commit"}, args)
+					return exec.Command("echo", "8a2bb0e")
+				case "log":
+					assert.EqualValues(t, []string{"log", "--decorate", "--oneline", "-30", "--abbrev=20"}, args)
+					return exec.Command("echo", "8a2bb0e commit 1\n78976bc commit 2")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("echo", "78976bc")
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					// here's where we are returning the error
+					return exec.Command("test")
+				case "branch":
+					assert.EqualValues(t, []string{"branch", "--contains"}, args)
+					// here too
+					return exec.Command("test")
+				case "rev-parse":
+					assert.EqualValues(t, []string{"rev-parse", "--short", "HEAD"}, args)
+					// here too
+					return exec.Command("test")
+				}
+
+				return nil
+			},
+			func(commits []*Commit, err error) {
+				assert.Error(t, err)
+				assert.Len(t, commits, 0)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			c := NewDummyCommitListBuilder()
+			c.OSCommand.SetCommand(s.command)
+			s.test(c.GetCommits(true))
+		})
+	}
+}

pkg/commands/file.go

@@ -1,5 +1,7 @@
 package commands
 
+import "github.com/fatih/color"
+
 // File : A file from git status
 // duplicating this for now
 type File struct {
@@ -14,3 +16,23 @@ type File struct {
 	Type                    string // one of 'file', 'directory', and 'other'
 	ShortStatus             string // e.g. 'AD', ' A', 'M ', '??'
 }
+
+// GetDisplayStrings returns the display string of a file
+func (f *File) GetDisplayStrings(isFocused bool) []string {
+	// potentially inefficient to be instantiating these color
+	// objects with each render
+	red := color.New(color.FgRed)
+	green := color.New(color.FgGreen)
+	if !f.Tracked && !f.HasStagedChanges {
+		return []string{red.Sprint(f.DisplayString)}
+	}
+
+	output := green.Sprint(f.DisplayString[0:1])
+	output += red.Sprint(f.DisplayString[1:3])
+	if f.HasUnstagedChanges {
+		output += red.Sprint(f.Name)
+	} else {
+		output += green.Sprint(f.Name)
+	}
+	return []string{output}
+}

pkg/commands/git.go

@@ -967,7 +967,7 @@ func (c *GitCommand) ResetSoft(ref string) error {
 
 // DiffCommits show diff between commits
 func (c *GitCommand) DiffCommits(sha1, sha2 string) (string, error) {
-	return c.OSCommand.RunCommandWithOutput("git diff --color --stat -p %s %s", sha1, sha2)
+	return c.OSCommand.RunCommandWithOutput("git diff --color %s %s", sha1, sha2)
 }
 
 // CreateFixupCommit creates a commit that fixes up a previous commit
@@ -1115,7 +1115,7 @@ func (c *GitCommand) GetReflogCommits() ([]*Commit, error) {
 	re := regexp.MustCompile(`(\w+).*HEAD@\{\d+\}: (.*)`)
 	for i, line := range lines {
 		match := re.FindStringSubmatch(line)
-		if len(match) <= 1 {
+		if len(match) == 1 {
 			continue
 		}
 

pkg/commands/remote_branch.go

@@ -1,7 +1,19 @@
 package commands
 
+import (
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
 // Remote Branch : A git remote branch
 type RemoteBranch struct {
 	Name       string
+	Selected   bool
 	RemoteName string
 }
+
+// GetDisplayStrings returns the display string of branch
+func (b *RemoteBranch) GetDisplayStrings(isFocused bool) []string {
+	displayName := utils.ColoredString(b.Name, GetBranchColor(b.Name))
+
+	return []string{displayName}
+}

pkg/commands/tag.go

@@ -4,3 +4,8 @@ package commands
 type Tag struct {
 	Name string
 }
+
+// GetDisplayStrings returns the display string of a remote
+func (r *Tag) GetDisplayStrings(isFocused bool) []string {
+	return []string{r.Name}
+}

pkg/config/app_config.go

@@ -247,7 +247,7 @@ func GetDefaultConfig() []byte {
   theme:
     lightTheme: false
     activeBorderColor:
-      - green
+      - white
       - bold
     inactiveBorderColor:
       - white

pkg/gui/branches_panel.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
@@ -58,6 +57,13 @@ func (gui *Gui) handleBranchSelect(g *gocui.Gui, v *gocui.View) error {
 
 func (gui *Gui) RenderSelectedBranchUpstreamDifferences() error {
 	return gui.newTask("branches", func(stop chan struct{}) error {
+		// here we tell the selected branch that it is selected.
+		// this is necessary for showing stats on a branch that is selected, because
+		// the displaystring function doesn't have access to gui state to tell if it's selected
+		for i, branch := range gui.State.Branches {
+			branch.Selected = i == gui.State.Panels.Branches.SelectedLine
+		}
+
 		branch := gui.getSelectedBranch()
 		branch.Pushables, branch.Pullables = gui.GitCommand.GetBranchUpstreamDifferenceCount(branch.Name)
 
@@ -67,10 +73,7 @@ func (gui *Gui) RenderSelectedBranchUpstreamDifferences() error {
 		default:
 		}
 
-		branchesView := gui.getBranchesView()
-		displayStrings := presentation.GetBranchListDisplayStrings(gui.State.Branches, gui.currentViewName() == "branches", gui.State.Panels.Branches.SelectedLine)
-		gui.renderDisplayStrings(branchesView, displayStrings)
-		return nil
+		return gui.renderListPanel(gui.getBranchesView(), gui.State.Branches)
 	})
 }
 

pkg/gui/commit_files_panel.go

@@ -4,7 +4,6 @@ import (
 	"github.com/go-errors/errors"
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 )
 
 func (gui *Gui) getSelectedCommitFile(g *gocui.Gui) *commands.CommitFile {
@@ -113,11 +112,11 @@ func (gui *Gui) refreshCommitFilesView() error {
 
 	gui.refreshSelectedLine(&gui.State.Panels.CommitFiles.SelectedLine, len(gui.State.CommitFiles))
 
-	commitsFileView := gui.getCommitFilesView()
-	displayStrings := presentation.GetCommitFileListDisplayStrings(gui.State.CommitFiles)
-	gui.renderDisplayStrings(commitsFileView, displayStrings)
+	if err := gui.renderListPanel(gui.getCommitFilesView(), gui.State.CommitFiles); err != nil {
+		return err
+	}
 
-	return gui.handleCommitFileSelect(gui.g, commitsFileView)
+	return gui.handleCommitFileSelect(gui.g, gui.getCommitFilesView())
 }
 
 func (gui *Gui) handleOpenOldCommitFile(g *gocui.Gui, v *gocui.View) error {

pkg/gui/commits_panel.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
@@ -601,8 +600,9 @@ func (gui *Gui) renderBranchCommitsWithSelection() error {
 	commitsView := gui.getCommitsView()
 
 	gui.refreshSelectedLine(&gui.State.Panels.Commits.SelectedLine, len(gui.State.Commits))
-	displayStrings := presentation.GetCommitListDisplayStrings(gui.State.Commits, gui.State.ScreenMode != SCREEN_NORMAL)
-	gui.renderDisplayStrings(commitsView, displayStrings)
+	if err := gui.renderListPanel(commitsView, gui.State.Commits); err != nil {
+		return err
+	}
 	if gui.g.CurrentView() == commitsView && commitsView.Context == "branch-commits" {
 		if err := gui.handleCommitSelect(gui.g, commitsView); err != nil {
 			return err
@@ -632,13 +632,7 @@ func (gui *Gui) switchCommitsPanelContext(context string) error {
 
 	commitsView.TabIndex = contextTabIndexMap[context]
 
-	return gui.refreshCommitsViewWithSelection()
-}
-
-func (gui *Gui) refreshCommitsViewWithSelection() error {
-	commitsView := gui.getCommitsView()
-
-	switch commitsView.Context {
+	switch context {
 	case "branch-commits":
 		return gui.renderBranchCommitsWithSelection()
 	case "reflog-commits":

pkg/gui/files_panel.go

@@ -12,7 +12,7 @@ import (
 
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
+	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
 // list panel functions
@@ -103,8 +103,14 @@ func (gui *Gui) refreshFiles() error {
 	}
 
 	gui.g.Update(func(g *gocui.Gui) error {
-		displayStrings := presentation.GetFileListDisplayStrings(gui.State.Files)
-		gui.renderDisplayStrings(filesView, displayStrings)
+
+		filesView.Clear()
+		isFocused := gui.g.CurrentView().Name() == "files"
+		list, err := utils.RenderList(gui.State.Files, isFocused)
+		if err != nil {
+			return err
+		}
+		fmt.Fprint(filesView, list)
 
 		if g.CurrentView() == filesView || (g.CurrentView() == gui.getMainView() && g.CurrentView().Context == "merging") {
 			newSelectedFile, _ := gui.getSelectedFile(gui.g)

pkg/gui/gui.go

@@ -24,7 +24,6 @@ import (
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
 	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 	"github.com/jesseduffield/lazygit/pkg/i18n"
 	"github.com/jesseduffield/lazygit/pkg/tasks"
 	"github.com/jesseduffield/lazygit/pkg/theme"
@@ -270,20 +269,12 @@ func NewGui(log *logrus.Entry, gitCommand *commands.GitCommand, oSCommand *comma
 
 func (gui *Gui) nextScreenMode(g *gocui.Gui, v *gocui.View) error {
 	gui.State.ScreenMode = utils.NextIntInCycle([]int{SCREEN_NORMAL, SCREEN_HALF, SCREEN_FULL}, gui.State.ScreenMode)
-	// commits render differently depending on whether we're in fullscreen more or not
-	if err := gui.refreshCommitsViewWithSelection(); err != nil {
-		return err
-	}
 
 	return nil
 }
 
 func (gui *Gui) prevScreenMode(g *gocui.Gui, v *gocui.View) error {
 	gui.State.ScreenMode = utils.PrevIntInCycle([]int{SCREEN_NORMAL, SCREEN_HALF, SCREEN_FULL}, gui.State.ScreenMode)
-	// commits render differently depending on whether we're in fullscreen more or not
-	if err := gui.refreshCommitsViewWithSelection(); err != nil {
-		return err
-	}
 
 	return nil
 }
@@ -383,8 +374,10 @@ func (gui *Gui) onFocusLost(v *gocui.View, newView *gocui.View) error {
 	case "branches":
 		if v.Context == "local-branches" {
 			// This stops the branches panel from showing the upstream/downstream changes to the selected branch, when it loses focus
-			displayStrings := presentation.GetBranchListDisplayStrings(gui.State.Branches, false, -1)
-			gui.renderDisplayStrings(gui.getBranchesView(), displayStrings)
+			// inside renderListPanel it checks to see if the panel has focus
+			if err := gui.renderListPanel(gui.getBranchesView(), gui.State.Branches); err != nil {
+				return err
+			}
 		}
 	case "main":
 		// if we have lost focus to a first-class panel, we need to do some cleanup

pkg/gui/presentation/branches.go

@@ -1,48 +0,0 @@
-package presentation
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/theme"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-func GetBranchListDisplayStrings(branches []*commands.Branch, isFocused bool, selectedLine int) [][]string {
-	lines := make([][]string, len(branches))
-
-	for i := range branches {
-		showUpstreamDifferences := isFocused && i == selectedLine
-		lines[i] = getBranchDisplayStrings(branches[i], showUpstreamDifferences)
-	}
-
-	return lines
-}
-
-// getBranchDisplayStrings returns the display string of branch
-func getBranchDisplayStrings(b *commands.Branch, showUpstreamDifferences bool) []string {
-	displayName := utils.ColoredString(b.Name, GetBranchColor(b.Name))
-	if showUpstreamDifferences && b.Pushables != "" && b.Pullables != "" {
-		displayName = fmt.Sprintf("%s ↑%s↓%s", displayName, b.Pushables, b.Pullables)
-	}
-
-	return []string{b.Recency, displayName}
-}
-
-// GetBranchColor branch color
-func GetBranchColor(name string) color.Attribute {
-	branchType := strings.Split(name, "/")[0]
-
-	switch branchType {
-	case "feature":
-		return color.FgGreen
-	case "bugfix":
-		return color.FgYellow
-	case "hotfix":
-		return color.FgRed
-	default:
-		return theme.DefaultTextColor
-	}
-}

pkg/gui/presentation/commit_files.go

@@ -1,35 +0,0 @@
-package presentation
-
-import (
-	"github.com/fatih/color"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/theme"
-)
-
-func GetCommitFileListDisplayStrings(branches []*commands.CommitFile) [][]string {
-	lines := make([][]string, len(branches))
-
-	for i := range branches {
-		lines[i] = getCommitFileDisplayStrings(branches[i])
-	}
-
-	return lines
-}
-
-// getCommitFileDisplayStrings returns the display string of branch
-func getCommitFileDisplayStrings(f *commands.CommitFile) []string {
-	yellow := color.New(color.FgYellow)
-	green := color.New(color.FgGreen)
-	defaultColor := color.New(theme.DefaultTextColor)
-
-	var colour *color.Color
-	switch f.Status {
-	case commands.UNSELECTED:
-		colour = defaultColor
-	case commands.WHOLE:
-		colour = green
-	case commands.PART:
-		colour = yellow
-	}
-	return []string{colour.Sprint(f.DisplayString)}
-}

pkg/gui/presentation/commits.go

@@ -1,126 +0,0 @@
-package presentation
-
-import (
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/theme"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-func GetCommitListDisplayStrings(commits []*commands.Commit, fullDescription bool) [][]string {
-	lines := make([][]string, len(commits))
-
-	var displayFunc func(*commands.Commit) []string
-	if fullDescription {
-		displayFunc = getFullDescriptionDisplayStringsForCommit
-	} else {
-		displayFunc = getDisplayStringsForCommit
-	}
-
-	for i := range commits {
-		lines[i] = displayFunc(commits[i])
-	}
-
-	return lines
-}
-
-func getFullDescriptionDisplayStringsForCommit(c *commands.Commit) []string {
-	red := color.New(color.FgRed)
-	yellow := color.New(color.FgYellow)
-	green := color.New(color.FgGreen)
-	blue := color.New(color.FgBlue)
-	cyan := color.New(color.FgCyan)
-	defaultColor := color.New(theme.DefaultTextColor)
-	magenta := color.New(color.FgMagenta)
-
-	// for some reason, setting the background to blue pads out the other commits
-	// horizontally. For the sake of accessibility I'm considering this a feature,
-	// not a bug
-	copied := color.New(color.FgCyan, color.BgBlue)
-
-	var shaColor *color.Color
-	switch c.Status {
-	case "unpushed":
-		shaColor = red
-	case "pushed":
-		shaColor = yellow
-	case "merged":
-		shaColor = green
-	case "rebasing":
-		shaColor = blue
-	case "reflog":
-		shaColor = blue
-	case "selected":
-		shaColor = magenta
-	default:
-		shaColor = defaultColor
-	}
-
-	if c.Copied {
-		shaColor = copied
-	}
-
-	tagString := ""
-	truncatedDate := utils.TruncateWithEllipsis(c.Date, 15)
-	secondColumnString := blue.Sprint(truncatedDate)
-	if c.Action != "" {
-		secondColumnString = cyan.Sprint(c.Action)
-	} else if c.ExtraInfo != "" {
-		tagColor := color.New(color.FgMagenta, color.Bold)
-		tagString = utils.ColoredStringDirect(c.ExtraInfo, tagColor) + " "
-	}
-
-	truncatedAuthor := utils.TruncateWithEllipsis(c.Author, 17)
-
-	return []string{shaColor.Sprint(c.Sha[:8]), secondColumnString, yellow.Sprint(truncatedAuthor), tagString + defaultColor.Sprint(c.Name)}
-}
-
-func getDisplayStringsForCommit(c *commands.Commit) []string {
-	red := color.New(color.FgRed)
-	yellow := color.New(color.FgYellow)
-	green := color.New(color.FgGreen)
-	blue := color.New(color.FgBlue)
-	cyan := color.New(color.FgCyan)
-	defaultColor := color.New(theme.DefaultTextColor)
-	magenta := color.New(color.FgMagenta)
-
-	// for some reason, setting the background to blue pads out the other commits
-	// horizontally. For the sake of accessibility I'm considering this a feature,
-	// not a bug
-	copied := color.New(color.FgCyan, color.BgBlue)
-
-	var shaColor *color.Color
-	switch c.Status {
-	case "unpushed":
-		shaColor = red
-	case "pushed":
-		shaColor = yellow
-	case "merged":
-		shaColor = green
-	case "rebasing":
-		shaColor = blue
-	case "reflog":
-		shaColor = blue
-	case "selected":
-		shaColor = magenta
-	default:
-		shaColor = defaultColor
-	}
-
-	if c.Copied {
-		shaColor = copied
-	}
-
-	actionString := ""
-	tagString := ""
-	if c.Action != "" {
-		actionString = cyan.Sprint(utils.WithPadding(c.Action, 7)) + " "
-	} else if len(c.Tags) > 0 {
-		tagColor := color.New(color.FgMagenta, color.Bold)
-		tagString = utils.ColoredStringDirect(strings.Join(c.Tags, " "), tagColor) + " "
-	}
-
-	return []string{shaColor.Sprint(c.Sha[:8]), actionString + tagString + defaultColor.Sprint(c.Name)}
-}

pkg/gui/presentation/files.go

@@ -1,36 +0,0 @@
-package presentation
-
-import (
-	"github.com/fatih/color"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-)
-
-func GetFileListDisplayStrings(files []*commands.File) [][]string {
-	lines := make([][]string, len(files))
-
-	for i := range files {
-		lines[i] = getFileDisplayStrings(files[i])
-	}
-
-	return lines
-}
-
-// getFileDisplayStrings returns the display string of branch
-func getFileDisplayStrings(f *commands.File) []string {
-	// potentially inefficient to be instantiating these color
-	// objects with each render
-	red := color.New(color.FgRed)
-	green := color.New(color.FgGreen)
-	if !f.Tracked && !f.HasStagedChanges {
-		return []string{red.Sprint(f.DisplayString)}
-	}
-
-	output := green.Sprint(f.DisplayString[0:1])
-	output += red.Sprint(f.DisplayString[1:3])
-	if f.HasUnstagedChanges {
-		output += red.Sprint(f.Name)
-	} else {
-		output += green.Sprint(f.Name)
-	}
-	return []string{output}
-}

pkg/gui/presentation/remote_branches.go

@@ -1,23 +0,0 @@
-package presentation
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-func GetRemoteBranchListDisplayStrings(branches []*commands.RemoteBranch) [][]string {
-	lines := make([][]string, len(branches))
-
-	for i := range branches {
-		lines[i] = getRemoteBranchDisplayStrings(branches[i])
-	}
-
-	return lines
-}
-
-// getRemoteBranchDisplayStrings returns the display string of branch
-func getRemoteBranchDisplayStrings(b *commands.RemoteBranch) []string {
-	displayName := utils.ColoredString(b.Name, GetBranchColor(b.Name))
-
-	return []string{displayName}
-}

pkg/gui/presentation/remotes.go

@@ -1,20 +0,0 @@
-package presentation
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/commands"
-)
-
-func GetRemoteListDisplayStrings(remotes []*commands.Remote) [][]string {
-	lines := make([][]string, len(remotes))
-
-	for i := range remotes {
-		lines[i] = getRemoteDisplayStrings(remotes[i])
-	}
-
-	return lines
-}
-
-// getRemoteDisplayStrings returns the display string of branch
-func getRemoteDisplayStrings(r *commands.Remote) []string {
-	return []string{r.Name}
-}

pkg/gui/presentation/stash_entries.go

@@ -1,20 +0,0 @@
-package presentation
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/commands"
-)
-
-func GetStashEntryListDisplayStrings(stashEntries []*commands.StashEntry) [][]string {
-	lines := make([][]string, len(stashEntries))
-
-	for i := range stashEntries {
-		lines[i] = getStashEntryDisplayStrings(stashEntries[i])
-	}
-
-	return lines
-}
-
-// getStashEntryDisplayStrings returns the display string of branch
-func getStashEntryDisplayStrings(s *commands.StashEntry) []string {
-	return []string{s.DisplayString}
-}

pkg/gui/presentation/tags.go

@@ -1,20 +0,0 @@
-package presentation
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/commands"
-)
-
-func GetTagListDisplayStrings(tags []*commands.Tag) [][]string {
-	lines := make([][]string, len(tags))
-
-	for i := range tags {
-		lines[i] = getTagDisplayStrings(tags[i])
-	}
-
-	return lines
-}
-
-// getTagDisplayStrings returns the display string of branch
-func getTagDisplayStrings(t *commands.Tag) []string {
-	return []string{t.Name}
-}

pkg/gui/rebase_options_panel.go

@@ -16,12 +16,10 @@ func (gui *Gui) handleCreateRebaseOptionsMenu(g *gocui.Gui, v *gocui.View) error
 
 	menuItems := make([]*menuItem, len(options))
 	for i, option := range options {
-		// note to self. Never, EVER, close over loop variables in a function
-		innerOption := option
 		menuItems[i] = &menuItem{
-			displayString: innerOption,
+			displayString: option,
 			onPress: func() error {
-				return gui.genericMergeCommand(innerOption)
+				return gui.genericMergeCommand(option)
 			},
 		}
 	}

pkg/gui/reflog_panel.go

@@ -3,7 +3,6 @@ package gui
 import (
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 )
 
 // list panel functions
@@ -67,8 +66,9 @@ func (gui *Gui) renderReflogCommitsWithSelection() error {
 	commitsView := gui.getCommitsView()
 
 	gui.refreshSelectedLine(&gui.State.Panels.ReflogCommits.SelectedLine, len(gui.State.ReflogCommits))
-	displayStrings := presentation.GetCommitListDisplayStrings(gui.State.ReflogCommits, gui.State.ScreenMode != SCREEN_NORMAL)
-	gui.renderDisplayStrings(commitsView, displayStrings)
+	if err := gui.renderListPanel(commitsView, gui.State.ReflogCommits); err != nil {
+		return err
+	}
 	if gui.g.CurrentView() == commitsView && commitsView.Context == "reflog-commits" {
 		if err := gui.handleReflogCommitSelect(gui.g, commitsView); err != nil {
 			return err

pkg/gui/remote_branches_panel.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 )
 
 // list panel functions
@@ -63,8 +62,9 @@ func (gui *Gui) renderRemoteBranchesWithSelection() error {
 	branchesView := gui.getBranchesView()
 
 	gui.refreshSelectedLine(&gui.State.Panels.RemoteBranches.SelectedLine, len(gui.State.RemoteBranches))
-	displayStrings := presentation.GetRemoteBranchListDisplayStrings(gui.State.RemoteBranches)
-	gui.renderDisplayStrings(branchesView, displayStrings)
+	if err := gui.renderListPanel(branchesView, gui.State.RemoteBranches); err != nil {
+		return err
+	}
 	if gui.g.CurrentView() == branchesView && branchesView.Context == "remote-branches" {
 		if err := gui.handleRemoteBranchSelect(gui.g, branchesView); err != nil {
 			return err

pkg/gui/remotes_panel.go

@@ -7,7 +7,6 @@ import (
 	"github.com/fatih/color"
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
@@ -81,10 +80,9 @@ func (gui *Gui) renderRemotesWithSelection() error {
 	branchesView := gui.getBranchesView()
 
 	gui.refreshSelectedLine(&gui.State.Panels.Remotes.SelectedLine, len(gui.State.Remotes))
-
-	displayStrings := presentation.GetRemoteListDisplayStrings(gui.State.Remotes)
-	gui.renderDisplayStrings(branchesView, displayStrings)
-
+	if err := gui.renderListPanel(branchesView, gui.State.Remotes); err != nil {
+		return err
+	}
 	if gui.g.CurrentView() == branchesView && branchesView.Context == "remotes" {
 		if err := gui.handleRemoteSelect(gui.g, branchesView); err != nil {
 			return err

pkg/gui/stash_panel.go

@@ -1,9 +1,11 @@
 package gui
 
 import (
+	"fmt"
+
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
+	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
 // list panel functions
@@ -54,12 +56,17 @@ func (gui *Gui) refreshStashEntries(g *gocui.Gui) error {
 
 		gui.refreshSelectedLine(&gui.State.Panels.Stash.SelectedLine, len(gui.State.StashEntries))
 
-		stashView := gui.getStashView()
+		isFocused := gui.g.CurrentView().Name() == "stash"
+		list, err := utils.RenderList(gui.State.StashEntries, isFocused)
+		if err != nil {
+			return err
+		}
 
-		displayStrings := presentation.GetStashEntryListDisplayStrings(gui.State.StashEntries)
-		gui.renderDisplayStrings(stashView, displayStrings)
+		v := gui.getStashView()
+		v.Clear()
+		fmt.Fprint(v, list)
 
-		if err := gui.resetOrigin(stashView); err != nil {
+		if err := gui.resetOrigin(v); err != nil {
 			return err
 		}
 		return nil

pkg/gui/status_panel.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/fatih/color"
 	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
+	"github.com/jesseduffield/lazygit/pkg/commands"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
@@ -35,7 +35,7 @@ func (gui *Gui) refreshStatus(g *gocui.Gui) error {
 
 		if len(branches) > 0 {
 			branch := branches[0]
-			name := utils.ColoredString(branch.Name, presentation.GetBranchColor(branch.Name))
+			name := utils.ColoredString(branch.Name, commands.GetBranchColor(branch.Name))
 			repoName := utils.GetCurrentRepoName()
 			status += fmt.Sprintf(" %s → %s", repoName, name)
 		}
@@ -136,14 +136,6 @@ func lazygitTitle() string {
 }
 
 func (gui *Gui) updateWorkTreeState() error {
-	rebaseMode, err := gui.GitCommand.RebaseMode()
-	if err != nil {
-		return err
-	}
-	if rebaseMode != "" {
-		gui.State.WorkingTreeState = "rebasing"
-		return nil
-	}
 	merging, err := gui.GitCommand.IsInMergeState()
 	if err != nil {
 		return err
@@ -152,6 +144,14 @@ func (gui *Gui) updateWorkTreeState() error {
 		gui.State.WorkingTreeState = "merging"
 		return nil
 	}
+	rebaseMode, err := gui.GitCommand.RebaseMode()
+	if err != nil {
+		return err
+	}
+	if rebaseMode != "" {
+		gui.State.WorkingTreeState = "rebasing"
+		return nil
+	}
 	gui.State.WorkingTreeState = "normal"
 	return nil
 }

pkg/gui/tags_panel.go

@@ -3,7 +3,6 @@ package gui
 import (
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 )
 
 // list panel functions
@@ -67,8 +66,9 @@ func (gui *Gui) renderTagsWithSelection() error {
 	branchesView := gui.getBranchesView()
 
 	gui.refreshSelectedLine(&gui.State.Panels.Tags.SelectedLine, len(gui.State.Tags))
-	displayStrings := presentation.GetTagListDisplayStrings(gui.State.Tags)
-	gui.renderDisplayStrings(branchesView, displayStrings)
+	if err := gui.renderListPanel(branchesView, gui.State.Tags); err != nil {
+		return err
+	}
 	if gui.g.CurrentView() == branchesView && branchesView.Context == "tags" {
 		if err := gui.handleTagSelect(gui.g, branchesView); err != nil {
 			return err
@@ -106,13 +106,7 @@ func (gui *Gui) handleDeleteTag(g *gocui.Gui, v *gocui.View) error {
 		if err := gui.GitCommand.DeleteTag(tag.Name); err != nil {
 			return gui.createErrorPanel(gui.g, err.Error())
 		}
-		if err := gui.refreshCommits(g); err != nil {
-			return gui.createErrorPanel(g, err.Error())
-		}
-		if err := gui.refreshTags(); err != nil {
-			return gui.createErrorPanel(g, err.Error())
-		}
-		return nil
+		return gui.refreshTags()
 	}, nil)
 }
 
@@ -143,13 +137,7 @@ func (gui *Gui) handleCreateTag(g *gocui.Gui, v *gocui.View) error {
 		if err := gui.GitCommand.CreateLightweightTag(v.Buffer(), ""); err != nil {
 			return gui.createErrorPanel(gui.g, err.Error())
 		}
-		if err := gui.refreshCommits(g); err != nil {
-			return gui.createErrorPanel(g, err.Error())
-		}
-		if err := gui.refreshTags(); err != nil {
-			return gui.createErrorPanel(g, err.Error())
-		}
-		return nil
+		return gui.refreshTags()
 	})
 }
 

pkg/gui/view_helpers.go

@@ -387,13 +387,18 @@ func (gui *Gui) refreshSelectedLine(line *int, total int) {
 	}
 }
 
-func (gui *Gui) renderDisplayStrings(v *gocui.View, displayStrings [][]string) {
+func (gui *Gui) renderListPanel(v *gocui.View, items interface{}) error {
 	gui.g.Update(func(g *gocui.Gui) error {
-		list := utils.RenderDisplayStrings(displayStrings)
+		isFocused := gui.g.CurrentView().Name() == v.Name()
+		list, err := utils.RenderList(items, isFocused)
+		if err != nil {
+			return gui.createErrorPanel(gui.g, err.Error())
+		}
 		v.Clear()
 		fmt.Fprint(v, list)
 		return nil
 	})
+	return nil
 }
 
 func (gui *Gui) renderPanelOptions() error {

pkg/utils/utils.go

@@ -6,10 +6,13 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"reflect"
 	"regexp"
 	"strings"
 	"time"
 
+	"github.com/go-errors/errors"
+
 	"github.com/fatih/color"
 )
 
@@ -111,6 +114,46 @@ func Min(x, y int) int {
 	return y
 }
 
+type Displayable interface {
+	GetDisplayStrings(bool) []string
+}
+
+// RenderList takes a slice of items, confirms they implement the Displayable
+// interface, then generates a list of their displaystrings to write to a panel's
+// buffer
+func RenderList(slice interface{}, isFocused bool) (string, error) {
+	s := reflect.ValueOf(slice)
+	if s.Kind() != reflect.Slice {
+		return "", errors.New("RenderList given a non-slice type")
+	}
+
+	displayables := make([]Displayable, s.Len())
+
+	for i := 0; i < s.Len(); i++ {
+		value, ok := s.Index(i).Interface().(Displayable)
+		if !ok {
+			return "", errors.New("item does not implement the Displayable interface")
+		}
+		displayables[i] = value
+	}
+
+	return renderDisplayableList(displayables, isFocused)
+}
+
+// renderDisplayableList takes a list of displayable items, obtains their display
+// strings via GetDisplayStrings() and then returns a single string containing
+// each item's string representation on its own line, with appropriate horizontal
+// padding between the item's own strings
+func renderDisplayableList(items []Displayable, isFocused bool) (string, error) {
+	if len(items) == 0 {
+		return "", nil
+	}
+
+	stringArrays := getDisplayStringArrays(items, isFocused)
+
+	return RenderDisplayStrings(stringArrays), nil
+}
+
 func RenderDisplayStrings(displayStringsArr [][]string) string {
 	padWidths := getPadWidths(displayStringsArr)
 	paddedDisplayStrings := getPaddedDisplayStrings(displayStringsArr, padWidths)
@@ -177,6 +220,14 @@ func displayArraysAligned(stringArrays [][]string) bool {
 	return true
 }
 
+func getDisplayStringArrays(displayables []Displayable, isFocused bool) [][]string {
+	stringArrays := make([][]string, len(displayables))
+	for i, item := range displayables {
+		stringArrays[i] = item.GetDisplayStrings(isFocused)
+	}
+	return stringArrays
+}
+
 // IncludesString if the list contains the string
 func IncludesString(list []string, a string) bool {
 	for _, b := range list {
@@ -297,22 +348,3 @@ func PrevIntInCycle(sl []int, current int) int {
 	}
 	return sl[len(sl)-1]
 }
-
-// TruncateWithEllipsis returns a string, truncated to a certain length, with an ellipsis
-func TruncateWithEllipsis(str string, limit int) string {
-	if limit == 1 && len(str) > 1 {
-		return "."
-	}
-
-	if limit == 2 && len(str) > 2 {
-		return ".."
-	}
-
-	ellipsis := "..."
-	if len(str) <= limit {
-		return str
-	}
-
-	remainingLength := limit - len(ellipsis)
-	return str[0:remainingLength] + "..."
-}

pkg/utils/utils_test.go

@@ -196,8 +196,166 @@ func TestDisplayArraysAligned(t *testing.T) {
 	}
 }
 
+type myDisplayable struct {
+	strings []string
+}
+
 type myStruct struct{}
 
+// GetDisplayStrings is a function.
+func (d *myDisplayable) GetDisplayStrings(isFocused bool) []string {
+	if isFocused {
+		return append(d.strings, "blah")
+	}
+	return d.strings
+}
+
+// TestGetDisplayStringArrays is a function.
+func TestGetDisplayStringArrays(t *testing.T) {
+	type scenario struct {
+		input     []Displayable
+		isFocused bool
+		expected  [][]string
+	}
+
+	scenarios := []scenario{
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"a", "b"}}),
+				Displayable(&myDisplayable{[]string{"c", "d"}}),
+			},
+			false,
+			[][]string{{"a", "b"}, {"c", "d"}},
+		},
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"a", "b"}}),
+				Displayable(&myDisplayable{[]string{"c", "d"}}),
+			},
+			true,
+			[][]string{{"a", "b", "blah"}, {"c", "d", "blah"}},
+		},
+	}
+
+	for _, s := range scenarios {
+		assert.EqualValues(t, s.expected, getDisplayStringArrays(s.input, s.isFocused))
+	}
+}
+
+// TestRenderDisplayableList is a function.
+func TestRenderDisplayableList(t *testing.T) {
+	type scenario struct {
+		input                []Displayable
+		isFocused            bool
+		expectedString       string
+		expectedErrorMessage string
+	}
+
+	scenarios := []scenario{
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{}}),
+				Displayable(&myDisplayable{[]string{}}),
+			},
+			false,
+			"\n",
+			"",
+		},
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"aa", "b"}}),
+				Displayable(&myDisplayable{[]string{"c", "d"}}),
+			},
+			false,
+			"aa b\nc  d",
+			"",
+		},
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"a"}}),
+				Displayable(&myDisplayable{[]string{"b", "c"}}),
+			},
+			false,
+			"a \nb c",
+			"",
+		},
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"a"}}),
+				Displayable(&myDisplayable{[]string{"b"}}),
+			},
+			true,
+			"a blah\nb blah",
+			"",
+		},
+	}
+
+	for _, s := range scenarios {
+		str, err := renderDisplayableList(s.input, s.isFocused)
+		assert.EqualValues(t, s.expectedString, str)
+		if s.expectedErrorMessage != "" {
+			assert.EqualError(t, err, s.expectedErrorMessage)
+		} else {
+			assert.NoError(t, err)
+		}
+	}
+}
+
+// TestRenderList is a function.
+func TestRenderList(t *testing.T) {
+	type scenario struct {
+		input                interface{}
+		isFocused            bool
+		expectedString       string
+		expectedErrorMessage string
+	}
+
+	scenarios := []scenario{
+		{
+			[]*myDisplayable{
+				{[]string{"aa", "b"}},
+				{[]string{"c", "d"}},
+			},
+			false,
+			"aa b\nc  d",
+			"",
+		},
+		{
+			[]*myStruct{
+				{},
+				{},
+			},
+			false,
+			"",
+			"item does not implement the Displayable interface",
+		},
+		{
+			&myStruct{},
+			false,
+			"",
+			"RenderList given a non-slice type",
+		},
+		{
+			[]*myDisplayable{
+				{[]string{"a"}},
+			},
+			true,
+			"a blah",
+			"",
+		},
+	}
+
+	for _, s := range scenarios {
+		str, err := RenderList(s.input, s.isFocused)
+		assert.EqualValues(t, s.expectedString, str)
+		if s.expectedErrorMessage != "" {
+			assert.EqualError(t, err, s.expectedErrorMessage)
+		} else {
+			assert.NoError(t, err)
+		}
+	}
+}
+
 // TestGetPaddedDisplayStrings is a function.
 func TestGetPaddedDisplayStrings(t *testing.T) {
 	type scenario struct {