Merge pull request #231 from jesseduffield/feature/24-support-unicode-characters

Support unicode characters

.circleci/config.yml

@@ -0,0 +1,61 @@
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/golang:1.10
+
+    working_directory: /go/src/github.com/jesseduffield/lazygit
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - v1-pkg-cache
+      - 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
+      - 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: v1-pkg-cache
+          paths:
+            - "/go/pkg"
+
+  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: /.*/

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,29 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+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.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,17 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.gitignore

@@ -0,0 +1,19 @@
+# Please do not add personal files
+
+# Logs
+*.log
+
+# Extras
+extra/lgit.rb
+
+# Notes
+notes/go.notes
+TODO.notes
+TODO.md
+
+# Tests
+test/repos/repo
+coverage.txt
+
+# Binaries
+lazygit

.goreleaser.yml

@@ -0,0 +1,64 @@
+# This is an example goreleaser.yaml file with some sane defaults.
+# Make sure to check the documentation at http://goreleaser.com
+builds:
+  - env:
+      - CGO_ENABLED=0
+    goos:
+      - freebsd
+      - windows
+      - darwin
+      - linux
+    goarch:
+      - amd64
+      - 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
+
+archive:
+  replacements:
+    darwin: Darwin
+    linux: Linux
+    windows: Windows
+    386: 32-bit
+    amd64: x86_64
+  format_overrides:
+    - goos: windows
+      format: zip
+checksum:
+  name_template: 'checksums.txt'
+snapshot:
+  name_template: '{{ .Tag }}-next'
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - '^docs:'
+      - '^test:'
+      - '^bump'
+brew:
+  # Reporitory to push the tap to.
+  github:
+    owner: jesseduffield
+    name: homebrew-lazygit
+
+  # Your app's homepage.
+  # Default is empty.
+  homepage: 'https://github.com/jesseduffield/lazygit/'
+
+  # Your app's description.
+  # Default is empty.
+  description: 'A simple terminal UI for git commands, written in Go'
+
+  # # Packages your package depends on.
+  # dependencies:
+  #   - git
+  #   - zsh
+  # # Packages that conflict with your package.
+  # conflicts:
+  #   - svn
+  #   - bash
+
+# test comment to see if goreleaser only releases on new commits

CODE-OF-CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the [project leader](https://github.com/jesseduffield). 
+All complaints will be reviewed and investigated and will result in a response that
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org

CONTRIBUTING.md

@@ -0,0 +1,34 @@
+# Contributing
+
+
+♥ We love pull requests from everyone !
+
+
+When contributing to this repository, please first discuss the change you wish
+to make via issue, email, or any other method with the owners of this repository
+before making a change. 
+
+## So all code changes happen through Pull Requests
+Pull requests are the best way to propose changes to the codebase. We actively
+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. 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].
+
+[code of conduct]: https://github.com/jesseduffield/lazygit/blob/master/CODE-OF-CONDUCT.md
+
+## Any contributions you make will be under the MIT Software License
+In short, when you submit code changes, your submissions are understood to be
+under the same [MIT License](http://choosealicense.com/licenses/mit/) that
+covers the project. Feel free to contact the maintainers if that's a concern.
+
+## Report bugs using Github's [issues](https://github.com/jesseduffield/lazygit/issues)
+We use GitHub issues to track public bugs. Report a bug by [opening a new
+issue](https://github.com/jesseduffield/lazygit/issues/new); it's that easy!

Gopkg.lock

@@ -0,0 +1,635 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[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",
+  ]
+  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"
+
+[[projects]]
+  branch = "master"
+  digest = "1:cd7ba2b29e93e2a8384e813dfc80ebb0f85d9214762e6ca89bb55a58092eab87"
+  name = "github.com/cloudfoundry/jibber_jabber"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "bcc4c8345a21301bf47c032ff42dd1aae2fe3027"
+
+[[projects]]
+  digest = "1:a2c1d0e43bd3baaa071d1b9ed72c27d78169b2b269f71c105ac4ba34b1be4a39"
+  name = "github.com/davecgh/go-spew"
+  packages = ["spew"]
+  pruneopts = "NUT"
+  revision = "346938d642f2ec3594ed81d874461961cd0faa76"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:de4a74b504df31145ffa8ca0c4edbffa2f3eb7f466753962184611b618fa5981"
+  name = "github.com/emirpasic/gods"
+  packages = [
+    "containers",
+    "lists",
+    "lists/arraylist",
+    "trees",
+    "trees/binaryheap",
+    "utils",
+  ]
+  pruneopts = "NUT"
+  revision = "f6c17b524822278a87e3b3bd809fec33b51f5b46"
+  version = "v1.9.0"
+
+[[projects]]
+  digest = "1:ade392a843b2035effb4b4a2efa2c3bab3eb29b992e98bacf9c898b0ecb54e45"
+  name = "github.com/fatih/color"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "5b77d2a35fb0ede96d138fc9a99f5c9b6aef11b4"
+  version = "v1.7.0"
+
+[[projects]]
+  digest = "1:1b91ae0dc69a41d4c2ed23ea5cffb721ea63f5037ca4b81e6d6771fbb8f45129"
+  name = "github.com/fsnotify/fsnotify"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9"
+  version = "v1.4.7"
+
+[[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"
+  name = "github.com/golang-collections/collections"
+  packages = ["stack"]
+  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"
+  name = "github.com/hashicorp/hcl"
+  packages = [
+    ".",
+    "hcl/ast",
+    "hcl/parser",
+    "hcl/printer",
+    "hcl/scanner",
+    "hcl/strconv",
+    "hcl/token",
+    "json/parser",
+    "json/scanner",
+    "json/token",
+  ]
+  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"
+  name = "github.com/jbenet/go-context"
+  packages = ["io"]
+  pruneopts = "NUT"
+  revision = "d14ea06fba99483203c19d92cfcd13ebe73135f4"
+
+[[projects]]
+  branch = "master"
+  digest = "1:490643e333b848f3d6ab772c21082d706663dcf4a3c0fbe9a4b4ef7b205ce6c7"
+  name = "github.com/jesseduffield/go-getter"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "906e15686e6309ff310c1c10463ab53287c3a678"
+
+[[projects]]
+  branch = "master"
+  digest = "1:acbcdae312c37a8019e0f573a9be26499058d5e1244243655373d2fd97714658"
+  name = "github.com/jesseduffield/gocui"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "5d9e836837237cb3aadca51ecb37c7cf3345bfa4"
+
+[[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"
+
+[[projects]]
+  digest = "1:8021af4dcbd531ae89433c8c3a6520e51064114aaf8eb1724c3cf911c497c9ba"
+  name = "github.com/kevinburke/ssh_config"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "9fc7bb800b555d63157c65a904c86a2cc7b4e795"
+  version = "0.4"
+
+[[projects]]
+  digest = "1:d244f8666a838fe6ad70ec8fe77f50ebc29fdc3331a2729ba5886bef8435d10d"
+  name = "github.com/magiconair/properties"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "c2353362d570a7bfa228149c62842019201cfb71"
+  version = "v1.8.0"
+
+[[projects]]
+  digest = "1:08c231ec84231a7e23d67e4b58f975e1423695a32467a362ee55a803f9de8061"
+  name = "github.com/mattn/go-colorable"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
+  version = "v0.0.9"
+
+[[projects]]
+  digest = "1:bc4f7eec3b7be8c6cb1f0af6c1e3333d5bb71072951aaaae2f05067b0803f287"
+  name = "github.com/mattn/go-isatty"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39"
+  version = "v0.0.3"
+
+[[projects]]
+  digest = "1:cb591533458f6eb6e2c1065ff3eac6b50263d7847deb23fc9f79b25bc608970e"
+  name = "github.com/mattn/go-runewidth"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "9e777a8366cce605130a531d2cd6363d07ad7317"
+  version = "v0.0.2"
+
+[[projects]]
+  digest = "1:a25c9a6b41e100f4ce164db80260f2b687095ba9d8b46a1d6072d3686cc020db"
+  name = "github.com/mgutz/str"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "968bf66e3da857419e4f6e71b2d5c9ae95682dc4"
+  version = "v1.2.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:a4df73029d2c42fabcb6b41e327d2f87e685284ec03edf76921c267d9cfc9c23"
+  name = "github.com/mitchellh/go-homedir"
+  packages = ["."]
+  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"
+  name = "github.com/mitchellh/mapstructure"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "f15292f7a699fcc1a38a80977f80a046874ba8ac"
+
+[[projects]]
+  digest = "1:2c34c77bf3ec848da26e48af58fc511ed52750961fa848399d122882b8890928"
+  name = "github.com/nicksnyder/go-i18n"
+  packages = [
+    "v2/i18n",
+    "v2/internal",
+    "v2/internal/plural",
+  ]
+  pruneopts = "NUT"
+  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"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "c37440a7cf42ac63b919c752ca73a85067e05992"
+  version = "v0.2.0"
+
+[[projects]]
+  digest = "1:51ea800cff51752ff68e12e04106f5887b4daec6f9356721238c28019f0b42db"
+  name = "github.com/pelletier/go-toml"
+  packages = ["."]
+  pruneopts = "NUT"
+  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"
+  packages = ["diffmatchpatch"]
+  pruneopts = "NUT"
+  revision = "1744e2970ca51c86172c8190fadad617561ed6e7"
+  version = "v1.0.0"
+
+[[projects]]
+  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"
+  packages = [
+    ".",
+    "mem",
+  ]
+  pruneopts = "NUT"
+  revision = "787d034dfe70e44075ccc060d346146ef53270ad"
+  version = "v1.1.1"
+
+[[projects]]
+  digest = "1:3fa7947ca83b98ae553590d993886e845a4bff19b7b007e869c6e0dd3b9da9cd"
+  name = "github.com/spf13/cast"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "8965335b8c7107321228e3e3702cab9832751bac"
+  version = "v1.2.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:f29f83301ed096daed24a90f4af591b7560cb14b9cc3e1827abbf04db7269ab5"
+  name = "github.com/spf13/jwalterweatherman"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "14d3d4c518341bea657dd8a226f5121c0ff8c9f2"
+
+[[projects]]
+  digest = "1:e3707aeaccd2adc89eba6c062fec72116fe1fc1ba71097da85b4d8ae1668a675"
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "9a97c102cda95a86cec2345a6f09f55a939babf5"
+  version = "v1.0.2"
+
+[[projects]]
+  digest = "1:454979540e2a1582f375a17c106cf4e11e3bcac4baffb4af23e515c87f87de13"
+  name = "github.com/spf13/viper"
+  packages = ["."]
+  pruneopts = "NUT"
+  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"
+  packages = [
+    ".",
+    "scanner",
+    "token",
+    "types",
+  ]
+  pruneopts = "NUT"
+  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"
+  packages = ["."]
+  pruneopts = "NUT"
+  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"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "640f0ab560aeb89d523bb6ac322b1244d5c3796c"
+  version = "v0.2.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:dfcb1b2db354cafa48fc3cdafe4905a08bec4a9757919ab07155db0ca23855b4"
+  name = "golang.org/x/crypto"
+  packages = [
+    "cast5",
+    "curve25519",
+    "ed25519",
+    "ed25519/internal/edwards25519",
+    "internal/chacha20",
+    "internal/subtle",
+    "openpgp",
+    "openpgp/armor",
+    "openpgp/elgamal",
+    "openpgp/errors",
+    "openpgp/packet",
+    "openpgp/s2k",
+    "poly1305",
+    "ssh",
+    "ssh/agent",
+    "ssh/knownhosts",
+    "ssh/terminal",
+  ]
+  pruneopts = "NUT"
+  revision = "de0752318171da717af4ce24d0a2e8626afaeb11"
+
+[[projects]]
+  branch = "master"
+  digest = "1:76ee51c3f468493aff39dbacc401e8831fbb765104cbf613b89bef01cf4bad70"
+  name = "golang.org/x/net"
+  packages = ["context"]
+  pruneopts = "NUT"
+  revision = "c39426892332e1bb5ec0a434a079bf82f5d30c54"
+
+[[projects]]
+  branch = "master"
+  digest = "1:ec76a40fbfda0c329ee58f4e3b14b4279a939efce89eca020e934e2e5234eddd"
+  name = "golang.org/x/sys"
+  packages = [
+    "unix",
+    "windows",
+  ]
+  pruneopts = "NUT"
+  revision = "98c5dad5d1a0e8a73845ecc8897d0bd56586511d"
+
+[[projects]]
+  digest = "1:a95288ef1ef4dfad6cba7fe30843e1683f71bc28c912ca1ba3f6a539d44db739"
+  name = "golang.org/x/text"
+  packages = [
+    "internal/gen",
+    "internal/tag",
+    "internal/triegen",
+    "internal/ucd",
+    "language",
+    "transform",
+    "unicode/cldr",
+    "unicode/norm",
+  ]
+  pruneopts = "NUT"
+  revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
+  version = "v0.3.0"
+
+[[projects]]
+  digest = "1:47a697b155f5214ff14e68e39ce9c2e8d93e1fb035ae5ba7e247d044e0ce64e3"
+  name = "gopkg.in/src-d/go-billy.v4"
+  packages = [
+    ".",
+    "helper/chroot",
+    "helper/polyfill",
+    "osfs",
+    "util",
+  ]
+  pruneopts = "NUT"
+  revision = "83cf655d40b15b427014d7875d10850f96edba14"
+  version = "v4.2.0"
+
+[[projects]]
+  digest = "1:e66078da2bd6e53c72518d7f6ae0c3c8c7f34c0df12c39435ce34a6bce165525"
+  name = "gopkg.in/src-d/go-git.v4"
+  packages = [
+    ".",
+    "config",
+    "internal/revision",
+    "plumbing",
+    "plumbing/cache",
+    "plumbing/filemode",
+    "plumbing/format/config",
+    "plumbing/format/diff",
+    "plumbing/format/gitignore",
+    "plumbing/format/idxfile",
+    "plumbing/format/index",
+    "plumbing/format/objfile",
+    "plumbing/format/packfile",
+    "plumbing/format/pktline",
+    "plumbing/object",
+    "plumbing/protocol/packp",
+    "plumbing/protocol/packp/capability",
+    "plumbing/protocol/packp/sideband",
+    "plumbing/revlist",
+    "plumbing/storer",
+    "plumbing/transport",
+    "plumbing/transport/client",
+    "plumbing/transport/file",
+    "plumbing/transport/git",
+    "plumbing/transport/http",
+    "plumbing/transport/internal/common",
+    "plumbing/transport/server",
+    "plumbing/transport/ssh",
+    "storage",
+    "storage/filesystem",
+    "storage/filesystem/dotgit",
+    "storage/memory",
+    "utils/binary",
+    "utils/diff",
+    "utils/ioutil",
+    "utils/merkletrie",
+    "utils/merkletrie/filesystem",
+    "utils/merkletrie/index",
+    "utils/merkletrie/internal/frame",
+    "utils/merkletrie/noder",
+  ]
+  pruneopts = "NUT"
+  revision = "43d17e14b714665ab5bc2ecc220b6740779d733f"
+
+[[projects]]
+  digest = "1:b233ad4ec87ac916e7bf5e678e98a2cb9e8b52f6de6ad3e11834fc7a71b8e3bf"
+  name = "gopkg.in/warnings.v0"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "ec4a0fea49c7b46c2aeb0b51aac55779c607e52b"
+  version = "v0.1.2"
+
+[[projects]]
+  digest = "1:7c95b35057a0ff2e19f707173cc1a947fa43a6eb5c4d300d196ece0334046082"
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
+  version = "v2.2.1"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  input-imports = [
+    "github.com/cloudfoundry/jibber_jabber",
+    "github.com/davecgh/go-spew/spew",
+    "github.com/fatih/color",
+    "github.com/golang-collections/collections/stack",
+    "github.com/heroku/rollrus",
+    "github.com/jesseduffield/go-getter",
+    "github.com/jesseduffield/gocui",
+    "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

@@ -0,0 +1,46 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+
+[prune]
+  go-tests = true
+  unused-packages = true
+  non-go = true
+
+[[constraint]]
+  name = "github.com/fatih/color"
+  version = "1.7.0"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/golang-collections/collections"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/jesseduffield/gocui"
+
+[[constraint]]
+  name = "gopkg.in/src-d/go-git.v4"
+  revision = "43d17e14b714665ab5bc2ecc220b6740779d733f"
+
+[[constraint]]
+  branch = "master"
+  name = "github.com/spkg/bom"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Jesse Duffield
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,133 @@
+# 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)]()
+
+A simple terminal UI for git commands, written in Go with the [gocui](https://github.com/jroimartin/gocui "gocui") library.
+
+Are YOU tired of typing every git command directly into the terminal, but you're
+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)
+
+  * [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://www.youtube.com/watch?v=VDXvbHZYeKY)
+  * [Twitch Stream](https://www.twitch.tv/jesseduffield)
+
+## Installation
+
+### Homebrew
+```sh
+brew tap jesseduffield/lazygit
+brew install lazygit
+```
+
+### Ubuntu
+Packages for Ubuntu 16.04, 18.04 and 18.10 are available via [Launchpad PPA](https://launchpad.net/~lazygit-team).
+
+**Release builds**
+
+Built from git tags. Supposed to be more stable.
+
+```sh
+sudo add-apt-repository ppa:lazygit-team/release
+sudo apt-get update
+sudo apt-get install lazygit
+```
+
+**Daily builds**
+
+Built from master branch once in 24 hours (or more sometimes).
+
+```sh
+sudo add-apt-repository ppa:lazygit-team/daily
+sudo apt-get update
+sudo apt-get install lazygit
+```
+
+### Void Linux
+Packages for Void Linux are available in the distro repo
+
+They follow upstream latest releases
+
+```sh
+sudo xbps-install -S lazygit
+```
+
+### Arch Linux
+Packages for Arch Linux are available via AUR (Arch User Repository).
+
+There are two packages. The stable one which is built with the latest release
+and the git version which builds from the most recent commit.
+
+  * Stable: https://aur.archlinux.org/packages/lazygit/
+  * Development: https://aur.archlinux.org/packages/lazygit-git/
+
+Instruction of how to install AUR content can be found here:
+https://wiki.archlinux.org/index.php/Arch_User_Repository
+
+### Binary Release (Windows/Linux/OSX)
+You can download a binary release [here](https://github.com/jesseduffield/lazygit/releases).
+
+### Go
+```sh
+go get github.com/jesseduffield/lazygit
+```
+
+Please note:
+If you get an error claiming that lazygit cannot be found or is not defined, you
+may need to add `~/go/bin` to your $PATH (MacOS/Linux), or `%HOME%\go\bin`
+(Windows). Not to be mistaked for `C:\Go\bin` (which is for Go's own binaries,
+not apps like Lazygit).
+
+## Usage
+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://www.youtube.com/watch?v=VDXvbHZYeKY).
+  * List of keybindings
+[here](/docs/Keybindings.md).
+
+## Cool features
+  * Adding files easily
+  * Resolving merge conflicts
+  * Easily check out recent branches
+  * Scroll through logs/diffs of branches/commits/stash
+  * Quick pushing/pulling
+  * Squash down and rename commits
+
+### Resolving merge conflicts
+![Gif](/docs/resources/resolving-merge-conflicts.gif)
+
+### Viewing commit diffs
+![Viewing Commit Diffs](/docs/resources/viewing-commit-diffs.png)
+
+## Milestones
+- [x] Easy Installation (homebrew, release binaries)
+- [ ] Configurable Keybindings
+- [ ] Configurable Color Themes
+- [ ] Spawning Subprocesses (help needed - have a look at https://github.com/jesseduffield/lazygit/pull/18)
+- [ ] Maintainability
+- [ ] Performance
+- [ ] i18n
+
+## Contributing
+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)
+
+## Work in progress
+This is still a work in progress so there's still bugs to iron out and as this
+is my first project in Go the code could no doubt use an increase in quality,
+but I'll be improving on it whenever I find the time. If you have any feedback
+feel free to [raise an issue](https://github.com/jesseduffield/lazygit/issues)/[submit a PR](https://github.com/jesseduffield/lazygit/pulls).
+
+## Social
+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).

docs/Config.md

@@ -0,0 +1,47 @@
+# User Config:
+
+## Default:
+
+```
+  gui:
+    # stuff relating to the UI
+    scrollHeight: 2 # how many lines you scroll by
+    theme:
+      activeBorderColor:
+        - white
+        - bold
+      inactiveBorderColor:
+        - white
+      optionsTextColor:
+        - blue
+  git:
+    # stuff relating to git
+  os:
+    # stuff relating to the OS
+  update:
+    method: prompt # can be: prompt | background | never
+    days: 14 # how often an update is checked for
+  reporting: 'undetermined' # one of: 'on' | 'off' | 'undetermined'
+```
+
+## Color Attributes:
+
+For color attributes you can choose an array of attributes (with max one color attribute)
+The available attributes are:
+
+- default
+- black
+- red
+- green
+- yellow
+- blue
+- magenta
+- cyan
+- white
+- bold
+- reverse # useful for high-contrast
+- underline
+
+## Example Coloring:
+
+![border example](/docs/resources/colored-border-example.png)

docs/Keybindings.md

@@ -0,0 +1,84 @@
+# 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>a</kbd>:        stage/unstage all
+  <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
+  <kbd>shift</kbd>+<kbd>A</kbd>: abort merge
+</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
+  <kbd>D</kbd>:       force 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>

main.go

@@ -0,0 +1,53 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"runtime"
+
+	"github.com/jesseduffield/lazygit/pkg/app"
+	"github.com/jesseduffield/lazygit/pkg/config"
+)
+
+var (
+	commit      string
+	version     = "unversioned"
+	date        string
+	buildSource = "unknown"
+
+	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")
+)
+
+func projectPath(path string) string {
+	gopath := os.Getenv("GOPATH")
+	return filepath.FromSlash(gopath + "/src/github.com/jesseduffield/lazygit/" + path)
+}
+
+func main() {
+	flag.Parse()
+	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)
+		os.Exit(0)
+	}
+
+	if *configFlag {
+		fmt.Printf("%s\n", config.GetDefaultConfig())
+		os.Exit(0)
+	}
+	appConfig, err := config.NewAppConfig("lazygit", version, commit, date, buildSource, debuggingFlag)
+	if err != nil {
+		panic(err)
+	}
+
+	app, err := app.NewApp(appConfig)
+	if err != nil {
+		app.Log.Error(err.Error())
+		panic(err)
+	}
+	app.GitCommand.SetupGit()
+	app.Gui.RunWithSubprocesses()
+}

pkg/app/app.go

@@ -0,0 +1,104 @@
+package app
+
+import (
+	"io"
+	"io/ioutil"
+	"os"
+
+	"github.com/heroku/rollrus"
+	"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/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
+}
+
+func newProductionLogger(config config.AppConfigurer) *logrus.Logger {
+	log := logrus.New()
+	log.Out = ioutil.Discard
+	return log
+}
+
+func newDevelopmentLogger() *logrus.Logger {
+	log := logrus.New()
+	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)
+	}
+	log.SetOutput(file)
+	return log
+}
+
+func newLogger(config config.AppConfigurer) *logrus.Entry {
+	var log *logrus.Logger
+	environment := "production"
+	if config.GetDebug() {
+		environment = "development"
+		log = newDevelopmentLogger()
+	} else {
+		log = newProductionLogger(config)
+	}
+	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 retruns a new applications
+func NewApp(config config.AppConfigurer) (*App, error) {
+	app := &App{
+		closers: []io.Closer{},
+		Config:  config,
+	}
+	var err error
+	app.Log = newLogger(config)
+	app.OSCommand = commands.NewOSCommand(app.Log)
+
+	app.Tr = i18n.NewLocalizer(app.Log)
+
+	app.GitCommand, err = commands.NewGitCommand(app.Log, app.OSCommand, app.Tr)
+	if err != nil {
+		return app, err
+	}
+	app.Updater, err = updates.NewUpdater(app.Log, config, app.OSCommand, app.Tr)
+	if err != nil {
+		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 app, nil
+}
+
+// Close closes any resources
+func (app *App) Close() error {
+	for _, closer := range app.closers {
+		err := closer.Close()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

pkg/commands/branch.go

@@ -0,0 +1,39 @@
+package commands
+
+import (
+	"strings"
+
+	"github.com/fatih/color"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
+// Branch : A git branch
+// duplicating this for now
+type Branch struct {
+	Name    string
+	Recency string
+}
+
+// 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
+func (b *Branch) GetColor() color.Attribute {
+	switch b.getType() {
+	case "feature":
+		return color.FgGreen
+	case "bugfix":
+		return color.FgYellow
+	case "hotfix":
+		return color.FgRed
+	default:
+		return color.FgWhite
+	}
+}
+
+// expected to return feature/bugfix/hotfix or blank string
+func (b *Branch) getType() string {
+	return strings.Split(b.Name, "/")[0]
+}

pkg/commands/git.go

@@ -0,0 +1,525 @@
+package commands
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/i18n"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+	"github.com/sirupsen/logrus"
+	gitconfig "github.com/tcnksm/go-gitconfig"
+	gogit "gopkg.in/src-d/go-git.v4"
+)
+
+// GitCommand is our main git interface
+type GitCommand struct {
+	Log       *logrus.Entry
+	OSCommand *OSCommand
+	Worktree  *gogit.Worktree
+	Repo      *gogit.Repository
+	Tr        *i18n.Localizer
+}
+
+// NewGitCommand it runs git commands
+func NewGitCommand(log *logrus.Entry, osCommand *OSCommand, tr *i18n.Localizer) (*GitCommand, error) {
+	gitCommand := &GitCommand{
+		Log:       log,
+		OSCommand: osCommand,
+		Tr:        tr,
+	}
+	return gitCommand, nil
+}
+
+// SetupGit sets git repo up
+func (c *GitCommand) SetupGit() {
+	c.verifyInGitRepo()
+	c.navigateToRepoRootDirectory()
+	if err := c.setupWorktree(); err != nil {
+		c.Log.Error(err)
+		panic(err)
+	}
+}
+
+// GetStashEntries stash entryies
+func (c *GitCommand) GetStashEntries() []StashEntry {
+	stashEntries := make([]StashEntry, 0)
+	rawString, _ := c.OSCommand.RunCommandWithOutput("git stash list --pretty='%gs'")
+	for i, line := range utils.SplitLines(rawString) {
+		stashEntries = append(stashEntries, stashEntryFromLine(line, i))
+	}
+	return stashEntries
+}
+
+func stashEntryFromLine(line string, index int) StashEntry {
+	return StashEntry{
+		Name:          line,
+		Index:         index,
+		DisplayString: line,
+	}
+}
+
+// GetStashEntryDiff stash diff
+func (c *GitCommand) GetStashEntryDiff(index int) (string, error) {
+	return c.OSCommand.RunCommandWithOutput("git stash show -p --color stash@{" + fmt.Sprint(index) + "}")
+}
+
+func includes(array []string, str string) bool {
+	for _, arrayStr := range array {
+		if arrayStr == str {
+			return true
+		}
+	}
+	return false
+}
+
+// GetStatusFiles git status files
+func (c *GitCommand) GetStatusFiles() []File {
+	statusOutput, _ := c.GitStatus()
+	statusStrings := utils.SplitLines(statusOutput)
+	files := make([]File, 0)
+
+	for _, statusString := range statusStrings {
+		change := statusString[0:2]
+		stagedChange := change[0:1]
+		unstagedChange := statusString[1:2]
+		filename := c.OSCommand.Unquote(statusString[3:])
+		tracked := !includes([]string{"??", "A ", "AM"}, change)
+		file := File{
+			Name:               filename,
+			DisplayString:      statusString,
+			HasStagedChanges:   !includes([]string{" ", "U", "?"}, stagedChange),
+			HasUnstagedChanges: unstagedChange != " ",
+			Tracked:            tracked,
+			Deleted:            unstagedChange == "D" || stagedChange == "D",
+			HasMergeConflicts:  change == "UU",
+			Type:               c.OSCommand.FileType(filename),
+		}
+		files = append(files, file)
+	}
+	c.Log.Info(files) // TODO: use a dumper-esque log here
+	return files
+}
+
+// StashDo modify stash
+func (c *GitCommand) StashDo(index int, method string) error {
+	return c.OSCommand.RunCommand("git stash " + method + " stash@{" + fmt.Sprint(index) + "}")
+}
+
+// StashSave save stash
+// TODO: before calling this, check if there is anything to save
+func (c *GitCommand) StashSave(message string) error {
+	return c.OSCommand.RunCommand("git stash save " + c.OSCommand.Quote(message))
+}
+
+// MergeStatusFiles merge status files
+func (c *GitCommand) MergeStatusFiles(oldFiles, newFiles []File) []File {
+	if len(oldFiles) == 0 {
+		return newFiles
+	}
+
+	appendedIndexes := make([]int, 0)
+
+	// retain position of files we already could see
+	result := make([]File, 0)
+	for _, oldFile := range oldFiles {
+		for newIndex, newFile := range newFiles {
+			if oldFile.Name == newFile.Name {
+				result = append(result, newFile)
+				appendedIndexes = append(appendedIndexes, newIndex)
+				break
+			}
+		}
+	}
+
+	// append any new files to the end
+	for index, newFile := range newFiles {
+		if !includesInt(appendedIndexes, index) {
+			result = append(result, newFile)
+		}
+	}
+
+	return result
+}
+
+func (c *GitCommand) verifyInGitRepo() {
+	if output, err := c.OSCommand.RunCommandWithOutput("git status"); err != nil {
+		fmt.Println(output)
+		os.Exit(1)
+	}
+}
+
+// GetBranchName branch name
+func (c *GitCommand) GetBranchName() (string, error) {
+	return c.OSCommand.RunCommandWithOutput("git symbolic-ref --short HEAD")
+}
+
+func (c *GitCommand) navigateToRepoRootDirectory() {
+	_, err := os.Stat(".git")
+	for os.IsNotExist(err) {
+		c.Log.Debug("going up a directory to find the root")
+		os.Chdir("..")
+		_, err = os.Stat(".git")
+	}
+}
+
+func (c *GitCommand) setupWorktree() error {
+	r, err := gogit.PlainOpen(".")
+	if err != nil {
+		if strings.Contains(err.Error(), `unquoted '\' must be followed by new line`) {
+			errorMessage := c.Tr.SLocalize("GitconfigParseErr")
+			return errors.New(errorMessage)
+		}
+		return err
+	}
+	c.Repo = r
+
+	w, err := r.Worktree()
+	if err != nil {
+		return err
+	}
+	c.Worktree = w
+	return nil
+}
+
+// ResetHard does the equivalent of `git reset --hard HEAD`
+func (c *GitCommand) ResetHard() error {
+	return c.Worktree.Reset(&gogit.ResetOptions{Mode: gogit.HardReset})
+}
+
+// UpstreamDifferenceCount checks how many pushables/pullables there are for the
+// current branch
+func (c *GitCommand) UpstreamDifferenceCount() (string, string) {
+	pushableCount, err := c.OSCommand.RunCommandWithOutput("git rev-list @{u}..head --count")
+	if err != nil {
+		return "?", "?"
+	}
+	pullableCount, err := c.OSCommand.RunCommandWithOutput("git rev-list head..@{u} --count")
+	if err != nil {
+		return "?", "?"
+	}
+	return strings.TrimSpace(pushableCount), strings.TrimSpace(pullableCount)
+}
+
+// GetCommitsToPush Returns the sha's of the commits that have not yet been pushed
+// to the remote branch of the current branch
+func (c *GitCommand) GetCommitsToPush() []string {
+	pushables, err := c.OSCommand.RunCommandWithOutput("git rev-list @{u}..head --abbrev-commit")
+	if err != nil {
+		return make([]string, 0)
+	}
+	return utils.SplitLines(pushables)
+}
+
+// RenameCommit renames the topmost commit with the given name
+func (c *GitCommand) RenameCommit(name string) error {
+	return c.OSCommand.RunCommand("git commit --allow-empty --amend -m " + c.OSCommand.Quote(name))
+}
+
+// Fetch fetch git repo
+func (c *GitCommand) Fetch() error {
+	return c.OSCommand.RunCommand("git fetch")
+}
+
+// ResetToCommit reset to commit
+func (c *GitCommand) ResetToCommit(sha string) error {
+	return c.OSCommand.RunCommand("git reset " + sha)
+}
+
+// NewBranch create new branch
+func (c *GitCommand) NewBranch(name string) error {
+	return c.OSCommand.RunCommand("git checkout -b " + name)
+}
+
+// DeleteBranch delete branch
+func (c *GitCommand) DeleteBranch(branch string, force bool) error {
+	var command string
+	if force {
+		command = "git branch -D "
+	} else {
+		command = "git branch -d "
+	}
+	return c.OSCommand.RunCommand(command + branch)
+}
+
+// ListStash list stash
+func (c *GitCommand) ListStash() (string, error) {
+	return c.OSCommand.RunCommandWithOutput("git stash list")
+}
+
+// Merge merge
+func (c *GitCommand) Merge(branchName string) error {
+	return c.OSCommand.RunCommand("git merge --no-edit " + branchName)
+}
+
+// AbortMerge abort merge
+func (c *GitCommand) AbortMerge() error {
+	return c.OSCommand.RunCommand("git merge --abort")
+}
+
+// UsingGpg tells us whether the user has gpg enabled so that we can know
+// whether we need to run a subprocess to allow them to enter their password
+func (c *GitCommand) UsingGpg() bool {
+	gpgsign, _ := gitconfig.Global("commit.gpgsign")
+	if gpgsign == "" {
+		gpgsign, _ = gitconfig.Local("commit.gpgsign")
+	}
+	if gpgsign == "" {
+		return false
+	}
+	return true
+}
+
+// Commit commit to git
+func (c *GitCommand) Commit(g *gocui.Gui, message string) (*exec.Cmd, error) {
+	command := "git commit -m " + c.OSCommand.Quote(message)
+	if c.UsingGpg() {
+		return c.OSCommand.PrepareSubProcess(c.OSCommand.Platform.shell, c.OSCommand.Platform.shellArg, command), nil
+	}
+	return nil, c.OSCommand.RunCommand(command)
+}
+
+// Pull pull from repo
+func (c *GitCommand) Pull() error {
+	return c.OSCommand.RunCommand("git pull --no-edit")
+}
+
+// Push push to a branch
+func (c *GitCommand) Push(branchName string, force bool) error {
+	forceFlag := ""
+	if force {
+		forceFlag = "--force-with-lease "
+	}
+	return c.OSCommand.RunCommand("git push " + forceFlag + "-u origin " + branchName)
+}
+
+// SquashPreviousTwoCommits squashes a commit down to the one below it
+// retaining the message of the higher commit
+func (c *GitCommand) SquashPreviousTwoCommits(message string) error {
+	// TODO: test this
+	err := c.OSCommand.RunCommand("git reset --soft HEAD^")
+	if err != nil {
+		return err
+	}
+	// TODO: if password is required, we need to return a subprocess
+	return c.OSCommand.RunCommand("git commit --amend -m " + c.OSCommand.Quote(message))
+}
+
+// SquashFixupCommit squashes a 'FIXUP' commit into the commit beneath it,
+// retaining the commit message of the lower commit
+func (c *GitCommand) SquashFixupCommit(branchName string, shaValue string) error {
+	var err error
+	commands := []string{
+		"git checkout -q " + shaValue,
+		"git reset --soft " + shaValue + "^",
+		"git commit --amend -C " + shaValue + "^",
+		"git rebase --onto HEAD " + shaValue + " " + branchName,
+	}
+	ret := ""
+	for _, command := range commands {
+		c.Log.Info(command)
+		output, err := c.OSCommand.RunCommandWithOutput(command)
+		ret += output
+		if err != nil {
+			c.Log.Info(ret)
+			break
+		}
+	}
+	if err != nil {
+		// We are already in an error state here so we're just going to append
+		// the output of these commands
+		output, _ := c.OSCommand.RunCommandWithOutput("git branch -d " + shaValue)
+		ret += output
+		output, _ = c.OSCommand.RunCommandWithOutput("git checkout " + branchName)
+		ret += output
+	}
+	if err != nil {
+		return errors.New(ret)
+	}
+	return nil
+}
+
+// CatFile obtain the contents of a file
+func (c *GitCommand) CatFile(fileName string) (string, error) {
+	return c.OSCommand.RunCommandWithOutput("cat " + c.OSCommand.Quote(fileName))
+}
+
+// StageFile stages a file
+func (c *GitCommand) StageFile(fileName string) error {
+	return c.OSCommand.RunCommand("git add " + c.OSCommand.Quote(fileName))
+}
+
+// StageAll stages all files
+func (c *GitCommand) StageAll() error {
+	return c.OSCommand.RunCommand("git add -A")
+}
+
+// UnstageAll stages all files
+func (c *GitCommand) UnstageAll() error {
+	return c.OSCommand.RunCommand("git reset")
+}
+
+// UnStageFile unstages a file
+func (c *GitCommand) UnStageFile(fileName string, tracked bool) error {
+	var command string
+	if tracked {
+		command = "git reset HEAD "
+	} else {
+		command = "git rm --cached "
+	}
+	return c.OSCommand.RunCommand(command + c.OSCommand.Quote(fileName))
+}
+
+// GitStatus returns the plaintext short status of the repo
+func (c *GitCommand) GitStatus() (string, error) {
+	return c.OSCommand.RunCommandWithOutput("git status --untracked-files=all --short")
+}
+
+// IsInMergeState states whether we are still mid-merge
+func (c *GitCommand) IsInMergeState() (bool, error) {
+	output, err := c.OSCommand.RunCommandWithOutput("git status --untracked-files=all")
+	if err != nil {
+		return false, err
+	}
+	return strings.Contains(output, "conclude merge") || strings.Contains(output, "unmerged paths"), nil
+}
+
+// RemoveFile directly
+func (c *GitCommand) RemoveFile(file File) error {
+	// if the file isn't tracked, we assume you want to delete it
+	if file.HasStagedChanges {
+		if err := c.OSCommand.RunCommand("git reset -- " + file.Name); err != nil {
+			return err
+		}
+	}
+	if !file.Tracked {
+		return os.RemoveAll(file.Name)
+	}
+	// if the file is tracked, we assume you want to just check it out
+	return c.OSCommand.RunCommand("git checkout -- " + file.Name)
+}
+
+// Checkout checks out a branch, with --force if you set the force arg to true
+func (c *GitCommand) Checkout(branch string, force bool) error {
+	forceArg := ""
+	if force {
+		forceArg = "--force "
+	}
+	return c.OSCommand.RunCommand("git checkout " + forceArg + branch)
+}
+
+// AddPatch prepares a subprocess for adding a patch by patch
+// this will eventually be swapped out for a better solution inside the Gui
+func (c *GitCommand) AddPatch(filename string) *exec.Cmd {
+	return c.OSCommand.PrepareSubProcess("git", "add", "--patch", filename)
+}
+
+// PrepareCommitSubProcess prepares a subprocess for `git commit`
+func (c *GitCommand) PrepareCommitSubProcess() *exec.Cmd {
+	return c.OSCommand.PrepareSubProcess("git", "commit")
+}
+
+// GetBranchGraph gets the color-formatted graph of the log for the given branch
+// Currently it limits the result to 100 commits, but when we get async stuff
+// working we can do lazy loading
+func (c *GitCommand) GetBranchGraph(branchName string) (string, error) {
+	return c.OSCommand.RunCommandWithOutput("git log --graph --color --abbrev-commit --decorate --date=relative --pretty=medium -100 " + branchName)
+}
+
+// Map (from https://gobyexample.com/collection-functions)
+func Map(vs []string, f func(string) string) []string {
+	vsm := make([]string, len(vs))
+	for i, v := range vs {
+		vsm[i] = f(v)
+	}
+	return vsm
+}
+
+func includesString(list []string, a string) bool {
+	for _, b := range list {
+		if b == a {
+			return true
+		}
+	}
+	return false
+}
+
+// not sure how to genericise this because []interface{} doesn't accept e.g.
+// []int arguments
+func includesInt(list []int, a int) bool {
+	for _, b := range list {
+		if b == a {
+			return true
+		}
+	}
+	return false
+}
+
+// GetCommits obtains the commits of the current branch
+func (c *GitCommand) GetCommits() []Commit {
+	pushables := c.GetCommitsToPush()
+	log := c.GetLog()
+	commits := make([]Commit, 0)
+	// now we can split it up and turn it into commits
+	lines := utils.SplitLines(log)
+	for _, line := range lines {
+		splitLine := strings.Split(line, " ")
+		sha := splitLine[0]
+		pushed := includesString(pushables, sha)
+		commits = append(commits, Commit{
+			Sha:           sha,
+			Name:          strings.Join(splitLine[1:], " "),
+			Pushed:        pushed,
+			DisplayString: strings.Join(splitLine, " "),
+		})
+	}
+	return commits
+}
+
+// GetLog gets the git log (currently limited to 30 commits for performance
+// until we work out lazy loading
+func (c *GitCommand) 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
+}
+
+// Ignore adds a file to the gitignore for the repo
+func (c *GitCommand) Ignore(filename string) error {
+	return c.OSCommand.AppendLineToFile(".gitignore", filename)
+}
+
+// Show shows the diff of a commit
+func (c *GitCommand) Show(sha string) string {
+	result, err := c.OSCommand.RunCommandWithOutput("git show --color " + sha)
+	if err != nil {
+		panic(err)
+	}
+	return result
+}
+
+// Diff returns the diff of a file
+func (c *GitCommand) Diff(file File) string {
+	cachedArg := ""
+	fileName := c.OSCommand.Quote(file.Name)
+	if file.HasStagedChanges && !file.HasUnstagedChanges {
+		cachedArg = "--cached"
+	}
+	trackedArg := "--"
+	if !file.Tracked && !file.HasStagedChanges {
+		trackedArg = "--no-index /dev/null"
+	}
+	command := fmt.Sprintf("%s %s %s %s", "git diff --color ", cachedArg, trackedArg, fileName)
+
+	// for now we assume an error means the file was deleted
+	s, _ := c.OSCommand.RunCommandWithOutput(command)
+	return s
+}

pkg/commands/git_structs.go

@@ -0,0 +1,36 @@
+package commands
+
+// File : A staged/unstaged file
+type File struct {
+	Name               string
+	HasStagedChanges   bool
+	HasUnstagedChanges bool
+	Tracked            bool
+	Deleted            bool
+	HasMergeConflicts  bool
+	DisplayString      string
+	Type               string // one of 'file', 'directory', and 'other'
+}
+
+// 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 {
+	Start  int
+	Middle int
+	End    int
+}

pkg/commands/git_test.go

@@ -0,0 +1,119 @@
+package commands
+
+import (
+	"io/ioutil"
+	"strings"
+	"testing"
+
+	"github.com/jesseduffield/lazygit/pkg/test"
+	"github.com/sirupsen/logrus"
+)
+
+func newDummyLog() *logrus.Entry {
+	log := logrus.New()
+	log.Out = ioutil.Discard
+	return log.WithField("test", "test")
+}
+
+func newDummyGitCommand() *GitCommand {
+	return &GitCommand{
+		Log:       newDummyLog(),
+		OSCommand: newDummyOSCommand(),
+	}
+}
+
+func TestDiff(t *testing.T) {
+	gitCommand := newDummyGitCommand()
+	if err := test.GenerateRepo("lots_of_diffs.sh"); err != nil {
+		t.Error(err.Error())
+	}
+	files := []File{
+		{
+			Name:               "deleted_staged",
+			HasStagedChanges:   false,
+			HasUnstagedChanges: true,
+			Tracked:            true,
+			Deleted:            true,
+			HasMergeConflicts:  false,
+			DisplayString:      " D deleted_staged",
+		},
+		{
+			Name:               "file with space staged",
+			HasStagedChanges:   true,
+			HasUnstagedChanges: false,
+			Tracked:            false,
+			Deleted:            false,
+			HasMergeConflicts:  false,
+			DisplayString:      "A  \"file with space staged\"",
+		},
+		{
+			Name:               "file with space unstaged",
+			HasStagedChanges:   false,
+			HasUnstagedChanges: true,
+			Tracked:            false,
+			Deleted:            false,
+			HasMergeConflicts:  false,
+			DisplayString:      "?? file with space unstaged",
+		},
+		{
+			Name:               "modified_unstaged",
+			HasStagedChanges:   true,
+			HasUnstagedChanges: false,
+			Tracked:            true,
+			Deleted:            false,
+			HasMergeConflicts:  false,
+			DisplayString:      "M  modified_unstaged",
+		},
+		{
+			Name:               "modified_staged",
+			HasStagedChanges:   false,
+			HasUnstagedChanges: true,
+			Tracked:            true,
+			Deleted:            false,
+			HasMergeConflicts:  false,
+			DisplayString:      " M modified_staged",
+		},
+		{
+			Name:               "renamed_before -> renamed_after",
+			HasStagedChanges:   true,
+			HasUnstagedChanges: false,
+			Tracked:            true,
+			Deleted:            false,
+			HasMergeConflicts:  false,
+			DisplayString:      "R  renamed_before -> renamed_after",
+		},
+		{
+			Name:               "untracked_unstaged",
+			HasStagedChanges:   false,
+			HasUnstagedChanges: true,
+			Tracked:            false,
+			Deleted:            false,
+			HasMergeConflicts:  false,
+			DisplayString:      "?? untracked_unstaged",
+		},
+		{
+			Name:               "untracked_staged",
+			HasStagedChanges:   true,
+			HasUnstagedChanges: false,
+			Tracked:            false,
+			Deleted:            false,
+			HasMergeConflicts:  false,
+			DisplayString:      "A  untracked_staged",
+		},
+		{
+			Name:               "master",
+			HasStagedChanges:   false,
+			HasUnstagedChanges: true,
+			Tracked:            false,
+			Deleted:            false,
+			HasMergeConflicts:  false,
+			DisplayString:      "?? master",
+		},
+	}
+	for _, file := range files {
+		content := gitCommand.Diff(file)
+		if strings.Contains(content, "error") {
+			t.Error("Error: diff test failed. File: " + file.Name + ", " + content)
+		}
+	}
+}

pkg/commands/os.go

@@ -0,0 +1,189 @@
+package commands
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/davecgh/go-spew/spew"
+
+	"github.com/mgutz/str"
+
+	"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
+}
+
+// OSCommand holds all the os commands
+type OSCommand struct {
+	Log                *logrus.Entry
+	Platform           *Platform
+	command            func(string, ...string) *exec.Cmd
+	getGlobalGitConfig func(string) (string, error)
+	getenv             func(string) string
+}
+
+// NewOSCommand os command runner
+func NewOSCommand(log *logrus.Entry) *OSCommand {
+	return &OSCommand{
+		Log:                log,
+		Platform:           getPlatform(),
+		command:            exec.Command,
+		getGlobalGitConfig: gitconfig.Global,
+		getenv:             os.Getenv,
+	}
+}
+
+// RunCommandWithOutput wrapper around commands returning their output and error
+func (c *OSCommand) RunCommandWithOutput(command string) (string, error) {
+	c.Log.WithField("command", command).Info("RunCommand")
+	splitCmd := str.ToArgv(command)
+	c.Log.Info(splitCmd)
+
+	return sanitisedCommandOutput(
+		c.command(splitCmd[0], splitCmd[1:]...).CombinedOutput(),
+	)
+}
+
+// RunCommand runs a command and just returns the error
+func (c *OSCommand) RunCommand(command string) error {
+	_, err := c.RunCommandWithOutput(command)
+	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(
+		exec.
+			Command(c.Platform.shell, args...).
+			CombinedOutput(),
+	)
+}
+
+func sanitisedCommandOutput(output []byte, err error) (string, error) {
+	outputString := string(output)
+	if err != nil {
+		// errors like 'exit status 1' are not very useful so we'll create an error
+		// from the combined output
+		return outputString, errors.New(outputString)
+	}
+	return outputString, nil
+}
+
+// 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")
+}
+
+// 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) error {
+	cmdName, cmdTrail, err := c.getOpenCommand()
+	if err != nil {
+		return err
+	}
+
+	return c.RunCommand(cmdName + " " + c.Quote(filename) + cmdTrail) // TODO: test on linux
+}
+
+// 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")
+
+	if editor == "" {
+		editor = c.getenv("VISUAL")
+	}
+	if editor == "" {
+		editor = c.getenv("EDITOR")
+	}
+	if editor == "" {
+		if err := c.RunCommand("which vi"); err == nil {
+			editor = "vi"
+		}
+	}
+	if editor == "" {
+		return nil, errors.New("No editor defined in $VISUAL, $EDITOR, or git config")
+	}
+
+	return c.PrepareSubProcess(editor, filename), nil
+}
+
+// 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...)
+}
+
+// Quote wraps a message in platform-specific quotation marks
+func (c *OSCommand) Quote(message string) string {
+	message = strings.Replace(message, "`", "\\`", -1)
+	return c.Platform.escapedQuote + message + c.Platform.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 err
+	}
+	defer f.Close()
+
+	_, err = f.WriteString("\n" + line)
+	return err
+}

pkg/commands/os_default_platform.go

@@ -0,0 +1,16 @@
+// +build !windows
+
+package commands
+
+import (
+	"runtime"
+)
+
+func getPlatform() *Platform {
+	return &Platform{
+		os:           runtime.GOOS,
+		shell:        "bash",
+		shellArg:     "-c",
+		escapedQuote: "\"",
+	}
+}

pkg/commands/os_test.go

@@ -0,0 +1,357 @@
+package commands
+
+import (
+	"os"
+	"os/exec"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func newDummyOSCommand() *OSCommand {
+	return NewOSCommand(newDummyLog())
+}
+
+func TestOSCommandRunCommandWithOutput(t *testing.T) {
+	type scenario struct {
+		command string
+		test    func(string, error)
+	}
+
+	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, ".*No such file or directory.*", err.Error())
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		s.test(newDummyOSCommand().RunCommandWithOutput(s.command))
+	}
+}
+
+func TestOSCommandRunCommand(t *testing.T) {
+	type scenario struct {
+		command string
+		test    func(error)
+	}
+
+	scenarios := []scenario{
+		{
+			"rmdir unexisting-folder",
+			func(err error) {
+				assert.Regexp(t, ".*No such file or directory.*", err.Error())
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		s.test(newDummyOSCommand().RunCommand(s.command))
+	}
+}
+
+func TestOSCommandGetOpenCommand(t *testing.T) {
+	type scenario struct {
+		command func(string, ...string) *exec.Cmd
+		test    func(string, string, error)
+	}
+
+	scenarios := []scenario{
+		{
+			func(name string, arg ...string) *exec.Cmd {
+				return exec.Command("exit", "1")
+			},
+			func(name string, trail string, err error) {
+				assert.EqualError(t, err, "Unsure what command to use to open this file")
+			},
+		},
+		{
+			func(name string, arg ...string) *exec.Cmd {
+				assert.Equal(t, "which", name)
+				assert.Len(t, arg, 1)
+				assert.Regexp(t, "xdg-open|cygstart|open", arg[0])
+				return exec.Command("echo")
+			},
+			func(name string, trail string, err error) {
+				assert.NoError(t, err)
+				assert.Regexp(t, "xdg-open|cygstart|open", name)
+				assert.Regexp(t, " \\&\\>/dev/null \\&|", trail)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		OSCmd := newDummyOSCommand()
+		OSCmd.command = s.command
+
+		s.test(OSCmd.getOpenCommand())
+	}
+}
+
+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.EqualError(t, err, "Unsure what command to use to open this file")
+			},
+		},
+		{
+			"test",
+			func(name string, arg ...string) *exec.Cmd {
+				if name == "which" {
+					return exec.Command("echo")
+				}
+
+				switch len(arg) {
+				case 1:
+					assert.Regexp(t, "open|cygstart", name)
+					assert.EqualValues(t, "test", arg[0])
+				case 3:
+					assert.Equal(t, "xdg-open", name)
+					assert.EqualValues(t, "test", arg[0])
+					assert.Regexp(t, " \\&\\>/dev/null \\&|", arg[1])
+					assert.EqualValues(t, "&", arg[2])
+				default:
+					assert.Fail(t, "Unexisting command given")
+				}
+
+				return exec.Command("echo")
+			},
+			func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		OSCmd := newDummyOSCommand()
+		OSCmd.command = s.command
+
+		s.test(OSCmd.OpenFile(s.filename))
+	}
+}
+
+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))
+	}
+}
+
+func TestOSCommandQuote(t *testing.T) {
+	osCommand := newDummyOSCommand()
+
+	actual := osCommand.Quote("hello `test`")
+
+	expected := osCommand.Platform.escapedQuote + "hello \\`test\\`" + osCommand.Platform.escapedQuote
+
+	assert.EqualValues(t, expected, actual)
+}
+
+func TestOSCommandUnquote(t *testing.T) {
+	osCommand := newDummyOSCommand()
+
+	actual := osCommand.Unquote(`hello "test"`)
+
+	expected := "hello test"
+
+	assert.EqualValues(t, expected, actual)
+}
+
+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)
+	}
+}

pkg/commands/os_windows.go

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

pkg/config/app_config.go

@@ -0,0 +1,253 @@
+package config
+
+import (
+	"bytes"
+	"io/ioutil"
+	"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
+}
+
+// AppConfigurer interface allows individual app config structs to inherit Fields
+// from AppConfig and still be used by lazygit.
+type AppConfigurer interface {
+	GetDebug() bool
+	GetVersion() string
+	GetCommit() string
+	GetBuildDate() string
+	GetName() string
+	GetBuildSource() string
+	GetUserConfig() *viper.Viper
+	GetAppState() *AppState
+	WriteToUserConfig(string, string) error
+	SaveAppState() error
+	LoadAppState() error
+}
+
+// NewAppConfig makes a new app config
+func NewAppConfig(name, version, commit, date string, buildSource string, debuggingFlag *bool) (*AppConfig, error) {
+	defaultConfig := GetDefaultConfig()
+	userConfig, err := LoadConfig("config", defaultConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	appConfig := &AppConfig{
+		Name:        "lazygit",
+		Version:     version,
+		Commit:      commit,
+		BuildDate:   date,
+		Debug:       *debuggingFlag,
+		BuildSource: buildSource,
+		UserConfig:  userConfig,
+		AppState:    &AppState{},
+	}
+
+	if err := appConfig.LoadAppState(); err != nil {
+		return nil, err
+	}
+
+	return appConfig, nil
+}
+
+// GetDebug returns debug flag
+func (c *AppConfig) GetDebug() bool {
+	return c.Debug
+}
+
+// GetVersion returns debug flag
+func (c *AppConfig) GetVersion() string {
+	return c.Version
+}
+
+// GetCommit returns debug flag
+func (c *AppConfig) GetCommit() string {
+	return c.Commit
+}
+
+// GetBuildDate returns debug flag
+func (c *AppConfig) GetBuildDate() string {
+	return c.BuildDate
+}
+
+// GetName returns debug flag
+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) {
+	v := viper.New()
+	v.SetConfigType("yaml")
+	v.SetConfigName(filename)
+	return v, nil
+}
+
+// LoadConfig gets the user's config
+func LoadConfig(filename string, defaults []byte) (*viper.Viper, error) {
+	v, err := newViper(filename)
+	if err != nil {
+		return nil, err
+	}
+	if defaults != nil {
+		if err = LoadDefaults(v, defaults); err != nil {
+			return nil, err
+		}
+	}
+	if err = LoadAndMergeFile(v, filename+".yml"); 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.ReadConfig(bytes.NewBuffer(defaults))
+}
+
+func prepareConfigFile(filename string) (string, 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)
+	if folder == nil {
+		// create the file as empty
+		folders := configDirs.QueryFolders(configdir.Global)
+		if err := folders[0].WriteFile(filename, []byte{}); err != nil {
+			return "", err
+		}
+		folder = configDirs.QueryFolderContainsFile(filename)
+	}
+	return filepath.Join(folder.Path, filename), nil
+}
+
+// LoadAndMergeFile Loads the config/state file, creating
+// the file as an empty one if it does not exist
+func LoadAndMergeFile(v *viper.Viper, filename string) error {
+	configPath, err := prepareConfigFile(filename)
+	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", nil)
+	if 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 {
+		return err
+	}
+
+	filepath, err := prepareConfigFile("state.yml")
+	if err != nil {
+		return err
+	}
+
+	return ioutil.WriteFile(filepath, marshalledAppState, 0644)
+}
+
+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)
+}
+
+func GetDefaultConfig() []byte {
+	return []byte(
+		`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
+update:
+  method: prompt # can be: prompt | background | never
+  days: 14 # how often a update is checked for
+reporting: 'undetermined' # one of: 'on' | 'off' | 'undetermined'
+`)
+}
+
+// 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 {
+	return []byte(`
+  lastUpdateCheck: 0
+  recentRepos: []
+`)
+}
+
+// // commenting this out until we use it again
+// func homeDirectory() string {
+// 	usr, err := user.Current()
+// 	if err != nil {
+// 		log.Fatal(err)
+// 	}
+// 	return usr.HomeDir
+// }

pkg/git/branch_list_builder.go

@@ -0,0 +1,163 @@
+package git
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/commands"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+
+	"github.com/sirupsen/logrus"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
+)
+
+// 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
+
+// BranchListBuilder returns a list of Branch objects for the current repo
+type BranchListBuilder struct {
+	Log        *logrus.Entry
+	GitCommand *commands.GitCommand
+}
+
+// NewBranchListBuilder builds a new branch list builder
+func NewBranchListBuilder(log *logrus.Entry, gitCommand *commands.GitCommand) (*BranchListBuilder, error) {
+	return &BranchListBuilder{
+		Log:        log,
+		GitCommand: gitCommand,
+	}, nil
+}
+
+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 {
+		branchName, err = b.GitCommand.OSCommand.RunCommandWithOutput("git rev-parse --short HEAD")
+		if err != nil {
+			panic(err.Error())
+		}
+	}
+	return commands.Branch{Name: strings.TrimSpace(branchName), Recency: "  *"}
+}
+
+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
+	}
+
+	branchLines := utils.SplitLines(rawString)
+	for _, line := range branchLines {
+		timeNumber, timeUnit, branchName := branchInfoFromLine(line)
+		timeUnit = abbreviatedTimeUnit(timeUnit)
+		branch := commands.Branch{Name: branchName, Recency: timeNumber + timeUnit}
+		branches = append(branches, branch)
+	}
+	return branches
+}
+
+func (b *BranchListBuilder) obtainSafeBranches() []commands.Branch {
+	branches := make([]commands.Branch, 0)
+
+	bIter, err := b.GitCommand.Repo.Branches()
+	if err != nil {
+		panic(err)
+	}
+	err = bIter.ForEach(func(b *plumbing.Reference) error {
+		name := b.Name().Short()
+		branches = append(branches, commands.Branch{Name: name})
+		return nil
+	})
+
+	return branches
+}
+
+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)
+		}
+	}
+	return finalBranches
+}
+
+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
+		}
+	}
+	return reflogBranch.Name
+}
+
+// Build the list of branches for the current repo
+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)
+	}
+
+	branches = b.appendNewBranches(branches, reflogBranches, safeBranches, true)
+	branches = b.appendNewBranches(branches, safeBranches, branches, false)
+
+	return branches
+}
+
+func branchIncluded(branchName string, branches []commands.Branch) bool {
+	for _, existingBranch := range branches {
+		if strings.ToLower(existingBranch.Name) == strings.ToLower(branchName) {
+			return true
+		}
+	}
+	return false
+}
+
+func uniqueByName(branches []commands.Branch) []commands.Branch {
+	finalBranches := make([]commands.Branch, 0)
+	for _, branch := range branches {
+		if branchIncluded(branch.Name, finalBranches) {
+			continue
+		}
+		finalBranches = append(finalBranches, branch)
+	}
+	return finalBranches
+}
+
+// A line will have the form '10 days ago master' so we need to strip out the
+// useful information from that into timeNumber, timeUnit, and branchName
+func branchInfoFromLine(line string) (string, string, string) {
+	r := regexp.MustCompile("\\|.*\\s")
+	line = r.ReplaceAllString(line, " ")
+	words := strings.Split(line, " ")
+	return words[0], words[1], words[len(words)-1]
+}
+
+func abbreviatedTimeUnit(timeUnit string) string {
+	r := regexp.MustCompile("s$")
+	timeUnit = r.ReplaceAllString(timeUnit, "")
+	timeUnitMap := map[string]string{
+		"hour":   "h",
+		"minute": "m",
+		"second": "s",
+		"week":   "w",
+		"year":   "y",
+		"day":    "d",
+		"month":  "m",
+	}
+	return timeUnitMap[timeUnit]
+}

pkg/gui/app_status_manager.go

@@ -0,0 +1,44 @@
+package gui
+
+import "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
+}

pkg/gui/branches_panel.go

@@ -0,0 +1,171 @@
+package gui
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/commands"
+	"github.com/jesseduffield/lazygit/pkg/git"
+)
+
+func (gui *Gui) handleBranchPress(g *gocui.Gui, v *gocui.View) error {
+	index := gui.getItemPosition(v)
+	if index == 0 {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("AlreadyCheckedOutBranch"))
+	}
+	branch := gui.getSelectedBranch(v)
+	if err := gui.GitCommand.Checkout(branch.Name, false); err != nil {
+		gui.createErrorPanel(g, err.Error())
+	}
+	return gui.refreshSidePanels(g)
+}
+
+func (gui *Gui) handleForceCheckout(g *gocui.Gui, v *gocui.View) error {
+	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 {
+		if err := gui.GitCommand.Checkout(branch.Name, true); err != nil {
+			gui.createErrorPanel(g, err.Error())
+		}
+		return gui.refreshSidePanels(g)
+	}, nil)
+}
+
+func (gui *Gui) handleCheckoutByName(g *gocui.Gui, v *gocui.View) error {
+	gui.createPromptPanel(g, v, gui.Tr.SLocalize("BranchName")+":", func(g *gocui.Gui, v *gocui.View) error {
+		if err := gui.GitCommand.Checkout(gui.trimmedContent(v), false); err != nil {
+			return gui.createErrorPanel(g, err.Error())
+		}
+		return gui.refreshSidePanels(g)
+	})
+	return nil
+}
+
+func (gui *Gui) handleNewBranch(g *gocui.Gui, v *gocui.View) error {
+	branch := gui.State.Branches[0]
+	message := gui.Tr.TemplateLocalize(
+		"NewBranchNameBranchOff",
+		Teml{
+			"branchName": branch.Name,
+		},
+	)
+	gui.createPromptPanel(g, v, message, func(g *gocui.Gui, v *gocui.View) error {
+		if err := gui.GitCommand.NewBranch(gui.trimmedContent(v)); err != nil {
+			return gui.createErrorPanel(g, err.Error())
+		}
+		gui.refreshSidePanels(g)
+		return gui.handleBranchSelect(g, v)
+	})
+	return nil
+}
+
+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 {
+	checkedOutBranch := gui.State.Branches[0]
+	selectedBranch := gui.getSelectedBranch(v)
+	if checkedOutBranch.Name == selectedBranch.Name {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("CantDeleteCheckOutBranch"))
+	}
+	title := gui.Tr.SLocalize("DeleteBranch")
+	var messageId string
+	if force {
+		messageId = "ForceDeleteBranchMessage"
+	} else {
+		messageId = "DeleteBranchMessage"
+	}
+	message := gui.Tr.TemplateLocalize(
+		messageId,
+		Teml{
+			"selectedBranchName": selectedBranch.Name,
+		},
+	)
+	return gui.createConfirmationPanel(g, v, title, message, func(g *gocui.Gui, v *gocui.View) error {
+		if err := gui.GitCommand.DeleteBranch(selectedBranch.Name, force); err != nil {
+			return gui.createErrorPanel(g, err.Error())
+		}
+		return gui.refreshSidePanels(g)
+	}, nil)
+}
+
+func (gui *Gui) handleMerge(g *gocui.Gui, v *gocui.View) error {
+	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"))
+	}
+	if err := gui.GitCommand.Merge(selectedBranch.Name); err != nil {
+		return gui.createErrorPanel(g, err.Error())
+	}
+	return nil
+}
+
+func (gui *Gui) getSelectedBranch(v *gocui.View) commands.Branch {
+	lineNumber := gui.getItemPosition(v)
+	return gui.State.Branches[lineNumber]
+}
+
+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"),
+		"D":       gui.Tr.SLocalize("forceDeleteBranch"),
+		"← → ↑ ↓": 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
+	}
+	// 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"))
+	}
+	go func() {
+		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

@@ -0,0 +1,59 @@
+package gui
+
+import (
+	"github.com/jesseduffield/gocui"
+)
+
+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"))
+	}
+	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)
+	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(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 {
+	message := gui.Tr.TemplateLocalize(
+		"CloseConfirm",
+		Teml{
+			"keyBindClose":   "esc",
+			"keyBindConfirm": "enter",
+		},
+	)
+	return gui.renderString(g, "options", message)
+}

pkg/gui/commits_panel.go

@@ -0,0 +1,172 @@
+package gui
+
+import (
+	"errors"
+
+	"github.com/fatih/color"
+	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/commands"
+)
+
+func (gui *Gui) refreshCommits(g *gocui.Gui) error {
+	g.Update(func(*gocui.Gui) error {
+		gui.State.Commits = gui.GitCommand.GetCommits()
+		v, err := g.View("commits")
+		if err != nil {
+			panic(err)
+		}
+		v.Clear()
+		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 g.CurrentView().Name() == "commits" {
+			gui.handleCommitSelect(g, v)
+		}
+		return nil
+	})
+	return nil
+}
+
+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, err := gui.getSelectedCommit(g)
+		if err != nil {
+			panic(err)
+		}
+		if err := gui.GitCommand.ResetToCommit(commit.Sha); err != nil {
+			return gui.createErrorPanel(g, err.Error())
+		}
+		if err := gui.refreshCommits(g); err != nil {
+			panic(err)
+		}
+		if err := gui.refreshFiles(g); err != nil {
+			panic(err)
+		}
+		gui.resetOrigin(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.Error() != 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 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"))
+	}
+	commit, err := gui.getSelectedCommit(g)
+	if err != nil {
+		return err
+	}
+	if err := gui.GitCommand.SquashPreviousTwoCommits(commit.Name); err != nil {
+		return gui.createErrorPanel(g, err.Error())
+	}
+	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 {
+	for _, file := range files {
+		if file.Tracked && file.HasUnstagedChanges {
+			return true
+		}
+	}
+	return false
+}
+
+func (gui *Gui) handleCommitFixup(g *gocui.Gui, v *gocui.View) error {
+	if len(gui.State.Commits) == 1 {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("YouNoCommitsToSquash"))
+	}
+	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
+	}
+	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 {
+	if gui.getItemPosition(v) != 0 {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("OnlyRenameTopCommit"))
+	}
+	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())
+		}
+		if err := gui.refreshCommits(g); err != nil {
+			panic(err)
+		}
+		return gui.handleCommitSelect(g, v)
+	})
+	return nil
+}
+
+func (gui *Gui) getSelectedCommit(g *gocui.Gui) (commands.Commit, error) {
+	v, err := g.View("commits")
+	if err != nil {
+		panic(err)
+	}
+	if len(gui.State.Commits) == 0 {
+		return commands.Commit{}, errors.New(gui.Tr.SLocalize("NoCommitsThisBranch"))
+	}
+	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.State.Commits[lineNumber], nil
+}

pkg/gui/confirmation_panel.go

@@ -0,0 +1,177 @@
+// lots of this has been directly ported from one of the example files, will brush up later
+
+// Copyright 2014 The gocui Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package gui
+
+import (
+	"strings"
+
+	"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
+			}
+		}
+		return gui.closeConfirmationPrompt(g)
+	}
+}
+
+func (gui *Gui) closeConfirmationPrompt(g *gocui.Gui) error {
+	view, err := g.View("confirmation")
+	if err != nil {
+		panic(err)
+	}
+	if err := gui.returnFocus(g, view); err != nil {
+		panic(err)
+	}
+	g.DeleteKeybindings("confirmation")
+	return g.DeleteView("confirmation")
+}
+
+func (gui *Gui) getMessageHeight(message string, width int) int {
+	lines := strings.Split(message, "\n")
+	lineCount := 0
+	for _, line := range lines {
+		lineCount += len(line)/width + 1
+	}
+	return lineCount
+}
+
+func (gui *Gui) getConfirmationPanelDimensions(g *gocui.Gui, prompt string) (int, int, int, int) {
+	width, height := g.Size()
+	panelWidth := width / 2
+	panelHeight := gui.getMessageHeight(prompt, panelWidth)
+	return width/2 - panelWidth/2,
+		height/2 - panelHeight/2 - panelHeight%2 - 1,
+		width/2 + panelWidth/2,
+		height/2 + panelHeight/2
+}
+
+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, "")
+	if err != nil {
+		return err
+	}
+	confirmationView.Editable = true
+	return gui.setKeyBindings(g, handleConfirm, nil)
+}
+
+func (gui *Gui) prepareConfirmationPanel(currentView *gocui.View, title, prompt string) (*gocui.View, error) {
+	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(gui.g, prompt)
+	confirmationView, err := gui.g.SetView("confirmation", x0, y0, x1, y1, 0)
+	if err != nil {
+		if err != gocui.ErrUnknownView {
+			return nil, err
+		}
+		confirmationView.Title = title
+		confirmationView.FgColor = gocui.ColorWhite
+	}
+	confirmationView.Clear()
+
+	if err := gui.switchFocus(gui.g, currentView, confirmationView); err != nil {
+		return nil, err
+	}
+	return confirmationView, nil
+}
+
+func (gui *Gui) onNewPopupPanel() {
+	gui.g.SetViewOnBottom("commitMessage")
+}
+
+func (gui *Gui) createConfirmationPanel(g *gocui.Gui, currentView *gocui.View, title, prompt string, 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
+		if view, _ := g.View("confirmation"); view != nil {
+			if err := gui.closeConfirmationPrompt(g); err != nil {
+				errMessage := gui.Tr.TemplateLocalize(
+					"CantCloseConfirmationPrompt",
+					Teml{
+						"error": err.Error(),
+					},
+				)
+				gui.Log.Error(errMessage)
+			}
+		}
+		confirmationView, err := gui.prepareConfirmationPanel(currentView, title, prompt)
+		if err != nil {
+			return err
+		}
+		confirmationView.Editable = false
+		if err := gui.renderString(g, "confirmation", prompt); err != nil {
+			return err
+		}
+		return gui.setKeyBindings(g, handleConfirm, handleClose)
+	})
+	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",
+		Teml{
+			"keyBindClose":   "esc",
+			"keyBindConfirm": "enter",
+		},
+	)
+	if err := gui.renderString(g, "options", actions); err != nil {
+		return err
+	}
+	if err := g.SetKeybinding("confirmation", gocui.KeyEnter, gocui.ModNone, gui.wrappedConfirmationFunction(handleConfirm)); err != nil {
+		return err
+	}
+	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.createConfirmationPanel(g, currentView, title, prompt, nil, nil)
+}
+
+func (gui *Gui) createErrorPanel(g *gocui.Gui, message string) error {
+	gui.Log.Error(message)
+	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/files_panel.go

@@ -0,0 +1,458 @@
+package gui
+
+import (
+
+	// "io"
+	// "io/ioutil"
+
+	// "strings"
+
+	"os/exec"
+	"strings"
+
+	"github.com/fatih/color"
+	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/commands"
+)
+
+func (gui *Gui) stagedFiles() []commands.File {
+	files := gui.State.Files
+	result := make([]commands.File, 0)
+	for _, file := range files {
+		if file.HasStagedChanges {
+			result = append(result, file)
+		}
+	}
+	return result
+}
+
+func (gui *Gui) trackedFiles() []commands.File {
+	files := gui.State.Files
+	result := make([]commands.File, 0)
+	for _, file := range files {
+		if file.Tracked {
+			result = append(result, file)
+		}
+	}
+	return result
+}
+
+func (gui *Gui) stageSelectedFile(g *gocui.Gui) error {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		return err
+	}
+	return gui.GitCommand.StageFile(file.Name)
+}
+
+func (gui *Gui) handleFilePress(g *gocui.Gui, v *gocui.View) error {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		if err == gui.Errors.ErrNoFiles {
+			return nil
+		}
+		return err
+	}
+
+	if file.HasMergeConflicts {
+		return gui.handleSwitchToMerge(g, v)
+	}
+
+	if file.HasUnstagedChanges {
+		gui.GitCommand.StageFile(file.Name)
+	} else {
+		gui.GitCommand.UnStageFile(file.Name, file.Tracked)
+	}
+
+	if err := gui.refreshFiles(g); err != nil {
+		return err
+	}
+
+	return gui.handleFileSelect(g, v)
+}
+
+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(g); err != nil {
+		return err
+	}
+
+	return gui.handleFileSelect(g, v)
+}
+
+func (gui *Gui) handleAddPatch(g *gocui.Gui, v *gocui.View) error {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		if err == gui.Errors.ErrNoFiles {
+			return nil
+		}
+		return err
+	}
+	if !file.HasUnstagedChanges {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("FileHasNoUnstagedChanges"))
+	}
+	if !file.Tracked {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("CannotGitAdd"))
+	}
+
+	gui.SubProcess = gui.GitCommand.AddPatch(file.Name)
+	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 {
+		if err == gui.Errors.ErrNoFiles {
+			return nil
+		}
+		return err
+	}
+	var deleteVerb string
+	if file.Tracked {
+		deleteVerb = gui.Tr.SLocalize("checkout")
+	} else {
+		deleteVerb = gui.Tr.SLocalize("delete")
+	}
+	message := gui.Tr.TemplateLocalize(
+		"SureTo",
+		Teml{
+			"deleteVerb": deleteVerb,
+			"fileName":   file.Name,
+		},
+	)
+	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
+		}
+		return gui.refreshFiles(g)
+	}, nil)
+}
+
+func (gui *Gui) handleIgnoreFile(g *gocui.Gui, v *gocui.View) error {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		return gui.createErrorPanel(g, err.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())
+	}
+	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"),
+		"a":         gui.Tr.SLocalize("toggleStagedAll"),
+		"PgUp/PgDn": gui.Tr.SLocalize("scroll"),
+	}
+	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.HasMergeConflicts {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("NoStagedFilesToCommit"))
+	}
+	commitMessageView := gui.getCommitMessageView(g)
+	g.Update(func(g *gocui.Gui) error {
+		g.SetViewOnTop("commitMessage")
+		gui.switchFocus(g, filesView, commitMessageView)
+		return nil
+	})
+	return 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.HasMergeConflicts {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("NoStagedFilesToCommit"))
+	}
+	gui.PrepareSubProcess(g, "git", "commit")
+	return nil
+}
+
+// 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()
+	g.Update(func(g *gocui.Gui) error {
+		return gui.Errors.ErrSubProcess
+	})
+}
+
+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 {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		return err
+	}
+	return gui.genericFileOpen(g, v, file.Name, gui.OSCommand.EditFile)
+}
+
+func (gui *Gui) handleFileOpen(g *gocui.Gui, v *gocui.View) error {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		return err
+	}
+	return gui.openFile(file.Name)
+}
+
+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(g)
+}
+
+func (gui *Gui) refreshStateFiles() {
+	// get files to stage
+	files := gui.GitCommand.GetStatusFiles()
+	gui.State.Files = gui.GitCommand.MergeStatusFiles(gui.State.Files, files)
+	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) {
+	item, err := gui.getSelectedFile(g)
+	if err != nil {
+		if err != gui.Errors.ErrNoFiles {
+			return "", err
+		}
+		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())
+	}
+	return cat, nil
+}
+
+func (gui *Gui) refreshFiles(g *gocui.Gui) error {
+	filesView, err := g.View("files")
+	if err != nil {
+		return 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) pullFiles(g *gocui.Gui, v *gocui.View) error {
+	gui.createMessagePanel(g, v, "", gui.Tr.SLocalize("PullWait"))
+	go func() {
+		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) pushWithForceFlag(currentView *gocui.View, force bool) error {
+	if err := gui.createMessagePanel(gui.g, currentView, "", gui.Tr.SLocalize("PushWait")); err != nil {
+		return err
+	}
+	go func() {
+		branchName := gui.State.Branches[0].Name
+		if err := gui.GitCommand.Push(branchName, force); err != nil {
+			_ = gui.createErrorPanel(gui.g, err.Error())
+		} else {
+			_ = gui.closeConfirmationPrompt(gui.g)
+			_ = gui.refreshCommits(gui.g)
+			_ = gui.refreshStatus(gui.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.UpstreamDifferenceCount()
+	if pullables == "?" || pullables == "0" {
+		return gui.pushWithForceFlag(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(v, true)
+	}, nil)
+	return err
+}
+
+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 {
+			return err
+		}
+		return nil
+	}
+	if !file.HasMergeConflicts {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("FileNoMergeCons"))
+	}
+	gui.switchFocus(g, v, mergeView)
+	return gui.refreshMergePanel(g)
+}
+
+func (gui *Gui) handleAbortMerge(g *gocui.Gui, v *gocui.View) error {
+	if err := gui.GitCommand.AbortMerge(); err != nil {
+		return gui.createErrorPanel(g, err.Error())
+	}
+	gui.createMessagePanel(g, v, "", gui.Tr.SLocalize("MergeAborted"))
+	gui.refreshStatus(g)
+	return gui.refreshFiles(g)
+}
+
+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.ResetHard(); err != nil {
+			gui.createErrorPanel(g, err.Error())
+		}
+		return gui.refreshFiles(g)
+	}, 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
+}

pkg/gui/gui.go

@@ -0,0 +1,424 @@
+package gui
+
+import (
+
+	// "io"
+	// "io/ioutil"
+
+	"errors"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+
+	// "strings"
+
+	"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
+var OverlappingEdges = false
+
+// SentinelErrors are the errors that have special meaning and need to be checked
+// by calling functions. The less of these, the better
+type SentinelErrors struct {
+	ErrSubProcess error
+	ErrNoFiles    error
+}
+
+// GenerateSentinelErrors makes the sentinel errors for the gui. We're defining it here
+// because we can't do package-scoped errors with localization, and also because
+// it seems like package-scoped variables are bad in general
+// https://dave.cheney.net/2017/06/11/go-without-package-scoped-variables
+// In the future it would be good to implement some of the recommendations of
+// that article. For now, if we don't need an error to be a sentinel, we will just
+// define it inline. This has implications for error messages that pop up everywhere
+// in that we'll be duplicating the default values. We may need to look at
+// having a default localisation bundle defined, and just using keys-only when
+// localising things in the code.
+func (gui *Gui) GenerateSentinelErrors() {
+	gui.Errors = SentinelErrors{
+		ErrSubProcess: errors.New(gui.Tr.SLocalize("RunningSubprocess")),
+		ErrNoFiles:    errors.New(gui.Tr.SLocalize("NoChangedFiles")),
+	}
+}
+
+// Teml is short for template used to make the required map[string]interface{} shorter when using gui.Tr.SLocalize and gui.Tr.TemplateLocalize
+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
+}
+
+type guiState struct {
+	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
+	Updating          bool
+}
+
+// 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) {
+
+	initialState := guiState{
+		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{},
+	}
+
+	gui.GenerateSentinelErrors()
+
+	return gui, nil
+}
+
+func (gui *Gui) scrollUpMain(g *gocui.Gui, v *gocui.View) error {
+	mainView, _ := g.View("main")
+	ox, oy := mainView.Origin()
+	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()
+	if oy < len(mainView.BufferLines()) {
+		return mainView.SetOrigin(ox, oy+gui.Config.GetUserConfig().GetInt("gui.scrollHeight"))
+	}
+	return nil
+}
+
+func (gui *Gui) handleRefresh(g *gocui.Gui, v *gocui.View) error {
+	return gui.refreshSidePanels(g)
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// 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()
+	version := gui.Config.GetVersion()
+	leftSideWidth := width / 3
+	statusFilesBoundary := 2
+	filesBranchesBoundary := 2 * height / 5   // height - 20
+	commitsBranchesBoundary := 3 * height / 5 // height - 10
+	commitsStashBoundary := height - 5        // height - 5
+	optionsVersionBoundary := width - max(len(version), 1)
+	minimumHeight := 16
+	minimumWidth := 10
+
+	appStatus := gui.statusManager.getStatusString()
+	appStatusOptionsBoundary := 0
+	if appStatus != "" {
+		appStatusOptionsBoundary = len(appStatus) + 2
+	}
+
+	panelSpacing := 1
+	if OverlappingEdges {
+		panelSpacing = 0
+	}
+
+	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 != gocui.ErrUnknownView {
+				return err
+			}
+			v.Title = gui.Tr.SLocalize("NotEnoughSpace")
+			v.Wrap = true
+		}
+		return nil
+	}
+
+	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 != gocui.ErrUnknownView {
+			return err
+		}
+		v.Title = gui.Tr.SLocalize("DiffTitle")
+		v.Wrap = true
+		v.FgColor = gocui.ColorWhite
+	}
+
+	if v, err := g.SetView("status", 0, 0, leftSideWidth, statusFilesBoundary, gocui.BOTTOM|gocui.RIGHT); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		v.Title = gui.Tr.SLocalize("StatusTitle")
+		v.FgColor = gocui.ColorWhite
+	}
+
+	filesView, err := g.SetView("files", 0, statusFilesBoundary+panelSpacing, leftSideWidth, filesBranchesBoundary, gocui.TOP|gocui.BOTTOM)
+	if err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		filesView.Highlight = true
+		filesView.Title = gui.Tr.SLocalize("FilesTitle")
+		v.FgColor = gocui.ColorWhite
+	}
+
+	if v, err := g.SetView("branches", 0, filesBranchesBoundary+panelSpacing, leftSideWidth, commitsBranchesBoundary, gocui.TOP|gocui.BOTTOM); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		v.Title = gui.Tr.SLocalize("BranchesTitle")
+		v.FgColor = gocui.ColorWhite
+	}
+
+	if v, err := g.SetView("commits", 0, commitsBranchesBoundary+panelSpacing, leftSideWidth, commitsStashBoundary, gocui.TOP|gocui.BOTTOM); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		v.Title = gui.Tr.SLocalize("CommitsTitle")
+		v.FgColor = gocui.ColorWhite
+	}
+
+	if v, err := g.SetView("stash", 0, commitsStashBoundary+panelSpacing, leftSideWidth, optionsTop, gocui.TOP|gocui.RIGHT); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		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 != gocui.ErrUnknownView {
+			return err
+		}
+		v.Frame = false
+		if v.FgColor, err = gui.GetOptionsPanelTextColor(); err != nil {
+			return err
+		}
+	}
+
+	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 != gocui.ErrUnknownView {
+				return err
+			}
+			g.SetViewOnBottom("commitMessage")
+			commitMessageView.Title = gui.Tr.SLocalize("CommitMessage")
+			commitMessageView.FgColor = gocui.ColorWhite
+			commitMessageView.Editable = true
+		}
+	}
+
+	if appStatusView, err := g.SetView("appStatus", -1, optionsTop, width, optionsTop+2, 0); err != nil {
+		if err != gocui.ErrUnknownView {
+			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("version", optionsVersionBoundary-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, "version", version); 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)
+		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
+			}
+		}
+	}
+
+	gui.resizePopupPanels(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 {
+		return gui.Config.WriteToUserConfig("reporting", "on")
+	}, func(g *gocui.Gui, v *gocui.View) error {
+		return gui.Config.WriteToUserConfig("reporting", "off")
+	})
+}
+
+func (gui *Gui) fetch(g *gocui.Gui) error {
+	gui.GitCommand.Fetch()
+	gui.refreshStatus(g)
+	return nil
+}
+
+func (gui *Gui) updateLoader(g *gocui.Gui) error {
+	if view, _ := g.View("confirmation"); view != nil {
+		content := gui.trimmedContent(view)
+		if strings.Contains(content, "...") {
+			staticContent := strings.Split(content, "...")[0] + "..."
+			if err := gui.renderString(g, "confirmation", staticContent+" "+utils.Loader()); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (gui *Gui) renderAppStatus(g *gocui.Gui) error {
+	appStatus := gui.statusManager.getStatusString()
+	if appStatus != "" {
+		return gui.renderString(gui.g, "appStatus", appStatus)
+	}
+	return nil
+}
+
+func (gui *Gui) goEvery(g *gocui.Gui, interval time.Duration, function func(*gocui.Gui) error) {
+	go func() {
+		for range time.Tick(interval) {
+			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)
+	if err != nil {
+		return err
+	}
+	defer g.Close()
+
+	gui.g = g // TODO: always use gui.g rather than passing g around everywhere
+
+	if err := gui.SetColorScheme(); err != nil {
+		return err
+	}
+
+	gui.goEvery(g, time.Second*60, gui.fetch)
+	gui.goEvery(g, time.Second*10, gui.refreshFiles)
+	gui.goEvery(g, time.Millisecond*50, gui.updateLoader)
+	gui.goEvery(g, time.Millisecond*50, gui.renderAppStatus)
+
+	g.SetManagerFunc(gui.layout)
+
+	if err = gui.keybindings(g); err != nil {
+		return err
+	}
+
+	err = g.MainLoop()
+	return err
+}
+
+// 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() {
+	for {
+		if err := gui.Run(); err != nil {
+			if err == gocui.ErrQuit {
+				break
+			} else if err == gui.Errors.ErrSubProcess {
+				gui.SubProcess.Stdin = os.Stdin
+				gui.SubProcess.Stdout = os.Stdout
+				gui.SubProcess.Stderr = os.Stderr
+				gui.SubProcess.Run()
+				gui.SubProcess.Stdout = ioutil.Discard
+				gui.SubProcess.Stderr = ioutil.Discard
+				gui.SubProcess.Stdin = nil
+				gui.SubProcess = nil
+			} else {
+				log.Panicln(err)
+			}
+		}
+	}
+}
+
+func (gui *Gui) quit(g *gocui.Gui, v *gocui.View) error {
+	if gui.State.Updating {
+		return gui.createUpdateQuitConfirmation(g, v)
+	}
+	return gocui.ErrQuit
+}

pkg/gui/keybindings.go

@@ -0,0 +1,99 @@
+package gui
+
+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
+}
+
+func (gui *Gui) keybindings(g *gocui.Gui) error {
+	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: '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: "status", Key: 'u', Modifier: gocui.ModNone, Handler: gui.handleCheckForUpdate},
+		{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: 'a', Modifier: gocui.ModNone, Handler: gui.handleStageAll},
+		{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: 'D', Modifier: gocui.ModNone, Handler: gui.handleForceDeleteBranch},
+		{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
+		}
+	}
+	return nil
+}

pkg/gui/merge_panel.go

@@ -0,0 +1,263 @@
+// though this panel is called the merge panel, it's really going to use the main panel. This may change in the future
+
+package gui
+
+import (
+	"bufio"
+	"bytes"
+	"io/ioutil"
+	"math"
+	"os"
+	"strings"
+
+	"github.com/fatih/color"
+	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/commands"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
+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) {
+		if line == "<<<<<<< HEAD" || line == "<<<<<<< MERGE_HEAD" || line == "<<<<<<< Updated upstream" {
+			newConflict = commands.Conflict{Start: i}
+		} else if line == "=======" {
+			newConflict.Middle = i
+		} else if strings.HasPrefix(line, ">>>>>>> ") {
+			newConflict.End = i
+			conflicts = append(conflicts, newConflict)
+		}
+	}
+	return conflicts, nil
+}
+
+func (gui *Gui) shiftConflict(conflicts []commands.Conflict) (commands.Conflict, []commands.Conflict) {
+	return conflicts[0], conflicts[1:]
+}
+
+func (gui *Gui) shouldHighlightLine(index int, conflict commands.Conflict, top bool) bool {
+	return (index >= conflict.Start && index <= conflict.Middle && top) || (index >= conflict.Middle && index <= conflict.End && !top)
+}
+
+func (gui *Gui) coloredConflictFile(content string, conflicts []commands.Conflict, conflictIndex int, conflictTop, hasFocus bool) (string, error) {
+	if len(conflicts) == 0 {
+		return content, nil
+	}
+	conflict, remainingConflicts := gui.shiftConflict(conflicts)
+	var outputBuffer bytes.Buffer
+	for i, line := range utils.SplitLines(content) {
+		colourAttr := color.FgWhite
+		if i == conflict.Start || i == conflict.Middle || i == conflict.End {
+			colourAttr = color.FgRed
+		}
+		colour := color.New(colourAttr)
+		if hasFocus && conflictIndex < len(conflicts) && conflicts[conflictIndex] == conflict && gui.shouldHighlightLine(i, conflict, conflictTop) {
+			colour.Add(color.Bold)
+		}
+		if i == conflict.End && len(remainingConflicts) > 0 {
+			conflict, remainingConflicts = gui.shiftConflict(remainingConflicts)
+		}
+		outputBuffer.WriteString(utils.ColoredStringDirect(line, colour) + "\n")
+	}
+	return outputBuffer.String(), nil
+}
+
+func (gui *Gui) handleSelectTop(g *gocui.Gui, v *gocui.View) error {
+	gui.State.ConflictTop = true
+	return gui.refreshMergePanel(g)
+}
+
+func (gui *Gui) handleSelectBottom(g *gocui.Gui, v *gocui.View) error {
+	gui.State.ConflictTop = false
+	return gui.refreshMergePanel(g)
+}
+
+func (gui *Gui) handleSelectNextConflict(g *gocui.Gui, v *gocui.View) error {
+	if gui.State.ConflictIndex >= len(gui.State.Conflicts)-1 {
+		return nil
+	}
+	gui.State.ConflictIndex++
+	return gui.refreshMergePanel(g)
+}
+
+func (gui *Gui) handleSelectPrevConflict(g *gocui.Gui, v *gocui.View) error {
+	if gui.State.ConflictIndex <= 0 {
+		return nil
+	}
+	gui.State.ConflictIndex--
+	return gui.refreshMergePanel(g)
+}
+
+func (gui *Gui) isIndexToDelete(i int, conflict commands.Conflict, pick string) bool {
+	return i == conflict.Middle ||
+		i == conflict.Start ||
+		i == conflict.End ||
+		pick != "both" &&
+			(pick == "bottom" && i > conflict.Start && i < conflict.Middle) ||
+		(pick == "top" && i > conflict.Middle && i < conflict.End)
+}
+
+func (gui *Gui) resolveConflict(g *gocui.Gui, conflict commands.Conflict, pick string) error {
+	gitFile, err := gui.getSelectedFile(g)
+	if err != nil {
+		return err
+	}
+	file, err := os.Open(gitFile.Name)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	reader := bufio.NewReader(file)
+	output := ""
+	for i := 0; true; i++ {
+		line, err := reader.ReadString('\n')
+		if err != nil {
+			break
+		}
+		if !gui.isIndexToDelete(i, conflict, pick) {
+			output += line
+		}
+	}
+	gui.Log.Info(output)
+	return ioutil.WriteFile(gitFile.Name, []byte(output), 0644)
+}
+
+func (gui *Gui) pushFileSnapshot(g *gocui.Gui) error {
+	gitFile, err := gui.getSelectedFile(g)
+	if err != nil {
+		return err
+	}
+	content, err := gui.GitCommand.CatFile(gitFile.Name)
+	if err != nil {
+		return err
+	}
+	gui.State.EditHistory.Push(content)
+	return nil
+}
+
+func (gui *Gui) handlePopFileSnapshot(g *gocui.Gui, v *gocui.View) error {
+	if gui.State.EditHistory.Len() == 0 {
+		return nil
+	}
+	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(g)
+}
+
+func (gui *Gui) handlePickHunk(g *gocui.Gui, v *gocui.View) error {
+	conflict := gui.State.Conflicts[gui.State.ConflictIndex]
+	gui.pushFileSnapshot(g)
+	pick := "bottom"
+	if gui.State.ConflictTop {
+		pick = "top"
+	}
+	err := gui.resolveConflict(g, conflict, pick)
+	if err != nil {
+		panic(err)
+	}
+	gui.refreshMergePanel(g)
+	return nil
+}
+
+func (gui *Gui) handlePickBothHunks(g *gocui.Gui, v *gocui.View) error {
+	conflict := gui.State.Conflicts[gui.State.ConflictIndex]
+	gui.pushFileSnapshot(g)
+	err := gui.resolveConflict(g, conflict, "both")
+	if err != nil {
+		panic(err)
+	}
+	return gui.refreshMergePanel(g)
+}
+
+func (gui *Gui) refreshMergePanel(g *gocui.Gui) error {
+	cat, err := gui.catSelectedFile(g)
+	if err != nil {
+		return err
+	}
+	if cat == "" {
+		return nil
+	}
+	gui.State.Conflicts, err = gui.findConflicts(cat)
+	if err != nil {
+		return err
+	}
+
+	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(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.scrollToConflict(g); err != nil {
+		return err
+	}
+	return gui.renderString(g, "main", content)
+}
+
+func (gui *Gui) scrollToConflict(g *gocui.Gui) error {
+	mainView, err := g.View("main")
+	if err != nil {
+		return err
+	}
+	if len(gui.State.Conflicts) == 0 {
+		return nil
+	}
+	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))))
+	return mainView.SetOrigin(ox, newOriginY)
+}
+
+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"),
+		"b":     gui.Tr.SLocalize("pickBothHunks"),
+		"z":     gui.Tr.SLocalize("undo"),
+	})
+}
+
+func (gui *Gui) handleEscapeMerge(g *gocui.Gui, v *gocui.View) error {
+	filesView, err := g.View("files")
+	if err != nil {
+		return err
+	}
+	gui.refreshFiles(g)
+	return gui.switchFocus(g, v, filesView)
+}
+
+func (gui *Gui) handleCompleteMerge(g *gocui.Gui) error {
+	filesView, err := g.View("files")
+	if err != nil {
+		return err
+	}
+	gui.stageSelectedFile(g)
+	gui.refreshFiles(g)
+	return gui.switchFocus(g, nil, filesView)
+}

pkg/gui/stash_panel.go

@@ -0,0 +1,105 @@
+package gui
+
+import (
+	"fmt"
+
+	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/commands"
+)
+
+func (gui *Gui) refreshStashEntries(g *gocui.Gui) error {
+	g.Update(func(g *gocui.Gui) error {
+		v, err := g.View("stash")
+		if err != nil {
+			panic(err)
+		}
+		gui.State.StashEntries = gui.GitCommand.GetStashEntries()
+		v.Clear()
+		for _, stashEntry := range gui.State.StashEntries {
+			fmt.Fprintln(v, stashEntry.DisplayString)
+		}
+		return gui.resetOrigin(v)
+	})
+	return nil
+}
+
+func (gui *Gui) getSelectedStashEntry(v *gocui.View) *commands.StashEntry {
+	if len(gui.State.StashEntries) == 0 {
+		return nil
+	}
+	lineNumber := gui.getItemPosition(v)
+	return &gui.State.StashEntries[lineNumber]
+}
+
+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"),
+	})
+}
+
+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")
+}
+
+func (gui *Gui) handleStashPop(g *gocui.Gui, v *gocui.View) error {
+	return gui.stashDo(g, v, "pop")
+}
+
+func (gui *Gui) handleStashDrop(g *gocui.Gui, v *gocui.View) error {
+	title := gui.Tr.SLocalize("StashDrop")
+	message := gui.Tr.SLocalize("SureDropStashEntry")
+	return gui.createConfirmationPanel(g, v, title, message, func(g *gocui.Gui, v *gocui.View) error {
+		return gui.stashDo(g, v, "drop")
+	}, nil)
+}
+
+func (gui *Gui) stashDo(g *gocui.Gui, v *gocui.View, method string) error {
+	stashEntry := gui.getSelectedStashEntry(v)
+	if stashEntry == nil {
+		errorMessage := gui.Tr.TemplateLocalize(
+			"NoStashTo",
+			Teml{
+				"method": method,
+			},
+		)
+		return gui.createErrorPanel(g, errorMessage)
+	}
+	if err := gui.GitCommand.StashDo(stashEntry.Index, method); err != nil {
+		gui.createErrorPanel(g, err.Error())
+	}
+	gui.refreshStashEntries(g)
+	return gui.refreshFiles(g)
+}
+
+func (gui *Gui) handleStashSave(g *gocui.Gui, filesView *gocui.View) error {
+	if len(gui.trackedFiles()) == 0 && len(gui.stagedFiles()) == 0 {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("NoTrackedStagedFilesStash"))
+	}
+	gui.createPromptPanel(g, filesView, gui.Tr.SLocalize("StashChanges"), func(g *gocui.Gui, v *gocui.View) error {
+		if err := gui.GitCommand.StashSave(gui.trimmedContent(v)); err != nil {
+			gui.createErrorPanel(g, err.Error())
+		}
+		gui.refreshStashEntries(g)
+		return gui.refreshFiles(g)
+	})
+	return nil
+}

pkg/gui/status_panel.go

@@ -0,0 +1,92 @@
+package gui
+
+import (
+	"fmt"
+
+	"github.com/fatih/color"
+	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
+func (gui *Gui) refreshStatus(g *gocui.Gui) error {
+	v, err := g.View("status")
+	if err != nil {
+		panic(err)
+	}
+	// for some reason if this isn't wrapped in an update the clear seems to
+	// be applied after the other things or something like that; the panel's
+	// contents end up cleared
+	g.Update(func(*gocui.Gui) error {
+		v.Clear()
+		pushables, pullables := gui.GitCommand.UpstreamDifferenceCount()
+		fmt.Fprint(v, "↑"+pushables+"↓"+pullables)
+		branches := gui.State.Branches
+		if err := gui.updateHasMergeConflictStatus(); err != nil {
+			return err
+		}
+		if gui.State.HasMergeConflicts {
+			fmt.Fprint(v, utils.ColoredString(" (merging)", color.FgYellow))
+		}
+
+		if len(branches) == 0 {
+			return nil
+		}
+		branch := branches[0]
+		name := utils.ColoredString(branch.Name, branch.GetColor())
+		repo := utils.GetCurrentRepoName()
+		fmt.Fprint(v, " "+repo+" → "+name)
+		return nil
+	})
+
+	return nil
+}
+
+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"),
+		"u": gui.Tr.SLocalize("CheckForUpdate"),
+	})
+}
+
+func (gui *Gui) handleCheckForUpdate(g *gocui.Gui, v *gocui.View) error {
+	gui.Updater.CheckForNewUpdate(gui.onUserUpdateCheckFinish, true)
+	return gui.createMessagePanel(gui.g, v, "", gui.Tr.SLocalize("CheckingForUpdates"))
+}
+
+func (gui *Gui) handleStatusSelect(g *gocui.Gui, v *gocui.View) error {
+	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.renderString(g, "main", dashboardString); err != nil {
+		return err
+	}
+	return gui.renderStatusOptions(g)
+}
+
+func (gui *Gui) handleOpenConfig(g *gocui.Gui, v *gocui.View) error {
+	return gui.openFile(gui.Config.GetUserConfig().ConfigFileUsed())
+}
+
+func (gui *Gui) handleEditConfig(g *gocui.Gui, v *gocui.View) error {
+	filename := gui.Config.GetUserConfig().ConfigFileUsed()
+	return gui.genericFileOpen(g, v, filename, gui.OSCommand.EditFile)
+}
+
+func lazygitTitle() string {
+	return `
+   _                       _ _
+  | |                     (_) |
+  | | __ _ _____   _  __ _ _| |_
+  | |/ _` + "`" + ` |_  / | | |/ _` + "`" + ` | | __|
+  | | (_| |/ /| |_| | (_| | | |_
+  |_|\__,_/___|\__, |\__, |_|\__|
+                __/ | __/ |
+               |___/ |___/       `
+}

pkg/gui/theme.go

@@ -0,0 +1,54 @@
+package gui
+
+import (
+	"github.com/jesseduffield/gocui"
+)
+
+// GetAttribute gets the gocui color attribute from the string
+func (gui *Gui) GetAttribute(key string) gocui.Attribute {
+	colorMap := map[string]gocui.Attribute{
+		"default":   gocui.ColorDefault,
+		"black":     gocui.ColorBlack,
+		"red":       gocui.ColorRed,
+		"green":     gocui.ColorGreen,
+		"yellow":    gocui.ColorYellow,
+		"blue":      gocui.ColorBlue,
+		"magenta":   gocui.ColorMagenta,
+		"cyan":      gocui.ColorCyan,
+		"white":     gocui.ColorWhite,
+		"bold":      gocui.AttrBold,
+		"reverse":   gocui.AttrReverse,
+		"underline": gocui.AttrUnderline,
+	}
+	value, present := colorMap[key]
+	if present {
+		return value
+	}
+	return gocui.ColorWhite
+}
+
+// GetColor bitwise OR's a list of attributes obtained via the given keys
+func (gui *Gui) GetColor(keys []string) gocui.Attribute {
+	var attribute gocui.Attribute
+	for _, key := range keys {
+		attribute = attribute | gui.GetAttribute(key)
+	}
+	return attribute
+}
+
+// GetOptionsPanelTextColor gets the color of the options panel text
+func (gui *Gui) GetOptionsPanelTextColor() (gocui.Attribute, error) {
+	userConfig := gui.Config.GetUserConfig()
+	optionsColor := userConfig.GetStringSlice("gui.theme.optionsTextColor")
+	return gui.GetColor(optionsColor), nil
+}
+
+// SetColorScheme sets the color scheme for the app based on the user config
+func (gui *Gui) SetColorScheme() error {
+	userConfig := gui.Config.GetUserConfig()
+	activeBorderColor := userConfig.GetStringSlice("gui.theme.activeBorderColor")
+	inactiveBorderColor := userConfig.GetStringSlice("gui.theme.inactiveBorderColor")
+	gui.g.FgColor = gui.GetColor(inactiveBorderColor)
+	gui.g.SelFgColor = gui.GetColor(activeBorderColor)
+	return nil
+}

pkg/gui/updates.go

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,270 @@
+package gui
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"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 {
+	gui.refreshBranches(g)
+	gui.refreshFiles(g)
+	gui.refreshCommits(g)
+	return nil
+}
+
+func (gui *Gui) nextView(g *gocui.Gui, v *gocui.View) error {
+	var focusedViewName string
+	if v == nil || v.Name() == cyclableViews[len(cyclableViews)-1] {
+		focusedViewName = cyclableViews[0]
+	} else {
+		for i := range cyclableViews {
+			if v.Name() == cyclableViews[i] {
+				focusedViewName = cyclableViews[i+1]
+				break
+			}
+			if i == len(cyclableViews)-1 {
+				message := gui.Tr.TemplateLocalize(
+					"IssntListOfViews",
+					Teml{
+						"name": v.Name(),
+					},
+				)
+				gui.Log.Info(message)
+				return nil
+			}
+		}
+	}
+	focusedView, err := g.View(focusedViewName)
+	if err != nil {
+		panic(err)
+	}
+	return gui.switchFocus(g, v, focusedView)
+}
+
+func (gui *Gui) previousView(g *gocui.Gui, v *gocui.View) error {
+	var focusedViewName string
+	if v == nil || v.Name() == cyclableViews[0] {
+		focusedViewName = cyclableViews[len(cyclableViews)-1]
+	} else {
+		for i := range cyclableViews {
+			if v.Name() == cyclableViews[i] {
+				focusedViewName = cyclableViews[i-1] // TODO: make this work properly
+				break
+			}
+			if i == len(cyclableViews)-1 {
+				message := gui.Tr.TemplateLocalize(
+					"IssntListOfViews",
+					Teml{
+						"name": v.Name(),
+					},
+				)
+				gui.Log.Info(message)
+				return nil
+			}
+		}
+	}
+	focusedView, err := g.View(focusedViewName)
+	if err != nil {
+		panic(err)
+	}
+	return gui.switchFocus(g, v, focusedView)
+}
+
+func (gui *Gui) newLineFocused(g *gocui.Gui, v *gocui.View) error {
+	mainView, _ := g.View("main")
+	mainView.SetOrigin(0, 0)
+
+	switch v.Name() {
+	case "status":
+		return gui.handleStatusSelect(g, v)
+	case "files":
+		return gui.handleFileSelect(g, v)
+	case "branches":
+		return gui.handleBranchSelect(g, v)
+	case "confirmation":
+		return nil
+	case "commitMessage":
+		return gui.handleCommitFocused(g, v)
+	case "main":
+		// 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"))
+	}
+}
+
+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)
+		}
+	}
+	return gui.switchFocus(g, v, previousView)
+}
+
+// pass in oldView = nil if you don't want to be able to return to your old view
+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" {
+		oldView.Highlight = false
+		message := gui.Tr.TemplateLocalize(
+			"settingPreviewsViewTo",
+			Teml{
+				"oldViewName": oldView.Name(),
+			},
+		)
+		gui.Log.Info(message)
+		gui.State.PreviousView = oldView.Name()
+	}
+	newView.Highlight = true
+	message := gui.Tr.TemplateLocalize(
+		"newFocusedViewIs",
+		Teml{
+			"newFocusedView": newView.Name(),
+		},
+	)
+	gui.Log.Info(message)
+	if _, err := g.SetCurrentView(newView.Name()); err != nil {
+		return err
+	}
+	g.Cursor = newView.Editable
+	return gui.newLineFocused(g, newView)
+}
+
+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
+	}
+
+	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 {
+	if err := v.SetCursor(0, 0); err != nil {
+		return err
+	}
+	return v.SetOrigin(0, 0)
+}
+
+// if the cursor down past the last item, move it to the last line
+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) 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
+		}
+		v.Clear()
+		output := string(bom.Clean([]byte(s)))
+		output = utils.NormalizeLinefeeds(output)
+		fmt.Fprint(v, output)
+		v.Wrap = true
+		return nil
+	})
+	return nil
+}
+
+func (gui *Gui) optionsMapToString(optionsMap map[string]string) string {
+	optionsArray := make([]string, 0)
+	for key, description := range optionsMap {
+		optionsArray = append(optionsArray, key+": "+description)
+	}
+	sort.Strings(optionsArray)
+	return strings.Join(optionsArray, ", ")
+}
+
+func (gui *Gui) renderOptionsMap(g *gocui.Gui, optionsMap map[string]string) error {
+	return gui.renderString(g, "options", gui.optionsMapToString(optionsMap))
+}
+
+// TODO: refactor properly
+func (gui *Gui) getFilesView(g *gocui.Gui) *gocui.View {
+	v, _ := g.View("files")
+	return v
+}
+
+func (gui *Gui) getCommitsView(g *gocui.Gui) *gocui.View {
+	v, _ := g.View("commits")
+	return v
+}
+
+func (gui *Gui) getCommitMessageView(g *gocui.Gui) *gocui.View {
+	v, _ := g.View("commitMessage")
+	return v
+}
+
+func (gui *Gui) trimmedContent(v *gocui.View) string {
+	return strings.TrimSpace(v.Buffer())
+}
+
+func (gui *Gui) currentViewName(g *gocui.Gui) string {
+	currentView := g.CurrentView()
+	return currentView.Name()
+}

pkg/i18n/dutch.go

@@ -0,0 +1,300 @@
+package i18n
+
+import (
+	"github.com/nicksnyder/go-i18n/v2/i18n"
+	"golang.org/x/text/language"
+)
+
+// addDutch will add all dutch translations
+func addDutch(i18nObject *i18n.Bundle) error {
+
+	// add the translations
+	return 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:    "FilesTitle",
+			Other: "Bestanden",
+		}, &i18n.Message{
+			ID:    "BranchesTitle",
+			Other: "Branches",
+		}, &i18n.Message{
+			ID:    "CommitsTitle",
+			Other: "Commits",
+		}, &i18n.Message{
+			ID:    "StashTitle",
+			Other: "Stash",
+		}, &i18n.Message{
+			ID:    "CommitMessage",
+			Other: "Commit Bericht",
+		}, &i18n.Message{
+			ID:    "CommitChanges",
+			Other: "Commit Veranderingen",
+		}, &i18n.Message{
+			ID:    "StatusTitle",
+			Other: "Status",
+		}, &i18n.Message{
+			ID:    "navigate",
+			Other: "navigeer",
+		}, &i18n.Message{
+			ID:    "stashFiles",
+			Other: "stash-bestanden",
+		}, &i18n.Message{
+			ID:    "open",
+			Other: "open",
+		}, &i18n.Message{
+			ID:    "ignore",
+			Other: "negeren",
+		}, &i18n.Message{
+			ID:    "delete",
+			Other: "verwijderen",
+		}, &i18n.Message{
+			ID:    "toggleStaged",
+			Other: "toggle staged",
+		}, &i18n.Message{
+			ID:    "toggleStagedAll",
+			Other: "toggle staged alle",
+		}, &i18n.Message{
+			ID:    "refresh",
+			Other: "verversen",
+		}, &i18n.Message{
+			ID:    "addPatch",
+			Other: "verandering toevoegen",
+		}, &i18n.Message{
+			ID:    "edit",
+			Other: "veranderen",
+		}, &i18n.Message{
+			ID:    "scroll",
+			Other: "scroll",
+		}, &i18n.Message{
+			ID:    "abortMerge",
+			Other: "samenvoegen afbreken",
+		}, &i18n.Message{
+			ID:    "resolveMergeConflicts",
+			Other: "verhelp samenvoegen fouten",
+		}, &i18n.Message{
+			ID:    "checkout",
+			Other: "uitchecken",
+		}, &i18n.Message{
+			ID:    "NoChangedFiles",
+			Other: "Geen Bestanden verandert",
+		}, &i18n.Message{
+			ID:    "FileHasNoUnstagedChanges",
+			Other: "Het bestand heeft geen unstaged veranderingen om toe te voegen",
+		}, &i18n.Message{
+			ID:    "CannotGitAdd",
+			Other: "Kan commando niet uitvoeren git add --path untracked files",
+		}, &i18n.Message{
+			ID:    "CantIgnoreTrackFiles",
+			Other: "Kan gevolgde bestanden niet negeren",
+		}, &i18n.Message{
+			ID:    "NoStagedFilesToCommit",
+			Other: "Er zijn geen staged bestanden om te commiten",
+		}, &i18n.Message{
+			ID:    "NoFilesDisplay",
+			Other: "Geen bestanden om te laten zien",
+		}, &i18n.Message{
+			ID:    "PullWait",
+			Other: "Pulling...",
+		}, &i18n.Message{
+			ID:    "PushWait",
+			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` 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 verwijdert)",
+		}, &i18n.Message{
+			ID:    "AlreadyCheckedOutBranch",
+			Other: "Je hebt uitgecheckt op deze branch",
+		}, &i18n.Message{
+			ID:    "SureForceCheckout",
+			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",
+		}, &i18n.Message{
+			ID:    "BranchName",
+			Other: "Branch naam",
+		}, &i18n.Message{
+			ID:    "NewBranchNameBranchOff",
+			Other: "Nieuw branch naam (Branch is afgeleid van {{.branchName}})",
+		}, &i18n.Message{
+			ID:    "CantDeleteCheckOutBranch",
+			Other: "Je kan een uitgecheckte branch niet verwijderen!",
+		}, &i18n.Message{
+			ID:    "DeleteBranch",
+			Other: "Verwijder branch",
+		}, &i18n.Message{
+			ID:    "DeleteBranchMessage",
+			Other: "Weet je zeker dat je branch {{.selectedBranchName}} wil verwijderen?",
+		}, &i18n.Message{
+			ID:    "ForceDeleteBranchMessage",
+			Other: "Weet je zeker dat je branch {{.selectedBranchName}} geforceerd wil verwijderen?",
+		}, &i18n.Message{
+			ID:    "CantMergeBranchIntoItself",
+			Other: "Je kan niet een branch in zichzelf mergen",
+		}, &i18n.Message{
+			ID:    "forceCheckout",
+			Other: "forceer checkout",
+		}, &i18n.Message{
+			ID:    "merge",
+			Other: "merge",
+		}, &i18n.Message{
+			ID:    "checkoutByName",
+			Other: "uitchecken bij naam",
+		}, &i18n.Message{
+			ID:    "newBranch",
+			Other: "nieuwe branch",
+		}, &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",
+		}, &i18n.Message{
+			ID:    "NoTrackingThisBranch",
+			Other: "deze branch wordt niet gevolgd",
+		}, &i18n.Message{
+			ID:    "CommitWithoutMessageErr",
+			Other: "Je kan geen commit maken zonder commit bericht",
+		}, &i18n.Message{
+			ID:    "CloseConfirm",
+			Other: "{{.keyBindClose}}: Sluiten, {{.keyBindConfirm}}: Bevestigen",
+		}, &i18n.Message{
+			ID:    "SureResetThisCommit",
+			Other: "Weet je het zeker dat je wil resetten naar deze commit?",
+		}, &i18n.Message{
+			ID:    "ResetToCommit",
+			Other: "Reset Naar Commit",
+		}, &i18n.Message{
+			ID:    "squashDown",
+			Other: "squash beneden",
+		}, &i18n.Message{
+			ID:    "rename",
+			Other: "hernoem",
+		}, &i18n.Message{
+			ID:    "resetToThisCommit",
+			Other: "reset naar deze commit",
+		}, &i18n.Message{
+			ID:    "fixupCommit",
+			Other: "Fixup commit",
+		}, &i18n.Message{
+			ID:    "NoCommitsThisBranch",
+			Other: "Er zijn geen commits voor deze branch",
+		}, &i18n.Message{
+			ID:    "OnlySquashTopmostCommit",
+			Other: "Kan alleen bovenste commit squashen",
+		}, &i18n.Message{
+			ID:    "YouNoCommitsToSquash",
+			Other: "Je hebt geen commits om mee te squashen",
+		}, &i18n.Message{
+			ID:    "CantFixupWhileUnstagedChanges",
+			Other: "Kan geen Fixup uitvoeren op unstaged veranderingen",
+		}, &i18n.Message{
+			ID:    "Fixup",
+			Other: "Fixup",
+		}, &i18n.Message{
+			ID:    "SureFixupThisCommit",
+			Other: "Weet je zeker dat je fixup wil uitvoeren op deze commit? De commit hieronder zol worden squashed in deze",
+		}, &i18n.Message{
+			ID:    "OnlyRenameTopCommit",
+			Other: "Je kan alleen de bovenste commit hernoemen",
+		}, &i18n.Message{
+			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: "Fout",
+		}, &i18n.Message{
+			ID:    "resizingPopupPanel",
+			Other: "resizen popup paneel",
+		}, &i18n.Message{
+			ID:    "RunningSubprocess",
+			Other: "subprocess lopend",
+		}, &i18n.Message{
+			ID:    "selectHunk",
+			Other: "selecteer Hunk",
+		}, &i18n.Message{
+			ID:    "navigateConflicts",
+			Other: "navigeer conflicts",
+		}, &i18n.Message{
+			ID:    "pickHunk",
+			Other: "kies Hunk",
+		}, &i18n.Message{
+			ID:    "pickBothHunks",
+			Other: "kies bijde hunks",
+		}, &i18n.Message{
+			ID:    "undo",
+			Other: "ongedaan maken",
+		}, &i18n.Message{
+			ID:    "pop",
+			Other: "pop",
+		}, &i18n.Message{
+			ID:    "drop",
+			Other: "drop",
+		}, &i18n.Message{
+			ID:    "apply",
+			Other: "toepassen",
+		}, &i18n.Message{
+			ID:    "NoStashEntries",
+			Other: "Geen stash items",
+		}, &i18n.Message{
+			ID:    "StashDrop",
+			Other: "Stash drop",
+		}, &i18n.Message{
+			ID:    "SureDropStashEntry",
+			Other: "Weet je het zeker dat je deze stash entry wil laten vallen?",
+		}, &i18n.Message{
+			ID:    "NoStashTo",
+			Other: "Geen stash voor {{.method}}",
+		}, &i18n.Message{
+			ID:    "NoTrackedStagedFilesStash",
+			Other: "Je hebt geen tracked/staged bestanden om te laten stashen",
+		}, &i18n.Message{
+			ID:    "StashChanges",
+			Other: "Stash veranderingen",
+		}, &i18n.Message{
+			ID:    "IssntListOfViews",
+			Other: "{{.name}} is niet in de lijst van weergaves",
+		}, &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",
+		},
+	)
+}

pkg/i18n/english.go

@@ -0,0 +1,347 @@
+/*
+
+Todo list when making a new translation
+- Copy this file and rename it to the language you want to translate to like someLanguage.go
+- Change the addEnglish() name to the language you want to translate to like addSomeLanguage()
+- change the first function argument of i18nObject.AddMessages( to the language you want to translate to like language.SomeLanguage
+- Remove this todo and the about section
+
+*/
+
+package i18n
+
+import (
+	"github.com/nicksnyder/go-i18n/v2/i18n"
+	"golang.org/x/text/language"
+)
+
+func addEnglish(i18nObject *i18n.Bundle) error {
+
+	return i18nObject.AddMessages(language.English,
+		&i18n.Message{
+			ID:    "NotEnoughSpace",
+			Other: "Not enough space to render panels",
+		}, &i18n.Message{
+			ID:    "DiffTitle",
+			Other: "Diff",
+		}, &i18n.Message{
+			ID:    "FilesTitle",
+			Other: "Files",
+		}, &i18n.Message{
+			ID:    "BranchesTitle",
+			Other: "Branches",
+		}, &i18n.Message{
+			ID:    "CommitsTitle",
+			Other: "Commits",
+		}, &i18n.Message{
+			ID:    "StashTitle",
+			Other: "Stash",
+		}, &i18n.Message{
+			ID:    "CommitMessage",
+			Other: "Commit message",
+		}, &i18n.Message{
+			ID:    "CommitChanges",
+			Other: "commit changes",
+		}, &i18n.Message{
+			ID:    "StatusTitle",
+			Other: "Status",
+		}, &i18n.Message{
+			ID:    "navigate",
+			Other: "navigate",
+		}, &i18n.Message{
+			ID:    "stashFiles",
+			Other: "stash files",
+		}, &i18n.Message{
+			ID:    "open",
+			Other: "open",
+		}, &i18n.Message{
+			ID:    "ignore",
+			Other: "ignore",
+		}, &i18n.Message{
+			ID:    "delete",
+			Other: "delete",
+		}, &i18n.Message{
+			ID:    "toggleStaged",
+			Other: "toggle staged",
+		}, &i18n.Message{
+			ID:    "toggleStagedAll",
+			Other: "stage/unstage all",
+		}, &i18n.Message{
+			ID:    "refresh",
+			Other: "refresh",
+		}, &i18n.Message{
+			ID:    "addPatch",
+			Other: "add patch",
+		}, &i18n.Message{
+			ID:    "edit",
+			Other: "edit",
+		}, &i18n.Message{
+			ID:    "scroll",
+			Other: "scroll",
+		}, &i18n.Message{
+			ID:    "abortMerge",
+			Other: "abort merge",
+		}, &i18n.Message{
+			ID:    "resolveMergeConflicts",
+			Other: "resolve merge conflicts",
+		}, &i18n.Message{
+			ID:    "checkout",
+			Other: "checkout",
+		}, &i18n.Message{
+			ID:    "NoChangedFiles",
+			Other: "No changed files",
+		}, &i18n.Message{
+			ID:    "FileHasNoUnstagedChanges",
+			Other: "File has no unstaged changes to add",
+		}, &i18n.Message{
+			ID:    "CannotGitAdd",
+			Other: "Cannot git add --patch untracked files",
+		}, &i18n.Message{
+			ID:    "CantIgnoreTrackFiles",
+			Other: "Cannot ignore tracked files",
+		}, &i18n.Message{
+			ID:    "NoStagedFilesToCommit",
+			Other: "There are no staged files to commit",
+		}, &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:    "FileNoMergeCons",
+			Other: "This file has no merge conflicts",
+		}, &i18n.Message{
+			ID:    "SureResetHardHead",
+			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)?",
+		}, &i18n.Message{
+			ID:    "AlreadyCheckedOutBranch",
+			Other: "You have already checked out this branch",
+		}, &i18n.Message{
+			ID:    "SureForceCheckout",
+			Other: "Are you sure you want force checkout? You will lose all local changes",
+		}, &i18n.Message{
+			ID:    "ForceCheckoutBranch",
+			Other: "Force Checkout Branch",
+		}, &i18n.Message{
+			ID:    "BranchName",
+			Other: "Branch name",
+		}, &i18n.Message{
+			ID:    "NewBranchNameBranchOff",
+			Other: "New Branch Name (Branch is off of {{.branchName}})",
+		}, &i18n.Message{
+			ID:    "CantDeleteCheckOutBranch",
+			Other: "You cannot delete the checked out branch!",
+		}, &i18n.Message{
+			ID:    "DeleteBranch",
+			Other: "Delete Branch",
+		}, &i18n.Message{
+			ID:    "DeleteBranchMessage",
+			Other: "Are you sure you want to delete the branch {{.selectedBranchName}}?",
+		}, &i18n.Message{
+			ID:    "ForceDeleteBranchMessage",
+			Other: "Are you sure you want to force delete the branch {{.selectedBranchName}}?",
+		}, &i18n.Message{
+			ID:    "CantMergeBranchIntoItself",
+			Other: "You cannot merge a branch into itself",
+		}, &i18n.Message{
+			ID:    "forceCheckout",
+			Other: "force checkout",
+		}, &i18n.Message{
+			ID:    "merge",
+			Other: "merge",
+		}, &i18n.Message{
+			ID:    "checkoutByName",
+			Other: "checkout by name",
+		}, &i18n.Message{
+			ID:    "newBranch",
+			Other: "new branch",
+		}, &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",
+		}, &i18n.Message{
+			ID:    "NoTrackingThisBranch",
+			Other: "There is no tracking for this branch",
+		}, &i18n.Message{
+			ID:    "CommitWithoutMessageErr",
+			Other: "You cannot commit without a commit message",
+		}, &i18n.Message{
+			ID:    "CloseConfirm",
+			Other: "{{.keyBindClose}}: close, {{.keyBindConfirm}}: confirm",
+		}, &i18n.Message{
+			ID:    "SureResetThisCommit",
+			Other: "Are you sure you want to reset to this commit?",
+		}, &i18n.Message{
+			ID:    "ResetToCommit",
+			Other: "Reset To Commit",
+		}, &i18n.Message{
+			ID:    "squashDown",
+			Other: "squash down",
+		}, &i18n.Message{
+			ID:    "rename",
+			Other: "rename",
+		}, &i18n.Message{
+			ID:    "resetToThisCommit",
+			Other: "reset to this commit",
+		}, &i18n.Message{
+			ID:    "fixupCommit",
+			Other: "fixup commit",
+		}, &i18n.Message{
+			ID:    "NoCommitsThisBranch",
+			Other: "No commits for this branch",
+		}, &i18n.Message{
+			ID:    "OnlySquashTopmostCommit",
+			Other: "Can only squash topmost commit",
+		}, &i18n.Message{
+			ID:    "YouNoCommitsToSquash",
+			Other: "You have no commits to squash with",
+		}, &i18n.Message{
+			ID:    "CantFixupWhileUnstagedChanges",
+			Other: "Can't fixup while there are unstaged changes",
+		}, &i18n.Message{
+			ID:    "Fixup",
+			Other: "Fixup",
+		}, &i18n.Message{
+			ID:    "SureFixupThisCommit",
+			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 rename topmost commit",
+		}, &i18n.Message{
+			ID:    "RenameCommit",
+			Other: "Rename Commit",
+		}, &i18n.Message{
+			ID:    "PotentialErrInGetselectedCommit",
+			Other: "potential error in getSelected Commit (mismatched ui and state)",
+		}, &i18n.Message{
+			ID:    "NoCommitsThisBranch",
+			Other: "No commits for this branch",
+		}, &i18n.Message{
+			ID:    "Error",
+			Other: "Error",
+		}, &i18n.Message{
+			ID:    "resizingPopupPanel",
+			Other: "resizing popup panel",
+		}, &i18n.Message{
+			ID:    "RunningSubprocess",
+			Other: "running subprocess",
+		}, &i18n.Message{
+			ID:    "selectHunk",
+			Other: "select hunk",
+		}, &i18n.Message{
+			ID:    "navigateConflicts",
+			Other: "navigate conflicts",
+		}, &i18n.Message{
+			ID:    "pickHunk",
+			Other: "pick hunk",
+		}, &i18n.Message{
+			ID:    "pickBothHunks",
+			Other: "pick both hunks",
+		}, &i18n.Message{
+			ID:    "undo",
+			Other: "undo",
+		}, &i18n.Message{
+			ID:    "pop",
+			Other: "pop",
+		}, &i18n.Message{
+			ID:    "drop",
+			Other: "drop",
+		}, &i18n.Message{
+			ID:    "apply",
+			Other: "apply",
+		}, &i18n.Message{
+			ID:    "NoStashEntries",
+			Other: "No stash entries",
+		}, &i18n.Message{
+			ID:    "StashDrop",
+			Other: "Stash drop",
+		}, &i18n.Message{
+			ID:    "SureDropStashEntry",
+			Other: "Are you sure you want to drop this stash entry?",
+		}, &i18n.Message{
+			ID:    "NoStashTo",
+			Other: "No stash to {{.method}}",
+		}, &i18n.Message{
+			ID:    "NoTrackedStagedFilesStash",
+			Other: "You have no tracked/staged files to stash",
+		}, &i18n.Message{
+			ID:    "StashChanges",
+			Other: "Stash changes",
+		}, &i18n.Message{
+			ID:    "IssntListOfViews",
+			Other: "{{.name}} is not in the list of views",
+		}, &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}}",
+		}, &i18n.Message{
+			ID:    "CantCloseConfirmationPrompt",
+			Other: "Could not close confirmation prompt: {{.error}}",
+		}, &i18n.Message{
+			ID:    "NoChangedFiles",
+			Other: "No changed files",
+		}, &i18n.Message{
+			ID:    "ClearFilePanel",
+			Other: "Clear file panel",
+		}, &i18n.Message{
+			ID:    "MergeAborted",
+			Other: "Merge aborted",
+		}, &i18n.Message{
+			ID:    "OpenConfig",
+			Other: "open config file",
+		}, &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 has non-backwards compatible changes.",
+		}, &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.`,
+		},
+	)
+}

pkg/i18n/i18n.go

@@ -0,0 +1,102 @@
+package i18n
+
+import (
+	"github.com/cloudfoundry/jibber_jabber"
+	"github.com/nicksnyder/go-i18n/v2/i18n"
+	"github.com/sirupsen/logrus"
+	"golang.org/x/text/language"
+)
+
+// Teml is short for template used to make the required map[string]interface{} shorter when using gui.Tr.SLocalize and gui.Tr.TemplateLocalize
+type Teml map[string]interface{}
+
+// Localizer will translate a message into the user's language
+type Localizer struct {
+	i18nLocalizer *i18n.Localizer
+	language      string
+	Log           *logrus.Entry
+}
+
+// NewLocalizer creates a new Localizer
+func NewLocalizer(log *logrus.Entry) *Localizer {
+	userLang := detectLanguage(jibber_jabber.DetectLanguage)
+
+	log.Info("language: " + userLang)
+
+	return setupLocalizer(log, userLang)
+}
+
+// Localize handels the translations
+// expects i18n.LocalizeConfig as input: https://godoc.org/github.com/nicksnyder/go-i18n/v2/i18n#Localizer.MustLocalize
+// output: translated string
+func (l *Localizer) Localize(config *i18n.LocalizeConfig) string {
+	return l.i18nLocalizer.MustLocalize(config)
+}
+
+// SLocalize (short localize) is for 1 line localizations
+// ID: The id that is used in the .toml translation files
+// Other: the default message it needs to return if there is no translation found or the system is english
+func (l *Localizer) SLocalize(ID string) string {
+	return l.Localize(&i18n.LocalizeConfig{
+		DefaultMessage: &i18n.Message{
+			ID: ID,
+		},
+	})
+}
+
+// TemplateLocalize allows the Other input to be dynamic
+func (l *Localizer) TemplateLocalize(ID string, TemplateData map[string]interface{}) string {
+	return l.Localize(&i18n.LocalizeConfig{
+		DefaultMessage: &i18n.Message{
+			ID: ID,
+		},
+		TemplateData: TemplateData,
+	})
+}
+
+// GetLanguage returns the currently selected language, e.g 'en'
+func (l *Localizer) GetLanguage() string {
+	return l.language
+}
+
+// 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,
+	}
+}

pkg/i18n/i18n_test.go

@@ -0,0 +1,87 @@
+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")
+}
+func TestNewLocalizer(t *testing.T) {
+	assert.NotNil(t, NewLocalizer(getDummyLog()))
+}
+
+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))
+	}
+}
+
+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 wil verwijderen?", l.TemplateLocalize("DeleteBranchMessage", Teml{"selectedBranchName": "test"}))
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		s.test(setupLocalizer(getDummyLog(), s.userLang))
+	}
+}

pkg/i18n/polish.go

@@ -0,0 +1,292 @@
+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:    "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:    "CommitMessage",
+			Other: "Wiadomość commita",
+		}, &i18n.Message{
+			ID:    "CommitChanges",
+			Other: "commituj zmiany",
+		}, &i18n.Message{
+			ID:    "StatusTitle",
+			Other: "Status",
+		}, &i18n.Message{
+			ID:    "navigate",
+			Other: "nawiguj",
+		}, &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:    "FileNoMergeCons",
+			Other: "Ten plik nie powoduje konfliktów scalania",
+		}, &i18n.Message{
+			ID:    "SureResetHardHead",
+			Other: "Jesteś pewny, że chcesz wykonać `reset --hard HEAD`? 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:    "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:    "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:    "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:    "PotentialErrInGetselectedCommit",
+			Other: "potencjalny błąd w getSelected Commit (niedopasowane ui i stan)",
+		}, &i18n.Message{
+			ID:    "NoCommitsThisBranch",
+			Other: "Brak commitów dla tej gałęzi",
+		}, &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:    "settingPreviewsViewTo",
+			Other: "ustawianie poprzedniego widoku na: {{.oldViewName}}",
+		}, &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:    "NoChangedFiles",
+			Other: "Brak zmienionych plików",
+		}, &i18n.Message{
+			ID:    "ClearFilePanel",
+			Other: "Wyczyść panel plików",
+		}, &i18n.Message{
+			ID:    "MergeAborted",
+			Other: "Scalanie anulowane",
+		},
+	)
+}

pkg/test/test.go

@@ -0,0 +1,31 @@
+package test
+
+import (
+	"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/updates/updates.go

@@ -0,0 +1,303 @@
+package updates
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+
+	"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"
+)
+
+// Update checks for updates and does updates
+type Updater struct {
+	Log       *logrus.Entry
+	Config    config.AppConfigurer
+	OSCommand *commands.OSCommand
+	Tr        *i18n.Localizer
+}
+
+// Updater implements the check and update methods
+type Updaterer interface {
+	CheckForNewUpdate()
+	Update()
+}
+
+var (
+	projectUrl = "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")
+
+	updater := &Updater{
+		Log:       contextLogger,
+		Config:    config,
+		OSCommand: osCommand,
+		Tr:        tr,
+	}
+	return updater, nil
+}
+
+func (u *Updater) getLatestVersionNumber() (string, error) {
+	req, err := http.NewRequest("GET", projectUrl+"/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()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return "", err
+	}
+
+	byt := []byte(body)
+	var dat map[string]interface{}
+	if err := json.Unmarshal(byt, &dat); err != nil {
+		return "", err
+	}
+	return dat["tag_name"].(string), nil
+}
+
+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
+	}
+	return strings.Split(oldVersion, ".")[0] != strings.Split(newVersion, ".")[0]
+}
+
+func (u *Updater) checkForNewUpdate() (string, error) {
+	u.Log.Info("Checking for an updated version")
+	if err := u.RecordLastUpdateCheck(); err != nil {
+		return "", err
+	}
+
+	newVersion, err := u.getLatestVersionNumber()
+	if err != nil {
+		return "", err
+	}
+	u.Log.Info("Current version is " + u.Config.GetVersion())
+	u.Log.Info("New version is " + newVersion)
+
+	if newVersion == u.Config.GetVersion() {
+		return "", errors.New(u.Tr.SLocalize("OnLatestVersionErr"))
+	}
+
+	if u.majorVersionDiffers(u.Config.GetVersion(), newVersion) {
+		return "", errors.New(u.Tr.SLocalize("MajorVersionErr"))
+	}
+
+	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",
+		projectUrl,
+		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

@@ -0,0 +1,92 @@
+package utils
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/fatih/color"
+)
+
+// SplitLines takes a multiline string and splits it on newlines
+// currently we are also stripping \r's which may have adverse effects for
+// windows users (but no issues have been raised yet)
+func SplitLines(multilineString string) []string {
+	multilineString = strings.Replace(multilineString, "\r", "", -1)
+	if multilineString == "" || multilineString == "\n" {
+		return make([]string, 0)
+	}
+	lines := strings.Split(multilineString, "\n")
+	if lines[len(lines)-1] == "" {
+		return lines[:len(lines)-1]
+	}
+	return lines
+}
+
+// WithPadding pads a string as much as you want
+func WithPadding(str string, padding int) string {
+	if padding-len(str) < 0 {
+		return str
+	}
+	return str + strings.Repeat(" ", padding-len(str))
+}
+
+// ColoredString takes a string and a colour attribute and returns a colored
+// string with that attribute
+func ColoredString(str string, colorAttribute color.Attribute) string {
+	colour := color.New(colorAttribute)
+	return ColoredStringDirect(str, colour)
+}
+
+// ColoredStringDirect used for aggregating a few color attributes rather than
+// just sending a single one
+func ColoredStringDirect(str string, colour *color.Color) string {
+	return colour.SprintFunc()(fmt.Sprint(str))
+}
+
+// GetCurrentRepoName gets the repo's base name
+func GetCurrentRepoName() string {
+	pwd, err := os.Getwd()
+	if err != nil {
+		log.Fatalln(err.Error())
+	}
+	return filepath.Base(pwd)
+}
+
+// TrimTrailingNewline - Trims the trailing newline
+// TODO: replace with `chomp` after refactor
+func TrimTrailingNewline(str string) string {
+	if strings.HasSuffix(str, "\n") {
+		return str[:len(str)-1]
+	}
+	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"
+}
+
+func Loader() string {
+	characters := "|/-\\"
+	now := time.Now()
+	nanos := now.UnixNano()
+	index := nanos / 50000000 % int64(len(characters))
+	return characters[index : index+1]
+}