bump version to v0.1.64

Add info about release PPA

.circleci/config.yml

@@ -0,0 +1,26 @@
+# Golang CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-go/ for more details
+version: 2
+jobs:
+  build:
+    docker:
+      # specify the version
+      - image: circleci/golang:1.9
+
+      # Specify service dependencies here if necessary
+      # CircleCI maintains a library of pre-built images
+      # documented at https://circleci.com/docs/2.0/circleci-images/
+      # - image: circleci/postgres:9.4
+
+    #### TEMPLATE_NOTE: go expects specific checkout path representing url
+    #### expecting it in the form of
+    ####   /go/src/github.com/circleci/go-tool
+    ####   /go/src/bitbucket.org/circleci/go-tool
+    working_directory: /go/src/github.com/jesseduffield/lazygit
+    steps:
+      - checkout
+
+      # specify any bash command here prefixed with `run: `
+      - run: go get -v -t -d ./...
+      - run: go test -v ./...

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,28 @@
+---
+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]
+
+**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,7 @@
+development.log
+commands.log
+extra/lgit.rb
+notes/go.notes
+TODO.notes
+TODO.md
+test/repos/repo

.goreleaser.yml

@@ -0,0 +1,59 @@
+# 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
+archive:
+  replacements:
+    darwin: Darwin
+    linux: Linux
+    windows: Windows
+    386: i386
+    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:'
+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,338 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  digest = "1:b2339e83ce9b5c4f79405f949429a7f68a9a904fed903c672aac1e7ceb7f5f02"
+  name = "github.com/Sirupsen/logrus"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "3e01752db0189b9157070a0e1668a620f9a85da2"
+  version = "v1.0.6"
+
+[[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]]
+  branch = "master"
+  digest = "1:4a8ed9b8cf22bd03bee5d74179fa06a282e4a73b6de949f7a865ff56cd2537e0"
+  name = "github.com/golang-collections/collections"
+  packages = ["stack"]
+  pruneopts = "NUT"
+  revision = "604e922904d35e97f98a774db7881f049cd8d970"
+
+[[projects]]
+  branch = "master"
+  digest = "1:62fe3a7ea2050ecbd753a71889026f83d73329337ada66325cbafd5dea5f713d"
+  name = "github.com/jbenet/go-context"
+  packages = ["io"]
+  pruneopts = "NUT"
+  revision = "d14ea06fba99483203c19d92cfcd13ebe73135f4"
+
+[[projects]]
+  branch = "master"
+  digest = "1:c9a848b0484a72da2dae28957b4f67501fe27fa38bc73f4713e454353c0a4a60"
+  name = "github.com/jesseduffield/gocui"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "432b7f6215f81ef1aaa1b2d9b69887822923cf79"
+
+[[projects]]
+  digest = "1:8021af4dcbd531ae89433c8c3a6520e51064114aaf8eb1724c3cf911c497c9ba"
+  name = "github.com/kevinburke/ssh_config"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "9fc7bb800b555d63157c65a904c86a2cc7b4e795"
+  version = "0.4"
+
+[[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]]
+  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:d917313f309bda80d27274d53985bc65651f81a5b66b820749ac7f8ef061fd04"
+  name = "github.com/sergi/go-diff"
+  packages = ["diffmatchpatch"]
+  pruneopts = "NUT"
+  revision = "1744e2970ca51c86172c8190fadad617561ed6e7"
+  version = "v1.0.0"
+
+[[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:cd5ffc5bda4e0296ab3e4de90dbb415259c78e45e7fab13694b14cde8ab74541"
+  name = "github.com/tcnksm/go-gitconfig"
+  packages = ["."]
+  pruneopts = "NUT"
+  revision = "d154598bacbf4501c095a309753c5d4af66caa81"
+  version = "v0.1.2"
+
+[[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"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  input-imports = [
+    "github.com/Sirupsen/logrus",
+    "github.com/cloudfoundry/jibber_jabber",
+    "github.com/davecgh/go-spew/spew",
+    "github.com/fatih/color",
+    "github.com/golang-collections/collections/stack",
+    "github.com/jesseduffield/gocui",
+    "github.com/mgutz/str",
+    "github.com/nicksnyder/go-i18n/v2/i18n",
+    "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",
+  ]
+  solver-name = "gps-cdcl"
+  solver-version = 1

Gopkg.toml

@@ -0,0 +1,42 @@
+# 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"

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 [![Go Report Card](https://goreportcard.com/badge/github.com/jesseduffield/lazygit)](https://goreportcard.com/report/github.com/jesseduffield/lazygit)
+
+A simple terminal UI for git commands, written in Go with the [gocui](https://github.com/jroimartin/gocui "gocui") library.
+
+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](https://image.ibb.co/mmeXho/optimisedgif.gif)
+
+  * [Installation](https://github.com/jesseduffield/lazygit#installation)
+  * [Usage](https://github.com/jesseduffield/lazygit#usage),
+    [Keybindings](https://github.com/jesseduffield/lazygit/blob/master/docs/Keybindings.md)
+  * [Cool Features](https://github.com/jesseduffield/lazygit#cool-features)
+  * [Contributing](https://github.com/jesseduffield/lazygit#contributing)
+  * [Video Tutorial](https://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](https://github.com/jesseduffield/lazygit/blob/master/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](https://image.ibb.co/iyxUTT/shortermerging.gif)
+
+### Viewing commit diffs
+![Viewing Commit Diffs](https://image.ibb.co/gPD02o/capture.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](/files/slack_rgb.png)](https://join.slack.com/t/lazygit/shared_invite/enQtNDE3MjIwNTYyMDA0LTM3Yjk3NzdiYzhhNTA1YjM4Y2M4MWNmNDBkOTI0YTE4YjQ1ZmI2YWRhZTgwNjg2YzhhYjg3NDBlMmQyMTI5N2M)
+
+## Work in progress
+This is still a work in progress so there's still bugs to iron out and as this
+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).

VERSION

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

docs/Keybindings.md

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

main.go

@@ -0,0 +1,70 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/user"
+	"path/filepath"
+
+	"github.com/jesseduffield/lazygit/pkg/app"
+	"github.com/jesseduffield/lazygit/pkg/config"
+)
+
+var (
+	commit  string
+	version = "unversioned"
+	date    string
+
+	debuggingFlag = flag.Bool("debug", false, "a boolean")
+	versionFlag   = flag.Bool("v", false, "Print the current version")
+)
+
+func homeDirectory() string {
+	usr, err := user.Current()
+	if err != nil {
+		log.Fatal(err)
+	}
+	return usr.HomeDir
+}
+
+func projectPath(path string) string {
+	gopath := os.Getenv("GOPATH")
+	return filepath.FromSlash(gopath + "/src/github.com/jesseduffield/lazygit/" + path)
+}
+
+// when building the binary, `version` is set as a compile-time variable, along
+// with `date` and `commit`. If this program has been opened directly via go,
+// we will populate the `version` with VERSION in the lazygit root directory
+func fallbackVersion() string {
+	path := projectPath("VERSION")
+	byteVersion, err := ioutil.ReadFile(path)
+	if err != nil {
+		return "unversioned"
+	}
+	return string(byteVersion)
+}
+
+func main() {
+	flag.Parse()
+	if version == "unversioned" {
+		version = fallbackVersion()
+	}
+	if *versionFlag {
+		fmt.Printf("commit=%s, build date=%s, version=%s\n", commit, date, version)
+		os.Exit(0)
+	}
+	appConfig := &config.AppConfig{
+		Name:      "lazygit",
+		Version:   version,
+		Commit:    commit,
+		BuildDate: date,
+		Debug:     *debuggingFlag,
+	}
+	app, err := app.NewApp(appConfig)
+	app.Log.Info(err)
+	app.GitCommand.SetupGit()
+	app.Gui.RunWithSubprocesses()
+}

pkg/app/app.go

@@ -0,0 +1,79 @@
+package app
+
+import (
+	"io"
+	"io/ioutil"
+	"os"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/jesseduffield/lazygit/pkg/commands"
+	"github.com/jesseduffield/lazygit/pkg/config"
+	"github.com/jesseduffield/lazygit/pkg/gui"
+	"github.com/jesseduffield/lazygit/pkg/i18n"
+)
+
+// App struct
+type App struct {
+	closers []io.Closer
+
+	Config     config.AppConfigurer
+	Log        *logrus.Logger
+	OSCommand  *commands.OSCommand
+	GitCommand *commands.GitCommand
+	Gui        *gui.Gui
+	Tr         *i18n.Localizer
+}
+
+func newLogger(config config.AppConfigurer) *logrus.Logger {
+	log := logrus.New()
+	if !config.GetDebug() {
+		log.Out = ioutil.Discard
+		return log
+	}
+	file, err := os.OpenFile("development.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+	if err != nil {
+		panic("unable to log to file") // TODO: don't panic (also, remove this call to the `panic` function)
+	}
+	log.SetOutput(file)
+	return log
+}
+
+// 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, err = commands.NewOSCommand(app.Log)
+	if err != nil {
+		return nil, err
+	}
+
+	app.Tr, err = i18n.NewLocalizer(app.Log)
+	if err != nil {
+		return nil, err
+	}
+
+	app.GitCommand, err = commands.NewGitCommand(app.Log, app.OSCommand)
+	if err != nil {
+		return nil, err
+	}
+	app.Gui, err = gui.NewGui(app.Log, app.GitCommand, app.OSCommand, app.Tr, config.GetVersion())
+	if err != nil {
+		return nil, 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,497 @@
+package commands
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+	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.Logger
+	OSCommand *OSCommand
+	Worktree  *gogit.Worktree
+	Repo      *gogit.Repository
+}
+
+// NewGitCommand it runs git commands
+func NewGitCommand(log *logrus.Logger, osCommand *OSCommand) (*GitCommand, error) {
+	gitCommand := &GitCommand{
+		Log:       log,
+		OSCommand: osCommand,
+	}
+	return gitCommand, nil
+}
+
+// SetupGit sets git repo up
+func (c *GitCommand) SetupGit() {
+	c.verifyInGitRepo()
+	c.navigateToRepoRootDirectory()
+	c.setupWorktree()
+}
+
+// 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 := statusString[3:]
+		tracked := !includes([]string{"??", "A "}, change)
+		file := File{
+			Name:               filename,
+			DisplayString:      statusString,
+			HasStagedChanges:   !includes([]string{" ", "U", "?"}, stagedChange),
+			HasUnstagedChanges: unstagedChange != " ",
+			Tracked:            tracked,
+			Deleted:            unstagedChange == "D" || stagedChange == "D",
+			HasMergeConflicts:  change == "UU",
+		}
+		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() {
+	r, err := gogit.PlainOpen(".")
+	if err != nil {
+		panic(err)
+	}
+	c.Repo = r
+
+	w, err := r.Worktree()
+	if err != nil {
+		panic(err)
+	}
+	c.Worktree = w
+}
+
+// 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) error {
+	return c.OSCommand.RunCommand("git branch -d " + 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)
+	}
+	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) error {
+	return c.OSCommand.RunCommand("git push -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(file string) (string, error) {
+	return c.OSCommand.RunCommandWithOutput("cat " + file)
+}
+
+// StageFile stages a file
+func (c *GitCommand) StageFile(file string) error {
+	return c.OSCommand.RunCommand("git add " + c.OSCommand.Quote(file))
+}
+
+// UnStageFile unstages a file
+func (c *GitCommand) UnStageFile(file string, tracked bool) error {
+	var command string
+	if tracked {
+		command = "git reset HEAD "
+	} else {
+		command = "git rm --cached "
+	}
+	return c.OSCommand.RunCommand(command + file)
+}
+
+// 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.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, error) {
+	return c.OSCommand.PrepareSubProcess("git", "add", "--patch", filename)
+}
+
+// PrepareCommitSubProcess prepares a subprocess for `git commit`
+func (c *GitCommand) PrepareCommitSubProcess() (*exec.Cmd, error) {
+	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) {
+	if _, err := c.OSCommand.RunDirectCommand("echo '" + filename + "' >> .gitignore"); err != nil {
+		panic(err)
+	}
+}
+
+// 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 := file.Name
+	if file.HasStagedChanges && !file.HasUnstagedChanges {
+		cachedArg = "--cached"
+	} else {
+		// if the file is staged and has spaces in it, it comes pre-quoted
+		fileName = c.OSCommand.Quote(fileName)
+	}
+	deletedArg := ""
+	if file.Deleted {
+		deletedArg = "--"
+	}
+	trackedArg := ""
+	if !file.Tracked && !file.HasStagedChanges {
+		trackedArg = "--no-index /dev/null"
+	}
+	command := fmt.Sprintf("%s %s %s %s %s", "git diff --color ", cachedArg, deletedArg, 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
+// TODO: decide whether to give all of these the Git prefix
+type File struct {
+	Name               string
+	HasStagedChanges   bool
+	HasUnstagedChanges bool
+	Tracked            bool
+	Deleted            bool
+	HasMergeConflicts  bool
+	DisplayString      string
+}
+
+// Commit : A git commit
+type Commit struct {
+	Sha           string
+	Name          string
+	Pushed        bool
+	DisplayString string
+}
+
+// StashEntry : A git stash entry
+type StashEntry struct {
+	Index         int
+	Name          string
+	DisplayString string
+}
+
+// Conflict : A git conflict with a start middle and end corresponding to line
+// numbers in the file where the conflict bars appear
+type Conflict struct {
+	Start  int
+	Middle int
+	End    int
+}

pkg/commands/os.go

@@ -0,0 +1,167 @@
+package commands
+
+import (
+	"errors"
+	"os"
+	"os/exec"
+	"runtime"
+
+	"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.Logger
+	Platform *Platform
+}
+
+// NewOSCommand os command runner
+func NewOSCommand(log *logrus.Logger) (*OSCommand, error) {
+	osCommand := &OSCommand{
+		Log:      log,
+		Platform: getPlatform(),
+	}
+	return osCommand, nil
+}
+
+// RunCommandWithOutput wrapper around commands returning their output and error
+func (c *OSCommand) RunCommandWithOutput(command string) (string, error) {
+	c.Log.WithField("command", command).Info("RunCommand")
+	splitCmd := str.ToArgv(command)
+	c.Log.Info(splitCmd)
+	cmdOut, err := exec.Command(splitCmd[0], splitCmd[1:]...).CombinedOutput()
+	return sanitisedCommandOutput(cmdOut, err)
+}
+
+// RunCommand runs a command and just returns the error
+func (c *OSCommand) RunCommand(command string) error {
+	_, err := c.RunCommandWithOutput(command)
+	return err
+}
+
+// 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))
+
+	cmdOut, err := exec.
+		Command(c.Platform.shell, args...).
+		CombinedOutput()
+	return sanitisedCommandOutput(cmdOut, err)
+}
+
+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
+}
+
+func getPlatform() *Platform {
+	switch runtime.GOOS {
+	case "windows":
+		return &Platform{
+			os:           "windows",
+			shell:        "cmd",
+			shellArg:     "/c",
+			escapedQuote: "\\\"",
+		}
+	default:
+		return &Platform{
+			os:           runtime.GOOS,
+			shell:        "bash",
+			shellArg:     "-c",
+			escapedQuote: "\"",
+		}
+	}
+}
+
+// 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) (*exec.Cmd, error) {
+	cmdName, cmdTrail, err := c.GetOpenCommand()
+	if err != nil {
+		return nil, err
+	}
+	err = c.RunCommand(cmdName + " " + filename + cmdTrail) // TODO: test on linux
+	return nil, err
+}
+
+// EditFile opens a file in a subprocess using whatever editor is available,
+// falling back to core.editor, VISUAL, EDITOR, then vi
+func (c *OSCommand) EditFile(filename string) (*exec.Cmd, error) {
+	editor, _ := gitconfig.Global("core.editor")
+	if editor == "" {
+		editor = os.Getenv("VISUAL")
+	}
+	if editor == "" {
+		editor = os.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)
+}
+
+// PrepareSubProcess iniPrepareSubProcessrocess then tells the Gui to switch to it
+func (c *OSCommand) PrepareSubProcess(cmdName string, commandArgs ...string) (*exec.Cmd, error) {
+	subprocess := exec.Command(cmdName, commandArgs...)
+	return subprocess, nil
+}
+
+// Quote wraps a message in platform-specific quotation marks
+func (c *OSCommand) Quote(message string) string {
+	return c.Platform.escapedQuote + message + c.Platform.escapedQuote
+}

pkg/config/app_config.go

@@ -0,0 +1,45 @@
+package config
+
+// 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"`
+}
+
+// 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
+}
+
+// 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
+}

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.Logger
+	GitCommand *commands.GitCommand
+}
+
+// NewBranchListBuilder builds a new branch list builder
+func NewBranchListBuilder(log *logrus.Logger, 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/branches_panel.go

@@ -0,0 +1,156 @@
+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 {
+	checkedOutBranch := gui.State.Branches[0]
+	selectedBranch := gui.getSelectedBranch(v)
+	if checkedOutBranch.Name == selectedBranch.Name {
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("CantDeleteCheckOutBranch"))
+	}
+	message := gui.Tr.TemplateLocalize(
+		"DeleteBranchMessage",
+		Teml{
+			"selectedBranchName": selectedBranch.Name,
+		},
+	)
+	title := gui.Tr.SLocalize("DeleteBranch")
+	return gui.createConfirmationPanel(g, v, title, message, func(g *gocui.Gui, v *gocui.View) error {
+		if err := gui.GitCommand.DeleteBranch(selectedBranch.Name); 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"),
+		"← → ↑ ↓": 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 != errors.New(gui.Tr.SLocalize("NoCommitsThisBranch")) {
+			return err
+		}
+		return gui.renderString(g, "main", gui.Tr.SLocalize("NoCommitsThisBranch"))
+	}
+	commitText := gui.GitCommand.Show(commit.Sha)
+	return gui.renderString(g, "main", commitText)
+}
+
+func (gui *Gui) handleCommitSquashDown(g *gocui.Gui, v *gocui.View) error {
+	if 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,166 @@
+// 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 {
+				panic(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()
+	// only need to fit one line
+	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(g, "")
+	if confirmationView, err := g.SetView("confirmation", x0, y0, x1, y1, 0); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+
+		confirmationView.Editable = true
+		confirmationView.Title = title
+		gui.switchFocus(g, currentView, confirmationView)
+		return gui.setKeyBindings(g, handleConfirm, nil)
+	}
+	return 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)
+			}
+		}
+		x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(g, prompt)
+		if confirmationView, err := g.SetView("confirmation", x0, y0, x1, y1, 0); err != nil {
+			if err != gocui.ErrUnknownView {
+				return err
+			}
+			confirmationView.Title = title
+			confirmationView.FgColor = gocui.ColorWhite
+			gui.renderString(g, "confirmation", prompt)
+			gui.switchFocus(g, currentView, confirmationView)
+			return gui.setKeyBindings(g, handleConfirm, handleClose)
+		}
+		return nil
+	})
+	return nil
+}
+
+func (gui *Gui) handleNewline(g *gocui.Gui, v *gocui.View) error {
+	// resising ahead of time so that the top line doesn't get hidden to make
+	// room for the cursor on the second line
+	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(g, v.Buffer())
+	if _, err := g.SetView("confirmation", x0, y0, x1, y1+1, 0); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+	}
+
+	v.EditNewLine()
+	return nil
+}
+
+func (gui *Gui) setKeyBindings(g *gocui.Gui, handleConfirm, handleClose func(*gocui.Gui, *gocui.View) error) error {
+	actions := gui.Tr.TemplateLocalize(
+		"CloseConfirm",
+		Teml{
+			"keyBindClose":   "esc",
+			"keyBindConfirm": "enter",
+		},
+	)
+	gui.renderString(g, "options", actions)
+	if err := g.SetKeybinding("confirmation", gocui.KeyEnter, gocui.ModNone, gui.wrappedConfirmationFunction(handleConfirm)); err != nil {
+		return err
+	}
+	if err := g.SetKeybinding("confirmation", gocui.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 {
+	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,401 @@
+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) 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"))
+	}
+	sub, err := gui.GitCommand.AddPatch(file.Name)
+	if err != nil {
+		return err
+	}
+	gui.SubProcess = sub
+	return gui.Errors.ErrSubProcess
+}
+
+func (gui *Gui) getSelectedFile(g *gocui.Gui) (commands.File, error) {
+	if len(gui.State.Files) == 0 {
+		return commands.File{}, gui.Errors.ErrNoFiles
+	}
+	filesView, err := g.View("files")
+	if err != nil {
+		panic(err)
+	}
+	lineNumber := gui.getItemPosition(filesView)
+	return gui.State.Files[lineNumber], nil
+}
+
+func (gui *Gui) handleFileRemove(g *gocui.Gui, v *gocui.View) error {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		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 {
+			panic(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"))
+	}
+	gui.GitCommand.Ignore(file.Name)
+	return gui.refreshFiles(g)
+}
+
+func (gui *Gui) renderfilesOptions(g *gocui.Gui, file *commands.File) error {
+	optionsMap := map[string]string{
+		"← → ↑ ↓":   gui.Tr.SLocalize("navigate"),
+		"S":         gui.Tr.SLocalize("stashFiles"),
+		"c":         gui.Tr.SLocalize("CommitChanges"),
+		"o":         gui.Tr.SLocalize("open"),
+		"i":         gui.Tr.SLocalize("ignore"),
+		"d":         gui.Tr.SLocalize("delete"),
+		"space":     gui.Tr.SLocalize("toggleStaged"),
+		"R":         gui.Tr.SLocalize("refresh"),
+		"t":         gui.Tr.SLocalize("addPatch"),
+		"e":         gui.Tr.SLocalize("edit"),
+		"PgUp/PgDn": gui.Tr.SLocalize("scroll"),
+	}
+	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) error {
+	sub, err := gui.GitCommand.PrepareCommitSubProcess()
+	if err != nil {
+		return err
+	}
+	gui.SubProcess = sub
+	g.Update(func(g *gocui.Gui) error {
+		return gui.Errors.ErrSubProcess
+	})
+	return nil
+}
+
+func (gui *Gui) genericFileOpen(g *gocui.Gui, v *gocui.View, open func(string) (*exec.Cmd, error)) error {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		if err != gui.Errors.ErrNoFiles {
+			return err
+		}
+		return nil
+	}
+	sub, err := open(file.Name)
+	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 {
+	return gui.genericFileOpen(g, v, gui.OSCommand.EditFile)
+}
+
+func (gui *Gui) handleFileOpen(g *gocui.Gui, v *gocui.View) error {
+	return gui.genericFileOpen(g, v, gui.OSCommand.OpenFile)
+}
+
+func (gui *Gui) handleSublimeFileOpen(g *gocui.Gui, v *gocui.View) error {
+	return gui.genericFileOpen(g, v, gui.OSCommand.SublimeOpenFile)
+}
+
+func (gui *Gui) handleVsCodeFileOpen(g *gocui.Gui, v *gocui.View) error {
+	return gui.genericFileOpen(g, v, 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"))
+	}
+	cat, err := gui.GitCommand.CatFile(item.Name)
+	if err != nil {
+		panic(err)
+	}
+	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) pushFiles(g *gocui.Gui, v *gocui.View) error {
+	gui.createMessagePanel(g, v, "", gui.Tr.SLocalize("PushWait"))
+	go func() {
+		branchName := gui.State.Branches[0].Name
+		if err := gui.GitCommand.Push(branchName); err != nil {
+			gui.createErrorPanel(g, err.Error())
+		} else {
+			gui.closeConfirmationPrompt(g)
+			gui.refreshCommits(g)
+			gui.refreshStatus(g)
+		}
+	}()
+	return nil
+}
+
+func (gui *Gui) handleSwitchToMerge(g *gocui.Gui, v *gocui.View) error {
+	mergeView, err := g.View("main")
+	if err != nil {
+		return err
+	}
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		if err != gui.Errors.ErrNoFiles {
+			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)
+}

pkg/gui/gui.go

@@ -0,0 +1,360 @@
+package gui
+
+import (
+
+	// "io"
+	// "io/ioutil"
+
+	"errors"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"strings"
+	"time"
+
+	// "strings"
+
+	"github.com/Sirupsen/logrus"
+	"github.com/golang-collections/collections/stack"
+	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/commands"
+	"github.com/jesseduffield/lazygit/pkg/i18n"
+)
+
+// 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.Logger
+	GitCommand *commands.GitCommand
+	OSCommand  *commands.OSCommand
+	Version    string
+	SubProcess *exec.Cmd
+	State      guiState
+	Tr         *i18n.Localizer
+	Errors     SentinelErrors
+}
+
+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
+	Version           string
+}
+
+// NewGui builds a new gui handler
+func NewGui(log *logrus.Logger, gitCommand *commands.GitCommand, oSCommand *commands.OSCommand, tr *i18n.Localizer, version string) (*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,
+		Version:       version,
+	}
+
+	gui := &Gui{
+		Log:        log,
+		GitCommand: gitCommand,
+		OSCommand:  oSCommand,
+		Version:    version,
+		State:      initialState,
+		Tr:         tr,
+	}
+
+	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-1)
+	}
+	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+1)
+	}
+	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
+	g.SelFgColor = gocui.ColorWhite | gocui.AttrBold
+	width, height := g.Size()
+	leftSideWidth := width / 3
+	statusFilesBoundary := 2
+	filesBranchesBoundary := 2 * height / 5   // height - 20
+	commitsBranchesBoundary := 3 * height / 5 // height - 10
+	commitsStashBoundary := height - 5        // height - 5
+	minimumHeight := 16
+	minimumWidth := 10
+
+	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", -1, optionsTop, width-len(gui.Version)-2, optionsTop+2, 0); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		v.FgColor = gocui.ColorBlue
+		v.Frame = false
+	}
+
+	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, height, 0); err != nil {
+			if err != gocui.ErrUnknownView {
+				return err
+			}
+			g.SetViewOnBottom("commitMessage")
+			commitMessageView.Title = gui.Tr.SLocalize("CommitMessage")
+			commitMessageView.FgColor = gocui.ColorWhite
+			commitMessageView.Editable = true
+		}
+	}
+
+	if v, err := g.SetView("version", width-len(gui.Version)-1, optionsTop, width, optionsTop+2, 0); err != nil {
+		if err != gocui.ErrUnknownView {
+			return err
+		}
+		v.BgColor = gocui.ColorDefault
+		v.FgColor = gocui.ColorGreen
+		v.Frame = false
+		gui.renderString(g, "version", gui.Version)
+
+		// these are only called once
+		gui.handleFileSelect(g, filesView)
+		gui.refreshFiles(g)
+		gui.refreshBranches(g)
+		gui.refreshCommits(g)
+		gui.refreshStashEntries(g)
+		gui.nextView(g, nil)
+	}
+
+	gui.resizePopupPanels(g)
+
+	return nil
+}
+
+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 confirmationView, _ := g.View("confirmation"); confirmationView != nil {
+		content := gui.trimmedContent(confirmationView)
+		if strings.Contains(content, "...") {
+			staticContent := strings.Split(content, "...")[0] + "..."
+			gui.renderString(g, "confirmation", staticContent+" "+gui.loader())
+		}
+	}
+	return nil
+}
+
+func (gui *Gui) 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
+
+	g.FgColor = gocui.ColorDefault
+
+	gui.goEvery(g, time.Second*60, gui.fetch)
+	gui.goEvery(g, time.Second*10, gui.refreshFiles)
+	gui.goEvery(g, time.Millisecond*10, gui.updateLoader)
+
+	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 {
+	return gocui.ErrQuit
+}

pkg/gui/keybindings.go

@@ -0,0 +1,93 @@
+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.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: "files", Key: 'c', Modifier: gocui.ModNone, Handler: gui.handleCommitPress},
+		{ViewName: "files", Key: 'C', Modifier: gocui.ModNone, Handler: gui.handleCommitEditorPress},
+		{ViewName: "files", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: gui.handleFilePress},
+		{ViewName: "files", Key: 'd', Modifier: gocui.ModNone, Handler: gui.handleFileRemove},
+		{ViewName: "files", Key: 'm', Modifier: gocui.ModNone, Handler: gui.handleSwitchToMerge},
+		{ViewName: "files", Key: 'e', Modifier: gocui.ModNone, Handler: gui.handleFileEdit},
+		{ViewName: "files", Key: 'o', Modifier: gocui.ModNone, Handler: gui.handleFileOpen},
+		{ViewName: "files", Key: 's', Modifier: gocui.ModNone, Handler: gui.handleSublimeFileOpen},
+		{ViewName: "files", Key: 'v', Modifier: gocui.ModNone, Handler: gui.handleVsCodeFileOpen},
+		{ViewName: "files", Key: 'i', Modifier: gocui.ModNone, Handler: gui.handleIgnoreFile},
+		{ViewName: "files", Key: 'r', Modifier: gocui.ModNone, Handler: gui.handleRefreshFiles},
+		{ViewName: "files", Key: 'S', Modifier: gocui.ModNone, Handler: gui.handleStashSave},
+		{ViewName: "files", Key: 'a', Modifier: gocui.ModNone, Handler: gui.handleAbortMerge},
+		{ViewName: "files", Key: 't', Modifier: gocui.ModNone, Handler: gui.handleAddPatch},
+		{ViewName: "files", Key: 'D', Modifier: gocui.ModNone, Handler: gui.handleResetHard},
+		{ViewName: "main", Key: gocui.KeyEsc, Modifier: gocui.ModNone, Handler: gui.handleEscapeMerge},
+		{ViewName: "main", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: gui.handlePickHunk},
+		{ViewName: "main", Key: 'b', Modifier: gocui.ModNone, Handler: gui.handlePickBothHunks},
+		{ViewName: "main", Key: gocui.KeyArrowLeft, Modifier: gocui.ModNone, Handler: gui.handleSelectPrevConflict},
+		{ViewName: "main", Key: gocui.KeyArrowRight, Modifier: gocui.ModNone, Handler: gui.handleSelectNextConflict},
+		{ViewName: "main", Key: gocui.KeyArrowUp, Modifier: gocui.ModNone, Handler: gui.handleSelectTop},
+		{ViewName: "main", Key: gocui.KeyArrowDown, Modifier: gocui.ModNone, Handler: gui.handleSelectBottom},
+		{ViewName: "main", Key: 'h', Modifier: gocui.ModNone, Handler: gui.handleSelectPrevConflict},
+		{ViewName: "main", Key: 'l', Modifier: gocui.ModNone, Handler: gui.handleSelectNextConflict},
+		{ViewName: "main", Key: 'k', Modifier: gocui.ModNone, Handler: gui.handleSelectTop},
+		{ViewName: "main", Key: 'j', Modifier: gocui.ModNone, Handler: gui.handleSelectBottom},
+		{ViewName: "main", Key: 'z', Modifier: gocui.ModNone, Handler: gui.handlePopFileSnapshot},
+		{ViewName: "branches", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: gui.handleBranchPress},
+		{ViewName: "branches", Key: 'c', Modifier: gocui.ModNone, Handler: gui.handleCheckoutByName},
+		{ViewName: "branches", Key: 'F', Modifier: gocui.ModNone, Handler: gui.handleForceCheckout},
+		{ViewName: "branches", Key: 'n', Modifier: gocui.ModNone, Handler: gui.handleNewBranch},
+		{ViewName: "branches", Key: 'd', Modifier: gocui.ModNone, Handler: gui.handleDeleteBranch},
+		{ViewName: "branches", Key: 'm', Modifier: gocui.ModNone, Handler: gui.handleMerge},
+		{ViewName: "commits", Key: 's', Modifier: gocui.ModNone, Handler: gui.handleCommitSquashDown},
+		{ViewName: "commits", Key: 'r', Modifier: gocui.ModNone, Handler: gui.handleRenameCommit},
+		{ViewName: "commits", Key: 'g', Modifier: gocui.ModNone, Handler: gui.handleResetToCommit},
+		{ViewName: "commits", Key: 'f', Modifier: gocui.ModNone, Handler: gui.handleCommitFixup},
+		{ViewName: "stash", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: gui.handleStashApply},
+		{ViewName: "stash", Key: 'g', Modifier: gocui.ModNone, Handler: gui.handleStashPop},
+		{ViewName: "stash", Key: 'd', Modifier: gocui.ModNone, Handler: gui.handleStashDrop},
+		{ViewName: "commitMessage", Key: gocui.KeyEnter, Modifier: gocui.ModNone, Handler: gui.handleCommitConfirm},
+		{ViewName: "commitMessage", Key: gocui.KeyEsc, Modifier: gocui.ModNone, Handler: gui.handleCommitClose},
+		{ViewName: "commitMessage", Key: gocui.KeyTab, Modifier: gocui.ModNone, Handler: gui.handleNewlineCommitMessage},
+	}
+
+	// Would make these keybindings global but that interferes with editing
+	// input in the confirmation panel
+	for _, viewName := range []string{"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,260 @@
+// 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
+	}
+	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,42 @@
+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
+}

pkg/gui/view_helpers.go

@@ -0,0 +1,269 @@
+package gui
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+
+	"github.com/jesseduffield/gocui"
+)
+
+var cyclableViews = []string{"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 "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 {
+		panic(err)
+	}
+	return gui.switchFocus(g, v, previousView)
+}
+
+// pass in oldView = nil if you don't want to be able to return to your old view
+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()
+		fmt.Fprint(v, s)
+		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))
+}
+
+func (gui *Gui) loader() string {
+	characters := "|/-\\"
+	now := time.Now()
+	nanos := now.UnixNano()
+	index := nanos / 50000000 % int64(len(characters))
+	return characters[index : index+1]
+}
+
+// TODO: refactor properly
+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,291 @@
+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) {
+
+	// add the translations
+	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:    "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 {{.selectedBranchName}} branch 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:    "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,299 @@
+/*
+
+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) {
+
+	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:    "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:    "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 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:    "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",
+		},
+	)
+}

pkg/i18n/i18n.go

@@ -0,0 +1,84 @@
+package i18n
+
+import (
+	"github.com/Sirupsen/logrus"
+	"github.com/cloudfoundry/jibber_jabber"
+	"github.com/nicksnyder/go-i18n/v2/i18n"
+	"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.Logger
+}
+
+// NewLocalizer creates a new Localizer
+func NewLocalizer(log *logrus.Logger) (*Localizer, error) {
+
+	// detect the user's language
+	userLang, err := jibber_jabber.DetectLanguage()
+	if err != nil {
+		return nil, err
+	}
+	log.Info("language: " + userLang)
+
+	// create a i18n bundle that can be used to add translations and other things
+	i18nBundle := &i18n.Bundle{DefaultLanguage: language.English}
+
+	addBundles(i18nBundle)
+
+	// return the new localizer that can be used to translate text
+	i18nLocalizer := i18n.NewLocalizer(i18nBundle, userLang)
+
+	localizer := &Localizer{
+		i18nLocalizer: i18nLocalizer,
+		language:      userLang,
+		Log:           log,
+	}
+
+	return localizer, nil
+}
+
+// Localize handels the translations
+// 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(i18nBundle *i18n.Bundle) {
+	addDutch(i18nBundle)
+	addEnglish(i18nBundle)
+}

pkg/utils/utils.go

@@ -0,0 +1,65 @@
+package utils
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"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
+}

scripts/push_new_patch.go

@@ -0,0 +1,63 @@
+// call from project root with
+// go run bin/push_new_patch.go
+
+// goreleaser expects a $GITHUB_TOKEN env variable to be defined
+// in order to push the release got github
+
+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+func main() {
+
+	version, err := ioutil.ReadFile("VERSION")
+	if err != nil {
+		log.Panicln(err.Error())
+	}
+	stringVersion := string(version)
+	fmt.Println("VERSION was " + stringVersion)
+
+	runCommand("git", "pull")
+
+	splitVersion := strings.Split(stringVersion, ".")
+	patch := splitVersion[len(splitVersion)-1]
+	newPatch, err := strconv.Atoi(patch)
+	splitVersion[len(splitVersion)-1] = strconv.FormatInt(int64(newPatch)+1, 10)
+	newVersion := strings.Join(splitVersion, ".")
+
+	err = ioutil.WriteFile("VERSION", []byte(newVersion), 0644)
+	if err != nil {
+		log.Panicln(err.Error())
+	}
+
+	runCommand("git", "add", "VERSION")
+	runCommand("git", "commit", "-m", "bump version to "+newVersion, "--", "VERSION")
+	runCommand("git", "push")
+	runCommand("git", "tag", newVersion)
+	runCommand("git", "push", "origin", newVersion)
+	runCommand("goreleaser", "--rm-dist")
+	runCommand("rm", "-rf", "dist")
+}
+
+func runCommand(args ...string) {
+	fmt.Println(strings.Join(args, " "))
+	cmd := exec.Command(args[0], args[1:]...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	err := cmd.Start()
+	if err != nil {
+		panic(err.Error())
+	}
+	err = cmd.Wait()
+	if err != nil {
+		panic(err.Error())
+	}
+}

test/repos/case_insensitive_checkouts.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -ex; rm -rf repo; mkdir repo; cd repo
+
+git init
+
+touch foo
+git add foo
+git commit -m "init"
+git branch -a
+git branch test
+git branch TEST
+git checkout TEST
+git checkout TeST
+git checkout TesT
+git checkout TEsT
+git branch -a

test/repos/extras/pre-commit

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+echo "test1"
+sleep 1
+echo "test2"
+sleep 1
+echo "test3"

test/repos/gpg.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -ex; rm -rf repo; mkdir repo; cd repo
+
+git init
+
+git config gpg.program $(which gpg)
+git config user.signingkey E304229F # test key
+git config commit.gpgsign true
+git config credential.helper store
+git config credential.helper cache 1
+
+touch foo
+git add foo
+
+touch bar
+git add bar

test/repos/lots_of_commits.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -ex; rm -rf repo; mkdir repo; cd repo
+
+git init
+
+i=2
+end=100
+while [ $i -le $end ]; do
+    echo "file${i}" > file${i}
+    git add file${i}
+    git commit -m file${i}
+
+    i=$(($i+1))
+done
+
+echo "unstaged change" > file100

test/repos/merge_conflict.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+set -ex; rm -rf repo; mkdir repo; cd repo
+
+git init
+
+function add_spacing {
+  for i in {1..60}
+  do
+    echo "..." >> $1
+  done
+}
+
+echo "Here is a story that has been told throuhg the ages" >> file1
+
+git add file1
+git commit -m "first commit"
+
+git checkout -b develop
+
+echo "once upon a time there was a dog" >> file1
+add_spacing file1
+echo "once upon a time there was another dog" >> file1
+git add file1
+git commit -m "first commit on develop"
+
+git checkout master
+
+echo "once upon a time there was a cat" >> file1
+add_spacing file1
+echo "once upon a time there was another cat" >> file1
+git add file1
+git commit -m "first commit on develop"
+
+git merge develop # should have a merge conflict here

test/repos/pre_commit_hook.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+set -ex; rm -rf repo; mkdir repo; cd repo
+
+git init
+cp ../extras/pre-commit .git/hooks/pre-commit
+chmod +x .git/hooks/pre-commit
+
+echo "file" > file
+git add file

test/repos/unicode_characters.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+set -ex; rm -rf repo; mkdir repo; cd repo
+
+git init
+
+# Add some ansi, unicode, zero width joiner caracters
+cat <<EOT >> charstest.txt
+ANSI      Œ	(U+0152	&OElig;	Latin capital ligature OE	Latin Extended-A)
+          ¥	(0xA5	U+00A5	&yen;	yes sign)
+          ƒ	(0x83	U+0192	&fnof;	Latin small letter f with hook)
+ZWJ       https://en.wikipedia.org/wiki/Zero-width_joiner / https://unicode.org/Public/emoji/4.0/emoji-zwj-sequences.txt 👶(👨‍👦)
+UNICODE   ☆ 🤓 え 术
+EOT
+git add charstest.txt
+git commit -m "Test chars Œ¥ƒ👶👨‍👦☆ 🤓 え 术 commit"
+echo "我喜歡編碼" >> charstest.txt
+echo "நான் குறியீடு விரும்புகிறேன்" >> charstest.txt
+git add charstest.txt
+git commit -m "Test chars 我喜歡編碼 நான் குறியீடு விரும்புகிறேன் commit"
+

test/shell_script_input_prompt.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+# For testing subprocesses that require input
+# Ask the user for login details
+read -p 'Username: ' user
+read -sp 'Password: ' pass
+echo
+echo Hello $user