Merge pull request #301 from rozuur/master

Initial version of delete named branch added

pkg/commands/commit.go

@@ -9,17 +9,21 @@ type Commit struct {
 	Sha           string
 	Name          string
 	Pushed        bool
+	Merged        bool
 	DisplayString string
 }
 
 func (c *Commit) GetDisplayStrings() []string {
 	red := color.New(color.FgRed)
-	yellow := color.New(color.FgYellow)
+	yellow := color.New(color.FgGreen)
+	green := color.New(color.FgYellow)
 	white := color.New(color.FgWhite)
 
 	shaColor := yellow
 	if c.Pushed {
 		shaColor = red
+	} else if !c.Merged {
+		shaColor = green
 	}
 
 	return []string{shaColor.Sprint(c.Sha), white.Sprint(c.Name)}

pkg/commands/git.go

@@ -221,11 +221,11 @@ func (c *GitCommand) ResetHard() error {
 // UpstreamDifferenceCount checks how many pushables/pullables there are for the
 // current branch
 func (c *GitCommand) UpstreamDifferenceCount() (string, string) {
-	pushableCount, err := c.OSCommand.RunCommandWithOutput("git rev-list @{u}..head --count")
+	pushableCount, err := c.OSCommand.RunCommandWithOutput("git rev-list @{u}..HEAD --count")
 	if err != nil {
 		return "?", "?"
 	}
-	pullableCount, err := c.OSCommand.RunCommandWithOutput("git rev-list head..@{u} --count")
+	pullableCount, err := c.OSCommand.RunCommandWithOutput("git rev-list HEAD..@{u} --count")
 	if err != nil {
 		return "?", "?"
 	}
@@ -236,7 +236,7 @@ func (c *GitCommand) UpstreamDifferenceCount() (string, string) {
 // to the remote branch of the current branch, a map is returned to ease look up
 func (c *GitCommand) GetCommitsToPush() map[string]bool {
 	pushables := map[string]bool{}
-	o, err := c.OSCommand.RunCommandWithOutput("git rev-list @{u}..head --abbrev-commit")
+	o, err := c.OSCommand.RunCommandWithOutput("git rev-list @{u}..HEAD --abbrev-commit")
 	if err != nil {
 		return pushables
 	}
@@ -267,6 +267,14 @@ func (c *GitCommand) NewBranch(name string) error {
 	return c.OSCommand.RunCommand(fmt.Sprintf("git checkout -b %s", name))
 }
 
+func (c *GitCommand) CurrentBranchName() (string, error) {
+	output, err := c.OSCommand.RunCommandWithOutput("git symbolic-ref --short HEAD")
+	if err != nil {
+		return "", err
+	}
+	return utils.TrimTrailingNewline(output), nil
+}
+
 // DeleteBranch delete branch
 func (c *GitCommand) DeleteBranch(branch string, force bool) error {
 	command := "git branch -d"
@@ -306,8 +314,12 @@ func (c *GitCommand) usingGpg() bool {
 }
 
 // Commit commits to git
-func (c *GitCommand) Commit(message string) (*exec.Cmd, error) {
-	command := fmt.Sprintf("git commit -m %s", c.OSCommand.Quote(message))
+func (c *GitCommand) Commit(message string, amend bool) (*exec.Cmd, error) {
+	amendParam := ""
+	if amend {
+		amendParam = " --amend"
+	}
+	command := fmt.Sprintf("git commit%s -m %s", amendParam, c.OSCommand.Quote(message))
 	if c.usingGpg() {
 		return c.OSCommand.PrepareSubProcess(c.OSCommand.Platform.shell, c.OSCommand.Platform.shellArg, command), nil
 	}
@@ -460,24 +472,63 @@ func (c *GitCommand) GetBranchGraph(branchName string) (string, error) {
 	return c.OSCommand.RunCommandWithOutput(fmt.Sprintf("git log --graph --color --abbrev-commit --decorate --date=relative --pretty=medium -100 %s", branchName))
 }
 
+func (c *GitCommand) getMergeBase() (string, error) {
+	currentBranch, err := c.CurrentBranchName()
+	if err != nil {
+		return "", err
+	}
+
+	baseBranch := "master"
+	if strings.HasPrefix(currentBranch, "feature/") {
+		baseBranch = "develop"
+	}
+
+	output, err := c.OSCommand.RunCommandWithOutput(fmt.Sprintf("git merge-base HEAD %s", baseBranch))
+	if err != nil {
+		// swallowing error because it's not a big deal; probably because there are no commits yet
+		c.Log.Error(err)
+	}
+	return output, nil
+}
+
 // GetCommits obtains the commits of the current branch
-func (c *GitCommand) GetCommits() []*Commit {
+func (c *GitCommand) GetCommits() ([]*Commit, error) {
 	pushables := c.GetCommitsToPush()
 	log := c.GetLog()
-	commits := []*Commit{}
+
+	lines := utils.SplitLines(log)
+	commits := make([]*Commit, len(lines))
 	// now we can split it up and turn it into commits
-	for _, line := range utils.SplitLines(log) {
+	for i, line := range lines {
 		splitLine := strings.Split(line, " ")
 		sha := splitLine[0]
 		_, pushed := pushables[sha]
-		commits = append(commits, &Commit{
+		commits[i] = &Commit{
 			Sha:           sha,
 			Name:          strings.Join(splitLine[1:], " "),
 			Pushed:        pushed,
 			DisplayString: strings.Join(splitLine, " "),
-		})
+		}
 	}
-	return commits
+	return c.setCommitMergedStatuses(commits)
+}
+
+func (c *GitCommand) setCommitMergedStatuses(commits []*Commit) ([]*Commit, error) {
+	ancestor, err := c.getMergeBase()
+	if err != nil {
+		return nil, err
+	}
+	if ancestor == "" {
+		return commits, nil
+	}
+	passedAncestor := false
+	for i, commit := range commits {
+		if strings.HasPrefix(ancestor, commit.Sha) {
+			passedAncestor = true
+		}
+		commits[i].Merged = passedAncestor
+	}
+	return commits, nil
 }
 
 // GetLog gets the git log (currently limited to 30 commits for performance
@@ -500,26 +551,38 @@ func (c *GitCommand) Ignore(filename string) error {
 }
 
 // Show shows the diff of a commit
-func (c *GitCommand) Show(sha string) string {
-	result, err := c.OSCommand.RunCommandWithOutput("git show --color " + sha)
-	if err != nil {
-		panic(err)
-	}
-	return result
+func (c *GitCommand) Show(sha string) (string, error) {
+	return c.OSCommand.RunCommandWithOutput(fmt.Sprintf("git show --color %s", sha))
+}
+
+// GetRemoteURL returns current repo remote url
+func (c *GitCommand) GetRemoteURL() string {
+	url, _ := c.OSCommand.RunCommandWithOutput("git config --get remote.origin.url")
+	return utils.TrimTrailingNewline(url)
+}
+
+// CheckRemoteBranchExists Returns remote branch
+func (c *GitCommand) CheckRemoteBranchExists(branch *Branch) bool {
+	_, err := c.OSCommand.RunCommandWithOutput(fmt.Sprintf(
+		"git show-ref --verify -- refs/remotes/origin/%s",
+		branch.Name,
+	))
+
+	return err == nil
 }
 
 // Diff returns the diff of a file
 func (c *GitCommand) Diff(file *File) string {
 	cachedArg := ""
+	trackedArg := "--"
 	fileName := c.OSCommand.Quote(file.Name)
 	if file.HasStagedChanges && !file.HasUnstagedChanges {
 		cachedArg = "--cached"
 	}
-	trackedArg := "--"
 	if !file.Tracked && !file.HasStagedChanges {
 		trackedArg = "--no-index /dev/null"
 	}
-	command := fmt.Sprintf("%s %s %s %s", "git diff --color ", cachedArg, trackedArg, fileName)
+	command := fmt.Sprintf("git diff --color %s %s %s", cachedArg, trackedArg, fileName)
 
 	// for now we assume an error means the file was deleted
 	s, _ := c.OSCommand.RunCommandWithOutput(command)

pkg/commands/git_test.go

@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/jesseduffield/lazygit/pkg/test"
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	gogit "gopkg.in/src-d/go-git.v4"
@@ -562,7 +561,7 @@ func TestGitCommandUpstreamDifferentCount(t *testing.T) {
 		{
 			"Can't retrieve pullable count",
 			func(cmd string, args ...string) *exec.Cmd {
-				if args[1] == "head..@{u}" {
+				if args[1] == "HEAD..@{u}" {
 					return exec.Command("test")
 				}
 
@@ -576,7 +575,7 @@ func TestGitCommandUpstreamDifferentCount(t *testing.T) {
 		{
 			"Retrieve pullable and pushable count",
 			func(cmd string, args ...string) *exec.Cmd {
-				if args[1] == "head..@{u}" {
+				if args[1] == "HEAD..@{u}" {
 					return exec.Command("echo", "10")
 				}
 
@@ -890,7 +889,76 @@ func TestGitCommandCommit(t *testing.T) {
 			gitCmd := newDummyGitCommand()
 			gitCmd.getGlobalGitConfig = s.getGlobalGitConfig
 			gitCmd.OSCommand.command = s.command
-			s.test(gitCmd.Commit("test"))
+			s.test(gitCmd.Commit("test", false))
+		})
+	}
+}
+
+func TestGitCommandCommitAmendFromFiles(t *testing.T) {
+	type scenario struct {
+		testName           string
+		command            func(string, ...string) *exec.Cmd
+		getGlobalGitConfig func(string) (string, error)
+		test               func(*exec.Cmd, error)
+	}
+
+	scenarios := []scenario{
+		{
+			"Amend commit using gpg",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "bash", cmd)
+				assert.EqualValues(t, []string{"-c", `git commit --amend -m 'test'`}, args)
+
+				return exec.Command("echo")
+			},
+			func(string) (string, error) {
+				return "true", nil
+			},
+			func(cmd *exec.Cmd, err error) {
+				assert.NotNil(t, cmd)
+				assert.Nil(t, err)
+			},
+		},
+		{
+			"Amend commit without using gpg",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"commit", "--amend", "-m", "test"}, args)
+
+				return exec.Command("echo")
+			},
+			func(string) (string, error) {
+				return "false", nil
+			},
+			func(cmd *exec.Cmd, err error) {
+				assert.Nil(t, cmd)
+				assert.Nil(t, err)
+			},
+		},
+		{
+			"Amend commit without using gpg with an error",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"commit", "--amend", "-m", "test"}, args)
+
+				return exec.Command("test")
+			},
+			func(string) (string, error) {
+				return "false", nil
+			},
+			func(cmd *exec.Cmd, err error) {
+				assert.Nil(t, cmd)
+				assert.Error(t, err)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			gitCmd := newDummyGitCommand()
+			gitCmd.getGlobalGitConfig = s.getGlobalGitConfig
+			gitCmd.OSCommand.command = s.command
+			s.test(gitCmd.Commit("test", true))
 		})
 	}
 }
@@ -1421,6 +1489,19 @@ func TestGitCommandRemoveFile(t *testing.T) {
 	}
 }
 
+func TestGitCommandShow(t *testing.T) {
+	gitCmd := newDummyGitCommand()
+	gitCmd.OSCommand.command = func(cmd string, args ...string) *exec.Cmd {
+		assert.EqualValues(t, "git", cmd)
+		assert.EqualValues(t, []string{"show", "--color", "456abcde"}, args)
+
+		return exec.Command("echo")
+	}
+
+	_, err := gitCmd.Show("456abcde")
+	assert.NoError(t, err)
+}
+
 func TestGitCommandCheckout(t *testing.T) {
 	type scenario struct {
 		testName string
@@ -1484,7 +1565,7 @@ func TestGitCommandGetCommits(t *testing.T) {
 	type scenario struct {
 		testName string
 		command  func(string, ...string) *exec.Cmd
-		test     func([]*Commit)
+		test     func([]*Commit, error)
 	}
 
 	scenarios := []scenario{
@@ -1495,16 +1576,23 @@ func TestGitCommandGetCommits(t *testing.T) {
 
 				switch args[0] {
 				case "rev-list":
-					assert.EqualValues(t, []string{"rev-list", "@{u}..head", "--abbrev-commit"}, args)
+					assert.EqualValues(t, []string{"rev-list", "@{u}..HEAD", "--abbrev-commit"}, args)
 					return exec.Command("echo")
 				case "log":
 					assert.EqualValues(t, []string{"log", "--oneline", "-30"}, 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) {
+			func(commits []*Commit, err error) {
+				assert.NoError(t, err)
 				assert.Len(t, commits, 0)
 			},
 		},
@@ -1515,33 +1603,70 @@ func TestGitCommandGetCommits(t *testing.T) {
 
 				switch args[0] {
 				case "rev-list":
-					assert.EqualValues(t, []string{"rev-list", "@{u}..head", "--abbrev-commit"}, args)
+					assert.EqualValues(t, []string{"rev-list", "@{u}..HEAD", "--abbrev-commit"}, args)
 					return exec.Command("echo", "8a2bb0e")
 				case "log":
 					assert.EqualValues(t, []string{"log", "--oneline", "-30"}, 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) {
+			func(commits []*Commit, err error) {
+				assert.NoError(t, err)
 				assert.Len(t, commits, 2)
 				assert.EqualValues(t, []*Commit{
 					{
 						Sha:           "8a2bb0e",
 						Name:          "commit 1",
 						Pushed:        true,
+						Merged:        false,
 						DisplayString: "8a2bb0e commit 1",
 					},
 					{
 						Sha:           "78976bc",
 						Name:          "commit 2",
 						Pushed:        false,
+						Merged:        true,
 						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", "--oneline", "-30"}, 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")
+				}
+
+				return nil
+			},
+			func(commits []*Commit, err error) {
+				assert.Error(t, err)
+				assert.Len(t, commits, 0)
+			},
+		},
 	}
 
 	for _, s := range scenarios {
@@ -1553,97 +1678,238 @@ func TestGitCommandGetCommits(t *testing.T) {
 	}
 }
 
-func TestGitCommandDiff(t *testing.T) {
-	gitCommand := newDummyGitCommand()
-	assert.NoError(t, test.GenerateRepo("lots_of_diffs.sh"))
+func TestGitCommandGetLog(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		test     func(string)
+	}
 
-	files := []*File{
+	scenarios := []scenario{
 		{
-			Name:               "deleted_staged",
-			HasStagedChanges:   false,
-			HasUnstagedChanges: true,
-			Tracked:            true,
-			Deleted:            true,
-			HasMergeConflicts:  false,
-			DisplayString:      " D deleted_staged",
+			"Retrieves logs",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"log", "--oneline", "-30"}, 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)
+			},
 		},
 		{
-			Name:               "file with space staged",
-			HasStagedChanges:   true,
-			HasUnstagedChanges: false,
-			Tracked:            false,
-			Deleted:            false,
-			HasMergeConflicts:  false,
-			DisplayString:      "A  \"file with space staged\"",
-		},
-		{
-			Name:               "file with space unstaged",
-			HasStagedChanges:   false,
-			HasUnstagedChanges: true,
-			Tracked:            false,
-			Deleted:            false,
-			HasMergeConflicts:  false,
-			DisplayString:      "?? file with space unstaged",
-		},
-		{
-			Name:               "modified_unstaged",
-			HasStagedChanges:   true,
-			HasUnstagedChanges: false,
-			Tracked:            true,
-			Deleted:            false,
-			HasMergeConflicts:  false,
-			DisplayString:      "M  modified_unstaged",
-		},
-		{
-			Name:               "modified_staged",
-			HasStagedChanges:   false,
-			HasUnstagedChanges: true,
-			Tracked:            true,
-			Deleted:            false,
-			HasMergeConflicts:  false,
-			DisplayString:      " M modified_staged",
-		},
-		{
-			Name:               "renamed_before -> renamed_after",
-			HasStagedChanges:   true,
-			HasUnstagedChanges: false,
-			Tracked:            true,
-			Deleted:            false,
-			HasMergeConflicts:  false,
-			DisplayString:      "R  renamed_before -> renamed_after",
-		},
-		{
-			Name:               "untracked_unstaged",
-			HasStagedChanges:   false,
-			HasUnstagedChanges: true,
-			Tracked:            false,
-			Deleted:            false,
-			HasMergeConflicts:  false,
-			DisplayString:      "?? untracked_unstaged",
-		},
-		{
-			Name:               "untracked_staged",
-			HasStagedChanges:   true,
-			HasUnstagedChanges: false,
-			Tracked:            false,
-			Deleted:            false,
-			HasMergeConflicts:  false,
-			DisplayString:      "A  untracked_staged",
-		},
-		{
-			Name:               "master",
-			HasStagedChanges:   false,
-			HasUnstagedChanges: true,
-			Tracked:            false,
-			Deleted:            false,
-			HasMergeConflicts:  false,
-			DisplayString:      "?? master",
+			"An error occurred when retrieving logs",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"log", "--oneline", "-30"}, args)
+				return exec.Command("test")
+			},
+			func(output string) {
+				assert.Empty(t, output)
+			},
 		},
 	}
 
-	for _, file := range files {
-		t.Run(file.Name, func(t *testing.T) {
-			assert.NotContains(t, gitCommand.Diff(file), "error")
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			gitCmd := newDummyGitCommand()
+			gitCmd.OSCommand.command = s.command
+			s.test(gitCmd.GetLog())
+		})
+	}
+}
+
+func TestGitCommandDiff(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		file     *File
+	}
+
+	scenarios := []scenario{
+		{
+			"Default case",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"diff", "--color", "--", "test.txt"}, args)
+
+				return exec.Command("echo")
+			},
+			&File{
+				Name:             "test.txt",
+				HasStagedChanges: false,
+				Tracked:          true,
+			},
+		},
+		{
+			"All changes staged",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"diff", "--color", "--cached", "--", "test.txt"}, args)
+
+				return exec.Command("echo")
+			},
+			&File{
+				Name:               "test.txt",
+				HasStagedChanges:   true,
+				HasUnstagedChanges: false,
+				Tracked:            true,
+			},
+		},
+		{
+			"File not tracked and file has no staged changes",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"diff", "--color", "--no-index", "/dev/null", "test.txt"}, args)
+
+				return exec.Command("echo")
+			},
+			&File{
+				Name:             "test.txt",
+				HasStagedChanges: false,
+				Tracked:          false,
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			gitCmd := newDummyGitCommand()
+			gitCmd.OSCommand.command = s.command
+			gitCmd.Diff(s.file)
+		})
+	}
+}
+
+func TestGitCommandGetMergeBase(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		test     func(string, error)
+	}
+
+	scenarios := []scenario{
+		{
+			"swallows an error if the call to merge-base returns an error",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "master")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("test")
+				}
+				return nil
+			},
+			func(output string, err error) {
+				assert.NoError(t, err)
+				assert.EqualValues(t, "", output)
+			},
+		},
+		{
+			"returns the commit when master",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "master")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("echo", "blah")
+				}
+				return nil
+			},
+			func(output string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, "blah\n", output)
+			},
+		},
+		{
+			"checks against develop when a feature branch",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "feature/test")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "develop"}, args)
+					return exec.Command("echo", "blah")
+				}
+				return nil
+			},
+			func(output string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, "blah\n", output)
+			},
+		},
+		{
+			"bubbles up error if there is one",
+			func(cmd string, args ...string) *exec.Cmd {
+				return exec.Command("test")
+			},
+			func(output string, err error) {
+				assert.Error(t, err)
+				assert.Equal(t, "", output)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			gitCmd := newDummyGitCommand()
+			gitCmd.OSCommand.command = s.command
+			s.test(gitCmd.getMergeBase())
+		})
+	}
+}
+
+func TestGitCommandCurrentBranchName(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		test     func(string, error)
+	}
+
+	scenarios := []scenario{
+		{
+			"says we are on the master branch if we are",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.Equal(t, "git", cmd)
+				assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+				return exec.Command("echo", "master")
+			},
+			func(output string, err error) {
+				assert.NoError(t, err)
+				assert.EqualValues(t, "master", output)
+			},
+		},
+		{
+			"bubbles up error if there is one",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.Equal(t, "git", cmd)
+				assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+				return exec.Command("test")
+			},
+			func(output string, err error) {
+				assert.Error(t, err)
+				assert.EqualValues(t, "", output)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			gitCmd := newDummyGitCommand()
+			gitCmd.OSCommand.command = s.command
+			s.test(gitCmd.CurrentBranchName())
 		})
 	}
 }

pkg/commands/os.go

@@ -8,9 +8,7 @@ import (
 
 	"github.com/jesseduffield/lazygit/pkg/config"
 	"github.com/jesseduffield/lazygit/pkg/utils"
-
 	"github.com/mgutz/str"
-
 	"github.com/sirupsen/logrus"
 	gitconfig "github.com/tcnksm/go-gitconfig"
 )
@@ -22,6 +20,7 @@ type Platform struct {
 	shellArg             string
 	escapedQuote         string
 	openCommand          string
+	openLinkCommand      string
 	fallbackEscapedQuote string
 }
 
@@ -110,6 +109,18 @@ func (c *OSCommand) OpenFile(filename string) error {
 	return err
 }
 
+// OpenFile opens a file with the given
+func (c *OSCommand) OpenLink(link string) error {
+	commandTemplate := c.Config.GetUserConfig().GetString("os.openLinkCommand")
+	templateValues := map[string]string{
+		"link": c.Quote(link),
+	}
+
+	command := utils.ResolvePlaceholderString(commandTemplate, templateValues)
+	err := c.RunCommand(command)
+	return err
+}
+
 // EditFile opens a file in a subprocess using whatever editor is available,
 // falling back to core.editor, VISUAL, EDITOR, then vi
 func (c *OSCommand) EditFile(filename string) (*exec.Cmd, error) {

pkg/commands/os_default_platform.go

@@ -13,6 +13,7 @@ func getPlatform() *Platform {
 		shellArg:             "-c",
 		escapedQuote:         "'",
 		openCommand:          "open {{filename}}",
+		openLinkCommand:      "open {{link}}",
 		fallbackEscapedQuote: "\"",
 	}
 }

pkg/commands/pull_request.go

@@ -0,0 +1,105 @@
+package commands
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+// Service is a service that repository is on (Github, Bitbucket, ...)
+type Service struct {
+	Name           string
+	PullRequestURL string
+}
+
+// PullRequest opens a link in browser to create new pull request
+// with selected branch
+type PullRequest struct {
+	GitServices []*Service
+	GitCommand  *GitCommand
+}
+
+// RepoInformation holds some basic information about the repo
+type RepoInformation struct {
+	Owner      string
+	Repository string
+}
+
+func getServices() []*Service {
+	return []*Service{
+		{
+			Name:           "github.com",
+			PullRequestURL: "https://github.com/%s/%s/compare/%s?expand=1",
+		},
+		{
+			Name:           "bitbucket.org",
+			PullRequestURL: "https://bitbucket.org/%s/%s/pull-requests/new?t=%s",
+		},
+		{
+			Name:           "gitlab.com",
+			PullRequestURL: "https://gitlab.com/%s/%s/merge_requests/new?merge_request[source_branch]=%s",
+		},
+	}
+}
+
+// NewPullRequest creates new instance of PullRequest
+func NewPullRequest(gitCommand *GitCommand) *PullRequest {
+	return &PullRequest{
+		GitServices: getServices(),
+		GitCommand:  gitCommand,
+	}
+}
+
+// Create opens link to new pull request in browser
+func (pr *PullRequest) Create(branch *Branch) error {
+	branchExistsOnRemote := pr.GitCommand.CheckRemoteBranchExists(branch)
+
+	if !branchExistsOnRemote {
+		return errors.New(pr.GitCommand.Tr.SLocalize("NoBranchOnRemote"))
+	}
+
+	repoURL := pr.GitCommand.GetRemoteURL()
+	var gitService *Service
+
+	for _, service := range pr.GitServices {
+		if strings.Contains(repoURL, service.Name) {
+			gitService = service
+			break
+		}
+	}
+
+	if gitService == nil {
+		return errors.New(pr.GitCommand.Tr.SLocalize("UnsupportedGitService"))
+	}
+
+	repoInfo := getRepoInfoFromURL(repoURL)
+
+	return pr.GitCommand.OSCommand.OpenLink(fmt.Sprintf(
+		gitService.PullRequestURL, repoInfo.Owner, repoInfo.Repository, branch.Name,
+	))
+}
+
+func getRepoInfoFromURL(url string) *RepoInformation {
+	isHTTP := strings.HasPrefix(url, "http")
+
+	if isHTTP {
+		splits := strings.Split(url, "/")
+		owner := splits[len(splits)-2]
+		repo := strings.TrimSuffix(splits[len(splits)-1], ".git")
+
+		return &RepoInformation{
+			Owner:      owner,
+			Repository: repo,
+		}
+	}
+
+	tmpSplit := strings.Split(url, ":")
+	splits := strings.Split(tmpSplit[1], "/")
+	owner := splits[0]
+	repo := strings.TrimSuffix(splits[1], ".git")
+
+	return &RepoInformation{
+		Owner:      owner,
+		Repository: repo,
+	}
+}

pkg/commands/pull_request_test.go

@@ -0,0 +1,152 @@
+package commands
+
+import (
+	"os/exec"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetRepoInfoFromURL(t *testing.T) {
+	type scenario struct {
+		testName string
+		repoURL  string
+		test     func(*RepoInformation)
+	}
+
+	scenarios := []scenario{
+		{
+			"Returns repository information for git remote url",
+			"git@github.com:petersmith/super_calculator",
+			func(repoInfo *RepoInformation) {
+				assert.EqualValues(t, repoInfo.Owner, "petersmith")
+				assert.EqualValues(t, repoInfo.Repository, "super_calculator")
+			},
+		},
+		{
+			"Returns repository information for http remote url",
+			"https://my_username@bitbucket.org/johndoe/social_network.git",
+			func(repoInfo *RepoInformation) {
+				assert.EqualValues(t, repoInfo.Owner, "johndoe")
+				assert.EqualValues(t, repoInfo.Repository, "social_network")
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			s.test(getRepoInfoFromURL(s.repoURL))
+		})
+	}
+}
+
+func TestCreatePullRequest(t *testing.T) {
+	type scenario struct {
+		testName string
+		branch   *Branch
+		command  func(string, ...string) *exec.Cmd
+		test     func(err error)
+	}
+
+	scenarios := []scenario{
+		{
+			"Opens a link to new pull request on bitbucket",
+			&Branch{
+				Name: "feature/profile-page",
+			},
+			func(cmd string, args ...string) *exec.Cmd {
+				// Handle git remote url call
+				if strings.HasPrefix(cmd, "git") {
+					return exec.Command("echo", "git@bitbucket.org:johndoe/social_network.git")
+				}
+
+				assert.Equal(t, cmd, "open")
+				assert.Equal(t, args, []string{"https://bitbucket.org/johndoe/social_network/pull-requests/new?t=feature/profile-page"})
+				return exec.Command("echo")
+			},
+			func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"Opens a link to new pull request on bitbucket with http remote url",
+			&Branch{
+				Name: "feature/events",
+			},
+			func(cmd string, args ...string) *exec.Cmd {
+				// Handle git remote url call
+				if strings.HasPrefix(cmd, "git") {
+					return exec.Command("echo", "https://my_username@bitbucket.org/johndoe/social_network.git")
+				}
+
+				assert.Equal(t, cmd, "open")
+				assert.Equal(t, args, []string{"https://bitbucket.org/johndoe/social_network/pull-requests/new?t=feature/events"})
+				return exec.Command("echo")
+			},
+			func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"Opens a link to new pull request on github",
+			&Branch{
+				Name: "feature/sum-operation",
+			},
+			func(cmd string, args ...string) *exec.Cmd {
+				// Handle git remote url call
+				if strings.HasPrefix(cmd, "git") {
+					return exec.Command("echo", "git@github.com:peter/calculator.git")
+				}
+
+				assert.Equal(t, cmd, "open")
+				assert.Equal(t, args, []string{"https://github.com/peter/calculator/compare/feature/sum-operation?expand=1"})
+				return exec.Command("echo")
+			},
+			func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"Opens a link to new pull request on gitlab",
+			&Branch{
+				Name: "feature/ui",
+			},
+			func(cmd string, args ...string) *exec.Cmd {
+				// Handle git remote url call
+				if strings.HasPrefix(cmd, "git") {
+					return exec.Command("echo", "git@gitlab.com:peter/calculator.git")
+				}
+
+				assert.Equal(t, cmd, "open")
+				assert.Equal(t, args, []string{"https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/ui"})
+				return exec.Command("echo")
+			},
+			func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			"Throws an error if git service is unsupported",
+			&Branch{
+				Name: "feature/divide-operation",
+			},
+			func(cmd string, args ...string) *exec.Cmd {
+				return exec.Command("echo", "git@something.com:peter/calculator.git")
+			},
+			func(err error) {
+				assert.Error(t, err)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			gitCommand := newDummyGitCommand()
+			gitCommand.OSCommand.command = s.command
+			gitCommand.OSCommand.Config.GetUserConfig().Set("os.openLinkCommand", "open {{link}}")
+			dummyPullRequest := NewPullRequest(gitCommand)
+			s.test(dummyPullRequest.Create(s.branch))
+		})
+	}
+}

pkg/config/config_default_platform.go

@@ -6,5 +6,6 @@ package config
 func GetPlatformDefaultConfig() []byte {
 	return []byte(
 		`os:
-  openCommand: 'open {{filename}}'`)
+  openCommand: 'open {{filename}}'
+  openLinkCommand: 'open {{link}}'`)
 }

pkg/config/config_linux.go

@@ -4,5 +4,6 @@ package config
 func GetPlatformDefaultConfig() []byte {
 	return []byte(
 		`os:
-  openCommand: 'sh -c "xdg-open {{filename}} >/dev/null"'`)
+  openCommand: 'sh -c "xdg-open {{filename}} >/dev/null"'
+  openLinkCommand: 'sh -c "xdg-open {{link}} >/dev/null"'`)
 }

pkg/config/config_windows.go

@@ -4,5 +4,6 @@ package config
 func GetPlatformDefaultConfig() []byte {
 	return []byte(
 		`os:
-  openCommand: 'cmd /c "start "" {{filename}}"'`)
+  openCommand: 'cmd /c "start "" {{filename}}"'
+  openLinkCommand: 'cmd /c "start "" {{link}}"'`)
 }

pkg/gui/branches_panel.go

@@ -22,6 +22,17 @@ func (gui *Gui) handleBranchPress(g *gocui.Gui, v *gocui.View) error {
 	return gui.refreshSidePanels(g)
 }
 
+func (gui *Gui) handleCreatePullRequestPress(g *gocui.Gui, v *gocui.View) error {
+	branch := gui.getSelectedBranch(gui.getBranchesView(g))
+	pullRequest := commands.NewPullRequest(gui.GitCommand)
+
+	if err := pullRequest.Create(branch); err != nil {
+		return gui.createErrorPanel(g, err.Error())
+	}
+
+	return nil
+}
+
 func (gui *Gui) handleForceCheckout(g *gocui.Gui, v *gocui.View) error {
 	branch := gui.getSelectedBranch(v)
 	message := gui.Tr.SLocalize("SureForceCheckout")
@@ -76,6 +87,10 @@ func (gui *Gui) deleteBranch(g *gocui.Gui, v *gocui.View, force bool) error {
 	if checkedOutBranch.Name == selectedBranch.Name {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("CantDeleteCheckOutBranch"))
 	}
+	return gui.deleteNamedBranch(g, v, selectedBranch, force)
+}
+
+func (gui *Gui) deleteNamedBranch(g *gocui.Gui, v *gocui.View, selectedBranch *commands.Branch, force bool) error {
 	title := gui.Tr.SLocalize("DeleteBranch")
 	var messageId string
 	if force {
@@ -91,7 +106,12 @@ func (gui *Gui) deleteBranch(g *gocui.Gui, v *gocui.View, force bool) error {
 	)
 	return gui.createConfirmationPanel(g, v, title, message, func(g *gocui.Gui, v *gocui.View) error {
 		if err := gui.GitCommand.DeleteBranch(selectedBranch.Name, force); err != nil {
-			return gui.createErrorPanel(g, err.Error())
+			errMessage := err.Error()
+			if !force && strings.Contains(errMessage, "is not fully merged") {
+				return gui.deleteNamedBranch(g, v, selectedBranch, true)
+			} else {
+				return gui.createErrorPanel(g, errMessage)
+			}
 		}
 		return gui.refreshSidePanels(g)
 	}, nil)

pkg/gui/commit_message_panel.go

@@ -12,7 +12,7 @@ func (gui *Gui) handleCommitConfirm(g *gocui.Gui, v *gocui.View) error {
 	if message == "" {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("CommitWithoutMessageErr"))
 	}
-	sub, err := gui.GitCommand.Commit(message)
+	sub, err := gui.GitCommand.Commit(message, false)
 	if err != nil {
 		// TODO need to find a way to send through this error
 		if err != gui.Errors.ErrSubProcess {

pkg/gui/commits_panel.go

@@ -11,13 +11,19 @@ import (
 
 func (gui *Gui) refreshCommits(g *gocui.Gui) error {
 	g.Update(func(*gocui.Gui) error {
-		gui.State.Commits = gui.GitCommand.GetCommits()
+		commits, err := gui.GitCommand.GetCommits()
+		if err != nil {
+			return err
+		}
+
+		gui.State.Commits = commits
 		v, err := g.View("commits")
 		if err != nil {
-			panic(err)
+			return err
 		}
 
 		v.Clear()
+
 		list, err := utils.RenderList(gui.State.Commits)
 		if err != nil {
 			return err
@@ -68,7 +74,10 @@ func (gui *Gui) handleCommitSelect(g *gocui.Gui, v *gocui.View) error {
 		}
 		return gui.renderString(g, "main", gui.Tr.SLocalize("NoCommitsThisBranch"))
 	}
-	commitText := gui.GitCommand.Show(commit.Sha)
+	commitText, err := gui.GitCommand.Show(commit.Sha)
+	if err != nil {
+		return err
+	}
 	return gui.renderString(g, "main", commitText)
 }
 

pkg/gui/files_panel.go

@@ -211,6 +211,28 @@ func (gui *Gui) handleCommitPress(g *gocui.Gui, filesView *gocui.View) error {
 	return nil
 }
 
+func (gui *Gui) handleAmendCommitPress(g *gocui.Gui, filesView *gocui.View) error {
+	if len(gui.stagedFiles()) == 0 && !gui.State.HasMergeConflicts {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("NoStagedFilesToCommit"))
+	}
+	title := strings.Title(gui.Tr.SLocalize("AmendLastCommit"))
+	question := gui.Tr.SLocalize("SureToAmend")
+
+	if len(gui.State.Commits) == 0 {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("NoCommitToAmend"))
+	}
+
+	return gui.createConfirmationPanel(g, filesView, title, question, func(g *gocui.Gui, v *gocui.View) error {
+		lastCommitMsg := gui.State.Commits[0].Name
+		_, err := gui.GitCommand.Commit(lastCommitMsg, true)
+		if err != nil {
+			return gui.createErrorPanel(g, err.Error())
+		}
+
+		return gui.refreshSidePanels(g)
+	}, nil)
+}
+
 // handleCommitEditorPress - handle when the user wants to commit changes via
 // their editor rather than via the popup panel
 func (gui *Gui) handleCommitEditorPress(g *gocui.Gui, filesView *gocui.View) error {

pkg/gui/keybindings.go

@@ -125,6 +125,12 @@ func (gui *Gui) GetKeybindings() []*Binding {
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCommitPress,
 			Description: gui.Tr.SLocalize("CommitChanges"),
+		}, {
+			ViewName:    "files",
+			Key:         'A',
+			Modifier:    gocui.ModNone,
+			Handler:     gui.handleAmendCommitPress,
+			Description: gui.Tr.SLocalize("AmendLastCommit"),
 		}, {
 			ViewName:    "files",
 			Key:         'C',
@@ -182,7 +188,7 @@ func (gui *Gui) GetKeybindings() []*Binding {
 			Description: gui.Tr.SLocalize("stashFiles"),
 		}, {
 			ViewName:    "files",
-			Key:         'A',
+			Key:         'M',
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleAbortMerge,
 			Description: gui.Tr.SLocalize("abortMerge"),
@@ -271,6 +277,12 @@ func (gui *Gui) GetKeybindings() []*Binding {
 			Handler:     gui.handleBranchPress,
 			KeyReadable: "space",
 			Description: gui.Tr.SLocalize("checkout"),
+		}, {
+			ViewName:    "branches",
+			Key:         'o',
+			Modifier:    gocui.ModNone,
+			Handler:     gui.handleCreatePullRequestPress,
+			Description: gui.Tr.SLocalize("createPullRequest"),
 		}, {
 			ViewName:    "branches",
 			Key:         'c',
@@ -295,12 +307,6 @@ func (gui *Gui) GetKeybindings() []*Binding {
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleDeleteBranch,
 			Description: gui.Tr.SLocalize("deleteBranch"),
-		}, {
-			ViewName:    "branches",
-			Key:         'D',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleForceDeleteBranch,
-			Description: gui.Tr.SLocalize("forceDeleteBranch"),
 		}, {
 			ViewName:    "branches",
 			Key:         'm',

pkg/i18n/dutch.go

@@ -34,6 +34,15 @@ func addDutch(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "CommitChanges",
 			Other: "Commit Veranderingen",
+		}, &i18n.Message{
+			ID:    "AmendLastCommit",
+			Other: "wijzig laatste commit",
+		}, &i18n.Message{
+			ID:    "SureToAmend",
+			Other: "Weet je zeker dat je de laatste commit wilt wijzigen? U kunt het commit-bericht wijzigen vanuit het commits-paneel.",
+		}, &i18n.Message{
+			ID:    "NoCommitToAmend",
+			Other: "Er is geen verplichting om te wijzigen.",
 		}, &i18n.Message{
 			ID:    "CommitChangesWithEditor",
 			Other: "commit Veranderingen met de git editor",
@@ -370,6 +379,15 @@ func addDutch(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "ConfirmQuit",
 			Other: `Weet je zeker dat je dit programma wil sluiten?`,
+		}, &i18n.Message{
+			ID:    "UnsupportedGitService",
+			Other: `Niet-ondersteunde git-service`,
+		}, &i18n.Message{
+			ID:    "createPullRequest",
+			Other: `maak een pull-aanvraag`,
+		}, &i18n.Message{
+			ID:    "NoBranchOnRemote",
+			Other: `Deze tak bestaat niet op de afstandsbediening. U moet eerst op de afstandsbediening drukken.`,
 		},
 	)
 }

pkg/i18n/english.go

@@ -42,6 +42,15 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "CommitChanges",
 			Other: "commit changes",
+		}, &i18n.Message{
+			ID:    "AmendLastCommit",
+			Other: "amend last commit",
+		}, &i18n.Message{
+			ID:    "SureToAmend",
+			Other: "Are you sure you want to amend last commit? You can change commit message from commits panel.",
+		}, &i18n.Message{
+			ID:    "NoCommitToAmend",
+			Other: "There's no commit to amend.",
 		}, &i18n.Message{
 			ID:    "CommitChangesWithEditor",
 			Other: "commit changes using git editor",
@@ -167,7 +176,7 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 			Other: "Are you sure you want to delete the branch {{.selectedBranchName}}?",
 		}, &i18n.Message{
 			ID:    "ForceDeleteBranchMessage",
-			Other: "Are you sure you want to force delete the branch {{.selectedBranchName}}?",
+			Other: "{{.selectedBranchName}} is not fully merged. Are you sure you want to delete it?",
 		}, &i18n.Message{
 			ID:    "CantMergeBranchIntoItself",
 			Other: "You cannot merge a branch into itself",
@@ -393,6 +402,15 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "SwitchRepo",
 			Other: `switch to a recent repo`,
+		}, &i18n.Message{
+			ID:    "UnsupportedGitService",
+			Other: `Unsupported git service`,
+		}, &i18n.Message{
+			ID:    "createPullRequest",
+			Other: `create pull request`,
+		}, &i18n.Message{
+			ID:    "NoBranchOnRemote",
+			Other: `This branch doesn't exist on remote. You need to push it to remote first.`,
 		},
 	)
 }

pkg/i18n/polish.go

@@ -32,6 +32,15 @@ func addPolish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "CommitChanges",
 			Other: "commituj zmiany",
+		}, &i18n.Message{
+			ID:    "AmendLastCommit",
+			Other: "zmień ostatnie zatwierdzenie",
+		}, &i18n.Message{
+			ID:    "SureToAmend",
+			Other: "Czy na pewno chcesz zmienić ostatnie zatwierdzenie? Możesz zmienić komunikat zatwierdzenia z panelu zatwierdzeń.",
+		}, &i18n.Message{
+			ID:    "NoCommitToAmend",
+			Other: "Nie ma zobowiązania do zmiany.",
 		}, &i18n.Message{
 			ID:    "CommitChangesWithEditor",
 			Other: "commituj zmiany używając edytora z gita",
@@ -368,6 +377,15 @@ func addPolish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "ConfirmQuit",
 			Other: `Na pewno chcesz wyjść z programu?`,
+		}, &i18n.Message{
+			ID:    "UnsupportedGitService",
+			Other: `Nieobsługiwana usługa git`,
+		}, &i18n.Message{
+			ID:    "createPullRequest",
+			Other: `utwórz żądanie wyciągnięcia`,
+		}, &i18n.Message{
+			ID:    "NoBranchOnRemote",
+			Other: `Ta gałąź nie istnieje na zdalnym. Najpierw musisz go odepchnąć na odległość.`,
 		},
 	)
 }

test/repos/lots_of_diffs.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-set -ex; rm -rf repo; mkdir repo; cd repo
-
-git init
-git config user.email "test@example.com"
-git config user.name "Lazygit Tester"
-
-
-echo "deleted" > deleted_staged
-echo "deleted_unstaged" > deleted_unstaged
-echo "modified_staged" > modified_staged
-echo "modified_unstaged" > modified_unstaged
-echo "renamed" > renamed_before
-
-git add .
-git commit -m "files to delete"
-rm deleted_staged
-rm deleted_unstaged
-
-rm renamed_before
-echo "renamed" > renamed_after
-echo "more" >> modified_staged
-echo "more" >> modified_unstaged
-echo "untracked_staged" > untracked_staged
-echo "untracked_unstaged" > untracked_unstaged
-echo "blah" > "file with space staged"
-echo "blah" > "file with space unstaged"
-echo "same name as branch" > master
-
-git add deleted_staged
-git add modified_staged
-git add untracked_staged
-git add "file with space staged"
-git add renamed_before
-git add renamed_after