bump version to v0.1.68

.circleci/config.yml

@@ -1,73 +1,26 @@
+# Golang CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-go/ for more details
 version: 2
 jobs:
   build:
     docker:
-      - image: circleci/golang:1.11
+      # specify the version
+      - image: circleci/golang:1.9
+
+      # Specify service dependencies here if necessary
+      # CircleCI maintains a library of pre-built images
+      # documented at https://circleci.com/docs/2.0/circleci-images/
+      # - image: circleci/postgres:9.4
+
+    #### TEMPLATE_NOTE: go expects specific checkout path representing url
+    #### expecting it in the form of
+    ####   /go/src/github.com/circleci/go-tool
+    ####   /go/src/bitbucket.org/circleci/go-tool
     working_directory: /go/src/github.com/jesseduffield/lazygit
     steps:
       - checkout
-      - run:
-          name: Ensure go.mod file is up to date
-          command: |
-            export GO111MODULE=on
-            rm go.sum
-            mv go.mod /tmp/
-            go mod init
-            export GO111MODULE=auto
 
-            if [ $(diff /tmp/go.mod go.mod|wc -l) -gt 0 ]; then
-              diff /tmp/go.mod go.mod
-              exit 1;
-            fi
-      - run:
-          name: Run gofmt -s
-          command: |
-            if [ $(find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;|wc -l) -gt 0 ]; then
-             find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;
-             exit 1;
-            fi
-      - restore_cache:
-          keys:
-            - pkg-cache-{{ checksum "Gopkg.lock" }}-v3
-      - run:
-          name: Run tests
-          command: |
-            ./test.sh
-      - run:
-          name: Compile project on every platform
-          command: |
-            go get github.com/mitchellh/gox
-            gox -parallel 10 -os "linux freebsd netbsd windows" -osarch "darwin/i386 darwin/amd64"
-      - run:
-          name: Push on codecov result
-          command: |
-            bash <(curl -s https://codecov.io/bash)
-      - save_cache:
-          key: pkg-cache-{{ checksum "Gopkg.lock" }}-v3
-          paths:
-            - ~/.cache/go-build
-
-  release:
-    docker:
-      - image: circleci/golang:1.10
-    working_directory: /go/src/github.com/jesseduffield/lazygit
-    steps:
-      - checkout
-      - run:
-          name: Run gorelease
-          command: |
-            curl -sL https://git.io/goreleaser | bash
-
-workflows:
-  version: 2
-  build:
-    jobs:
-      - build
-  release:
-    jobs:
-      - release:
-          filters:
-            tags:
-              only: /v[0-9]+(\.[0-9]+)*/
-            branches:
-              ignore: /.*/
+      # specify any bash command here prefixed with `run: `
+      - run: go test -v ./...
+      - run: bash <(curl -s https://codecov.io/bash)

.github/ISSUE_TEMPLATE/bug_report.md

@@ -23,7 +23,6 @@ If applicable, add screenshots to help explain your problem.
 **Desktop (please complete the following information):**
  - OS: [e.g. Windows]
  - Lazygit Version [e.g. v0.1.45]
- - The last commit id if you built project from sources (run : ```git-rev parse HEAD```)
 
 **Additional context**
 Add any other context about the problem here.

.gitignore

@@ -1,28 +1,7 @@
-# Please do not add personal files
-
-# Logs
-*.log
-
-# Hidden
-.*
-
-# TODO
-TODO.*
-
-# Notes
-*.notes
-
-# Tests
+development.log
+commands.log
+extra/lgit.rb
+notes/go.notes
+TODO.notes
+TODO.md
 test/repos/repo
-coverage.txt
-
-# Binaries
-lazygit
-
-# Exceptions
-!.gitignore
-!.goreleaser.yml
-!.circleci/
-!.github/
-
-test/git_server/data

.goreleaser.yml

@@ -13,9 +13,8 @@ builds:
       - arm
       - arm64
       - 386
-    # Default is `-s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}}`.
     ldflags:
-      - -s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}} -X main.buildSource=binaryRelease
+      - -s -w -X main.version={{.Version}} -X main.tag={{.Tag}} -X main.date={{.Date}} -X main.commit={{.Commit}} -X "main.goos={{.Os}} -X "main.arch={{.Arch}} -X "main.arm={{.Arm}}"
 
 archive:
   replacements:

CONTRIBUTING.md

@@ -15,10 +15,9 @@ welcome your pull requests:
 1. Fork the repo and create your branch from `master`.
 2. If you've added code that should be tested, add tests.
 3. If you've added code that need documentation, update the documentation.
-4. Make sure your code follows the [effective go](https://golang.org/doc/effective_go.html) guidelines as much as possible.
-5. Be sure to test your modifications.
-6. Write a [good commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
-7. Issue that pull request!
+4. Be sure to test your modifications.
+5. Write a [good commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+6. Issue that pull request!
 
 ## Code of conduct
 Please note by participating in this project, you agree to abide by the [code of conduct].

Dockerfile

@@ -1,15 +0,0 @@
-# run with:
-# docker build -t lazygit .
-# docker run -it lazygit:latest /bin/sh -l
-
-FROM golang:alpine
-WORKDIR /go/src/github.com/jesseduffield/lazygit/
-COPY ./ .
-RUN CGO_ENABLED=0 GOOS=linux go build -o lazygit .
-
-FROM alpine:latest
-RUN apk add -U git xdg-utils
-WORKDIR /go/src/github.com/jesseduffield/lazygit/
-COPY --from=0 /go/src/github.com/jesseduffield/lazygit /go/src/github.com/jesseduffield/lazygit
-COPY --from=0 /go/src/github.com/jesseduffield/lazygit/lazygit /bin/
-RUN echo "alias gg=lazygit" >> ~/.profile

Gopkg.lock

@@ -2,52 +2,12 @@
 
 
 [[projects]]
-  digest = "1:e24ea5dbc89fbab51635ee32e5be4f61a9267cae20788efcae4c07efb4abec99"
-  name = "github.com/aws/aws-sdk-go"
-  packages = [
-    "aws",
-    "aws/awserr",
-    "aws/awsutil",
-    "aws/client",
-    "aws/client/metadata",
-    "aws/corehandlers",
-    "aws/credentials",
-    "aws/credentials/ec2rolecreds",
-    "aws/credentials/endpointcreds",
-    "aws/credentials/stscreds",
-    "aws/csm",
-    "aws/defaults",
-    "aws/ec2metadata",
-    "aws/endpoints",
-    "aws/request",
-    "aws/session",
-    "aws/signer/v4",
-    "internal/sdkio",
-    "internal/sdkrand",
-    "internal/sdkuri",
-    "internal/shareddefaults",
-    "private/protocol",
-    "private/protocol/eventstream",
-    "private/protocol/eventstream/eventstreamapi",
-    "private/protocol/query",
-    "private/protocol/query/queryutil",
-    "private/protocol/rest",
-    "private/protocol/restxml",
-    "private/protocol/xml/xmlutil",
-    "service/s3",
-    "service/sts",
-  ]
+  digest = "1:b2339e83ce9b5c4f79405f949429a7f68a9a904fed903c672aac1e7ceb7f5f02"
+  name = "github.com/Sirupsen/logrus"
+  packages = ["."]
   pruneopts = "NUT"
-  revision = "4324bc9d8865bdb3e6aa86ec7772ca1272d2750e"
-  version = "v1.15.21"
-
-[[projects]]
-  branch = "master"
-  digest = "1:37011b20a70e205b93ebea5287e1afa5618db54bf3998c36ff5a8e4b146a170a"
-  name = "github.com/bgentry/go-netrc"
-  packages = ["netrc"]
-  pruneopts = "NUT"
-  revision = "9fd32a8b3d3d3f9d43c341bfe098430e07609480"
+  revision = "3e01752db0189b9157070a0e1668a620f9a85da2"
+  version = "v1.0.6"
 
 [[projects]]
   branch = "master"
@@ -96,22 +56,6 @@
   revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9"
   version = "v1.4.7"
 
-[[projects]]
-  digest = "1:ea1d5bfdb4ec5c2ee48c97865e6de1a28fa8c4849a3f56b27d521aa619038e06"
-  name = "github.com/go-errors/errors"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "a6af135bd4e28680facf08a3d206b454abc877a4"
-  version = "v1.0.1"
-
-[[projects]]
-  digest = "1:74d9b0a7b4107b41e0ade759fac64502876f82d29fb23d77b3dd24b194ee3dd5"
-  name = "github.com/go-ini/ini"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "5cf292cae48347c2490ac1a58fe36735fb78df7e"
-  version = "v1.38.2"
-
 [[projects]]
   branch = "master"
   digest = "1:4a8ed9b8cf22bd03bee5d74179fa06a282e4a73b6de949f7a865ff56cd2537e0"
@@ -120,38 +64,6 @@
   pruneopts = "NUT"
   revision = "604e922904d35e97f98a774db7881f049cd8d970"
 
-[[projects]]
-  branch = "master"
-  digest = "1:a5d940c38bf56f121721bfa747c66356df387cb9d5318c570c6d4170aab62862"
-  name = "github.com/hashicorp/go-cleanhttp"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "d5fe4b57a186c716b0e00b8c301cbd9b4182694d"
-
-[[projects]]
-  branch = "master"
-  digest = "1:b634d733abf079dc191d359e5a8d31479f1795d00e656f8a018a459571046266"
-  name = "github.com/hashicorp/go-getter"
-  packages = ["helper/url"]
-  pruneopts = "NUT"
-  revision = "4bda8fa99001c61db3cad96b421d4c12a81f256d"
-
-[[projects]]
-  branch = "master"
-  digest = "1:fbab03227343a0285fc74a68dd2ff46cda7edecbbe5a3e98d2cecd00cc67b217"
-  name = "github.com/hashicorp/go-safetemp"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "b1a1dbde6fdc11e3ae79efd9039009e22d4ae240"
-
-[[projects]]
-  digest = "1:0b06ffe0c0764e413a6738e3f045d6bb14117359aef80a09f8c60fbff2ecad6b"
-  name = "github.com/hashicorp/go-version"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "b5a281d3160aa11950a6182bd9a9dc2cb1e02d50"
-  version = "v1.0.0"
-
 [[projects]]
   branch = "master"
   digest = "1:11c6c696067d3127ecf332b10f89394d386d9083f82baf71f40f2da31841a009"
@@ -171,14 +83,6 @@
   pruneopts = "NUT"
   revision = "ef8a98b0bbce4a65b5aa4c368430a80ddc533168"
 
-[[projects]]
-  branch = "master"
-  digest = "1:d457d39e88f678ed14ac29517c3d74927a48dbc6a9f073fa241cf364a68cbe5c"
-  name = "github.com/heroku/rollrus"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "fc0cef2ff331aebb24cd4e9ded7e20650f3d7006"
-
 [[projects]]
   branch = "master"
   digest = "1:62fe3a7ea2050ecbd753a71889026f83d73329337ada66325cbafd5dea5f713d"
@@ -189,50 +93,11 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:490643e333b848f3d6ab772c21082d706663dcf4a3c0fbe9a4b4ef7b205ce6c7"
-  name = "github.com/jesseduffield/go-getter"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "906e15686e6309ff310c1c10463ab53287c3a678"
-
-[[projects]]
-  branch = "master"
-  digest = "1:31a87f65dc451471f411d04742d2cb5ab79a699b8c73666b8fc29f47a8f43f7e"
+  digest = "1:c9a848b0484a72da2dae28957b4f67501fe27fa38bc73f4713e454353c0a4a60"
   name = "github.com/jesseduffield/gocui"
   packages = ["."]
   pruneopts = "NUT"
-  revision = "b502ee11d6743144c86226ca0366adaed727214d"
-
-[[projects]]
-  branch = "master"
-  digest = "1:a46c2f4863e5284ddb255c28750298e04bc8c0fc896bed6056e947673168b7be"
-  name = "github.com/jesseduffield/pty"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "02db52c7e406c7abec44c717a173c7715e4c1b62"
-
-[[projects]]
-  branch = "master"
-  digest = "1:3ab130f65766f5b7cc944d557df31c6a007ec017151705ec1e1b8719f2689021"
-  name = "github.com/jesseduffield/termbox-go"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "1e272ff78dcb4c448870f464fda1cdcf2bf0b3dd"
-
-[[projects]]
-  digest = "1:ac6d01547ec4f7f673311b4663909269bfb8249952de3279799289467837c3cc"
-  name = "github.com/jmespath/go-jmespath"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "0b12d6b5"
-
-[[projects]]
-  branch = "master"
-  digest = "1:263f9b0a0bcbfff9d5e7d9f2aa11f53995d98214fe0fb97e429e7a5f4534a0f9"
-  name = "github.com/kardianos/osext"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "ae77be60afb1dcacde03767a8c37337fad28ac14"
+  revision = "432b7f6215f81ef1aaa1b2d9b69887822923cf79"
 
 [[projects]]
   digest = "1:8021af4dcbd531ae89433c8c3a6520e51064114aaf8eb1724c3cf911c497c9ba"
@@ -290,14 +155,6 @@
   pruneopts = "NUT"
   revision = "58046073cbffe2f25d425fe1331102f55cf719de"
 
-[[projects]]
-  branch = "master"
-  digest = "1:18b773b92ac82a451c1276bd2776c1e55ce057ee202691ab33c8d6690efcc048"
-  name = "github.com/mitchellh/go-testing-interface"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "a61a99592b77c9ba629d254a693acffaeb4b7e28"
-
 [[projects]]
   branch = "master"
   digest = "1:5fe20cfe4ef484c237cec9f947b2a6fa90bad4b8610fd014f0e4211e13d82d5d"
@@ -318,6 +175,14 @@
   revision = "a16b91a3ba80db3a2301c70d1d302d42251c9079"
   version = "v2.0.0-beta.5"
 
+[[projects]]
+  branch = "master"
+  digest = "1:34d9354c2c5d916c05864327553047df59fc10e86ff1f408e4136eba0a25a5ec"
+  name = "github.com/nsf/termbox-go"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "5c94acc5e6eb520f1bcd183974e01171cc4c23b3"
+
 [[projects]]
   digest = "1:cf254277d898b713195cc6b4a3fac8bf738b9f1121625df27843b52b267eec6c"
   name = "github.com/pelletier/go-buffruneio"
@@ -334,22 +199,6 @@
   revision = "c01d1270ff3e442a8a57cddc1c92dc1138598194"
   version = "v1.2.0"
 
-[[projects]]
-  digest = "1:5cf3f025cbee5951a4ee961de067c8a89fc95a5adabead774f82822efabab121"
-  name = "github.com/pkg/errors"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
-  version = "v0.8.0"
-
-[[projects]]
-  digest = "1:0028cb19b2e4c3112225cd871870f2d9cf49b9b4276531f03438a88e94be86fe"
-  name = "github.com/pmezard/go-difflib"
-  packages = ["difflib"]
-  pruneopts = "NUT"
-  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
-  version = "v1.0.0"
-
 [[projects]]
   digest = "1:d917313f309bda80d27274d53985bc65651f81a5b66b820749ac7f8ef061fd04"
   name = "github.com/sergi/go-diff"
@@ -359,20 +208,13 @@
   version = "v1.0.0"
 
 [[projects]]
+  branch = "master"
   digest = "1:41618aee8828e62dfe62d44f579c06892d0e98907d1c6d5bcd83bfe8536ec5a3"
   name = "github.com/shibukawa/configdir"
   packages = ["."]
   pruneopts = "NUT"
   revision = "e180dbdc8da04c4fa04272e875ce64949f38bd3e"
 
-[[projects]]
-  digest = "1:b2339e83ce9b5c4f79405f949429a7f68a9a904fed903c672aac1e7ceb7f5f02"
-  name = "github.com/sirupsen/logrus"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "3e01752db0189b9157070a0e1668a620f9a85da2"
-  version = "v1.0.6"
-
 [[projects]]
   digest = "1:330e9062b308ac597e28485699c02223bd052437a6eed32a173c9227dcb9d95a"
   name = "github.com/spf13/afero"
@@ -416,14 +258,6 @@
   revision = "907c19d40d9a6c9bb55f040ff4ae45271a4754b9"
   version = "v1.1.0"
 
-[[projects]]
-  branch = "master"
-  digest = "1:0e9a5ac14bcc11f205031a671b28c7e05cb88b2ebbe06f383c1ab0b2c12c7cb5"
-  name = "github.com/spkg/bom"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "59b7046e48ad6bac800c5e1dd5142282cbfcf154"
-
 [[projects]]
   digest = "1:ccca1dcd18bc54e23b517a3c5babeff2e3924a7d8fc1932162225876cfe4bfb0"
   name = "github.com/src-d/gcfg"
@@ -437,22 +271,6 @@
   revision = "f187355171c936ac84a82793659ebb4936bc1c23"
   version = "v1.3.0"
 
-[[projects]]
-  digest = "1:bacb8b590716ab7c33f2277240972c9582d389593ee8d66fc10074e0508b8126"
-  name = "github.com/stretchr/testify"
-  packages = ["assert"]
-  pruneopts = "NUT"
-  revision = "f35b8ab0b5a2cef36673838d662e249dd9c94686"
-  version = "v1.2.2"
-
-[[projects]]
-  branch = "master"
-  digest = "1:e42372d3f4921ec35df07f9b23239631e9d28580f7c1edcca212bc6daddc68fe"
-  name = "github.com/stvp/roll"
-  packages = ["."]
-  pruneopts = "NUT"
-  revision = "3627a5cbeaeaa68023abd02bb8687925265f2f63"
-
 [[projects]]
   digest = "1:cd5ffc5bda4e0296ab3e4de90dbb415259c78e45e7fab13694b14cde8ab74541"
   name = "github.com/tcnksm/go-gitconfig"
@@ -461,19 +279,6 @@
   revision = "d154598bacbf4501c095a309753c5d4af66caa81"
   version = "v0.1.2"
 
-[[projects]]
-  digest = "1:07e8742c479bab0066149ad02a710024154e76874fd0a2dba002d87702725825"
-  name = "github.com/ulikunitz/xz"
-  packages = [
-    ".",
-    "internal/hash",
-    "internal/xlog",
-    "lzma",
-  ]
-  pruneopts = "NUT"
-  revision = "0c6b41e72360850ca4f98dc341fd999726ea007f"
-  version = "v0.5.4"
-
 [[projects]]
   digest = "1:3148cb3478c26a92b4c1a18abb9428234b281e278af6267840721a24b6cbc6a3"
   name = "github.com/xanzy/ssh-agent"
@@ -626,27 +431,20 @@
   analyzer-name = "dep"
   analyzer-version = 1
   input-imports = [
+    "github.com/Sirupsen/logrus",
     "github.com/cloudfoundry/jibber_jabber",
+    "github.com/davecgh/go-spew/spew",
     "github.com/fatih/color",
-    "github.com/go-errors/errors",
     "github.com/golang-collections/collections/stack",
-    "github.com/heroku/rollrus",
-    "github.com/jesseduffield/go-getter",
     "github.com/jesseduffield/gocui",
-    "github.com/jesseduffield/pty",
-    "github.com/kardianos/osext",
     "github.com/mgutz/str",
     "github.com/nicksnyder/go-i18n/v2/i18n",
     "github.com/shibukawa/configdir",
-    "github.com/sirupsen/logrus",
     "github.com/spf13/viper",
-    "github.com/spkg/bom",
-    "github.com/stretchr/testify/assert",
     "github.com/tcnksm/go-gitconfig",
     "golang.org/x/text/language",
     "gopkg.in/src-d/go-git.v4",
     "gopkg.in/src-d/go-git.v4/plumbing",
-    "gopkg.in/yaml.v2",
   ]
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -37,14 +37,6 @@
   branch = "master"
   name = "github.com/jesseduffield/gocui"
 
-[[constraint]]
-  branch = "master"
-  name = "github.com/jesseduffield/pty"
-
 [[constraint]]
   name = "gopkg.in/src-d/go-git.v4"
   revision = "43d17e14b714665ab5bc2ecc220b6740779d733f"
-
-[[constraint]]
-  branch = "master"
-  name = "github.com/spkg/bom"

README.md

@@ -1,4 +1,4 @@
-# lazygit [![CircleCI](https://circleci.com/gh/jesseduffield/lazygit.svg?style=svg)](https://circleci.com/gh/jesseduffield/lazygit) [![codecov](https://codecov.io/gh/jesseduffield/lazygit/branch/master/graph/badge.svg)](https://codecov.io/gh/jesseduffield/lazygit) [![Go Report Card](https://goreportcard.com/badge/github.com/jesseduffield/lazygit)](https://goreportcard.com/report/github.com/jesseduffield/lazygit) [![GolangCI](https://golangci.com/badges/github.com/jesseduffield/lazygit.svg)](https://golangci.com) [![GoDoc](https://godoc.org/github.com/jesseduffield/lazygit?status.svg)](http://godoc.org/github.com/jesseduffield/lazygit) [![GitHub tag](https://img.shields.io/github/tag/jesseduffield/lazygit.svg)]()
+# lazygit [![Go Report Card](https://goreportcard.com/badge/github.com/jesseduffield/lazygit)](https://goreportcard.com/report/github.com/jesseduffield/lazygit)
 
 A simple terminal UI for git commands, written in Go with the [gocui](https://github.com/jroimartin/gocui "gocui") library.
 
@@ -7,14 +7,14 @@ too stubborn to use Sourcetree because you'll never forgive Atlassian for making
 Jira? This is the app for you!
 
 
-![Gif](/docs/resources/lazygit-example.gif)
+![Gif](https://image.ibb.co/mmeXho/optimisedgif.gif)
 
   * [Installation](https://github.com/jesseduffield/lazygit#installation)
   * [Usage](https://github.com/jesseduffield/lazygit#usage),
     [Keybindings](https://github.com/jesseduffield/lazygit/blob/master/docs/Keybindings.md)
   * [Cool Features](https://github.com/jesseduffield/lazygit#cool-features)
   * [Contributing](https://github.com/jesseduffield/lazygit#contributing)
-  * [Video Tutorial](https://youtu.be/VDXvbHZYeKY)
+  * [Video Tutorial](https://www.youtube.com/watch?v=VDXvbHZYeKY)
   * [Twitch Stream](https://www.twitch.tv/jesseduffield)
 
 ## Installation
@@ -69,12 +69,6 @@ and the git version which builds from the most recent commit.
 Instruction of how to install AUR content can be found here:
 https://wiki.archlinux.org/index.php/Arch_User_Repository
 
-### Conda
-Released versions are available for different platforms, see https://anaconda.org/conda-forge/lazygit
-```sh
-conda install -c conda-forge lazygit
-```
-
 ### Binary Release (Windows/Linux/OSX)
 You can download a binary release [here](https://github.com/jesseduffield/lazygit/releases).
 
@@ -94,9 +88,9 @@ Call `lazygit` in your terminal inside a git repository. If you want, you can
 also add an alias for this with `echo "alias lg='lazygit'" >> ~/.zshrc` (or
 whichever rc file you're using).
 
-  * Basic video tutorial [here](https://youtu.be/VDXvbHZYeKY).
+  * Basic video tutorial [here](https://www.youtube.com/watch?v=VDXvbHZYeKY).
   * List of keybindings
-[here](/docs/Keybindings.md).
+[here](https://github.com/jesseduffield/lazygit/blob/master/docs/Keybindings.md).
 
 ## Cool features
   * Adding files easily
@@ -107,10 +101,10 @@ whichever rc file you're using).
   * Squash down and rename commits
 
 ### Resolving merge conflicts
-![Gif](/docs/resources/resolving-merge-conflicts.gif)
+![Gif](https://image.ibb.co/iyxUTT/shortermerging.gif)
 
 ### Viewing commit diffs
-![Viewing Commit Diffs](/docs/resources/viewing-commit-diffs.png)
+![Viewing Commit Diffs](https://image.ibb.co/gPD02o/capture.png)
 
 ## Milestones
 - [x] Easy Installation (homebrew, release binaries)
@@ -125,12 +119,7 @@ whichever rc file you're using).
 We love your input! Please check out the [contributing guide](CONTRIBUTING.md).
 For contributor discussion about things not better discussed here in the repo, join the slack channel
 
-[![Slack](/docs/resources/slack_rgb.png)](https://join.slack.com/t/lazygit/shared_invite/enQtNDE3MjIwNTYyMDA0LTM3Yjk3NzdiYzhhNTA1YjM4Y2M4MWNmNDBkOTI0YTE4YjQ1ZmI2YWRhZTgwNjg2YzhhYjg3NDBlMmQyMTI5N2M)
-
-## Donate
-If you would like to support the development of lazygit, please donate
-
-[![Donate](https://d1iczxrky3cnb2.cloudfront.net/button-medium-blue.png)](https://donorbox.org/lazygit)
+[![Slack](/files/slack_rgb.png)](https://join.slack.com/t/lazygit/shared_invite/enQtNDE3MjIwNTYyMDA0LTM3Yjk3NzdiYzhhNTA1YjM4Y2M4MWNmNDBkOTI0YTE4YjQ1ZmI2YWRhZTgwNjg2YzhhYjg3NDBlMmQyMTI5N2M)
 
 ## Work in progress
 This is still a work in progress so there's still bugs to iron out and as this
@@ -142,7 +131,3 @@ feel free to [raise an issue](https://github.com/jesseduffield/lazygit/issues)/[
 If you want to see what I (Jesse) am up to in terms of development, follow me on
 [twitter](https://twitter.com/DuffieldJesse) or watch me program on
 [twitch](https://www.twitch.tv/jesseduffield).
-
-## Alternatives
-If you find that lazygit doesn't quite satisfy your requirements, these may be a better fit:
-- [tig](https://github.com/jonas/tig)

VERSION

@@ -0,0 +1 @@
+v0.1.68

docs/Config.md

@@ -6,7 +6,6 @@
   gui:
     # stuff relating to the UI
     scrollHeight: 2 # how many lines you scroll by
-    scrollPastBottom: true # enable scrolling past the bottom
     theme:
       activeBorderColor:
         - white
@@ -15,49 +14,10 @@
         - white
       optionsTextColor:
         - blue
-    commitLength:
-      show: true
   git:
-    merging:
-      # only applicable to unix users
-      manualCommit: false
-  update:
-    method: prompt # can be: prompt | background | never
-    days: 14 # how often an update is checked for
-  reporting: 'undetermined' # one of: 'on' | 'off' | 'undetermined'
-  confirmOnQuit: false
-```
-
-## Platform Defaults:
-
-### Windows:
-
-```
+    # stuff relating to git
   os:
-    openCommand: 'cmd /c "start "" {{filename}}"'
-```
-
-### Linux:
-
-```
-  os:
-    openCommand: 'sh -c "xdg-open {{filename}} >/dev/null"'
-```
-
-### OSX:
-
-```
-  os:
-    openCommand: 'open {{filename}}'
-```
-
-### Recommended Config Values:
-
-for users of VSCode
-
-```
-  os:
-    openCommand: 'code -r {{filename}}'
+    # stuff relating to the OS
 ```
 
 ## Color Attributes:
@@ -77,7 +37,3 @@ The available attributes are:
 - bold
 - reverse # useful for high-contrast
 - underline
-
-## Example Coloring:
-
-![border example](/docs/resources/colored-border-example.png)

docs/Keybindings.md

@@ -0,0 +1,81 @@
+# Keybindings:
+
+## Global:
+
+<pre>
+  <kbd>←</kbd><kbd>→</kbd><kbd>↑</kbd><kbd>↓</kbd>/<kbd>h</kbd><kbd>j</kbd><kbd>k</kbd><kbd>l</kbd>:               navigate
+  <kbd>PgUp</kbd>/<kbd>PgDn</kbd> or <kbd>ctrl</kbd>+<kbd>u</kbd>/<kbd>ctrl</kbd>+<kbd>d</kbd>:   scroll diff panel
+                                     (for <kbd>PgUp</kbd> and <kbd>PgDn</kbd>, use <kbd>fn</kbd>+<kbd>up</kbd>/<kbd>fn</kbd>+<kbd>down</kbd> on osx)
+  <kbd>q</kbd>:                                quit
+  <kbd>p</kbd>:                                pull
+  <kbd>shift</kbd>+<kbd>P</kbd>:                         push
+</pre>
+
+## Status Panel:
+
+<pre>
+  <kbd>e</kbd>:        edit config file
+  <kbd>o</kbd>:        open config file
+</pre>
+
+## Files Panel:
+
+<pre>
+  <kbd>space</kbd>:    toggle staged
+  <kbd>c</kbd>:        commit changes
+  <kbd>shift</kbd>+<kbd>C</kbd>: commit using git editor
+  <kbd>shift</kbd>+<kbd>S</kbd>: stash files
+  <kbd>t</kbd>:        add patched (i.e. pick chunks of a file to add)
+  <kbd>o</kbd>:        open
+  <kbd>e</kbd>:        edit
+  <kbd>s</kbd>:        open in sublime (requires 'subl' command)
+  <kbd>v</kbd>:        open in vscode (requires 'code' command)
+  <kbd>i</kbd>:        add to .gitignore
+  <kbd>d</kbd>:        delete if untracked checkout if tracked (aka go away)
+  <kbd>shift</kbd>+<kbd>R</kbd>: refresh files
+</pre>
+
+## Branches Panel:
+
+<pre>
+  <kbd>space</kbd>:   checkout branch
+  <kbd>f</kbd>:       force checkout branch
+  <kbd>m</kbd>:       merge into currently checked out branch
+  <kbd>c</kbd>:       checkout by name
+  <kbd>n</kbd>:       new branch
+  <kbd>d</kbd>:       delete branch
+</pre>
+
+## Commits Panel:
+
+<pre>
+  <kbd>s</kbd>:       squash down (only available for topmost commit)
+  <kbd>r</kbd>:       rename commit
+  <kbd>g</kbd>:       reset to this commit
+</pre>
+
+## Stash Panel:
+
+<pre>
+  <kbd>space</kbd>:   apply
+  <kbd>g</kbd>:       pop
+  <kbd>d</kbd>:       drop
+</pre>
+
+## Popup Panel:
+
+<pre>
+  <kbd>esc</kbd>:     close/cancel
+  <kbd>enter</kbd>:   confirm
+  <kbd>tab</kbd>:     enter newline (if editing)
+</pre>
+
+## Resolving Merge Conflicts (Diff Panel):
+
+<pre>
+  <kbd>←</kbd><kbd>→</kbd>/<kbd>h</kbd><kbd>l</kbd>: navigate conflicts
+  <kbd>↑</kbd><kbd>↓</kbd>/<kbd>k</kbd><kbd>j</kbd>: select hunk
+  <kbd>space</kbd>:      pick hunk
+  <kbd>b</kbd>:         pick both hunks
+  <kbd>z</kbd>:         undo (only available while still inside diff panel)
+</pre>

docs/Keybindings_en.md

@@ -1,114 +0,0 @@
-# Lazygit menu
-
-## Global
-
-<pre>
-  <kbd>m</kbd>: view merge/rebase options
-  <kbd>P</kbd>: push
-  <kbd>p</kbd>: pull
-  <kbd>R</kbd>: refresh
-</pre>
-
-## Status
-
-<pre>
-  <kbd>e</kbd>: edit config file
-  <kbd>o</kbd>: open config file
-  <kbd>u</kbd>: check for update
-  <kbd>s</kbd>: switch to a recent repo
-</pre>
-
-## Files
-
-<pre>
-  <kbd>c</kbd>: commit changes
-  <kbd>A</kbd>: amend last commit
-  <kbd>C</kbd>: commit changes using git editor
-  <kbd>space</kbd>: toggle staged
-  <kbd>d</kbd>: delete if untracked / checkout if tracked
-  <kbd>e</kbd>: edit file
-  <kbd>o</kbd>: open file
-  <kbd>i</kbd>: add to .gitignore
-  <kbd>r</kbd>: refresh files
-  <kbd>S</kbd>: stash files
-  <kbd>s</kbd>: soft reset to last commit
-  <kbd>a</kbd>: stage/unstage all
-  <kbd>t</kbd>: add patch
-  <kbd>D</kbd>: reset hard and remove untracked files
-  <kbd>enter</kbd>: stage individual hunks/lines
-  <kbd>f</kbd>: fetch
-</pre>
-
-## Branches
-
-<pre>
-  <kbd>space</kbd>: checkout
-  <kbd>o</kbd>: create pull request
-  <kbd>c</kbd>: checkout by name
-  <kbd>F</kbd>: force checkout
-  <kbd>n</kbd>: new branch
-  <kbd>d</kbd>: delete branch
-  <kbd>r</kbd>: rebase branch
-  <kbd>M</kbd>: merge into currently checked out branch
-  <kbd>f</kbd>: fast-forward this branch from its upstream
-</pre>
-
-## Commits
-
-<pre>
-  <kbd>s</kbd>: squash down
-  <kbd>r</kbd>: reword commit
-  <kbd>R</kbd>: rename commit with editor
-  <kbd>g</kbd>: reset to this commit
-  <kbd>f</kbd>: fixup commit
-  <kbd>d</kbd>: delete commit
-  <kbd>J</kbd>: move commit down one
-  <kbd>K</kbd>: move commit up one
-  <kbd>e</kbd>: edit commit
-  <kbd>A</kbd>: amend commit with staged changes
-  <kbd>p</kbd>: pick commit (when mid-rebase)
-  <kbd>t</kbd>: revert commit
-  <kbd>c</kbd>: copy commit (cherry-pick)
-  <kbd>C</kbd>: copy commit range (cherry-pick)
-  <kbd>v</kbd>: paste commits (cherry-pick)
-</pre>
-
-## Stash
-
-<pre>
-  <kbd>space</kbd>: apply
-  <kbd>g</kbd>: pop
-  <kbd>d</kbd>: drop
-</pre>
-
-## Main (Normal)
-
-<pre>
-  <kbd>PgDn</kbd>: scroll down
-  <kbd>PgUp</kbd>: scroll up
-</pre>
-
-## Main (Staging)
-
-<pre>
-  <kbd>esc</kbd>: return to files panel
-  <kbd>▲</kbd>: select previous line
-  <kbd>▼</kbd>: select next line
-  <kbd>◄</kbd>: select previous hunk
-  <kbd>►</kbd>: select next hunk
-  <kbd>space</kbd>: stage line
-  <kbd>a</kbd>: stage hunk
-</pre>
-
-## Main (Merging)
-
-<pre>
-  <kbd>esc</kbd>: return to files panel
-  <kbd>space</kbd>: pick hunk
-  <kbd>b</kbd>: pick both hunks
-  <kbd>◄</kbd>: select previous conflict
-  <kbd>►</kbd>: select next conflict
-  <kbd>▲</kbd>: select top hunk
-  <kbd>▼</kbd>: select bottom hunk
-  <kbd>z</kbd>: undo
-</pre>

go.mod

@@ -1,64 +0,0 @@
-module github.com/jesseduffield/lazygit
-
-require (
-	github.com/aws/aws-sdk-go v1.15.21
-	github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d
-	github.com/cloudfoundry/jibber_jabber v0.0.0-20151120183258-bcc4c8345a21
-	github.com/davecgh/go-spew v1.1.0
-	github.com/emirpasic/gods v1.9.0
-	github.com/fatih/color v1.7.0
-	github.com/fsnotify/fsnotify v1.4.7
-	github.com/go-errors/errors v1.0.1
-	github.com/go-ini/ini v1.38.2
-	github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3
-	github.com/hashicorp/go-cleanhttp v0.0.0-20171218145408-d5fe4b57a186
-	github.com/hashicorp/go-getter v0.0.0-20180809191950-4bda8fa99001
-	github.com/hashicorp/go-safetemp v0.0.0-20180326211150-b1a1dbde6fdc
-	github.com/hashicorp/go-version v1.0.0
-	github.com/hashicorp/hcl v0.0.0-20180404174102-ef8a98b0bbce
-	github.com/heroku/rollrus v0.0.0-20180515183152-fc0cef2ff331
-	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99
-	github.com/jesseduffield/go-getter v0.0.0-20180822080847-906e15686e63
-	github.com/jesseduffield/gocui v0.0.0-20190303031804-b502ee11d674
-	github.com/jesseduffield/pty v0.0.0-20181218102224-02db52c7e406
-	github.com/jesseduffield/termbox-go v0.0.0-20180919093808-1e272ff78dcb
-	github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8
-	github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1
-	github.com/kevinburke/ssh_config v0.0.0-20180317175531-9fc7bb800b55
-	github.com/magiconair/properties v1.8.0
-	github.com/mattn/go-colorable v0.0.9
-	github.com/mattn/go-isatty v0.0.3
-	github.com/mattn/go-runewidth v0.0.2
-	github.com/mgutz/str v1.2.0
-	github.com/mitchellh/go-homedir v0.0.0-20180801233206-58046073cbff
-	github.com/mitchellh/go-testing-interface v0.0.0-20171004221916-a61a99592b77
-	github.com/mitchellh/mapstructure v0.0.0-20180715050151-f15292f7a699
-	github.com/nicksnyder/go-i18n v0.0.0-20180803040939-a16b91a3ba80
-	github.com/pelletier/go-buffruneio v0.2.0
-	github.com/pelletier/go-toml v1.2.0
-	github.com/pkg/errors v0.8.0
-	github.com/pmezard/go-difflib v1.0.0
-	github.com/sergi/go-diff v1.0.0
-	github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0
-	github.com/sirupsen/logrus v1.0.6
-	github.com/spf13/afero v1.1.1
-	github.com/spf13/cast v1.2.0
-	github.com/spf13/jwalterweatherman v0.0.0-20180814060501-14d3d4c51834
-	github.com/spf13/pflag v1.0.2
-	github.com/spf13/viper v1.1.0
-	github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad
-	github.com/src-d/gcfg v1.3.0
-	github.com/stretchr/testify v1.2.2
-	github.com/stvp/roll v0.0.0-20170522205222-3627a5cbeaea
-	github.com/tcnksm/go-gitconfig v0.1.2
-	github.com/ulikunitz/xz v0.5.4
-	github.com/xanzy/ssh-agent v0.2.0
-	golang.org/x/crypto v0.0.0-20180808211826-de0752318171
-	golang.org/x/net v0.0.0-20180811021610-c39426892332
-	golang.org/x/sys v0.0.0-20180810173357-98c5dad5d1a0
-	golang.org/x/text v0.3.0
-	gopkg.in/src-d/go-billy.v4 v4.2.0
-	gopkg.in/src-d/go-git.v4 v4.0.0-20180807092216-43d17e14b714
-	gopkg.in/warnings.v0 v0.1.2
-	gopkg.in/yaml.v2 v2.2.1
-)

go.sum

@@ -1,121 +0,0 @@
-github.com/BurntSushi/toml v0.3.0/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/aws/aws-sdk-go v1.15.21 h1:STLvc6RrpycslC1NRtTvt/YSgDkIGCTrB9K9vE5R2oQ=
-github.com/aws/aws-sdk-go v1.15.21/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0=
-github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas=
-github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4=
-github.com/cloudfoundry/jibber_jabber v0.0.0-20151120183258-bcc4c8345a21 h1:tuijfIjZyjZaHq9xDUh0tNitwXshJpbLkqMOJv4H3do=
-github.com/cloudfoundry/jibber_jabber v0.0.0-20151120183258-bcc4c8345a21/go.mod h1:po7NpZ/QiTKzBKyrsEAxwnTamCoh8uDk/egRpQ7siIc=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.9.0 h1:rUF4PuzEjMChMiNsVjdI+SyLu7rEqpQ5reNFnhC7oFo=
-github.com/emirpasic/gods v1.9.0/go.mod h1:YfzfFFoVP/catgzJb4IKIqXjX78Ha8FMSDh3ymbK86o=
-github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
-github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
-github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/go-ini/ini v1.25.4/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
-github.com/go-ini/ini v1.38.2 h1:6Hl/z3p3iFkA0dlDfzYxuFuUGD+kaweypF6btsR2/Q4=
-github.com/go-ini/ini v1.38.2/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
-github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3 h1:zN2lZNZRflqFyxVaTIU61KNKQ9C0055u9CAfpmqUvo4=
-github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3/go.mod h1:nPpo7qLxd6XL3hWJG/O60sR8ZKfMCiIoNap5GvD12KU=
-github.com/hashicorp/go-cleanhttp v0.0.0-20171218145408-d5fe4b57a186 h1:URgjUo+bs1KwatoNbwG0uCO4dHN4r1jsp4a5AGgHRjo=
-github.com/hashicorp/go-cleanhttp v0.0.0-20171218145408-d5fe4b57a186/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
-github.com/hashicorp/go-getter v0.0.0-20180809191950-4bda8fa99001 h1:MFPzqpPED05pFyGjNPJEC2sXM6EHTzFyvX+0s0JoZ48=
-github.com/hashicorp/go-getter v0.0.0-20180809191950-4bda8fa99001/go.mod h1:6rdJFnhkXnzGOJbvkrdv4t9nLwKcVA+tmbQeUlkIzrU=
-github.com/hashicorp/go-safetemp v0.0.0-20180326211150-b1a1dbde6fdc h1:wAa9fGALVHfjYxZuXRnmuJG2CnwRpJYOTvY6YdErAh0=
-github.com/hashicorp/go-safetemp v0.0.0-20180326211150-b1a1dbde6fdc/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I=
-github.com/hashicorp/go-version v1.0.0 h1:21MVWPKDphxa7ineQQTrCU5brh7OuVVAzGOCnnCPtE8=
-github.com/hashicorp/go-version v1.0.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
-github.com/hashicorp/hcl v0.0.0-20180404174102-ef8a98b0bbce h1:xdsDDbiBDQTKASoGEZ+pEmF1OnWuu8AQ9I8iNbHNeno=
-github.com/hashicorp/hcl v0.0.0-20180404174102-ef8a98b0bbce/go.mod h1:oZtUIOe8dh44I2q6ScRibXws4Ajl+d+nod3AaR9vL5w=
-github.com/heroku/rollrus v0.0.0-20180515183152-fc0cef2ff331 h1:qio0y/sQdhbHRA3cmgczo04MaSV2zw+n46G1owvgWIk=
-github.com/heroku/rollrus v0.0.0-20180515183152-fc0cef2ff331/go.mod h1:BT+PgT529opmb6mcUY+Fg0IwVRRmwqFyavEMU17GnBg=
-github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
-github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
-github.com/jesseduffield/go-getter v0.0.0-20180822080847-906e15686e63 h1:Nrr/yUxNjXWYK0B3IqcFlYh1ICnesJDB4ogcfOVc5Ns=
-github.com/jesseduffield/go-getter v0.0.0-20180822080847-906e15686e63/go.mod h1:fNqjRf+4XnTo2PrGN1JRb79b/BeoHwP4lU00f39SQY0=
-github.com/jesseduffield/gocui v0.0.0-20181209104758-fe55a32c8a4c h1:jEfh/vAtfF3pQ8xFhpYR/0S4iHo11VfaYelJmzZJm94=
-github.com/jesseduffield/gocui v0.0.0-20181209104758-fe55a32c8a4c/go.mod h1:2RtZznzYKt8RLRwvFiSkXjU0Ei8WwHdubgnlaYH47dw=
-github.com/jesseduffield/pty v0.0.0-20181218102224-02db52c7e406 h1:iYMH6h6SuWuBkIzRtymosE8NpSgTK0oRMfyTdVWgxzc=
-github.com/jesseduffield/pty v0.0.0-20181218102224-02db52c7e406/go.mod h1:7jlS40+UhOqkZJDIG1B/H21xnuET/+fvbbnHCa8wSIo=
-github.com/jesseduffield/termbox-go v0.0.0-20180919093808-1e272ff78dcb h1:cFHYEWpQEfzFZVKiKZytCUX4UwQixKSw0kd3WhluPsY=
-github.com/jesseduffield/termbox-go v0.0.0-20180919093808-1e272ff78dcb/go.mod h1:anMibpZtqNxjDbxrcDEAwSdaJ37vyUeM1f/M4uekib4=
-github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8 h1:12VvqtR6Aowv3l/EQUlocDHW2Cp4G9WJVH7uyH8QFJE=
-github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
-github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1 h1:PJPDf8OUfOK1bb/NeTKd4f1QXZItOX389VN3B6qC8ro=
-github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1/go.mod h1:1NbS8ALrpOvjt0rHPNLyCIeMtbizbir8U//inJ+zuB8=
-github.com/kevinburke/ssh_config v0.0.0-20180317175531-9fc7bb800b55 h1:S38dC4mEwxdw/U41+97VWdbun8mTcTjwg5Ujfg8QPME=
-github.com/kevinburke/ssh_config v0.0.0-20180317175531-9fc7bb800b55/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
-github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
-github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
-github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
-github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-isatty v0.0.3 h1:ns/ykhmWi7G9O+8a448SecJU3nSMBXJfqQkl0upE1jI=
-github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/mattn/go-runewidth v0.0.2 h1:UnlwIPBGaTZfPQ6T1IGzPI0EkYAQmT9fAEJ/poFC63o=
-github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
-github.com/mgutz/str v1.2.0 h1:4IzWSdIz9qPQWLfKZ0rJcV0jcUDpxvP4JVZ4GXQyvSw=
-github.com/mgutz/str v1.2.0/go.mod h1:w1v0ofgLaJdoD0HpQ3fycxKD1WtxpjSo151pK/31q6w=
-github.com/mitchellh/go-homedir v0.0.0-20180801233206-58046073cbff h1:jM4Eo4qMmmcqePS3u6X2lcEELtVuXWkWJIS/pRI3oSk=
-github.com/mitchellh/go-homedir v0.0.0-20180801233206-58046073cbff/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/mitchellh/go-testing-interface v0.0.0-20171004221916-a61a99592b77 h1:7GoSOOW2jpsfkntVKaS2rAr1TJqfcxotyaUcuxoZSzg=
-github.com/mitchellh/go-testing-interface v0.0.0-20171004221916-a61a99592b77/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
-github.com/mitchellh/mapstructure v0.0.0-20180715050151-f15292f7a699 h1:KXZJFdun9knAVAR8tg/aHJEr5DgtcbqyvzacK+CDCaI=
-github.com/mitchellh/mapstructure v0.0.0-20180715050151-f15292f7a699/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/nicksnyder/go-i18n v0.0.0-20180803040939-a16b91a3ba80 h1:7ory6RlsEkeK89iyV7Imz3sVz8YHeSw29w3PehpCWC0=
-github.com/nicksnyder/go-i18n v0.0.0-20180803040939-a16b91a3ba80/go.mod h1:e4Di5xjP9oTVrC6y3C7C0HoSYXjSbhh/dU0eUV32nB4=
-github.com/nicksnyder/go-i18n/v2 v2.0.0-beta.6 h1:SooTCzUOOs899x/M7gmSS+dgL+AUfSWqAcHLN3auCic=
-github.com/nicksnyder/go-i18n/v2 v2.0.0-beta.6/go.mod h1:4Opqa6/HIv0lhG3WRAkqzO0afezkRhxXI0P8EJkqeRU=
-github.com/pelletier/go-buffruneio v0.2.0 h1:U4t4R6YkofJ5xHm3dJzuRpPZ0mr5MMCoAWooScCR7aA=
-github.com/pelletier/go-buffruneio v0.2.0/go.mod h1:JkE26KsDizTr40EUHkXVtNPvgGtbSNq5BcowyYOWdKo=
-github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
-github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
-github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
-github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
-github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0 h1:Xuk8ma/ibJ1fOy4Ee11vHhUFHQNpHhrBneOCNHVXS5w=
-github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0/go.mod h1:7AwjWCpdPhkSmNAgUv5C7EJ4AbmjEB3r047r3DXWu3Y=
-github.com/sirupsen/logrus v1.0.6 h1:hcP1GmhGigz/O7h1WVUM5KklBp1JoNS9FggWKdj/j3s=
-github.com/sirupsen/logrus v1.0.6/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc=
-github.com/spf13/afero v1.1.1 h1:Lt3ihYMlE+lreX1GS4Qw4ZsNpYQLxIXKBTEOXm3nt6I=
-github.com/spf13/afero v1.1.1/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
-github.com/spf13/cast v1.2.0 h1:HHl1DSRbEQN2i8tJmtS6ViPyHx35+p51amrdsiTCrkg=
-github.com/spf13/cast v1.2.0/go.mod h1:r2rcYCSwa1IExKTDiTfzaxqT2FNHs8hODu4LnUfgKEg=
-github.com/spf13/jwalterweatherman v0.0.0-20180814060501-14d3d4c51834 h1:kJI9pPzfsULT/72wy7mxkRQZPtKWgFdCA2RTGZ4v8/E=
-github.com/spf13/jwalterweatherman v0.0.0-20180814060501-14d3d4c51834/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
-github.com/spf13/pflag v1.0.2 h1:Fy0orTDgHdbnzHcsOgfCN4LtHf0ec3wwtiwJqwvf3Gc=
-github.com/spf13/pflag v1.0.2/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
-github.com/spf13/viper v1.1.0 h1:V7OZpY8i3C1x/pDmU0zNNlfVoDz112fSYvtWMjjS3f4=
-github.com/spf13/viper v1.1.0/go.mod h1:A8kyI5cUJhb8N+3pkfONlcEcZbueH6nhAm0Fq7SrnBM=
-github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad h1:fiWzISvDn0Csy5H0iwgAuJGQTUpVfEMJJd4nRFXogbc=
-github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0=
-github.com/src-d/gcfg v1.3.0 h1:2BEDr8r0I0b8h/fOqwtxCEiq2HJu8n2JGZJQFGXWLjg=
-github.com/src-d/gcfg v1.3.0/go.mod h1:p/UMsR43ujA89BJY9duynAwIpvqEujIH/jFlfL7jWoI=
-github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stvp/roll v0.0.0-20170522205222-3627a5cbeaea h1:jysxIKov/4GJ33wI2aRvuIK7yBwB28E5almlgDLPRpM=
-github.com/stvp/roll v0.0.0-20170522205222-3627a5cbeaea/go.mod h1:Ffmqrj3nXIMIjeA4uW3Qjj0Ud9eDoTG0fu4JxyAr/tE=
-github.com/tcnksm/go-gitconfig v0.1.2 h1:iiDhRitByXAEyjgBqsKi9QU4o2TNtv9kPP3RgPgXBPw=
-github.com/tcnksm/go-gitconfig v0.1.2/go.mod h1:/8EhP4H7oJZdIPyT+/UIsG87kTzrzM4UsLGSItWYCpE=
-github.com/ulikunitz/xz v0.5.4 h1:zATC2OoZ8H1TZll3FpbX+ikwmadbO699PE06cIkm9oU=
-github.com/ulikunitz/xz v0.5.4/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
-github.com/xanzy/ssh-agent v0.2.0 h1:Adglfbi5p9Z0BmK2oKU9nTG+zKfniSfnaMYB+ULd+Ro=
-github.com/xanzy/ssh-agent v0.2.0/go.mod h1:0NyE30eGUDliuLEHJgYte/zncp2zdTStcOnWhgSqHD8=
-golang.org/x/crypto v0.0.0-20180808211826-de0752318171 h1:vYogbvSFj2YXcjQxFHu/rASSOt9sLytpCaSkiwQ135I=
-golang.org/x/crypto v0.0.0-20180808211826-de0752318171/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
-golang.org/x/net v0.0.0-20180811021610-c39426892332 h1:efGso+ep0DjyCBJPjvoz0HI6UldX4Md2F1rZFe1ir0E=
-golang.org/x/net v0.0.0-20180811021610-c39426892332/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/sys v0.0.0-20180810173357-98c5dad5d1a0 h1:8H8QZJ30plJyIVj60H3lr8TZGIq2Fh3Cyrs/ZNg1foU=
-golang.org/x/sys v0.0.0-20180810173357-98c5dad5d1a0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/text v0.0.0-20171214130843-f21a4dfb5e38/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/src-d/go-billy.v4 v4.2.0 h1:VGbrP1EsYxtvVPEiHui+4//imr4E5MGEFLx66bQtusg=
-gopkg.in/src-d/go-billy.v4 v4.2.0/go.mod h1:ZHSF0JP+7oD97194otDUCD7Ofbk63+xFcfWP5bT6h+Q=
-gopkg.in/src-d/go-git.v4 v4.0.0-20180807092216-43d17e14b714 h1:+wM2BGgQ1znCKBexOB4OrGVSDw8mtKNUSq3wqxZhi/k=
-gopkg.in/src-d/go-git.v4 v4.0.0-20180807092216-43d17e14b714/go.mod h1:CzbUWqMn4pvmvndg3gnh5iZFmSsbhyhUWdI0IQ60AQo=
-gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
-gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
-gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
-gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

main.go

@@ -3,23 +3,22 @@ package main
 import (
 	"flag"
 	"fmt"
-	"log"
+	"io/ioutil"
 	"os"
 	"path/filepath"
-	"runtime"
 
-	"github.com/go-errors/errors"
 	"github.com/jesseduffield/lazygit/pkg/app"
 	"github.com/jesseduffield/lazygit/pkg/config"
 )
 
 var (
-	commit      string
-	version     = "unversioned"
-	date        string
-	buildSource = "unknown"
+	commit  string
+	version = "unversioned"
+	date    string
+	goos    string
+	arch    string
+	arm     string
 
-	configFlag    = flag.Bool("config", false, "Print the current default config")
 	debuggingFlag = flag.Bool("debug", false, "a boolean")
 	versionFlag   = flag.Bool("v", false, "Print the current version")
 )
@@ -29,33 +28,34 @@ func projectPath(path string) string {
 	return filepath.FromSlash(gopath + "/src/github.com/jesseduffield/lazygit/" + path)
 }
 
+// when building the binary, `version` is set as a compile-time variable, along
+// with `date` and `commit`. If this program has been opened directly via go,
+// we will populate the `version` with VERSION in the lazygit root directory
+func fallbackVersion() string {
+	path := projectPath("VERSION")
+	byteVersion, err := ioutil.ReadFile(path)
+	if err != nil {
+		return "unversioned"
+	}
+	return string(byteVersion)
+}
+
 func main() {
 	flag.Parse()
+	if version == "unversioned" {
+		version = fallbackVersion()
+	}
 	if *versionFlag {
-		fmt.Printf("commit=%s, build date=%s, build source=%s, version=%s, os=%s, arch=%s\n", commit, date, buildSource, version, runtime.GOOS, runtime.GOARCH)
+		fmt.Printf("commit=%s, build date=%s, version=%s, os=%s, arch=%s, arm=%s\n", commit, date, version, goos, arch, arm)
 		os.Exit(0)
 	}
-
-	if *configFlag {
-		fmt.Printf("%s\n", config.GetDefaultConfig())
-		os.Exit(0)
-	}
-	appConfig, err := config.NewAppConfig("lazygit", version, commit, date, buildSource, *debuggingFlag)
+	appConfig, err := config.NewAppConfig("lazygit", version, commit, date, debuggingFlag)
 	if err != nil {
-		log.Fatal(err.Error())
+		panic(err)
 	}
 
 	app, err := app.NewApp(appConfig)
-
-	if err == nil {
-		err = app.Run()
-	}
-
-	if err != nil {
-		newErr := errors.Wrap(err, 0)
-		stackTrace := newErr.ErrorStack()
-		app.Log.Error(stackTrace)
-
-		log.Fatal(fmt.Sprintf("%s\n\n%s", app.Tr.SLocalize("ErrorOccurred"), stackTrace))
-	}
+	app.Log.Info(err)
+	app.GitCommand.SetupGit()
+	app.Gui.RunWithSubprocesses()
 }

pkg/app/app.go

@@ -1,52 +1,36 @@
 package app
 
 import (
-	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
-	"path/filepath"
-	"strings"
 
-	"github.com/heroku/rollrus"
+	"github.com/Sirupsen/logrus"
 	"github.com/jesseduffield/lazygit/pkg/commands"
 	"github.com/jesseduffield/lazygit/pkg/config"
 	"github.com/jesseduffield/lazygit/pkg/gui"
 	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/jesseduffield/lazygit/pkg/updates"
-	"github.com/shibukawa/configdir"
-	"github.com/sirupsen/logrus"
 )
 
 // App struct
 type App struct {
 	closers []io.Closer
 
-	Config        config.AppConfigurer
-	Log           *logrus.Entry
-	OSCommand     *commands.OSCommand
-	GitCommand    *commands.GitCommand
-	Gui           *gui.Gui
-	Tr            *i18n.Localizer
-	Updater       *updates.Updater // may only need this on the Gui
-	ClientContext string
+	Config     config.AppConfigurer
+	Log        *logrus.Logger
+	OSCommand  *commands.OSCommand
+	GitCommand *commands.GitCommand
+	Gui        *gui.Gui
+	Tr         *i18n.Localizer
 }
 
-func newProductionLogger(config config.AppConfigurer) *logrus.Logger {
+func newLogger(config config.AppConfigurer) *logrus.Logger {
 	log := logrus.New()
-	log.Out = ioutil.Discard
-	return log
-}
-
-func globalConfigDir() string {
-	configDirs := configdir.New("jesseduffield", "lazygit")
-	configDir := configDirs.QueryFolders(configdir.Global)[0]
-	return configDir.Path
-}
-
-func newDevelopmentLogger(config config.AppConfigurer) *logrus.Logger {
-	log := logrus.New()
-	file, err := os.OpenFile(filepath.Join(globalConfigDir(), "development.log"), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+	if !config.GetDebug() {
+		log.Out = ioutil.Discard
+		return log
+	}
+	file, err := os.OpenFile("development.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
 	if err != nil {
 		panic("unable to log to file") // TODO: don't panic (also, remove this call to the `panic` function)
 	}
@@ -54,34 +38,7 @@ func newDevelopmentLogger(config config.AppConfigurer) *logrus.Logger {
 	return log
 }
 
-func newLogger(config config.AppConfigurer) *logrus.Entry {
-	var log *logrus.Logger
-	environment := "production"
-	if config.GetDebug() || os.Getenv("DEBUG") == "TRUE" {
-		environment = "development"
-		log = newDevelopmentLogger(config)
-	} else {
-		log = newProductionLogger(config)
-	}
-
-	// highly recommended: tail -f development.log | humanlog
-	// https://github.com/aybabtme/humanlog
-	log.Formatter = &logrus.JSONFormatter{}
-
-	if config.GetUserConfig().GetString("reporting") == "on" {
-		// this isn't really a secret token: it only has permission to push new rollbar items
-		hook := rollrus.NewHook("23432119147a4367abf7c0de2aa99a2d", environment)
-		log.Hooks.Add(hook)
-	}
-	return log.WithFields(logrus.Fields{
-		"debug":     config.GetDebug(),
-		"version":   config.GetVersion(),
-		"commit":    config.GetCommit(),
-		"buildDate": config.GetBuildDate(),
-	})
-}
-
-// NewApp bootstrap a new application
+// NewApp retruns a new applications
 func NewApp(config config.AppConfigurer) (*App, error) {
 	app := &App{
 		closers: []io.Closer{},
@@ -89,68 +46,27 @@ func NewApp(config config.AppConfigurer) (*App, error) {
 	}
 	var err error
 	app.Log = newLogger(config)
-	app.Tr = i18n.NewLocalizer(app.Log)
-
-	// if we are being called in 'demon' mode, we can just return here
-	app.ClientContext = os.Getenv("LAZYGIT_CLIENT_COMMAND")
-	if app.ClientContext != "" {
-		return app, nil
+	app.OSCommand, err = commands.NewOSCommand(app.Log)
+	if err != nil {
+		return nil, err
 	}
 
-	app.OSCommand = commands.NewOSCommand(app.Log, config)
+	app.Tr, err = i18n.NewLocalizer(app.Log)
+	if err != nil {
+		return nil, err
+	}
 
-	app.Updater, err = updates.NewUpdater(app.Log, config, app.OSCommand, app.Tr)
+	app.GitCommand, err = commands.NewGitCommand(app.Log, app.OSCommand)
 	if err != nil {
-		return app, err
+		return nil, err
 	}
-	app.GitCommand, err = commands.NewGitCommand(app.Log, app.OSCommand, app.Tr, app.Config)
+	app.Gui, err = gui.NewGui(app.Log, app.GitCommand, app.OSCommand, app.Tr, config)
 	if err != nil {
-		if strings.Contains(err.Error(), "Not a git repository") {
-			fmt.Println("Not in a git repository. Use `git init` to create a new one")
-			os.Exit(1)
-		}
-		return app, err
-	}
-	app.Gui, err = gui.NewGui(app.Log, app.GitCommand, app.OSCommand, app.Tr, config, app.Updater)
-	if err != nil {
-		return app, err
+		return nil, err
 	}
 	return app, nil
 }
 
-func (app *App) Run() error {
-	if app.ClientContext == "INTERACTIVE_REBASE" {
-		return app.Rebase()
-	}
-
-	if app.ClientContext == "EXIT_IMMEDIATELY" {
-		os.Exit(0)
-	}
-
-	return app.Gui.RunWithSubprocesses()
-}
-
-// Rebase contains logic for when we've been run in demon mode, meaning we've
-// given lazygit as a command for git to call e.g. to edit a file
-func (app *App) Rebase() error {
-	app.Log.Info("Lazygit invoked as interactive rebase demon")
-	app.Log.Info("args: ", os.Args)
-
-	if strings.HasSuffix(os.Args[1], "git-rebase-todo") {
-		if err := ioutil.WriteFile(os.Args[1], []byte(os.Getenv("LAZYGIT_REBASE_TODO")), 0644); err != nil {
-			return err
-		}
-
-	} else if strings.HasSuffix(os.Args[1], ".git/COMMIT_EDITMSG") {
-		// if we are rebasing and squashing, we'll see a COMMIT_EDITMSG
-		// but in this case we don't need to edit it, so we'll just return
-	} else {
-		app.Log.Info("Lazygit demon did not match on any use cases")
-	}
-
-	return nil
-}
-
 // Close closes any resources
 func (app *App) Close() error {
 	for _, closer := range app.closers {

pkg/commands/branch.go

@@ -1,7 +1,6 @@
 package commands
 
 import (
-	"fmt"
 	"strings"
 
 	"github.com/fatih/color"
@@ -11,21 +10,13 @@ import (
 // Branch : A git branch
 // duplicating this for now
 type Branch struct {
-	Name      string
-	Recency   string
-	Pushables string
-	Pullables string
-	Selected  bool
+	Name    string
+	Recency string
 }
 
-// GetDisplayStrings returns the dispaly string of branch
-func (b *Branch) GetDisplayStrings(isFocused bool) []string {
-	displayName := utils.ColoredString(b.Name, b.GetColor())
-	if isFocused && b.Selected && b.Pushables != "" && b.Pullables != "" {
-		displayName = fmt.Sprintf("%s ↑%s↓%s", displayName, b.Pushables, b.Pullables)
-	}
-
-	return []string{b.Recency, displayName}
+// GetDisplayString returns the dispaly string of branch
+func (b *Branch) GetDisplayString() string {
+	return utils.WithPadding(b.Recency, 4) + utils.ColoredString(b.Name, b.GetColor())
 }
 
 // GetColor branch color

pkg/commands/commit.go

@@ -1,56 +0,0 @@
-package commands
-
-import (
-	"github.com/fatih/color"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// Commit : A git commit
-type Commit struct {
-	Sha           string
-	Name          string
-	Status        string // one of "unpushed", "pushed", "merged", or "rebasing"
-	DisplayString string
-	Action        string // one of "", "pick", "edit", "squash", "reword", "drop", "fixup"
-	Copied        bool   // to know if this commit is ready to be cherry-picked somewhere
-}
-
-// 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)
-	white := color.New(color.FgWhite)
-
-	// 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
-	default:
-		shaColor = white
-	}
-
-	if c.Copied {
-		shaColor = copied
-	}
-
-	actionString := ""
-	if c.Action != "" {
-		actionString = cyan.Sprint(utils.WithPadding(c.Action, 7)) + " "
-	}
-
-	return []string{shaColor.Sprint(c.Sha), actionString + white.Sprint(c.Name)}
-}

pkg/commands/dummies.go

@@ -1,58 +0,0 @@
-package commands
-
-import (
-	"io/ioutil"
-
-	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/sirupsen/logrus"
-	"github.com/spf13/viper"
-	yaml "gopkg.in/yaml.v2"
-)
-
-// This file exports dummy constructors for use by tests in other packages
-
-// NewDummyOSCommand creates a new dummy OSCommand for testing
-func NewDummyOSCommand() *OSCommand {
-	return NewOSCommand(NewDummyLog(), NewDummyAppConfig())
-}
-
-// NewDummyAppConfig creates a new dummy AppConfig for testing
-func NewDummyAppConfig() *config.AppConfig {
-	appConfig := &config.AppConfig{
-		Name:        "lazygit",
-		Version:     "unversioned",
-		Commit:      "",
-		BuildDate:   "",
-		Debug:       false,
-		BuildSource: "",
-		UserConfig:  viper.New(),
-	}
-	_ = yaml.Unmarshal([]byte{}, appConfig.AppState)
-	return appConfig
-}
-
-// NewDummyLog creates a new dummy Log for testing
-func NewDummyLog() *logrus.Entry {
-	log := logrus.New()
-	log.Out = ioutil.Discard
-	return log.WithField("test", "test")
-}
-
-// NewDummyGitCommand creates a new dummy GitCommand for testing
-func NewDummyGitCommand() *GitCommand {
-	return NewDummyGitCommandWithOSCommand(NewDummyOSCommand())
-}
-
-// NewDummyGitCommandWithOSCommand creates a new dummy GitCommand for testing
-func NewDummyGitCommandWithOSCommand(osCommand *OSCommand) *GitCommand {
-	return &GitCommand{
-		Log:                NewDummyLog(),
-		OSCommand:          osCommand,
-		Tr:                 i18n.NewLocalizer(NewDummyLog()),
-		Config:             NewDummyAppConfig(),
-		getGlobalGitConfig: func(string) (string, error) { return "", nil },
-		getLocalGitConfig:  func(string) (string, error) { return "", nil },
-		removeFile:         func(string) error { return nil },
-	}
-}

pkg/commands/exec_live_default.go

@@ -1,100 +0,0 @@
-// +build !windows
-
-package commands
-
-import (
-	"bufio"
-	"bytes"
-	"os"
-	"strings"
-	"unicode/utf8"
-
-	"github.com/go-errors/errors"
-
-	"github.com/jesseduffield/pty"
-	"github.com/mgutz/str"
-)
-
-// RunCommandWithOutputLiveWrapper runs a command and return every word that gets written in stdout
-// Output is a function that executes by every word that gets read by bufio
-// As return of output you need to give a string that will be written to stdin
-// NOTE: If the return data is empty it won't written anything to stdin
-func RunCommandWithOutputLiveWrapper(c *OSCommand, command string, output func(string) string) error {
-	splitCmd := str.ToArgv(command)
-	cmd := c.command(splitCmd[0], splitCmd[1:]...)
-
-	cmd.Env = os.Environ()
-	cmd.Env = append(cmd.Env, "LANG=en_US.UTF-8", "LC_ALL=en_US.UTF-8")
-
-	var stderr bytes.Buffer
-	cmd.Stderr = &stderr
-
-	ptmx, err := pty.Start(cmd)
-
-	if err != nil {
-		return err
-	}
-
-	go func() {
-		scanner := bufio.NewScanner(ptmx)
-		scanner.Split(scanWordsWithNewLines)
-		for scanner.Scan() {
-			toOutput := strings.Trim(scanner.Text(), " ")
-			_, _ = ptmx.WriteString(output(toOutput))
-		}
-	}()
-
-	err = cmd.Wait()
-	ptmx.Close()
-	if err != nil {
-		return errors.New(stderr.String())
-	}
-
-	return nil
-}
-
-// scanWordsWithNewLines is a copy of bufio.ScanWords but this also captures new lines
-// For specific comments about this function take a look at: bufio.ScanWords
-func scanWordsWithNewLines(data []byte, atEOF bool) (advance int, token []byte, err error) {
-	start := 0
-	for width := 0; start < len(data); start += width {
-		var r rune
-		r, width = utf8.DecodeRune(data[start:])
-		if !isSpace(r) {
-			break
-		}
-	}
-	for width, i := 0, start; i < len(data); i += width {
-		var r rune
-		r, width = utf8.DecodeRune(data[i:])
-		if isSpace(r) {
-			return i + width, data[start:i], nil
-		}
-	}
-	if atEOF && len(data) > start {
-		return len(data), data[start:], nil
-	}
-	return start, nil, nil
-}
-
-// isSpace is also copied from the bufio package and has been modified to also captures new lines
-// For specific comments about this function take a look at: bufio.isSpace
-func isSpace(r rune) bool {
-	if r <= '\u00FF' {
-		switch r {
-		case ' ', '\t', '\v', '\f':
-			return true
-		case '\u0085', '\u00A0':
-			return true
-		}
-		return false
-	}
-	if '\u2000' <= r && r <= '\u200a' {
-		return true
-	}
-	switch r {
-	case '\u1680', '\u2028', '\u2029', '\u202f', '\u205f', '\u3000':
-		return true
-	}
-	return false
-}

pkg/commands/exec_live_win.go

@@ -1,9 +0,0 @@
-// +build windows
-
-package commands
-
-// RunCommandWithOutputLiveWrapper runs a command live but because of windows compatibility this command can't be ran there
-// TODO: Remove this hack and replace it with a proper way to run commands live on windows
-func RunCommandWithOutputLiveWrapper(c *OSCommand, command string, output func(string) string) error {
-	return c.RunCommand(command)
-}

pkg/commands/file.go

@@ -1,37 +0,0 @@
-package commands
-
-import "github.com/fatih/color"
-
-// File : A file from git status
-// duplicating this for now
-type File struct {
-	Name                    string
-	HasStagedChanges        bool
-	HasUnstagedChanges      bool
-	Tracked                 bool
-	Deleted                 bool
-	HasMergeConflicts       bool
-	HasInlineMergeConflicts bool
-	DisplayString           string
-	Type                    string // one of 'file', 'directory', and 'other'
-}
-
-// 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_structs.go

@@ -1,5 +1,32 @@
 package commands
 
+// File : A staged/unstaged file
+// TODO: decide whether to give all of these the Git prefix
+type File struct {
+	Name               string
+	HasStagedChanges   bool
+	HasUnstagedChanges bool
+	Tracked            bool
+	Deleted            bool
+	HasMergeConflicts  bool
+	DisplayString      string
+}
+
+// Commit : A git commit
+type Commit struct {
+	Sha           string
+	Name          string
+	Pushed        bool
+	DisplayString string
+}
+
+// StashEntry : A git stash entry
+type StashEntry struct {
+	Index         int
+	Name          string
+	DisplayString string
+}
+
 // Conflict : A git conflict with a start middle and end corresponding to line
 // numbers in the file where the conflict bars appear
 type Conflict struct {

pkg/commands/os.go

@@ -1,114 +1,50 @@
 package commands
 
 import (
-	"io/ioutil"
+	"errors"
 	"os"
 	"os/exec"
-	"path/filepath"
-	"regexp"
+	"runtime"
 	"strings"
 
-	"github.com/go-errors/errors"
+	"github.com/davecgh/go-spew/spew"
 
-	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/jesseduffield/lazygit/pkg/utils"
 	"github.com/mgutz/str"
-	"github.com/sirupsen/logrus"
+
+	"github.com/Sirupsen/logrus"
 	gitconfig "github.com/tcnksm/go-gitconfig"
 )
 
 // Platform stores the os state
 type Platform struct {
-	os                   string
-	shell                string
-	shellArg             string
-	escapedQuote         string
-	openCommand          string
-	openLinkCommand      string
-	fallbackEscapedQuote string
+	os           string
+	shell        string
+	shellArg     string
+	escapedQuote string
 }
 
 // OSCommand holds all the os commands
 type OSCommand struct {
-	Log                *logrus.Entry
-	Platform           *Platform
-	Config             config.AppConfigurer
-	command            func(string, ...string) *exec.Cmd
-	getGlobalGitConfig func(string) (string, error)
-	getenv             func(string) string
+	Log      *logrus.Logger
+	Platform *Platform
 }
 
 // NewOSCommand os command runner
-func NewOSCommand(log *logrus.Entry, config config.AppConfigurer) *OSCommand {
-	return &OSCommand{
-		Log:                log,
-		Platform:           getPlatform(),
-		Config:             config,
-		command:            exec.Command,
-		getGlobalGitConfig: gitconfig.Global,
-		getenv:             os.Getenv,
+func NewOSCommand(log *logrus.Logger) (*OSCommand, error) {
+	osCommand := &OSCommand{
+		Log:      log,
+		Platform: getPlatform(),
 	}
-}
-
-// SetCommand sets the command function used by the struct.
-// To be used for testing only
-func (c *OSCommand) SetCommand(cmd func(string, ...string) *exec.Cmd) {
-	c.command = cmd
+	return osCommand, nil
 }
 
 // RunCommandWithOutput wrapper around commands returning their output and error
 func (c *OSCommand) RunCommandWithOutput(command string) (string, error) {
 	c.Log.WithField("command", command).Info("RunCommand")
-	cmd := c.ExecutableFromString(command)
-	return sanitisedCommandOutput(cmd.CombinedOutput())
-}
-
-// RunExecutableWithOutput runs an executable file and returns its output
-func (c *OSCommand) RunExecutableWithOutput(cmd *exec.Cmd) (string, error) {
-	return sanitisedCommandOutput(cmd.CombinedOutput())
-}
-
-// RunExecutable runs an executable file and returns an error if there was one
-func (c *OSCommand) RunExecutable(cmd *exec.Cmd) error {
-	_, err := c.RunExecutableWithOutput(cmd)
-	return err
-}
-
-// ExecutableFromString takes a string like `git status` and returns an executable command for it
-func (c *OSCommand) ExecutableFromString(commandStr string) *exec.Cmd {
-	splitCmd := str.ToArgv(commandStr)
+	splitCmd := str.ToArgv(command)
 	c.Log.Info(splitCmd)
-	return c.command(splitCmd[0], splitCmd[1:]...)
-}
-
-// RunCommandWithOutputLive runs RunCommandWithOutputLiveWrapper
-func (c *OSCommand) RunCommandWithOutputLive(command string, output func(string) string) error {
-	return RunCommandWithOutputLiveWrapper(c, command, output)
-}
-
-// DetectUnamePass detect a username / password question in a command
-// ask is a function that gets executen when this function detect you need to fillin a password
-// The ask argument will be "username" or "password" and expects the user's password or username back
-func (c *OSCommand) DetectUnamePass(command string, ask func(string) string) error {
-	ttyText := ""
-	errMessage := c.RunCommandWithOutputLive(command, func(word string) string {
-		ttyText = ttyText + " " + word
-
-		prompts := map[string]string{
-			"password": `Password\s*for\s*'.+':`,
-			"username": `Username\s*for\s*'.+':`,
-		}
-
-		for askFor, pattern := range prompts {
-			if match, _ := regexp.MatchString(pattern, ttyText); match {
-				ttyText = ""
-				return ask(askFor)
-			}
-		}
-
-		return ""
-	})
-	return errMessage
+	cmdOut, err := exec.Command(splitCmd[0], splitCmd[1:]...).CombinedOutput()
+	return sanitisedCommandOutput(cmdOut, err)
 }
 
 // RunCommand runs a command and just returns the error
@@ -117,26 +53,16 @@ func (c *OSCommand) RunCommand(command string) error {
 	return err
 }
 
-// FileType tells us if the file is a file, directory or other
-func (c *OSCommand) FileType(path string) string {
-	fileInfo, err := os.Stat(path)
-	if err != nil {
-		return "other"
-	}
-	if fileInfo.IsDir() {
-		return "directory"
-	}
-	return "file"
-}
-
 // RunDirectCommand wrapper around direct commands
 func (c *OSCommand) RunDirectCommand(command string) (string, error) {
 	c.Log.WithField("command", command).Info("RunDirectCommand")
+	args := str.ToArgv(c.Platform.shellArg + " " + command)
+	c.Log.Info(spew.Sdump(args))
 
-	return sanitisedCommandOutput(
-		c.command(c.Platform.shell, c.Platform.shellArg, command).
-			CombinedOutput(),
-	)
+	cmdOut, err := exec.
+		Command(c.Platform.shell, args...).
+		CombinedOutput()
+	return sanitisedCommandOutput(cmdOut, err)
 }
 
 func sanitisedCommandOutput(output []byte, err error) (string, error) {
@@ -144,48 +70,80 @@ func sanitisedCommandOutput(output []byte, err error) (string, error) {
 	if err != nil {
 		// errors like 'exit status 1' are not very useful so we'll create an error
 		// from the combined output
-		if outputString == "" {
-			return "", errors.Wrap(err, 0)
-		}
 		return outputString, errors.New(outputString)
 	}
 	return outputString, nil
 }
 
-// OpenFile opens a file with the given
-func (c *OSCommand) OpenFile(filename string) error {
-	commandTemplate := c.Config.GetUserConfig().GetString("os.openCommand")
-	templateValues := map[string]string{
-		"filename": c.Quote(filename),
+func getPlatform() *Platform {
+	switch runtime.GOOS {
+	case "windows":
+		return &Platform{
+			os:           "windows",
+			shell:        "cmd",
+			shellArg:     "/c",
+			escapedQuote: "\\\"",
+		}
+	default:
+		return &Platform{
+			os:           runtime.GOOS,
+			shell:        "bash",
+			shellArg:     "-c",
+			escapedQuote: "\"",
+		}
 	}
-
-	command := utils.ResolvePlaceholderString(commandTemplate, templateValues)
-	err := c.RunCommand(command)
-	return err
 }
 
-// OpenLink 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),
+// GetOpenCommand get open command
+func (c *OSCommand) GetOpenCommand() (string, string, error) {
+	//NextStep open equivalents: xdg-open (linux), cygstart (cygwin), open (OSX)
+	trailMap := map[string]string{
+		"xdg-open": " &>/dev/null &",
+		"cygstart": "",
+		"open":     "",
 	}
+	for name, trail := range trailMap {
+		if err := c.RunCommand("which " + name); err == nil {
+			return name, trail, nil
+		}
+	}
+	return "", "", errors.New("Unsure what command to use to open this file")
+}
 
-	command := utils.ResolvePlaceholderString(commandTemplate, templateValues)
-	err := c.RunCommand(command)
-	return err
+// VsCodeOpenFile opens the file in code, with the -r flag to open in the
+// current window
+// each of these open files needs to have the same function signature because
+// they're being passed as arguments into another function,
+// but only editFile actually returns a *exec.Cmd
+func (c *OSCommand) VsCodeOpenFile(filename string) (*exec.Cmd, error) {
+	return nil, c.RunCommand("code -r " + filename)
+}
+
+// SublimeOpenFile opens the filein sublime
+// may be deprecated in the future
+func (c *OSCommand) SublimeOpenFile(filename string) (*exec.Cmd, error) {
+	return nil, c.RunCommand("subl " + filename)
+}
+
+// OpenFile opens a file with the given
+func (c *OSCommand) OpenFile(filename string) (*exec.Cmd, error) {
+	cmdName, cmdTrail, err := c.GetOpenCommand()
+	if err != nil {
+		return nil, err
+	}
+	err = c.RunCommand(cmdName + " " + c.Quote(filename) + cmdTrail) // TODO: test on linux
+	return nil, 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) {
-	editor, _ := c.getGlobalGitConfig("core.editor")
-
+	editor, _ := gitconfig.Global("core.editor")
 	if editor == "" {
-		editor = c.getenv("VISUAL")
+		editor = os.Getenv("VISUAL")
 	}
 	if editor == "" {
-		editor = c.getenv("EDITOR")
+		editor = os.Getenv("EDITOR")
 	}
 	if editor == "" {
 		if err := c.RunCommand("which vi"); err == nil {
@@ -195,104 +153,17 @@ func (c *OSCommand) EditFile(filename string) (*exec.Cmd, error) {
 	if editor == "" {
 		return nil, errors.New("No editor defined in $VISUAL, $EDITOR, or git config")
 	}
-
-	return c.PrepareSubProcess(editor, filename), nil
+	return c.PrepareSubProcess(editor, filename)
 }
 
 // PrepareSubProcess iniPrepareSubProcessrocess then tells the Gui to switch to it
-func (c *OSCommand) PrepareSubProcess(cmdName string, commandArgs ...string) *exec.Cmd {
-	return c.command(cmdName, commandArgs...)
+func (c *OSCommand) PrepareSubProcess(cmdName string, commandArgs ...string) (*exec.Cmd, error) {
+	subprocess := exec.Command(cmdName, commandArgs...)
+	return subprocess, nil
 }
 
 // Quote wraps a message in platform-specific quotation marks
 func (c *OSCommand) Quote(message string) string {
 	message = strings.Replace(message, "`", "\\`", -1)
-	escapedQuote := c.Platform.escapedQuote
-	if strings.Contains(message, c.Platform.escapedQuote) {
-		escapedQuote = c.Platform.fallbackEscapedQuote
-	}
-	return escapedQuote + message + escapedQuote
-}
-
-// Unquote removes wrapping quotations marks if they are present
-// this is needed for removing quotes from staged filenames with spaces
-func (c *OSCommand) Unquote(message string) string {
-	return strings.Replace(message, `"`, "", -1)
-}
-
-// AppendLineToFile adds a new line in file
-func (c *OSCommand) AppendLineToFile(filename, line string) error {
-	f, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
-	if err != nil {
-		return errors.Wrap(err, 0)
-	}
-	defer f.Close()
-
-	_, err = f.WriteString("\n" + line)
-	if err != nil {
-		return errors.Wrap(err, 0)
-	}
-	return nil
-}
-
-// CreateTempFile writes a string to a new temp file and returns the file's name
-func (c *OSCommand) CreateTempFile(filename, content string) (string, error) {
-	tmpfile, err := ioutil.TempFile("", filename)
-	if err != nil {
-		c.Log.Error(err)
-		return "", errors.Wrap(err, 0)
-	}
-
-	if _, err := tmpfile.WriteString(content); err != nil {
-		c.Log.Error(err)
-		return "", errors.Wrap(err, 0)
-	}
-	if err := tmpfile.Close(); err != nil {
-		c.Log.Error(err)
-		return "", errors.Wrap(err, 0)
-	}
-
-	return tmpfile.Name(), nil
-}
-
-// RemoveFile removes a file at the specified path
-func (c *OSCommand) RemoveFile(filename string) error {
-	err := os.Remove(filename)
-	return errors.Wrap(err, 0)
-}
-
-// FileExists checks whether a file exists at the specified path
-func (c *OSCommand) FileExists(path string) (bool, error) {
-	if _, err := os.Stat(path); err != nil {
-		if os.IsNotExist(err) {
-			return false, nil
-		}
-		return false, err
-	}
-	return true, nil
-}
-
-// RunPreparedCommand takes a pointer to an exec.Cmd and runs it
-// this is useful if you need to give your command some environment variables
-// before running it
-func (c *OSCommand) RunPreparedCommand(cmd *exec.Cmd) error {
-	out, err := cmd.CombinedOutput()
-	outString := string(out)
-	c.Log.Info(outString)
-	if err != nil {
-		if len(outString) == 0 {
-			return err
-		}
-		return errors.New(outString)
-	}
-	return nil
-}
-
-// GetLazygitPath returns the path of the currently executed file
-func (c *OSCommand) GetLazygitPath() string {
-	ex, err := os.Executable() // get the executable path for git to use
-	if err != nil {
-		ex = os.Args[0] // fallback to the first call argument if needed
-	}
-	return filepath.ToSlash(ex)
+	return c.Platform.escapedQuote + message + c.Platform.escapedQuote
 }

pkg/commands/os_default_platform.go

@@ -1,19 +0,0 @@
-// +build !windows
-
-package commands
-
-import (
-	"runtime"
-)
-
-func getPlatform() *Platform {
-	return &Platform{
-		os:                   runtime.GOOS,
-		shell:                "bash",
-		shellArg:             "-c",
-		escapedQuote:         "'",
-		openCommand:          "open {{filename}}",
-		openLinkCommand:      "open {{link}}",
-		fallbackEscapedQuote: "\"",
-	}
-}

pkg/commands/os_test.go

@@ -1,377 +1,16 @@
 package commands
 
-import (
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"testing"
+import "testing"
 
-	"github.com/stretchr/testify/assert"
-)
-
-// TestOSCommandRunCommandWithOutput is a function.
-func TestOSCommandRunCommandWithOutput(t *testing.T) {
-	type scenario struct {
-		command string
-		test    func(string, error)
+func TestQuote(t *testing.T) {
+	osCommand := &OSCommand{
+		Log:      nil,
+		Platform: getPlatform(),
 	}
-
-	scenarios := []scenario{
-		{
-			"echo -n '123'",
-			func(output string, err error) {
-				assert.NoError(t, err)
-				assert.EqualValues(t, "123", output)
-			},
-		},
-		{
-			"rmdir unexisting-folder",
-			func(output string, err error) {
-				assert.Regexp(t, "rmdir.*unexisting-folder.*", err.Error())
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		s.test(NewDummyOSCommand().RunCommandWithOutput(s.command))
-	}
-}
-
-// TestOSCommandRunCommand is a function.
-func TestOSCommandRunCommand(t *testing.T) {
-	type scenario struct {
-		command string
-		test    func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"rmdir unexisting-folder",
-			func(err error) {
-				assert.Regexp(t, "rmdir.*unexisting-folder.*", err.Error())
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		s.test(NewDummyOSCommand().RunCommand(s.command))
-	}
-}
-
-// TestOSCommandOpenFile is a function.
-func TestOSCommandOpenFile(t *testing.T) {
-	type scenario struct {
-		filename string
-		command  func(string, ...string) *exec.Cmd
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				return exec.Command("exit", "1")
-			},
-			func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "open", name)
-				assert.Equal(t, []string{"test"}, arg)
-				return exec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"filename with spaces",
-			func(name string, arg ...string) *exec.Cmd {
-				assert.Equal(t, "open", name)
-				assert.Equal(t, []string{"filename with spaces"}, arg)
-				return exec.Command("echo")
-			},
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		OSCmd := NewDummyOSCommand()
-		OSCmd.command = s.command
-		OSCmd.Config.GetUserConfig().Set("os.openCommand", "open {{filename}}")
-
-		s.test(OSCmd.OpenFile(s.filename))
-	}
-}
-
-// TestOSCommandEditFile is a function.
-func TestOSCommandEditFile(t *testing.T) {
-	type scenario struct {
-		filename           string
-		command            func(string, ...string) *exec.Cmd
-		getenv             func(string) string
-		getGlobalGitConfig func(string) (string, error)
-		test               func(*exec.Cmd, error)
-	}
-
-	scenarios := []scenario{
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				return exec.Command("exit", "1")
-			},
-			func(env string) string {
-				return ""
-			},
-			func(cf string) (string, error) {
-				return "", nil
-			},
-			func(cmd *exec.Cmd, err error) {
-				assert.EqualError(t, err, "No editor defined in $VISUAL, $EDITOR, or git config")
-			},
-		},
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				if name == "which" {
-					return exec.Command("exit", "1")
-				}
-
-				assert.EqualValues(t, "nano", name)
-
-				return nil
-			},
-			func(env string) string {
-				return ""
-			},
-			func(cf string) (string, error) {
-				return "nano", nil
-			},
-			func(cmd *exec.Cmd, err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				if name == "which" {
-					return exec.Command("exit", "1")
-				}
-
-				assert.EqualValues(t, "nano", name)
-
-				return nil
-			},
-			func(env string) string {
-				if env == "VISUAL" {
-					return "nano"
-				}
-
-				return ""
-			},
-			func(cf string) (string, error) {
-				return "", nil
-			},
-			func(cmd *exec.Cmd, err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				if name == "which" {
-					return exec.Command("exit", "1")
-				}
-
-				assert.EqualValues(t, "emacs", name)
-
-				return nil
-			},
-			func(env string) string {
-				if env == "EDITOR" {
-					return "emacs"
-				}
-
-				return ""
-			},
-			func(cf string) (string, error) {
-				return "", nil
-			},
-			func(cmd *exec.Cmd, err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"test",
-			func(name string, arg ...string) *exec.Cmd {
-				if name == "which" {
-					return exec.Command("echo")
-				}
-
-				assert.EqualValues(t, "vi", name)
-
-				return nil
-			},
-			func(env string) string {
-				return ""
-			},
-			func(cf string) (string, error) {
-				return "", nil
-			},
-			func(cmd *exec.Cmd, err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		OSCmd := NewDummyOSCommand()
-		OSCmd.command = s.command
-		OSCmd.getGlobalGitConfig = s.getGlobalGitConfig
-		OSCmd.getenv = s.getenv
-
-		s.test(OSCmd.EditFile(s.filename))
-	}
-}
-
-// TestOSCommandQuote is a function.
-func TestOSCommandQuote(t *testing.T) {
-	osCommand := NewDummyOSCommand()
-
-	actual := osCommand.Quote("hello `test`")
-
+	test := "hello `test`"
 	expected := osCommand.Platform.escapedQuote + "hello \\`test\\`" + osCommand.Platform.escapedQuote
-
-	assert.EqualValues(t, expected, actual)
-}
-
-// TestOSCommandQuoteSingleQuote tests the quote function with ' quotes explicitly for Linux
-func TestOSCommandQuoteSingleQuote(t *testing.T) {
-	osCommand := NewDummyOSCommand()
-
-	osCommand.Platform.os = "linux"
-
-	actual := osCommand.Quote("hello 'test'")
-
-	expected := osCommand.Platform.fallbackEscapedQuote + "hello 'test'" + osCommand.Platform.fallbackEscapedQuote
-
-	assert.EqualValues(t, expected, actual)
-}
-
-// TestOSCommandQuoteDoubleQuote tests the quote function with " quotes explicitly for Linux
-func TestOSCommandQuoteDoubleQuote(t *testing.T) {
-	osCommand := NewDummyOSCommand()
-
-	osCommand.Platform.os = "linux"
-
-	actual := osCommand.Quote(`hello "test"`)
-
-	expected := osCommand.Platform.escapedQuote + "hello \"test\"" + osCommand.Platform.escapedQuote
-
-	assert.EqualValues(t, expected, actual)
-}
-
-// TestOSCommandUnquote is a function.
-func TestOSCommandUnquote(t *testing.T) {
-	osCommand := NewDummyOSCommand()
-
-	actual := osCommand.Unquote(`hello "test"`)
-
-	expected := "hello test"
-
-	assert.EqualValues(t, expected, actual)
-}
-
-// TestOSCommandFileType is a function.
-func TestOSCommandFileType(t *testing.T) {
-	type scenario struct {
-		path  string
-		setup func()
-		test  func(string)
-	}
-
-	scenarios := []scenario{
-		{
-			"testFile",
-			func() {
-				if _, err := os.Create("testFile"); err != nil {
-					panic(err)
-				}
-			},
-			func(output string) {
-				assert.EqualValues(t, "file", output)
-			},
-		},
-		{
-			"file with spaces",
-			func() {
-				if _, err := os.Create("file with spaces"); err != nil {
-					panic(err)
-				}
-			},
-			func(output string) {
-				assert.EqualValues(t, "file", output)
-			},
-		},
-		{
-			"testDirectory",
-			func() {
-				if err := os.Mkdir("testDirectory", 0644); err != nil {
-					panic(err)
-				}
-			},
-			func(output string) {
-				assert.EqualValues(t, "directory", output)
-			},
-		},
-		{
-			"nonExistant",
-			func() {},
-			func(output string) {
-				assert.EqualValues(t, "other", output)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		s.setup()
-		s.test(NewDummyOSCommand().FileType(s.path))
-		_ = os.RemoveAll(s.path)
-	}
-}
-
-func TestOSCommandCreateTempFile(t *testing.T) {
-	type scenario struct {
-		testName string
-		filename string
-		content  string
-		test     func(string, error)
-	}
-
-	scenarios := []scenario{
-		{
-			"valid case",
-			"filename",
-			"content",
-			func(path string, err error) {
-				assert.NoError(t, err)
-
-				content, err := ioutil.ReadFile(path)
-				assert.NoError(t, err)
-
-				assert.Equal(t, "content", string(content))
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			s.test(NewDummyOSCommand().CreateTempFile(s.filename, s.content))
-		})
+	test = osCommand.Quote(test)
+	if test != expected {
+		t.Error("Expected " + expected + ", got " + test)
 	}
 }

pkg/commands/os_windows.go

@@ -1,11 +0,0 @@
-package commands
-
-func getPlatform() *Platform {
-	return &Platform{
-		os:                   "windows",
-		shell:                "cmd",
-		shellArg:             "/c",
-		escapedQuote:         `\"`,
-		fallbackEscapedQuote: "\\'",
-	}
-}

pkg/commands/pull_request.go

@@ -1,106 +0,0 @@
-package commands
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/go-errors/errors"
-)
-
-// 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

@@ -1,154 +0,0 @@
-package commands
-
-import (
-	"os/exec"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// TestGetRepoInfoFromURL is a function.
-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))
-		})
-	}
-}
-
-// TestCreatePullRequest is a function.
-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/commands/stash_entry.go

@@ -1,13 +0,0 @@
-package commands
-
-// StashEntry : A git stash entry
-type StashEntry struct {
-	Index         int
-	Name          string
-	DisplayString string
-}
-
-// GetDisplayStrings returns the dispaly string of branch
-func (s *StashEntry) GetDisplayStrings(isFocused bool) []string {
-	return []string{s.DisplayString}
-}

pkg/config/app_config.go

@@ -2,26 +2,19 @@ package config
 
 import (
 	"bytes"
-	"io/ioutil"
-	"os"
-	"path/filepath"
 
 	"github.com/shibukawa/configdir"
 	"github.com/spf13/viper"
-	yaml "gopkg.in/yaml.v2"
 )
 
 // AppConfig contains the base configuration fields required for lazygit.
 type AppConfig struct {
-	Debug       bool   `long:"debug" env:"DEBUG" default:"false"`
-	Version     string `long:"version" env:"VERSION" default:"unversioned"`
-	Commit      string `long:"commit" env:"COMMIT"`
-	BuildDate   string `long:"build-date" env:"BUILD_DATE"`
-	Name        string `long:"name" env:"NAME" default:"lazygit"`
-	BuildSource string `long:"build-source" env:"BUILD_SOURCE" default:""`
-	UserConfig  *viper.Viper
-	AppState    *AppState
-	IsNewRepo   bool
+	Debug      bool   `long:"debug" env:"DEBUG" default:"false"`
+	Version    string `long:"version" env:"VERSION" default:"unversioned"`
+	Commit     string `long:"commit" env:"COMMIT"`
+	BuildDate  string `long:"build-date" env:"BUILD_DATE"`
+	Name       string `long:"name" env:"NAME" default:"lazygit"`
+	UserConfig *viper.Viper
 }
 
 // AppConfigurer interface allows individual app config structs to inherit Fields
@@ -32,56 +25,28 @@ type AppConfigurer interface {
 	GetCommit() string
 	GetBuildDate() string
 	GetName() string
-	GetBuildSource() string
 	GetUserConfig() *viper.Viper
-	GetAppState() *AppState
-	WriteToUserConfig(string, string) error
-	SaveAppState() error
-	LoadAppState() error
-	SetIsNewRepo(bool)
-	GetIsNewRepo() bool
+	InsertToUserConfig(string, string) error
 }
 
 // NewAppConfig makes a new app config
-func NewAppConfig(name, version, commit, date string, buildSource string, debuggingFlag bool) (*AppConfig, error) {
-	userConfig, err := LoadConfig("config", true)
+func NewAppConfig(name, version, commit, date string, debuggingFlag *bool) (*AppConfig, error) {
+	userConfig, err := LoadUserConfig()
 	if err != nil {
-		return nil, err
-	}
-
-	if os.Getenv("DEBUG") == "TRUE" {
-		debuggingFlag = true
+		panic(err)
 	}
 
 	appConfig := &AppConfig{
-		Name:        "lazygit",
-		Version:     version,
-		Commit:      commit,
-		BuildDate:   date,
-		Debug:       debuggingFlag,
-		BuildSource: buildSource,
-		UserConfig:  userConfig,
-		AppState:    &AppState{},
-		IsNewRepo:   false,
+		Name:       "lazygit",
+		Version:    version,
+		Commit:     commit,
+		BuildDate:  date,
+		Debug:      *debuggingFlag,
+		UserConfig: userConfig,
 	}
-
-	if err := appConfig.LoadAppState(); err != nil {
-		return nil, err
-	}
-
 	return appConfig, nil
 }
 
-// GetIsNewRepo returns known repo boolean
-func (c *AppConfig) GetIsNewRepo() bool {
-	return c.IsNewRepo
-}
-
-// SetIsNewRepo set if the current repo is known
-func (c *AppConfig) SetIsNewRepo(toSet bool) {
-	c.IsNewRepo = toSet
-}
-
 // GetDebug returns debug flag
 func (c *AppConfig) GetDebug() bool {
 	return c.Debug
@@ -107,167 +72,98 @@ func (c *AppConfig) GetName() string {
 	return c.Name
 }
 
-// GetBuildSource returns the source of the build. For builds from goreleaser
-// this will be binaryBuild
-func (c *AppConfig) GetBuildSource() string {
-	return c.BuildSource
-}
-
 // GetUserConfig returns the user config
 func (c *AppConfig) GetUserConfig() *viper.Viper {
 	return c.UserConfig
 }
 
-// GetAppState returns the app state
-func (c *AppConfig) GetAppState() *AppState {
-	return c.AppState
-}
-
-func newViper(filename string) (*viper.Viper, error) {
+func newViper() (*viper.Viper, error) {
 	v := viper.New()
 	v.SetConfigType("yaml")
-	v.SetConfigName(filename)
+	v.SetConfigName("config")
 	return v, nil
 }
 
-// LoadConfig gets the user's config
-func LoadConfig(filename string, withDefaults bool) (*viper.Viper, error) {
-	v, err := newViper(filename)
+// LoadUserConfig gets the user's config
+func LoadUserConfig() (*viper.Viper, error) {
+	v, err := newViper()
 	if err != nil {
+		panic(err)
+	}
+	if err = LoadDefaultConfig(v); err != nil {
 		return nil, err
 	}
-	if withDefaults {
-		if err = LoadDefaults(v, GetDefaultConfig()); err != nil {
-			return nil, err
-		}
-		if err = LoadDefaults(v, GetPlatformDefaultConfig()); err != nil {
-			return nil, err
-		}
-	}
-	if err = LoadAndMergeFile(v, filename+".yml"); err != nil {
+	if err = LoadUserConfigFromFile(v); err != nil {
 		return nil, err
 	}
 	return v, nil
 }
 
-// LoadDefaults loads in the defaults defined in this file
-func LoadDefaults(v *viper.Viper, defaults []byte) error {
-	return v.MergeConfig(bytes.NewBuffer(defaults))
+// LoadDefaultConfig loads in the defaults defined in this file
+func LoadDefaultConfig(v *viper.Viper) error {
+	defaults := getDefaultConfig()
+	return v.ReadConfig(bytes.NewBuffer(defaults))
 }
 
-func prepareConfigFile(filename string) (string, error) {
+// LoadUserConfigFromFile Loads the user config from their config file, creating
+// the file as an empty config if it does not exist
+func LoadUserConfigFromFile(v *viper.Viper) error {
 	// chucking my name there is not for vanity purposes, the xdg spec (and that
 	// function) requires a vendor name. May as well line up with github
 	configDirs := configdir.New("jesseduffield", "lazygit")
-	folder := configDirs.QueryFolderContainsFile(filename)
+	folder := configDirs.QueryFolderContainsFile("config.yml")
 	if folder == nil {
-		// create the file as empty
+		// create the file as an empty config and load it
 		folders := configDirs.QueryFolders(configdir.Global)
-		if err := folders[0].WriteFile(filename, []byte{}); err != nil {
-			return "", err
+		if err := folders[0].WriteFile("config.yml", []byte{}); err != nil {
+			return err
 		}
-		folder = configDirs.QueryFolderContainsFile(filename)
+		folder = configDirs.QueryFolderContainsFile("config.yml")
 	}
-	return filepath.Join(folder.Path, filename), nil
+	v.AddConfigPath(folder.Path)
+	if err := v.MergeInConfig(); err != nil {
+		return err
+	}
+	return nil
 }
 
-// LoadAndMergeFile Loads the config/state file, creating
-// the file has an empty one if it does not exist
-func LoadAndMergeFile(v *viper.Viper, filename string) error {
-	configPath, err := prepareConfigFile(filename)
+// InsertToUserConfig adds a key/value pair to the user's config and saves it
+func (c *AppConfig) InsertToUserConfig(key, value string) error {
+	// making a new viper object so that we're not writing any defaults back
+	// to the user's config file
+	v, err := newViper()
 	if err != nil {
 		return err
 	}
-
-	v.AddConfigPath(filepath.Dir(configPath))
-	return v.MergeInConfig()
-}
-
-// WriteToUserConfig adds a key/value pair to the user's config and saves it
-func (c *AppConfig) WriteToUserConfig(key, value string) error {
-	// reloading the user config directly (without defaults) so that we're not
-	// writing any defaults back to the user's config
-	v, err := LoadConfig("config", false)
-	if err != nil {
+	if err = LoadUserConfigFromFile(v); err != nil {
 		return err
 	}
-
 	v.Set(key, value)
-	return v.WriteConfig()
-}
-
-// SaveAppState marhsalls the AppState struct and writes it to the disk
-func (c *AppConfig) SaveAppState() error {
-	marshalledAppState, err := yaml.Marshal(c.AppState)
-	if err != nil {
+	if err := v.WriteConfig(); err != nil {
 		return err
 	}
-
-	filepath, err := prepareConfigFile("state.yml")
-	if err != nil {
-		return err
-	}
-
-	return ioutil.WriteFile(filepath, marshalledAppState, 0644)
+	return nil
 }
 
-// LoadAppState loads recorded AppState from file
-func (c *AppConfig) LoadAppState() error {
-	filepath, err := prepareConfigFile("state.yml")
-	if err != nil {
-		return err
-	}
-	appStateBytes, err := ioutil.ReadFile(filepath)
-	if err != nil {
-		return err
-	}
-	if len(appStateBytes) == 0 {
-		return yaml.Unmarshal(getDefaultAppState(), c.AppState)
-	}
-	return yaml.Unmarshal(appStateBytes, c.AppState)
-}
-
-// GetDefaultConfig returns the application default configuration
-func GetDefaultConfig() []byte {
-	return []byte(
-		`gui:
-  ## stuff relating to the UI
-  scrollHeight: 2
-  scrollPastBottom: true
-  mouseEvents: false # will default to true when the feature is complete
-  theme:
-    activeBorderColor:
-      - white
-      - bold
-    inactiveBorderColor:
-      - white
-    optionsTextColor:
-      - blue
-  commitLength:
-    show: true
-  git:
-    merging:
-      manualCommit: false
-update:
-  method: prompt # can be: prompt | background | never
-  days: 14 # how often a update is checked for
-reporting: 'undetermined' # one of: 'on' | 'off' | 'undetermined'
-confirmOnQuit: false
-`)
-}
-
-// AppState stores data between runs of the app like when the last update check
-// was performed and which other repos have been checked out
-type AppState struct {
-	LastUpdateCheck int64
-	RecentRepos     []string
-}
-
-func getDefaultAppState() []byte {
+func getDefaultConfig() []byte {
 	return []byte(`
-    lastUpdateCheck: 0
-    recentRepos: []
-  `)
+  gui:
+    ## stuff relating to the UI
+    scrollHeight: 2
+    theme:
+      activeBorderColor:
+        - white
+        - bold
+      inactiveBorderColor:
+        - white
+      optionsTextColor:
+        - blue
+  git:
+    # stuff relating to git
+  os:
+    # stuff relating to the OS
+
+`)
 }
 
 // // commenting this out until we use it again

pkg/config/config_default_platform.go

@@ -1,11 +0,0 @@
-// +build !windows,!linux
-
-package config
-
-// GetPlatformDefaultConfig gets the defaults for the platform
-func GetPlatformDefaultConfig() []byte {
-	return []byte(
-		`os:
-  openCommand: 'open {{filename}}'
-  openLinkCommand: 'open {{link}}'`)
-}

pkg/config/config_linux.go

@@ -1,9 +0,0 @@
-package config
-
-// GetPlatformDefaultConfig gets the defaults for the platform
-func GetPlatformDefaultConfig() []byte {
-	return []byte(
-		`os:
-  openCommand: 'sh -c "xdg-open {{filename}} >/dev/null"'
-  openLinkCommand: 'sh -c "xdg-open {{link}} >/dev/null"'`)
-}

pkg/config/config_windows.go

@@ -1,9 +0,0 @@
-package config
-
-// GetPlatformDefaultConfig gets the defaults for the platform
-func GetPlatformDefaultConfig() []byte {
-	return []byte(
-		`os:
-  openCommand: 'cmd /c "start "" {{filename}}"'
-  openLinkCommand: 'cmd /c "start "" {{link}}"'`)
-}

pkg/git/branch_list_builder.go

@@ -7,7 +7,7 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/commands"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 
-	"github.com/sirupsen/logrus"
+	"github.com/Sirupsen/logrus"
 
 	"gopkg.in/src-d/go-git.v4/plumbing"
 )
@@ -20,34 +20,35 @@ import (
 // our safe branches, then add the remaining safe branches, ensuring uniqueness
 // along the way
 
-// 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
-
 // BranchListBuilder returns a list of Branch objects for the current repo
 type BranchListBuilder struct {
-	Log        *logrus.Entry
+	Log        *logrus.Logger
 	GitCommand *commands.GitCommand
 }
 
 // NewBranchListBuilder builds a new branch list builder
-func NewBranchListBuilder(log *logrus.Entry, gitCommand *commands.GitCommand) (*BranchListBuilder, error) {
+func NewBranchListBuilder(log *logrus.Logger, gitCommand *commands.GitCommand) (*BranchListBuilder, error) {
 	return &BranchListBuilder{
 		Log:        log,
 		GitCommand: gitCommand,
 	}, nil
 }
 
-func (b *BranchListBuilder) obtainCurrentBranch() *commands.Branch {
-	branchName, err := b.GitCommand.CurrentBranchName()
+func (b *BranchListBuilder) obtainCurrentBranch() commands.Branch {
+	// I used go-git for this, but that breaks if you've just done a git init,
+	// even though you're on 'master'
+	branchName, err := b.GitCommand.OSCommand.RunCommandWithOutput("git symbolic-ref --short HEAD")
 	if err != nil {
-		panic(err.Error())
+		branchName, err = b.GitCommand.OSCommand.RunCommandWithOutput("git rev-parse --short HEAD")
+		if err != nil {
+			panic(err.Error())
+		}
 	}
-
-	return &commands.Branch{Name: strings.TrimSpace(branchName)}
+	return commands.Branch{Name: strings.TrimSpace(branchName), Recency: "  *"}
 }
 
-func (b *BranchListBuilder) obtainReflogBranches() []*commands.Branch {
-	branches := make([]*commands.Branch, 0)
+func (b *BranchListBuilder) obtainReflogBranches() []commands.Branch {
+	branches := make([]commands.Branch, 0)
 	rawString, err := b.GitCommand.OSCommand.RunCommandWithOutput("git reflog -n100 --pretty='%cr|%gs' --grep-reflog='checkout: moving' HEAD")
 	if err != nil {
 		return branches
@@ -57,14 +58,14 @@ func (b *BranchListBuilder) obtainReflogBranches() []*commands.Branch {
 	for _, line := range branchLines {
 		timeNumber, timeUnit, branchName := branchInfoFromLine(line)
 		timeUnit = abbreviatedTimeUnit(timeUnit)
-		branch := &commands.Branch{Name: branchName, Recency: timeNumber + timeUnit}
+		branch := commands.Branch{Name: branchName, Recency: timeNumber + timeUnit}
 		branches = append(branches, branch)
 	}
-	return uniqueByName(branches)
+	return branches
 }
 
-func (b *BranchListBuilder) obtainSafeBranches() []*commands.Branch {
-	branches := make([]*commands.Branch, 0)
+func (b *BranchListBuilder) obtainSafeBranches() []commands.Branch {
+	branches := make([]commands.Branch, 0)
 
 	bIter, err := b.GitCommand.Repo.Branches()
 	if err != nil {
@@ -72,14 +73,14 @@ func (b *BranchListBuilder) obtainSafeBranches() []*commands.Branch {
 	}
 	err = bIter.ForEach(func(b *plumbing.Reference) error {
 		name := b.Name().Short()
-		branches = append(branches, &commands.Branch{Name: name})
+		branches = append(branches, commands.Branch{Name: name})
 		return nil
 	})
 
 	return branches
 }
 
-func (b *BranchListBuilder) appendNewBranches(finalBranches, newBranches, existingBranches []*commands.Branch, included bool) []*commands.Branch {
+func (b *BranchListBuilder) appendNewBranches(finalBranches, newBranches, existingBranches []commands.Branch, included bool) []commands.Branch {
 	for _, newBranch := range newBranches {
 		if included == branchIncluded(newBranch.Name, existingBranches) {
 			finalBranches = append(finalBranches, newBranch)
@@ -88,7 +89,7 @@ func (b *BranchListBuilder) appendNewBranches(finalBranches, newBranches, existi
 	return finalBranches
 }
 
-func sanitisedReflogName(reflogBranch *commands.Branch, safeBranches []*commands.Branch) string {
+func sanitisedReflogName(reflogBranch commands.Branch, safeBranches []commands.Branch) string {
 	for _, safeBranch := range safeBranches {
 		if strings.ToLower(safeBranch.Name) == strings.ToLower(reflogBranch.Name) {
 			return safeBranch.Name
@@ -98,12 +99,15 @@ func sanitisedReflogName(reflogBranch *commands.Branch, safeBranches []*commands
 }
 
 // Build the list of branches for the current repo
-func (b *BranchListBuilder) Build() []*commands.Branch {
-	branches := make([]*commands.Branch, 0)
+func (b *BranchListBuilder) Build() []commands.Branch {
+	branches := make([]commands.Branch, 0)
 	head := b.obtainCurrentBranch()
 	safeBranches := b.obtainSafeBranches()
-
+	if len(safeBranches) == 0 {
+		return append(branches, head)
+	}
 	reflogBranches := b.obtainReflogBranches()
+	reflogBranches = uniqueByName(append([]commands.Branch{head}, reflogBranches...))
 	for i, reflogBranch := range reflogBranches {
 		reflogBranches[i].Name = sanitisedReflogName(reflogBranch, safeBranches)
 	}
@@ -111,16 +115,10 @@ func (b *BranchListBuilder) Build() []*commands.Branch {
 	branches = b.appendNewBranches(branches, reflogBranches, safeBranches, true)
 	branches = b.appendNewBranches(branches, safeBranches, branches, false)
 
-	if len(branches) == 0 || branches[0].Name != head.Name {
-		branches = append([]*commands.Branch{head}, branches...)
-	}
-
-	branches[0].Recency = "  *"
-
 	return branches
 }
 
-func branchIncluded(branchName string, branches []*commands.Branch) bool {
+func branchIncluded(branchName string, branches []commands.Branch) bool {
 	for _, existingBranch := range branches {
 		if strings.ToLower(existingBranch.Name) == strings.ToLower(branchName) {
 			return true
@@ -129,8 +127,8 @@ func branchIncluded(branchName string, branches []*commands.Branch) bool {
 	return false
 }
 
-func uniqueByName(branches []*commands.Branch) []*commands.Branch {
-	finalBranches := make([]*commands.Branch, 0)
+func uniqueByName(branches []commands.Branch) []commands.Branch {
+	finalBranches := make([]commands.Branch, 0)
 	for _, branch := range branches {
 		if branchIncluded(branch.Name, finalBranches) {
 			continue

pkg/git/commit_list_builder.go

@@ -1,288 +0,0 @@
-package git
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/sirupsen/logrus"
-)
-
-// context:
-// here we get the commits from git log but format them to show whether they're
-// unpushed/pushed/merged into the base branch or not, or if they're yet to
-// be processed as part of a rebase (these won't appear in git log but we
-// grab them from the rebase-related files in the .git directory to show them
-
-// 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
-
-// CommitListBuilder returns a list of Branch objects for the current repo
-type CommitListBuilder struct {
-	Log                 *logrus.Entry
-	GitCommand          *commands.GitCommand
-	OSCommand           *commands.OSCommand
-	Tr                  *i18n.Localizer
-	CherryPickedCommits []*commands.Commit
-}
-
-// NewCommitListBuilder builds a new commit list builder
-func NewCommitListBuilder(log *logrus.Entry, gitCommand *commands.GitCommand, osCommand *commands.OSCommand, tr *i18n.Localizer, cherryPickedCommits []*commands.Commit) (*CommitListBuilder, error) {
-	return &CommitListBuilder{
-		Log:                 log,
-		GitCommand:          gitCommand,
-		OSCommand:           osCommand,
-		Tr:                  tr,
-		CherryPickedCommits: cherryPickedCommits,
-	}, nil
-}
-
-// GetCommits obtains the commits of the current branch
-func (c *CommitListBuilder) GetCommits() ([]*commands.Commit, error) {
-	commits := []*commands.Commit{}
-	var rebasingCommits []*commands.Commit
-	rebaseMode, err := c.GitCommand.RebaseMode()
-	if err != nil {
-		return nil, err
-	}
-	if rebaseMode != "" {
-		// here we want to also prepend the commits that we're in the process of rebasing
-		rebasingCommits, err = c.getRebasingCommits(rebaseMode)
-		if err != nil {
-			return nil, err
-		}
-		if len(rebasingCommits) > 0 {
-			commits = append(commits, rebasingCommits...)
-		}
-	}
-
-	unpushedCommits := c.getUnpushedCommits()
-	log := c.getLog()
-
-	// now we can split it up and turn it into commits
-	for _, line := range utils.SplitLines(log) {
-		splitLine := strings.Split(line, " ")
-		sha := splitLine[0]
-		_, unpushed := unpushedCommits[sha]
-		status := map[bool]string{true: "unpushed", false: "pushed"}[unpushed]
-		commits = append(commits, &commands.Commit{
-			Sha:           sha,
-			Name:          strings.Join(splitLine[1:], " "),
-			Status:        status,
-			DisplayString: strings.Join(splitLine, " "),
-		})
-	}
-	if rebaseMode != "" {
-		currentCommit := commits[len(rebasingCommits)]
-		blue := color.New(color.FgYellow)
-		youAreHere := blue.Sprintf("<-- %s ---", c.Tr.SLocalize("YouAreHere"))
-		currentCommit.Name = fmt.Sprintf("%s %s", youAreHere, currentCommit.Name)
-	}
-
-	commits, err = c.setCommitMergedStatuses(commits)
-	if err != nil {
-		return nil, err
-	}
-
-	commits, err = c.setCommitCherryPickStatuses(commits)
-	if err != nil {
-		return nil, err
-	}
-
-	return commits, nil
-}
-
-// getRebasingCommits obtains the commits that we're in the process of rebasing
-func (c *CommitListBuilder) getRebasingCommits(rebaseMode string) ([]*commands.Commit, error) {
-	switch rebaseMode {
-	case "normal":
-		return c.getNormalRebasingCommits()
-	case "interactive":
-		return c.getInteractiveRebasingCommits()
-	default:
-		return nil, nil
-	}
-}
-
-func (c *CommitListBuilder) getNormalRebasingCommits() ([]*commands.Commit, error) {
-	rewrittenCount := 0
-	bytesContent, err := ioutil.ReadFile(".git/rebase-apply/rewritten")
-	if err == nil {
-		content := string(bytesContent)
-		rewrittenCount = len(strings.Split(content, "\n"))
-	}
-
-	// we know we're rebasing, so lets get all the files whose names have numbers
-	commits := []*commands.Commit{}
-	err = filepath.Walk(".git/rebase-apply", func(path string, f os.FileInfo, err error) error {
-		if rewrittenCount > 0 {
-			rewrittenCount--
-			return nil
-		}
-		if err != nil {
-			return err
-		}
-		re := regexp.MustCompile(`^\d+$`)
-		if !re.MatchString(f.Name()) {
-			return nil
-		}
-		bytesContent, err := ioutil.ReadFile(path)
-		if err != nil {
-			return err
-		}
-		content := string(bytesContent)
-		commit, err := c.commitFromPatch(content)
-		if err != nil {
-			return err
-		}
-		commits = append([]*commands.Commit{commit}, commits...)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return commits, nil
-}
-
-// git-rebase-todo example:
-// pick ac446ae94ee560bdb8d1d057278657b251aaef17 ac446ae
-// pick afb893148791a2fbd8091aeb81deba4930c73031 afb8931
-
-// git-rebase-todo.backup example:
-// pick 49cbba374296938ea86bbd4bf4fee2f6ba5cccf6 third commit on master
-// pick ac446ae94ee560bdb8d1d057278657b251aaef17 blah  commit on master
-// pick afb893148791a2fbd8091aeb81deba4930c73031 fourth commit on master
-
-// getInteractiveRebasingCommits takes our git-rebase-todo and our git-rebase-todo.backup files
-// and extracts out the sha and names of commits that we still have to go
-// in the rebase:
-func (c *CommitListBuilder) getInteractiveRebasingCommits() ([]*commands.Commit, error) {
-	bytesContent, err := ioutil.ReadFile(".git/rebase-merge/git-rebase-todo")
-	if err != nil {
-		c.Log.Info(fmt.Sprintf("error occured reading git-rebase-todo: %s", err.Error()))
-		// we assume an error means the file doesn't exist so we just return
-		return nil, nil
-	}
-
-	commits := []*commands.Commit{}
-	lines := strings.Split(string(bytesContent), "\n")
-	for _, line := range lines {
-		if line == "" || line == "noop" {
-			return commits, nil
-		}
-		splitLine := strings.Split(line, " ")
-		commits = append([]*commands.Commit{{
-			Sha:    splitLine[1][0:7],
-			Name:   strings.Join(splitLine[2:], " "),
-			Status: "rebasing",
-			Action: splitLine[0],
-		}}, commits...)
-	}
-
-	return nil, nil
-}
-
-// assuming the file starts like this:
-// From e93d4193e6dd45ca9cf3a5a273d7ba6cd8b8fb20 Mon Sep 17 00:00:00 2001
-// From: Lazygit Tester <test@example.com>
-// Date: Wed, 5 Dec 2018 21:03:23 +1100
-// Subject: second commit on master
-func (c *CommitListBuilder) commitFromPatch(content string) (*commands.Commit, error) {
-	lines := strings.Split(content, "\n")
-	sha := strings.Split(lines[0], " ")[1][0:7]
-	name := strings.TrimPrefix(lines[3], "Subject: ")
-	return &commands.Commit{
-		Sha:    sha,
-		Name:   name,
-		Status: "rebasing",
-	}, nil
-}
-
-func (c *CommitListBuilder) setCommitMergedStatuses(commits []*commands.Commit) ([]*commands.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
-		}
-		if commit.Status != "pushed" {
-			continue
-		}
-		if passedAncestor {
-			commits[i].Status = "merged"
-		}
-	}
-	return commits, nil
-}
-
-func (c *CommitListBuilder) setCommitCherryPickStatuses(commits []*commands.Commit) ([]*commands.Commit, error) {
-	for _, commit := range commits {
-		for _, cherryPickedCommit := range c.CherryPickedCommits {
-			if commit.Sha == cherryPickedCommit.Sha {
-				commit.Copied = true
-			}
-		}
-	}
-	return commits, nil
-}
-
-func (c *CommitListBuilder) getMergeBase() (string, error) {
-	currentBranch, err := c.GitCommand.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
-	}
-	return output, nil
-}
-
-// getUnpushedCommits Returns the sha's of the commits that have not yet been pushed
-// to the remote branch of the current branch, a map is returned to ease look up
-func (c *CommitListBuilder) getUnpushedCommits() map[string]bool {
-	pushables := map[string]bool{}
-	o, err := c.OSCommand.RunCommandWithOutput("git rev-list @{u}..HEAD --abbrev-commit")
-	if err != nil {
-		return pushables
-	}
-	for _, p := range utils.SplitLines(o) {
-		pushables[p] = true
-	}
-
-	return pushables
-}
-
-// getLog gets the git log (currently limited to 30 commits for performance
-// until we work out lazy loading
-func (c *CommitListBuilder) getLog() string {
-	// currently limiting to 30 for performance reasons
-	// TODO: add lazyloading when you scroll down
-	result, err := c.OSCommand.RunCommandWithOutput("git log --oneline -30")
-	if err != nil {
-		// assume if there is an error there are no commits yet for this branch
-		return ""
-	}
-
-	return result
-}

pkg/git/commit_list_builder_test.go

@@ -1,315 +0,0 @@
-package git
-
-import (
-	"os/exec"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/stretchr/testify/assert"
-)
-
-// NewDummyCommitListBuilder creates a new dummy CommitListBuilder for testing
-func NewDummyCommitListBuilder() *CommitListBuilder {
-	osCommand := commands.NewDummyOSCommand()
-
-	return &CommitListBuilder{
-		Log:                 commands.NewDummyLog(),
-		GitCommand:          commands.NewDummyGitCommandWithOSCommand(osCommand),
-		OSCommand:           osCommand,
-		Tr:                  i18n.NewLocalizer(commands.NewDummyLog()),
-		CherryPickedCommits: []*commands.Commit{},
-	}
-}
-
-// TestCommitListBuilderGetUnpushedCommits is a function.
-func TestCommitListBuilderGetUnpushedCommits(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		test     func(map[string]bool)
-	}
-
-	scenarios := []scenario{
-		{
-			"Can't retrieve pushable commits",
-			func(string, ...string) *exec.Cmd {
-				return exec.Command("test")
-			},
-			func(pushables map[string]bool) {
-				assert.EqualValues(t, map[string]bool{}, pushables)
-			},
-		},
-		{
-			"Retrieve pushable commits",
-			func(cmd string, args ...string) *exec.Cmd {
-				return exec.Command("echo", "8a2bb0e\n78976bc")
-			},
-			func(pushables map[string]bool) {
-				assert.Len(t, pushables, 2)
-				assert.EqualValues(t, map[string]bool{"8a2bb0e": true, "78976bc": true}, pushables)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			c := NewDummyCommitListBuilder()
-			c.OSCommand.SetCommand(s.command)
-			s.test(c.getUnpushedCommits())
-		})
-	}
-}
-
-// TestCommitListBuilderGetMergeBase is a function.
-func TestCommitListBuilderGetMergeBase(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) {
-			c := NewDummyCommitListBuilder()
-			c.OSCommand.SetCommand(s.command)
-			s.test(c.getMergeBase())
-		})
-	}
-}
-
-// 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", "--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)
-			},
-		},
-		{
-			"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 _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			c := NewDummyCommitListBuilder()
-			c.OSCommand.SetCommand(s.command)
-			s.test(c.getLog())
-		})
-	}
-}
-
-// TestCommitListBuilderGetCommits is a function.
-func TestCommitListBuilderGetCommits(t *testing.T) {
-	type scenario struct {
-		testName string
-		command  func(string, ...string) *exec.Cmd
-		test     func([]*commands.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", "--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 []*commands.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", "--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 []*commands.Commit, err error) {
-				assert.NoError(t, err)
-				assert.Len(t, commits, 2)
-				assert.EqualValues(t, []*commands.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", "--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")
-				case "rev-parse":
-					assert.EqualValues(t, []string{"rev-parse", "--short", "HEAD"}, args)
-					// here too
-					return exec.Command("test")
-				}
-
-				return nil
-			},
-			func(commits []*commands.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())
-		})
-	}
-}

pkg/git/patch_modifier.go

@@ -1,157 +0,0 @@
-package git
-
-import (
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/go-errors/errors"
-
-	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/sirupsen/logrus"
-)
-
-type PatchModifier struct {
-	Log *logrus.Entry
-	Tr  *i18n.Localizer
-}
-
-// NewPatchModifier builds a new branch list builder
-func NewPatchModifier(log *logrus.Entry) (*PatchModifier, error) {
-	return &PatchModifier{
-		Log: log,
-	}, nil
-}
-
-// ModifyPatchForHunk takes the original patch, which may contain several hunks,
-// and removes any hunks that aren't the selected hunk
-func (p *PatchModifier) ModifyPatchForHunk(patch string, hunkStarts []int, currentLine int) (string, error) {
-	// get hunk start and end
-	lines := strings.Split(patch, "\n")
-	hunkStartIndex := utils.PrevIndex(hunkStarts, currentLine)
-	hunkStart := hunkStarts[hunkStartIndex]
-	nextHunkStartIndex := utils.NextIndex(hunkStarts, currentLine)
-	var hunkEnd int
-	if nextHunkStartIndex == 0 {
-		hunkEnd = len(lines) - 1
-	} else {
-		hunkEnd = hunkStarts[nextHunkStartIndex]
-	}
-
-	headerLength, err := p.getHeaderLength(lines)
-	if err != nil {
-		return "", err
-	}
-
-	output := strings.Join(lines[0:headerLength], "\n") + "\n"
-	output += strings.Join(lines[hunkStart:hunkEnd], "\n") + "\n"
-
-	return output, nil
-}
-
-func (p *PatchModifier) getHeaderLength(patchLines []string) (int, error) {
-	for index, line := range patchLines {
-		if strings.HasPrefix(line, "@@") {
-			return index, nil
-		}
-	}
-	return 0, errors.New(p.Tr.SLocalize("CantFindHunks"))
-}
-
-// ModifyPatchForLine takes the original patch, which may contain several hunks,
-// and the line number of the line we want to stage
-func (p *PatchModifier) ModifyPatchForLine(patch string, lineNumber int) (string, error) {
-	lines := strings.Split(patch, "\n")
-	headerLength, err := p.getHeaderLength(lines)
-	if err != nil {
-		return "", err
-	}
-	output := strings.Join(lines[0:headerLength], "\n") + "\n"
-
-	hunkStart, err := p.getHunkStart(lines, lineNumber)
-	if err != nil {
-		return "", err
-	}
-
-	hunk, err := p.getModifiedHunk(lines, hunkStart, lineNumber)
-	if err != nil {
-		return "", err
-	}
-
-	output += strings.Join(hunk, "\n")
-
-	return output, nil
-}
-
-// getHunkStart returns the line number of the hunk we're going to be modifying
-// in order to stage our line
-func (p *PatchModifier) getHunkStart(patchLines []string, lineNumber int) (int, error) {
-	// find the hunk that we're modifying
-	hunkStart := 0
-	for index, line := range patchLines {
-		if strings.HasPrefix(line, "@@") {
-			hunkStart = index
-		}
-		if index == lineNumber {
-			return hunkStart, nil
-		}
-	}
-
-	return 0, errors.New(p.Tr.SLocalize("CantFindHunk"))
-}
-
-func (p *PatchModifier) getModifiedHunk(patchLines []string, hunkStart int, lineNumber int) ([]string, error) {
-	lineChanges := 0
-	// strip the hunk down to just the line we want to stage
-	newHunk := []string{patchLines[hunkStart]}
-	for offsetIndex, line := range patchLines[hunkStart+1:] {
-		index := offsetIndex + hunkStart + 1
-		if strings.HasPrefix(line, "@@") {
-			newHunk = append(newHunk, "\n")
-			break
-		}
-		if index != lineNumber {
-			// we include other removals but treat them like context
-			if strings.HasPrefix(line, "-") {
-				newHunk = append(newHunk, " "+line[1:])
-				lineChanges += 1
-				continue
-			}
-			// we don't include other additions
-			if strings.HasPrefix(line, "+") {
-				lineChanges -= 1
-				continue
-			}
-		}
-		newHunk = append(newHunk, line)
-	}
-
-	var err error
-	newHunk[0], err = p.updatedHeader(newHunk[0], lineChanges)
-	if err != nil {
-		return nil, err
-	}
-
-	return newHunk, nil
-}
-
-// updatedHeader returns the hunk header with the updated line range
-// we need to update the hunk length to reflect the changes we made
-// if the hunk has three additions but we're only staging one, then
-// @@ -14,8 +14,11 @@ import (
-// becomes
-// @@ -14,8 +14,9 @@ import (
-func (p *PatchModifier) updatedHeader(currentHeader string, lineChanges int) (string, error) {
-	// current counter is the number after the second comma
-	re := regexp.MustCompile(`(\d+) @@`)
-	prevLengthString := re.FindStringSubmatch(currentHeader)[1]
-
-	prevLength, err := strconv.Atoi(prevLengthString)
-	if err != nil {
-		return "", err
-	}
-	re = regexp.MustCompile(`\d+ @@`)
-	newLength := strconv.Itoa(prevLength + lineChanges)
-	return re.ReplaceAllString(currentHeader, newLength+" @@"), nil
-}

pkg/git/patch_modifier_test.go

@@ -1,85 +0,0 @@
-package git
-
-import (
-	"io/ioutil"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/stretchr/testify/assert"
-)
-
-// NewDummyPatchModifier constructs a new dummy patch modifier for testing
-func NewDummyPatchModifier() *PatchModifier {
-	return &PatchModifier{
-		Log: commands.NewDummyLog(),
-	}
-}
-
-func TestModifyPatchForLine(t *testing.T) {
-	type scenario struct {
-		testName              string
-		patchFilename         string
-		lineNumber            int
-		shouldError           bool
-		expectedPatchFilename string
-	}
-
-	scenarios := []scenario{
-		{
-			"Removing one line",
-			"testdata/testPatchBefore.diff",
-			8,
-			false,
-			"testdata/testPatchAfter1.diff",
-		},
-		{
-			"Adding one line",
-			"testdata/testPatchBefore.diff",
-			10,
-			false,
-			"testdata/testPatchAfter2.diff",
-		},
-		{
-			"Adding one line in top hunk in diff with multiple hunks",
-			"testdata/testPatchBefore2.diff",
-			20,
-			false,
-			"testdata/testPatchAfter3.diff",
-		},
-		{
-			"Adding one line in top hunk in diff with multiple hunks",
-			"testdata/testPatchBefore2.diff",
-			53,
-			false,
-			"testdata/testPatchAfter4.diff",
-		},
-		{
-			"adding unstaged file with a single line",
-			"testdata/addedFile.diff",
-			6,
-			false,
-			"testdata/addedFile.diff",
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			p := NewDummyPatchModifier()
-			beforePatch, err := ioutil.ReadFile(s.patchFilename)
-			if err != nil {
-				panic("Cannot open file at " + s.patchFilename)
-			}
-			afterPatch, err := p.ModifyPatchForLine(string(beforePatch), s.lineNumber)
-			if s.shouldError {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				expected, err := ioutil.ReadFile(s.expectedPatchFilename)
-				if err != nil {
-					panic("Cannot open file at " + s.expectedPatchFilename)
-				}
-				assert.Equal(t, string(expected), afterPatch)
-			}
-		})
-	}
-}

pkg/git/patch_parser.go

@@ -1,36 +0,0 @@
-package git
-
-import (
-	"strings"
-
-	"github.com/sirupsen/logrus"
-)
-
-type PatchParser struct {
-	Log *logrus.Entry
-}
-
-// NewPatchParser builds a new branch list builder
-func NewPatchParser(log *logrus.Entry) (*PatchParser, error) {
-	return &PatchParser{
-		Log: log,
-	}, nil
-}
-
-func (p *PatchParser) ParsePatch(patch string) ([]int, []int, error) {
-	lines := strings.Split(patch, "\n")
-	hunkStarts := []int{}
-	stageableLines := []int{}
-	pastHeader := false
-	for index, line := range lines {
-		if strings.HasPrefix(line, "@@") {
-			pastHeader = true
-			hunkStarts = append(hunkStarts, index)
-		}
-		if pastHeader && (strings.HasPrefix(line, "-") || strings.HasPrefix(line, "+")) {
-			stageableLines = append(stageableLines, index)
-		}
-	}
-	p.Log.WithField("staging", "staging").Info(stageableLines)
-	return hunkStarts, stageableLines, nil
-}

pkg/git/patch_parser_test.go

@@ -1,68 +0,0 @@
-package git
-
-import (
-	"io/ioutil"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/stretchr/testify/assert"
-)
-
-// NewDummyPatchParser constructs a new dummy patch parser for testing
-func NewDummyPatchParser() *PatchParser {
-	return &PatchParser{
-		Log: commands.NewDummyLog(),
-	}
-}
-
-func TestParsePatch(t *testing.T) {
-	type scenario struct {
-		testName               string
-		patchFilename          string
-		shouldError            bool
-		expectedStageableLines []int
-		expectedHunkStarts     []int
-	}
-
-	scenarios := []scenario{
-		{
-			"Diff with one hunk",
-			"testdata/testPatchBefore.diff",
-			false,
-			[]int{8, 9, 10, 11},
-			[]int{4},
-		},
-		{
-			"Diff with two hunks",
-			"testdata/testPatchBefore2.diff",
-			false,
-			[]int{8, 9, 10, 11, 12, 13, 20, 21, 22, 23, 24, 25, 26, 27, 28, 33, 34, 35, 36, 37, 45, 46, 47, 48, 49, 50, 51, 52, 53},
-			[]int{4, 41},
-		},
-		{
-			"Unstaged file",
-			"testdata/addedFile.diff",
-			false,
-			[]int{6},
-			[]int{5},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			p := NewDummyPatchParser()
-			beforePatch, err := ioutil.ReadFile(s.patchFilename)
-			if err != nil {
-				panic("Cannot open file at " + s.patchFilename)
-			}
-			hunkStarts, stageableLines, err := p.ParsePatch(string(beforePatch))
-			if s.shouldError {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				assert.Equal(t, s.expectedStageableLines, stageableLines)
-				assert.Equal(t, s.expectedHunkStarts, hunkStarts)
-			}
-		})
-	}
-}

pkg/git/testdata/addedFile.diff

@@ -1,7 +0,0 @@
-diff --git a/blah b/blah
-new file mode 100644
-index 0000000..907b308
---- /dev/null
-+++ b/blah
-@@ -0,0 +1 @@
-+blah

pkg/git/testdata/testPatchAfter1.diff

@@ -1,13 +0,0 @@
-diff --git a/pkg/git/branch_list_builder.go b/pkg/git/branch_list_builder.go
-index 60ec4e0..db4485d 100644
---- a/pkg/git/branch_list_builder.go
-+++ b/pkg/git/branch_list_builder.go
-@@ -14,8 +14,7 @@ import (
- 
- // context:
- // we want to only show 'safe' branches (ones that haven't e.g. been deleted)
--// which `git branch -a` gives us, but we also want the recency data that
- // git reflog gives us.
- // So we get the HEAD, then append get the reflog branches that intersect with
- // our safe branches, then add the remaining safe branches, ensuring uniqueness
- // along the way

pkg/git/testdata/testPatchAfter2.diff

@@ -1,14 +0,0 @@
-diff --git a/pkg/git/branch_list_builder.go b/pkg/git/branch_list_builder.go
-index 60ec4e0..db4485d 100644
---- a/pkg/git/branch_list_builder.go
-+++ b/pkg/git/branch_list_builder.go
-@@ -14,8 +14,9 @@ import (
- 
- // context:
- // we want to only show 'safe' branches (ones that haven't e.g. been deleted)
- // which `git branch -a` gives us, but we also want the recency data that
- // git reflog gives us.
-+// test 2 - if I remove this, I decrement the end counter
- // So we get the HEAD, then append get the reflog branches that intersect with
- // our safe branches, then add the remaining safe branches, ensuring uniqueness
- // along the way

pkg/git/testdata/testPatchAfter3.diff

@@ -1,25 +0,0 @@
-diff --git a/pkg/git/patch_modifier.go b/pkg/git/patch_modifier.go
-index a8fc600..6d8f7d7 100644
---- a/pkg/git/patch_modifier.go
-+++ b/pkg/git/patch_modifier.go
-@@ -36,18 +36,19 @@ func (p *PatchModifier) ModifyPatchForHunk(patch string, hunkStarts []int, curre
- 		hunkEnd = hunkStarts[nextHunkStartIndex]
- 	}
- 
- 	headerLength := 4
- 	output := strings.Join(lines[0:headerLength], "\n") + "\n"
- 	output += strings.Join(lines[hunkStart:hunkEnd], "\n") + "\n"
- 
- 	return output, nil
- }
- 
-+func getHeaderLength(patchLines []string) (int, error) {
- // ModifyPatchForLine takes the original patch, which may contain several hunks,
- // and the line number of the line we want to stage
- func (p *PatchModifier) ModifyPatchForLine(patch string, lineNumber int) (string, error) {
- 	lines := strings.Split(patch, "\n")
- 	headerLength := 4
- 	output := strings.Join(lines[0:headerLength], "\n") + "\n"
- 
- 	hunkStart, err := p.getHunkStart(lines, lineNumber)
-

pkg/git/testdata/testPatchAfter4.diff

@@ -1,19 +0,0 @@
-diff --git a/pkg/git/patch_modifier.go b/pkg/git/patch_modifier.go
-index a8fc600..6d8f7d7 100644
---- a/pkg/git/patch_modifier.go
-+++ b/pkg/git/patch_modifier.go
-@@ -124,13 +140,14 @@ func (p *PatchModifier) getModifiedHunk(patchLines []string, hunkStart int, line
- // @@ -14,8 +14,9 @@ import (
- func (p *PatchModifier) updatedHeader(currentHeader string, lineChanges int) (string, error) {
- 	// current counter is the number after the second comma
- 	re := regexp.MustCompile(`^[^,]+,[^,]+,(\d+)`)
- 	matches := re.FindStringSubmatch(currentHeader)
- 	if len(matches) < 2 {
- 		re = regexp.MustCompile(`^[^,]+,[^+]+\+(\d+)`)
- 		matches = re.FindStringSubmatch(currentHeader)
- 	}
- 	prevLengthString := matches[1]
-+	prevLengthString := re.FindStringSubmatch(currentHeader)[1]
- 
- 	prevLength, err := strconv.Atoi(prevLengthString)
- 	if err != nil {

pkg/git/testdata/testPatchBefore.diff

@@ -1,15 +0,0 @@
-diff --git a/pkg/git/branch_list_builder.go b/pkg/git/branch_list_builder.go
-index 60ec4e0..db4485d 100644
---- a/pkg/git/branch_list_builder.go
-+++ b/pkg/git/branch_list_builder.go
-@@ -14,8 +14,8 @@ import (
- 
- // context:
- // we want to only show 'safe' branches (ones that haven't e.g. been deleted)
--// which `git branch -a` gives us, but we also want the recency data that
--// git reflog gives us.
-+// test 2 - if I remove this, I decrement the end counter
-+// test
- // So we get the HEAD, then append get the reflog branches that intersect with
- // our safe branches, then add the remaining safe branches, ensuring uniqueness
- // along the way

pkg/git/testdata/testPatchBefore2.diff

@@ -1,57 +0,0 @@
-diff --git a/pkg/git/patch_modifier.go b/pkg/git/patch_modifier.go
-index a8fc600..6d8f7d7 100644
---- a/pkg/git/patch_modifier.go
-+++ b/pkg/git/patch_modifier.go
-@@ -36,18 +36,34 @@ func (p *PatchModifier) ModifyPatchForHunk(patch string, hunkStarts []int, curre
- 		hunkEnd = hunkStarts[nextHunkStartIndex]
- 	}
- 
--	headerLength := 4
-+	headerLength, err := getHeaderLength(lines)
-+	if err != nil {
-+		return "", err
-+	}
-+
- 	output := strings.Join(lines[0:headerLength], "\n") + "\n"
- 	output += strings.Join(lines[hunkStart:hunkEnd], "\n") + "\n"
- 
- 	return output, nil
- }
- 
-+func getHeaderLength(patchLines []string) (int, error) {
-+	for index, line := range patchLines {
-+		if strings.HasPrefix(line, "@@") {
-+			return index, nil
-+		}
-+	}
-+	return 0, errors.New("Could not find any hunks in this patch")
-+}
-+
- // ModifyPatchForLine takes the original patch, which may contain several hunks,
- // and the line number of the line we want to stage
- func (p *PatchModifier) ModifyPatchForLine(patch string, lineNumber int) (string, error) {
- 	lines := strings.Split(patch, "\n")
--	headerLength := 4
-+	headerLength, err := getHeaderLength(lines)
-+	if err != nil {
-+		return "", err
-+	}
- 	output := strings.Join(lines[0:headerLength], "\n") + "\n"
- 
- 	hunkStart, err := p.getHunkStart(lines, lineNumber)
-@@ -124,13 +140,8 @@ func (p *PatchModifier) getModifiedHunk(patchLines []string, hunkStart int, line
- // @@ -14,8 +14,9 @@ import (
- func (p *PatchModifier) updatedHeader(currentHeader string, lineChanges int) (string, error) {
- 	// current counter is the number after the second comma
--	re := regexp.MustCompile(`^[^,]+,[^,]+,(\d+)`)
--	matches := re.FindStringSubmatch(currentHeader)
--	if len(matches) < 2 {
--		re = regexp.MustCompile(`^[^,]+,[^+]+\+(\d+)`)
--		matches = re.FindStringSubmatch(currentHeader)
--	}
--	prevLengthString := matches[1]
-+	re := regexp.MustCompile(`(\d+) @@`)
-+	prevLengthString := re.FindStringSubmatch(currentHeader)[1]
- 
- 	prevLength, err := strconv.Atoi(prevLengthString)
- 	if err != nil {

pkg/gui/app_status_manager.go

@@ -1,70 +0,0 @@
-package gui
-
-import (
-	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-type appStatus struct {
-	name       string
-	statusType string
-	duration   int
-}
-
-type statusManager struct {
-	statuses []appStatus
-}
-
-func (m *statusManager) removeStatus(name string) {
-	newStatuses := []appStatus{}
-	for _, status := range m.statuses {
-		if status.name != name {
-			newStatuses = append(newStatuses, status)
-		}
-	}
-	m.statuses = newStatuses
-}
-
-func (m *statusManager) addWaitingStatus(name string) {
-	m.removeStatus(name)
-	newStatus := appStatus{
-		name:       name,
-		statusType: "waiting",
-		duration:   0,
-	}
-	m.statuses = append([]appStatus{newStatus}, m.statuses...)
-}
-
-func (m *statusManager) getStatusString() string {
-	if len(m.statuses) == 0 {
-		return ""
-	}
-	topStatus := m.statuses[0]
-	if topStatus.statusType == "waiting" {
-		return topStatus.name + " " + utils.Loader()
-	}
-	return topStatus.name
-}
-
-// WithWaitingStatus wraps a function and shows a waiting status while the function is still executing
-func (gui *Gui) WithWaitingStatus(name string, f func() error) error {
-	go func() {
-		gui.g.Update(func(g *gocui.Gui) error {
-			gui.statusManager.addWaitingStatus(name)
-			return nil
-		})
-
-		defer gui.g.Update(func(g *gocui.Gui) error {
-			gui.statusManager.removeStatus(name)
-			return nil
-		})
-
-		if err := f(); err != nil {
-			gui.g.Update(func(g *gocui.Gui) error {
-				return gui.createErrorPanel(gui.g, err.Error())
-			})
-		}
-	}()
-
-	return nil
-}

pkg/gui/branches_panel.go

@@ -9,153 +9,20 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/git"
 )
 
-// list panel functions
-
-func (gui *Gui) getSelectedBranch() *commands.Branch {
-	selectedLine := gui.State.Panels.Branches.SelectedLine
-	if selectedLine == -1 {
-		return nil
-	}
-
-	return gui.State.Branches[selectedLine]
-}
-
-// may want to standardise how these select methods work
-func (gui *Gui) handleBranchSelect(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	if _, err := gui.g.SetCurrentView(v.Name()); err != nil {
-		return err
-	}
-	// This really shouldn't happen: there should always be a master branch
-	if len(gui.State.Branches) == 0 {
-		return gui.renderString(g, "main", gui.Tr.SLocalize("NoBranchesThisRepo"))
-	}
-	branch := gui.getSelectedBranch()
-	if err := gui.focusPoint(0, gui.State.Panels.Branches.SelectedLine, v); err != nil {
-		return err
-	}
-	go func() {
-		_ = gui.RenderSelectedBranchUpstreamDifferences()
-	}()
-	go func() {
-		graph, err := gui.GitCommand.GetBranchGraph(branch.Name)
-		if err != nil && strings.HasPrefix(graph, "fatal: ambiguous argument") {
-			graph = gui.Tr.SLocalize("NoTrackingThisBranch")
-		}
-		_ = gui.renderString(g, "main", graph)
-	}()
-	return nil
-}
-
-func (gui *Gui) RenderSelectedBranchUpstreamDifferences() 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)
-	return gui.renderListPanel(gui.getBranchesView(), gui.State.Branches)
-}
-
-// gui.refreshStatus is called at the end of this because that's when we can
-// be sure there is a state.Branches array to pick the current branch from
-func (gui *Gui) refreshBranches(g *gocui.Gui) error {
-	g.Update(func(g *gocui.Gui) error {
-		builder, err := git.NewBranchListBuilder(gui.Log, gui.GitCommand)
-		if err != nil {
-			return err
-		}
-		gui.State.Branches = builder.Build()
-
-		gui.refreshSelectedLine(&gui.State.Panels.Branches.SelectedLine, len(gui.State.Branches))
-		if err := gui.RenderSelectedBranchUpstreamDifferences(); err != nil {
-			return err
-		}
-
-		return gui.refreshStatus(g)
-	})
-	return nil
-}
-
-func (gui *Gui) handleBranchesNextLine(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	panelState := gui.State.Panels.Branches
-	gui.changeSelectedLine(&panelState.SelectedLine, len(gui.State.Branches), false)
-
-	if err := gui.resetOrigin(gui.getMainView()); err != nil {
-		return err
-	}
-	return gui.handleBranchSelect(gui.g, v)
-}
-
-func (gui *Gui) handleBranchesPrevLine(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	panelState := gui.State.Panels.Branches
-	gui.changeSelectedLine(&panelState.SelectedLine, len(gui.State.Branches), true)
-
-	if err := gui.resetOrigin(gui.getMainView()); err != nil {
-		return err
-	}
-	return gui.handleBranchSelect(gui.g, v)
-}
-
-// specific functions
-
 func (gui *Gui) handleBranchPress(g *gocui.Gui, v *gocui.View) error {
-	if gui.State.Panels.Branches.SelectedLine == -1 {
-		return nil
-	}
-	if gui.State.Panels.Branches.SelectedLine == 0 {
+	index := gui.getItemPosition(v)
+	if index == 0 {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("AlreadyCheckedOutBranch"))
 	}
-	branch := gui.getSelectedBranch()
+	branch := gui.getSelectedBranch(v)
 	if err := gui.GitCommand.Checkout(branch.Name, false); err != nil {
-		if err := gui.createErrorPanel(g, err.Error()); err != nil {
-			return err
-		}
-	} else {
-		gui.State.Panels.Branches.SelectedLine = 0
+		gui.createErrorPanel(g, err.Error())
 	}
-
 	return gui.refreshSidePanels(g)
 }
 
-func (gui *Gui) handleCreatePullRequestPress(g *gocui.Gui, v *gocui.View) error {
-	pullRequest := commands.NewPullRequest(gui.GitCommand)
-
-	branch := gui.getSelectedBranch()
-	if err := pullRequest.Create(branch); err != nil {
-		return gui.createErrorPanel(g, err.Error())
-	}
-
-	return nil
-}
-
-func (gui *Gui) handleGitFetch(g *gocui.Gui, v *gocui.View) error {
-	if err := gui.createLoaderPanel(gui.g, v, gui.Tr.SLocalize("FetchWait")); err != nil {
-		return err
-	}
-	go func() {
-		unamePassOpend, err := gui.fetch(g, v, true)
-		gui.HandleCredentialsPopup(g, unamePassOpend, err)
-	}()
-	return nil
-}
-
 func (gui *Gui) handleForceCheckout(g *gocui.Gui, v *gocui.View) error {
-	branch := gui.getSelectedBranch()
+	branch := gui.getSelectedBranch(v)
 	message := gui.Tr.SLocalize("SureForceCheckout")
 	title := gui.Tr.SLocalize("ForceCheckoutBranch")
 	return gui.createConfirmationPanel(g, v, title, message, func(g *gocui.Gui, v *gocui.View) error {
@@ -195,123 +62,95 @@ func (gui *Gui) handleNewBranch(g *gocui.Gui, v *gocui.View) error {
 }
 
 func (gui *Gui) handleDeleteBranch(g *gocui.Gui, v *gocui.View) error {
-	return gui.deleteBranch(g, v, false)
-}
-
-func (gui *Gui) handleForceDeleteBranch(g *gocui.Gui, v *gocui.View) error {
-	return gui.deleteBranch(g, v, true)
-}
-
-func (gui *Gui) deleteBranch(g *gocui.Gui, v *gocui.View, force bool) error {
-	selectedBranch := gui.getSelectedBranch()
-	if selectedBranch == nil {
-		return nil
-	}
 	checkedOutBranch := gui.State.Branches[0]
+	selectedBranch := gui.getSelectedBranch(v)
 	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 {
-		messageID = "ForceDeleteBranchMessage"
-	} else {
-		messageID = "DeleteBranchMessage"
-	}
 	message := gui.Tr.TemplateLocalize(
-		messageID,
+		"DeleteBranchMessage",
 		Teml{
 			"selectedBranchName": selectedBranch.Name,
 		},
 	)
+	title := gui.Tr.SLocalize("DeleteBranch")
 	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 {
-			errMessage := err.Error()
-			if !force && strings.Contains(errMessage, "is not fully merged") {
-				return gui.deleteNamedBranch(g, v, selectedBranch, true)
-			}
-			return gui.createErrorPanel(g, errMessage)
+		if err := gui.GitCommand.DeleteBranch(selectedBranch.Name); err != nil {
+			return gui.createErrorPanel(g, err.Error())
 		}
 		return gui.refreshSidePanels(g)
 	}, nil)
 }
 
 func (gui *Gui) handleMerge(g *gocui.Gui, v *gocui.View) error {
-	checkedOutBranch := gui.State.Branches[0].Name
-	selectedBranch := gui.getSelectedBranch().Name
-	if checkedOutBranch == selectedBranch {
+	checkedOutBranch := gui.State.Branches[0]
+	selectedBranch := gui.getSelectedBranch(v)
+	defer gui.refreshSidePanels(g)
+	if checkedOutBranch.Name == selectedBranch.Name {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("CantMergeBranchIntoItself"))
 	}
-	prompt := gui.Tr.TemplateLocalize(
-		"ConfirmMerge",
-		Teml{
-			"checkedOutBranch": checkedOutBranch,
-			"selectedBranch":   selectedBranch,
-		},
-	)
-	return gui.createConfirmationPanel(g, v, gui.Tr.SLocalize("MergingTitle"), prompt,
-		func(g *gocui.Gui, v *gocui.View) error {
-
-			err := gui.GitCommand.Merge(selectedBranch)
-			return gui.handleGenericMergeCommandResult(err)
-		}, nil)
+	if err := gui.GitCommand.Merge(selectedBranch.Name); err != nil {
+		return gui.createErrorPanel(g, err.Error())
+	}
+	return nil
 }
 
-func (gui *Gui) handleRebase(g *gocui.Gui, v *gocui.View) error {
-	checkedOutBranch := gui.State.Branches[0].Name
-	selectedBranch := gui.getSelectedBranch().Name
-	if selectedBranch == checkedOutBranch {
-		return gui.createErrorPanel(g, gui.Tr.SLocalize("CantRebaseOntoSelf"))
-	}
-	prompt := gui.Tr.TemplateLocalize(
-		"ConfirmRebase",
-		Teml{
-			"checkedOutBranch": checkedOutBranch,
-			"selectedBranch":   selectedBranch,
-		},
-	)
-	return gui.createConfirmationPanel(g, v, gui.Tr.SLocalize("RebasingTitle"), prompt,
-		func(g *gocui.Gui, v *gocui.View) error {
-
-			err := gui.GitCommand.RebaseBranch(selectedBranch)
-			return gui.handleGenericMergeCommandResult(err)
-		}, nil)
+func (gui *Gui) getSelectedBranch(v *gocui.View) commands.Branch {
+	lineNumber := gui.getItemPosition(v)
+	return gui.State.Branches[lineNumber]
 }
 
-func (gui *Gui) handleFastForward(g *gocui.Gui, v *gocui.View) error {
-	branch := gui.getSelectedBranch()
-	if branch == nil {
-		return nil
+func (gui *Gui) renderBranchesOptions(g *gocui.Gui) error {
+	return gui.renderOptionsMap(g, map[string]string{
+		"space":   gui.Tr.SLocalize("checkout"),
+		"f":       gui.Tr.SLocalize("forceCheckout"),
+		"m":       gui.Tr.SLocalize("merge"),
+		"c":       gui.Tr.SLocalize("checkoutByName"),
+		"n":       gui.Tr.SLocalize("newBranch"),
+		"d":       gui.Tr.SLocalize("deleteBranch"),
+		"← → ↑ ↓": gui.Tr.SLocalize("navigate"),
+	})
+}
+
+// may want to standardise how these select methods work
+func (gui *Gui) handleBranchSelect(g *gocui.Gui, v *gocui.View) error {
+	if err := gui.renderBranchesOptions(g); err != nil {
+		return err
 	}
-	if branch.Pushables == "" {
-		return nil
+	// This really shouldn't happen: there should always be a master branch
+	if len(gui.State.Branches) == 0 {
+		return gui.renderString(g, "main", gui.Tr.SLocalize("NoBranchesThisRepo"))
 	}
-	if branch.Pushables == "?" {
-		return gui.createErrorPanel(gui.g, gui.Tr.SLocalize("FwdNoUpstream"))
-	}
-	if branch.Pushables != "0" {
-		return gui.createErrorPanel(gui.g, gui.Tr.SLocalize("FwdCommitsToPush"))
-	}
-	upstream := "origin" // hardcoding for now
-	message := gui.Tr.TemplateLocalize(
-		"Fetching",
-		Teml{
-			"from": fmt.Sprintf("%s/%s", upstream, branch.Name),
-			"to":   branch.Name,
-		},
-	)
 	go func() {
-		_ = gui.createLoaderPanel(gui.g, v, message)
-		if err := gui.GitCommand.FastForward(branch.Name); err != nil {
-			_ = gui.createErrorPanel(gui.g, err.Error())
-		} else {
-			_ = gui.closeConfirmationPrompt(gui.g)
-			_ = gui.RenderSelectedBranchUpstreamDifferences()
+		branch := gui.getSelectedBranch(v)
+		diff, err := gui.GitCommand.GetBranchGraph(branch.Name)
+		if err != nil && strings.HasPrefix(diff, "fatal: ambiguous argument") {
+			diff = gui.Tr.SLocalize("NoTrackingThisBranch")
 		}
+		gui.renderString(g, "main", diff)
 	}()
 	return nil
 }
+
+// gui.refreshStatus is called at the end of this because that's when we can
+// be sure there is a state.Branches array to pick the current branch from
+func (gui *Gui) refreshBranches(g *gocui.Gui) error {
+	g.Update(func(g *gocui.Gui) error {
+		v, err := g.View("branches")
+		if err != nil {
+			panic(err)
+		}
+		builder, err := git.NewBranchListBuilder(gui.Log, gui.GitCommand)
+		if err != nil {
+			return err
+		}
+		gui.State.Branches = builder.Build()
+		v.Clear()
+		for _, branch := range gui.State.Branches {
+			fmt.Fprintln(v, branch.GetDisplayString())
+		}
+		gui.resetOrigin(v)
+		return gui.refreshStatus(g)
+	})
+	return nil
+}

pkg/gui/commit_message_panel.go

@@ -1,56 +1,53 @@
 package gui
 
 import (
-	"os/exec"
-	"strconv"
-	"strings"
-
 	"github.com/jesseduffield/gocui"
 )
 
-// runSyncOrAsyncCommand takes the output of a command that may have returned
-// either no error, an error, or a subprocess to execute, and if a subprocess
-// needs to be set on the gui object, it does so, and then returns the error
-func (gui *Gui) runSyncOrAsyncCommand(sub *exec.Cmd, err error) error {
-	if err != nil {
-		if err != gui.Errors.ErrSubProcess {
-			return gui.createErrorPanel(gui.g, err.Error())
-		}
-	}
-	if sub != nil {
-		gui.SubProcess = sub
-		return gui.Errors.ErrSubProcess
-	}
-	return nil
-}
-
 func (gui *Gui) handleCommitConfirm(g *gocui.Gui, v *gocui.View) error {
 	message := gui.trimmedContent(v)
 	if message == "" {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("CommitWithoutMessageErr"))
 	}
-	if err := gui.runSyncOrAsyncCommand(gui.GitCommand.Commit(message)); err != nil {
-		return err
+	sub, err := gui.GitCommand.Commit(g, message)
+	if err != nil {
+		// TODO need to find a way to send through this error
+		if err != gui.Errors.ErrSubProcess {
+			return gui.createErrorPanel(g, err.Error())
+		}
 	}
-
+	if sub != nil {
+		gui.SubProcess = sub
+		return gui.Errors.ErrSubProcess
+	}
+	gui.refreshFiles(g)
 	v.Clear()
-	_ = v.SetCursor(0, 0)
-	_ = v.SetOrigin(0, 0)
-	_, _ = g.SetViewOnBottom("commitMessage")
-	_ = gui.switchFocus(g, v, gui.getFilesView())
-	return gui.refreshSidePanels(g)
+	v.SetCursor(0, 0)
+	g.SetViewOnBottom("commitMessage")
+	gui.switchFocus(g, v, gui.getFilesView(g))
+	return gui.refreshCommits(g)
 }
 
 func (gui *Gui) handleCommitClose(g *gocui.Gui, v *gocui.View) error {
 	g.SetViewOnBottom("commitMessage")
-	return gui.switchFocus(g, v, gui.getFilesView())
+	return gui.switchFocus(g, v, gui.getFilesView(g))
+}
+
+func (gui *Gui) handleNewlineCommitMessage(g *gocui.Gui, v *gocui.View) error {
+	// resising ahead of time so that the top line doesn't get hidden to make
+	// room for the cursor on the second line
+	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(g, v.Buffer())
+	if _, err := g.SetView("commitMessage", x0, y0, x1, y1+1, 0); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+	}
+
+	v.EditNewLine()
+	return nil
 }
 
 func (gui *Gui) handleCommitFocused(g *gocui.Gui, v *gocui.View) error {
-	if _, err := g.SetViewOnTop("commitMessage"); err != nil {
-		return err
-	}
-
 	message := gui.Tr.TemplateLocalize(
 		"CloseConfirm",
 		Teml{
@@ -60,43 +57,3 @@ func (gui *Gui) handleCommitFocused(g *gocui.Gui, v *gocui.View) error {
 	)
 	return gui.renderString(g, "options", message)
 }
-
-func (gui *Gui) simpleEditor(v *gocui.View, key gocui.Key, ch rune, mod gocui.Modifier) {
-	switch {
-	case key == gocui.KeyBackspace || key == gocui.KeyBackspace2:
-		v.EditDelete(true)
-	case key == gocui.KeyDelete:
-		v.EditDelete(false)
-	case key == gocui.KeyArrowDown:
-		v.MoveCursor(0, 1, false)
-	case key == gocui.KeyArrowUp:
-		v.MoveCursor(0, -1, false)
-	case key == gocui.KeyArrowLeft:
-		v.MoveCursor(-1, 0, false)
-	case key == gocui.KeyArrowRight:
-		v.MoveCursor(1, 0, false)
-	case key == gocui.KeyTab:
-		v.EditNewLine()
-	case key == gocui.KeySpace:
-		v.EditWrite(' ')
-	case key == gocui.KeyInsert:
-		v.Overwrite = !v.Overwrite
-	default:
-		v.EditWrite(ch)
-	}
-
-	gui.RenderCommitLength()
-}
-
-func (gui *Gui) getBufferLength(view *gocui.View) string {
-	return " " + strconv.Itoa(strings.Count(view.Buffer(), "")-1) + " "
-}
-
-// RenderCommitLength is a function.
-func (gui *Gui) RenderCommitLength() {
-	if !gui.Config.GetUserConfig().GetBool("gui.commitLength.show") {
-		return
-	}
-	v := gui.getCommitMessageView()
-	v.Subtitle = gui.getBufferLength(v)
-}

pkg/gui/commits_panel.go

@@ -1,77 +1,36 @@
 package gui
 
 import (
-	"fmt"
-	"strconv"
-
-	"github.com/go-errors/errors"
+	"errors"
 
+	"github.com/fatih/color"
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/git"
-	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
-// list panel functions
-
-func (gui *Gui) getSelectedCommit(g *gocui.Gui) *commands.Commit {
-	selectedLine := gui.State.Panels.Commits.SelectedLine
-	if selectedLine == -1 {
-		return nil
-	}
-
-	return gui.State.Commits[selectedLine]
-}
-
-func (gui *Gui) handleCommitSelect(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	if _, err := gui.g.SetCurrentView(v.Name()); err != nil {
-		return err
-	}
-	commit := gui.getSelectedCommit(g)
-	if commit == nil {
-		return gui.renderString(g, "main", gui.Tr.SLocalize("NoCommitsThisBranch"))
-	}
-
-	if err := gui.focusPoint(0, gui.State.Panels.Commits.SelectedLine, v); err != nil {
-		return err
-	}
-	commitText, err := gui.GitCommand.Show(commit.Sha)
-	if err != nil {
-		return err
-	}
-	return gui.renderString(g, "main", commitText)
-}
-
 func (gui *Gui) refreshCommits(g *gocui.Gui) error {
 	g.Update(func(*gocui.Gui) error {
-		builder, err := git.NewCommitListBuilder(gui.Log, gui.GitCommand, gui.OSCommand, gui.Tr, gui.State.CherryPickedCommits)
+		gui.State.Commits = gui.GitCommand.GetCommits()
+		v, err := g.View("commits")
 		if err != nil {
-			return err
+			panic(err)
 		}
-		commits, err := builder.GetCommits()
-		if err != nil {
-			return err
-		}
-		gui.State.Commits = commits
-
-		gui.refreshSelectedLine(&gui.State.Panels.Commits.SelectedLine, len(gui.State.Commits))
-
-		isFocused := gui.g.CurrentView().Name() == "commits"
-		list, err := utils.RenderList(gui.State.Commits, isFocused)
-		if err != nil {
-			return err
-		}
-
-		v := gui.getCommitsView()
 		v.Clear()
-		fmt.Fprint(v, list)
-
+		red := color.New(color.FgRed)
+		yellow := color.New(color.FgYellow)
+		white := color.New(color.FgWhite)
+		shaColor := white
+		for _, commit := range gui.State.Commits {
+			if commit.Pushed {
+				shaColor = red
+			} else {
+				shaColor = yellow
+			}
+			shaColor.Fprint(v, commit.Sha+" ")
+			white.Fprintln(v, commit.Name)
+		}
 		gui.refreshStatus(g)
-		if v == g.CurrentView() {
+		if g.CurrentView().Name() == "commits" {
 			gui.handleCommitSelect(g, v)
 		}
 		return nil
@@ -79,41 +38,11 @@ func (gui *Gui) refreshCommits(g *gocui.Gui) error {
 	return nil
 }
 
-func (gui *Gui) handleCommitsNextLine(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	panelState := gui.State.Panels.Commits
-	gui.changeSelectedLine(&panelState.SelectedLine, len(gui.State.Commits), false)
-
-	if err := gui.resetOrigin(gui.getMainView()); err != nil {
-		return err
-	}
-	return gui.handleCommitSelect(gui.g, v)
-}
-
-func (gui *Gui) handleCommitsPrevLine(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	panelState := gui.State.Panels.Commits
-	gui.changeSelectedLine(&panelState.SelectedLine, len(gui.State.Commits), true)
-
-	if err := gui.resetOrigin(gui.getMainView()); err != nil {
-		return err
-	}
-	return gui.handleCommitSelect(gui.g, v)
-}
-
-// specific functions
-
 func (gui *Gui) handleResetToCommit(g *gocui.Gui, commitView *gocui.View) error {
 	return gui.createConfirmationPanel(g, commitView, gui.Tr.SLocalize("ResetToCommit"), gui.Tr.SLocalize("SureResetThisCommit"), func(g *gocui.Gui, v *gocui.View) error {
-		commit := gui.getSelectedCommit(g)
-		if commit == nil {
-			panic(errors.New(gui.Tr.SLocalize("NoCommitsThisBranch")))
+		commit, err := gui.getSelectedCommit(g)
+		if err != nil {
+			panic(err)
 		}
 		if err := gui.GitCommand.ResetToCommit(commit.Sha); err != nil {
 			return gui.createErrorPanel(g, err.Error())
@@ -121,39 +50,62 @@ func (gui *Gui) handleResetToCommit(g *gocui.Gui, commitView *gocui.View) error
 		if err := gui.refreshCommits(g); err != nil {
 			panic(err)
 		}
-		if err := gui.refreshFiles(); err != nil {
+		if err := gui.refreshFiles(g); err != nil {
 			panic(err)
 		}
 		gui.resetOrigin(commitView)
-		gui.State.Panels.Commits.SelectedLine = 0
-		return gui.handleCommitSelect(g, commitView)
+		return gui.handleCommitSelect(g, nil)
 	}, nil)
 }
 
+func (gui *Gui) renderCommitsOptions(g *gocui.Gui) error {
+	return gui.renderOptionsMap(g, map[string]string{
+		"s":       gui.Tr.SLocalize("squashDown"),
+		"r":       gui.Tr.SLocalize("rename"),
+		"g":       gui.Tr.SLocalize("resetToThisCommit"),
+		"f":       gui.Tr.SLocalize("fixupCommit"),
+		"← → ↑ ↓": gui.Tr.SLocalize("navigate"),
+	})
+}
+
+func (gui *Gui) handleCommitSelect(g *gocui.Gui, v *gocui.View) error {
+	if err := gui.renderCommitsOptions(g); err != nil {
+		return err
+	}
+	commit, err := gui.getSelectedCommit(g)
+	if err != nil {
+		if err != errors.New(gui.Tr.SLocalize("NoCommitsThisBranch")) {
+			return err
+		}
+		return gui.renderString(g, "main", gui.Tr.SLocalize("NoCommitsThisBranch"))
+	}
+	commitText := gui.GitCommand.Show(commit.Sha)
+	return gui.renderString(g, "main", commitText)
+}
+
 func (gui *Gui) handleCommitSquashDown(g *gocui.Gui, v *gocui.View) error {
-	if len(gui.State.Commits) <= 1 {
+	if gui.getItemPosition(v) != 0 {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("OnlySquashTopmostCommit"))
+	}
+	if len(gui.State.Commits) == 1 {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("YouNoCommitsToSquash"))
 	}
-
-	applied, err := gui.handleMidRebaseCommand("squash")
+	commit, err := gui.getSelectedCommit(g)
 	if err != nil {
 		return err
 	}
-	if applied {
-		return nil
+	if err := gui.GitCommand.SquashPreviousTwoCommits(commit.Name); err != nil {
+		return gui.createErrorPanel(g, err.Error())
 	}
-
-	gui.createConfirmationPanel(g, v, gui.Tr.SLocalize("Squash"), gui.Tr.SLocalize("SureSquashThisCommit"), func(g *gocui.Gui, v *gocui.View) error {
-		return gui.WithWaitingStatus(gui.Tr.SLocalize("SquashingStatus"), func() error {
-			err := gui.GitCommand.InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLine, "squash")
-			return gui.handleGenericMergeCommandResult(err)
-		})
-	}, nil)
-	return nil
+	if err := gui.refreshCommits(g); err != nil {
+		panic(err)
+	}
+	gui.refreshStatus(g)
+	return gui.handleCommitSelect(g, v)
 }
 
 // TODO: move to files panel
-func (gui *Gui) anyUnStagedChanges(files []*commands.File) bool {
+func (gui *Gui) anyUnStagedChanges(files []commands.File) bool {
 	for _, file := range files {
 		if file.Tracked && file.HasUnstagedChanges {
 			return true
@@ -163,40 +115,35 @@ func (gui *Gui) anyUnStagedChanges(files []*commands.File) bool {
 }
 
 func (gui *Gui) handleCommitFixup(g *gocui.Gui, v *gocui.View) error {
-	if len(gui.State.Commits) <= 1 {
+	if len(gui.State.Commits) == 1 {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("YouNoCommitsToSquash"))
 	}
-
-	applied, err := gui.handleMidRebaseCommand("fixup")
+	if gui.anyUnStagedChanges(gui.State.Files) {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("CantFixupWhileUnstagedChanges"))
+	}
+	branch := gui.State.Branches[0]
+	commit, err := gui.getSelectedCommit(g)
 	if err != nil {
 		return err
 	}
-	if applied {
-		return nil
-	}
-
-	gui.createConfirmationPanel(g, v, gui.Tr.SLocalize("Fixup"), gui.Tr.SLocalize("SureFixupThisCommit"), func(g *gocui.Gui, v *gocui.View) error {
-		return gui.WithWaitingStatus(gui.Tr.SLocalize("FixingStatus"), func() error {
-			err := gui.GitCommand.InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLine, "fixup")
-			return gui.handleGenericMergeCommandResult(err)
-		})
+	message := gui.Tr.SLocalize("SureFixupThisCommit")
+	gui.createConfirmationPanel(g, v, gui.Tr.SLocalize("Fixup"), message, func(g *gocui.Gui, v *gocui.View) error {
+		if err := gui.GitCommand.SquashFixupCommit(branch.Name, commit.Sha); err != nil {
+			return gui.createErrorPanel(g, err.Error())
+		}
+		if err := gui.refreshCommits(g); err != nil {
+			panic(err)
+		}
+		return gui.refreshStatus(g)
 	}, nil)
 	return nil
 }
 
 func (gui *Gui) handleRenameCommit(g *gocui.Gui, v *gocui.View) error {
-	applied, err := gui.handleMidRebaseCommand("reword")
-	if err != nil {
-		return err
-	}
-	if applied {
-		return nil
-	}
-
-	if gui.State.Panels.Commits.SelectedLine != 0 {
+	if gui.getItemPosition(v) != 0 {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("OnlyRenameTopCommit"))
 	}
-	return gui.createPromptPanel(g, v, gui.Tr.SLocalize("renameCommit"), func(g *gocui.Gui, v *gocui.View) error {
+	gui.createPromptPanel(g, v, gui.Tr.SLocalize("RenameCommit"), func(g *gocui.Gui, v *gocui.View) error {
 		if err := gui.GitCommand.RenameCommit(v.Buffer()); err != nil {
 			return gui.createErrorPanel(g, err.Error())
 		}
@@ -205,235 +152,21 @@ func (gui *Gui) handleRenameCommit(g *gocui.Gui, v *gocui.View) error {
 		}
 		return gui.handleCommitSelect(g, v)
 	})
-}
-
-func (gui *Gui) handleRenameCommitEditor(g *gocui.Gui, v *gocui.View) error {
-	applied, err := gui.handleMidRebaseCommand("reword")
-	if err != nil {
-		return err
-	}
-	if applied {
-		return nil
-	}
-
-	subProcess, err := gui.GitCommand.RewordCommit(gui.State.Commits, gui.State.Panels.Commits.SelectedLine)
-	if err != nil {
-		return gui.createErrorPanel(gui.g, err.Error())
-	}
-	if subProcess != nil {
-		gui.SubProcess = subProcess
-		return gui.Errors.ErrSubProcess
-	}
-
 	return nil
 }
 
-// handleMidRebaseCommand sees if the selected commit is in fact a rebasing
-// commit meaning you are trying to edit the todo file rather than actually
-// begin a rebase. It then updates the todo file with that action
-func (gui *Gui) handleMidRebaseCommand(action string) (bool, error) {
-	selectedCommit := gui.State.Commits[gui.State.Panels.Commits.SelectedLine]
-	if selectedCommit.Status != "rebasing" {
-		return false, nil
-	}
-
-	// for now we do not support setting 'reword' because it requires an editor
-	// and that means we either unconditionally wait around for the subprocess to ask for
-	// our input or we set a lazygit client as the EDITOR env variable and have it
-	// request us to edit the commit message when prompted.
-	if action == "reword" {
-		return true, gui.createErrorPanel(gui.g, gui.Tr.SLocalize("rewordNotSupported"))
-	}
-
-	if err := gui.GitCommand.EditRebaseTodo(gui.State.Panels.Commits.SelectedLine, action); err != nil {
-		return false, gui.createErrorPanel(gui.g, err.Error())
-	}
-	return true, gui.refreshCommits(gui.g)
-}
-
-// handleMoveTodoDown like handleMidRebaseCommand but for moving an item up in the todo list
-func (gui *Gui) handleMoveTodoDown(index int) (bool, error) {
-	selectedCommit := gui.State.Commits[index]
-	if selectedCommit.Status != "rebasing" {
-		return false, nil
-	}
-	if gui.State.Commits[index+1].Status != "rebasing" {
-		return true, nil
-	}
-	if err := gui.GitCommand.MoveTodoDown(index); err != nil {
-		return true, gui.createErrorPanel(gui.g, err.Error())
-	}
-	return true, gui.refreshCommits(gui.g)
-}
-
-func (gui *Gui) handleCommitDelete(g *gocui.Gui, v *gocui.View) error {
-	applied, err := gui.handleMidRebaseCommand("drop")
+func (gui *Gui) getSelectedCommit(g *gocui.Gui) (commands.Commit, error) {
+	v, err := g.View("commits")
 	if err != nil {
-		return err
+		panic(err)
 	}
-	if applied {
-		return nil
+	if len(gui.State.Commits) == 0 {
+		return commands.Commit{}, errors.New(gui.Tr.SLocalize("NoCommitsThisBranch"))
 	}
-
-	return gui.createConfirmationPanel(gui.g, v, gui.Tr.SLocalize("DeleteCommitTitle"), gui.Tr.SLocalize("DeleteCommitPrompt"), func(*gocui.Gui, *gocui.View) error {
-		return gui.WithWaitingStatus(gui.Tr.SLocalize("DeletingStatus"), func() error {
-			err := gui.GitCommand.InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLine, "drop")
-			return gui.handleGenericMergeCommandResult(err)
-		})
-	}, nil)
-}
-
-func (gui *Gui) handleCommitMoveDown(g *gocui.Gui, v *gocui.View) error {
-	index := gui.State.Panels.Commits.SelectedLine
-	selectedCommit := gui.State.Commits[index]
-	if selectedCommit.Status == "rebasing" {
-		if gui.State.Commits[index+1].Status != "rebasing" {
-			return nil
-		}
-		if err := gui.GitCommand.MoveTodoDown(index); err != nil {
-			return gui.createErrorPanel(gui.g, err.Error())
-		}
-		gui.State.Panels.Commits.SelectedLine++
-		return gui.refreshCommits(gui.g)
+	lineNumber := gui.getItemPosition(v)
+	if lineNumber > len(gui.State.Commits)-1 {
+		gui.Log.Info(gui.Tr.SLocalize("PotentialErrInGetselectedCommit"), gui.State.Commits, lineNumber)
+		return gui.State.Commits[len(gui.State.Commits)-1], nil
 	}
-
-	return gui.WithWaitingStatus(gui.Tr.SLocalize("MovingStatus"), func() error {
-		err := gui.GitCommand.MoveCommitDown(gui.State.Commits, index)
-		if err == nil {
-			gui.State.Panels.Commits.SelectedLine++
-		}
-		return gui.handleGenericMergeCommandResult(err)
-	})
-}
-
-func (gui *Gui) handleCommitMoveUp(g *gocui.Gui, v *gocui.View) error {
-	index := gui.State.Panels.Commits.SelectedLine
-	if index == 0 {
-		return nil
-	}
-	selectedCommit := gui.State.Commits[index]
-	if selectedCommit.Status == "rebasing" {
-		if err := gui.GitCommand.MoveTodoDown(index - 1); err != nil {
-			return gui.createErrorPanel(gui.g, err.Error())
-		}
-		gui.State.Panels.Commits.SelectedLine--
-		return gui.refreshCommits(gui.g)
-	}
-
-	return gui.WithWaitingStatus(gui.Tr.SLocalize("MovingStatus"), func() error {
-		err := gui.GitCommand.MoveCommitDown(gui.State.Commits, index-1)
-		if err == nil {
-			gui.State.Panels.Commits.SelectedLine--
-		}
-		return gui.handleGenericMergeCommandResult(err)
-	})
-}
-
-func (gui *Gui) handleCommitEdit(g *gocui.Gui, v *gocui.View) error {
-	applied, err := gui.handleMidRebaseCommand("edit")
-	if err != nil {
-		return err
-	}
-	if applied {
-		return nil
-	}
-
-	return gui.WithWaitingStatus(gui.Tr.SLocalize("RebasingStatus"), func() error {
-		err = gui.GitCommand.InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLine, "edit")
-		return gui.handleGenericMergeCommandResult(err)
-	})
-}
-
-func (gui *Gui) handleCommitAmendTo(g *gocui.Gui, v *gocui.View) error {
-	return gui.createConfirmationPanel(gui.g, v, gui.Tr.SLocalize("AmendCommitTitle"), gui.Tr.SLocalize("AmendCommitPrompt"), func(*gocui.Gui, *gocui.View) error {
-		return gui.WithWaitingStatus(gui.Tr.SLocalize("AmendingStatus"), func() error {
-			err := gui.GitCommand.AmendTo(gui.State.Commits[gui.State.Panels.Commits.SelectedLine].Sha)
-			return gui.handleGenericMergeCommandResult(err)
-		})
-	}, nil)
-}
-
-func (gui *Gui) handleCommitPick(g *gocui.Gui, v *gocui.View) error {
-	applied, err := gui.handleMidRebaseCommand("pick")
-	if err != nil {
-		return err
-	}
-	if applied {
-		return nil
-	}
-
-	// at this point we aren't actually rebasing so we will interpret this as an
-	// attempt to pull. We might revoke this later after enabling configurable keybindings
-	return gui.pullFiles(g, v)
-}
-
-func (gui *Gui) handleCommitRevert(g *gocui.Gui, v *gocui.View) error {
-	if err := gui.GitCommand.Revert(gui.State.Commits[gui.State.Panels.Commits.SelectedLine].Sha); err != nil {
-		return gui.createErrorPanel(gui.g, err.Error())
-	}
-	gui.State.Panels.Commits.SelectedLine++
-	return gui.refreshCommits(gui.g)
-}
-
-func (gui *Gui) handleCopyCommit(g *gocui.Gui, v *gocui.View) error {
-	// get currently selected commit, add the sha to state.
-	commit := gui.State.Commits[gui.State.Panels.Commits.SelectedLine]
-
-	// we will un-copy it if it's already copied
-	for index, cherryPickedCommit := range gui.State.CherryPickedCommits {
-		if commit.Sha == cherryPickedCommit.Sha {
-			gui.State.CherryPickedCommits = append(gui.State.CherryPickedCommits[0:index], gui.State.CherryPickedCommits[index+1:]...)
-			return gui.refreshCommits(gui.g)
-		}
-	}
-
-	gui.addCommitToCherryPickedCommits(gui.State.Panels.Commits.SelectedLine)
-	return gui.refreshCommits(gui.g)
-}
-
-func (gui *Gui) addCommitToCherryPickedCommits(index int) {
-	// not super happy with modifying the state of the Commits array here
-	// but the alternative would be very tricky
-	gui.State.Commits[index].Copied = true
-
-	newCommits := []*commands.Commit{}
-	for _, commit := range gui.State.Commits {
-		if commit.Copied {
-			// duplicating just the things we need to put in the rebase TODO list
-			newCommits = append(newCommits, &commands.Commit{Name: commit.Name, Sha: commit.Sha})
-		}
-	}
-
-	gui.State.CherryPickedCommits = newCommits
-}
-
-func (gui *Gui) handleCopyCommitRange(g *gocui.Gui, v *gocui.View) error {
-	// whenever I add a commit, I need to make sure I retain its order
-
-	// find the last commit that is copied that's above our position
-	// if there are none, startIndex = 0
-	startIndex := 0
-	for index, commit := range gui.State.Commits[0:gui.State.Panels.Commits.SelectedLine] {
-		if commit.Copied {
-			startIndex = index
-		}
-	}
-
-	gui.Log.Info("commit copy start index: " + strconv.Itoa(startIndex))
-
-	for index := startIndex; index <= gui.State.Panels.Commits.SelectedLine; index++ {
-		gui.addCommitToCherryPickedCommits(index)
-	}
-
-	return gui.refreshCommits(gui.g)
-}
-
-// HandlePasteCommits begins a cherry-pick rebase with the commits the user has copied
-func (gui *Gui) HandlePasteCommits(g *gocui.Gui, v *gocui.View) error {
-	return gui.createConfirmationPanel(g, v, gui.Tr.SLocalize("CherryPick"), gui.Tr.SLocalize("SureCherryPick"), func(g *gocui.Gui, v *gocui.View) error {
-		return gui.WithWaitingStatus(gui.Tr.SLocalize("CherryPickingStatus"), func() error {
-			err := gui.GitCommand.CherryPickCommits(gui.State.CherryPickedCommits)
-			return gui.handleGenericMergeCommandResult(err)
-		})
-	}, nil)
+	return gui.State.Commits[lineNumber], nil
 }

pkg/gui/confirmation_panel.go

@@ -8,17 +8,17 @@ package gui
 
 import (
 	"strings"
-	"time"
 
 	"github.com/fatih/color"
 	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
 func (gui *Gui) wrappedConfirmationFunction(function func(*gocui.Gui, *gocui.View) error) func(*gocui.Gui, *gocui.View) error {
 	return func(g *gocui.Gui, v *gocui.View) error {
 		if function != nil {
 			if err := function(g, v); err != nil {
-				return err
+				panic(err)
 			}
 		}
 		return gui.closeConfirmationPrompt(g)
@@ -28,7 +28,7 @@ func (gui *Gui) wrappedConfirmationFunction(function func(*gocui.Gui, *gocui.Vie
 func (gui *Gui) closeConfirmationPrompt(g *gocui.Gui) error {
 	view, err := g.View("confirmation")
 	if err != nil {
-		return nil // if it's already been closed we can just return
+		panic(err)
 	}
 	if err := gui.returnFocus(g, view); err != nil {
 		panic(err)
@@ -37,24 +37,19 @@ func (gui *Gui) closeConfirmationPrompt(g *gocui.Gui) error {
 	return g.DeleteView("confirmation")
 }
 
-func (gui *Gui) getMessageHeight(wrap bool, message string, width int) int {
+func (gui *Gui) getMessageHeight(message string, width int) int {
 	lines := strings.Split(message, "\n")
 	lineCount := 0
-	// if we need to wrap, calculate height to fit content within view's width
-	if wrap {
-		for _, line := range lines {
-			lineCount += len(line)/width + 1
-		}
-	} else {
-		lineCount = len(lines)
+	for _, line := range lines {
+		lineCount += len(line)/width + 1
 	}
 	return lineCount
 }
 
-func (gui *Gui) getConfirmationPanelDimensions(g *gocui.Gui, wrap bool, prompt string) (int, int, int, int) {
+func (gui *Gui) getConfirmationPanelDimensions(g *gocui.Gui, prompt string) (int, int, int, int) {
 	width, height := g.Size()
 	panelWidth := width / 2
-	panelHeight := gui.getMessageHeight(wrap, prompt, panelWidth)
+	panelHeight := gui.getMessageHeight(prompt, panelWidth)
 	return width/2 - panelWidth/2,
 		height/2 - panelHeight/2 - panelHeight%2 - 1,
 		width/2 + panelWidth/2,
@@ -63,51 +58,27 @@ func (gui *Gui) getConfirmationPanelDimensions(g *gocui.Gui, wrap bool, prompt s
 
 func (gui *Gui) createPromptPanel(g *gocui.Gui, currentView *gocui.View, title string, handleConfirm func(*gocui.Gui, *gocui.View) error) error {
 	gui.onNewPopupPanel()
-	confirmationView, err := gui.prepareConfirmationPanel(currentView, title, "", false)
-	if err != nil {
-		return err
-	}
-	confirmationView.Editable = true
-	return gui.setKeyBindings(g, handleConfirm, nil)
-}
-
-func (gui *Gui) prepareConfirmationPanel(currentView *gocui.View, title, prompt string, hasLoader bool) (*gocui.View, error) {
-	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(gui.g, true, prompt)
-	confirmationView, err := gui.g.SetView("confirmation", x0, y0, x1, y1, 0)
-	if err != nil {
-		if err.Error() != "unknown view" {
-			return nil, err
+	// only need to fit one line
+	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(g, "")
+	if confirmationView, err := g.SetView("confirmation", x0, y0, x1, y1, 0); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
 		}
-		confirmationView.HasLoader = hasLoader
+
+		confirmationView.Editable = true
 		confirmationView.Title = title
-		confirmationView.Wrap = true
 		confirmationView.FgColor = gocui.ColorWhite
+		gui.switchFocus(g, currentView, confirmationView)
+		return gui.setKeyBindings(g, handleConfirm, nil)
 	}
-	gui.g.Update(func(g *gocui.Gui) error {
-		return gui.switchFocus(gui.g, currentView, confirmationView)
-	})
-	return confirmationView, nil
+	return nil
 }
 
 func (gui *Gui) onNewPopupPanel() {
-	viewNames := []string{"commitMessage",
-		"credentials",
-		"menu"}
-	for _, viewName := range viewNames {
-		_, _ = gui.g.SetViewOnBottom(viewName)
-	}
+	gui.g.SetViewOnBottom("commitMessage")
 }
 
-func (gui *Gui) createLoaderPanel(g *gocui.Gui, currentView *gocui.View, prompt string) error {
-	return gui.createPopupPanel(g, currentView, "", prompt, true, nil, nil)
-}
-
-// it is very important that within this function we never include the original prompt in any error messages, because it may contain e.g. a user password
 func (gui *Gui) createConfirmationPanel(g *gocui.Gui, currentView *gocui.View, title, prompt string, handleConfirm, handleClose func(*gocui.Gui, *gocui.View) error) error {
-	return gui.createPopupPanel(g, currentView, title, prompt, false, handleConfirm, handleClose)
-}
-
-func (gui *Gui) createPopupPanel(g *gocui.Gui, currentView *gocui.View, title, prompt string, hasLoader bool, handleConfirm, handleClose func(*gocui.Gui, *gocui.View) error) error {
 	gui.onNewPopupPanel()
 	g.Update(func(g *gocui.Gui) error {
 		// delete the existing confirmation panel if it exists
@@ -122,19 +93,36 @@ func (gui *Gui) createPopupPanel(g *gocui.Gui, currentView *gocui.View, title, p
 				gui.Log.Error(errMessage)
 			}
 		}
-		confirmationView, err := gui.prepareConfirmationPanel(currentView, title, prompt, hasLoader)
-		if err != nil {
-			return err
+		x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(g, prompt)
+		if confirmationView, err := g.SetView("confirmation", x0, y0, x1, y1, 0); err != nil {
+			if err != gocui.ErrUnknownView {
+				return err
+			}
+			confirmationView.Title = title
+			confirmationView.FgColor = gocui.ColorWhite
+			gui.renderString(g, "confirmation", prompt)
+			gui.switchFocus(g, currentView, confirmationView)
+			return gui.setKeyBindings(g, handleConfirm, handleClose)
 		}
-		confirmationView.Editable = false
-		if err := gui.renderString(g, "confirmation", prompt); err != nil {
-			return err
-		}
-		return gui.setKeyBindings(g, handleConfirm, handleClose)
+		return nil
 	})
 	return nil
 }
 
+func (gui *Gui) handleNewline(g *gocui.Gui, v *gocui.View) error {
+	// resising ahead of time so that the top line doesn't get hidden to make
+	// room for the cursor on the second line
+	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(g, v.Buffer())
+	if _, err := g.SetView("confirmation", x0, y0, x1, y1+1, 0); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+	}
+
+	v.EditNewLine()
+	return nil
+}
+
 func (gui *Gui) setKeyBindings(g *gocui.Gui, handleConfirm, handleClose func(*gocui.Gui, *gocui.View) error) error {
 	actions := gui.Tr.TemplateLocalize(
 		"CloseConfirm",
@@ -143,40 +131,37 @@ func (gui *Gui) setKeyBindings(g *gocui.Gui, handleConfirm, handleClose func(*go
 			"keyBindConfirm": "enter",
 		},
 	)
-	if err := gui.renderString(g, "options", actions); err != nil {
+	gui.renderString(g, "options", actions)
+	if err := g.SetKeybinding("confirmation", gocui.KeyEnter, gocui.ModNone, gui.wrappedConfirmationFunction(handleConfirm)); err != nil {
 		return err
 	}
-	if err := g.SetKeybinding("confirmation", gocui.KeyEnter, gocui.ModNone, gui.wrappedConfirmationFunction(handleConfirm)); err != nil {
+	if err := g.SetKeybinding("confirmation", gocui.KeyTab, gocui.ModNone, gui.handleNewline); err != nil {
 		return err
 	}
 	return g.SetKeybinding("confirmation", gocui.KeyEsc, gocui.ModNone, gui.wrappedConfirmationFunction(handleClose))
 }
 
 func (gui *Gui) createMessagePanel(g *gocui.Gui, currentView *gocui.View, title, prompt string) error {
-	return gui.createPopupPanel(g, currentView, title, prompt, false, nil, nil)
-}
-
-// createSpecificErrorPanel allows you to create an error popup, specifying the
-//  view to be focused when the user closes the popup, and a boolean specifying
-// whether we will log the error. If the message may include a user password,
-// this function is to be used over the more generic createErrorPanel, with
-// willLog set to false
-func (gui *Gui) createSpecificErrorPanel(message string, nextView *gocui.View, willLog bool) error {
-	if willLog {
-		go func() {
-			// when reporting is switched on this log call sometimes introduces
-			// a delay on the error panel popping up. Here I'm adding a second wait
-			// so that the error is logged while the user is reading the error message
-			time.Sleep(time.Second)
-			gui.Log.Error(message)
-		}()
-	}
-
-	colorFunction := color.New(color.FgRed).SprintFunc()
-	coloredMessage := colorFunction(strings.TrimSpace(message))
-	return gui.createConfirmationPanel(gui.g, nextView, gui.Tr.SLocalize("Error"), coloredMessage, nil, nil)
+	return gui.createConfirmationPanel(g, currentView, title, prompt, nil, nil)
 }
 
 func (gui *Gui) createErrorPanel(g *gocui.Gui, message string) error {
-	return gui.createSpecificErrorPanel(message, g.CurrentView(), true)
+	currentView := g.CurrentView()
+	colorFunction := color.New(color.FgRed).SprintFunc()
+	coloredMessage := colorFunction(strings.TrimSpace(message))
+	return gui.createConfirmationPanel(g, currentView, gui.Tr.SLocalize("Error"), coloredMessage, nil, nil)
+}
+
+func (gui *Gui) resizePopupPanel(g *gocui.Gui, v *gocui.View) error {
+	// If the confirmation panel is already displayed, just resize the width,
+	// otherwise continue
+	content := utils.TrimTrailingNewline(v.Buffer())
+	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(g, content)
+	vx0, vy0, vx1, vy1 := v.Dimensions()
+	if vx0 == x0 && vy0 == y0 && vx1 == x1 && vy1 == y1 {
+		return nil
+	}
+	gui.Log.Info(gui.Tr.SLocalize("resizingPopupPanel"))
+	_, err := g.SetView(v.Name(), x0, y0, x1, y1, 0)
+	return err
 }

pkg/gui/context.go

@@ -1,75 +0,0 @@
-package gui
-
-func (gui *Gui) titleMap() map[string]string {
-	return map[string]string{
-		"commits":  gui.Tr.SLocalize("DiffTitle"),
-		"branches": gui.Tr.SLocalize("LogTitle"),
-		"files":    gui.Tr.SLocalize("DiffTitle"),
-		"status":   "",
-		"stash":    gui.Tr.SLocalize("DiffTitle"),
-	}
-}
-
-func (gui *Gui) contextTitleMap() map[string]map[string]string {
-	return map[string]map[string]string{
-		"main": {
-			"staging": gui.Tr.SLocalize("StagingMainTitle"),
-			"merging": gui.Tr.SLocalize("MergingMainTitle"),
-			"normal":  "",
-		},
-	}
-}
-
-func (gui *Gui) setMainTitle() error {
-	currentViewName := gui.g.CurrentView().Name()
-	var newTitle string
-	if context, ok := gui.State.Contexts[currentViewName]; ok {
-		newTitle = gui.contextTitleMap()[currentViewName][context]
-	} else if title, ok := gui.titleMap()[currentViewName]; ok {
-		newTitle = title
-	} else {
-		return nil
-	}
-	gui.getMainView().Title = newTitle
-	return nil
-}
-
-func (gui *Gui) changeContext(viewName, context string) error {
-	if gui.State.Contexts[viewName] == context {
-		return nil
-	}
-
-	contextMap := gui.GetContextMap()
-
-	gui.g.DeleteKeybindings(viewName)
-
-	bindings := contextMap[viewName][context]
-	for _, binding := range bindings {
-		if err := gui.g.SetKeybinding(viewName, binding.Key, binding.Modifier, binding.Handler); err != nil {
-			return err
-		}
-	}
-	gui.State.Contexts[viewName] = context
-	return gui.setMainTitle()
-}
-
-func (gui *Gui) setInitialContexts() error {
-	contextMap := gui.GetContextMap()
-
-	initialContexts := map[string]string{
-		"main": "normal",
-	}
-
-	for viewName, context := range initialContexts {
-		bindings := contextMap[viewName][context]
-		for _, binding := range bindings {
-			if err := gui.g.SetKeybinding(binding.ViewName, binding.Key, binding.Modifier, binding.Handler); err != nil {
-				return err
-			}
-		}
-	}
-
-	gui.State.Contexts = initialContexts
-
-	return nil
-}

pkg/gui/credentials_panel.go

@@ -1,104 +0,0 @@
-package gui
-
-import (
-	"strings"
-
-	"github.com/jesseduffield/gocui"
-)
-
-type credentials chan string
-
-// waitForPassUname wait for a username or password input from the credentials popup
-func (gui *Gui) waitForPassUname(g *gocui.Gui, currentView *gocui.View, passOrUname string) string {
-	gui.credentials = make(chan string)
-	g.Update(func(g *gocui.Gui) error {
-		credentialsView, _ := g.View("credentials")
-		if passOrUname == "username" {
-			credentialsView.Title = gui.Tr.SLocalize("CredentialsUsername")
-			credentialsView.Mask = 0
-		} else {
-			credentialsView.Title = gui.Tr.SLocalize("CredentialsPassword")
-			credentialsView.Mask = '*'
-		}
-		err := gui.switchFocus(g, currentView, credentialsView)
-		if err != nil {
-			return err
-		}
-		gui.RenderCommitLength()
-		return nil
-	})
-
-	// wait for username/passwords input
-	userInput := <-gui.credentials
-	return userInput + "\n"
-}
-
-func (gui *Gui) handleSubmitCredential(g *gocui.Gui, v *gocui.View) error {
-	message := gui.trimmedContent(v)
-	gui.credentials <- message
-	err := gui.refreshFiles()
-	if err != nil {
-		return err
-	}
-	v.Clear()
-	err = v.SetCursor(0, 0)
-	if err != nil {
-		return err
-	}
-	_, err = g.SetViewOnBottom("credentials")
-	if err != nil {
-		return err
-	}
-	nextView, err := gui.g.View("confirmation")
-	if err != nil {
-		nextView = gui.getFilesView()
-	}
-	err = gui.switchFocus(g, nil, nextView)
-	if err != nil {
-		return err
-	}
-	return gui.refreshCommits(g)
-}
-
-func (gui *Gui) handleCloseCredentialsView(g *gocui.Gui, v *gocui.View) error {
-	_, err := g.SetViewOnBottom("credentials")
-	if err != nil {
-		return err
-	}
-
-	gui.credentials <- ""
-	return gui.switchFocus(g, nil, gui.getFilesView())
-}
-
-func (gui *Gui) handleCredentialsViewFocused(g *gocui.Gui, v *gocui.View) error {
-	if _, err := g.SetViewOnTop("credentials"); err != nil {
-		return err
-	}
-
-	message := gui.Tr.TemplateLocalize(
-		"CloseConfirm",
-		Teml{
-			"keyBindClose":   "esc",
-			"keyBindConfirm": "enter",
-		},
-	)
-	return gui.renderString(g, "options", message)
-}
-
-// HandleCredentialsPopup handles the views after executing a command that might ask for credentials
-func (gui *Gui) HandleCredentialsPopup(g *gocui.Gui, popupOpened bool, cmdErr error) {
-	if popupOpened {
-		_, _ = gui.g.SetViewOnBottom("credentials")
-	}
-	if cmdErr != nil {
-		errMessage := cmdErr.Error()
-		if strings.Contains(errMessage, "Invalid username or password") {
-			errMessage = gui.Tr.SLocalize("PassUnameWrong")
-		}
-		// we are not logging this error because it may contain a password
-		_ = gui.createSpecificErrorPanel(errMessage, gui.getFilesView(), false)
-	} else {
-		_ = gui.closeConfirmationPrompt(g)
-		_ = gui.refreshSidePanels(g)
-	}
-}

pkg/gui/files_panel.go

@@ -7,136 +7,17 @@ import (
 
 	// "strings"
 
-	"fmt"
+	"os/exec"
 	"strings"
 
+	"github.com/fatih/color"
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
-// list panel functions
-
-func (gui *Gui) getSelectedFile(g *gocui.Gui) (*commands.File, error) {
-	selectedLine := gui.State.Panels.Files.SelectedLine
-	if selectedLine == -1 {
-		return &commands.File{}, gui.Errors.ErrNoFiles
-	}
-
-	return gui.State.Files[selectedLine], nil
-}
-
-func (gui *Gui) handleFilesFocus(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	cx, cy := v.Cursor()
-	_, oy := v.Origin()
-
-	prevSelectedLine := gui.State.Panels.Files.SelectedLine
-	newSelectedLine := cy - oy
-
-	if newSelectedLine > len(gui.State.Files)-1 || len(utils.Decolorise(gui.State.Files[newSelectedLine].DisplayString)) < cx {
-		return gui.handleFileSelect(gui.g, v, false)
-	}
-
-	gui.State.Panels.Files.SelectedLine = newSelectedLine
-
-	if prevSelectedLine == newSelectedLine && gui.currentViewName() == v.Name() {
-		return gui.handleFilePress(gui.g, v)
-	} else {
-		return gui.handleFileSelect(gui.g, v, true)
-	}
-}
-
-func (gui *Gui) handleFileSelect(g *gocui.Gui, v *gocui.View, alreadySelected bool) error {
-	if _, err := gui.g.SetCurrentView(v.Name()); err != nil {
-		return err
-	}
-
-	file, err := gui.getSelectedFile(g)
-	if err != nil {
-		if err != gui.Errors.ErrNoFiles {
-			return err
-		}
-		return gui.renderString(g, "main", gui.Tr.SLocalize("NoChangedFiles"))
-	}
-
-	if err := gui.focusPoint(0, gui.State.Panels.Files.SelectedLine, v); err != nil {
-		return err
-	}
-
-	if file.HasInlineMergeConflicts {
-		return gui.refreshMergePanel()
-	}
-
-	content := gui.GitCommand.Diff(file, false)
-	if alreadySelected {
-		g.Update(func(*gocui.Gui) error {
-			return gui.setViewContent(gui.g, gui.getMainView(), content)
-		})
-		return nil
-	}
-	return gui.renderString(g, "main", content)
-}
-
-func (gui *Gui) refreshFiles() error {
-	selectedFile, _ := gui.getSelectedFile(gui.g)
-
-	filesView := gui.getFilesView()
-	if err := gui.refreshStateFiles(); err != nil {
-		return err
-	}
-
-	gui.g.Update(func(g *gocui.Gui) error {
-
-		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 filesView == g.CurrentView() {
-			newSelectedFile, _ := gui.getSelectedFile(gui.g)
-			alreadySelected := newSelectedFile.Name == selectedFile.Name
-			return gui.handleFileSelect(g, filesView, alreadySelected)
-		}
-		return nil
-	})
-
-	return nil
-}
-
-func (gui *Gui) handleFilesNextLine(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	panelState := gui.State.Panels.Files
-	gui.changeSelectedLine(&panelState.SelectedLine, len(gui.State.Files), false)
-
-	return gui.handleFileSelect(gui.g, v, false)
-}
-
-func (gui *Gui) handleFilesPrevLine(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	panelState := gui.State.Panels.Files
-	gui.changeSelectedLine(&panelState.SelectedLine, len(gui.State.Files), true)
-
-	return gui.handleFileSelect(gui.g, v, false)
-}
-
-// specific functions
-
-func (gui *Gui) stagedFiles() []*commands.File {
+func (gui *Gui) stagedFiles() []commands.File {
 	files := gui.State.Files
-	result := make([]*commands.File, 0)
+	result := make([]commands.File, 0)
 	for _, file := range files {
 		if file.HasStagedChanges {
 			result = append(result, file)
@@ -145,9 +26,9 @@ func (gui *Gui) stagedFiles() []*commands.File {
 	return result
 }
 
-func (gui *Gui) trackedFiles() []*commands.File {
+func (gui *Gui) trackedFiles() []commands.File {
 	files := gui.State.Files
-	result := make([]*commands.File, 0)
+	result := make([]commands.File, 0)
 	for _, file := range files {
 		if file.Tracked {
 			result = append(result, file)
@@ -164,29 +45,6 @@ func (gui *Gui) stageSelectedFile(g *gocui.Gui) error {
 	return gui.GitCommand.StageFile(file.Name)
 }
 
-func (gui *Gui) handleEnterFile(g *gocui.Gui, v *gocui.View) error {
-	file, err := gui.getSelectedFile(g)
-	if err != nil {
-		if err != gui.Errors.ErrNoFiles {
-			return err
-		}
-		return nil
-	}
-	if file.HasInlineMergeConflicts {
-		return gui.handleSwitchToMerge(g, v)
-	}
-	if !file.HasUnstagedChanges || file.HasMergeConflicts {
-		return gui.createErrorPanel(g, gui.Tr.SLocalize("FileStagingRequirements"))
-	}
-	if err := gui.changeContext("main", "staging"); err != nil {
-		return err
-	}
-	if err := gui.switchFocus(g, v, gui.getMainView()); err != nil {
-		return err
-	}
-	return gui.refreshStagingPanel()
-}
-
 func (gui *Gui) handleFilePress(g *gocui.Gui, v *gocui.View) error {
 	file, err := gui.getSelectedFile(g)
 	if err != nil {
@@ -196,7 +54,7 @@ func (gui *Gui) handleFilePress(g *gocui.Gui, v *gocui.View) error {
 		return err
 	}
 
-	if file.HasInlineMergeConflicts {
+	if file.HasMergeConflicts {
 		return gui.handleSwitchToMerge(g, v)
 	}
 
@@ -206,38 +64,11 @@ func (gui *Gui) handleFilePress(g *gocui.Gui, v *gocui.View) error {
 		gui.GitCommand.UnStageFile(file.Name, file.Tracked)
 	}
 
-	if err := gui.refreshFiles(); err != nil {
+	if err := gui.refreshFiles(g); err != nil {
 		return err
 	}
 
-	return gui.handleFileSelect(g, v, true)
-}
-
-func (gui *Gui) allFilesStaged() bool {
-	for _, file := range gui.State.Files {
-		if file.HasUnstagedChanges {
-			return false
-		}
-	}
-	return true
-}
-
-func (gui *Gui) handleStageAll(g *gocui.Gui, v *gocui.View) error {
-	var err error
-	if gui.allFilesStaged() {
-		err = gui.GitCommand.UnstageAll()
-	} else {
-		err = gui.GitCommand.StageAll()
-	}
-	if err != nil {
-		_ = gui.createErrorPanel(g, err.Error())
-	}
-
-	if err := gui.refreshFiles(); err != nil {
-		return err
-	}
-
-	return gui.handleFileSelect(g, v, false)
+	return gui.handleFileSelect(g, v)
 }
 
 func (gui *Gui) handleAddPatch(g *gocui.Gui, v *gocui.View) error {
@@ -254,11 +85,26 @@ func (gui *Gui) handleAddPatch(g *gocui.Gui, v *gocui.View) error {
 	if !file.Tracked {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("CannotGitAdd"))
 	}
-
-	gui.SubProcess = gui.GitCommand.AddPatch(file.Name)
+	sub, err := gui.GitCommand.AddPatch(file.Name)
+	if err != nil {
+		return err
+	}
+	gui.SubProcess = sub
 	return gui.Errors.ErrSubProcess
 }
 
+func (gui *Gui) getSelectedFile(g *gocui.Gui) (commands.File, error) {
+	if len(gui.State.Files) == 0 {
+		return commands.File{}, gui.Errors.ErrNoFiles
+	}
+	filesView, err := g.View("files")
+	if err != nil {
+		panic(err)
+	}
+	lineNumber := gui.getItemPosition(filesView)
+	return gui.State.Files[lineNumber], nil
+}
+
 func (gui *Gui) handleFileRemove(g *gocui.Gui, v *gocui.View) error {
 	file, err := gui.getSelectedFile(g)
 	if err != nil {
@@ -282,9 +128,9 @@ func (gui *Gui) handleFileRemove(g *gocui.Gui, v *gocui.View) error {
 	)
 	return gui.createConfirmationPanel(g, v, strings.Title(deleteVerb)+" file", message, func(g *gocui.Gui, v *gocui.View) error {
 		if err := gui.GitCommand.RemoveFile(file); err != nil {
-			return err
+			panic(err)
 		}
-		return gui.refreshFiles()
+		return gui.refreshFiles(g)
 	}, nil)
 }
 
@@ -296,50 +142,73 @@ func (gui *Gui) handleIgnoreFile(g *gocui.Gui, v *gocui.View) error {
 	if file.Tracked {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("CantIgnoreTrackFiles"))
 	}
-	if err := gui.GitCommand.Ignore(file.Name); err != nil {
-		return gui.createErrorPanel(g, err.Error())
+	gui.GitCommand.Ignore(file.Name)
+	return gui.refreshFiles(g)
+}
+
+func (gui *Gui) renderfilesOptions(g *gocui.Gui, file *commands.File) error {
+	optionsMap := map[string]string{
+		"← → ↑ ↓":   gui.Tr.SLocalize("navigate"),
+		"S":         gui.Tr.SLocalize("stashFiles"),
+		"c":         gui.Tr.SLocalize("CommitChanges"),
+		"o":         gui.Tr.SLocalize("open"),
+		"i":         gui.Tr.SLocalize("ignore"),
+		"d":         gui.Tr.SLocalize("delete"),
+		"space":     gui.Tr.SLocalize("toggleStaged"),
+		"R":         gui.Tr.SLocalize("refresh"),
+		"t":         gui.Tr.SLocalize("addPatch"),
+		"e":         gui.Tr.SLocalize("edit"),
+		"PgUp/PgDn": gui.Tr.SLocalize("scroll"),
 	}
-	return gui.refreshFiles()
+	if gui.State.HasMergeConflicts {
+		optionsMap["a"] = gui.Tr.SLocalize("abortMerge")
+		optionsMap["m"] = gui.Tr.SLocalize("resolveMergeConflicts")
+	}
+	if file == nil {
+		return gui.renderOptionsMap(g, optionsMap)
+	}
+	if file.Tracked {
+		optionsMap["d"] = gui.Tr.SLocalize("checkout")
+	}
+	return gui.renderOptionsMap(g, optionsMap)
+}
+
+func (gui *Gui) handleFileSelect(g *gocui.Gui, v *gocui.View) error {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		if err != gui.Errors.ErrNoFiles {
+			return err
+		}
+		gui.renderString(g, "main", gui.Tr.SLocalize("NoChangedFiles"))
+		return gui.renderfilesOptions(g, nil)
+	}
+	gui.renderfilesOptions(g, &file)
+	var content string
+	if file.HasMergeConflicts {
+		return gui.refreshMergePanel(g)
+	}
+
+	content = gui.GitCommand.Diff(file)
+	return gui.renderString(g, "main", content)
 }
 
 func (gui *Gui) handleCommitPress(g *gocui.Gui, filesView *gocui.View) error {
-	if len(gui.stagedFiles()) == 0 && gui.State.WorkingTreeState == "normal" {
+	if len(gui.stagedFiles()) == 0 && !gui.State.HasMergeConflicts {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("NoStagedFilesToCommit"))
 	}
-	commitMessageView := gui.getCommitMessageView()
+	commitMessageView := gui.getCommitMessageView(g)
 	g.Update(func(g *gocui.Gui) error {
 		g.SetViewOnTop("commitMessage")
 		gui.switchFocus(g, filesView, commitMessageView)
-		gui.RenderCommitLength()
 		return nil
 	})
 	return nil
 }
 
-func (gui *Gui) handleAmendCommitPress(g *gocui.Gui, filesView *gocui.View) error {
-	if len(gui.stagedFiles()) == 0 && gui.State.WorkingTreeState == "normal" {
-		return gui.createErrorPanel(g, gui.Tr.SLocalize("NoStagedFilesToCommit"))
-	}
-	if len(gui.State.Commits) == 0 {
-		return gui.createErrorPanel(g, gui.Tr.SLocalize("NoCommitToAmend"))
-	}
-
-	title := strings.Title(gui.Tr.SLocalize("AmendLastCommit"))
-	question := gui.Tr.SLocalize("SureToAmend")
-
-	return gui.createConfirmationPanel(g, filesView, title, question, func(g *gocui.Gui, v *gocui.View) error {
-		if err := gui.runSyncOrAsyncCommand(gui.GitCommand.AmendHead()); err != nil {
-			return err
-		}
-
-		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 {
-	if len(gui.stagedFiles()) == 0 && gui.State.WorkingTreeState == "normal" {
+	if len(gui.stagedFiles()) == 0 && !gui.State.HasMergeConflicts {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("NoStagedFilesToCommit"))
 	}
 	gui.PrepareSubProcess(g, "git", "commit")
@@ -347,15 +216,29 @@ func (gui *Gui) handleCommitEditorPress(g *gocui.Gui, filesView *gocui.View) err
 }
 
 // PrepareSubProcess - prepare a subprocess for execution and tell the gui to switch to it
-func (gui *Gui) PrepareSubProcess(g *gocui.Gui, commands ...string) {
-	gui.SubProcess = gui.GitCommand.PrepareCommitSubProcess()
+func (gui *Gui) PrepareSubProcess(g *gocui.Gui, commands ...string) error {
+	sub, err := gui.GitCommand.PrepareCommitSubProcess()
+	if err != nil {
+		return err
+	}
+	gui.SubProcess = sub
 	g.Update(func(g *gocui.Gui) error {
 		return gui.Errors.ErrSubProcess
 	})
+	return nil
 }
 
-func (gui *Gui) editFile(filename string) error {
-	return gui.runSyncOrAsyncCommand(gui.OSCommand.EditFile(filename))
+func (gui *Gui) genericFileOpen(g *gocui.Gui, v *gocui.View, filename string, open func(string) (*exec.Cmd, error)) error {
+
+	sub, err := open(filename)
+	if err != nil {
+		return gui.createErrorPanel(g, err.Error())
+	}
+	if sub != nil {
+		gui.SubProcess = sub
+		return gui.Errors.ErrSubProcess
+	}
+	return nil
 }
 
 func (gui *Gui) handleFileEdit(g *gocui.Gui, v *gocui.View) error {
@@ -363,8 +246,7 @@ func (gui *Gui) handleFileEdit(g *gocui.Gui, v *gocui.View) error {
 	if err != nil {
 		return err
 	}
-
-	return gui.editFile(file.Name)
+	return gui.genericFileOpen(g, v, file.Name, gui.OSCommand.EditFile)
 }
 
 func (gui *Gui) handleFileOpen(g *gocui.Gui, v *gocui.View) error {
@@ -372,19 +254,61 @@ func (gui *Gui) handleFileOpen(g *gocui.Gui, v *gocui.View) error {
 	if err != nil {
 		return err
 	}
-	return gui.openFile(file.Name)
+	return gui.genericFileOpen(g, v, file.Name, gui.OSCommand.OpenFile)
+}
+
+func (gui *Gui) handleSublimeFileOpen(g *gocui.Gui, v *gocui.View) error {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		return err
+	}
+	return gui.genericFileOpen(g, v, file.Name, gui.OSCommand.SublimeOpenFile)
+}
+
+func (gui *Gui) handleVsCodeFileOpen(g *gocui.Gui, v *gocui.View) error {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		return err
+	}
+	return gui.genericFileOpen(g, v, file.Name, gui.OSCommand.VsCodeOpenFile)
 }
 
 func (gui *Gui) handleRefreshFiles(g *gocui.Gui, v *gocui.View) error {
-	return gui.refreshFiles()
+	return gui.refreshFiles(g)
 }
 
-func (gui *Gui) refreshStateFiles() error {
+func (gui *Gui) refreshStateFiles() {
 	// get files to stage
 	files := gui.GitCommand.GetStatusFiles()
 	gui.State.Files = gui.GitCommand.MergeStatusFiles(gui.State.Files, files)
-	gui.refreshSelectedLine(&gui.State.Panels.Files.SelectedLine, len(gui.State.Files))
-	return gui.updateWorkTreeState()
+	gui.updateHasMergeConflictStatus()
+}
+
+func (gui *Gui) updateHasMergeConflictStatus() error {
+	merging, err := gui.GitCommand.IsInMergeState()
+	if err != nil {
+		return err
+	}
+	gui.State.HasMergeConflicts = merging
+	return nil
+}
+
+func (gui *Gui) renderFile(file commands.File, filesView *gocui.View) {
+	// potentially inefficient to be instantiating these color
+	// objects with each render
+	red := color.New(color.FgRed)
+	green := color.New(color.FgGreen)
+	if !file.Tracked && !file.HasStagedChanges {
+		red.Fprintln(filesView, file.DisplayString)
+		return
+	}
+	green.Fprint(filesView, file.DisplayString[0:1])
+	red.Fprint(filesView, file.DisplayString[1:3])
+	if file.HasUnstagedChanges {
+		red.Fprintln(filesView, file.Name)
+	} else {
+		green.Fprintln(filesView, file.Name)
+	}
 }
 
 func (gui *Gui) catSelectedFile(g *gocui.Gui) (string, error) {
@@ -395,62 +319,65 @@ func (gui *Gui) catSelectedFile(g *gocui.Gui) (string, error) {
 		}
 		return "", gui.renderString(g, "main", gui.Tr.SLocalize("NoFilesDisplay"))
 	}
-	if item.Type != "file" {
-		return "", gui.renderString(g, "main", gui.Tr.SLocalize("NotAFile"))
-	}
 	cat, err := gui.GitCommand.CatFile(item.Name)
 	if err != nil {
-		gui.Log.Error(err)
-		return "", gui.renderString(g, "main", err.Error())
+		panic(err)
 	}
 	return cat, nil
 }
 
-func (gui *Gui) pullFiles(g *gocui.Gui, v *gocui.View) error {
-	if err := gui.createLoaderPanel(gui.g, v, gui.Tr.SLocalize("PullWait")); err != nil {
+func (gui *Gui) refreshFiles(g *gocui.Gui) error {
+	filesView, err := g.View("files")
+	if err != nil {
 		return err
 	}
-
-	go func() {
-		unamePassOpend := false
-		err := gui.GitCommand.Pull(func(passOrUname string) string {
-			unamePassOpend = true
-			return gui.waitForPassUname(g, v, passOrUname)
-		})
-		gui.HandleCredentialsPopup(g, unamePassOpend, err)
-	}()
+	gui.refreshStateFiles()
+	filesView.Clear()
+	for _, file := range gui.State.Files {
+		gui.renderFile(file, filesView)
+	}
+	gui.correctCursor(filesView)
+	if filesView == g.CurrentView() {
+		gui.handleFileSelect(g, filesView)
+	}
 	return nil
 }
 
-func (gui *Gui) pushWithForceFlag(g *gocui.Gui, v *gocui.View, force bool) error {
-	if err := gui.createLoaderPanel(gui.g, v, gui.Tr.SLocalize("PushWait")); err != nil {
-		return err
-	}
+func (gui *Gui) pullFiles(g *gocui.Gui, v *gocui.View) error {
+	gui.createMessagePanel(g, v, "", gui.Tr.SLocalize("PullWait"))
 	go func() {
-		unamePassOpend := false
-		branchName := gui.State.Branches[0].Name
-		err := gui.GitCommand.Push(branchName, force, func(passOrUname string) string {
-			unamePassOpend = true
-			return gui.waitForPassUname(g, v, passOrUname)
-		})
-		gui.HandleCredentialsPopup(g, unamePassOpend, err)
+		if err := gui.GitCommand.Pull(); err != nil {
+			gui.createErrorPanel(g, err.Error())
+		} else {
+			gui.closeConfirmationPrompt(g)
+			gui.refreshCommits(g)
+			gui.refreshStatus(g)
+		}
+		gui.refreshFiles(g)
 	}()
 	return nil
 }
 
 func (gui *Gui) pushFiles(g *gocui.Gui, v *gocui.View) error {
-	// if we have pullables we'll ask if the user wants to force push
-	_, pullables := gui.GitCommand.GetCurrentBranchUpstreamDifferenceCount()
-	if pullables == "?" || pullables == "0" {
-		return gui.pushWithForceFlag(g, v, false)
-	}
-	err := gui.createConfirmationPanel(g, nil, gui.Tr.SLocalize("ForcePush"), gui.Tr.SLocalize("ForcePushPrompt"), func(g *gocui.Gui, v *gocui.View) error {
-		return gui.pushWithForceFlag(g, v, true)
-	}, nil)
-	return err
+	gui.createMessagePanel(g, v, "", gui.Tr.SLocalize("PushWait"))
+	go func() {
+		branchName := gui.State.Branches[0].Name
+		if err := gui.GitCommand.Push(branchName); err != nil {
+			gui.createErrorPanel(g, err.Error())
+		} else {
+			gui.closeConfirmationPrompt(g)
+			gui.refreshCommits(g)
+			gui.refreshStatus(g)
+		}
+	}()
+	return nil
 }
 
 func (gui *Gui) handleSwitchToMerge(g *gocui.Gui, v *gocui.View) error {
+	mergeView, err := g.View("main")
+	if err != nil {
+		return err
+	}
 	file, err := gui.getSelectedFile(g)
 	if err != nil {
 		if err != gui.Errors.ErrNoFiles {
@@ -458,16 +385,11 @@ func (gui *Gui) handleSwitchToMerge(g *gocui.Gui, v *gocui.View) error {
 		}
 		return nil
 	}
-	if !file.HasInlineMergeConflicts {
+	if !file.HasMergeConflicts {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("FileNoMergeCons"))
 	}
-	if err := gui.changeContext("main", "merging"); err != nil {
-		return err
-	}
-	if err := gui.switchFocus(g, v, gui.getMainView()); err != nil {
-		return err
-	}
-	return gui.refreshMergePanel()
+	gui.switchFocus(g, v, mergeView)
+	return gui.refreshMergePanel(g)
 }
 
 func (gui *Gui) handleAbortMerge(g *gocui.Gui, v *gocui.View) error {
@@ -476,43 +398,14 @@ func (gui *Gui) handleAbortMerge(g *gocui.Gui, v *gocui.View) error {
 	}
 	gui.createMessagePanel(g, v, "", gui.Tr.SLocalize("MergeAborted"))
 	gui.refreshStatus(g)
-	return gui.refreshFiles()
+	return gui.refreshFiles(g)
 }
 
-func (gui *Gui) handleResetAndClean(g *gocui.Gui, v *gocui.View) error {
+func (gui *Gui) handleResetHard(g *gocui.Gui, v *gocui.View) error {
 	return gui.createConfirmationPanel(g, v, gui.Tr.SLocalize("ClearFilePanel"), gui.Tr.SLocalize("SureResetHardHead"), func(g *gocui.Gui, v *gocui.View) error {
-		if err := gui.GitCommand.ResetAndClean(); err != nil {
+		if err := gui.GitCommand.ResetHard(); err != nil {
 			gui.createErrorPanel(g, err.Error())
 		}
-		return gui.refreshFiles()
-	}, nil)
-}
-
-func (gui *Gui) openFile(filename string) error {
-	if err := gui.OSCommand.OpenFile(filename); err != nil {
-		return gui.createErrorPanel(gui.g, err.Error())
-	}
-	return nil
-}
-
-func (gui *Gui) anyFilesWithMergeConflicts() bool {
-	for _, file := range gui.State.Files {
-		if file.HasMergeConflicts {
-			return true
-		}
-	}
-	return false
-}
-
-func (gui *Gui) handleSoftReset(g *gocui.Gui, v *gocui.View) error {
-	return gui.createConfirmationPanel(g, v, gui.Tr.SLocalize("SoftReset"), gui.Tr.SLocalize("ConfirmSoftReset"), func(g *gocui.Gui, v *gocui.View) error {
-		if err := gui.GitCommand.SoftReset("HEAD^"); err != nil {
-			return gui.createErrorPanel(g, err.Error())
-		}
-
-		if err := gui.refreshCommits(gui.g); err != nil {
-			return err
-		}
-		return gui.refreshFiles()
+		return gui.refreshFiles(g)
 	}, nil)
 }

pkg/gui/gui.go

@@ -1,31 +1,26 @@
 package gui
 
 import (
-	"math"
-	"sync"
 
 	// "io"
 	// "io/ioutil"
 
+	"errors"
 	"io/ioutil"
+	"log"
 	"os"
 	"os/exec"
 	"strings"
 	"time"
 
-	"github.com/go-errors/errors"
-
 	// "strings"
 
-	"github.com/fatih/color"
+	"github.com/Sirupsen/logrus"
 	"github.com/golang-collections/collections/stack"
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
 	"github.com/jesseduffield/lazygit/pkg/config"
 	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/jesseduffield/lazygit/pkg/updates"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/sirupsen/logrus"
 )
 
 // OverlappingEdges determines if panel edges overlap
@@ -36,7 +31,6 @@ var OverlappingEdges = false
 type SentinelErrors struct {
 	ErrSubProcess error
 	ErrNoFiles    error
-	ErrSwitchRepo error
 }
 
 // GenerateSentinelErrors makes the sentinel errors for the gui. We're defining it here
@@ -53,7 +47,6 @@ func (gui *Gui) GenerateSentinelErrors() {
 	gui.Errors = SentinelErrors{
 		ErrSubProcess: errors.New(gui.Tr.SLocalize("RunningSubprocess")),
 		ErrNoFiles:    errors.New(gui.Tr.SLocalize("NoChangedFiles")),
-		ErrSwitchRepo: errors.New("switching repo"),
 	}
 }
 
@@ -62,116 +55,52 @@ type Teml i18n.Teml
 
 // Gui wraps the gocui Gui object which handles rendering and events
 type Gui struct {
-	g             *gocui.Gui
-	Log           *logrus.Entry
-	GitCommand    *commands.GitCommand
-	OSCommand     *commands.OSCommand
-	SubProcess    *exec.Cmd
-	State         guiState
-	Config        config.AppConfigurer
-	Tr            *i18n.Localizer
-	Errors        SentinelErrors
-	Updater       *updates.Updater
-	statusManager *statusManager
-	credentials   credentials
-	waitForIntro  sync.WaitGroup
-}
-
-// for now the staging panel state, unlike the other panel states, is going to be
-// non-mutative, so that we don't accidentally end up
-// with mismatches of data. We might change this in the future
-type stagingPanelState struct {
-	SelectedLine   int
-	StageableLines []int
-	HunkStarts     []int
-	Diff           string
-}
-
-type mergingPanelState struct {
-	ConflictIndex int
-	ConflictTop   bool
-	Conflicts     []commands.Conflict
-	EditHistory   *stack.Stack
-}
-
-type filePanelState struct {
-	SelectedLine int
-}
-
-type branchPanelState struct {
-	SelectedLine int
-}
-
-type commitPanelState struct {
-	SelectedLine int
-}
-
-type stashPanelState struct {
-	SelectedLine int
-}
-
-type menuPanelState struct {
-	SelectedLine int
-}
-
-type panelStates struct {
-	Files    *filePanelState
-	Branches *branchPanelState
-	Commits  *commitPanelState
-	Stash    *stashPanelState
-	Menu     *menuPanelState
-	Staging  *stagingPanelState
-	Merging  *mergingPanelState
+	g          *gocui.Gui
+	Log        *logrus.Logger
+	GitCommand *commands.GitCommand
+	OSCommand  *commands.OSCommand
+	SubProcess *exec.Cmd
+	State      guiState
+	Config     config.AppConfigurer
+	Tr         *i18n.Localizer
+	Errors     SentinelErrors
 }
 
 type guiState struct {
-	Files               []*commands.File
-	Branches            []*commands.Branch
-	Commits             []*commands.Commit
-	StashEntries        []*commands.StashEntry
-	PreviousView        string
-	Platform            commands.Platform
-	Updating            bool
-	Panels              *panelStates
-	WorkingTreeState    string // one of "merging", "rebasing", "normal"
-	Contexts            map[string]string
-	CherryPickedCommits []*commands.Commit
+	Files             []commands.File
+	Branches          []commands.Branch
+	Commits           []commands.Commit
+	StashEntries      []commands.StashEntry
+	PreviousView      string
+	HasMergeConflicts bool
+	ConflictIndex     int
+	ConflictTop       bool
+	Conflicts         []commands.Conflict
+	EditHistory       *stack.Stack
+	Platform          commands.Platform
 }
 
 // NewGui builds a new gui handler
-func NewGui(log *logrus.Entry, gitCommand *commands.GitCommand, oSCommand *commands.OSCommand, tr *i18n.Localizer, config config.AppConfigurer, updater *updates.Updater) (*Gui, error) {
-
+func NewGui(log *logrus.Logger, gitCommand *commands.GitCommand, oSCommand *commands.OSCommand, tr *i18n.Localizer, config config.AppConfigurer) (*Gui, error) {
 	initialState := guiState{
-		Files:               make([]*commands.File, 0),
-		PreviousView:        "files",
-		Commits:             make([]*commands.Commit, 0),
-		CherryPickedCommits: make([]*commands.Commit, 0),
-		StashEntries:        make([]*commands.StashEntry, 0),
-		Platform:            *oSCommand.Platform,
-		Panels: &panelStates{
-			Files:    &filePanelState{SelectedLine: -1},
-			Branches: &branchPanelState{SelectedLine: 0},
-			Commits:  &commitPanelState{SelectedLine: -1},
-			Stash:    &stashPanelState{SelectedLine: -1},
-			Menu:     &menuPanelState{SelectedLine: 0},
-			Merging: &mergingPanelState{
-				ConflictIndex: 0,
-				ConflictTop:   true,
-				Conflicts:     []commands.Conflict{},
-				EditHistory:   stack.New(),
-			},
-		},
+		Files:         make([]commands.File, 0),
+		PreviousView:  "files",
+		Commits:       make([]commands.Commit, 0),
+		StashEntries:  make([]commands.StashEntry, 0),
+		ConflictIndex: 0,
+		ConflictTop:   true,
+		Conflicts:     make([]commands.Conflict, 0),
+		EditHistory:   stack.New(),
+		Platform:      *oSCommand.Platform,
 	}
 
 	gui := &Gui{
-		Log:           log,
-		GitCommand:    gitCommand,
-		OSCommand:     oSCommand,
-		State:         initialState,
-		Config:        config,
-		Tr:            tr,
-		Updater:       updater,
-		statusManager: &statusManager{},
+		Log:        log,
+		GitCommand: gitCommand,
+		OSCommand:  oSCommand,
+		State:      initialState,
+		Config:     config,
+		Tr:         tr,
 	}
 
 	gui.GenerateSentinelErrors()
@@ -182,19 +111,16 @@ func NewGui(log *logrus.Entry, gitCommand *commands.GitCommand, oSCommand *comma
 func (gui *Gui) scrollUpMain(g *gocui.Gui, v *gocui.View) error {
 	mainView, _ := g.View("main")
 	ox, oy := mainView.Origin()
-	newOy := int(math.Max(0, float64(oy-gui.Config.GetUserConfig().GetInt("gui.scrollHeight"))))
-	return mainView.SetOrigin(ox, newOy)
+	if oy >= 1 {
+		return mainView.SetOrigin(ox, oy-gui.Config.GetUserConfig().GetInt("gui.scrollHeight"))
+	}
+	return nil
 }
 
 func (gui *Gui) scrollDownMain(g *gocui.Gui, v *gocui.View) error {
 	mainView, _ := g.View("main")
 	ox, oy := mainView.Origin()
-	y := oy
-	if !gui.Config.GetUserConfig().GetBool("gui.scrollPastBottom") {
-		_, sy := mainView.Size()
-		y += sy
-	}
-	if y < len(mainView.BufferLines()) {
+	if oy < len(mainView.BufferLines()) {
 		return mainView.SetOrigin(ox, oy+gui.Config.GetUserConfig().GetInt("gui.scrollHeight"))
 	}
 	return nil
@@ -211,89 +137,18 @@ func max(a, b int) int {
 	return b
 }
 
-// getFocusLayout returns a manager function for when view gain and lose focus
-func (gui *Gui) getFocusLayout() func(g *gocui.Gui) error {
-	var focusedView *gocui.View
-	return func(g *gocui.Gui) error {
-		v := gui.g.CurrentView()
-		if v != focusedView {
-			if err := gui.onFocusChange(); err != nil {
-				return err
-			}
-			if err := gui.onFocusLost(focusedView); err != nil {
-				return err
-			}
-			if err := gui.onFocus(v); err != nil {
-				return err
-			}
-			focusedView = v
-		}
-		return nil
-	}
-}
-
-func (gui *Gui) onFocusChange() error {
-	currentView := gui.g.CurrentView()
-	for _, view := range gui.g.Views() {
-		view.Highlight = view == currentView
-	}
-	return gui.setMainTitle()
-}
-
-func (gui *Gui) onFocusLost(v *gocui.View) error {
-	if v == nil {
-		return nil
-	}
-	if v.Name() == "branches" {
-		if err := gui.renderListPanel(gui.getBranchesView(), gui.State.Branches); err != nil {
-			return err
-		}
-	} else if v.Name() == "main" {
-		// if we have lost focus to a popup panel, that's okay
-		if gui.popupPanelFocused() {
-			return nil
-		}
-
-		if err := gui.changeContext("main", "normal"); err != nil {
-			return err
-		}
-	}
-	gui.Log.Info(v.Name() + " focus lost")
-	return nil
-}
-
-func (gui *Gui) onFocus(v *gocui.View) error {
-	if v == nil {
-		return nil
-	}
-	gui.Log.Info(v.Name() + " focus gained")
-	return nil
-}
-
 // layout is called for every screen re-render e.g. when the screen is resized
 func (gui *Gui) layout(g *gocui.Gui) error {
 	g.Highlight = true
 	width, height := g.Size()
-	information := gui.Config.GetVersion()
-	if gui.g.Mouse {
-		donate := color.New(color.FgMagenta, color.Underline).Sprint(gui.Tr.SLocalize("Donate"))
-		information = donate + " " + information
-	}
 	leftSideWidth := width / 3
 	statusFilesBoundary := 2
-	filesBranchesBoundary := 2 * height / 5
-	commitsBranchesBoundary := 3 * height / 5
-	optionsTop := height - 2
-	commitsStashBoundary := optionsTop - 3
-	optionsVersionBoundary := width - max(len(utils.Decolorise(information)), 1)
-	minimumHeight := 18
+	filesBranchesBoundary := 2 * height / 5   // height - 20
+	commitsBranchesBoundary := 3 * height / 5 // height - 10
+	commitsStashBoundary := height - 5        // height - 5
+	minimumHeight := 16
 	minimumWidth := 10
-
-	appStatus := gui.statusManager.getStatusString()
-	appStatusOptionsBoundary := 0
-	if appStatus != "" {
-		appStatusOptionsBoundary = len(appStatus) + 2
-	}
+	version := gui.Config.GetVersion()
 
 	panelSpacing := 1
 	if OverlappingEdges {
@@ -303,21 +158,26 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 	if height < minimumHeight || width < minimumWidth {
 		v, err := g.SetView("limit", 0, 0, max(width-1, 2), max(height-1, 2), 0)
 		if err != nil {
-			if err.Error() != "unknown view" {
+			if err != gocui.ErrUnknownView {
 				return err
 			}
 			v.Title = gui.Tr.SLocalize("NotEnoughSpace")
 			v.Wrap = true
-			g.SetViewOnTop("limit")
 		}
 		return nil
 	}
-	_, _ = g.SetViewOnBottom("limit")
+
 	g.DeleteView("limit")
 
+	optionsTop := height - 2
+	// hiding options if there's not enough space
+	if height < 30 {
+		optionsTop = height - 1
+	}
+
 	v, err := g.SetView("main", leftSideWidth+panelSpacing, 0, width-1, optionsTop, gocui.LEFT)
 	if err != nil {
-		if err.Error() != "unknown view" {
+		if err != gocui.ErrUnknownView {
 			return err
 		}
 		v.Title = gui.Tr.SLocalize("DiffTitle")
@@ -326,7 +186,7 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 	}
 
 	if v, err := g.SetView("status", 0, 0, leftSideWidth, statusFilesBoundary, gocui.BOTTOM|gocui.RIGHT); err != nil {
-		if err.Error() != "unknown view" {
+		if err != gocui.ErrUnknownView {
 			return err
 		}
 		v.Title = gui.Tr.SLocalize("StatusTitle")
@@ -335,7 +195,7 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 
 	filesView, err := g.SetView("files", 0, statusFilesBoundary+panelSpacing, leftSideWidth, filesBranchesBoundary, gocui.TOP|gocui.BOTTOM)
 	if err != nil {
-		if err.Error() != "unknown view" {
+		if err != gocui.ErrUnknownView {
 			return err
 		}
 		filesView.Highlight = true
@@ -343,35 +203,32 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		v.FgColor = gocui.ColorWhite
 	}
 
-	branchesView, err := g.SetView("branches", 0, filesBranchesBoundary+panelSpacing, leftSideWidth, commitsBranchesBoundary, gocui.TOP|gocui.BOTTOM)
-	if err != nil {
-		if err.Error() != "unknown view" {
+	if v, err := g.SetView("branches", 0, filesBranchesBoundary+panelSpacing, leftSideWidth, commitsBranchesBoundary, gocui.TOP|gocui.BOTTOM); err != nil {
+		if err != gocui.ErrUnknownView {
 			return err
 		}
-		branchesView.Title = gui.Tr.SLocalize("BranchesTitle")
-		branchesView.FgColor = gocui.ColorWhite
+		v.Title = gui.Tr.SLocalize("BranchesTitle")
+		v.FgColor = gocui.ColorWhite
 	}
 
-	commitsView, err := g.SetView("commits", 0, commitsBranchesBoundary+panelSpacing, leftSideWidth, commitsStashBoundary, gocui.TOP|gocui.BOTTOM)
-	if err != nil {
-		if err.Error() != "unknown view" {
+	if v, err := g.SetView("commits", 0, commitsBranchesBoundary+panelSpacing, leftSideWidth, commitsStashBoundary, gocui.TOP|gocui.BOTTOM); err != nil {
+		if err != gocui.ErrUnknownView {
 			return err
 		}
-		commitsView.Title = gui.Tr.SLocalize("CommitsTitle")
-		commitsView.FgColor = gocui.ColorWhite
+		v.Title = gui.Tr.SLocalize("CommitsTitle")
+		v.FgColor = gocui.ColorWhite
 	}
 
-	stashView, err := g.SetView("stash", 0, commitsStashBoundary+panelSpacing, leftSideWidth, optionsTop, gocui.TOP|gocui.RIGHT)
-	if err != nil {
-		if err.Error() != "unknown view" {
+	if v, err := g.SetView("stash", 0, commitsStashBoundary+panelSpacing, leftSideWidth, optionsTop, gocui.TOP|gocui.RIGHT); err != nil {
+		if err != gocui.ErrUnknownView {
 			return err
 		}
-		stashView.Title = gui.Tr.SLocalize("StashTitle")
-		stashView.FgColor = gocui.ColorWhite
+		v.Title = gui.Tr.SLocalize("StashTitle")
+		v.FgColor = gocui.ColorWhite
 	}
 
-	if v, err := g.SetView("options", appStatusOptionsBoundary-1, optionsTop, optionsVersionBoundary-1, optionsTop+2, 0); err != nil {
-		if err.Error() != "unknown view" {
+	if v, err := g.SetView("options", -1, optionsTop, width-len(version)-2, optionsTop+2, 0); err != nil {
+		if err != gocui.ErrUnknownView {
 			return err
 		}
 		v.Frame = false
@@ -380,167 +237,79 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		}
 	}
 
-	if gui.getCommitMessageView() == nil {
+	if gui.getCommitMessageView(g) == nil {
 		// doesn't matter where this view starts because it will be hidden
-		if commitMessageView, err := g.SetView("commitMessage", 0, 0, width/2, height/2, 0); err != nil {
-			if err.Error() != "unknown view" {
+		if commitMessageView, err := g.SetView("commitMessage", 0, 0, width, height, 0); err != nil {
+			if err != gocui.ErrUnknownView {
 				return err
 			}
 			g.SetViewOnBottom("commitMessage")
 			commitMessageView.Title = gui.Tr.SLocalize("CommitMessage")
 			commitMessageView.FgColor = gocui.ColorWhite
 			commitMessageView.Editable = true
-			commitMessageView.Editor = gocui.EditorFunc(gui.simpleEditor)
 		}
 	}
 
-	if check, _ := g.View("credentials"); check == nil {
-		// doesn't matter where this view starts because it will be hidden
-		if credentialsView, err := g.SetView("credentials", 0, 0, width/2, height/2, 0); err != nil {
-			if err.Error() != "unknown view" {
-				return err
-			}
-			_, err := g.SetViewOnBottom("credentials")
-			if err != nil {
-				return err
-			}
-			credentialsView.Title = gui.Tr.SLocalize("CredentialsUsername")
-			credentialsView.FgColor = gocui.ColorWhite
-			credentialsView.Editable = true
-			credentialsView.Editor = gocui.EditorFunc(gui.simpleEditor)
-		}
-	}
-
-	if appStatusView, err := g.SetView("appStatus", -1, optionsTop, width, optionsTop+2, 0); err != nil {
-		if err.Error() != "unknown view" {
-			return err
-		}
-		appStatusView.BgColor = gocui.ColorDefault
-		appStatusView.FgColor = gocui.ColorCyan
-		appStatusView.Frame = false
-		if _, err := g.SetViewOnBottom("appStatus"); err != nil {
-			return err
-		}
-	}
-
-	if v, err := g.SetView("information", optionsVersionBoundary-1, optionsTop, width, optionsTop+2, 0); err != nil {
-		if err.Error() != "unknown view" {
+	if v, err := g.SetView("version", width-len(version)-1, optionsTop, width, optionsTop+2, 0); err != nil {
+		if err != gocui.ErrUnknownView {
 			return err
 		}
 		v.BgColor = gocui.ColorDefault
 		v.FgColor = gocui.ColorGreen
 		v.Frame = false
-		if err := gui.renderString(g, "information", information); err != nil {
-			return err
-		}
-
-		// these are only called once (it's a place to put all the things you want
-		// to happen on startup after the screen is first rendered)
-		gui.Updater.CheckForNewUpdate(gui.onBackgroundUpdateCheckFinish, false)
-		if err := gui.updateRecentRepoList(); err != nil {
-			return err
-		}
-		gui.waitForIntro.Done()
-
-		if _, err := gui.g.SetCurrentView(filesView.Name()); err != nil {
-			return err
-		}
-
-		if err := gui.refreshSidePanels(gui.g); err != nil {
+		if err := gui.renderString(g, "version", version); err != nil {
 			return err
 		}
 
+		// these are only called once
+		gui.handleFileSelect(g, filesView)
+		gui.refreshFiles(g)
+		gui.refreshBranches(g)
+		gui.refreshCommits(g)
+		gui.refreshStashEntries(g)
 		if err := gui.switchFocus(g, nil, filesView); err != nil {
 			return err
 		}
-
-		if gui.Config.GetUserConfig().GetString("reporting") == "undetermined" {
-			if err := gui.promptAnonymousReporting(); err != nil {
-				return err
-			}
-		}
 	}
 
-	listViews := map[*gocui.View]int{
-		filesView:    gui.State.Panels.Files.SelectedLine,
-		branchesView: gui.State.Panels.Branches.SelectedLine,
-		commitsView:  gui.State.Panels.Commits.SelectedLine,
-		stashView:    gui.State.Panels.Stash.SelectedLine,
-	}
+	gui.resizePopupPanels(g)
 
-	// menu view might not exist so we check to be safe
-	if menuView, err := gui.g.View("menu"); err == nil {
-		listViews[menuView] = gui.State.Panels.Menu.SelectedLine
-	}
-	for view, selectedLine := range listViews {
-		// check if the selected line is now out of view and if so refocus it
-		if err := gui.focusPoint(0, selectedLine, view); err != nil {
-			return err
-		}
-	}
-
-	// here is a good place log some stuff
-	// if you download humanlog and do tail -f development.log | humanlog
-	// this will let you see these branches as prettified json
-	// gui.Log.Info(utils.AsJson(gui.State.Branches[0:4]))
-	return gui.resizeCurrentPopupPanel(g)
+	return nil
 }
 
-func (gui *Gui) promptAnonymousReporting() error {
-	return gui.createConfirmationPanel(gui.g, nil, gui.Tr.SLocalize("AnonymousReportingTitle"), gui.Tr.SLocalize("AnonymousReportingPrompt"), func(g *gocui.Gui, v *gocui.View) error {
-		gui.waitForIntro.Done()
-		return gui.Config.WriteToUserConfig("reporting", "on")
-	}, func(g *gocui.Gui, v *gocui.View) error {
-		gui.waitForIntro.Done()
-		return gui.Config.WriteToUserConfig("reporting", "off")
-	})
-}
-
-func (gui *Gui) fetch(g *gocui.Gui, v *gocui.View, canAskForCredentials bool) (unamePassOpend bool, err error) {
-	unamePassOpend = false
-	err = gui.GitCommand.Fetch(func(passOrUname string) string {
-		unamePassOpend = true
-		return gui.waitForPassUname(gui.g, v, passOrUname)
-	}, canAskForCredentials)
-
-	if canAskForCredentials && err != nil && strings.Contains(err.Error(), "exit status 128") {
-		colorFunction := color.New(color.FgRed).SprintFunc()
-		coloredMessage := colorFunction(strings.TrimSpace(gui.Tr.SLocalize("PassUnameWrong")))
-		close := func(g *gocui.Gui, v *gocui.View) error {
-			return nil
-		}
-		_ = gui.createConfirmationPanel(g, v, gui.Tr.SLocalize("Error"), coloredMessage, close, close)
-	}
-
+func (gui *Gui) fetch(g *gocui.Gui) error {
+	gui.GitCommand.Fetch()
 	gui.refreshStatus(g)
-	return unamePassOpend, err
+	return nil
 }
 
-func (gui *Gui) renderAppStatus() error {
-	appStatus := gui.statusManager.getStatusString()
-	if appStatus != "" {
-		return gui.renderString(gui.g, "appStatus", appStatus)
+func (gui *Gui) updateLoader(g *gocui.Gui) error {
+	if confirmationView, _ := g.View("confirmation"); confirmationView != nil {
+		content := gui.trimmedContent(confirmationView)
+		if strings.Contains(content, "...") {
+			staticContent := strings.Split(content, "...")[0] + "..."
+			gui.renderString(g, "confirmation", staticContent+" "+gui.loader())
+		}
 	}
 	return nil
 }
 
-func (gui *Gui) renderGlobalOptions() error {
-	return gui.renderOptionsMap(map[string]string{
-		"PgUp/PgDn": gui.Tr.SLocalize("scroll"),
-		"← → ↑ ↓":   gui.Tr.SLocalize("navigate"),
-		"esc/q":     gui.Tr.SLocalize("close"),
-		"x":         gui.Tr.SLocalize("menu"),
-	})
-}
-
-func (gui *Gui) goEvery(interval time.Duration, function func() error) {
+func (gui *Gui) goEvery(g *gocui.Gui, interval time.Duration, function func(*gocui.Gui) error) {
 	go func() {
 		for range time.Tick(interval) {
-			_ = function()
+			function(g)
 		}
 	}()
 }
 
+func (gui *Gui) resizePopupPanels(g *gocui.Gui) error {
+	v := g.CurrentView()
+	if v.Name() == "commitMessage" || v.Name() == "confirmation" {
+		return gui.resizePopupPanel(g, v)
+	}
+	return nil
+}
+
 // Run setup the gui with keybindings and start the mainloop
 func (gui *Gui) Run() error {
 	g, err := gocui.NewGui(gocui.OutputNormal, OverlappingEdges)
@@ -549,42 +318,17 @@ func (gui *Gui) Run() error {
 	}
 	defer g.Close()
 
-	if gui.Config.GetUserConfig().GetBool("gui.mouseEvents") {
-		g.Mouse = true
-	}
-
 	gui.g = g // TODO: always use gui.g rather than passing g around everywhere
 
 	if err := gui.SetColorScheme(); err != nil {
 		return err
 	}
 
-	if gui.Config.GetUserConfig().GetString("reporting") == "undetermined" {
-		gui.waitForIntro.Add(2)
-	} else {
-		gui.waitForIntro.Add(1)
-	}
+	gui.goEvery(g, time.Second*60, gui.fetch)
+	gui.goEvery(g, time.Second*10, gui.refreshFiles)
+	gui.goEvery(g, time.Millisecond*10, gui.updateLoader)
 
-	go func() {
-		gui.waitForIntro.Wait()
-		isNew := gui.Config.GetIsNewRepo()
-		if !isNew {
-			time.After(60 * time.Second)
-		}
-		_, err := gui.fetch(g, g.CurrentView(), false)
-		if err != nil && strings.Contains(err.Error(), "exit status 128") && isNew {
-			_ = gui.createConfirmationPanel(g, g.CurrentView(), gui.Tr.SLocalize("NoAutomaticGitFetchTitle"), gui.Tr.SLocalize("NoAutomaticGitFetchBody"), nil, nil)
-		} else {
-			gui.goEvery(time.Second*60, func() error {
-				_, err := gui.fetch(gui.g, gui.g.CurrentView(), false)
-				return err
-			})
-		}
-	}()
-	gui.goEvery(time.Second*10, gui.refreshFiles)
-	gui.goEvery(time.Millisecond*50, gui.renderAppStatus)
-
-	g.SetManager(gocui.ManagerFunc(gui.layout), gocui.ManagerFunc(gui.getFocusLayout()))
+	g.SetManagerFunc(gui.layout)
 
 	if err = gui.keybindings(g); err != nil {
 		return err
@@ -597,13 +341,11 @@ func (gui *Gui) Run() error {
 // RunWithSubprocesses loops, instantiating a new gocui.Gui with each iteration
 // if the error returned from a run is a ErrSubProcess, it runs the subprocess
 // otherwise it handles the error, possibly by quitting the application
-func (gui *Gui) RunWithSubprocesses() error {
+func (gui *Gui) RunWithSubprocesses() {
 	for {
 		if err := gui.Run(); err != nil {
 			if err == gocui.ErrQuit {
 				break
-			} else if err == gui.Errors.ErrSwitchRepo {
-				continue
 			} else if err == gui.Errors.ErrSubProcess {
 				gui.SubProcess.Stdin = os.Stdin
 				gui.SubProcess.Stdout = os.Stdout
@@ -614,33 +356,12 @@ func (gui *Gui) RunWithSubprocesses() error {
 				gui.SubProcess.Stdin = nil
 				gui.SubProcess = nil
 			} else {
-				return err
+				log.Panicln(err)
 			}
 		}
 	}
-	return nil
 }
 
 func (gui *Gui) quit(g *gocui.Gui, v *gocui.View) error {
-	if gui.State.Updating {
-		return gui.createUpdateQuitConfirmation(g, v)
-	}
-	if gui.Config.GetUserConfig().GetBool("confirmOnQuit") {
-		return gui.createConfirmationPanel(g, v, "", gui.Tr.SLocalize("ConfirmQuit"), func(g *gocui.Gui, v *gocui.View) error {
-			return gocui.ErrQuit
-		}, nil)
-	}
 	return gocui.ErrQuit
 }
-
-func (gui *Gui) handleDonate(g *gocui.Gui, v *gocui.View) error {
-	if !gui.g.Mouse {
-		return nil
-	}
-
-	cx, _ := v.Cursor()
-	if cx > len(gui.Tr.SLocalize("Donate")) {
-		return nil
-	}
-	return gui.OSCommand.OpenLink("https://donorbox.org/lazygit")
-}

pkg/gui/keybindings.go

@@ -1,687 +1,95 @@
 package gui
 
-import (
-	"github.com/jesseduffield/gocui"
-)
+import "github.com/jesseduffield/gocui"
 
 // Binding - a keybinding mapping a key and modifier to a handler. The keypress
 // is only handled if the given view has focus, or handled globally if the view
 // is ""
 type Binding struct {
-	ViewName    string
-	Handler     func(*gocui.Gui, *gocui.View) error
-	Key         interface{} // FIXME: find out how to get `gocui.Key | rune`
-	Modifier    gocui.Modifier
-	Description string
-}
-
-// GetDisplayStrings returns the display string of a file
-func (b *Binding) GetDisplayStrings(isFocused bool) []string {
-	return []string{b.GetKey(), b.Description}
-}
-
-// GetKey is a function.
-func (b *Binding) GetKey() string {
-	key := 0
-
-	switch b.Key.(type) {
-	case rune:
-		key = int(b.Key.(rune))
-	case gocui.Key:
-		key = int(b.Key.(gocui.Key))
-	}
-
-	// special keys
-	switch key {
-	case 27:
-		return "esc"
-	case 13:
-		return "enter"
-	case 32:
-		return "space"
-	case 65514:
-		return "►"
-	case 65515:
-		return "◄"
-	case 65517:
-		return "▲"
-	case 65516:
-		return "▼"
-	case 65508:
-		return "PgUp"
-	case 65507:
-		return "PgDn"
-	}
-
-	return string(key)
-}
-
-// GetInitialKeybindings is a function.
-func (gui *Gui) GetInitialKeybindings() []*Binding {
-	bindings := []*Binding{
-		{
-			ViewName: "",
-			Key:      'q',
-			Modifier: gocui.ModNone,
-			Handler:  gui.quit,
-		}, {
-			ViewName: "",
-			Key:      gocui.KeyCtrlC,
-			Modifier: gocui.ModNone,
-			Handler:  gui.quit,
-		}, {
-			ViewName: "",
-			Key:      gocui.KeyEsc,
-			Modifier: gocui.ModNone,
-			Handler:  gui.quit,
-		}, {
-			ViewName: "",
-			Key:      gocui.KeyPgup,
-			Modifier: gocui.ModNone,
-			Handler:  gui.scrollUpMain,
-		}, {
-			ViewName: "",
-			Key:      gocui.KeyPgdn,
-			Modifier: gocui.ModNone,
-			Handler:  gui.scrollDownMain,
-		}, {
-			ViewName: "",
-			Key:      gocui.KeyCtrlU,
-			Modifier: gocui.ModNone,
-			Handler:  gui.scrollUpMain,
-		}, {
-			ViewName: "",
-			Key:      gocui.KeyCtrlD,
-			Modifier: gocui.ModNone,
-			Handler:  gui.scrollDownMain,
-		}, {
-			ViewName:    "",
-			Key:         'm',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCreateRebaseOptionsMenu,
-			Description: gui.Tr.SLocalize("ViewMergeRebaseOptions"),
-		}, {
-			ViewName:    "",
-			Key:         'P',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.pushFiles,
-			Description: gui.Tr.SLocalize("push"),
-		}, {
-			ViewName:    "",
-			Key:         'p',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.pullFiles,
-			Description: gui.Tr.SLocalize("pull"),
-		}, {
-			ViewName:    "",
-			Key:         'R',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleRefresh,
-			Description: gui.Tr.SLocalize("refresh"),
-		}, {
-			ViewName: "",
-			Key:      'x',
-			Modifier: gocui.ModNone,
-			Handler:  gui.handleCreateOptionsMenu,
-		}, {
-			ViewName:    "status",
-			Key:         'e',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleEditConfig,
-			Description: gui.Tr.SLocalize("EditConfig"),
-		}, {
-			ViewName:    "status",
-			Key:         'o',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleOpenConfig,
-			Description: gui.Tr.SLocalize("OpenConfig"),
-		}, {
-			ViewName:    "status",
-			Key:         'u',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCheckForUpdate,
-			Description: gui.Tr.SLocalize("checkForUpdate"),
-		}, {
-			ViewName:    "status",
-			Key:         's',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCreateRecentReposMenu,
-			Description: gui.Tr.SLocalize("SwitchRepo"),
-		},
-		{
-			ViewName:    "files",
-			Key:         'c',
-			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',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitEditorPress,
-			Description: gui.Tr.SLocalize("CommitChangesWithEditor"),
-		}, {
-			ViewName:    "files",
-			Key:         gocui.KeySpace,
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleFilePress,
-			Description: gui.Tr.SLocalize("toggleStaged"),
-		}, {
-			ViewName:    "files",
-			Key:         'd',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleFileRemove,
-			Description: gui.Tr.SLocalize("removeFile"),
-		}, {
-			ViewName:    "files",
-			Key:         'e',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleFileEdit,
-			Description: gui.Tr.SLocalize("editFile"),
-		}, {
-			ViewName:    "files",
-			Key:         'o',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleFileOpen,
-			Description: gui.Tr.SLocalize("openFile"),
-		}, {
-			ViewName:    "files",
-			Key:         'i',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleIgnoreFile,
-			Description: gui.Tr.SLocalize("ignoreFile"),
-		}, {
-			ViewName:    "files",
-			Key:         'r',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleRefreshFiles,
-			Description: gui.Tr.SLocalize("refreshFiles"),
-		}, {
-			ViewName:    "files",
-			Key:         'S',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleStashSave,
-			Description: gui.Tr.SLocalize("stashFiles"),
-		}, {
-			ViewName:    "files",
-			Key:         's',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleSoftReset,
-			Description: gui.Tr.SLocalize("softReset"),
-		}, {
-			ViewName:    "files",
-			Key:         'a',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleStageAll,
-			Description: gui.Tr.SLocalize("toggleStagedAll"),
-		}, {
-			ViewName:    "files",
-			Key:         't',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleAddPatch,
-			Description: gui.Tr.SLocalize("addPatch"),
-		}, {
-			ViewName:    "files",
-			Key:         'D',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleResetAndClean,
-			Description: gui.Tr.SLocalize("resetHard"),
-		}, {
-			ViewName:    "files",
-			Key:         gocui.KeyEnter,
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleEnterFile,
-			Description: gui.Tr.SLocalize("StageLines"),
-		}, {
-			ViewName:    "files",
-			Key:         'f',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleGitFetch,
-			Description: gui.Tr.SLocalize("fetch"),
-		}, {
-			ViewName:    "branches",
-			Key:         gocui.KeySpace,
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleBranchPress,
-			Description: gui.Tr.SLocalize("checkout"),
-		}, {
-			ViewName:    "branches",
-			Key:         'o',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCreatePullRequestPress,
-			Description: gui.Tr.SLocalize("createPullRequest"),
-		}, {
-			ViewName:    "branches",
-			Key:         'c',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCheckoutByName,
-			Description: gui.Tr.SLocalize("checkoutByName"),
-		}, {
-			ViewName:    "branches",
-			Key:         'F',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleForceCheckout,
-			Description: gui.Tr.SLocalize("forceCheckout"),
-		}, {
-			ViewName:    "branches",
-			Key:         'n',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleNewBranch,
-			Description: gui.Tr.SLocalize("newBranch"),
-		}, {
-			ViewName:    "branches",
-			Key:         'd',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleDeleteBranch,
-			Description: gui.Tr.SLocalize("deleteBranch"),
-		}, {
-			ViewName:    "branches",
-			Key:         'r',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleRebase,
-			Description: gui.Tr.SLocalize("rebaseBranch"),
-		}, {
-			ViewName:    "branches",
-			Key:         'M',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleMerge,
-			Description: gui.Tr.SLocalize("mergeIntoCurrentBranch"),
-		}, {
-			ViewName:    "branches",
-			Key:         'f',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleFastForward,
-			Description: gui.Tr.SLocalize("FastForward"),
-		}, {
-			ViewName:    "commits",
-			Key:         's',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitSquashDown,
-			Description: gui.Tr.SLocalize("squashDown"),
-		}, {
-			ViewName:    "commits",
-			Key:         'r',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleRenameCommit,
-			Description: gui.Tr.SLocalize("renameCommit"),
-		}, {
-			ViewName:    "commits",
-			Key:         'R',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleRenameCommitEditor,
-			Description: gui.Tr.SLocalize("renameCommitEditor"),
-		}, {
-			ViewName:    "commits",
-			Key:         'g',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleResetToCommit,
-			Description: gui.Tr.SLocalize("resetToThisCommit"),
-		}, {
-			ViewName:    "commits",
-			Key:         'f',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitFixup,
-			Description: gui.Tr.SLocalize("fixupCommit"),
-		}, {
-			ViewName:    "commits",
-			Key:         'd',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitDelete,
-			Description: gui.Tr.SLocalize("deleteCommit"),
-		}, {
-			ViewName:    "commits",
-			Key:         'J',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitMoveDown,
-			Description: gui.Tr.SLocalize("moveDownCommit"),
-		}, {
-			ViewName:    "commits",
-			Key:         'K',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitMoveUp,
-			Description: gui.Tr.SLocalize("moveUpCommit"),
-		}, {
-			ViewName:    "commits",
-			Key:         'e',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitEdit,
-			Description: gui.Tr.SLocalize("editCommit"),
-		}, {
-			ViewName:    "commits",
-			Key:         'A',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitAmendTo,
-			Description: gui.Tr.SLocalize("amendToCommit"),
-		}, {
-			ViewName:    "commits",
-			Key:         'p',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitPick,
-			Description: gui.Tr.SLocalize("pickCommit"),
-		}, {
-			ViewName:    "commits",
-			Key:         't',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitRevert,
-			Description: gui.Tr.SLocalize("revertCommit"),
-		}, {
-			ViewName:    "commits",
-			Key:         'c',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCopyCommit,
-			Description: gui.Tr.SLocalize("cherryPickCopy"),
-		}, {
-			ViewName:    "commits",
-			Key:         'C',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCopyCommitRange,
-			Description: gui.Tr.SLocalize("cherryPickCopyRange"),
-		}, {
-			ViewName:    "commits",
-			Key:         'v',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.HandlePasteCommits,
-			Description: gui.Tr.SLocalize("pasteCommits"),
-		}, {
-			ViewName:    "stash",
-			Key:         gocui.KeySpace,
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleStashApply,
-			Description: gui.Tr.SLocalize("apply"),
-		}, {
-			ViewName:    "stash",
-			Key:         'g',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleStashPop,
-			Description: gui.Tr.SLocalize("pop"),
-		}, {
-			ViewName:    "stash",
-			Key:         'd',
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleStashDrop,
-			Description: gui.Tr.SLocalize("drop"),
-		}, {
-			ViewName: "commitMessage",
-			Key:      gocui.KeyEnter,
-			Modifier: gocui.ModNone,
-			Handler:  gui.handleCommitConfirm,
-		}, {
-			ViewName: "commitMessage",
-			Key:      gocui.KeyEsc,
-			Modifier: gocui.ModNone,
-			Handler:  gui.handleCommitClose,
-		}, {
-			ViewName: "credentials",
-			Key:      gocui.KeyEnter,
-			Modifier: gocui.ModNone,
-			Handler:  gui.handleSubmitCredential,
-		}, {
-			ViewName: "credentials",
-			Key:      gocui.KeyEsc,
-			Modifier: gocui.ModNone,
-			Handler:  gui.handleCloseCredentialsView,
-		}, {
-			ViewName: "menu",
-			Key:      gocui.KeyEsc,
-			Modifier: gocui.ModNone,
-			Handler:  gui.handleMenuClose,
-		}, {
-			ViewName: "menu",
-			Key:      'q',
-			Modifier: gocui.ModNone,
-			Handler:  gui.handleMenuClose,
-		}, {
-			ViewName: "information",
-			Key:      gocui.MouseLeft,
-			Modifier: gocui.ModNone,
-			Handler:  gui.handleDonate,
-		},
-	}
-
-	for _, viewName := range []string{"status", "branches", "files", "commits", "stash", "menu"} {
-		bindings = append(bindings, []*Binding{
-			{ViewName: viewName, Key: gocui.KeyTab, Modifier: gocui.ModNone, Handler: gui.nextView},
-			{ViewName: viewName, Key: gocui.KeyArrowLeft, Modifier: gocui.ModNone, Handler: gui.previousView},
-			{ViewName: viewName, Key: gocui.KeyArrowRight, Modifier: gocui.ModNone, Handler: gui.nextView},
-			{ViewName: viewName, Key: 'h', Modifier: gocui.ModNone, Handler: gui.previousView},
-			{ViewName: viewName, Key: 'l', Modifier: gocui.ModNone, Handler: gui.nextView},
-		}...)
-	}
-
-	listPanelMap := map[string]struct {
-		prevLine func(*gocui.Gui, *gocui.View) error
-		nextLine func(*gocui.Gui, *gocui.View) error
-		focus    func(*gocui.Gui, *gocui.View) error
-	}{
-		"menu":     {prevLine: gui.handleMenuPrevLine, nextLine: gui.handleMenuNextLine, focus: gui.handleMenuSelect},
-		"files":    {prevLine: gui.handleFilesPrevLine, nextLine: gui.handleFilesNextLine, focus: gui.handleFilesFocus},
-		"branches": {prevLine: gui.handleBranchesPrevLine, nextLine: gui.handleBranchesNextLine, focus: gui.handleBranchSelect},
-		"commits":  {prevLine: gui.handleCommitsPrevLine, nextLine: gui.handleCommitsNextLine, focus: gui.handleCommitSelect},
-		"stash":    {prevLine: gui.handleStashPrevLine, nextLine: gui.handleStashNextLine, focus: gui.handleStashEntrySelect},
-		"status":   {focus: gui.handleStatusSelect},
-	}
-
-	for viewName, functions := range listPanelMap {
-		bindings = append(bindings, []*Binding{
-			{ViewName: viewName, Key: 'k', Modifier: gocui.ModNone, Handler: functions.prevLine},
-			{ViewName: viewName, Key: gocui.KeyArrowUp, Modifier: gocui.ModNone, Handler: functions.prevLine},
-			{ViewName: viewName, Key: gocui.MouseWheelUp, Modifier: gocui.ModNone, Handler: functions.prevLine},
-			{ViewName: viewName, Key: 'j', Modifier: gocui.ModNone, Handler: functions.nextLine},
-			{ViewName: viewName, Key: gocui.KeyArrowDown, Modifier: gocui.ModNone, Handler: functions.nextLine},
-			{ViewName: viewName, Key: gocui.MouseWheelDown, Modifier: gocui.ModNone, Handler: functions.nextLine},
-			{ViewName: viewName, Key: gocui.MouseLeft, Modifier: gocui.ModNone, Handler: functions.focus},
-		}...)
-	}
-
-	return bindings
-}
-
-// GetCurrentKeybindings gets the list of keybindings given the current context
-func (gui *Gui) GetCurrentKeybindings() []*Binding {
-	bindings := gui.GetInitialKeybindings()
-	viewName := gui.currentViewName()
-	currentContext := gui.State.Contexts[viewName]
-	contextBindings := gui.GetContextMap()[viewName][currentContext]
-
-	return append(bindings, contextBindings...)
+	ViewName string
+	Handler  func(*gocui.Gui, *gocui.View) error
+	Key      interface{} // FIXME: find out how to get `gocui.Key | rune`
+	Modifier gocui.Modifier
 }
 
 func (gui *Gui) keybindings(g *gocui.Gui) error {
-	bindings := gui.GetInitialKeybindings()
+	bindings := []Binding{
+		{ViewName: "", Key: 'q', Modifier: gocui.ModNone, Handler: gui.quit},
+		{ViewName: "", Key: gocui.KeyCtrlC, Modifier: gocui.ModNone, Handler: gui.quit},
+		{ViewName: "", Key: gocui.KeyPgup, Modifier: gocui.ModNone, Handler: gui.scrollUpMain},
+		{ViewName: "", Key: gocui.KeyPgdn, Modifier: gocui.ModNone, Handler: gui.scrollDownMain},
+		{ViewName: "", Key: gocui.KeyCtrlU, Modifier: gocui.ModNone, Handler: gui.scrollUpMain},
+		{ViewName: "", Key: gocui.KeyCtrlD, Modifier: gocui.ModNone, Handler: gui.scrollDownMain},
+		{ViewName: "", Key: 'P', Modifier: gocui.ModNone, Handler: gui.pushFiles},
+		{ViewName: "", Key: 'p', Modifier: gocui.ModNone, Handler: gui.pullFiles},
+		{ViewName: "", Key: 'R', Modifier: gocui.ModNone, Handler: gui.handleRefresh},
+		{ViewName: "status", Key: 'e', Modifier: gocui.ModNone, Handler: gui.handleEditConfig},
+		{ViewName: "status", Key: 'o', Modifier: gocui.ModNone, Handler: gui.handleOpenConfig},
+		{ViewName: "files", Key: 'c', Modifier: gocui.ModNone, Handler: gui.handleCommitPress},
+		{ViewName: "files", Key: 'C', Modifier: gocui.ModNone, Handler: gui.handleCommitEditorPress},
+		{ViewName: "files", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: gui.handleFilePress},
+		{ViewName: "files", Key: 'd', Modifier: gocui.ModNone, Handler: gui.handleFileRemove},
+		{ViewName: "files", Key: 'm', Modifier: gocui.ModNone, Handler: gui.handleSwitchToMerge},
+		{ViewName: "files", Key: 'e', Modifier: gocui.ModNone, Handler: gui.handleFileEdit},
+		{ViewName: "files", Key: 'o', Modifier: gocui.ModNone, Handler: gui.handleFileOpen},
+		{ViewName: "files", Key: 's', Modifier: gocui.ModNone, Handler: gui.handleSublimeFileOpen},
+		{ViewName: "files", Key: 'v', Modifier: gocui.ModNone, Handler: gui.handleVsCodeFileOpen},
+		{ViewName: "files", Key: 'i', Modifier: gocui.ModNone, Handler: gui.handleIgnoreFile},
+		{ViewName: "files", Key: 'r', Modifier: gocui.ModNone, Handler: gui.handleRefreshFiles},
+		{ViewName: "files", Key: 'S', Modifier: gocui.ModNone, Handler: gui.handleStashSave},
+		{ViewName: "files", Key: 'a', Modifier: gocui.ModNone, Handler: gui.handleAbortMerge},
+		{ViewName: "files", Key: 't', Modifier: gocui.ModNone, Handler: gui.handleAddPatch},
+		{ViewName: "files", Key: 'D', Modifier: gocui.ModNone, Handler: gui.handleResetHard},
+		{ViewName: "main", Key: gocui.KeyEsc, Modifier: gocui.ModNone, Handler: gui.handleEscapeMerge},
+		{ViewName: "main", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: gui.handlePickHunk},
+		{ViewName: "main", Key: 'b', Modifier: gocui.ModNone, Handler: gui.handlePickBothHunks},
+		{ViewName: "main", Key: gocui.KeyArrowLeft, Modifier: gocui.ModNone, Handler: gui.handleSelectPrevConflict},
+		{ViewName: "main", Key: gocui.KeyArrowRight, Modifier: gocui.ModNone, Handler: gui.handleSelectNextConflict},
+		{ViewName: "main", Key: gocui.KeyArrowUp, Modifier: gocui.ModNone, Handler: gui.handleSelectTop},
+		{ViewName: "main", Key: gocui.KeyArrowDown, Modifier: gocui.ModNone, Handler: gui.handleSelectBottom},
+		{ViewName: "main", Key: 'h', Modifier: gocui.ModNone, Handler: gui.handleSelectPrevConflict},
+		{ViewName: "main", Key: 'l', Modifier: gocui.ModNone, Handler: gui.handleSelectNextConflict},
+		{ViewName: "main", Key: 'k', Modifier: gocui.ModNone, Handler: gui.handleSelectTop},
+		{ViewName: "main", Key: 'j', Modifier: gocui.ModNone, Handler: gui.handleSelectBottom},
+		{ViewName: "main", Key: 'z', Modifier: gocui.ModNone, Handler: gui.handlePopFileSnapshot},
+		{ViewName: "branches", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: gui.handleBranchPress},
+		{ViewName: "branches", Key: 'c', Modifier: gocui.ModNone, Handler: gui.handleCheckoutByName},
+		{ViewName: "branches", Key: 'F', Modifier: gocui.ModNone, Handler: gui.handleForceCheckout},
+		{ViewName: "branches", Key: 'n', Modifier: gocui.ModNone, Handler: gui.handleNewBranch},
+		{ViewName: "branches", Key: 'd', Modifier: gocui.ModNone, Handler: gui.handleDeleteBranch},
+		{ViewName: "branches", Key: 'm', Modifier: gocui.ModNone, Handler: gui.handleMerge},
+		{ViewName: "commits", Key: 's', Modifier: gocui.ModNone, Handler: gui.handleCommitSquashDown},
+		{ViewName: "commits", Key: 'r', Modifier: gocui.ModNone, Handler: gui.handleRenameCommit},
+		{ViewName: "commits", Key: 'g', Modifier: gocui.ModNone, Handler: gui.handleResetToCommit},
+		{ViewName: "commits", Key: 'f', Modifier: gocui.ModNone, Handler: gui.handleCommitFixup},
+		{ViewName: "stash", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: gui.handleStashApply},
+		{ViewName: "stash", Key: 'g', Modifier: gocui.ModNone, Handler: gui.handleStashPop},
+		{ViewName: "stash", Key: 'd', Modifier: gocui.ModNone, Handler: gui.handleStashDrop},
+		{ViewName: "commitMessage", Key: gocui.KeyEnter, Modifier: gocui.ModNone, Handler: gui.handleCommitConfirm},
+		{ViewName: "commitMessage", Key: gocui.KeyEsc, Modifier: gocui.ModNone, Handler: gui.handleCommitClose},
+		{ViewName: "commitMessage", Key: gocui.KeyTab, Modifier: gocui.ModNone, Handler: gui.handleNewlineCommitMessage},
+	}
+
+	// Would make these keybindings global but that interferes with editing
+	// input in the confirmation panel
+	for _, viewName := range []string{"status", "files", "branches", "commits", "stash"} {
+		bindings = append(bindings, []Binding{
+			{ViewName: viewName, Key: gocui.KeyTab, Modifier: gocui.ModNone, Handler: gui.nextView},
+			{ViewName: viewName, Key: gocui.KeyArrowLeft, Modifier: gocui.ModNone, Handler: gui.previousView},
+			{ViewName: viewName, Key: gocui.KeyArrowRight, Modifier: gocui.ModNone, Handler: gui.nextView},
+			{ViewName: viewName, Key: gocui.KeyArrowUp, Modifier: gocui.ModNone, Handler: gui.cursorUp},
+			{ViewName: viewName, Key: gocui.KeyArrowDown, Modifier: gocui.ModNone, Handler: gui.cursorDown},
+			{ViewName: viewName, Key: 'h', Modifier: gocui.ModNone, Handler: gui.previousView},
+			{ViewName: viewName, Key: 'l', Modifier: gocui.ModNone, Handler: gui.nextView},
+			{ViewName: viewName, Key: 'k', Modifier: gocui.ModNone, Handler: gui.cursorUp},
+			{ViewName: viewName, Key: 'j', Modifier: gocui.ModNone, Handler: gui.cursorDown},
+		}...)
+	}
 
 	for _, binding := range bindings {
 		if err := g.SetKeybinding(binding.ViewName, binding.Key, binding.Modifier, binding.Handler); err != nil {
 			return err
 		}
 	}
-	if err := gui.setInitialContexts(); err != nil {
-		return err
-	}
 	return nil
 }
-
-func (gui *Gui) GetContextMap() map[string]map[string][]*Binding {
-	return map[string]map[string][]*Binding{
-		"main": {
-			"normal": {
-				{
-					ViewName:    "main",
-					Key:         gocui.MouseWheelDown,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.scrollDownMain,
-					Description: gui.Tr.SLocalize("ScrollDown"),
-				}, {
-					ViewName:    "main",
-					Key:         gocui.MouseWheelUp,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.scrollUpMain,
-					Description: gui.Tr.SLocalize("ScrollUp"),
-				},
-			},
-			"staging": {
-				{
-					ViewName:    "main",
-					Key:         gocui.KeyEsc,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handleStagingEscape,
-					Description: gui.Tr.SLocalize("EscapeStaging"),
-				}, {
-					ViewName:    "main",
-					Key:         gocui.KeyArrowUp,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handleStagingPrevLine,
-					Description: gui.Tr.SLocalize("PrevLine"),
-				}, {
-					ViewName:    "main",
-					Key:         gocui.KeyArrowDown,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handleStagingNextLine,
-					Description: gui.Tr.SLocalize("NextLine"),
-				}, {
-					ViewName: "main",
-					Key:      'k',
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleStagingPrevLine,
-				}, {
-					ViewName: "main",
-					Key:      'j',
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleStagingNextLine,
-				}, {
-					ViewName: "main",
-					Key:      gocui.MouseWheelUp,
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleStagingPrevLine,
-				}, {
-					ViewName: "main",
-					Key:      gocui.MouseWheelDown,
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleStagingNextLine,
-				}, {
-					ViewName:    "main",
-					Key:         gocui.KeyArrowLeft,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handleStagingPrevHunk,
-					Description: gui.Tr.SLocalize("PrevHunk"),
-				}, {
-					ViewName:    "main",
-					Key:         gocui.KeyArrowRight,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handleStagingNextHunk,
-					Description: gui.Tr.SLocalize("NextHunk"),
-				}, {
-					ViewName: "main",
-					Key:      'h',
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleStagingPrevHunk,
-				}, {
-					ViewName: "main",
-					Key:      'l',
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleStagingNextHunk,
-				}, {
-					ViewName:    "main",
-					Key:         gocui.KeySpace,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handleStageLine,
-					Description: gui.Tr.SLocalize("StageLine"),
-				}, {
-					ViewName:    "main",
-					Key:         'a',
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handleStageHunk,
-					Description: gui.Tr.SLocalize("StageHunk"),
-				},
-			},
-			"merging": {
-				{
-					ViewName:    "main",
-					Key:         gocui.KeyEsc,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handleEscapeMerge,
-					Description: gui.Tr.SLocalize("EscapeStaging"),
-				}, {
-					ViewName:    "main",
-					Key:         gocui.KeySpace,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handlePickHunk,
-					Description: gui.Tr.SLocalize("PickHunk"),
-				}, {
-					ViewName:    "main",
-					Key:         'b',
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handlePickBothHunks,
-					Description: gui.Tr.SLocalize("PickBothHunks"),
-				}, {
-					ViewName:    "main",
-					Key:         gocui.KeyArrowLeft,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handleSelectPrevConflict,
-					Description: gui.Tr.SLocalize("PrevConflict"),
-				}, {
-					ViewName: "main",
-					Key:      gocui.KeyArrowRight,
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleSelectNextConflict,
-
-					Description: gui.Tr.SLocalize("NextConflict"),
-				}, {
-					ViewName: "main",
-					Key:      gocui.KeyArrowUp,
-
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handleSelectTop,
-					Description: gui.Tr.SLocalize("SelectTop"),
-				}, {
-					ViewName:    "main",
-					Key:         gocui.KeyArrowDown,
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handleSelectBottom,
-					Description: gui.Tr.SLocalize("SelectBottom"),
-				}, {
-					ViewName: "main",
-					Key:      gocui.MouseWheelUp,
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleSelectTop,
-				}, {
-					ViewName: "main",
-					Key:      gocui.MouseWheelDown,
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleSelectBottom,
-				}, {
-					ViewName: "main",
-					Key:      'h',
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleSelectPrevConflict,
-				}, {
-					ViewName: "main",
-					Key:      'l',
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleSelectNextConflict,
-				}, {
-					ViewName: "main",
-					Key:      'k',
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleSelectTop,
-				}, {
-					ViewName: "main",
-					Key:      'j',
-					Modifier: gocui.ModNone,
-					Handler:  gui.handleSelectBottom,
-				}, {
-					ViewName:    "main",
-					Key:         'z',
-					Modifier:    gocui.ModNone,
-					Handler:     gui.handlePopFileSnapshot,
-					Description: gui.Tr.SLocalize("Undo"),
-				},
-			},
-		},
-	}
-}

pkg/gui/menu_panel.go

@@ -1,99 +0,0 @@
-package gui
-
-import (
-	"fmt"
-
-	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// list panel functions
-
-func (gui *Gui) handleMenuSelect(g *gocui.Gui, v *gocui.View) error {
-	return gui.focusPoint(0, gui.State.Panels.Menu.SelectedLine, v)
-}
-
-func (gui *Gui) handleMenuNextLine(g *gocui.Gui, v *gocui.View) error {
-	panelState := gui.State.Panels.Menu
-	gui.changeSelectedLine(&panelState.SelectedLine, v.LinesHeight(), false)
-
-	return gui.handleMenuSelect(g, v)
-}
-
-func (gui *Gui) handleMenuPrevLine(g *gocui.Gui, v *gocui.View) error {
-	panelState := gui.State.Panels.Menu
-	gui.changeSelectedLine(&panelState.SelectedLine, v.LinesHeight(), true)
-
-	return gui.handleMenuSelect(g, v)
-}
-
-// specific functions
-
-func (gui *Gui) renderMenuOptions() error {
-	optionsMap := map[string]string{
-		"esc/q": gui.Tr.SLocalize("close"),
-		"↑ ↓":   gui.Tr.SLocalize("navigate"),
-		"space": gui.Tr.SLocalize("execute"),
-	}
-	return gui.renderOptionsMap(optionsMap)
-}
-
-func (gui *Gui) handleMenuClose(g *gocui.Gui, v *gocui.View) error {
-	for _, key := range []gocui.Key{gocui.KeySpace, gocui.KeyEnter} {
-		if err := g.DeleteKeybinding("menu", key, gocui.ModNone); err != nil {
-			return err
-		}
-	}
-	err := g.DeleteView("menu")
-	if err != nil {
-		return err
-	}
-	return gui.returnFocus(g, v)
-}
-
-func (gui *Gui) createMenu(title string, items interface{}, handlePress func(int) error) error {
-	isFocused := gui.g.CurrentView().Name() == "menu"
-	list, err := utils.RenderList(items, isFocused)
-	if err != nil {
-		return err
-	}
-
-	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(gui.g, false, list)
-	menuView, _ := gui.g.SetView("menu", x0, y0, x1, y1, 0)
-	menuView.Title = title
-	menuView.FgColor = gocui.ColorWhite
-	menuView.Clear()
-	fmt.Fprint(menuView, list)
-	gui.State.Panels.Menu.SelectedLine = 0
-
-	wrappedHandlePress := func(g *gocui.Gui, v *gocui.View) error {
-		selectedLine := gui.State.Panels.Menu.SelectedLine
-		if err := handlePress(selectedLine); err != nil {
-			return err
-		}
-		if _, err := gui.g.View("menu"); err == nil {
-			if _, err := gui.g.SetViewOnBottom("menu"); err != nil {
-				return err
-			}
-		}
-
-		return gui.returnFocus(gui.g, menuView)
-	}
-
-	for _, key := range []gocui.Key{gocui.KeySpace, gocui.KeyEnter} {
-		if err := gui.g.SetKeybinding("menu", key, gocui.ModNone, wrappedHandlePress); err != nil {
-			return err
-		}
-	}
-
-	gui.g.Update(func(g *gocui.Gui) error {
-		if _, err := gui.g.View("menu"); err == nil {
-			if _, err := g.SetViewOnTop("menu"); err != nil {
-				return err
-			}
-		}
-		currentView := gui.g.CurrentView()
-		return gui.switchFocus(gui.g, currentView, menuView)
-	})
-	return nil
-}

pkg/gui/merge_panel.go

@@ -11,7 +11,6 @@ import (
 	"strings"
 
 	"github.com/fatih/color"
-	"github.com/golang-collections/collections/stack"
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
 	"github.com/jesseduffield/lazygit/pkg/utils"
@@ -21,13 +20,11 @@ func (gui *Gui) findConflicts(content string) ([]commands.Conflict, error) {
 	conflicts := make([]commands.Conflict, 0)
 	var newConflict commands.Conflict
 	for i, line := range utils.SplitLines(content) {
-		trimmedLine := strings.TrimPrefix(line, "++")
-		gui.Log.Info(trimmedLine)
-		if trimmedLine == "<<<<<<< HEAD" || trimmedLine == "<<<<<<< MERGE_HEAD" || trimmedLine == "<<<<<<< Updated upstream" {
+		if line == "<<<<<<< HEAD" || line == "<<<<<<< MERGE_HEAD" || line == "<<<<<<< Updated upstream" {
 			newConflict = commands.Conflict{Start: i}
-		} else if trimmedLine == "=======" {
+		} else if line == "=======" {
 			newConflict.Middle = i
-		} else if strings.HasPrefix(trimmedLine, ">>>>>>> ") {
+		} else if strings.HasPrefix(line, ">>>>>>> ") {
 			newConflict.End = i
 			conflicts = append(conflicts, newConflict)
 		}
@@ -67,29 +64,29 @@ func (gui *Gui) coloredConflictFile(content string, conflicts []commands.Conflic
 }
 
 func (gui *Gui) handleSelectTop(g *gocui.Gui, v *gocui.View) error {
-	gui.State.Panels.Merging.ConflictTop = true
-	return gui.refreshMergePanel()
+	gui.State.ConflictTop = true
+	return gui.refreshMergePanel(g)
 }
 
 func (gui *Gui) handleSelectBottom(g *gocui.Gui, v *gocui.View) error {
-	gui.State.Panels.Merging.ConflictTop = false
-	return gui.refreshMergePanel()
+	gui.State.ConflictTop = false
+	return gui.refreshMergePanel(g)
 }
 
 func (gui *Gui) handleSelectNextConflict(g *gocui.Gui, v *gocui.View) error {
-	if gui.State.Panels.Merging.ConflictIndex >= len(gui.State.Panels.Merging.Conflicts)-1 {
+	if gui.State.ConflictIndex >= len(gui.State.Conflicts)-1 {
 		return nil
 	}
-	gui.State.Panels.Merging.ConflictIndex++
-	return gui.refreshMergePanel()
+	gui.State.ConflictIndex++
+	return gui.refreshMergePanel(g)
 }
 
 func (gui *Gui) handleSelectPrevConflict(g *gocui.Gui, v *gocui.View) error {
-	if gui.State.Panels.Merging.ConflictIndex <= 0 {
+	if gui.State.ConflictIndex <= 0 {
 		return nil
 	}
-	gui.State.Panels.Merging.ConflictIndex--
-	return gui.refreshMergePanel()
+	gui.State.ConflictIndex--
+	return gui.refreshMergePanel(g)
 }
 
 func (gui *Gui) isIndexToDelete(i int, conflict commands.Conflict, pick string) bool {
@@ -136,112 +133,105 @@ func (gui *Gui) pushFileSnapshot(g *gocui.Gui) error {
 	if err != nil {
 		return err
 	}
-	gui.State.Panels.Merging.EditHistory.Push(content)
+	gui.State.EditHistory.Push(content)
 	return nil
 }
 
 func (gui *Gui) handlePopFileSnapshot(g *gocui.Gui, v *gocui.View) error {
-	if gui.State.Panels.Merging.EditHistory.Len() == 0 {
+	if gui.State.EditHistory.Len() == 0 {
 		return nil
 	}
-	prevContent := gui.State.Panels.Merging.EditHistory.Pop().(string)
+	prevContent := gui.State.EditHistory.Pop().(string)
 	gitFile, err := gui.getSelectedFile(g)
 	if err != nil {
 		return err
 	}
 	ioutil.WriteFile(gitFile.Name, []byte(prevContent), 0644)
-	return gui.refreshMergePanel()
+	return gui.refreshMergePanel(g)
 }
 
 func (gui *Gui) handlePickHunk(g *gocui.Gui, v *gocui.View) error {
-	conflict := gui.State.Panels.Merging.Conflicts[gui.State.Panels.Merging.ConflictIndex]
+	conflict := gui.State.Conflicts[gui.State.ConflictIndex]
 	gui.pushFileSnapshot(g)
 	pick := "bottom"
-	if gui.State.Panels.Merging.ConflictTop {
+	if gui.State.ConflictTop {
 		pick = "top"
 	}
 	err := gui.resolveConflict(g, conflict, pick)
 	if err != nil {
 		panic(err)
 	}
-
-	// if that was the last conflict, finish the merge for this file
-	if len(gui.State.Panels.Merging.Conflicts) == 1 {
-		if err := gui.handleCompleteMerge(); err != nil {
-			return err
-		}
-	}
-	return gui.refreshMergePanel()
+	gui.refreshMergePanel(g)
+	return nil
 }
 
 func (gui *Gui) handlePickBothHunks(g *gocui.Gui, v *gocui.View) error {
-	conflict := gui.State.Panels.Merging.Conflicts[gui.State.Panels.Merging.ConflictIndex]
+	conflict := gui.State.Conflicts[gui.State.ConflictIndex]
 	gui.pushFileSnapshot(g)
 	err := gui.resolveConflict(g, conflict, "both")
 	if err != nil {
 		panic(err)
 	}
-	return gui.refreshMergePanel()
+	return gui.refreshMergePanel(g)
 }
 
-func (gui *Gui) refreshMergePanel() error {
-	panelState := gui.State.Panels.Merging
-	cat, err := gui.catSelectedFile(gui.g)
+func (gui *Gui) refreshMergePanel(g *gocui.Gui) error {
+	cat, err := gui.catSelectedFile(g)
 	if err != nil {
 		return err
 	}
-	if cat == "" {
-		return nil
-	}
-	panelState.Conflicts, err = gui.findConflicts(cat)
+	gui.State.Conflicts, err = gui.findConflicts(cat)
 	if err != nil {
 		return err
 	}
 
-	// handle potential fixes that the user made in their editor since we last refreshed
-	if len(panelState.Conflicts) == 0 {
-		return gui.handleCompleteMerge()
-	} else if panelState.ConflictIndex > len(panelState.Conflicts)-1 {
-		panelState.ConflictIndex = len(panelState.Conflicts) - 1
+	if len(gui.State.Conflicts) == 0 {
+		return gui.handleCompleteMerge(g)
+	} else if gui.State.ConflictIndex > len(gui.State.Conflicts)-1 {
+		gui.State.ConflictIndex = len(gui.State.Conflicts) - 1
 	}
-
-	hasFocus := gui.currentViewName() == "main"
-	content, err := gui.coloredConflictFile(cat, panelState.Conflicts, panelState.ConflictIndex, panelState.ConflictTop, hasFocus)
+	hasFocus := gui.currentViewName(g) == "main"
+	if hasFocus {
+		gui.renderMergeOptions(g)
+	}
+	content, err := gui.coloredConflictFile(cat, gui.State.Conflicts, gui.State.ConflictIndex, gui.State.ConflictTop, hasFocus)
 	if err != nil {
 		return err
 	}
-	if err := gui.renderString(gui.g, "main", content); err != nil {
+	if err := gui.scrollToConflict(g); err != nil {
 		return err
 	}
-	if err := gui.scrollToConflict(gui.g); err != nil {
-		return err
-	}
-
-	mainView := gui.getMainView()
-	mainView.Wrap = false
-
-	return nil
+	return gui.renderString(g, "main", content)
 }
 
 func (gui *Gui) scrollToConflict(g *gocui.Gui) error {
-	panelState := gui.State.Panels.Merging
-	if len(panelState.Conflicts) == 0 {
+	mainView, err := g.View("main")
+	if err != nil {
+		return err
+	}
+	if len(gui.State.Conflicts) == 0 {
 		return nil
 	}
-	mergingView := gui.getMainView()
-	conflict := panelState.Conflicts[panelState.ConflictIndex]
-	ox, _ := mergingView.Origin()
-	_, height := mergingView.Size()
+	conflict := gui.State.Conflicts[gui.State.ConflictIndex]
+	ox, _ := mainView.Origin()
+	_, height := mainView.Size()
 	conflictMiddle := (conflict.End + conflict.Start) / 2
 	newOriginY := int(math.Max(0, float64(conflictMiddle-(height/2))))
-	gui.g.Update(func(g *gocui.Gui) error {
-		return mergingView.SetOrigin(ox, newOriginY)
-	})
-	return nil
+	return mainView.SetOrigin(ox, newOriginY)
 }
 
-func (gui *Gui) renderMergeOptions() error {
-	return gui.renderOptionsMap(map[string]string{
+func (gui *Gui) switchToMerging(g *gocui.Gui) error {
+	gui.State.ConflictIndex = 0
+	gui.State.ConflictTop = true
+	_, err := g.SetCurrentView("main")
+	if err != nil {
+		return err
+	}
+	return gui.refreshMergePanel(g)
+}
+
+func (gui *Gui) renderMergeOptions(g *gocui.Gui) error {
+	return gui.renderOptionsMap(g, map[string]string{
 		"↑ ↓":   gui.Tr.SLocalize("selectHunk"),
 		"← →":   gui.Tr.SLocalize("navigateConflicts"),
 		"space": gui.Tr.SLocalize("pickHunk"),
@@ -251,40 +241,20 @@ func (gui *Gui) renderMergeOptions() error {
 }
 
 func (gui *Gui) handleEscapeMerge(g *gocui.Gui, v *gocui.View) error {
-	gui.State.Panels.Merging.EditHistory = stack.New()
-	if err := gui.refreshFiles(); err != nil {
+	filesView, err := g.View("files")
+	if err != nil {
 		return err
 	}
-	// it's possible this method won't be called from the merging view so we need to
-	// ensure we only 'return' focus if we already have it
-	if gui.g.CurrentView() == gui.getMainView() {
-		return gui.switchFocus(g, v, gui.getFilesView())
-	}
-	return nil
+	gui.refreshFiles(g)
+	return gui.switchFocus(g, v, filesView)
 }
 
-func (gui *Gui) handleCompleteMerge() error {
-	if err := gui.stageSelectedFile(gui.g); err != nil {
+func (gui *Gui) handleCompleteMerge(g *gocui.Gui) error {
+	filesView, err := g.View("files")
+	if err != nil {
 		return err
 	}
-	if err := gui.refreshFiles(); err != nil {
-		return err
-	}
-	// if we got conflicts after unstashing, we don't want to call any git
-	// commands to continue rebasing/merging here
-	if gui.State.WorkingTreeState == "normal" {
-		return gui.handleEscapeMerge(gui.g, gui.getMainView())
-	}
-	// if there are no more files with merge conflicts, we should ask whether the user wants to continue
-	if !gui.anyFilesWithMergeConflicts() {
-		return gui.promptToContinue()
-	}
-	return gui.handleEscapeMerge(gui.g, gui.getMainView())
-}
-
-// promptToContinue asks the user if they want to continue the rebase/merge that's in progress
-func (gui *Gui) promptToContinue() error {
-	return gui.createConfirmationPanel(gui.g, gui.getFilesView(), "continue", gui.Tr.SLocalize("ConflictsResolved"), func(g *gocui.Gui, v *gocui.View) error {
-		return gui.genericMergeCommand("continue")
-	}, nil)
+	gui.stageSelectedFile(g)
+	gui.refreshFiles(g)
+	return gui.switchFocus(g, nil, filesView)
 }

pkg/gui/options_menu_panel.go

@@ -1,53 +0,0 @@
-package gui
-
-import (
-	"strings"
-
-	"github.com/go-errors/errors"
-
-	"github.com/jesseduffield/gocui"
-)
-
-func (gui *Gui) getBindings(v *gocui.View) []*Binding {
-	var (
-		bindingsGlobal, bindingsPanel []*Binding
-	)
-
-	bindings := gui.GetCurrentKeybindings()
-
-	for _, binding := range bindings {
-		if binding.GetKey() != "" && binding.Description != "" {
-			switch binding.ViewName {
-			case "":
-				bindingsGlobal = append(bindingsGlobal, binding)
-			case v.Name():
-				bindingsPanel = append(bindingsPanel, binding)
-			}
-		}
-	}
-
-	// append dummy element to have a separator between
-	// panel and global keybindings
-	bindingsPanel = append(bindingsPanel, &Binding{})
-	return append(bindingsPanel, bindingsGlobal...)
-}
-
-func (gui *Gui) handleCreateOptionsMenu(g *gocui.Gui, v *gocui.View) error {
-	bindings := gui.getBindings(v)
-
-	handleMenuPress := func(index int) error {
-		if bindings[index].Key == nil {
-			return nil
-		}
-		if index >= len(bindings) {
-			return errors.New("Index is greater than size of bindings")
-		}
-		err := gui.handleMenuClose(g, v)
-		if err != nil {
-			return err
-		}
-		return bindings[index].Handler(g, v)
-	}
-
-	return gui.createMenu(strings.Title(gui.Tr.SLocalize("menu")), bindings, handleMenuPress)
-}

pkg/gui/rebase_options_panel.go

@@ -1,91 +0,0 @@
-package gui
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/jesseduffield/gocui"
-)
-
-type option struct {
-	value string
-}
-
-// GetDisplayStrings is a function.
-func (r *option) GetDisplayStrings(isFocused bool) []string {
-	return []string{r.value}
-}
-
-func (gui *Gui) handleCreateRebaseOptionsMenu(g *gocui.Gui, v *gocui.View) error {
-	options := []*option{
-		{value: "continue"},
-		{value: "abort"},
-	}
-
-	if gui.State.WorkingTreeState == "rebasing" {
-		options = append(options, &option{value: "skip"})
-	}
-
-	handleMenuPress := func(index int) error {
-		command := options[index].value
-		return gui.genericMergeCommand(command)
-	}
-
-	var title string
-	if gui.State.WorkingTreeState == "merging" {
-		title = gui.Tr.SLocalize("MergeOptionsTitle")
-	} else {
-		title = gui.Tr.SLocalize("RebaseOptionsTitle")
-	}
-
-	return gui.createMenu(title, options, handleMenuPress)
-}
-
-func (gui *Gui) genericMergeCommand(command string) error {
-	status := gui.State.WorkingTreeState
-
-	if status != "merging" && status != "rebasing" {
-		return gui.createErrorPanel(gui.g, gui.Tr.SLocalize("NotMergingOrRebasing"))
-	}
-
-	commandType := strings.Replace(status, "ing", "e", 1)
-	// we should end up with a command like 'git merge --continue'
-
-	// it's impossible for a rebase to require a commit so we'll use a subprocess only if it's a merge
-	if status == "merging" && command != "abort" && gui.Config.GetUserConfig().GetBool("git.merging.manualCommit") {
-		sub := gui.OSCommand.PrepareSubProcess("git", commandType, fmt.Sprintf("--%s", command))
-		if sub != nil {
-			gui.SubProcess = sub
-			return gui.Errors.ErrSubProcess
-		}
-		return nil
-	}
-	result := gui.GitCommand.GenericMerge(commandType, command)
-	if err := gui.handleGenericMergeCommandResult(result); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (gui *Gui) handleGenericMergeCommandResult(result error) error {
-	if err := gui.refreshSidePanels(gui.g); err != nil {
-		return err
-	}
-	if result == nil {
-		return nil
-	} else if result == gui.Errors.ErrSubProcess {
-		return result
-	} else if strings.Contains(result.Error(), "No changes - did you forget to use") {
-		return gui.genericMergeCommand("skip")
-	} else if strings.Contains(result.Error(), "When you have resolved this problem") || strings.Contains(result.Error(), "fix conflicts") || strings.Contains(result.Error(), "Resolve all conflicts manually") {
-		return gui.createConfirmationPanel(gui.g, gui.getFilesView(), gui.Tr.SLocalize("FoundConflictsTitle"), gui.Tr.SLocalize("FoundConflicts"),
-			func(g *gocui.Gui, v *gocui.View) error {
-				return nil
-			}, func(g *gocui.Gui, v *gocui.View) error {
-				return gui.genericMergeCommand("abort")
-			},
-		)
-	} else {
-		return gui.createErrorPanel(gui.g, result.Error())
-	}
-}

pkg/gui/recent_repos_panel.go

@@ -1,76 +0,0 @@
-package gui
-
-import (
-	"os"
-	"path/filepath"
-
-	"github.com/fatih/color"
-	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-type recentRepo struct {
-	path string
-}
-
-// GetDisplayStrings returns the path from a recent repo.
-func (r *recentRepo) GetDisplayStrings(isFocused bool) []string {
-	yellow := color.New(color.FgMagenta)
-	base := filepath.Base(r.path)
-	path := yellow.Sprint(r.path)
-	return []string{base, path}
-}
-
-func (gui *Gui) handleCreateRecentReposMenu(g *gocui.Gui, v *gocui.View) error {
-	recentRepoPaths := gui.Config.GetAppState().RecentRepos
-	reposCount := utils.Min(len(recentRepoPaths), 20)
-	// we won't show the current repo hence the -1
-	recentRepos := make([]*recentRepo, reposCount-1)
-	for i, path := range recentRepoPaths[1:reposCount] {
-		recentRepos[i] = &recentRepo{path: path}
-	}
-
-	handleMenuPress := func(index int) error {
-		repo := recentRepos[index]
-		if err := os.Chdir(repo.path); err != nil {
-			return err
-		}
-		newGitCommand, err := commands.NewGitCommand(gui.Log, gui.OSCommand, gui.Tr, gui.Config)
-		if err != nil {
-			return err
-		}
-		gui.GitCommand = newGitCommand
-		return gui.Errors.ErrSwitchRepo
-	}
-
-	return gui.createMenu(gui.Tr.SLocalize("RecentRepos"), recentRepos, handleMenuPress)
-}
-
-// updateRecentRepoList registers the fact that we opened lazygit in this repo,
-// so that we can open the same repo via the 'recent repos' menu
-func (gui *Gui) updateRecentRepoList() error {
-	recentRepos := gui.Config.GetAppState().RecentRepos
-	currentRepo, err := os.Getwd()
-	if err != nil {
-		return err
-	}
-	known, recentRepos := newRecentReposList(recentRepos, currentRepo)
-	gui.Config.SetIsNewRepo(known)
-	gui.Config.GetAppState().RecentRepos = recentRepos
-	return gui.Config.SaveAppState()
-}
-
-// newRecentReposList returns a new repo list with a new entry but only when it doesn't exist yet
-func newRecentReposList(recentRepos []string, currentRepo string) (bool, []string) {
-	isNew := true
-	newRepos := []string{currentRepo}
-	for _, repo := range recentRepos {
-		if repo != currentRepo {
-			newRepos = append(newRepos, repo)
-		} else {
-			isNew = false
-		}
-	}
-	return isNew, newRepos
-}

pkg/gui/staging_panel.go

@@ -1,222 +0,0 @@
-package gui
-
-import (
-	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/git"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-func (gui *Gui) refreshStagingPanel() error {
-	file, err := gui.getSelectedFile(gui.g)
-	if err != nil {
-		if err != gui.Errors.ErrNoFiles {
-			return err
-		}
-		return gui.handleStagingEscape(gui.g, nil)
-	}
-
-	if !file.HasUnstagedChanges {
-		return gui.handleStagingEscape(gui.g, nil)
-	}
-
-	// note for custom diffs, we'll need to send a flag here saying not to use the custom diff
-	diff := gui.GitCommand.Diff(file, true)
-	colorDiff := gui.GitCommand.Diff(file, false)
-
-	if len(diff) < 2 {
-		return gui.handleStagingEscape(gui.g, nil)
-	}
-
-	// parse the diff and store the line numbers of hunks and stageable lines
-	// TODO: maybe instantiate this at application start
-	p, err := git.NewPatchParser(gui.Log)
-	if err != nil {
-		return nil
-	}
-	hunkStarts, stageableLines, err := p.ParsePatch(diff)
-	if err != nil {
-		return nil
-	}
-
-	var selectedLine int
-	if gui.State.Panels.Staging != nil {
-		end := len(stageableLines) - 1
-		if end < gui.State.Panels.Staging.SelectedLine {
-			selectedLine = end
-		} else {
-			selectedLine = gui.State.Panels.Staging.SelectedLine
-		}
-	} else {
-		selectedLine = 0
-	}
-
-	gui.State.Panels.Staging = &stagingPanelState{
-		StageableLines: stageableLines,
-		HunkStarts:     hunkStarts,
-		SelectedLine:   selectedLine,
-		Diff:           diff,
-	}
-
-	if len(stageableLines) == 0 {
-		return gui.createErrorPanel(gui.g, "No lines to stage")
-	}
-
-	if err := gui.focusLineAndHunk(); err != nil {
-		return err
-	}
-
-	mainView := gui.getMainView()
-	mainView.Highlight = true
-	mainView.Wrap = false
-
-	gui.g.Update(func(*gocui.Gui) error {
-		return gui.setViewContent(gui.g, gui.getMainView(), colorDiff)
-	})
-
-	return nil
-}
-
-func (gui *Gui) handleStagingEscape(g *gocui.Gui, v *gocui.View) error {
-	gui.State.Panels.Staging = nil
-
-	return gui.switchFocus(gui.g, nil, gui.getFilesView())
-}
-
-func (gui *Gui) handleStagingPrevLine(g *gocui.Gui, v *gocui.View) error {
-	return gui.handleCycleLine(true)
-}
-
-func (gui *Gui) handleStagingNextLine(g *gocui.Gui, v *gocui.View) error {
-	return gui.handleCycleLine(false)
-}
-
-func (gui *Gui) handleStagingPrevHunk(g *gocui.Gui, v *gocui.View) error {
-	return gui.handleCycleHunk(true)
-}
-
-func (gui *Gui) handleStagingNextHunk(g *gocui.Gui, v *gocui.View) error {
-	return gui.handleCycleHunk(false)
-}
-
-func (gui *Gui) handleCycleHunk(prev bool) error {
-	state := gui.State.Panels.Staging
-	lineNumbers := state.StageableLines
-	currentLine := lineNumbers[state.SelectedLine]
-	currentHunkIndex := utils.PrevIndex(state.HunkStarts, currentLine)
-	var newHunkIndex int
-	if prev {
-		if currentHunkIndex == 0 {
-			newHunkIndex = len(state.HunkStarts) - 1
-		} else {
-			newHunkIndex = currentHunkIndex - 1
-		}
-	} else {
-		if currentHunkIndex == len(state.HunkStarts)-1 {
-			newHunkIndex = 0
-		} else {
-			newHunkIndex = currentHunkIndex + 1
-		}
-	}
-
-	state.SelectedLine = utils.NextIndex(lineNumbers, state.HunkStarts[newHunkIndex])
-
-	return gui.focusLineAndHunk()
-}
-
-func (gui *Gui) handleCycleLine(prev bool) error {
-	state := gui.State.Panels.Staging
-	lineNumbers := state.StageableLines
-	currentLine := lineNumbers[state.SelectedLine]
-	var newIndex int
-	if prev {
-		newIndex = utils.PrevIndex(lineNumbers, currentLine)
-	} else {
-		newIndex = utils.NextIndex(lineNumbers, currentLine)
-	}
-	state.SelectedLine = newIndex
-
-	return gui.focusLineAndHunk()
-}
-
-// focusLineAndHunk works out the best focus for the staging panel given the
-// selected line and size of the hunk
-func (gui *Gui) focusLineAndHunk() error {
-	stagingView := gui.getMainView()
-	state := gui.State.Panels.Staging
-
-	lineNumber := state.StageableLines[state.SelectedLine]
-
-	// we want the bottom line of the view buffer to ideally be the bottom line
-	// of the hunk, but if the hunk is too big we'll just go three lines beyond
-	// the currently selected line so that the user can see the context
-	var bottomLine int
-	nextHunkStartIndex := utils.NextIndex(state.HunkStarts, lineNumber)
-	if nextHunkStartIndex == 0 {
-		// for now linesHeight is an efficient means of getting the number of lines
-		// in the patch. However if we introduce word wrap we'll need to update this
-		bottomLine = stagingView.LinesHeight() - 1
-	} else {
-		bottomLine = state.HunkStarts[nextHunkStartIndex] - 1
-	}
-
-	hunkStartIndex := utils.PrevIndex(state.HunkStarts, lineNumber)
-	hunkStart := state.HunkStarts[hunkStartIndex]
-	// if it's the first hunk we'll also show the diff header
-	if hunkStartIndex == 0 {
-		hunkStart = 0
-	}
-
-	_, height := stagingView.Size()
-	// if this hunk is too big, we will just ensure that the user can at least
-	// see three lines of context below the cursor
-	if bottomLine-hunkStart > height {
-		bottomLine = lineNumber + 3
-	}
-
-	return gui.generalFocusLine(lineNumber, bottomLine, stagingView)
-}
-
-func (gui *Gui) handleStageHunk(g *gocui.Gui, v *gocui.View) error {
-	return gui.handleStageLineOrHunk(true)
-}
-
-func (gui *Gui) handleStageLine(g *gocui.Gui, v *gocui.View) error {
-	return gui.handleStageLineOrHunk(false)
-}
-
-func (gui *Gui) handleStageLineOrHunk(hunk bool) error {
-	state := gui.State.Panels.Staging
-	p, err := git.NewPatchModifier(gui.Log)
-	if err != nil {
-		return err
-	}
-
-	currentLine := state.StageableLines[state.SelectedLine]
-	var patch string
-	if hunk {
-		patch, err = p.ModifyPatchForHunk(state.Diff, state.HunkStarts, currentLine)
-	} else {
-		patch, err = p.ModifyPatchForLine(state.Diff, currentLine)
-	}
-	if err != nil {
-		return err
-	}
-
-	// for logging purposes
-	// ioutil.WriteFile("patch.diff", []byte(patch), 0600)
-
-	// apply the patch then refresh this panel
-	// create a new temp file with the patch, then call git apply with that patch
-	_, err = gui.GitCommand.ApplyPatch(patch)
-	if err != nil {
-		return err
-	}
-
-	if err := gui.refreshFiles(); err != nil {
-		return err
-	}
-	if err := gui.refreshStagingPanel(); err != nil {
-		return err
-	}
-	return nil
-}

pkg/gui/stash_panel.go

@@ -5,96 +5,56 @@ import (
 
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
-// list panel functions
-
-func (gui *Gui) getSelectedStashEntry(v *gocui.View) *commands.StashEntry {
-	selectedLine := gui.State.Panels.Stash.SelectedLine
-	if selectedLine == -1 {
-		return nil
-	}
-
-	return gui.State.StashEntries[selectedLine]
-}
-
-func (gui *Gui) handleStashEntrySelect(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	if _, err := gui.g.SetCurrentView(v.Name()); err != nil {
-		return err
-	}
-	stashEntry := gui.getSelectedStashEntry(v)
-	if stashEntry == nil {
-		return gui.renderString(g, "main", gui.Tr.SLocalize("NoStashEntries"))
-	}
-	if err := gui.focusPoint(0, gui.State.Panels.Stash.SelectedLine, v); err != nil {
-		return err
-	}
-	go func() {
-		// doing this asynchronously cos it can take time
-		diff, _ := gui.GitCommand.GetStashEntryDiff(stashEntry.Index)
-		_ = gui.renderString(g, "main", diff)
-	}()
-	return nil
-}
-
 func (gui *Gui) refreshStashEntries(g *gocui.Gui) error {
 	g.Update(func(g *gocui.Gui) error {
-		gui.State.StashEntries = gui.GitCommand.GetStashEntries()
-
-		gui.refreshSelectedLine(&gui.State.Panels.Stash.SelectedLine, len(gui.State.StashEntries))
-
-		isFocused := gui.g.CurrentView().Name() == "stash"
-		list, err := utils.RenderList(gui.State.StashEntries, isFocused)
+		v, err := g.View("stash")
 		if err != nil {
-			return err
+			panic(err)
 		}
-
-		v := gui.getStashView()
+		gui.State.StashEntries = gui.GitCommand.GetStashEntries()
 		v.Clear()
-		fmt.Fprint(v, list)
-
-		if err := gui.resetOrigin(v); err != nil {
-			return err
+		for _, stashEntry := range gui.State.StashEntries {
+			fmt.Fprintln(v, stashEntry.DisplayString)
 		}
-		return nil
+		return gui.resetOrigin(v)
 	})
 	return nil
 }
 
-func (gui *Gui) handleStashNextLine(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
+func (gui *Gui) getSelectedStashEntry(v *gocui.View) *commands.StashEntry {
+	if len(gui.State.StashEntries) == 0 {
 		return nil
 	}
-
-	panelState := gui.State.Panels.Stash
-	gui.changeSelectedLine(&panelState.SelectedLine, len(gui.State.StashEntries), false)
-
-	if err := gui.resetOrigin(gui.getMainView()); err != nil {
-		return err
-	}
-	return gui.handleStashEntrySelect(gui.g, v)
+	lineNumber := gui.getItemPosition(v)
+	return &gui.State.StashEntries[lineNumber]
 }
 
-func (gui *Gui) handleStashPrevLine(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	panelState := gui.State.Panels.Stash
-	gui.changeSelectedLine(&panelState.SelectedLine, len(gui.State.StashEntries), true)
-
-	if err := gui.resetOrigin(gui.getMainView()); err != nil {
-		return err
-	}
-	return gui.handleStashEntrySelect(gui.g, v)
+func (gui *Gui) renderStashOptions(g *gocui.Gui) error {
+	return gui.renderOptionsMap(g, map[string]string{
+		"space":   gui.Tr.SLocalize("apply"),
+		"g":       gui.Tr.SLocalize("pop"),
+		"d":       gui.Tr.SLocalize("drop"),
+		"← → ↑ ↓": gui.Tr.SLocalize("navigate"),
+	})
 }
 
-// specific functions
+func (gui *Gui) handleStashEntrySelect(g *gocui.Gui, v *gocui.View) error {
+	if err := gui.renderStashOptions(g); err != nil {
+		return err
+	}
+	go func() {
+		stashEntry := gui.getSelectedStashEntry(v)
+		if stashEntry == nil {
+			gui.renderString(g, "main", gui.Tr.SLocalize("NoStashEntries"))
+			return
+		}
+		diff, _ := gui.GitCommand.GetStashEntryDiff(stashEntry.Index)
+		gui.renderString(g, "main", diff)
+	}()
+	return nil
+}
 
 func (gui *Gui) handleStashApply(g *gocui.Gui, v *gocui.View) error {
 	return gui.stashDo(g, v, "apply")
@@ -127,7 +87,7 @@ func (gui *Gui) stashDo(g *gocui.Gui, v *gocui.View, method string) error {
 		gui.createErrorPanel(g, err.Error())
 	}
 	gui.refreshStashEntries(g)
-	return gui.refreshFiles()
+	return gui.refreshFiles(g)
 }
 
 func (gui *Gui) handleStashSave(g *gocui.Gui, filesView *gocui.View) error {
@@ -139,7 +99,7 @@ func (gui *Gui) handleStashSave(g *gocui.Gui, filesView *gocui.View) error {
 			gui.createErrorPanel(g, err.Error())
 		}
 		gui.refreshStashEntries(g)
-		return gui.refreshFiles()
+		return gui.refreshFiles(g)
 	})
 	return nil
 }

pkg/gui/status_panel.go

@@ -2,7 +2,6 @@ package gui
 
 import (
 	"fmt"
-	"strings"
 
 	"github.com/fatih/color"
 	"github.com/jesseduffield/gocui"
@@ -19,14 +18,14 @@ func (gui *Gui) refreshStatus(g *gocui.Gui) error {
 	// contents end up cleared
 	g.Update(func(*gocui.Gui) error {
 		v.Clear()
-		pushables, pullables := gui.GitCommand.GetCurrentBranchUpstreamDifferenceCount()
+		pushables, pullables := gui.GitCommand.UpstreamDifferenceCount()
 		fmt.Fprint(v, "↑"+pushables+"↓"+pullables)
 		branches := gui.State.Branches
-		if err := gui.updateWorkTreeState(); err != nil {
+		if err := gui.updateHasMergeConflictStatus(); err != nil {
 			return err
 		}
-		if gui.State.WorkingTreeState != "normal" {
-			fmt.Fprint(v, utils.ColoredString(fmt.Sprintf(" (%s)", gui.State.WorkingTreeState), color.FgYellow))
+		if gui.State.HasMergeConflicts {
+			fmt.Fprint(v, utils.ColoredString(" (merging)", color.FgYellow))
 		}
 
 		if len(branches) == 0 {
@@ -42,42 +41,37 @@ func (gui *Gui) refreshStatus(g *gocui.Gui) error {
 	return nil
 }
 
-func (gui *Gui) handleCheckForUpdate(g *gocui.Gui, v *gocui.View) error {
-	gui.Updater.CheckForNewUpdate(gui.onUserUpdateCheckFinish, true)
-	return gui.createLoaderPanel(gui.g, v, gui.Tr.SLocalize("CheckingForUpdates"))
+func (gui *Gui) renderStatusOptions(g *gocui.Gui) error {
+	return gui.renderOptionsMap(g, map[string]string{
+		"o": gui.Tr.SLocalize("OpenConfig"),
+		"e": gui.Tr.SLocalize("EditConfig"),
+	})
 }
 
 func (gui *Gui) handleStatusSelect(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
+	dashboardString := fmt.Sprintf(
+		"%s\n\n%s\n\n%s\n\n%s\n\n%s",
+		lazygitTitle(),
+		"Keybindings: https://github.com/jesseduffield/lazygit/blob/master/docs/Keybindings.md",
+		"Config Options: https://github.com/jesseduffield/lazygit/blob/master/docs/Config.md",
+		"Tutorial: https://www.youtube.com/watch?v=VDXvbHZYeKY",
+		"Raise an Issue: https://github.com/jesseduffield/lazygit/issues",
+	)
 
-	if _, err := gui.g.SetCurrentView(v.Name()); err != nil {
+	if err := gui.renderString(g, "main", dashboardString); err != nil {
 		return err
 	}
-	magenta := color.New(color.FgMagenta)
-
-	dashboardString := strings.Join(
-		[]string{
-			lazygitTitle(),
-			"Copyright (c) 2018 Jesse Duffield",
-			"Keybindings: https://github.com/jesseduffield/lazygit/blob/master/docs/Keybindings.md",
-			"Config Options: https://github.com/jesseduffield/lazygit/blob/master/docs/Config.md",
-			"Tutorial: https://youtu.be/VDXvbHZYeKY",
-			"Raise an Issue: https://github.com/jesseduffield/lazygit/issues",
-			magenta.Sprint("Buy Jesse a coffee: https://donorbox.org/lazygit"), // caffeine ain't free
-		}, "\n\n")
-
-	return gui.renderString(g, "main", dashboardString)
+	return gui.renderStatusOptions(g)
 }
 
 func (gui *Gui) handleOpenConfig(g *gocui.Gui, v *gocui.View) error {
-	return gui.openFile(gui.Config.GetUserConfig().ConfigFileUsed())
+	filename := gui.Config.GetUserConfig().ConfigFileUsed()
+	return gui.genericFileOpen(g, v, filename, gui.OSCommand.OpenFile)
 }
 
 func (gui *Gui) handleEditConfig(g *gocui.Gui, v *gocui.View) error {
 	filename := gui.Config.GetUserConfig().ConfigFileUsed()
-	return gui.editFile(filename)
+	return gui.genericFileOpen(g, v, filename, gui.OSCommand.EditFile)
 }
 
 func lazygitTitle() string {
@@ -91,24 +85,3 @@ func lazygitTitle() string {
                 __/ | __/ |
                |___/ |___/       `
 }
-
-func (gui *Gui) updateWorkTreeState() error {
-	merging, err := gui.GitCommand.IsInMergeState()
-	if err != nil {
-		return err
-	}
-	if merging {
-		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/updates.go

@@ -1,65 +0,0 @@
-package gui
-
-import "github.com/jesseduffield/gocui"
-
-func (gui *Gui) showUpdatePrompt(newVersion string) error {
-	title := "New version available!"
-	message := "Download latest version? (enter/esc)"
-	currentView := gui.g.CurrentView()
-	return gui.createConfirmationPanel(gui.g, currentView, title, message, func(g *gocui.Gui, v *gocui.View) error {
-		gui.startUpdating(newVersion)
-		return nil
-	}, nil)
-}
-
-func (gui *Gui) onUserUpdateCheckFinish(newVersion string, err error) error {
-	if err != nil {
-		return gui.createErrorPanel(gui.g, err.Error())
-	}
-	if newVersion == "" {
-		return gui.createErrorPanel(gui.g, "New version not found")
-	}
-	return gui.showUpdatePrompt(newVersion)
-}
-
-func (gui *Gui) onBackgroundUpdateCheckFinish(newVersion string, err error) error {
-	if err != nil {
-		// ignoring the error for now so that I'm not annoying users
-		gui.Log.Error(err.Error())
-		return nil
-	}
-	if newVersion == "" {
-		return nil
-	}
-	if gui.Config.GetUserConfig().Get("update.method") == "background" {
-		gui.startUpdating(newVersion)
-		return nil
-	}
-	return gui.showUpdatePrompt(newVersion)
-}
-
-func (gui *Gui) startUpdating(newVersion string) {
-	gui.State.Updating = true
-	gui.statusManager.addWaitingStatus("updating")
-	gui.Updater.Update(newVersion, gui.onUpdateFinish)
-}
-
-func (gui *Gui) onUpdateFinish(err error) error {
-	gui.State.Updating = false
-	gui.statusManager.removeStatus("updating")
-	if err := gui.renderString(gui.g, "appStatus", ""); err != nil {
-		return err
-	}
-	if err != nil {
-		return gui.createErrorPanel(gui.g, "Update failed: "+err.Error())
-	}
-	return nil
-}
-
-func (gui *Gui) createUpdateQuitConfirmation(g *gocui.Gui, v *gocui.View) error {
-	title := "Currently Updating"
-	message := "An update is in progress. Are you sure you want to quit?"
-	return gui.createConfirmationPanel(gui.g, v, title, message, func(g *gocui.Gui, v *gocui.View) error {
-		return gocui.ErrQuit
-	}, nil)
-}

pkg/gui/view_helpers.go

@@ -4,25 +4,18 @@ import (
 	"fmt"
 	"sort"
 	"strings"
+	"time"
 
 	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/spkg/bom"
 )
 
 var cyclableViews = []string{"status", "files", "branches", "commits", "stash"}
 
 func (gui *Gui) refreshSidePanels(g *gocui.Gui) error {
-	if err := gui.refreshBranches(g); err != nil {
-		return err
-	}
-	if err := gui.refreshFiles(); err != nil {
-		return err
-	}
-	if err := gui.refreshCommits(g); err != nil {
-		return err
-	}
-	return gui.refreshStashEntries(g)
+	gui.refreshBranches(g)
+	gui.refreshFiles(g)
+	gui.refreshCommits(g)
+	return nil
 }
 
 func (gui *Gui) nextView(g *gocui.Gui, v *gocui.View) error {
@@ -84,31 +77,29 @@ func (gui *Gui) previousView(g *gocui.Gui, v *gocui.View) error {
 }
 
 func (gui *Gui) newLineFocused(g *gocui.Gui, v *gocui.View) error {
+	mainView, _ := g.View("main")
+	mainView.SetOrigin(0, 0)
+
 	switch v.Name() {
-	case "menu":
-		return gui.handleMenuSelect(g, v)
 	case "status":
 		return gui.handleStatusSelect(g, v)
 	case "files":
-		return gui.handleFileSelect(g, v, false)
+		return gui.handleFileSelect(g, v)
 	case "branches":
 		return gui.handleBranchSelect(g, v)
-	case "commits":
-		return gui.handleCommitSelect(g, v)
-	case "stash":
-		return gui.handleStashEntrySelect(g, v)
 	case "confirmation":
 		return nil
 	case "commitMessage":
 		return gui.handleCommitFocused(g, v)
-	case "credentials":
-		return gui.handleCredentialsViewFocused(g, v)
 	case "main":
-		if gui.State.Contexts["main"] == "merging" {
-			return gui.refreshMergePanel()
-		}
+		// TODO: pull this out into a 'view focused' function
+		gui.refreshMergePanel(g)
 		v.Highlight = false
 		return nil
+	case "commits":
+		return gui.handleCommitSelect(g, v)
+	case "stash":
+		return gui.handleStashEntrySelect(g, v)
 	default:
 		panic(gui.Tr.SLocalize("NoViewMachingNewLineFocusedSwitchStatement"))
 	}
@@ -117,30 +108,27 @@ func (gui *Gui) newLineFocused(g *gocui.Gui, v *gocui.View) error {
 func (gui *Gui) returnFocus(g *gocui.Gui, v *gocui.View) error {
 	previousView, err := g.View(gui.State.PreviousView)
 	if err != nil {
-		// always fall back to files view if there's no 'previous' view stored
-		previousView, err = g.View("files")
-		if err != nil {
-			gui.Log.Error(err)
-		}
+		panic(err)
 	}
 	return gui.switchFocus(g, v, previousView)
 }
 
 // pass in oldView = nil if you don't want to be able to return to your old view
-// TODO: move some of this logic into our onFocusLost and onFocus hooks
 func (gui *Gui) switchFocus(g *gocui.Gui, oldView, newView *gocui.View) error {
 	// we assume we'll never want to return focus to a confirmation panel i.e.
 	// we should never stack confirmation panels
 	if oldView != nil && oldView.Name() != "confirmation" {
-		// second class panels should never have focus restored to them because
-		// once they lose focus they are effectively 'destroyed'
-		secondClassPanels := []string{"confirmation", "menu"}
-		if !utils.IncludesString(secondClassPanels, oldView.Name()) {
-			gui.State.PreviousView = oldView.Name()
-		}
+		oldView.Highlight = false
+		message := gui.Tr.TemplateLocalize(
+			"settingPreviewsViewTo",
+			Teml{
+				"oldViewName": oldView.Name(),
+			},
+		)
+		gui.Log.Info(message)
+		gui.State.PreviousView = oldView.Name()
 	}
-
-	gui.Log.Info("setting highlight to true for view" + newView.Name())
+	newView.Highlight = true
 	message := gui.Tr.TemplateLocalize(
 		"newFocusedViewIs",
 		Teml{
@@ -151,17 +139,55 @@ func (gui *Gui) switchFocus(g *gocui.Gui, oldView, newView *gocui.View) error {
 	if _, err := g.SetCurrentView(newView.Name()); err != nil {
 		return err
 	}
-	if _, err := g.SetViewOnTop(newView.Name()); err != nil {
-		return err
-	}
-
 	g.Cursor = newView.Editable
+	return gui.newLineFocused(g, newView)
+}
 
-	if err := gui.renderPanelOptions(); err != nil {
-		return err
+func (gui *Gui) getItemPosition(v *gocui.View) int {
+	gui.correctCursor(v)
+	_, cy := v.Cursor()
+	_, oy := v.Origin()
+	return oy + cy
+}
+
+func (gui *Gui) cursorUp(g *gocui.Gui, v *gocui.View) error {
+	// swallowing cursor movements in main
+	// TODO: pull this out
+	if v == nil || v.Name() == "main" {
+		return nil
 	}
 
-	return gui.newLineFocused(g, newView)
+	ox, oy := v.Origin()
+	cx, cy := v.Cursor()
+	if err := v.SetCursor(cx, cy-1); err != nil && oy > 0 {
+		if err := v.SetOrigin(ox, oy-1); err != nil {
+			return err
+		}
+	}
+
+	gui.newLineFocused(g, v)
+	return nil
+}
+
+func (gui *Gui) cursorDown(g *gocui.Gui, v *gocui.View) error {
+	// swallowing cursor movements in main
+	// TODO: pull this out
+	if v == nil || v.Name() == "main" {
+		return nil
+	}
+	cx, cy := v.Cursor()
+	ox, oy := v.Origin()
+	if cy+oy >= len(v.BufferLines())-2 {
+		return nil
+	}
+	if err := v.SetCursor(cx, cy+1); err != nil {
+		if err := v.SetOrigin(ox, oy+1); err != nil {
+			return err
+		}
+	}
+
+	gui.newLineFocused(g, v)
+	return nil
 }
 
 func (gui *Gui) resetOrigin(v *gocui.View) error {
@@ -172,68 +198,28 @@ func (gui *Gui) resetOrigin(v *gocui.View) error {
 }
 
 // if the cursor down past the last item, move it to the last line
-func (gui *Gui) focusPoint(cx int, cy int, v *gocui.View) error {
-	if cy < 0 {
-		return nil
-	}
-	ox, oy := v.Origin()
-	_, height := v.Size()
-	ly := height - 1
-
-	// if line is above origin, move origin and set cursor to zero
-	// if line is below origin + height, move origin and set cursor to max
-	// otherwise set cursor to value - origin
-	if ly > v.LinesHeight() {
-		if err := v.SetCursor(cx, cy); err != nil {
-			return err
-		}
-		if err := v.SetOrigin(ox, 0); err != nil {
-			return err
-		}
-	} else if cy < oy {
-		if err := v.SetCursor(cx, 0); err != nil {
-			return err
-		}
-		if err := v.SetOrigin(ox, cy); err != nil {
-			return err
-		}
-	} else if cy > oy+ly {
-		if err := v.SetCursor(cx, ly); err != nil {
-			return err
-		}
-		if err := v.SetOrigin(ox, cy-ly); err != nil {
-			return err
-		}
-	} else {
-		if err := v.SetCursor(cx, cy-oy); err != nil {
-			return err
-		}
+func (gui *Gui) correctCursor(v *gocui.View) error {
+	cx, cy := v.Cursor()
+	_, oy := v.Origin()
+	lineCount := len(v.BufferLines()) - 2
+	if cy >= lineCount-oy {
+		return v.SetCursor(cx, lineCount-oy)
 	}
 	return nil
 }
 
-func (gui *Gui) cleanString(s string) string {
-	output := string(bom.Clean([]byte(s)))
-	return utils.NormalizeLinefeeds(output)
-}
-
-func (gui *Gui) setViewContent(g *gocui.Gui, v *gocui.View, s string) error {
-	v.Clear()
-	fmt.Fprint(v, gui.cleanString(s))
-	return nil
-}
-
-// renderString resets the origin of a view and sets its content
 func (gui *Gui) renderString(g *gocui.Gui, viewName, s string) error {
 	g.Update(func(*gocui.Gui) error {
 		v, err := g.View(viewName)
+		// just in case the view disappeared as this function was called, we'll
+		// silently return if it's not found
 		if err != nil {
-			return nil // return gracefully if view has been deleted
+			return nil
 		}
-		if err := v.SetOrigin(0, 0); err != nil {
-			return err
-		}
-		return gui.setViewContent(gui.g, v, s)
+		v.Clear()
+		fmt.Fprint(v, s)
+		v.Wrap = true
+		return nil
 	})
 	return nil
 }
@@ -247,39 +233,31 @@ func (gui *Gui) optionsMapToString(optionsMap map[string]string) string {
 	return strings.Join(optionsArray, ", ")
 }
 
-func (gui *Gui) renderOptionsMap(optionsMap map[string]string) error {
-	return gui.renderString(gui.g, "options", gui.optionsMapToString(optionsMap))
+func (gui *Gui) renderOptionsMap(g *gocui.Gui, optionsMap map[string]string) error {
+	return gui.renderString(g, "options", gui.optionsMapToString(optionsMap))
+}
+
+func (gui *Gui) loader() string {
+	characters := "|/-\\"
+	now := time.Now()
+	nanos := now.UnixNano()
+	index := nanos / 50000000 % int64(len(characters))
+	return characters[index : index+1]
 }
 
 // TODO: refactor properly
-// i'm so sorry but had to add this getBranchesView
-func (gui *Gui) getFilesView() *gocui.View {
-	v, _ := gui.g.View("files")
+func (gui *Gui) getFilesView(g *gocui.Gui) *gocui.View {
+	v, _ := g.View("files")
 	return v
 }
 
-func (gui *Gui) getCommitsView() *gocui.View {
-	v, _ := gui.g.View("commits")
+func (gui *Gui) getCommitsView(g *gocui.Gui) *gocui.View {
+	v, _ := g.View("commits")
 	return v
 }
 
-func (gui *Gui) getCommitMessageView() *gocui.View {
-	v, _ := gui.g.View("commitMessage")
-	return v
-}
-
-func (gui *Gui) getBranchesView() *gocui.View {
-	v, _ := gui.g.View("branches")
-	return v
-}
-
-func (gui *Gui) getMainView() *gocui.View {
-	v, _ := gui.g.View("main")
-	return v
-}
-
-func (gui *Gui) getStashView() *gocui.View {
-	v, _ := gui.g.View("stash")
+func (gui *Gui) getCommitMessageView(g *gocui.Gui) *gocui.View {
+	v, _ := g.View("commitMessage")
 	return v
 }
 
@@ -287,113 +265,7 @@ func (gui *Gui) trimmedContent(v *gocui.View) string {
 	return strings.TrimSpace(v.Buffer())
 }
 
-func (gui *Gui) currentViewName() string {
-	currentView := gui.g.CurrentView()
+func (gui *Gui) currentViewName(g *gocui.Gui) string {
+	currentView := g.CurrentView()
 	return currentView.Name()
 }
-
-func (gui *Gui) resizeCurrentPopupPanel(g *gocui.Gui) error {
-	v := g.CurrentView()
-	if v.Name() == "commitMessage" || v.Name() == "credentials" || v.Name() == "confirmation" {
-		return gui.resizePopupPanel(g, v)
-	}
-	return nil
-}
-
-func (gui *Gui) resizePopupPanel(g *gocui.Gui, v *gocui.View) error {
-	// If the confirmation panel is already displayed, just resize the width,
-	// otherwise continue
-	content := v.Buffer()
-	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(g, v.Wrap, content)
-	vx0, vy0, vx1, vy1 := v.Dimensions()
-	if vx0 == x0 && vy0 == y0 && vx1 == x1 && vy1 == y1 {
-		return nil
-	}
-	gui.Log.Info(gui.Tr.SLocalize("resizingPopupPanel"))
-	_, err := g.SetView(v.Name(), x0, y0, x1, y1, 0)
-	return err
-}
-
-// generalFocusLine takes a lineNumber to focus, and a bottomLine to ensure we can see
-func (gui *Gui) generalFocusLine(lineNumber int, bottomLine int, v *gocui.View) error {
-	_, height := v.Size()
-	overScroll := bottomLine - height + 1
-	if overScroll < 0 {
-		overScroll = 0
-	}
-	if err := v.SetOrigin(0, overScroll); err != nil {
-		return err
-	}
-	if err := v.SetCursor(0, lineNumber-overScroll); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (gui *Gui) changeSelectedLine(line *int, total int, up bool) {
-	if up {
-		if *line == -1 || *line == 0 {
-			return
-		}
-
-		*line -= 1
-	} else {
-		if *line == -1 || *line == total-1 {
-			return
-		}
-
-		*line += 1
-	}
-}
-
-func (gui *Gui) refreshSelectedLine(line *int, total int) {
-	if *line == -1 && total > 0 {
-		*line = 0
-	} else if total-1 < *line {
-		*line = total - 1
-	}
-}
-
-func (gui *Gui) renderListPanel(v *gocui.View, items interface{}) error {
-	gui.g.Update(func(g *gocui.Gui) error {
-		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 {
-	currentView := gui.g.CurrentView()
-	switch currentView.Name() {
-	case "menu":
-		return gui.renderMenuOptions()
-	case "main":
-		if gui.State.Contexts["main"] == "merging" {
-			return gui.renderMergeOptions()
-		}
-	}
-	return gui.renderGlobalOptions()
-}
-
-func (gui *Gui) handleFocusView(g *gocui.Gui, v *gocui.View) error {
-	_, err := gui.g.SetCurrentView(v.Name())
-	return err
-}
-
-func (gui *Gui) popupPanelFocused() bool {
-	viewNames := []string{"commitMessage",
-		"credentials",
-		"menu"}
-	for _, viewName := range viewNames {
-		if gui.currentViewName() == viewName {
-			return true
-		}
-	}
-	return false
-}

pkg/i18n/dutch.go

@@ -6,19 +6,16 @@ import (
 )
 
 // addDutch will add all dutch translations
-func addDutch(i18nObject *i18n.Bundle) error {
+func addDutch(i18nObject *i18n.Bundle) {
 
 	// add the translations
-	return i18nObject.AddMessages(language.Dutch,
+	i18nObject.AddMessages(language.Dutch,
 		&i18n.Message{
 			ID:    "NotEnoughSpace",
 			Other: "Niet genoeg ruimte om de panelen te renderen",
 		}, &i18n.Message{
 			ID:    "DiffTitle",
 			Other: "Diff",
-		}, &i18n.Message{
-			ID:    "LogTitle",
-			Other: "Log",
 		}, &i18n.Message{
 			ID:    "FilesTitle",
 			Other: "Bestanden",
@@ -31,54 +28,18 @@ func addDutch(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "StashTitle",
 			Other: "Stash",
-		}, &i18n.Message{
-			ID:    "StagingMainTitle",
-			Other: `Stage Lines/Hunks`,
-		}, &i18n.Message{
-			ID:    "MergingMainTitle",
-			Other: "Resolve merge conflicts",
 		}, &i18n.Message{
 			ID:    "CommitMessage",
-			Other: "Commit bericht",
-		}, &i18n.Message{
-			ID:    "CredentialsUsername",
-			Other: "Gebruikersnaam",
-		}, &i18n.Message{
-			ID:    "CredentialsPassword",
-			Other: "Wachtwoord",
-		}, &i18n.Message{
-			ID:    "PassUnameWrong",
-			Other: "Wachtwoord en/of gebruikersnaam verkeert",
+			Other: "Commit Bericht",
 		}, &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 commits om te wijzigen.",
-		}, &i18n.Message{
-			ID:    "CommitChangesWithEditor",
-			Other: "commit veranderingen met de git editor",
+			Other: "Commit Veranderingen",
 		}, &i18n.Message{
 			ID:    "StatusTitle",
 			Other: "Status",
-		}, &i18n.Message{
-			ID:    "GlobalTitle",
-			Other: "Global",
 		}, &i18n.Message{
 			ID:    "navigate",
 			Other: "navigeer",
-		}, &i18n.Message{
-			ID:    "menu",
-			Other: "menu",
-		}, &i18n.Message{
-			ID:    "execute",
-			Other: "uitvoeren",
 		}, &i18n.Message{
 			ID:    "stashFiles",
 			Other: "stash-bestanden",
@@ -94,24 +55,15 @@ func addDutch(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "toggleStaged",
 			Other: "toggle staged",
-		}, &i18n.Message{
-			ID:    "toggleStagedAll",
-			Other: "toggle staged alle",
 		}, &i18n.Message{
 			ID:    "refresh",
 			Other: "verversen",
-		}, &i18n.Message{
-			ID:    "push",
-			Other: "push",
-		}, &i18n.Message{
-			ID:    "pull",
-			Other: "pull",
 		}, &i18n.Message{
 			ID:    "addPatch",
-			Other: "bewerkingen toevoegen",
+			Other: "verandering toevoegen",
 		}, &i18n.Message{
 			ID:    "edit",
-			Other: "bewerken",
+			Other: "veranderen",
 		}, &i18n.Message{
 			ID:    "scroll",
 			Other: "scroll",
@@ -120,13 +72,13 @@ func addDutch(i18nObject *i18n.Bundle) error {
 			Other: "samenvoegen afbreken",
 		}, &i18n.Message{
 			ID:    "resolveMergeConflicts",
-			Other: "los merge conflicten op",
+			Other: "verhelp samenvoegen fouten",
 		}, &i18n.Message{
 			ID:    "checkout",
 			Other: "uitchecken",
 		}, &i18n.Message{
 			ID:    "NoChangedFiles",
-			Other: "Geen bestanden veranderd",
+			Other: "Geen Bestanden verandert",
 		}, &i18n.Message{
 			ID:    "FileHasNoUnstagedChanges",
 			Other: "Het bestand heeft geen unstaged veranderingen om toe te voegen",
@@ -142,33 +94,27 @@ func addDutch(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "NoFilesDisplay",
 			Other: "Geen bestanden om te laten zien",
-		}, &i18n.Message{
-			ID:    "NotAFile",
-			Other: "Dit is geen bestand",
 		}, &i18n.Message{
 			ID:    "PullWait",
-			Other: "Pullen...",
+			Other: "Pulling...",
 		}, &i18n.Message{
 			ID:    "PushWait",
-			Other: "Pushen...",
-		}, &i18n.Message{
-			ID:    "FetchWait",
-			Other: "Fetchen...",
+			Other: "Pushing...",
 		}, &i18n.Message{
 			ID:    "FileNoMergeCons",
 			Other: "Dit bestand heeft geen merge conflicten",
 		}, &i18n.Message{
 			ID:    "SureResetHardHead",
-			Other: "Weet je het zeker dat je `reset --hard HEAD` en `clean -fd` wil uitvoeren? Het kan dat je hierdoor bestanden verliest",
+			Other: "Weet je het zeker dat je `reset --hard HEAD` wil uitvoeren? het kan dat je hierdoor bestanden verliest",
 		}, &i18n.Message{
 			ID:    "SureTo",
-			Other: "Weet je het zeker dat je {{.fileName}} wilt {{.deleteVerb}} (je veranderingen zullen worden verwijderd)",
+			Other: "Weet je het zeker dat je {{.fileName}} wilt {{.deleteVerb}} (je veranderingen zullen worden verwijdert)",
 		}, &i18n.Message{
 			ID:    "AlreadyCheckedOutBranch",
-			Other: "Je hebt deze branch al uitgecheckt",
+			Other: "Je hebt uitgecheckt op deze branch",
 		}, &i18n.Message{
 			ID:    "SureForceCheckout",
-			Other: "Weet je zeker dat je het uitchecken wil forceren? Al je lokale verandering zullen worden verwijdert",
+			Other: "Weet je zeker dat je het uitchecken wil forceren? al je locale verandering zullen worden verwijdert",
 		}, &i18n.Message{
 			ID:    "ForceCheckoutBranch",
 			Other: "Forceer uitchecken op deze branch",
@@ -186,13 +132,7 @@ func addDutch(i18nObject *i18n.Bundle) error {
 			Other: "Verwijder branch",
 		}, &i18n.Message{
 			ID:    "DeleteBranchMessage",
-			Other: "Weet je zeker dat je branch {{.selectedBranchName}} wilt verwijderen?",
-		}, &i18n.Message{
-			ID:    "ForceDeleteBranchMessage",
-			Other: "Weet je zeker dat je branch {{.selectedBranchName}} geforceerd wil verwijderen?",
-		}, &i18n.Message{
-			ID:    "rebaseBranch",
-			Other: "rebase branch",
+			Other: "Weet je zeker dat je {{.selectedBranchName}} branch wil verwijderen?",
 		}, &i18n.Message{
 			ID:    "CantMergeBranchIntoItself",
 			Other: "Je kan niet een branch in zichzelf mergen",
@@ -201,7 +141,7 @@ func addDutch(i18nObject *i18n.Bundle) error {
 			Other: "forceer checkout",
 		}, &i18n.Message{
 			ID:    "merge",
-			Other: "samenvoegen",
+			Other: "merge",
 		}, &i18n.Message{
 			ID:    "checkoutByName",
 			Other: "uitchecken bij naam",
@@ -211,9 +151,6 @@ func addDutch(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "deleteBranch",
 			Other: "verwijder branch",
-		}, &i18n.Message{
-			ID:    "forceDeleteBranch",
-			Other: "verwijder branch (forceer)",
 		}, &i18n.Message{
 			ID:    "NoBranchesThisRepo",
 			Other: "Geen branches voor deze repo",
@@ -226,9 +163,6 @@ func addDutch(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "CloseConfirm",
 			Other: "{{.keyBindClose}}: Sluiten, {{.keyBindConfirm}}: Bevestigen",
-		}, &i18n.Message{
-			ID:    "close",
-			Other: "sluiten",
 		}, &i18n.Message{
 			ID:    "SureResetThisCommit",
 			Other: "Weet je het zeker dat je wil resetten naar deze commit?",
@@ -240,7 +174,7 @@ func addDutch(i18nObject *i18n.Bundle) error {
 			Other: "squash beneden",
 		}, &i18n.Message{
 			ID:    "rename",
-			Other: "hernoemen",
+			Other: "hernoem",
 		}, &i18n.Message{
 			ID:    "resetToThisCommit",
 			Other: "reset naar deze commit",
@@ -269,17 +203,17 @@ func addDutch(i18nObject *i18n.Bundle) error {
 			ID:    "OnlyRenameTopCommit",
 			Other: "Je kan alleen de bovenste commit hernoemen",
 		}, &i18n.Message{
-			ID:    "renameCommit",
-			Other: "hernoem commit",
-		}, &i18n.Message{
-			ID:    "renameCommitEditor",
-			Other: "rename commit with editor",
+			ID:    "RenameCommit",
+			Other: "Hernoem Commit",
 		}, &i18n.Message{
 			ID:    "PotentialErrInGetselectedCommit",
 			Other: "Er is mogelijk een error in getSelected Commit (geen match tussen ui en state)",
+		}, &i18n.Message{
+			ID:    "NoCommitsThisBranch",
+			Other: "Geen commits voor deze branch",
 		}, &i18n.Message{
 			ID:    "Error",
-			Other: "Foutmelding",
+			Other: "Fout",
 		}, &i18n.Message{
 			ID:    "resizingPopupPanel",
 			Other: "resizen popup paneel",
@@ -288,16 +222,16 @@ func addDutch(i18nObject *i18n.Bundle) error {
 			Other: "subprocess lopend",
 		}, &i18n.Message{
 			ID:    "selectHunk",
-			Other: "selecteer stuk",
+			Other: "selecteer Hunk",
 		}, &i18n.Message{
 			ID:    "navigateConflicts",
 			Other: "navigeer conflicts",
 		}, &i18n.Message{
 			ID:    "pickHunk",
-			Other: "kies stuk",
+			Other: "kies Hunk",
 		}, &i18n.Message{
 			ID:    "pickBothHunks",
-			Other: "kies beide stukken",
+			Other: "kies bijde hunks",
 		}, &i18n.Message{
 			ID:    "undo",
 			Other: "ongedaan maken",
@@ -334,315 +268,24 @@ func addDutch(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "NoViewMachingNewLineFocusedSwitchStatement",
 			Other: "Er machen geen weergave met de newLineFocused switch declaratie",
+		}, &i18n.Message{
+			ID:    "settingPreviewsViewTo",
+			Other: "vorige weergave instellen op: {{.oldViewName}}",
 		}, &i18n.Message{
 			ID:    "newFocusedViewIs",
 			Other: "nieuw gefocussed weergave is {{.newFocusedView}}",
 		}, &i18n.Message{
 			ID:    "CantCloseConfirmationPrompt",
 			Other: "Kon de bevestiging prompt niet sluiten: {{.error}}",
+		}, &i18n.Message{
+			ID:    "NoChangedFiles",
+			Other: "Geen veranderde files",
 		}, &i18n.Message{
 			ID:    "ClearFilePanel",
 			Other: "maak bestandsvenster leeg",
 		}, &i18n.Message{
 			ID:    "MergeAborted",
 			Other: "Merge afgebroken",
-		}, &i18n.Message{
-			ID:    "OpenConfig",
-			Other: "open config file",
-		}, &i18n.Message{
-			ID:    "EditConfig",
-			Other: "verander config file",
-		}, &i18n.Message{
-			ID:    "ForcePush",
-			Other: "Forceer push",
-		}, &i18n.Message{
-			ID:    "ForcePushPrompt",
-			Other: "Jouw branch is afgeweken van de remote branch. Druk 'esc' om te annuleren, of 'enter' om geforceert te pushen.",
-		}, &i18n.Message{
-			ID:    "checkForUpdate",
-			Other: "check voor updates",
-		}, &i18n.Message{
-			ID:    "CheckingForUpdates",
-			Other: "zoeken naar updates...",
-		}, &i18n.Message{
-			ID:    "OnLatestVersionErr",
-			Other: "Je hebt al de laatste versie",
-		}, &i18n.Message{
-			ID:    "MajorVersionErr",
-			Other: "Nieuwe versie ({{.newVersion}}) is niet backwards compatibele vergeleken met de huidige versie ({{.currentVersion}})",
-		}, &i18n.Message{
-			ID:    "CouldNotFindBinaryErr",
-			Other: "Kon geen binary vinden op {{.url}}",
-		}, &i18n.Message{
-			ID:    "AnonymousReportingTitle",
-			Other: "Help lazygit te verbeteren",
-		}, &i18n.Message{
-			ID:    "AnonymousReportingPrompt",
-			Other: "Zou je anonieme data rapportage willen aanzetten om lazygit beter te kunnen maken? (enter/esc)",
-		}, &i18n.Message{
-			ID:    "GitconfigParseErr",
-			Other: `Gogit kon je gitconfig bestand niet goed parsen door de aanwezigheid van losstaande '\' tekens. Het weghalen van deze tekens zou het probleem moeten oplossen. `,
-		}, &i18n.Message{
-			ID:    "removeFile",
-			Other: `Verwijder als untracked / uitchecken wordt gevolgd (ga weg)`,
-		}, &i18n.Message{
-			ID:    "editFile",
-			Other: `verander bestand`,
-		}, &i18n.Message{
-			ID:    "openFile",
-			Other: `open bestand`,
-		}, &i18n.Message{
-			ID:    "ignoreFile",
-			Other: `voeg toe aan .gitignore`,
-		}, &i18n.Message{
-			ID:    "refreshFiles",
-			Other: `refresh bestanden`,
-		}, &i18n.Message{
-			ID:    "resetHard",
-			Other: `harde reset and verwijderen ongevolgde bestanden`,
-		}, &i18n.Message{
-			ID:    "mergeIntoCurrentBranch",
-			Other: `merge in met huidige checked out branch`,
-		}, &i18n.Message{
-			ID:    "ConfirmQuit",
-			Other: `Weet je zeker dat je dit programma wil sluiten?`,
-		}, &i18n.Message{
-			ID:    "SwitchRepo",
-			Other: "wissel naar een recente repo",
-		}, &i18n.Message{
-			ID:    "UnsupportedGitService",
-			Other: `Niet-ondersteunde git-service`,
-		}, &i18n.Message{
-			ID:    "createPullRequest",
-			Other: `maak een pull-aanvraag`,
-		}, &i18n.Message{
-			ID:    "NoBranchOnRemote",
-			Other: `Deze branch bestaat niet op de remote. U moet het eerst naar de remote pushen.`,
-		}, &i18n.Message{
-			ID:    "fetch",
-			Other: `fetch`,
-		}, &i18n.Message{
-			ID:    "NoAutomaticGitFetchTitle",
-			Other: `Geen automatiese git fetch`,
-		}, &i18n.Message{
-			ID:    "NoAutomaticGitFetchBody",
-			Other: `Lazygit kan niet "git fetch" uitvoeren in een privé repository, gebruik f in het branches paneel om "git fetch" manueel uit te voeren`,
-		}, &i18n.Message{
-			ID:    "StageLines",
-			Other: `stage individuele hunks/lijnen`,
-		}, &i18n.Message{
-			ID:    "FileStagingRequirements",
-			Other: `Kan alleen individuele lijnen stagen van getrackte bestanden met onstaged veranderingen`,
-		}, &i18n.Message{
-			ID:    "StagingTitle",
-			Other: `Stage Lines/Hunks`,
-		}, &i18n.Message{
-			ID:    "StageHunk",
-			Other: `stage hunk`,
-		}, &i18n.Message{
-			ID:    "StageLine",
-			Other: `stage lijn`,
-		}, &i18n.Message{
-			ID:    "EscapeStaging",
-			Other: `ga terug naar het bestanden paneel`,
-		}, &i18n.Message{
-			ID:    "CantFindHunks",
-			Other: `Kan geen hunks vinden in deze patch`,
-		}, &i18n.Message{
-			ID:    "CantFindHunk",
-			Other: `Kan geen hunk vinden`,
-		}, &i18n.Message{
-			ID:    "RebasingTitle",
-			Other: "Rebasing",
-		}, &i18n.Message{
-			ID:    "MergingTitle",
-			Other: "Merging",
-		}, &i18n.Message{
-			ID:    "ConfirmRebase",
-			Other: "Are you sure you want to rebase {{.checkedOutBranch}} onto {{.selectedBranch}}?",
-		}, &i18n.Message{
-			ID:    "ConfirmMerge",
-			Other: "Are you sure you want to merge {{.selectedBranch}} into {{.checkedOutBranch}}?",
-		}, &i18n.Message{
-			ID:    "FwdNoUpstream",
-			Other: "Cannot fast-forward a branch with no upstream",
-		}, &i18n.Message{
-			ID:    "ErrorOccurred",
-			Other: "An error occurred! Please create an issue at https://github.com/jesseduffield/lazygit/issues",
-		}, &i18n.Message{
-			ID:    "FwdCommitsToPush",
-			Other: "Cannot fast-forward a branch with commits to push",
-		}, &i18n.Message{
-			ID:    "MainTitle",
-			Other: "Main",
-		}, &i18n.Message{
-			ID:    "NormalTitle",
-			Other: "Normal",
-		}, &i18n.Message{
-			ID:    "softReset",
-			Other: "soft reset to last commit",
-		}, &i18n.Message{
-			ID:    "SoftReset",
-			Other: "Soft reset",
-		}, &i18n.Message{
-			ID:    "ConfirmSoftReset",
-			Other: "Are you sure you want to `reset --soft HEAD^`? The changes in your topmost commit will be placed in your working tree",
-		}, &i18n.Message{
-			ID:    "CantRebaseOntoSelf",
-			Other: "You cannot rebase a branch onto itself",
-		}, &i18n.Message{
-			ID:    "SureSquashThisCommit",
-			Other: "Are you sure you want to squash this commit into the commit below?",
-		}, &i18n.Message{
-			ID:    "Squash",
-			Other: "Squash",
-		}, &i18n.Message{
-			ID:    "pickCommit",
-			Other: "pick commit (when mid-rebase)",
-		}, &i18n.Message{
-			ID:    "revertCommit",
-			Other: "revert commit",
-		}, &i18n.Message{
-			ID:    "deleteCommit",
-			Other: "delete commit",
-		}, &i18n.Message{
-			ID:    "moveDownCommit",
-			Other: "move commit down one",
-		}, &i18n.Message{
-			ID:    "moveUpCommit",
-			Other: "move commit up one",
-		}, &i18n.Message{
-			ID:    "editCommit",
-			Other: "edit commit",
-		}, &i18n.Message{
-			ID:    "amendToCommit",
-			Other: "amend commit with staged changes",
-		}, &i18n.Message{
-			ID:    "FoundConflicts",
-			Other: "Damn, conflicts! To abort press 'esc', otherwise press 'enter'",
-		}, &i18n.Message{
-			ID:    "FoundConflictsTitle",
-			Other: "Auto-merge failed",
-		}, &i18n.Message{
-			ID:    "Undo",
-			Other: "undo",
-		}, &i18n.Message{
-			ID:    "PickHunk",
-			Other: "pick hunk",
-		}, &i18n.Message{
-			ID:    "PickBothHunks",
-			Other: "pick both hunks",
-		}, &i18n.Message{
-			ID:    "ViewMergeRebaseOptions",
-			Other: "view merge/rebase options",
-		}, &i18n.Message{
-			ID:    "NotMergingOrRebasing",
-			Other: "You are currently neither rebasing nor merging",
-		}, &i18n.Message{
-			ID:    "RecentRepos",
-			Other: "recent repositories",
-		}, &i18n.Message{
-			ID:    "MergeOptionsTitle",
-			Other: "Merge Options",
-		}, &i18n.Message{
-			ID:    "RebaseOptionsTitle",
-			Other: "Rebase Options",
-		}, &i18n.Message{
-			ID:    "ConflictsResolved",
-			Other: "all merge conflicts resolved. Continue?",
-		}, &i18n.Message{
-			ID:    "NoRoom",
-			Other: "Not enough room",
-		}, &i18n.Message{
-			ID:    "YouAreHere",
-			Other: "YOU ARE HERE",
-		}, &i18n.Message{
-			ID:    "rewordNotSupported",
-			Other: "rewording commits while interactively rebasing is not currently supported",
-		}, &i18n.Message{
-			ID:    "cherryPickCopy",
-			Other: "copy commit (cherry-pick)",
-		}, &i18n.Message{
-			ID:    "cherryPickCopyRange",
-			Other: "copy commit range (cherry-pick)",
-		}, &i18n.Message{
-			ID:    "pasteCommits",
-			Other: "paste commits (cherry-pick)",
-		}, &i18n.Message{
-			ID:    "SureCherryPick",
-			Other: "Are you sure you want to cherry-pick the copied commits onto this branch?",
-		}, &i18n.Message{
-			ID:    "CherryPick",
-			Other: "Cherry-Pick",
-		}, &i18n.Message{
-			ID:    "CannotRebaseOntoFirstCommit",
-			Other: "You cannot interactive rebase onto the first commit",
-		}, &i18n.Message{
-			ID:    "Donate",
-			Other: "Donate",
-		}, &i18n.Message{
-			ID:    "PrevLine",
-			Other: "select previous line",
-		}, &i18n.Message{
-			ID:    "NextLine",
-			Other: "select next line",
-		}, &i18n.Message{
-			ID:    "PrevHunk",
-			Other: "select previous hunk",
-		}, &i18n.Message{
-			ID:    "NextHunk",
-			Other: "select next hunk",
-		}, &i18n.Message{
-			ID:    "PrevConflict",
-			Other: "select previous conflict",
-		}, &i18n.Message{
-			ID:    "NextConflict",
-			Other: "select next conflict",
-		}, &i18n.Message{
-			ID:    "SelectTop",
-			Other: "select top hunk",
-		}, &i18n.Message{
-			ID:    "SelectBottom",
-			Other: "select bottom hunk",
-		}, &i18n.Message{
-			ID:    "ScrollDown",
-			Other: "scroll down",
-		}, &i18n.Message{
-			ID:    "ScrollUp",
-			Other: "scroll up",
-		}, &i18n.Message{
-			ID:    "AmendCommitTitle",
-			Other: "Amend Commit",
-		}, &i18n.Message{
-			ID:    "AmendCommitPrompt",
-			Other: "Are you sure you want to amend this commit with your staged files?",
-		}, &i18n.Message{
-			ID:    "DeleteCommitTitle",
-			Other: "Delete Commit",
-		}, &i18n.Message{
-			ID:    "DeleteCommitPrompt",
-			Other: "Are you sure you want to delete this commit?",
-		}, &i18n.Message{
-			ID:    "SquashingStatus",
-			Other: "squashing",
-		}, &i18n.Message{
-			ID:    "FixingStatus",
-			Other: "fixing up",
-		}, &i18n.Message{
-			ID:    "DeletingStatus",
-			Other: "deleting",
-		}, &i18n.Message{
-			ID:    "MovingStatus",
-			Other: "moving",
-		}, &i18n.Message{
-			ID:    "RebasingStatus",
-			Other: "rebasing",
-		}, &i18n.Message{
-			ID:    "AmendingStatus",
-			Other: "amending",
-		}, &i18n.Message{
-			ID:    "CherryPickingStatus",
-			Other: "cherry-picking",
 		},
 	)
 }

pkg/i18n/english.go

@@ -15,18 +15,15 @@ import (
 	"golang.org/x/text/language"
 )
 
-func addEnglish(i18nObject *i18n.Bundle) error {
+func addEnglish(i18nObject *i18n.Bundle) {
 
-	return i18nObject.AddMessages(language.English,
+	i18nObject.AddMessages(language.English,
 		&i18n.Message{
 			ID:    "NotEnoughSpace",
 			Other: "Not enough space to render panels",
 		}, &i18n.Message{
 			ID:    "DiffTitle",
 			Other: "Diff",
-		}, &i18n.Message{
-			ID:    "LogTitle",
-			Other: "Log",
 		}, &i18n.Message{
 			ID:    "FilesTitle",
 			Other: "Files",
@@ -39,72 +36,21 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "StashTitle",
 			Other: "Stash",
-		}, &i18n.Message{
-			ID:    "StagingMainTitle",
-			Other: `Stage Lines/Hunks`,
-		}, &i18n.Message{
-			ID:    "MergingMainTitle",
-			Other: "Resolve merge conflicts",
-		}, &i18n.Message{
-			ID:    "MainTitle",
-			Other: "Main",
-		}, &i18n.Message{
-			ID:    "StagingTitle",
-			Other: "Staging",
-		}, &i18n.Message{
-			ID:    "MergingTitle",
-			Other: "Merging",
-		}, &i18n.Message{
-			ID:    "NormalTitle",
-			Other: "Normal",
 		}, &i18n.Message{
 			ID:    "CommitMessage",
 			Other: "Commit message",
-		}, &i18n.Message{
-			ID:    "CredentialsUsername",
-			Other: "Username",
-		}, &i18n.Message{
-			ID:    "CredentialsPassword",
-			Other: "Password",
-		}, &i18n.Message{
-			ID:    "PassUnameWrong",
-			Other: "Password and/or username wrong",
 		}, &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? Afterwards, you can change commit message from the commits panel.",
-		}, &i18n.Message{
-			ID:    "NoCommitToAmend",
-			Other: "There's no commit to amend.",
-		}, &i18n.Message{
-			ID:    "CommitChangesWithEditor",
-			Other: "commit changes using git editor",
 		}, &i18n.Message{
 			ID:    "StatusTitle",
 			Other: "Status",
-		}, &i18n.Message{
-			ID:    "GlobalTitle",
-			Other: "Global",
 		}, &i18n.Message{
 			ID:    "navigate",
 			Other: "navigate",
-		}, &i18n.Message{
-			ID:    "menu",
-			Other: "menu",
-		}, &i18n.Message{
-			ID:    "execute",
-			Other: "execute",
 		}, &i18n.Message{
 			ID:    "stashFiles",
 			Other: "stash files",
-		}, &i18n.Message{
-			ID:    "softReset",
-			Other: "soft reset to last commit",
 		}, &i18n.Message{
 			ID:    "open",
 			Other: "open",
@@ -117,18 +63,9 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "toggleStaged",
 			Other: "toggle staged",
-		}, &i18n.Message{
-			ID:    "toggleStagedAll",
-			Other: "stage/unstage all",
 		}, &i18n.Message{
 			ID:    "refresh",
 			Other: "refresh",
-		}, &i18n.Message{
-			ID:    "push",
-			Other: "push",
-		}, &i18n.Message{
-			ID:    "pull",
-			Other: "pull",
 		}, &i18n.Message{
 			ID:    "addPatch",
 			Other: "add patch",
@@ -165,30 +102,18 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "NoFilesDisplay",
 			Other: "No file to display",
-		}, &i18n.Message{
-			ID:    "NotAFile",
-			Other: "Not a file",
 		}, &i18n.Message{
 			ID:    "PullWait",
 			Other: "Pulling...",
 		}, &i18n.Message{
 			ID:    "PushWait",
 			Other: "Pushing...",
-		}, &i18n.Message{
-			ID:    "FetchWait",
-			Other: "Fetching...",
 		}, &i18n.Message{
 			ID:    "FileNoMergeCons",
-			Other: "This file has no inline merge conflicts",
+			Other: "This file has no merge conflicts",
 		}, &i18n.Message{
 			ID:    "SureResetHardHead",
-			Other: "Are you sure you want to `reset --hard HEAD` and `clean -fd`? You may lose changes",
-		}, &i18n.Message{
-			ID:    "SoftReset",
-			Other: "Soft reset",
-		}, &i18n.Message{
-			ID:    "ConfirmSoftReset",
-			Other: "Are you sure you want to `reset --soft HEAD^`? The changes in your topmost commit will be placed in your working tree",
+			Other: "Are you sure you want `reset --hard HEAD`? You may lose changes",
 		}, &i18n.Message{
 			ID:    "SureTo",
 			Other: "Are you sure you want to {{.deleteVerb}} {{.fileName}} (you will lose your changes)?",
@@ -215,16 +140,7 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 			Other: "Delete Branch",
 		}, &i18n.Message{
 			ID:    "DeleteBranchMessage",
-			Other: "Are you sure you want to delete the branch {{.selectedBranchName}}?",
-		}, &i18n.Message{
-			ID:    "ForceDeleteBranchMessage",
-			Other: "{{.selectedBranchName}} is not fully merged. Are you sure you want to delete it?",
-		}, &i18n.Message{
-			ID:    "rebaseBranch",
-			Other: "rebase branch",
-		}, &i18n.Message{
-			ID:    "CantRebaseOntoSelf",
-			Other: "You cannot rebase a branch onto itself",
+			Other: "Are you sure you want delete the branch {{.selectedBranchName}} ?",
 		}, &i18n.Message{
 			ID:    "CantMergeBranchIntoItself",
 			Other: "You cannot merge a branch into itself",
@@ -243,9 +159,6 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "deleteBranch",
 			Other: "delete branch",
-		}, &i18n.Message{
-			ID:    "forceDeleteBranch",
-			Other: "delete branch (force)",
 		}, &i18n.Message{
 			ID:    "NoBranchesThisRepo",
 			Other: "No branches for this repo",
@@ -258,9 +171,6 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "CloseConfirm",
 			Other: "{{.keyBindClose}}: close, {{.keyBindConfirm}}: confirm",
-		}, &i18n.Message{
-			ID:    "close",
-			Other: "close",
 		}, &i18n.Message{
 			ID:    "SureResetThisCommit",
 			Other: "Are you sure you want to reset to this commit?",
@@ -296,43 +206,13 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 			Other: "Fixup",
 		}, &i18n.Message{
 			ID:    "SureFixupThisCommit",
-			Other: "Are you sure you want to 'fixup' this commit? It will be merged into the commit below",
-		}, &i18n.Message{
-			ID:    "SureSquashThisCommit",
-			Other: "Are you sure you want to squash this commit into the commit below?",
-		}, &i18n.Message{
-			ID:    "Squash",
-			Other: "Squash",
-		}, &i18n.Message{
-			ID:    "pickCommit",
-			Other: "pick commit (when mid-rebase)",
-		}, &i18n.Message{
-			ID:    "revertCommit",
-			Other: "revert commit",
+			Other: "Are you sure you want to fixup this commit? The commit beneath will be squashed up into this one",
 		}, &i18n.Message{
 			ID:    "OnlyRenameTopCommit",
-			Other: "Can only reword topmost commit from within lazygit. Use shift+R instead",
+			Other: "Can only rename topmost commit",
 		}, &i18n.Message{
-			ID:    "renameCommit",
-			Other: "reword commit",
-		}, &i18n.Message{
-			ID:    "deleteCommit",
-			Other: "delete commit",
-		}, &i18n.Message{
-			ID:    "moveDownCommit",
-			Other: "move commit down one",
-		}, &i18n.Message{
-			ID:    "moveUpCommit",
-			Other: "move commit up one",
-		}, &i18n.Message{
-			ID:    "editCommit",
-			Other: "edit commit",
-		}, &i18n.Message{
-			ID:    "amendToCommit",
-			Other: "amend commit with staged changes",
-		}, &i18n.Message{
-			ID:    "renameCommitEditor",
-			Other: "rename commit with editor",
+			ID:    "RenameCommit",
+			Other: "Rename Commit",
 		}, &i18n.Message{
 			ID:    "PotentialErrInGetselectedCommit",
 			Other: "potential error in getSelected Commit (mismatched ui and state)",
@@ -396,6 +276,9 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "NoViewMachingNewLineFocusedSwitchStatement",
 			Other: "No view matching newLineFocused switch statement",
+		}, &i18n.Message{
+			ID:    "settingPreviewsViewTo",
+			Other: "setting previous view to: {{.oldViewName}}",
 		}, &i18n.Message{
 			ID:    "newFocusedViewIs",
 			Other: "new focused view is {{.newFocusedView}}",
@@ -417,255 +300,6 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "EditConfig",
 			Other: "edit config file",
-		}, &i18n.Message{
-			ID:    "ForcePush",
-			Other: "Force push",
-		}, &i18n.Message{
-			ID:    "ForcePushPrompt",
-			Other: "Your branch has diverged from the remote branch. Press 'esc' to cancel, or 'enter' to force push.",
-		}, &i18n.Message{
-			ID:    "checkForUpdate",
-			Other: "check for update",
-		}, &i18n.Message{
-			ID:    "CheckingForUpdates",
-			Other: "Checking for updates...",
-		}, &i18n.Message{
-			ID:    "OnLatestVersionErr",
-			Other: "You already have the latest version",
-		}, &i18n.Message{
-			ID:    "MajorVersionErr",
-			Other: "New version ({{.newVersion}}) has non-backwards compatible changes compared to the current version ({{.currentVersion}})",
-		}, &i18n.Message{
-			ID:    "CouldNotFindBinaryErr",
-			Other: "Could not find any binary at {{.url}}",
-		}, &i18n.Message{
-			ID:    "AnonymousReportingTitle",
-			Other: "Help make lazygit better",
-		}, &i18n.Message{
-			ID:    "AnonymousReportingPrompt",
-			Other: "Would you like to enable anonymous reporting data to help improve lazygit? (enter/esc)",
-		}, &i18n.Message{
-			ID:    "GitconfigParseErr",
-			Other: `Gogit failed to parse your gitconfig file due to the presence of unquoted '\' characters. Removing these should fix the issue.`,
-		}, &i18n.Message{
-			ID:    "removeFile",
-			Other: `delete if untracked / checkout if tracked`,
-		}, &i18n.Message{
-			ID:    "editFile",
-			Other: `edit file`,
-		}, &i18n.Message{
-			ID:    "openFile",
-			Other: `open file`,
-		}, &i18n.Message{
-			ID:    "ignoreFile",
-			Other: `add to .gitignore`,
-		}, &i18n.Message{
-			ID:    "refreshFiles",
-			Other: `refresh files`,
-		}, &i18n.Message{
-			ID:    "resetHard",
-			Other: `reset hard and remove untracked files`,
-		}, &i18n.Message{
-			ID:    "mergeIntoCurrentBranch",
-			Other: `merge into currently checked out branch`,
-		}, &i18n.Message{
-			ID:    "ConfirmQuit",
-			Other: `Are you sure you want to quit?`,
-		}, &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.`,
-		}, &i18n.Message{
-			ID:    "fetch",
-			Other: `fetch`,
-		}, &i18n.Message{
-			ID:    "NoAutomaticGitFetchTitle",
-			Other: `No automatic git fetch`,
-		}, &i18n.Message{
-			ID:    "NoAutomaticGitFetchBody",
-			Other: `Lazygit can't use "git fetch" in a private repo; use 'f' in the files panel to run "git fetch" manually`,
-		}, &i18n.Message{
-			ID:    "StageLines",
-			Other: `stage individual hunks/lines`,
-		}, &i18n.Message{
-			ID:    "FileStagingRequirements",
-			Other: `Can only stage individual lines for tracked files with unstaged changes`,
-		}, &i18n.Message{
-			ID:    "StageHunk",
-			Other: `stage hunk`,
-		}, &i18n.Message{
-			ID:    "StageLine",
-			Other: `stage line`,
-		}, &i18n.Message{
-			ID:    "EscapeStaging",
-			Other: `return to files panel`,
-		}, &i18n.Message{
-			ID:    "CantFindHunks",
-			Other: `Could not find any hunks in this patch`,
-		}, &i18n.Message{
-			ID:    "CantFindHunk",
-			Other: `Could not find hunk`,
-		}, &i18n.Message{
-			ID:    "FastForward",
-			Other: `fast-forward this branch from its upstream`,
-		}, &i18n.Message{
-			ID:    "Fetching",
-			Other: "fetching and fast-forwarding {{.from}} -> {{.to}} ...",
-		}, &i18n.Message{
-			ID:    "FoundConflicts",
-			Other: "Damn, conflicts! To abort press 'esc', otherwise press 'enter'",
-		}, &i18n.Message{
-			ID:    "FoundConflictsTitle",
-			Other: "Auto-merge failed",
-		}, &i18n.Message{
-			ID:    "Undo",
-			Other: "undo",
-		}, &i18n.Message{
-			ID:    "PickHunk",
-			Other: "pick hunk",
-		}, &i18n.Message{
-			ID:    "PickBothHunks",
-			Other: "pick both hunks",
-		}, &i18n.Message{
-			ID:    "ViewMergeRebaseOptions",
-			Other: "view merge/rebase options",
-		}, &i18n.Message{
-			ID:    "NotMergingOrRebasing",
-			Other: "You are currently neither rebasing nor merging",
-		}, &i18n.Message{
-			ID:    "RecentRepos",
-			Other: "recent repositories",
-		}, &i18n.Message{
-			ID:    "MergeOptionsTitle",
-			Other: "Merge Options",
-		}, &i18n.Message{
-			ID:    "RebaseOptionsTitle",
-			Other: "Rebase Options",
-		}, &i18n.Message{
-			ID:    "ConflictsResolved",
-			Other: "all merge conflicts resolved. Continue?",
-		}, &i18n.Message{
-			ID:    "RebasingTitle",
-			Other: "Rebasing",
-		}, &i18n.Message{
-			ID:    "MergingTitle",
-			Other: "Merging",
-		}, &i18n.Message{
-			ID:    "ConfirmRebase",
-			Other: "Are you sure you want to rebase {{.checkedOutBranch}} onto {{.selectedBranch}}?",
-		}, &i18n.Message{
-			ID:    "ConfirmMerge",
-			Other: "Are you sure you want to merge {{.selectedBranch}} into {{.checkedOutBranch}}?",
-		}, &i18n.Message{}, &i18n.Message{
-			ID:    "FwdNoUpstream",
-			Other: "Cannot fast-forward a branch with no upstream",
-		}, &i18n.Message{
-			ID:    "FwdCommitsToPush",
-			Other: "Cannot fast-forward a branch with commits to push",
-		}, &i18n.Message{
-			ID:    "ErrorOccurred",
-			Other: "An error occurred! Please create an issue at https://github.com/jesseduffield/lazygit/issues",
-		}, &i18n.Message{
-			ID:    "NoRoom",
-			Other: "Not enough room",
-		}, &i18n.Message{
-			ID:    "YouAreHere",
-			Other: "YOU ARE HERE",
-		}, &i18n.Message{
-			ID:    "rewordNotSupported",
-			Other: "rewording commits while interactively rebasing is not currently supported",
-		}, &i18n.Message{
-			ID:    "cherryPickCopy",
-			Other: "copy commit (cherry-pick)",
-		}, &i18n.Message{
-			ID:    "cherryPickCopyRange",
-			Other: "copy commit range (cherry-pick)",
-		}, &i18n.Message{
-			ID:    "pasteCommits",
-			Other: "paste commits (cherry-pick)",
-		}, &i18n.Message{
-			ID:    "SureCherryPick",
-			Other: "Are you sure you want to cherry-pick the copied commits onto this branch?",
-		}, &i18n.Message{
-			ID:    "CherryPick",
-			Other: "Cherry-Pick",
-		}, &i18n.Message{
-			ID:    "CannotRebaseOntoFirstCommit",
-			Other: "You cannot interactive rebase onto the first commit",
-		}, &i18n.Message{
-			ID:    "Donate",
-			Other: "Donate",
-		}, &i18n.Message{
-			ID:    "PrevLine",
-			Other: "select previous line",
-		}, &i18n.Message{
-			ID:    "NextLine",
-			Other: "select next line",
-		}, &i18n.Message{
-			ID:    "PrevHunk",
-			Other: "select previous hunk",
-		}, &i18n.Message{
-			ID:    "NextHunk",
-			Other: "select next hunk",
-		}, &i18n.Message{
-			ID:    "PrevConflict",
-			Other: "select previous conflict",
-		}, &i18n.Message{
-			ID:    "NextConflict",
-			Other: "select next conflict",
-		}, &i18n.Message{
-			ID:    "SelectTop",
-			Other: "select top hunk",
-		}, &i18n.Message{
-			ID:    "SelectBottom",
-			Other: "select bottom hunk",
-		}, &i18n.Message{
-			ID:    "ScrollDown",
-			Other: "scroll down",
-		}, &i18n.Message{
-			ID:    "ScrollUp",
-			Other: "scroll up",
-		}, &i18n.Message{
-			ID:    "AmendCommitTitle",
-			Other: "Amend Commit",
-		}, &i18n.Message{
-			ID:    "AmendCommitPrompt",
-			Other: "Are you sure you want to amend this commit with your staged files?",
-		}, &i18n.Message{
-			ID:    "DeleteCommitTitle",
-			Other: "Delete Commit",
-		}, &i18n.Message{
-			ID:    "DeleteCommitPrompt",
-			Other: "Are you sure you want to delete this commit?",
-		}, &i18n.Message{
-			ID:    "SquashingStatus",
-			Other: "squashing",
-		}, &i18n.Message{
-			ID:    "FixingStatus",
-			Other: "fixing up",
-		}, &i18n.Message{
-			ID:    "DeletingStatus",
-			Other: "deleting",
-		}, &i18n.Message{
-			ID:    "MovingStatus",
-			Other: "moving",
-		}, &i18n.Message{
-			ID:    "RebasingStatus",
-			Other: "rebasing",
-		}, &i18n.Message{
-			ID:    "AmendingStatus",
-			Other: "amending",
-		}, &i18n.Message{
-			ID:    "CherryPickingStatus",
-			Other: "cherry-picking",
 		},
 	)
 }

pkg/i18n/i18n.go

@@ -1,9 +1,9 @@
 package i18n
 
 import (
+	"github.com/Sirupsen/logrus"
 	"github.com/cloudfoundry/jibber_jabber"
 	"github.com/nicksnyder/go-i18n/v2/i18n"
-	"github.com/sirupsen/logrus"
 	"golang.org/x/text/language"
 )
 
@@ -14,16 +14,34 @@ type Teml map[string]interface{}
 type Localizer struct {
 	i18nLocalizer *i18n.Localizer
 	language      string
-	Log           *logrus.Entry
+	Log           *logrus.Logger
 }
 
 // NewLocalizer creates a new Localizer
-func NewLocalizer(log *logrus.Entry) *Localizer {
-	userLang := detectLanguage(jibber_jabber.DetectLanguage)
+func NewLocalizer(log *logrus.Logger) (*Localizer, error) {
 
+	// detect the user's language
+	userLang, err := jibber_jabber.DetectLanguage()
+	if err != nil {
+		return nil, err
+	}
 	log.Info("language: " + userLang)
 
-	return setupLocalizer(log, userLang)
+	// create a i18n bundle that can be used to add translations and other things
+	i18nBundle := &i18n.Bundle{DefaultLanguage: language.English}
+
+	addBundles(i18nBundle)
+
+	// return the new localizer that can be used to translate text
+	i18nLocalizer := i18n.NewLocalizer(i18nBundle, userLang)
+
+	localizer := &Localizer{
+		i18nLocalizer: i18nLocalizer,
+		language:      userLang,
+		Log:           log,
+	}
+
+	return localizer, nil
 }
 
 // Localize handels the translations
@@ -60,43 +78,7 @@ func (l *Localizer) GetLanguage() string {
 }
 
 // add translation file(s)
-func addBundles(log *logrus.Entry, i18nBundle *i18n.Bundle) {
-	fs := []func(*i18n.Bundle) error{
-		addPolish,
-		addDutch,
-		addEnglish,
-	}
-
-	for _, f := range fs {
-		if err := f(i18nBundle); err != nil {
-			log.Fatal(err)
-
-		}
-	}
-}
-
-// detectLanguage extracts user language from environment
-func detectLanguage(langDetector func() (string, error)) string {
-	if userLang, err := langDetector(); err == nil {
-		return userLang
-	}
-
-	return "C"
-}
-
-// setupLocalizer creates a new localizer using given userLang
-func setupLocalizer(log *logrus.Entry, userLang string) *Localizer {
-	// create a i18n bundle that can be used to add translations and other things
-	i18nBundle := &i18n.Bundle{DefaultLanguage: language.English}
-
-	addBundles(log, i18nBundle)
-
-	// return the new localizer that can be used to translate text
-	i18nLocalizer := i18n.NewLocalizer(i18nBundle, userLang)
-
-	return &Localizer{
-		i18nLocalizer: i18nLocalizer,
-		language:      userLang,
-		Log:           log,
-	}
+func addBundles(i18nBundle *i18n.Bundle) {
+	addDutch(i18nBundle)
+	addEnglish(i18nBundle)
 }

pkg/i18n/i18n_test.go

@@ -1,91 +0,0 @@
-package i18n
-
-import (
-	"fmt"
-	"io/ioutil"
-	"testing"
-
-	"github.com/nicksnyder/go-i18n/v2/i18n"
-
-	"github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/assert"
-)
-
-func getDummyLog() *logrus.Entry {
-	log := logrus.New()
-	log.Out = ioutil.Discard
-	return log.WithField("test", "test")
-}
-
-// TestNewLocalizer is a function.
-func TestNewLocalizer(t *testing.T) {
-	assert.NotNil(t, NewLocalizer(getDummyLog()))
-}
-
-// TestDetectLanguage is a function.
-func TestDetectLanguage(t *testing.T) {
-	type scenario struct {
-		langDetector func() (string, error)
-		expected     string
-	}
-
-	scenarios := []scenario{
-		{
-			func() (string, error) {
-				return "", fmt.Errorf("An error occurred")
-			},
-			"C",
-		},
-		{
-			func() (string, error) {
-				return "en", nil
-			},
-			"en",
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, detectLanguage(s.langDetector))
-	}
-}
-
-// TestLocalizer is a function.
-func TestLocalizer(t *testing.T) {
-	type scenario struct {
-		userLang string
-		test     func(*Localizer)
-	}
-
-	scenarios := []scenario{
-		{
-			"C",
-			func(l *Localizer) {
-				assert.EqualValues(t, "C", l.GetLanguage())
-				assert.Equal(t, "Diff", l.Localize(&i18n.LocalizeConfig{
-					DefaultMessage: &i18n.Message{
-						ID: "DiffTitle",
-					},
-				}))
-				assert.Equal(t, "Diff", l.SLocalize("DiffTitle"))
-				assert.Equal(t, "Are you sure you want to delete the branch test?", l.TemplateLocalize("DeleteBranchMessage", Teml{"selectedBranchName": "test"}))
-			},
-		},
-		{
-			"nl",
-			func(l *Localizer) {
-				assert.EqualValues(t, "nl", l.GetLanguage())
-				assert.Equal(t, "Diff", l.Localize(&i18n.LocalizeConfig{
-					DefaultMessage: &i18n.Message{
-						ID: "DiffTitle",
-					},
-				}))
-				assert.Equal(t, "Diff", l.SLocalize("DiffTitle"))
-				assert.Equal(t, "Weet je zeker dat je branch test wilt verwijderen?", l.TemplateLocalize("DeleteBranchMessage", Teml{"selectedBranchName": "test"}))
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		s.test(setupLocalizer(getDummyLog(), s.userLang))
-	}
-}

pkg/i18n/polish.go

@@ -1,631 +0,0 @@
-package i18n
-
-import (
-	"github.com/nicksnyder/go-i18n/v2/i18n"
-	"golang.org/x/text/language"
-)
-
-func addPolish(i18nObject *i18n.Bundle) error {
-
-	return i18nObject.AddMessages(language.Polish,
-		&i18n.Message{
-			ID:    "NotEnoughSpace",
-			Other: "Za mało miejsca do wyświetlenia paneli",
-		}, &i18n.Message{
-			ID:    "DiffTitle",
-			Other: "Różnice",
-		}, &i18n.Message{
-			ID:    "LogTitle",
-			Other: "Log",
-		}, &i18n.Message{
-			ID:    "FilesTitle",
-			Other: "Pliki",
-		}, &i18n.Message{
-			ID:    "BranchesTitle",
-			Other: "Gałęzie",
-		}, &i18n.Message{
-			ID:    "CommitsTitle",
-			Other: "Commity",
-		}, &i18n.Message{
-			ID:    "StashTitle",
-			Other: "Schowek",
-		}, &i18n.Message{
-			ID:    "StagingMainTitle",
-			Other: `Stage Lines/Hunks`,
-		}, &i18n.Message{
-			ID:    "MergingMainTitle",
-			Other: "Resolve merge conflicts",
-		}, &i18n.Message{
-			ID:    "CommitMessage",
-			Other: "Wiadomość commita",
-		}, &i18n.Message{
-			ID:    "CredentialsUsername",
-			Other: "Username",
-		}, &i18n.Message{
-			ID:    "CredentialsPassword",
-			Other: "Password",
-		}, &i18n.Message{
-			ID:    "PassUnameWrong",
-			Other: "Password and/or username wrong",
-		}, &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",
-		}, &i18n.Message{
-			ID:    "StatusTitle",
-			Other: "Status",
-		}, &i18n.Message{
-			ID:    "GlobalTitle",
-			Other: "Globalne",
-		}, &i18n.Message{
-			ID:    "navigate",
-			Other: "nawiguj",
-		}, &i18n.Message{
-			ID:    "menu",
-			Other: "menu",
-		}, &i18n.Message{
-			ID:    "execute",
-			Other: "wykonaj",
-		}, &i18n.Message{
-			ID:    "stashFiles",
-			Other: "przechowaj pliki",
-		}, &i18n.Message{
-			ID:    "open",
-			Other: "otwórz",
-		}, &i18n.Message{
-			ID:    "ignore",
-			Other: "ignoruj",
-		}, &i18n.Message{
-			ID:    "delete",
-			Other: "usuń",
-		}, &i18n.Message{
-			ID:    "toggleStaged",
-			Other: "przełącz zatwierdzenie",
-		}, &i18n.Message{
-			ID:    "toggleStagedAll",
-			Other: "przełącz wszystkie zatwierdzenia",
-		}, &i18n.Message{
-			ID:    "refresh",
-			Other: "odśwież",
-		}, &i18n.Message{
-			ID:    "addPatch",
-			Other: "dodaj łatkę",
-		}, &i18n.Message{
-			ID:    "edit",
-			Other: "edytuj",
-		}, &i18n.Message{
-			ID:    "scroll",
-			Other: "przewiń",
-		}, &i18n.Message{
-			ID:    "abortMerge",
-			Other: "o scalaniu",
-		}, &i18n.Message{
-			ID:    "resolveMergeConflicts",
-			Other: "rozwiąż konflikty scalania",
-		}, &i18n.Message{
-			ID:    "checkout",
-			Other: "przełącz",
-		}, &i18n.Message{
-			ID:    "NoChangedFiles",
-			Other: "Brak zmienionych plików",
-		}, &i18n.Message{
-			ID:    "FileHasNoUnstagedChanges",
-			Other: "Plik nie zawiera żadnych nieopublikowanych zmian do dodania",
-		}, &i18n.Message{
-			ID:    "CannotGitAdd",
-			Other: "Nie można git add --patch nieśledzonych plików",
-		}, &i18n.Message{
-			ID:    "CantIgnoreTrackFiles",
-			Other: "Nie można zignorować nieśledzonych plików",
-		}, &i18n.Message{
-			ID:    "NoStagedFilesToCommit",
-			Other: "Brak zatwierdzonych plików do commita",
-		}, &i18n.Message{
-			ID:    "NoFilesDisplay",
-			Other: "Brak pliku do wyświetlenia",
-		}, &i18n.Message{
-			ID:    "PullWait",
-			Other: "Wciąganie zmian...",
-		}, &i18n.Message{
-			ID:    "PushWait",
-			Other: "Wypychanie zmian...",
-		}, &i18n.Message{
-			ID:    "FetchWait",
-			Other: "Fetching...",
-		}, &i18n.Message{
-			ID:    "FileNoMergeCons",
-			Other: "Ten plik nie powoduje konfliktów scalania",
-		}, &i18n.Message{
-			ID:    "SureResetHardHead",
-			Other: "Jesteś pewny, że chcesz wykonać `reset --hard HEAD` i `clean -fd`? Możesz stracić wprowadzone zmiany",
-		}, &i18n.Message{
-			ID:    "SureTo",
-			Other: "Jesteś pewny, że chcesz {{.deleteVerb}} {{.fileName}} (stracisz swoje wprowadzone zmiany)?",
-		}, &i18n.Message{
-			ID:    "AlreadyCheckedOutBranch",
-			Other: "Już przęłączono na tą gałąź",
-		}, &i18n.Message{
-			ID:    "SureForceCheckout",
-			Other: "Jesteś pewny, że chcesz wymusić przełączenie? Stracisz wszystkie lokalne zmiany",
-		}, &i18n.Message{
-			ID:    "ForceCheckoutBranch",
-			Other: "Wymuś przełączenie gałęzi",
-		}, &i18n.Message{
-			ID:    "BranchName",
-			Other: "Nazwa gałęzi",
-		}, &i18n.Message{
-			ID:    "NewBranchNameBranchOff",
-			Other: "Nazwa nowej gałęzi (gałąź na bazie {{.branchName}})",
-		}, &i18n.Message{
-			ID:    "CantDeleteCheckOutBranch",
-			Other: "Nie możesz usunąć obecnej przełączonej gałęzi!",
-		}, &i18n.Message{
-			ID:    "DeleteBranch",
-			Other: "Usuń gałąź",
-		}, &i18n.Message{
-			ID:    "DeleteBranchMessage",
-			Other: "Jesteś pewien, że chcesz usunąć gałąź {{.selectedBranchName}} ?",
-		}, &i18n.Message{
-			ID:    "ForceDeleteBranchMessage",
-			Other: "Na pewno wymusić usunięcie gałęzi {{.selectedBranchName}}?",
-		}, &i18n.Message{
-			ID:    "rebaseBranch",
-			Other: "rebase branch",
-		}, &i18n.Message{
-			ID:    "CantRebaseOntoSelf",
-			Other: "You cannot rebase a branch onto itself",
-		}, &i18n.Message{
-			ID:    "CantMergeBranchIntoItself",
-			Other: "Nie możesz scalić gałęzi do samej siebie",
-		}, &i18n.Message{
-			ID:    "forceCheckout",
-			Other: "wymuś przełączenie",
-		}, &i18n.Message{
-			ID:    "merge",
-			Other: "scal",
-		}, &i18n.Message{
-			ID:    "checkoutByName",
-			Other: "przełącz używając nazwy",
-		}, &i18n.Message{
-			ID:    "newBranch",
-			Other: "nowa gałąź",
-		}, &i18n.Message{
-			ID:    "deleteBranch",
-			Other: "usuń gałąź",
-		}, &i18n.Message{
-			ID:    "forceDeleteBranch",
-			Other: "usuń gałąź (wymuś)",
-		}, &i18n.Message{
-			ID:    "NoBranchesThisRepo",
-			Other: "Brak gałęzi dla tego repozytorium",
-		}, &i18n.Message{
-			ID:    "NoTrackingThisBranch",
-			Other: "Brak śledzenia dla tej gałęzi",
-		}, &i18n.Message{
-			ID:    "CommitWithoutMessageErr",
-			Other: "Nie możesz commitować bez podania wiadomości",
-		}, &i18n.Message{
-			ID:    "CloseConfirm",
-			Other: "{{.keyBindClose}}: zamknij, {{.keyBindConfirm}}: potwierdź",
-		}, &i18n.Message{
-			ID:    "close",
-			Other: "zamknij",
-		}, &i18n.Message{
-			ID:    "SureResetThisCommit",
-			Other: "Jesteś pewny, że chcesz zresetować ten commit?",
-		}, &i18n.Message{
-			ID:    "ResetToCommit",
-			Other: "Zresetuj, aby commitować",
-		}, &i18n.Message{
-			ID:    "squashDown",
-			Other: "ściśnij w dół",
-		}, &i18n.Message{
-			ID:    "rename",
-			Other: "przemianuj",
-		}, &i18n.Message{
-			ID:    "resetToThisCommit",
-			Other: "zresetuj do tego commita",
-		}, &i18n.Message{
-			ID:    "fixupCommit",
-			Other: "napraw commit",
-		}, &i18n.Message{
-			ID:    "NoCommitsThisBranch",
-			Other: "Brak commitów dla tej gałęzi",
-		}, &i18n.Message{
-			ID:    "OnlySquashTopmostCommit",
-			Other: "Można tylko ścisnąć najwyższy commit",
-		}, &i18n.Message{
-			ID:    "YouNoCommitsToSquash",
-			Other: "Nie masz commitów do ściśnięcia",
-		}, &i18n.Message{
-			ID:    "CantFixupWhileUnstagedChanges",
-			Other: "Nie można wykonać naprawy, kiedy istnieją niezatwierdzone zmiany",
-		}, &i18n.Message{
-			ID:    "Fixup",
-			Other: "Napraw",
-		}, &i18n.Message{
-			ID:    "SureFixupThisCommit",
-			Other: "Jesteś pewny, ze chcesz naprawić ten commit? Commit poniżej zostanie ściśnięty w górę wraz z tym",
-		}, &i18n.Message{
-			ID:    "OnlyRenameTopCommit",
-			Other: "Można przmianować tylko najwyższy commit",
-		}, &i18n.Message{
-			ID:    "renameCommit",
-			Other: "przemianuj commit",
-		}, &i18n.Message{
-			ID:    "renameCommitEditor",
-			Other: "przemianuj commit w edytorze",
-		}, &i18n.Message{
-			ID:    "PotentialErrInGetselectedCommit",
-			Other: "potencjalny błąd w getSelected Commit (niedopasowane ui i stan)",
-		}, &i18n.Message{
-			ID:    "Error",
-			Other: "Błąd",
-		}, &i18n.Message{
-			ID:    "resizingPopupPanel",
-			Other: "skalowanie wyskakującego panelu",
-		}, &i18n.Message{
-			ID:    "RunningSubprocess",
-			Other: "uruchomiony podproces",
-		}, &i18n.Message{
-			ID:    "selectHunk",
-			Other: "wybierz kawałek",
-		}, &i18n.Message{
-			ID:    "navigateConflicts",
-			Other: "nawiguj konflikty",
-		}, &i18n.Message{
-			ID:    "pickHunk",
-			Other: "wybierz kawałek",
-		}, &i18n.Message{
-			ID:    "pickBothHunks",
-			Other: "wybierz oba kawałki",
-		}, &i18n.Message{
-			ID:    "undo",
-			Other: "cofnij",
-		}, &i18n.Message{
-			ID:    "pop",
-			Other: "wyciągnij",
-		}, &i18n.Message{
-			ID:    "drop",
-			Other: "porzuć",
-		}, &i18n.Message{
-			ID:    "apply",
-			Other: "zastosuj",
-		}, &i18n.Message{
-			ID:    "NoStashEntries",
-			Other: "Brak pozycji w schowku",
-		}, &i18n.Message{
-			ID:    "StashDrop",
-			Other: "Porzuć schowek",
-		}, &i18n.Message{
-			ID:    "SureDropStashEntry",
-			Other: "Jesteś pewny, że chcesz porzucić tę pozycję w schowku?",
-		}, &i18n.Message{
-			ID:    "NoStashTo",
-			Other: "Brak schowka dla {{.method}}",
-		}, &i18n.Message{
-			ID:    "NoTrackedStagedFilesStash",
-			Other: "Nie masz śledzonych/zatwierdzonych plików do przechowania",
-		}, &i18n.Message{
-			ID:    "StashChanges",
-			Other: "Przechowaj zmiany",
-		}, &i18n.Message{
-			ID:    "IssntListOfViews",
-			Other: "{{.name}} nie jest na liście widoków",
-		}, &i18n.Message{
-			ID:    "NoViewMachingNewLineFocusedSwitchStatement",
-			Other: "Brak widoku pasującego do instrukcji przełączania newLineFocused",
-		}, &i18n.Message{
-			ID:    "newFocusedViewIs",
-			Other: "nowy skupiony widok to {{.newFocusedView}}",
-		}, &i18n.Message{
-			ID:    "CantCloseConfirmationPrompt",
-			Other: "Nie można zamknąć monitu potwierdzenia: {{.error}}",
-		}, &i18n.Message{
-			ID:    "ClearFilePanel",
-			Other: "Wyczyść panel plików",
-		}, &i18n.Message{
-			ID:    "MergeAborted",
-			Other: "Scalanie anulowane",
-		}, &i18n.Message{
-			ID:    "OpenConfig",
-			Other: "otwórz plik konfiguracyjny",
-		}, &i18n.Message{
-			ID:    "EditConfig",
-			Other: "edytuj plik konfiguracyjny",
-		}, &i18n.Message{
-			ID:    "ForcePush",
-			Other: "Wymuś wypchnięcie",
-		}, &i18n.Message{
-			ID:    "ForcePushPrompt",
-			Other: "Twoja gałąź rozeszła się z gałęzią zdalną. Wciśnij 'esc' aby anulować lub 'enter' aby wymusić wypchnięcie.",
-		}, &i18n.Message{
-			ID:    "checkForUpdate",
-			Other: "sprawdź aktualizacje",
-		}, &i18n.Message{
-			ID:    "CheckingForUpdates",
-			Other: "Sprawdzanie aktualizacji...",
-		}, &i18n.Message{
-			ID:    "OnLatestVersionErr",
-			Other: "Już posiadasz najnowszą wersję",
-		}, &i18n.Message{
-			ID:    "MajorVersionErr",
-			Other: "Nowa wersja ({{.newVersion}}) posiada niekompatybilne zmiany w porównaniu do obecnej wersji ({{.currentVersion}})",
-		}, &i18n.Message{
-			ID:    "CouldNotFindBinaryErr",
-			Other: "Nie można znaleźć pliku binarnego w {{.url}}",
-		}, &i18n.Message{
-			ID:    "AnonymousReportingTitle",
-			Other: "Help make lazygit better",
-		}, &i18n.Message{
-			ID:    "AnonymousReportingPrompt",
-			Other: "Włączyć anonimowe raportowanie błędów w celu pomocy w usprawnianiu lazygita (enter/esc)?",
-		}, &i18n.Message{
-			ID:    "removeFile",
-			Other: `usuń jeśli nie śledzony / przełącz jeśli śledzony`,
-		}, &i18n.Message{
-			ID:    "editFile",
-			Other: `edytuj plik`,
-		}, &i18n.Message{
-			ID:    "openFile",
-			Other: `otwórz plik`,
-		}, &i18n.Message{
-			ID:    "ignoreFile",
-			Other: `dodaj do .gitignore`,
-		}, &i18n.Message{
-			ID:    "refreshFiles",
-			Other: `odśwież pliki`,
-		}, &i18n.Message{
-			ID:    "resetHard",
-			Other: `zresetuj twardo i usuń niepotwierdzone pliki`,
-		}, &i18n.Message{
-			ID:    "mergeIntoCurrentBranch",
-			Other: `scal do obecnej gałęzi`,
-		}, &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ść.`,
-		}, &i18n.Message{
-			ID:    "fetch",
-			Other: `fetch`,
-		}, &i18n.Message{
-			ID:    "NoAutomaticGitFetchTitle",
-			Other: `No automatic git fetch`,
-		}, &i18n.Message{
-			ID:    "NoAutomaticGitFetchBody",
-			Other: `Lazygit can't use "git fetch" in a private repo use f in the branches panel to run "git fetch" manually`,
-		}, &i18n.Message{
-			ID:    "StageLines",
-			Other: `zatwierdź pojedyncze linie`,
-		}, &i18n.Message{
-			ID:    "FileStagingRequirements",
-			Other: `Można tylko zatwierdzić pojedyncze linie dla śledzonych plików z niezatwierdzonymi zmianami`,
-		}, &i18n.Message{
-			ID:    "StagingTitle",
-			Other: `Zatwierdzanie`,
-		}, &i18n.Message{
-			ID:    "StageHunk",
-			Other: `zatwierdź kawałek`,
-		}, &i18n.Message{
-			ID:    "StageLine",
-			Other: `zatwierdź linię`,
-		}, &i18n.Message{
-			ID:    "EscapeStaging",
-			Other: `wróć do panelu plików`,
-		}, &i18n.Message{
-			ID:    "CantFindHunks",
-			Other: `Nie można znaleźć żadnych kawałków w tej łatce`,
-		}, &i18n.Message{
-			ID:    "CantFindHunk",
-			Other: `Nie można znaleźć kawałka`,
-		}, &i18n.Message{
-			ID:    "RebasingTitle",
-			Other: "Rebasing",
-		}, &i18n.Message{
-			ID:    "MergingTitle",
-			Other: "Merging",
-		}, &i18n.Message{
-			ID:    "ConfirmRebase",
-			Other: "Are you sure you want to rebase {{.checkedOutBranch}} onto {{.selectedBranch}}?",
-		}, &i18n.Message{
-			ID:    "ConfirmMerge",
-			Other: "Are you sure you want to merge {{.selectedBranch}} into {{.checkedOutBranch}}?",
-		}, &i18n.Message{}, &i18n.Message{
-			ID:    "FwdNoUpstream",
-			Other: "Cannot fast-forward a branch with no upstream",
-		}, &i18n.Message{
-			ID:    "FwdCommitsToPush",
-			Other: "Cannot fast-forward a branch with commits to push",
-		}, &i18n.Message{
-			ID:    "ErrorOccurred",
-			Other: "An error occurred! Please create an issue at https://github.com/jesseduffield/lazygit/issues",
-		}, &i18n.Message{
-			ID:    "MainTitle",
-			Other: "Main",
-		}, &i18n.Message{
-			ID:    "NormalTitle",
-			Other: "Normal",
-		}, &i18n.Message{
-			ID:    "softReset",
-			Other: "soft reset to last commit",
-		}, &i18n.Message{
-			ID:    "SoftReset",
-			Other: "Soft reset",
-		}, &i18n.Message{
-			ID:    "ConfirmSoftReset",
-			Other: "Are you sure you want to `reset --soft HEAD^`? The changes in your topmost commit will be placed in your working tree",
-		}, &i18n.Message{
-			ID:    "SureSquashThisCommit",
-			Other: "Are you sure you want to squash this commit into the commit below?",
-		}, &i18n.Message{
-			ID:    "Squash",
-			Other: "Squash",
-		}, &i18n.Message{
-			ID:    "pickCommit",
-			Other: "pick commit (when mid-rebase)",
-		}, &i18n.Message{
-			ID:    "revertCommit",
-			Other: "revert commit",
-		}, &i18n.Message{
-			ID:    "deleteCommit",
-			Other: "delete commit",
-		}, &i18n.Message{
-			ID:    "moveDownCommit",
-			Other: "move commit down one",
-		}, &i18n.Message{
-			ID:    "moveUpCommit",
-			Other: "move commit up one",
-		}, &i18n.Message{
-			ID:    "editCommit",
-			Other: "edit commit",
-		}, &i18n.Message{
-			ID:    "amendToCommit",
-			Other: "amend commit with staged changes",
-		}, &i18n.Message{
-			ID:    "FoundConflicts",
-			Other: "Damn, conflicts! To abort press 'esc', otherwise press 'enter'",
-		}, &i18n.Message{
-			ID:    "FoundConflictsTitle",
-			Other: "Auto-merge failed",
-		}, &i18n.Message{
-			ID:    "Undo",
-			Other: "undo",
-		}, &i18n.Message{
-			ID:    "PickHunk",
-			Other: "pick hunk",
-		}, &i18n.Message{
-			ID:    "PickBothHunks",
-			Other: "pick both hunks",
-		}, &i18n.Message{
-			ID:    "ViewMergeRebaseOptions",
-			Other: "view merge/rebase options",
-		}, &i18n.Message{
-			ID:    "NotMergingOrRebasing",
-			Other: "You are currently neither rebasing nor merging",
-		}, &i18n.Message{
-			ID:    "RecentRepos",
-			Other: "recent repositories",
-		}, &i18n.Message{
-			ID:    "MergeOptionsTitle",
-			Other: "Merge Options",
-		}, &i18n.Message{
-			ID:    "RebaseOptionsTitle",
-			Other: "Rebase Options",
-		}, &i18n.Message{
-			ID:    "ConflictsResolved",
-			Other: "all merge conflicts resolved. Continue?",
-		}, &i18n.Message{
-			ID:    "NoRoom",
-			Other: "Not enough room",
-		}, &i18n.Message{
-			ID:    "YouAreHere",
-			Other: "YOU ARE HERE",
-		}, &i18n.Message{
-			ID:    "rewordNotSupported",
-			Other: "rewording commits while interactively rebasing is not currently supported",
-		}, &i18n.Message{
-			ID:    "cherryPickCopy",
-			Other: "copy commit (cherry-pick)",
-		}, &i18n.Message{
-			ID:    "cherryPickCopyRange",
-			Other: "copy commit range (cherry-pick)",
-		}, &i18n.Message{
-			ID:    "pasteCommits",
-			Other: "paste commits (cherry-pick)",
-		}, &i18n.Message{
-			ID:    "SureCherryPick",
-			Other: "Are you sure you want to cherry-pick the copied commits onto this branch?",
-		}, &i18n.Message{
-			ID:    "CherryPick",
-			Other: "Cherry-Pick",
-		}, &i18n.Message{
-			ID:    "CannotRebaseOntoFirstCommit",
-			Other: "You cannot interactive rebase onto the first commit",
-		}, &i18n.Message{
-			ID:    "Donate",
-			Other: "Donate",
-		}, &i18n.Message{
-			ID:    "PrevLine",
-			Other: "select previous line",
-		}, &i18n.Message{
-			ID:    "NextLine",
-			Other: "select next line",
-		}, &i18n.Message{
-			ID:    "PrevHunk",
-			Other: "select previous hunk",
-		}, &i18n.Message{
-			ID:    "NextHunk",
-			Other: "select next hunk",
-		}, &i18n.Message{
-			ID:    "PrevConflict",
-			Other: "select previous conflict",
-		}, &i18n.Message{
-			ID:    "NextConflict",
-			Other: "select next conflict",
-		}, &i18n.Message{
-			ID:    "SelectTop",
-			Other: "select top hunk",
-		}, &i18n.Message{
-			ID:    "SelectBottom",
-			Other: "select bottom hunk",
-		}, &i18n.Message{
-			ID:    "ScrollDown",
-			Other: "scroll down",
-		}, &i18n.Message{
-			ID:    "ScrollUp",
-			Other: "scroll up",
-		}, &i18n.Message{
-			ID:    "AmendCommitTitle",
-			Other: "Amend Commit",
-		}, &i18n.Message{
-			ID:    "AmendCommitPrompt",
-			Other: "Are you sure you want to amend this commit with your staged files?",
-		}, &i18n.Message{
-			ID:    "DeleteCommitTitle",
-			Other: "Delete Commit",
-		}, &i18n.Message{
-			ID:    "DeleteCommitPrompt",
-			Other: "Are you sure you want to delete this commit?",
-		}, &i18n.Message{
-			ID:    "SquashingStatus",
-			Other: "squashing",
-		}, &i18n.Message{
-			ID:    "FixingStatus",
-			Other: "fixing up",
-		}, &i18n.Message{
-			ID:    "DeletingStatus",
-			Other: "deleting",
-		}, &i18n.Message{
-			ID:    "MovingStatus",
-			Other: "moving",
-		}, &i18n.Message{
-			ID:    "RebasingStatus",
-			Other: "rebasing",
-		}, &i18n.Message{
-			ID:    "AmendingStatus",
-			Other: "amending",
-		}, &i18n.Message{
-			ID:    "CherryPickingStatus",
-			Other: "cherry-picking",
-		},
-	)
-}

pkg/test/test.go

@@ -1,31 +0,0 @@
-package test
-
-import (
-	"github.com/go-errors/errors"
-	"os"
-	"os/exec"
-	"path/filepath"
-
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// GenerateRepo generates a repo from test/repos and changes the directory to be
-// inside the newly made repo
-func GenerateRepo(filename string) error {
-	reposDir := "/test/repos/"
-	testPath := utils.GetProjectRoot() + reposDir
-
-	// workaround for debian packaging
-	if _, err := os.Stat(testPath); os.IsNotExist(err) {
-		cwd, _ := os.Getwd()
-		testPath = filepath.Dir(filepath.Dir(cwd)) + reposDir
-	}
-	if err := os.Chdir(testPath); err != nil {
-		return err
-	}
-	if output, err := exec.Command("bash", filename).CombinedOutput(); err != nil {
-		return errors.New(string(output))
-	}
-
-	return os.Chdir(testPath + "repo")
-}

pkg/test/utils.go

@@ -1,45 +0,0 @@
-package test
-
-import (
-	"fmt"
-	"os/exec"
-	"strings"
-	"testing"
-
-	"github.com/mgutz/str"
-	"github.com/stretchr/testify/assert"
-)
-
-// CommandSwapper takes a command, verifies that it is what it's expected to be
-// and then returns a replacement command that will actually be called by the os
-type CommandSwapper struct {
-	Expect  string
-	Replace string
-}
-
-// SwapCommand verifies the command is what we expected, and swaps it out for a different command
-func (i *CommandSwapper) SwapCommand(t *testing.T, cmd string, args []string) *exec.Cmd {
-	splitCmd := str.ToArgv(i.Expect)
-	assert.EqualValues(t, splitCmd[0], cmd, fmt.Sprintf("received command: %s %s", cmd, strings.Join(args, " ")))
-	if len(splitCmd) > 1 {
-		assert.EqualValues(t, splitCmd[1:], args, fmt.Sprintf("received command: %s %s", cmd, strings.Join(args, " ")))
-	}
-
-	splitCmd = str.ToArgv(i.Replace)
-	return exec.Command(splitCmd[0], splitCmd[1:]...)
-}
-
-// CreateMockCommand creates a command function that will verify its receiving the right sequence of commands from lazygit
-func CreateMockCommand(t *testing.T, swappers []*CommandSwapper) func(cmd string, args ...string) *exec.Cmd {
-	commandIndex := 0
-
-	return func(cmd string, args ...string) *exec.Cmd {
-		var command *exec.Cmd
-		if commandIndex > len(swappers)-1 {
-			assert.Fail(t, fmt.Sprintf("too many commands run. This command was (%s %s)", cmd, strings.Join(args, " ")))
-		}
-		command = swappers[commandIndex].SwapCommand(t, cmd, args)
-		commandIndex++
-		return command
-	}
-}

pkg/updates/updates.go

@@ -1,313 +0,0 @@
-package updates
-
-import (
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/go-errors/errors"
-
-	"github.com/kardianos/osext"
-
-	getter "github.com/jesseduffield/go-getter"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/sirupsen/logrus"
-)
-
-// Updater checks for updates and does updates
-type Updater struct {
-	Log       *logrus.Entry
-	Config    config.AppConfigurer
-	OSCommand *commands.OSCommand
-	Tr        *i18n.Localizer
-}
-
-// Updaterer implements the check and update methods
-type Updaterer interface {
-	CheckForNewUpdate()
-	Update()
-}
-
-const (
-	PROJECT_URL = "https://github.com/jesseduffield/lazygit"
-)
-
-// NewUpdater creates a new updater
-func NewUpdater(log *logrus.Entry, config config.AppConfigurer, osCommand *commands.OSCommand, tr *i18n.Localizer) (*Updater, error) {
-	contextLogger := log.WithField("context", "updates")
-
-	return &Updater{
-		Log:       contextLogger,
-		Config:    config,
-		OSCommand: osCommand,
-		Tr:        tr,
-	}, nil
-}
-
-func (u *Updater) getLatestVersionNumber() (string, error) {
-	req, err := http.NewRequest("GET", PROJECT_URL+"/releases/latest", nil)
-	if err != nil {
-		return "", err
-	}
-	req.Header.Set("Accept", "application/json")
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	dec := json.NewDecoder(resp.Body)
-	data := struct {
-		TagName string `json:"tag_name"`
-	}{}
-	if err := dec.Decode(&data); err != nil {
-		return "", err
-	}
-
-	return data.TagName, nil
-}
-
-// RecordLastUpdateCheck records last time an update check was performed
-func (u *Updater) RecordLastUpdateCheck() error {
-	u.Config.GetAppState().LastUpdateCheck = time.Now().Unix()
-	return u.Config.SaveAppState()
-}
-
-// expecting version to be of the form `v12.34.56`
-func (u *Updater) majorVersionDiffers(oldVersion, newVersion string) bool {
-	if oldVersion == "unversioned" {
-		return false
-	}
-	oldVersion = strings.TrimPrefix(oldVersion, "v")
-	newVersion = strings.TrimPrefix(newVersion, "v")
-	return strings.Split(oldVersion, ".")[0] != strings.Split(newVersion, ".")[0]
-}
-
-func (u *Updater) checkForNewUpdate() (string, error) {
-	u.Log.Info("Checking for an updated version")
-	currentVersion := u.Config.GetVersion()
-	if err := u.RecordLastUpdateCheck(); err != nil {
-		return "", err
-	}
-
-	newVersion, err := u.getLatestVersionNumber()
-	if err != nil {
-		return "", err
-	}
-	u.Log.Info("Current version is " + currentVersion)
-	u.Log.Info("New version is " + newVersion)
-
-	if newVersion == currentVersion {
-		return "", errors.New(u.Tr.SLocalize("OnLatestVersionErr"))
-	}
-
-	if u.majorVersionDiffers(currentVersion, newVersion) {
-		errMessage := u.Tr.TemplateLocalize(
-			"MajorVersionErr",
-			i18n.Teml{
-				"newVersion":     newVersion,
-				"currentVersion": currentVersion,
-			},
-		)
-		return "", errors.New(errMessage)
-	}
-
-	rawUrl, err := u.getBinaryUrl(newVersion)
-	if err != nil {
-		return "", err
-	}
-	u.Log.Info("Checking for resource at url " + rawUrl)
-	if !u.verifyResourceFound(rawUrl) {
-		errMessage := u.Tr.TemplateLocalize(
-			"CouldNotFindBinaryErr",
-			i18n.Teml{
-				"url": rawUrl,
-			},
-		)
-		return "", errors.New(errMessage)
-	}
-	u.Log.Info("Verified resource is available, ready to update")
-
-	return newVersion, nil
-}
-
-// CheckForNewUpdate checks if there is an available update
-func (u *Updater) CheckForNewUpdate(onFinish func(string, error) error, userRequested bool) {
-	if !userRequested && u.skipUpdateCheck() {
-		return
-	}
-
-	go func() {
-		newVersion, err := u.checkForNewUpdate()
-		if err = onFinish(newVersion, err); err != nil {
-			u.Log.Error(err)
-		}
-	}()
-}
-
-func (u *Updater) skipUpdateCheck() bool {
-	// will remove the check for windows after adding a manifest file asking for
-	// the required permissions
-	if runtime.GOOS == "windows" {
-		u.Log.Info("Updating is currently not supported for windows until we can fix permission issues")
-		return true
-	}
-
-	if u.Config.GetVersion() == "unversioned" {
-		u.Log.Info("Current version is not built from an official release so we won't check for an update")
-		return true
-	}
-
-	if u.Config.GetBuildSource() != "buildBinary" {
-		u.Log.Info("Binary is not built with the buildBinary flag so we won't check for an update")
-		return true
-	}
-
-	userConfig := u.Config.GetUserConfig()
-	if userConfig.Get("update.method") == "never" {
-		u.Log.Info("Update method is set to never so we won't check for an update")
-		return true
-	}
-
-	currentTimestamp := time.Now().Unix()
-	lastUpdateCheck := u.Config.GetAppState().LastUpdateCheck
-	days := userConfig.GetInt64("update.days")
-
-	if (currentTimestamp-lastUpdateCheck)/(60*60*24) < days {
-		u.Log.Info("Last update was too recent so we won't check for an update")
-		return true
-	}
-
-	return false
-}
-
-func (u *Updater) mappedOs(os string) string {
-	osMap := map[string]string{
-		"darwin":  "Darwin",
-		"linux":   "Linux",
-		"windows": "Windows",
-	}
-	result, found := osMap[os]
-	if found {
-		return result
-	}
-	return os
-}
-
-func (u *Updater) mappedArch(arch string) string {
-	archMap := map[string]string{
-		"386":   "32-bit",
-		"amd64": "x86_64",
-	}
-	result, found := archMap[arch]
-	if found {
-		return result
-	}
-	return arch
-}
-
-// example: https://github.com/jesseduffield/lazygit/releases/download/v0.1.73/lazygit_0.1.73_Darwin_x86_64.tar.gz
-func (u *Updater) getBinaryUrl(newVersion string) (string, error) {
-	extension := "tar.gz"
-	if runtime.GOOS == "windows" {
-		extension = "zip"
-	}
-	url := fmt.Sprintf(
-		"%s/releases/download/%s/lazygit_%s_%s_%s.%s",
-		PROJECT_URL,
-		newVersion,
-		newVersion[1:],
-		u.mappedOs(runtime.GOOS),
-		u.mappedArch(runtime.GOARCH),
-		extension,
-	)
-	u.Log.Info("Url for latest release is " + url)
-	return url, nil
-}
-
-// Update downloads the latest binary and replaces the current binary with it
-func (u *Updater) Update(newVersion string, onFinish func(error) error) {
-	go func() {
-		err := u.update(newVersion)
-		if err = onFinish(err); err != nil {
-			u.Log.Error(err)
-		}
-	}()
-}
-
-func (u *Updater) update(newVersion string) error {
-	rawUrl, err := u.getBinaryUrl(newVersion)
-	if err != nil {
-		return err
-	}
-	u.Log.Info("Updating with url " + rawUrl)
-	return u.downloadAndInstall(rawUrl)
-}
-
-func (u *Updater) downloadAndInstall(rawUrl string) error {
-	url, err := url.Parse(rawUrl)
-	if err != nil {
-		return err
-	}
-
-	g := new(getter.HttpGetter)
-	tempDir, err := ioutil.TempDir("", "lazygit")
-	if err != nil {
-		return err
-	}
-	defer os.RemoveAll(tempDir)
-	u.Log.Info("Temp directory is " + tempDir)
-
-	// Get it!
-	if err := g.Get(tempDir, url); err != nil {
-		return err
-	}
-
-	// get the path of the current binary
-	binaryPath, err := osext.Executable()
-	if err != nil {
-		return err
-	}
-	u.Log.Info("Binary path is " + binaryPath)
-
-	binaryName := filepath.Base(binaryPath)
-	u.Log.Info("Binary name is " + binaryName)
-
-	// Verify the main file exists
-	tempPath := filepath.Join(tempDir, binaryName)
-	u.Log.Info("Temp path to binary is " + tempPath)
-	if _, err := os.Stat(tempPath); err != nil {
-		return err
-	}
-
-	// swap out the old binary for the new one
-	err = os.Rename(tempPath, binaryPath)
-	if err != nil {
-		return err
-	}
-	u.Log.Info("Update complete!")
-
-	return nil
-}
-
-func (u *Updater) verifyResourceFound(rawUrl string) bool {
-	resp, err := http.Head(rawUrl)
-	if err != nil {
-		return false
-	}
-	defer resp.Body.Close()
-	u.Log.Info("Received status code ", resp.StatusCode)
-	// 403 means the resource is there (not going to bother adding extra request headers)
-	// 404 means its not
-	return resp.StatusCode == 403
-}

pkg/utils/utils.go

@@ -1,17 +1,11 @@
 package utils
 
 import (
-	"encoding/json"
 	"fmt"
 	"log"
 	"os"
 	"path/filepath"
-	"reflect"
-	"regexp"
 	"strings"
-	"time"
-
-	"github.com/go-errors/errors"
 
 	"github.com/fatih/color"
 )
@@ -69,184 +63,3 @@ func TrimTrailingNewline(str string) string {
 	}
 	return str
 }
-
-// NormalizeLinefeeds - Removes all Windows and Mac style line feeds
-func NormalizeLinefeeds(str string) string {
-	str = strings.Replace(str, "\r\n", "\n", -1)
-	str = strings.Replace(str, "\r", "", -1)
-	return str
-}
-
-// GetProjectRoot returns the path to the root of the project. Only to be used
-// in testing contexts, as with binaries it's unlikely this path will exist on
-// the machine
-func GetProjectRoot() string {
-	dir, err := os.Getwd()
-	if err != nil {
-		panic(err)
-	}
-	return strings.Split(dir, "lazygit")[0] + "lazygit"
-}
-
-// Loader dumps a string to be displayed as a loader
-func Loader() string {
-	characters := "|/-\\"
-	now := time.Now()
-	nanos := now.UnixNano()
-	index := nanos / 50000000 % int64(len(characters))
-	return characters[index : index+1]
-}
-
-// ResolvePlaceholderString populates a template with values
-func ResolvePlaceholderString(str string, arguments map[string]string) string {
-	for key, value := range arguments {
-		str = strings.Replace(str, "{{"+key+"}}", value, -1)
-	}
-	return str
-}
-
-// Min returns the minimum of two integers
-func Min(x, y int) int {
-	if x < y {
-		return x
-	}
-	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)
-
-	if !displayArraysAligned(stringArrays) {
-		return "", errors.New("Each item must return the same number of strings to display")
-	}
-
-	padWidths := getPadWidths(stringArrays)
-	paddedDisplayStrings := getPaddedDisplayStrings(stringArrays, padWidths)
-
-	return strings.Join(paddedDisplayStrings, "\n"), nil
-}
-
-// Decolorise strips a string of color
-func Decolorise(str string) string {
-	re := regexp.MustCompile(`\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]`)
-	return re.ReplaceAllString(str, "")
-}
-
-func getPadWidths(stringArrays [][]string) []int {
-	if len(stringArrays[0]) <= 1 {
-		return []int{}
-	}
-	padWidths := make([]int, len(stringArrays[0])-1)
-	for i := range padWidths {
-		for _, strings := range stringArrays {
-			uncoloredString := Decolorise(strings[i])
-			if len(uncoloredString) > padWidths[i] {
-				padWidths[i] = len(uncoloredString)
-			}
-		}
-	}
-	return padWidths
-}
-
-func getPaddedDisplayStrings(stringArrays [][]string, padWidths []int) []string {
-	paddedDisplayStrings := make([]string, len(stringArrays))
-	for i, stringArray := range stringArrays {
-		if len(stringArray) == 0 {
-			continue
-		}
-		for j, padWidth := range padWidths {
-			paddedDisplayStrings[i] += WithPadding(stringArray[j], padWidth) + " "
-		}
-		paddedDisplayStrings[i] += stringArray[len(padWidths)]
-	}
-	return paddedDisplayStrings
-}
-
-// displayArraysAligned returns true if every string array returned from our
-// list of displayables has the same length
-func displayArraysAligned(stringArrays [][]string) bool {
-	for _, strings := range stringArrays {
-		if len(strings) != len(stringArrays[0]) {
-			return false
-		}
-	}
-	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 {
-		if b == a {
-			return true
-		}
-	}
-	return false
-}
-
-// NextIndex returns the index of the element that comes after the given number
-func NextIndex(numbers []int, currentNumber int) int {
-	for index, number := range numbers {
-		if number > currentNumber {
-			return index
-		}
-	}
-	return 0
-}
-
-// PrevIndex returns the index that comes before the given number, cycling if we reach the end
-func PrevIndex(numbers []int, currentNumber int) int {
-	end := len(numbers) - 1
-	for i := end; i >= 0; i -= 1 {
-		if numbers[i] < currentNumber {
-			return i
-		}
-	}
-	return end
-}
-
-func AsJson(i interface{}) string {
-	bytes, _ := json.MarshalIndent(i, "", "    ")
-	return string(bytes)
-}

pkg/utils/utils_test.go

@@ -1,575 +0,0 @@
-package utils
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// TestSplitLines is a function.
-func TestSplitLines(t *testing.T) {
-	type scenario struct {
-		multilineString string
-		expected        []string
-	}
-
-	scenarios := []scenario{
-		{
-			"",
-			[]string{},
-		},
-		{
-			"\n",
-			[]string{},
-		},
-		{
-			"hello world !\nhello universe !\n",
-			[]string{
-				"hello world !",
-				"hello universe !",
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, SplitLines(s.multilineString))
-	}
-}
-
-// TestWithPadding is a function.
-func TestWithPadding(t *testing.T) {
-	type scenario struct {
-		str      string
-		padding  int
-		expected string
-	}
-
-	scenarios := []scenario{
-		{
-			"hello world !",
-			1,
-			"hello world !",
-		},
-		{
-			"hello world !",
-			14,
-			"hello world ! ",
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, WithPadding(s.str, s.padding))
-	}
-}
-
-// TestTrimTrailingNewline is a function.
-func TestTrimTrailingNewline(t *testing.T) {
-	type scenario struct {
-		str      string
-		expected string
-	}
-
-	scenarios := []scenario{
-		{
-			"hello world !\n",
-			"hello world !",
-		},
-		{
-			"hello world !",
-			"hello world !",
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, TrimTrailingNewline(s.str))
-	}
-}
-
-// TestNormalizeLinefeeds is a function.
-func TestNormalizeLinefeeds(t *testing.T) {
-	type scenario struct {
-		byteArray []byte
-		expected  []byte
-	}
-	var scenarios = []scenario{
-		{
-			// \r\n
-			[]byte{97, 115, 100, 102, 13, 10},
-			[]byte{97, 115, 100, 102, 10},
-		},
-		{
-			// bash\r\nblah
-			[]byte{97, 115, 100, 102, 13, 10, 97, 115, 100, 102},
-			[]byte{97, 115, 100, 102, 10, 97, 115, 100, 102},
-		},
-		{
-			// \r
-			[]byte{97, 115, 100, 102, 13},
-			[]byte{97, 115, 100, 102},
-		},
-		{
-			// \n
-			[]byte{97, 115, 100, 102, 10},
-			[]byte{97, 115, 100, 102, 10},
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, string(s.expected), NormalizeLinefeeds(string(s.byteArray)))
-	}
-}
-
-// TestResolvePlaceholderString is a function.
-func TestResolvePlaceholderString(t *testing.T) {
-	type scenario struct {
-		templateString string
-		arguments      map[string]string
-		expected       string
-	}
-
-	scenarios := []scenario{
-		{
-			"",
-			map[string]string{},
-			"",
-		},
-		{
-			"hello",
-			map[string]string{},
-			"hello",
-		},
-		{
-			"hello {{arg}}",
-			map[string]string{},
-			"hello {{arg}}",
-		},
-		{
-			"hello {{arg}}",
-			map[string]string{"arg": "there"},
-			"hello there",
-		},
-		{
-			"hello",
-			map[string]string{"arg": "there"},
-			"hello",
-		},
-		{
-			"{{nothing}}",
-			map[string]string{"nothing": ""},
-			"",
-		},
-		{
-			"{{}} {{ this }} { should not throw}} an {{{{}}}} error",
-			map[string]string{
-				"blah": "blah",
-				"this": "won't match",
-			},
-			"{{}} {{ this }} { should not throw}} an {{{{}}}} error",
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, string(s.expected), ResolvePlaceholderString(s.templateString, s.arguments))
-	}
-}
-
-// TestDisplayArraysAligned is a function.
-func TestDisplayArraysAligned(t *testing.T) {
-	type scenario struct {
-		input    [][]string
-		expected bool
-	}
-
-	scenarios := []scenario{
-		{
-			[][]string{{"", ""}, {"", ""}},
-			true,
-		},
-		{
-			[][]string{{""}, {"", ""}},
-			false,
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, displayArraysAligned(s.input))
-	}
-}
-
-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,
-			"",
-			"Each item must return the same number of strings to display",
-		},
-		{
-			[]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 {
-		stringArrays [][]string
-		padWidths    []int
-		expected     []string
-	}
-
-	scenarios := []scenario{
-		{
-			[][]string{{"a", "b"}, {"c", "d"}},
-			[]int{1},
-			[]string{"a b", "c d"},
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, getPaddedDisplayStrings(s.stringArrays, s.padWidths))
-	}
-}
-
-// TestGetPadWidths is a function.
-func TestGetPadWidths(t *testing.T) {
-	type scenario struct {
-		stringArrays [][]string
-		expected     []int
-	}
-
-	scenarios := []scenario{
-		{
-			[][]string{{""}, {""}},
-			[]int{},
-		},
-		{
-			[][]string{{"a"}, {""}},
-			[]int{},
-		},
-		{
-			[][]string{{"aa", "b", "ccc"}, {"c", "d", "e"}},
-			[]int{2, 1},
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, getPadWidths(s.stringArrays))
-	}
-}
-
-// TestMin is a function.
-func TestMin(t *testing.T) {
-	type scenario struct {
-		a        int
-		b        int
-		expected int
-	}
-
-	scenarios := []scenario{
-		{
-			1,
-			1,
-			1,
-		},
-		{
-			1,
-			2,
-			1,
-		},
-		{
-			2,
-			1,
-			1,
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, Min(s.a, s.b))
-	}
-}
-
-// TestIncludesString is a function.
-func TestIncludesString(t *testing.T) {
-	type scenario struct {
-		list     []string
-		element  string
-		expected bool
-	}
-
-	scenarios := []scenario{
-		{
-			[]string{"a", "b"},
-			"a",
-			true,
-		},
-		{
-			[]string{"a", "b"},
-			"c",
-			false,
-		},
-		{
-			[]string{"a", "b"},
-			"",
-			false,
-		},
-		{
-			[]string{""},
-			"",
-			true,
-		},
-	}
-
-	for _, s := range scenarios {
-		assert.EqualValues(t, s.expected, IncludesString(s.list, s.element))
-	}
-}
-
-func TestNextIndex(t *testing.T) {
-	type scenario struct {
-		testName string
-		list     []int
-		element  int
-		expected int
-	}
-
-	scenarios := []scenario{
-		{
-			// I'm not really fussed about how it behaves here
-			"no elements",
-			[]int{},
-			1,
-			0,
-		},
-		{
-			"one element",
-			[]int{1},
-			1,
-			0,
-		},
-		{
-			"two elements",
-			[]int{1, 2},
-			1,
-			1,
-		},
-		{
-			"two elements, giving second one",
-			[]int{1, 2},
-			2,
-			0,
-		},
-		{
-			"three elements, giving second one",
-			[]int{1, 2, 3},
-			2,
-			2,
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			assert.EqualValues(t, s.expected, NextIndex(s.list, s.element))
-		})
-	}
-}
-
-func TestPrevIndex(t *testing.T) {
-	type scenario struct {
-		testName string
-		list     []int
-		element  int
-		expected int
-	}
-
-	scenarios := []scenario{
-		{
-			// I'm not really fussed about how it behaves here
-			"no elements",
-			[]int{},
-			1,
-			-1,
-		},
-		{
-			"one element",
-			[]int{1},
-			1,
-			0,
-		},
-		{
-			"two elements",
-			[]int{1, 2},
-			1,
-			1,
-		},
-		{
-			"three elements, giving second one",
-			[]int{1, 2, 3},
-			2,
-			0,
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			assert.EqualValues(t, s.expected, PrevIndex(s.list, s.element))
-		})
-	}
-}
-
-func TestAsJson(t *testing.T) {
-	type myStruct struct {
-		a string
-	}
-
-	output := AsJson(&myStruct{a: "foo"})
-
-	// no idea why this is returning empty hashes but it's works in the app ¯\_(ツ)_/¯
-	assert.EqualValues(t, "{}", output)
-}

scripts/bump_modules.sh

@@ -1,5 +0,0 @@
-#!/bin/sh
-
-GO111MODULE=on
-mv go.mod /tmp/
-go mod init

scripts/generate_cheatsheet.go

@@ -1,126 +0,0 @@
-// This "script" generates a file called Keybindings_{{.LANG}}.md
-// in current working directory.
-//
-// The content of this generated file is a keybindings cheatsheet.
-//
-// To generate cheatsheet in english run:
-//   LANG=en go run scripts/generate_cheatsheet.go
-
-package main
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/app"
-	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/jesseduffield/lazygit/pkg/gui"
-)
-
-type bindingSection struct {
-	title    string
-	bindings []*gui.Binding
-}
-
-func main() {
-	mConfig, _ := config.NewAppConfig("", "", "", "", "", true)
-	mApp, _ := app.NewApp(mConfig)
-	lang := mApp.Tr.GetLanguage()
-	file, _ := os.Create("Keybindings_" + lang + ".md")
-
-	bindingSections := getBindingSections(mApp)
-
-	content := formatSections(mApp, bindingSections)
-
-	writeString(file, content)
-}
-
-func writeString(file *os.File, str string) {
-	_, err := file.WriteString(str)
-	if err != nil {
-		log.Fatal(err)
-	}
-}
-
-func localisedTitle(mApp *app.App, str string) string {
-	viewTitle := strings.Title(str) + "Title"
-	return mApp.Tr.SLocalize(viewTitle)
-}
-
-func formatTitle(title string) string {
-	return fmt.Sprintf("\n## %s\n\n", title)
-}
-
-func formatBinding(binding *gui.Binding) string {
-	return fmt.Sprintf("  <kbd>%s</kbd>: %s\n", binding.GetKey(), binding.Description)
-}
-
-func getBindingSections(mApp *app.App) []*bindingSection {
-	bindingSections := []*bindingSection{}
-
-	// TODO: add context-based keybindings
-	for _, binding := range mApp.Gui.GetInitialKeybindings() {
-		if binding.Description == "" {
-			continue
-		}
-
-		viewName := binding.ViewName
-		if viewName == "" {
-			viewName = "global"
-		}
-		title := localisedTitle(mApp, viewName)
-
-		bindingSections = addBinding(title, bindingSections, binding)
-	}
-
-	for view, contexts := range mApp.Gui.GetContextMap() {
-		for contextName, contextBindings := range contexts {
-			translatedView := localisedTitle(mApp, view)
-			translatedContextName := localisedTitle(mApp, contextName)
-			title := fmt.Sprintf("%s (%s)", translatedView, translatedContextName)
-
-			for _, binding := range contextBindings {
-				bindingSections = addBinding(title, bindingSections, binding)
-			}
-		}
-	}
-
-	return bindingSections
-}
-
-func addBinding(title string, bindingSections []*bindingSection, binding *gui.Binding) []*bindingSection {
-	if binding.Description == "" {
-		return bindingSections
-	}
-
-	for _, section := range bindingSections {
-		if title == section.title {
-			section.bindings = append(section.bindings, binding)
-			return bindingSections
-		}
-	}
-
-	section := &bindingSection{
-		title:    title,
-		bindings: []*gui.Binding{binding},
-	}
-
-	return append(bindingSections, section)
-}
-
-func formatSections(mApp *app.App, bindingSections []*bindingSection) string {
-	content := fmt.Sprintf("# Lazygit %s\n", mApp.Tr.SLocalize("menu"))
-
-	for _, section := range bindingSections {
-		content += formatTitle(section.title)
-		content += "<pre>\n"
-		for _, binding := range section.bindings {
-			content += formatBinding(binding)
-		}
-		content += "</pre>\n"
-	}
-
-	return content
-}

scripts/push_new_patch.go

@@ -1,5 +1,5 @@
 // call from project root with
-// go run scripts/push_new_patch/main.go
+// go run bin/push_new_patch.go
 
 // goreleaser expects a $GITHUB_TOKEN env variable to be defined
 // in order to push the release got github

test.sh

@@ -1,24 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-echo "" > coverage.txt
-
-use_go_test=false
-if command -v gotest; then
-    use_go_test=true
-fi
-
-for d in $( find ./* -maxdepth 10 ! -path "./vendor*" ! -path "./.git*" ! -path "./scripts*" -type d); do
-    if ls $d/*.go &> /dev/null; then
-        args="-v -race -coverprofile=profile.out -covermode=atomic $d"
-        if [ "$use_go_test" == true ]; then
-            gotest $args
-        else
-            go test $args
-        fi
-        if [ -f profile.out ]; then
-            cat profile.out >> coverage.txt
-            rm profile.out
-        fi
-    fi
-done

test/hooks/pre-push

@@ -1,25 +0,0 @@
-#!/bin/bash
-
-# test pre-push hook for testing the lazygit credentials view
-#
-# to enable, use:
-# chmod +x .git/hooks/pre-push
-#
-# this will hang if you're using git from the command line, so only enable this
-# when you are testing the credentials view in lazygit
-
-exec < /dev/tty
-
-echo -n "Username for 'github': "
-read username
-
-echo -n "Password for 'github': "
-read password
-
-if [ "$username" = "username" -a "$password" = "password" ]; then
-  echo "success"
-  exit 0
-fi
-
->&2 echo "incorrect username/password"
-exit 1

test/repos/bom.sh

@@ -1,23 +0,0 @@
-#!/bin/bash
-set -ex; rm -rf repo; mkdir repo; cd repo
-
-git init
-
-cat <<EOT >> windowslf.txt
-asdf
-asdf
-EOT
-
-cat <<EOT >> linuxlf.txt
-asdf
-asdf
-EOT
-
-cat <<EOT >> bomtest.txt
-A,B,C,D,E
-F,G,H,I,J
-K,L,M,N,O
-P,Q,R,S,T
-U,V,W,X,Y
-Z,1,2,3,4
-EOT

test/repos/case_insensitive_checkouts.sh

@@ -2,9 +2,6 @@
 set -ex; rm -rf repo; mkdir repo; cd repo
 
 git init
-git config user.email "test@example.com"
-git config user.name "Lazygit Tester"
-
 
 touch foo
 git add foo

test/repos/gpg.sh

@@ -2,9 +2,6 @@
 set -ex; rm -rf repo; mkdir repo; cd repo
 
 git init
-git config user.email "test@example.com"
-git config user.name "Lazygit Tester"
-
 
 git config gpg.program $(which gpg)
 git config user.signingkey E304229F # test key

test/repos/lots_of_commits.sh

@@ -2,9 +2,6 @@
 set -ex; rm -rf repo; mkdir repo; cd repo
 
 git init
-git config user.email "test@example.com"
-git config user.name "Lazygit Tester"
-
 
 i=2
 end=100

test/repos/merge_conflict.sh

@@ -1,10 +1,7 @@
-#!/bin/sh
+#!/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"
-
 
 function add_spacing {
   for i in {1..60}
@@ -13,124 +10,25 @@ function add_spacing {
   done
 }
 
-mkdir directory
-echo "test1" > directory/file
-echo "test1" > directory/file2
-
-
 echo "Here is a story that has been told throuhg the ages" >> file1
 
 git add file1
-git add directory
 git commit -m "first commit"
 
-git checkout -b feature/cherry-picking
-
-echo "this is file number 1 that I'm going to cherry-pick" > cherrypicking1
-echo "this is file number 2 that I'm going to cherry-pick" > cherrypicking2
-
-git add .
-
-git commit -am "first commit freshman year"
-
-echo "this is file number 3 that I'm going to cherry-pick" > cherrypicking3
-
-git add .
-
-git commit -am "second commit subway eat fresh"
-
-echo "this is file number 4 that I'm going to cherry-pick" > cherrypicking4
-
-git add .
-
-git commit -am "third commit fresh"
-
-echo "this is file number 5 that I'm going to cherry-pick" > cherrypicking5
-
-git add .
-
-git commit -am "fourth commit cool"
-
-echo "this is file number 6 that I'm going to cherry-pick" > cherrypicking6
-
-git add .
-
-git commit -am "fifth commit nice"
-
-echo "this is file number 7 that I'm going to cherry-pick" > cherrypicking7
-
-git add .
-
-git commit -am "sixth commit haha"
-
-echo "this is file number 8 that I'm going to cherry-pick" > cherrypicking8
-
-git add .
-
-git commit -am "seventh commit yeah"
-
-echo "this is file number 9 that I'm going to cherry-pick" > cherrypicking9
-
-git add .
-
-git commit -am "eighth commit woo"
-
-
 git checkout -b develop
+
 echo "once upon a time there was a dog" >> file1
 add_spacing file1
 echo "once upon a time there was another dog" >> file1
 git add file1
-echo "test2" > directory/file
-echo "test2" > directory/file2
-git add directory
 git commit -m "first commit on develop"
 
-
 git checkout master
+
 echo "once upon a time there was a cat" >> file1
 add_spacing file1
 echo "once upon a time there was another cat" >> file1
 git add file1
-echo "test3" > directory/file
-echo "test3" > directory/file2
-git add directory
-git commit -m "first commit on master"
+git commit -m "first commit on develop"
 
-
-git checkout develop
-echo "once upon a time there was a mouse" >> file3
-git add file3
-git commit -m "second commit on develop"
-
-
-git checkout master
-echo "once upon a time there was a horse" >> file3
-git add file3
-git commit -m "second commit on master"
-
-
-git checkout develop
-echo "once upon a time there was a mouse" >> file4
-git add file4
-git commit -m "third commit on develop"
-
-
-git checkout master
-echo "once upon a time there was a horse" >> file4
-git add file4
-git commit -m "third commit on master"
-
-
-git checkout develop
-echo "once upon a time there was a mouse" >> file5
-git add file5
-git commit -m "fourth commit on develop"
-
-
-git checkout master
-echo "once upon a time there was a horse" >> file5
-git add file5
-git commit -m "fourth commit on master"
-
-# git merge develop # should have a merge conflict here
+git merge develop # should have a merge conflict here

test/repos/pre_commit_hook.sh

@@ -2,9 +2,6 @@
 set -ex; rm -rf repo; mkdir repo; cd repo
 
 git init
-git config user.email "test@example.com"
-git config user.name "Lazygit Tester"
-
 cp ../extras/pre-commit .git/hooks/pre-commit
 chmod +x .git/hooks/pre-commit
 

test/repos/unicode_characters.sh

@@ -2,9 +2,6 @@
 set -ex; rm -rf repo; mkdir repo; cd repo
 
 git init
-git config user.email "test@example.com"
-git config user.name "Lazygit Tester"
-
 
 # Add some ansi, unicode, zero width joiner caracters
 cat <<EOT >> charstest.txt
@@ -15,8 +12,9 @@ ZWJ       https://en.wikipedia.org/wiki/Zero-width_joiner / https://unicode.org/
 UNICODE   ☆ 🤓 え 术
 EOT
 git add charstest.txt
-git commit -m "Test chars Œ¥ƒ👶👨‍👦☆ 🤓 え 术👩‍💻👩🏻‍💻👩🏽‍💻👩🏼‍💻👩🏾‍💻👩🏿‍💻👨‍💻👨🏻‍💻👨🏼‍💻👨🏽‍💻👨🏾‍💻👨🏿‍💻 commit"
+git commit -m "Test chars Œ¥ƒ👶👨‍👦☆ 🤓 え 术 commit"
 echo "我喜歡編碼" >> charstest.txt
 echo "நான் குறியீடு விரும்புகிறேன்" >> charstest.txt
 git add charstest.txt
 git commit -m "Test chars 我喜歡編碼 நான் குறியீடு விரும்புகிறேன் commit"
+