support clicking through to commit files panel

jks I'm that that close to the edge... but I am getting there haha

.circleci/config.yml

@@ -0,0 +1,62 @@
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/golang:1.13
+    environment:
+      GO111MODULE: "on"
+    working_directory: /go/src/github.com/jesseduffield/lazygit
+    steps:
+      - checkout
+      - run:
+          name: Run gofmt -s
+          command: |
+            if [ $(find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;|wc -l) -gt 0 ]; then
+             find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;
+             exit 1;
+            fi
+      - restore_cache:
+          keys:
+            - pkg-cache-{{ checksum "go.sum" }}-v5
+      - run:
+          name: Run tests
+          command: |
+            ./test.sh
+      - run:
+          name: Push on codecov result
+          command: |
+            bash <(curl -s https://codecov.io/bash)
+      - run:
+          name: Compile project on every platform
+          command: |
+            go get github.com/mitchellh/gox
+            GOFLAGS=-mod=vendor gox -parallel 10 -os "linux freebsd netbsd windows" -osarch "darwin/i386 darwin/amd64"
+      - save_cache:
+          key: pkg-cache-{{ checksum "go.sum" }}-v5
+          paths:
+            - ~/.cache/go-build
+
+  release:
+    docker:
+      - image: circleci/golang:1.13
+    working_directory: /go/src/github.com/jesseduffield/lazygit
+    steps:
+      - checkout
+      - run:
+          name: Run gorelease
+          command: |
+            curl -sL https://git.io/goreleaser | bash
+
+workflows:
+  version: 2
+  build:
+    jobs:
+      - build
+  release:
+    jobs:
+      - release:
+          filters:
+            tags:
+              only: /v[0-9]+(\.[0-9]+)*/
+            branches:
+              ignore: /.*/

.github/FUNDING.yml

@@ -1,4 +1,5 @@
 # These are supported funding model platforms
 
 github: [jesseduffield]
+ko_fi: jesseduffield
 custom: ['https://donorbox.org/lazygit']

.github/dependabot.yml

@@ -1,9 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: "gomod"
-    directory: "/"
-    schedule:
-      interval: "weekly"
-    allowed_updates:
-      - match:
-          update_type: "security"

.github/workflows/automerge.yml

@@ -1,28 +0,0 @@
-name: automerge
-on:
-  pull_request:
-    types:
-      - labeled
-      - unlabeled
-      - synchronize
-      - opened
-      - edited
-      - ready_for_review
-      - reopened
-      - unlocked
-  pull_request_review:
-    types:
-      - submitted
-  check_suite:
-    types:
-      - completed
-  status: {}
-jobs:
-  automerge:
-    runs-on: ubuntu-latest
-    steps:
-      - name: automerge
-        uses: "pascalgn/automerge-action@135f0bdb927d9807b5446f7ca9ecc2c51de03c4a"
-        env:
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
-          MERGE_METHOD: rebase

.github/workflows/cd.yml

@@ -1,31 +0,0 @@
-name: Continuous Delivery
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  goreleaser:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-      - name: Unshallow repo
-        run: git fetch --prune --unshallow
-      - name: Setup Go
-        uses: actions/setup-go@v1
-        with:
-          go-version: 1.16.x
-      - name: Run goreleaser
-        uses: goreleaser/goreleaser-action@v1
-        env:
-          GITHUB_TOKEN: ${{secrets.GITHUB_API_TOKEN}}
-  homebrew:
-    runs-on: macos-latest
-    steps:
-      - name: Bump Homebrew formula
-        uses: dawidd6/action-homebrew-bump-formula@v3
-        with:
-          token: ${{secrets.GITHUB_API_TOKEN}}
-          formula: lazygit

.github/workflows/ci.yml

@@ -1,65 +0,0 @@
-name: Continuous Integration
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-
-jobs:
-  ci:
-    strategy:
-      fail-fast: false
-      matrix:
-        os:
-          - ubuntu-latest
-          - windows-latest
-    name: ci - ${{matrix.os}}
-    runs-on: ${{matrix.os}}
-    env:
-      GOFLAGS: -mod=vendor
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-      - name: Setup Go
-        uses: actions/setup-go@v1
-        with:
-          go-version: 1.16.x
-      - name: Cache build
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/go-build
-          key: ${{runner.os}}-go-${{hashFiles('**/go.sum')}}-test
-          restore-keys: |
-            ${{runner.os}}-go-
-      - name: Test code
-        run: |
-          bash ./test.sh
-  build:
-    runs-on: ubuntu-latest
-    env:
-      GOFLAGS: -mod=vendor
-      GOARCH: amd64
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-      - name: Setup Go
-        uses: actions/setup-go@v1
-        with:
-          go-version: 1.16.x
-      - name: Cache build
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/go-build
-          key: ${{runner.os}}-go-${{hashFiles('**/go.sum')}}-build
-          restore-keys: |
-            ${{runner.os}}-go-
-      - name: Build linux binary
-        run: |
-          GOOS=linux go build
-      - name: Build windows binary
-        run: |
-          GOOS=windows go build
-      - name: Build darwin binary
-        run: |
-          GOOS=darwin go build

.github/workflows/lint.yml

@@ -1,20 +0,0 @@
-name: Lint
-
-on: pull_request
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Lint
-        uses: golangci/golangci-lint-action@v2
-        with:
-          version: latest
-      - name: Format code
-        run: |
-          if [ $(find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;|wc -l) -gt 0 ]; then
-           find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;
-           exit 1
-          fi

.gitignore

@@ -25,12 +25,4 @@ lazygit
 !.circleci/
 !.github/
 
-test/git_server/data
-test/integration/*/actual/
-test/integration/*/actual_remote/
-test/integration/*/used_config/
-# these sample hooks waste too much space
-test/integration/*/expected/.git_keep/hooks/
-test/integration/*/expected_remote/hooks/
-!.git_keep/
-lazygit.exe
+test/git_server/data

.goreleaser.yml

@@ -17,16 +17,16 @@ builds:
     ldflags:
       - -s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}} -X main.buildSource=binaryRelease
 
-archives:
-  - replacements:
-      darwin: Darwin
-      linux: Linux
-      windows: Windows
-      386: 32-bit
-      amd64: x86_64
-    format_overrides:
-      - goos: windows
-        format: zip
+archive:
+  replacements:
+    darwin: Darwin
+    linux: Linux
+    windows: Windows
+    386: 32-bit
+    amd64: x86_64
+  format_overrides:
+    - goos: windows
+      format: zip
 checksum:
   name_template: 'checksums.txt'
 snapshot:
@@ -38,26 +38,27 @@ changelog:
       - '^docs:'
       - '^test:'
       - '^bump'
-brews:
-  -
-    # Repository to push the tap to.
-    tap:
-      owner: jesseduffield
-      name: homebrew-lazygit
+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 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'
+  # 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
+  # # 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

CONTRIBUTING.md

@@ -1,13 +1,14 @@
 # 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.
+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:
 
@@ -20,33 +21,15 @@ welcome your pull requests:
 7. 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!
-
-## Updating Gocui
-
-Sometimes you will need to make a change in the gocui fork (https://github.com/jesseduffield/gocui). Gocui is the package responsible for rending windows and handling user input. Here's the typical process to follow:
-
-1. Make the changes in gocui inside the vendor directory so it's easy to test against lazygit
-2. Copy the changes over to the actual gocui repo (clone it if you haven't already, and use the `awesome` branch, not `master`)
-3. Raise a PR on the gocui repo with your changes
-4. After that PR is merged, make a PR in lazygit bumping the gocui version. You can bump the version by running the following at the lazygit repo root:
-
-```sh
-./bump_gocui.sh
-```
-
-5. Raise a PR in lazygit with those changes

Dockerfile

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

README.md

@@ -1,91 +1,41 @@
-<p align="center">
-  <img src="https://i.imgur.com/oYB7Cj8.png">
-</p>
+# lazygit [![CircleCI](https://circleci.com/gh/jesseduffield/lazygit.svg?style=svg)](https://circleci.com/gh/jesseduffield/lazygit) [![codecov](https://codecov.io/gh/jesseduffield/lazygit/branch/master/graph/badge.svg)](https://codecov.io/gh/jesseduffield/lazygit) [![Go Report Card](https://goreportcard.com/badge/github.com/jesseduffield/lazygit)](https://goreportcard.com/report/github.com/jesseduffield/lazygit) [![GolangCI](https://golangci.com/badges/github.com/jesseduffield/lazygit.svg)](https://golangci.com) [![GoDoc](https://godoc.org/github.com/jesseduffield/lazygit?status.svg)](http://godoc.org/github.com/jesseduffield/lazygit) [![GitHub tag](https://img.shields.io/github/tag/jesseduffield/lazygit.svg)]()
 
-![CI](https://github.com/jesseduffield/lazygit/workflows/Continuous%20Integration/badge.svg) [![Go Report Card](https://goreportcard.com/badge/github.com/jesseduffield/lazygit)](https://goreportcard.com/report/github.com/jesseduffield/lazygit) [![GolangCI](https://golangci.com/badges/github.com/jesseduffield/lazygit.svg)](https://golangci.com) [![GoDoc](https://godoc.org/github.com/jesseduffield/lazygit?status.svg)](http://godoc.org/github.com/jesseduffield/lazygit) [![GitHub tag](https://img.shields.io/github/tag/jesseduffield/lazygit.svg)]() [![TODOs](https://badgen.net/https/api.tickgit.com/badgen/github.com/jesseduffield/lazygit)](https://www.tickgit.com/browse?repo=github.com/jesseduffield/lazygit)
+A simple terminal UI for git commands, written in Go with the [gocui](https://github.com/jroimartin/gocui 'gocui') library.
 
-
-
-
-A simple terminal UI for git commands, written in Go with the [gocui](https://github.com/jroimartin/gocui "gocui") library.
-
-Rant time: You've heard it before, git is _powerful_, but what good is that power when everything is so damn hard to do? Interactive rebasing requires you to edit a goddamn TODO file in your editor? *Are you kidding me?* To stage part of a file you need to use a command line program to step through each hunk and if a hunk can't be split down any further but contains code you don't want to stage, you have to edit an arcane patch file _by hand_? *Are you KIDDING me?!* Sometimes you get asked to stash your changes when switching branches only to realise that after you switch and unstash that there weren't even any conflicts and it would have been fine to just checkout the branch directly? *YOU HAVE GOT TO BE KIDDING ME!*
+Rant time: You've heard it before, git is _powerful_, but what good is that power when everything is so damn hard to do? Interactive rebasing requires you to edit a goddamn TODO file in your editor? *Are you kidding me?* To stage part of a file you need to use a command line program stepping through each hunk and if a hunk can't be split down any further but contains code you don't want to stage, bad luck? *Are you KIDDING me?!* Sometimes you get asked to stash your changes when switching branches only to realise that after you switch and unstash that there weren't even any conflicts and it would have been fine to just checkout the branch directly? *YOU HAVE GOT TO BE KIDDING ME!* 
 
 If you're a mere mortal like me and you're tired of hearing how powerful git is when in your daily life it's a powerful pain in your ass, lazygit might be for you.
 
-![Gif](../assets/staging.gif)
+![Gif](/docs/resources/lazygit-example.gif)
 
-## Table of contents
-
-- [Installation](#installation)
-  - [Binary releases](#binary-releases)
-  - [Homebrew](#homebrew)
-  - [MacPorts](#macports)
-  - [Ubuntu](#ubuntu)
-  - [Void Linux](#void-linux)
-  - [Scoop (Windows)](#scoop-windows)
-  - [Arch Linux](#arch-linux)
-  - [Fedora and CentOS 7](#fedora-and-centos-7)
-  - [Solus Linux](#solus-linux)
-  - [Funtoo Linux](#funtoo-linux)
-  - [FreeBSD](#freebsd)
-  - [Conda](#conda)
-  - [Go](#go)
-  - [Chocolatey (Windows)](#chocolatey-windows)
-  - [Manual](#manual)
-- [Usage](#usage)
-  - [Keybindings](#keybindings)
-  - [Changing directory on exit](#changing-directory-on-exit)
-  - [Undo/Redo](#undoredo)
-- [Configuration](#configuration)
-  - [Custom pagers](#configuration)
-  - [Custom commands](#configuration)
-- [Tutorials](#tutorials)
-- [Cool Features](#cool-features)
-- [Contributing](#contributing)
-- [Donate](#donate)
-- [Alternatives](#alternatives)
-
-Github Sponsors is matching all donations dollar-for-dollar for 12 months so if you're feeling generous consider [sponsoring me](https://github.com/sponsors/jesseduffield)
+- [Installation](https://github.com/jesseduffield/lazygit#installation)
+- [Usage](https://github.com/jesseduffield/lazygit#usage),
+  [Keybindings](/docs/keybindings)
+- [Cool Features](https://github.com/jesseduffield/lazygit#cool-features)
+- [Contributing](https://github.com/jesseduffield/lazygit#contributing)
+- [Video Tutorial](https://youtu.be/VDXvbHZYeKY)
+- [Rebase Magic Video Tutorial](https://youtu.be/4XaToVut_hs)
+- [Twitch Stream](https://www.twitch.tv/jesseduffield)
 
 [<img src="https://i.imgur.com/sVEktDn.png">](https://youtu.be/CPLdltN7wgE)
 
+Github Sponsors is matching all donations dollar-for-dollar for 12 months so if you're feeling generous consider [sponsoring me](https://github.com/sponsors/jesseduffield)
+
 ## Installation
 
-### Binary Releases
-
-For Windows, Mac OS(10.12+) or Linux, you can download a binary release [here](../../releases).
-
 ### Homebrew
 
-Normally the lazygit formula can be found in the Homebrew core but we suggest you tap our formula to get the frequently updated one. It works with Linux, too.
-
-Tap:
-
-```
-brew install jesseduffield/lazygit/lazygit
-```
-
-Core:
-
-```
+```sh
 brew install lazygit
 ```
 
-### MacPorts
-
-Latest version built from github releases.
-Tap:
-
-```
-sudo port install lazygit
-```
-
 ### Ubuntu
 
-**Deprecated**: will no longer receive updates.
+Packages for Ubuntu 16.04, 18.04 and 18.10 are available via [Launchpad PPA](https://launchpad.net/~lazygit-team).
 
-Packages for Ubuntu 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
@@ -93,6 +43,16 @@ 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
@@ -103,69 +63,31 @@ They follow upstream latest releases
 sudo xbps-install -S lazygit
 ```
 
-### Scoop (Windows)
-
-You can install `lazygit` using [scoop](https://scoop.sh/). It's in the `extras` bucket:
-
-```sh
-# Add the extras bucket
-scoop bucket add extras
-
-# Install lazygit
-scoop install lazygit
-```
-
 ### Arch Linux
 
-Packages for Arch Linux are available via pacman and AUR (Arch User Repository).
+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: `sudo pacman -S lazygit`
-- Development: <https://aur.archlinux.org/packages/lazygit-git/>
+- 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>
-
-### Fedora and CentOS 7
-
-Packages for Fedora and CentOS 7 are available via [Copr](https://copr.fedorainfracloud.org/coprs/atim/lazygit/) (Cool Other Package Repo).
-
-```sh
-sudo dnf copr enable atim/lazygit -y
-sudo dnf install lazygit
-```
-
-### Solus Linux
-
-```sh
-sudo eopkg install lazygit
-```
-
-### Funtoo Linux
-
-Funtoo Linux has an autogenerated lazygit package in [dev-kit](https://github.com/funtoo/dev-kit/tree/1.4-release/dev-vcs/lazygit):
-
-```sh
-sudo emerge dev-vcs/lazygit
-```
-
-### FreeBSD
-
-```sh
-pkg install lazygit
-```
-
+https://wiki.archlinux.org/index.php/Arch_User_Repository
 
 ### Conda
 
-Released versions are available for different platforms, see <https://anaconda.org/conda-forge/lazygit>
+Released versions are available for different platforms, see https://anaconda.org/conda-forge/lazygit
 
 ```sh
 conda install -c conda-forge lazygit
 ```
 
+### Binary Release (Windows/Linux/OSX)
+
+You can download a binary release [here](https://github.com/jesseduffield/lazygit/releases).
+
 ### Go
 
 ```sh
@@ -178,86 +100,16 @@ 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).
 
-### Chocolatey (Windows)
-
-You can install `lazygit` using [Chocolatey](https://chocolatey.org/):
-
-```sh
-choco install lazygit
-```
-
-### Manual
-
-You'll need to [install Go](https://golang.org/doc/install)
-
-```
-git clone https://github.com/jesseduffield/lazygit.git
-cd lazygit
-go install
-```
-
-You can also use `go run main.go` to compile and run in one go (pun definitely intended)
-
 ## Usage
 
-Call `lazygit` in your terminal inside a git repository.
-
-```sh
-$ lazygit
-```
-
-If you want, you can
+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).
 
-### Keybindings
-
-You can check out the list of keybindings [here](/docs/keybindings).
-
-### Changing Directory On Exit
-
-If you change repos in lazygit and want your shell to change directory into that repo on exiting lazygit, add this to your `~/.zshrc` (or other rc file):
-
-```
-lg()
-{
-    export LAZYGIT_NEW_DIR_FILE=~/.lazygit/newdir
-
-    lazygit "$@"
-
-    if [ -f $LAZYGIT_NEW_DIR_FILE ]; then
-            cd "$(cat $LAZYGIT_NEW_DIR_FILE)"
-            rm -f $LAZYGIT_NEW_DIR_FILE > /dev/null
-    fi
-}
-```
-
-Then `source ~/.zshrc` and from now on when you call `lg` and exit you'll switch directories to whatever you were in inside lazyigt. To override this behaviour you can exit using `shift+Q` rather than just `q`.
-
-### Undo/Redo
-
-See the [docs](/docs/Undoing.md)
-
-## Configuration
-
-Check out the [configuration docs](docs/Config.md).
-
-### Custom Pagers
-
-See the [docs](docs/Custom_Pagers.md)
-
-### Custom Commands
-
-If lazygit is missing a feature, there's a good chance you can implement it yourself with a custom command!
-
-See the [docs](docs/Custom_Command_Keybindings.md)
-
-## Tutorials
-
-- [Video Tutorial](https://youtu.be/VDXvbHZYeKY)
-- [Rebase Magic Video Tutorial](https://youtu.be/4XaToVut_hs)
-- [Twitch Stream](https://www.twitch.tv/jesseduffield)
-
+- Basic video tutorial [here](https://youtu.be/VDXvbHZYeKY).
+- Rebase Magic tutorial [here](https://youtu.be/4XaToVut_hs)
+- List of keybindings
+  [here](/docs/keybindings).
 
 ## Cool features
 
@@ -266,34 +118,33 @@ See the [docs](docs/Custom_Command_Keybindings.md)
 - Easily check out recent branches
 - Scroll through logs/diffs of branches/commits/stash
 - Quick pushing/pulling
-- Squash down and reword commits
+- Squash down and rename commits
 
 ### Resolving merge conflicts
 
-![Gif](../assets/resolving-merge-conflicts.gif)
+![Gif](/docs/resources/resolving-merge-conflicts.gif)
 
 ### Interactive Rebasing
 
-![Interactive Rebasing](../assets/rebase.gif)
+![Interactive Rebasing](/docs/resources/interactive-rebase.png)
 
 ## 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](../assets/slack_rgb.png)](https://join.slack.com/t/lazygit/shared_invite/zt-5bo2clzo-hB8ZTVN5dWUCqj5QFiQVLA)
-
-### Debugging Locally
-Run `lazygit --debug` in one terminal tab and `lazygit --logs` in another to view the program and its log output side by side
+[![Slack](/docs/resources/slack_rgb.png)](https://join.slack.com/t/lazygit/shared_invite/enQtNDE3MjIwNTYyMDA0LTM3Yjk3NzdiYzhhNTA1YjM4Y2M4MWNmNDBkOTI0YTE4YjQ1ZmI2YWRhZTgwNjg2YzhhYjg3NDBlMmQyMTI5N2M)
 
 ## Donate
 
 If you would like to support the development of lazygit, consider [sponsoring me](https://github.com/sponsors/jesseduffield) (github is matching all donations dollar-for-dollar for 12 months)
 
-## FAQ
+## Work in progress
 
-### I'm struggling to see the selected line
-see [here](https://github.com/jesseduffield/lazygit/blob/master/docs/Config.md#struggling-to-see-selected-line)
+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
 
@@ -305,5 +156,4 @@ If you want to see what I (Jesse) am up to in terms of development, follow me on
 
 If you find that lazygit doesn't quite satisfy your requirements, these may be a better fit:
 
-- [GitUI](https://github.com/Extrawurst/gitui)
 - [tig](https://github.com/jonas/tig)

bump_gocui.sh

@@ -1,5 +0,0 @@
-# Go's proxy servers are not very up-to-date so that's why we use `GOPROXY=direct`
-# We specify the `awesome` branch to avoid the default behaviour of looking for a semver tag.
-GOPROXY=direct go get -u github.com/jesseduffield/gocui@awesome && go mod vendor && go mod tidy
-
-# Note to self if you ever want to fork a repo be sure to use this same approach: it's important to use the branch name (e.g. master)

docs/Config.md

@@ -1,315 +1,75 @@
-# User Config
+# User Config:
 
-Default path for the config file:
-
-- Linux: `~/.config/lazygit/config.yml`
-- MacOS: `~/Library/Application Support/lazygit/config.yml`
-- Windows: `%APPDATA%\lazygit\config.yml`
-
-For old installations (slightly embarrassing: I didn't realise at the time that you didn't need to supply a vendor name to the path so I just used my name):
-
-- Linux: `~/.config/jesseduffield/lazygit/config.yml`
-- MacOS: `~/Library/Application Support/jesseduffield/lazygit/config.yml`
-- Windows: `%APPDATA%\jesseduffield\lazygit\config.yml`
-
-## Default
+## Default:
 
 ```yaml
-gui:
-  # stuff relating to the UI
-  scrollHeight: 2 # how many lines you scroll by
-  scrollPastBottom: true # enable scrolling past the bottom
-  sidePanelWidth: 0.3333 # number from 0 to 1
-  expandFocusedSidePanel: false
-  mainPanelSplitMode: 'flexible' # one of 'horizontal' | 'flexible' | 'vertical'
-  language: 'auto' # one of 'auto' | 'en' | 'zh' | 'pl' | 'nl'
-  theme:
-    lightTheme: false # For terminals with a light background
-    activeBorderColor:
-      - white
-      - bold
-    inactiveBorderColor:
-      - green
-    optionsTextColor:
-      - blue
-    selectedLineBgColor:
-      - default
-    selectedRangeBgColor:
-      - blue
-    cherryPickedCommitBgColor:
-      - blue
-    cherryPickedCommitFgColor:
-      - cyan
-  commitLength:
-    show: true
-  mouseEvents: true
-  skipUnstageLineWarning: false
-  skipStashWarning: true
-  showFileTree: true # for rendering changes files in a tree format
-  showListFooter: true # for seeing the '5 of 20' message in list panels
-  showRandomTip: true
-  showCommandLog: true
-  commandLogSize: 8
-git:
-  paging:
-    colorArg: always
-    useConfig: false
-  commit:
-    signOff: false
-  merging:
-    # only applicable to unix users
-    manualCommit: false
-    # extra args passed to `git merge`, e.g. --no-ff
-    args: ''
-  log:
-    # one of date-order, author-date-order, topo-order.
-    # topo-order makes it easier to read the git log graph, but commits may not
-    # appear chronologically. See https://git-scm.com/docs/git-log#_commit_ordering
-    order: 'topo-order'
-    # one of always, never, when-maximised
-    # this determines whether the git graph is rendered in the commits panel
-    showGraph: 'when-maximised'
-  skipHookPrefix: WIP
-  autoFetch: true
-  branchLogCmd: 'git log --graph --color=always --abbrev-commit --decorate --date=relative --pretty=medium {{branchName}} --'
-  allBranchesLogCmd: 'git log --graph --all --color=always --abbrev-commit --decorate --date=relative  --pretty=medium'
-  overrideGpg: false # prevents lazygit from spawning a separate process when using GPG
-  disableForcePushing: false
-  parseEmoji: false
-  diffContextSize: 3 # how many lines of context are shown around a change in diffs
-os:
-  editCommand: '' # see 'Configuring File Editing' section
-  editCommandTemplate: '{{editor}} {{filename}}'
-  openCommand: ''
-refresher:
-  refreshInterval: 10 # file/submodule refresh interval in seconds
-  fetchInterval: 60 # re-fetch interval in seconds
-update:
-  method: prompt # can be: prompt | background | never
-  days: 14 # how often an update is checked for
-reporting: 'undetermined' # one of: 'on' | 'off' | 'undetermined'
-confirmOnQuit: false
-# determines whether hitting 'esc' will quit the application when there is nothing to cancel/close
-quitOnTopLevelReturn: false
-disableStartupPopups: false
-notARepository: 'prompt' # one of: 'prompt' | 'create' | 'skip'
-keybinding:
-  universal:
-    quit: 'q'
-    quit-alt1: '<c-c>' # alternative/alias of quit
-    return: '<esc>' # return to previous menu, will quit if there's nowhere to return
-    quitWithoutChangingDirectory: 'Q'
-    togglePanel: '<tab>' # goto the next panel
-    prevItem: '<up>' # go one line up
-    nextItem: '<down>' # go one line down
-    prevItem-alt: 'k' # go one line up
-    nextItem-alt: 'j' # go one line down
-    prevPage: ',' # go to next page in list
-    nextPage: '.' # go to previous page in list
-    gotoTop: '<' # go to top of list
-    gotoBottom: '>' # go to bottom of list
-    scrollLeft: 'H' # scroll left within list view
-    scrollRight: 'L' # scroll right within list view
-    prevBlock: '<left>' # goto the previous block / panel
-    nextBlock: '<right>' # goto the next block / panel
-    prevBlock-alt: 'h' # goto the previous block / panel
-    nextBlock-alt: 'l' # goto the next block / panel
-    jumpToBlock: ['1', '2', '3', '4', '5'] # goto the Nth block / panel
-    nextMatch: 'n'
-    prevMatch: 'N'
-    optionMenu: 'x' # show help menu
-    optionMenu-alt1: '?' # show help menu
-    select: '<space>'
-    goInto: '<enter>'
-    openRecentRepos: '<c-r>'
-    confirm: '<enter>'
-    confirm-alt1: 'y'
-    remove: 'd'
-    new: 'n'
-    edit: 'e'
-    openFile: 'o'
-    scrollUpMain: '<pgup>' # main panel scroll up
-    scrollDownMain: '<pgdown>' # main panel scroll down
-    scrollUpMain-alt1: 'K' # main panel scroll up
-    scrollDownMain-alt1: 'J' # main panel scroll down
-    scrollUpMain-alt2: '<c-u>' # main panel scroll up
-    scrollDownMain-alt2: '<c-d>' # main panel scroll down
-    executeCustomCommand: ':'
-    createRebaseOptionsMenu: 'm'
-    pushFiles: 'P'
-    pullFiles: 'p'
-    refresh: 'R'
-    createPatchOptionsMenu: '<c-p>'
-    nextTab: ']'
-    prevTab: '['
-    nextScreenMode: '+'
-    prevScreenMode: '_'
-    undo: 'z'
-    redo: '<c-z>'
-    filteringMenu: '<c-s>'
-    diffingMenu: 'W'
-    diffingMenu-alt: '<c-e>' # deprecated
-    copyToClipboard: '<c-o>'
-    submitEditorText: '<enter>'
-    appendNewline: '<a-enter>'
-    extrasMenu: '@'
-    toggleWhitespaceInDiffView: '<c-w>'
-    increaseContextInDiffView: '}'
-    decreaseContextInDiffView: '{'
-  status:
-    checkForUpdate: 'u'
-    recentRepos: '<enter>'
-  files:
-    commitChanges: 'c'
-    commitChangesWithoutHook: 'w' # commit changes without pre-commit hook
-    amendLastCommit: 'A'
-    commitChangesWithEditor: 'C'
-    ignoreFile: 'i'
-    refreshFiles: 'r'
-    stashAllChanges: 's'
-    viewStashOptions: 'S'
-    toggleStagedAll: 'a' # stage/unstage all
-    viewResetOptions: 'D'
-    fetch: 'f'
-    toggleTreeView: '`'
-  branches:
-    createPullRequest: 'o'
-    viewPullRequestOptions: 'O'
-    checkoutBranchByName: 'c'
-    forceCheckoutBranch: 'F'
-    rebaseBranch: 'r'
-    mergeIntoCurrentBranch: 'M'
-    viewGitFlowOptions: 'i'
-    fastForward: 'f' # fast-forward this branch from its upstream
-    pushTag: 'P'
-    setUpstream: 'u' # set as upstream of checked-out branch
-    fetchRemote: 'f'
-  commits:
-    squashDown: 's'
-    renameCommit: 'r'
-    renameCommitWithEditor: 'R'
-    viewResetOptions: 'g'
-    markCommitAsFixup: 'f'
-    createFixupCommit: 'F' # create fixup commit for this commit
-    squashAboveCommits: 'S'
-    moveDownCommit: '<c-j>' # move commit down one
-    moveUpCommit: '<c-k>' # move commit up one
-    amendToCommit: 'A'
-    pickCommit: 'p' # pick commit (when mid-rebase)
-    revertCommit: 't'
-    cherryPickCopy: 'c'
-    cherryPickCopyRange: 'C'
-    pasteCommits: 'v'
-    tagCommit: 'T'
-    checkoutCommit: '<space>'
-    resetCherryPick: '<c-R>'
-    copyCommitMessageToClipboard: '<c-y>'
-    openLogMenu: '<c-l>'
-  stash:
-    popStash: 'g'
-  commitFiles:
-    checkoutCommitFile: 'c'
-  main:
-    toggleDragSelect: 'v'
-    toggleDragSelect-alt: 'V'
-    toggleSelectHunk: 'a'
-    pickBothHunks: 'b'
-  submodules:
-    init: 'i'
-    update: 'u'
-    bulkMenu: 'b'
+  gui:
+    # stuff relating to the UI
+    scrollHeight: 2 # how many lines you scroll by
+    scrollPastBottom: true # enable scrolling past the bottom
+    theme:
+      lightTheme: false # For terminals with a light background
+      activeBorderColor:
+        - white
+        - bold
+      inactiveBorderColor:
+        - white
+      optionsTextColor:
+        - blue
+    commitLength:
+      show: true
+    mouseEvents: true
+  git:
+    merging:
+      # only applicable to unix users
+      manualCommit: false
+    skipHookPrefix: WIP
+    autoFetch: true
+  update:
+    method: prompt # can be: prompt | background | never
+    days: 14 # how often an update is checked for
+  reporting: 'undetermined' # one of: 'on' | 'off' | 'undetermined'
+  confirmOnQuit: false
 ```
 
-## Platform Defaults
+## Platform Defaults:
 
-### Windows
+### Windows:
 
 ```yaml
-os:
-  openCommand: 'start "" {{filename}}'
+  os:
+    openCommand: 'cmd /c "start "" {{filename}}"'
 ```
 
-### Linux
+### Linux:
 
 ```yaml
-os:
-  openCommand: 'xdg-open {{filename}} >/dev/null'
+  os:
+    openCommand: 'sh -c "xdg-open {{filename}} >/dev/null"'
 ```
 
-### OSX
+### OSX:
 
 ```yaml
-os:
-  openCommand: 'open {{filename}}'
+  os:
+    openCommand: 'open {{filename}}'
 ```
 
-### Configuring File Editing
-
-Lazygit will edit a file with the first set editor in the following:
-
-1. config.yaml
-
-```yaml
-os:
-  editCommand: 'vim' # as an example
-```
-
-2. \$(git config core.editor)
-3. \$GIT_EDITOR
-4. \$VISUAL
-5. \$EDITOR
-6. \$(which vi)
-
-Lazygit will log an error if none of these options are set.
-
-You can specify a line number you are currently at when in the line-by-line mode.
-
-```yaml
-os:
-  editCommand: 'vim'
-  editCommandTemplate: '{{editor}} +{{line}} {{filename}}'
-```
-
-or
-
-```yaml
-os:
-  editCommand: 'code'
-  editCommandTemplate: '{{editor}} --goto {{filename}}:{{line}}'
-```
-
-`{{editor}}` in `editCommandTemplate` is replaced with the value of `editCommand`.
-
-### Overriding default config file location
-
-To override the default config directory, use `$CONFIG_DIR="~/.config/lazygit"`. This directory contains the config file in addition to some other files lazygit uses to keep track of state across sessions.
-
-To override the individual config file used, use the `--use-config-file` arg or the `LG_CONFIG_FILE` env var.
-
-If you want to merge a specific config file into a more general config file, perhaps for the sake of setting some theme-specific options, you can supply a list of comma-separated config file paths, like so:
-
-```sh
-lazygit --use-config-file=~/.base_lg_conf,~/.light_theme_lg_conf
-or
-LG_CONFIG_FILE="~/.base_lg_conf,~/.light_theme_lg_conf" lazygit
-```
-
-### Recommended Config Values
+### Recommended Config Values:
 
 for users of VSCode
 
 ```yaml
-os:
-  openCommand: 'code -rg {{filename}}'
+  os:
+    openCommand: 'code -r {{filename}}'
 ```
 
-## Color Attributes
+## Color Attributes:
 
 For color attributes you can choose an array of attributes (with max one color attribute)
 The available attributes are:
 
-**Colors**
-
+- default
 - black
 - red
 - green
@@ -318,191 +78,25 @@ The available attributes are:
 - magenta
 - cyan
 - white
-- '#ff00ff'
-
-**Modifiers**
-
 - bold
-- default
 - reverse # useful for high-contrast
 - underline
 
-## Light terminal theme
+## Light terminal theme:
 
 If you have issues with a light terminal theme where you can't read / see the text add these settings
 
 ```yaml
-gui:
-  theme:
-    lightTheme: true
-    activeBorderColor:
-      - black
-      - bold
-    inactiveBorderColor:
-      - black
-    selectedLineBgColor:
-      - default
+  gui:
+    theme:
+      lightTheme: true
+      activeBorderColor:
+        - black
+        - bold
+      inactiveBorderColor:
+        - black
 ```
 
-## Struggling to see selected line
+## Example Coloring:
 
-If you struggle to see the selected line I recommend using the reverse attribute on selected lines like so:
-
-```yaml
-gui:
-  theme:
-    selectedLineBgColor:
-      - reverse
-    selectedRangeBgColor:
-      - reverse
-```
-
-The following has also worked for a couple of people:
-
-```yaml
-gui:
-  theme:
-    activeBorderColor:
-      - white
-      - bold
-    inactiveBorderColor:
-      - white
-    selectedLineBgColor:
-      - reverse
-      - blue
-```
-
-Alternatively you may have bold fonts disabled in your terminal, in which case enabling bold fonts should solve the problem.
-
-If you're still having trouble please raise an issue.
-
-## Custom Author Color
-
-Lazygit will assign a random color for every commit author in the commits pane by default.
-
-You can customize the color in case you're not happy with the randomly assigned one:
-
-```yaml
-gui:
-  authorColors:
-    'John Smith': '#ff0000' # use red for John Smith
-```
-
-You can use wildcard to set a unified color in case your are lazy to customize the color for every author or you just want a single color for all/other authors:
-```yaml
-gui:
-  authorColors:
-    # use red for John Smith
-    'John Smith': '#ff0000'
-    # use blue for other authors
-    '*': '#0000ff'
-```
-
-## Example Coloring
-
-![border example](../../assets/colored-border-example.png)
-
-## Keybindings
-
-For all possible keybinding options, check [Custom_Keybindings.md](https://github.com/jesseduffield/lazygit/blob/master/docs/keybindings/Custom_Keybindings.md)
-
-### Example Keybindings For Colemak Users
-
-```yaml
-keybinding:
-  universal:
-    prevItem-alt: 'u'
-    nextItem-alt: 'e'
-    prevBlock-alt: 'n'
-    nextBlock-alt: 'i'
-    nextMatch: '='
-    prevMatch: '-'
-    new: 'k'
-    edit: 'o'
-    openFile: 'O'
-    scrollUpMain-alt1: 'U'
-    scrollDownMain-alt1: 'E'
-    scrollUpMain-alt2: '<c-u>'
-    scrollDownMain-alt2: '<c-e>'
-    undo: 'l'
-    redo: '<c-r>'
-    diffingMenu: 'M'
-    filteringMenu: '<c-f>'
-  files:
-    ignoreFile: 'I'
-  commits:
-    moveDownCommit: '<c-e>'
-    moveUpCommit: '<c-u>'
-  branches:
-    viewGitFlowOptions: 'I'
-    setUpstream: 'U'
-```
-
-## Custom pull request URLs
-
-Some git provider setups (e.g. on-premises GitLab) can have distinct URLs for git-related calls and
-the web interface/API itself. To work with those, Lazygit needs to know where it needs to create
-the pull request. You can do so on your `config.yml` file using the following syntax:
-
-```yaml
-services:
-  '<gitDomain>': '<provider>:<webDomain>'
-```
-
-Where:
-
-- `gitDomain` stands for the domain used by git itself (i.e. the one present on clone URLs), e.g. `git.work.com`
-- `provider` is one of `github`, `bitbucket` or `gitlab`
-- `webDomain` is the URL where your git service exposes a web interface and APIs, e.g. `gitservice.work.com`
-
-## Predefined commit message prefix
-
-In situations where certain naming pattern is used for branches and commits, pattern can be used to populate
-commit message with prefix that is parsed from the branch name.
-
-Example:
-
-- Branch name: feature/AB-123
-- Commit message: [AB-123] Adding feature
-
-```yaml
-git:
-  commitPrefixes:
-    my_project: # This is repository folder name
-      pattern: "^\\w+\\/(\\w+-\\w+).*"
-      replace: '[$1] '
-```
-
-## Custom git log command
-
-You can override the `git log` command that's used to render the log of the selected branch like so:
-
-```
-git:
-  branchLogCmd: "git log --graph --color=always --abbrev-commit --decorate --date=relative --pretty=medium --oneline {{branchName}} --"
-```
-
-Result:
-
-![](https://i.imgur.com/Nibq35B.png)
-
-## Launching not in a repository behaviour
-
-By default, when launching lazygit from a directory that is not a repository,
-you will be prompted to choose if you would like to initialize a repo. You can
-override this behaviour in the config with one of the following:
-
-```yaml
-# for default prompting behaviour
-notARepository: 'prompt'
-```
-
-```yaml
-# to skip and initialize a new repo
-notARepository: 'create'
-```
-
-```yaml
-# to skip without creating a new repo
-notARepository: 'skip'
-```
+![border example](/docs/resources/colored-border-example.png)

docs/Custom_Command_Keybindings.md

@@ -1,168 +0,0 @@
-# Custom Command Keybindings
-
-You can add custom command keybindings in your config.yml (accessible by pressing 'o' on the status panel from within lazygit) like so:
-
-```yml
-customCommands:
-  - key: '<c-r>'
-    command: 'hub browse -- "commit/{{.SelectedLocalCommit.Sha}}"'
-    context: 'commits'
-  - key: 'a'
-    command: "git {{if .SelectedFile.HasUnstagedChanges}} add {{else}} reset {{end}} {{.SelectedFile.Name}}"
-    context: 'files'
-    description: 'toggle file staged'
-  - key: 'C'
-    command: "git commit"
-    context: 'global'
-    subprocess: true
-  - key: 'n'
-    prompts:
-      - type: 'menu'
-        title: 'What kind of branch is it?'
-        options:
-          - name: 'feature'
-            description: 'a feature branch'
-            value: 'feature'
-          - name: 'hotfix'
-            description: 'a hotfix branch'
-            value: 'hotfix'
-          - name: 'release'
-            description: 'a release branch'
-            value: 'release'
-      - type: 'input'
-        title: 'What is the new branch name?'
-        initialValue: ''
-    command: "git flow {{index .PromptResponses 0}} start {{index .PromptResponses 1}}"
-    context: 'localBranches'
-    loadingText: 'creating branch'
-  - key : 'r'
-    description: 'Checkout a remote branch as FETCH_HEAD'
-    command: "git fetch {{index .PromptResponses 0}} {{index .PromptResponses 1}} && git checkout FETCH_HEAD"
-    context: 'remotes'
-    prompts:
-      - type: 'input'
-        title: 'Remote:'
-        initialValue: "{{index .SelectedRemote.Name }}"
-      - type: 'menuFromCommand'
-        title: 'Remote branch:'
-        command: 'git branch  -r --list {{index .PromptResponses 0}}/*'
-        filter: '.*{{index .PromptResponses 0}}/(?P<branch>.*)'
-        valueFormat: '{{ .branch }}'
-        labelFormat: '{{ .branch | green }}'
-```
-
-Looking at the command assigned to the 'n' key, here's what the result looks like:
-
-![](../../assets/custom-command-keybindings.gif)
-
-Custom command keybindings will appear alongside inbuilt keybindings when you view the options menu by pressing 'x':
-
-![](https://i.imgur.com/QB21FPx.png)
-
-For a given custom command, here are the allowed fields:
-| _field_ | _description_ | required |
-|-----------------|----------------------|-|
-| key | the key to trigger the command. Use a single letter or one of the values from [here](https://github.com/jesseduffield/lazygit/blob/master/docs/keybindings/Custom_Keybindings.md) | yes |
-| command | the command to run | yes |
-| context | the context in which to listen for the key (see below) | yes |
-| subprocess | whether you want the command to run in a subprocess (necessary if you want to view the output of the command or provide user input) | no |
-| prompts | a list of prompts that will request user input before running the final command | no |
-| loadingText | text to display while waiting for command to finish | no |
-| description | text to display in the keybindings menu that appears when you press 'x' | no |
-
-### Contexts
-
-The permitted contexts are:
-
-| _context_      | _description_                                                                                            |
-| -------------- | -------------------------------------------------------------------------------------------------------- |
-| status         | the 'Status' tab                                                                                         |
-| files          | the 'Files' tab                                                                                          |
-| localBranches  | the 'Local Branches' tab                                                                                 |
-| remotes        | the 'Remotes' tab                                                                                        |
-| remoteBranches | the context you get when pressing enter on a remote in the remotes tab                                   |
-| tags           | the 'Tags' tab                                                                                           |
-| commits        | the 'Commits' tab                                                                                        |
-| reflogCommits  | the 'Reflog' tab                                                                                         |
-| subCommits     | the context you see when pressing enter on a branch                                                      |
-| commitFiles    | the context you see when pressing enter on a commit or stash entry (warning, might be renamed in future) |
-| stash          | the 'Stash' tab                                                                                          |
-| global         | this keybinding will take affect everywhere                                                              |
-
-### Prompts
-
-The permitted prompt fields are:
-
-| _field_           | _description_                                                                    | _required_ |
-| ------------      | -------------------------------------------------------------------------------- | ---------- |
-| type              | one of 'input' or 'menu'                                                         | yes        |
-| title             | the title to display in the popup panel                                          | no         |
-| initialValue      | (only applicable to 'input' prompts) the initial value to appear in the text box | no         |
-| options           | (only applicable to 'menu' prompts) the options to display in the menu           | no         |
-| command           | (only applicable to 'menuFromCommand' prompts) the command to run to generate    | yes        |
-|                   | menu options                                                                     |            |
-| filter            | (only applicable to 'menuFromCommand' prompts) the regexp to run specifying      | yes        |
-|                   | groups which are going to be kept from the command's output                      |            |
-| valueFormat       | (only applicable to 'menuFromCommand' prompts) how to format matched groups from | yes        |
-|                   | the filter to construct a menu item's value (What gets appended to prompt        |            |
-|                   | responses when the item is selected). You can use named groups,                  |            |
-|                   | or `{{ .group_GROUPID }}`.                                                       |            |
-|                   | PS: named groups keep first match only                                           |            |
-| labelFormat       | (only applicable to 'menuFromCommand' prompts) how to format matched groups from | no         |
-|                   | the filter to construct the item's label (What's shown on screen). You can use   |            |
-|                   | named groups, or `{{ .group_GROUPID }}`. You can also color each match with      |            |
-|                   | `{{ .group_GROUPID | colorname }}` (Color names from                             |            |
-|                   | [here](https://github.com/jesseduffield/lazygit/blob/master/docs/Config.md))     |            |
-|                   | If `labelFormat` is not specified, `valueFormat` is shown instead.               |            |
-|                   | PS: named groups keep first match only                                           |            |
-
-The permitted option fields are:
-| _field_ | _description_ | _required_ |
-|-----------------|----------------------|-|
-| name | the string which will appear first on the line | no |
-| description | the string which will appear second on the line | no |
-| value | the value that will be stored in `.PromptResponses` if the option is selected | yes |
-
-If an option has no name the value will be displayed to the user in place of the name, so you're allowed to only include the value like so:
-
-```yml
-    prompts:
-      - type: 'menu'
-        title: 'What kind of branch is it?'
-        options:
-          - value: 'feature'
-          - value: 'hotfix'
-          - value: 'release'
-```
-
-### Placeholder values
-
-Your commands can contain placeholder strings using Go's [template syntax](https://jan.newmarch.name/go/template/chapter-template.html). The template syntax is pretty powerful, letting you do things like conditionals if you want, but for the most part you'll simply want to be accessing the fields on the following objects:
-
-```
-SelectedLocalCommit
-SelectedReflogCommit
-SelectedSubCommit
-SelectedFile
-SelectedLocalBranch
-SelectedRemoteBranch
-SelectedRemote
-SelectedTag
-SelectedStashEntry
-SelectedCommitFile
-CheckedOutBranch
-```
-
-To see what fields are available on e.g. the `SelectedFile`, see [here](https://github.com/jesseduffield/lazygit/blob/master/pkg/commands/models/file.go) (all the modelling lives in the same directory). Note that the custom commands feature does not guarantee backwards compatibility (until we hit lazygit version 1.0 of course) which means a field you're accessing on an object may no longer be available from one release to the next. Typically however, all you'll need is `{{.SelectedFile.Name}}`, `{{.SelectedLocalCommit.Sha}}` and `{{.SelectedBranch.Name}}`. In the future we will likely introduce a tighter interface that exposes a limited set of fields for each model.
-
-### Keybinding collisions
-
-If your custom keybinding collides with an inbuilt keybinding that is defined for the same context, only the custom keybinding will be executed. This also applies to the global context. However, one caveat is that if you have a custom keybinding defined on the global context for some key, and there is an in-built keybinding defined for the same key and for a specific context (say the 'files' context), then the in-built keybinding will take precedence. See how to change in-built keybindings [here](https://github.com/jesseduffield/lazygit/blob/master/docs/Config.md#keybindings)
-
-### Debugging
-
-If you want to verify that your command actually does what you expect, you can wrap it in an 'echo' call and set `subprocess: true` so that it doesn't actually execute the command but you can see how the placeholders were resolved. Alternatively you can run lazygit in debug mode with `lazygit --debug` and in another terminal window run `lazygit --logs` to see which commands are actually run
-
-### More Examples
-
-See the [wiki](https://github.com/jesseduffield/lazygit/wiki/Custom-Commands-Compendium) page for more examples, and feel free to add your own custom commands to this page so others can benefit!

docs/Custom_Pagers.md

@@ -1,64 +0,0 @@
-# Custom Pagers
-
-Lazygit supports custom pagers, [configured](/docs/Config.md) in the config.yml file (which can be opened by pressing `o` in the Status panel).
-
-Support does not extend to Windows users, because we're making use of a package which doesn't have Windows support.
-
-## Default:
-
-```yaml
-git:
-  paging:
-    colorArg: always
-    useConfig: false
-```
-
-the `colorArg` key is for whether you want the `--color=always` arg in your `git diff` command. Some pagers want it set to `always`, others want it set to `never`.
-
-## Delta:
-
-```yaml
-git:
-  paging:
-    colorArg: always
-    pager: delta --dark --paging=never
-```
-
-![](https://i.imgur.com/QJpQkF3.png)
-
-## Diff-so-fancy
-
-```yaml
-git:
-  paging:
-    colorArg: always
-    pager: diff-so-fancy
-```
-
-![](https://i.imgur.com/rjH1TpT.png)
-
-## ydiff
-
-```yaml
-gui:
-  sidePanelWidth: 0.2 # gives you more space to show things side-by-side
-git:
-  paging:
-    colorArg: never
-    pager: ydiff -p cat -s --wrap --width={{columnWidth}}
-```
-
-![](https://i.imgur.com/vaa8z0H.png)
-
-Be careful with this one, I think the homebrew and pip versions are behind master. I needed to directly download the ydiff script to get the no-pager functionality working.
-
-## Using git config
-
-```yaml
-git:
-  paging:
-    colorArg: always
-    useConfig: true
-```
-
-If you set `useConfig: true`, lazygit will use whatever pager is specified in `$GIT_PAGER`, `$PAGER`, or your *git config*. If the pager ends with something like ` | less` we will strip that part out, because less doesn't play nice with our rendering approach. If the custom pager uses less under the hood, that will also break rendering (hence the `--paging=never` flag for the `delta` pager).

docs/Integration_Tests.md

@@ -1,90 +0,0 @@
-# How To Make And Run Integration Tests For lazygit
-
-Integration tests are located in `test/integration`. Each test will run a bash script to prepare a test repo, then replay a recorded lazygit session from within that repo, and then the resultant repo will be compared to an expected repo that was created upon the initial recording. Each integration test lives in its own directory, and the name of the directory becomes the name of the test. Within the directory must be the following files:
-
-### `test.json`
-
-An example of a `test.json` is:
-
-```
-{ "description": "stage a file and commit the change", "speed": 20 }
-```
-
-The `speed` key refers to the playback speed as a multiple of the original recording speed. So 20 means the test will run 20 times faster than the original recording speed. If a test fails for a given speed, it will drop the speed and re-test, until finally attempting the test at the original speed. If you omit the speed, it will default to 10.
-
-### `setup.sh`
-
-This is a bash script containing the instructions for creating the test repo from scratch. For example:
-
-```
-#!/bin/sh
-
-cd $1
-
-git init
-
-git config user.email "CI@example.com"
-git config user.name "CI"
-
-echo test1 > myfile1
-git add .
-git commit -am "myfile1"
-```
-
-## Running tests
-
-To run all tests - assuming you're at the project root:
-```
-go test ./pkg/gui/
-```
-
-To run them in parallel
-```
-PARALLEL=true go test ./pkg/gui
-```
-
-To run a single test
-```
-go test ./pkg/gui -run /<test name>
-# For example, to run the `tags` test:
-go test ./pkg/gui -run /tags
-```
-
-To run a test at a certain speed
-```
-SPEED=2 go test ./pkg/gui -run /<test name>
-```
-
-To update a snapshot
-```
-UPDATE_SNAPSHOTS=true go test ./pkg/gui -run /<test name>
-```
-
-## Creating a new test
-
-To create a new test:
-1) Copy and paste an existing test directory and rename the new directory to whatever you want the test name to be. Update the test.json file's description to describe your test.
-2) Update the `setup.sh` any way you like
-3) If you want to have a config folder for just that test, create a `config` directory to contain a `config.yml` and optionally a `state.yml` file. Otherwise, the `test/default_test_config` directory will be used.
-4) From the lazygit root directory, run:
-```
-RECORD_EVENTS=true go test ./pkg/gui -run /<test name>
-```
-5) Feel free to re-attempt recording as many times as you like. In the absence of a proper testing framework, the more deliberate your keypresses, the better!
-6) Once satisfied with the recording, stage all the newly created files: `test.json`, `setup.sh`, `recording.json` and the `expected` directory that contains a copy of the repo you created.
-
-The resulting directory will look like:
-```
-actual/ (the resulting repo after running the test, ignored by git)
-expected/ (the 'snapshot' repo)
-config/ (need not be present)
-test.json
-setup.sh
-recording.json
-```
-
-Feel free to create a hierarchy of directories in the `test/integration` directory to group tests by feature.
-
-## Feedback
-
-If you think this process can be improved, let me know! It shouldn't be too hard to change things.

docs/README.md

@@ -1,7 +0,0 @@
-# Documentation Overview 
-
-* [Configuration](./Config.md).
-* [Custom Commands](./Custom_Command_Keybindings.md)
-* [Custom Pagers](./Custom_Pagers.md)
-* [Keybindings](./keybindings)
-* [Undo/Redo](./Undoing.md)

docs/Undoing.md

@@ -1,24 +0,0 @@
-# Undo/Redo in lazygit
-
-![Gif](../../assets/undo2.gif)
-
-## Keybindings:
-'z' to undo, 'ctrl+z' to redo
-
-## How it works
-
-If you're as clumsy as me you'll probably have felt the pain of botching an interactive rebase or doing a hard reset onto the wrong commit. Luckily, the reflog allows you to trace your steps and make things right again, but I personally can't stand trying to make sense of the reflog.
-
-Lazygit can read through your reflog for you and walk back action by action so that you don't even need to read the reflog. If lazygit finds a reflog entry where you checked out a branch, we'll checkout the original branch. If the entry is from a commit being applied, we'll go back to the commit before that. If we hit an interactive rebase, we'll go back to the commit you were on just before you started it.
-
-## You can even undo things you did outside of lazygit!
-
-Because lazygit just uses the reflog to keep track of things, it doesn't matter whether you're trying to undo something you did in lazygit or directly on the command line. You can open lazygit for the first time and start undoing thing in your repo! Likewise, lazygit marks its undos/redos in the reflog so if you quit the application and come back, lazygit still knows where you're up to.
-
-## Limitations
-
-There are limitations: firstly, lazygit can only undo things that are recorded in the reflog. That means changes to your working tree or stash aren't covered. Secondly, anything permanent you do like pushing to a remote can't be undone. Thirdly, actions like creating a branch won't be undone, because they're not stored in the reflog.
-
-If you are mid-rebase, undo/redo is not supported, because the reflog doesn't contain enough information about what specific things have happened inside that rebase. If you want to undo out of a rebase, it's best to abort the rebase (the default keybinding for bringing up rebase options is 'm').
-
-Undo/Redo is a new feature so if you find a bug let us know. The worst case scenario is that you'll just need to look at your reflog and manually put yourself back on track.

docs/keybindings/Custom_Keybindings.md

@@ -1,59 +0,0 @@
-## Possible keybindings
-| Put in        | You will get   |
-|---------------|----------------|
-| `<f1>`        | F1             |
-| `<f2>`        | F2             |
-| `<f3>`        | F3             |
-| `<f4>`        | F4             |
-| `<f5>`        | F5             |
-| `<f6>`        | F6             |
-| `<f7>`        | F7             |
-| `<f8>`        | F8             |
-| `<f9>`        | F9             |
-| `<f10>`       | F10            |
-| `<f11>`       | F11            |
-| `<f12>`       | F12            |
-| `<insert>`    | Insert         |
-| `<delete>`    | Delete         |
-| `<home>`      | Home           |
-| `<end>`       | End            |
-| `<pgup>`      | Pgup           |
-| `<pgdown>`    | Pgdn           |
-| `<up>`        | ArrowUp        |
-| `<down>`      | ArrowDown      |
-| `<left>`      | ArrowLeft      |
-| `<right>`     | ArrowRight     |
-| `<tab>`       | Tab            |
-| `<enter>`     | Enter          |
-| `<esc>`       | Esc            |
-| `<backspace>` | Backspace      |
-| `<c-space>`   | CtrlSpace      |
-| `<c-/>`       | CtrlSlash      |
-| `<space>`     | Space          |
-| `<c-a>`       | CtrlA          |
-| `<c-b>`       | CtrlB          |
-| `<c-c>`       | CtrlC          |
-| `<c-d>`       | CtrlD          |
-| `<c-e>`       | CtrlE          |
-| `<c-f>`       | CtrlF          |
-| `<c-g>`       | CtrlG          |
-| `<c-j>`       | CtrlJ          |
-| `<c-k>`       | CtrlK          |
-| `<c-l>`       | CtrlL          |
-| `<c-n>`       | CtrlN          |
-| `<c-o>`       | CtrlO          |
-| `<c-p>`       | CtrlP          |
-| `<c-q>`       | CtrlQ          |
-| `<c-r>`       | CtrlR          |
-| `<c-s>`       | CtrlS          |
-| `<c-t>`       | CtrlT          |
-| `<c-u>`       | CtrlU          |
-| `<c-v>`       | CtrlV          |
-| `<c-w>`       | CtrlW          |
-| `<c-x>`       | CtrlX          |
-| `<c-y>`       | CtrlY          |
-| `<c-z>`       | CtrlZ          |
-| `<c-4>`       | Ctrl4          |
-| `<c-5>`       | Ctrl5          |
-| `<c-6>`       | Ctrl6          |
-| `<c-8>`       | Ctrl8          |

docs/keybindings/Keybindings_en.md

@@ -1,169 +1,24 @@
-# Lazygit Keybindings
+# Lazygit menu
 
-## Global Keybindings
+## Global
 
 <pre>
-  <kbd>ctrl+r</kbd>: switch to a recent repo (<c-r>)
-  <kbd>pgup</kbd>: scroll up main panel (fn+up)
-  <kbd>pgdown</kbd>: scroll down main panel (fn+down)
   <kbd>m</kbd>: view merge/rebase options
-  <kbd>ctrl+p</kbd>: view custom patch options
   <kbd>P</kbd>: push
   <kbd>p</kbd>: pull
   <kbd>R</kbd>: refresh
-  <kbd>x</kbd>: open menu
-  <kbd>z</kbd>: undo (via reflog) (experimental)
-  <kbd>ctrl+z</kbd>: redo (via reflog) (experimental)
-  <kbd>+</kbd>: next screen mode (normal/half/fullscreen)
-  <kbd>_</kbd>: prev screen mode
-  <kbd>:</kbd>: execute custom command
-  <kbd>ctrl+s</kbd>: view filter-by-path options
-  <kbd>W</kbd>: open diff menu
-  <kbd>ctrl+e</kbd>: open diff menu
-  <kbd>@</kbd>: open command log menu
 </pre>
 
-## List Panel Navigation
+## Status
 
 <pre>
-  <kbd>.</kbd>: next page
-  <kbd>,</kbd>: previous page
-  <kbd><</kbd>: scroll to top
-  <kbd>></kbd>: scroll to bottom
-  <kbd>/</kbd>: start search
-  <kbd>]</kbd>: next tab
-  <kbd>[</kbd>: previous tab
+  <kbd>e</kbd>: edit config file
+  <kbd>o</kbd>: open config file
+  <kbd>u</kbd>: check for update
+  <kbd>s</kbd>: switch to a recent repo
 </pre>
 
-## Branches Panel (Branches Tab)
-
-<pre>
-  <kbd>space</kbd>: checkout
-  <kbd>o</kbd>: create pull request
-  <kbd>O</kbd>: create pull request options
-  <kbd>ctrl+y</kbd>: copy pull request URL to clipboard
-  <kbd>c</kbd>: checkout by name
-  <kbd>F</kbd>: force checkout
-  <kbd>n</kbd>: new branch
-  <kbd>d</kbd>: delete branch
-  <kbd>r</kbd>: rebase checked-out branch onto this branch
-  <kbd>M</kbd>: merge into currently checked out branch
-  <kbd>i</kbd>: show git-flow options
-  <kbd>f</kbd>: fast-forward this branch from its upstream
-  <kbd>g</kbd>: view reset options
-  <kbd>R</kbd>: rename branch
-  <kbd>ctrl+o</kbd>: copy branch name to clipboard
-  <kbd>enter</kbd>: view commits
-</pre>
-
-## Branches Panel (Remote Branches (in Remotes tab))
-
-<pre>
-  <kbd>esc</kbd>: Return to remotes list
-  <kbd>g</kbd>: view reset options
-  <kbd>enter</kbd>: view commits
-  <kbd>space</kbd>: checkout
-  <kbd>n</kbd>: new branch
-  <kbd>M</kbd>: merge into currently checked out branch
-  <kbd>d</kbd>: delete branch
-  <kbd>r</kbd>: rebase checked-out branch onto this branch
-  <kbd>u</kbd>: set as upstream of checked-out branch
-</pre>
-
-## Branches Panel (Remotes Tab)
-
-<pre>
-  <kbd>f</kbd>: fetch remote
-  <kbd>n</kbd>: add new remote
-  <kbd>d</kbd>: remove remote
-  <kbd>e</kbd>: edit remote
-</pre>
-
-## Branches Panel (Sub-commits)
-
-<pre>
-  <kbd>enter</kbd>: view commit's files
-  <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: view reset options
-  <kbd>n</kbd>: new branch
-  <kbd>c</kbd>: copy commit (cherry-pick)
-  <kbd>C</kbd>: copy commit range (cherry-pick)
-  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
-  <kbd>ctrl+o</kbd>: copy commit SHA to clipboard
-</pre>
-
-## Branches Panel (Tags Tab)
-
-<pre>
-  <kbd>space</kbd>: checkout
-  <kbd>d</kbd>: delete tag
-  <kbd>P</kbd>: push tag
-  <kbd>n</kbd>: create tag
-  <kbd>g</kbd>: view reset options
-  <kbd>enter</kbd>: view commits
-</pre>
-
-## Commit Files Panel
-
-<pre>
-  <kbd>ctrl+o</kbd>: copy the committed file name to the clipboard
-  <kbd>c</kbd>: checkout file
-  <kbd>d</kbd>: discard this commit's changes to this file
-  <kbd>o</kbd>: open file
-  <kbd>e</kbd>: edit file
-  <kbd>space</kbd>: toggle file included in patch
-  <kbd>enter</kbd>: enter file to add selected lines to the patch (or toggle directory collapsed)
-  <kbd>`</kbd>: toggle file tree view
-</pre>
-
-## Commits Panel (Commits)
-
-<pre>
-  <kbd>s</kbd>: squash down
-  <kbd>r</kbd>: reword commit
-  <kbd>R</kbd>: reword commit with editor
-  <kbd>g</kbd>: reset to this commit
-  <kbd>f</kbd>: fixup commit
-  <kbd>F</kbd>: create fixup commit for this commit
-  <kbd>S</kbd>: squash all 'fixup!' commits above selected commit (autosquash)
-  <kbd>d</kbd>: delete commit
-  <kbd>ctrl+j</kbd>: move commit down one
-  <kbd>ctrl+k</kbd>: move commit up one
-  <kbd>e</kbd>: edit commit
-  <kbd>A</kbd>: amend commit with staged changes
-  <kbd>p</kbd>: pick commit (when mid-rebase)
-  <kbd>t</kbd>: revert commit
-  <kbd>c</kbd>: copy commit (cherry-pick)
-  <kbd>ctrl+o</kbd>: copy commit SHA to clipboard
-  <kbd>C</kbd>: copy commit range (cherry-pick)
-  <kbd>v</kbd>: paste commits (cherry-pick)
-  <kbd>enter</kbd>: view commit's files
-  <kbd>space</kbd>: checkout commit
-  <kbd>n</kbd>: create new branch off of commit
-  <kbd>T</kbd>: tag commit
-  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
-  <kbd>ctrl+y</kbd>: copy commit message to clipboard
-</pre>
-
-## Commits Panel (Reflog Tab)
-
-<pre>
-  <kbd>enter</kbd>: view commit's files
-  <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: view reset options
-  <kbd>c</kbd>: copy commit (cherry-pick)
-  <kbd>C</kbd>: copy commit range (cherry-pick)
-  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
-  <kbd>ctrl+o</kbd>: copy commit SHA to clipboard
-</pre>
-
-## Extras Panel
-
-<pre>
-  <kbd>@</kbd>: open command log menu
-</pre>
-
-## Files Panel (Files)
+## Files
 
 <pre>
   <kbd>c</kbd>: commit changes
@@ -176,112 +31,98 @@
   <kbd>o</kbd>: open file
   <kbd>i</kbd>: add to .gitignore
   <kbd>r</kbd>: refresh files
-  <kbd>s</kbd>: stash changes
-  <kbd>S</kbd>: view stash options
+  <kbd>S</kbd>: stash files
   <kbd>a</kbd>: stage/unstage all
+  <kbd>t</kbd>: add patch
   <kbd>D</kbd>: view reset options
-  <kbd>enter</kbd>: stage individual hunks/lines for file, or collapse/expand for directory
+  <kbd>enter</kbd>: stage individual hunks/lines
   <kbd>f</kbd>: fetch
-  <kbd>ctrl+o</kbd>: copy the file name to the clipboard
-  <kbd>g</kbd>: view upstream reset options
-  <kbd>`</kbd>: toggle file tree view
-  <kbd>M</kbd>: open external merge tool (git mergetool)
-  <kbd>ctrl+w</kbd>: Toggle whether or not whitespace changes are shown in the diff view
+  <kbd>X</kbd>: execute custom command
 </pre>
 
-## Files Panel (Submodules)
+## Branches
 
 <pre>
-  <kbd>ctrl+o</kbd>: copy submodule name to clipboard
-  <kbd>enter</kbd>: enter submodule
-  <kbd>d</kbd>: view reset and remove submodule options
-  <kbd>u</kbd>: update submodule
-  <kbd>n</kbd>: add new submodule
-  <kbd>e</kbd>: update submodule URL
-  <kbd>i</kbd>: initialize submodule
-  <kbd>b</kbd>: view bulk submodule options
+  <kbd>space</kbd>: checkout
+  <kbd>o</kbd>: create pull request
+  <kbd>c</kbd>: checkout by name
+  <kbd>F</kbd>: force checkout
+  <kbd>n</kbd>: new branch
+  <kbd>d</kbd>: delete branch
+  <kbd>r</kbd>: rebase branch
+  <kbd>M</kbd>: merge into currently checked out branch
+  <kbd>f</kbd>: fast-forward this branch from its upstream
 </pre>
 
-## Main Panel (Merging)
+## Commits
 
 <pre>
-  <kbd>esc</kbd>: return to files panel
-  <kbd>M</kbd>: open external merge tool (git mergetool)
-  <kbd>space</kbd>: pick hunk
-  <kbd>b</kbd>: pick all hunks
-  <kbd>◄</kbd>: select previous conflict
-  <kbd>►</kbd>: select next conflict
-  <kbd>▲</kbd>: select previous hunk
-  <kbd>▼</kbd>: select next hunk
-  <kbd>z</kbd>: undo
+  <kbd>s</kbd>: squash down
+  <kbd>r</kbd>: reword commit
+  <kbd>R</kbd>: rename commit with editor
+  <kbd>g</kbd>: reset to this commit
+  <kbd>f</kbd>: fixup commit
+  <kbd>F</kbd>: create fixup commit for this commit
+  <kbd>S</kbd>: squash above commits
+  <kbd>d</kbd>: delete commit
+  <kbd>ctrl+j</kbd>: move commit down one
+  <kbd>ctrl+k</kbd>: move commit up one
+  <kbd>e</kbd>: edit commit
+  <kbd>A</kbd>: amend commit with staged changes
+  <kbd>p</kbd>: pick commit (when mid-rebase)
+  <kbd>t</kbd>: revert commit
+  <kbd>c</kbd>: copy commit (cherry-pick)
+  <kbd>C</kbd>: copy commit range (cherry-pick)
+  <kbd>v</kbd>: paste commits (cherry-pick)
+  <kbd>enter</kbd>: view commit's files
+  <kbd>space</kbd>: select commit to diff with another commit
 </pre>
 
-## Main Panel (Normal)
+## Stash
 
 <pre>
-  <kbd>Ő</kbd>: scroll down (fn+up)
-  <kbd>ő</kbd>: scroll up (fn+down)
-</pre>
-
-## Main Panel (Patch Building)
-
-<pre>
-  <kbd>esc</kbd>: exit line-by-line mode
-  <kbd>o</kbd>: open file
-  <kbd>▲</kbd>: select previous line
-  <kbd>▼</kbd>: select next line
-  <kbd>◄</kbd>: select previous hunk
-  <kbd>►</kbd>: select next hunk
-  <kbd>space</kbd>: add/remove line(s) to patch
-  <kbd>v</kbd>: toggle drag select
-  <kbd>V</kbd>: toggle drag select
-  <kbd>a</kbd>: toggle select hunk
-</pre>
-
-## Main Panel (Staging)
-
-<pre>
-  <kbd>esc</kbd>: return to files panel
-  <kbd>space</kbd>: toggle line staged / unstaged
-  <kbd>d</kbd>: delete change (git reset)
-  <kbd>tab</kbd>: switch to other panel
-  <kbd>o</kbd>: open file
-  <kbd>▲</kbd>: select previous line
-  <kbd>▼</kbd>: select next line
-  <kbd>◄</kbd>: select previous hunk
-  <kbd>►</kbd>: select next hunk
-  <kbd>e</kbd>: edit file
-  <kbd>o</kbd>: open file
-  <kbd>v</kbd>: toggle drag select
-  <kbd>V</kbd>: toggle drag select
-  <kbd>a</kbd>: toggle select hunk
-  <kbd>c</kbd>: commit changes
-  <kbd>w</kbd>: commit changes without pre-commit hook
-  <kbd>C</kbd>: commit changes using git editor
-</pre>
-
-## Menu Panel
-
-<pre>
-  <kbd>esc</kbd>: close menu
-</pre>
-
-## Stash Panel
-
-<pre>
-  <kbd>enter</kbd>: view stash entry's files
   <kbd>space</kbd>: apply
   <kbd>g</kbd>: pop
   <kbd>d</kbd>: drop
-  <kbd>n</kbd>: new branch
 </pre>
 
-## Status Panel
+## Commit files
 
 <pre>
-  <kbd>e</kbd>: edit config file
-  <kbd>o</kbd>: open config file
-  <kbd>u</kbd>: check for update
-  <kbd>enter</kbd>: switch to a recent repo
-  <kbd>a</kbd>: show all branch logs
+  <kbd>esc</kbd>: go back
+  <kbd>c</kbd>: checkout file
+  <kbd>d</kbd>: discard this commit's changes to this file
+  <kbd>o</kbd>: open file
+</pre>
+
+## Main (Normal)
+
+<pre>
+  <kbd>PgDn</kbd>: scroll down (fn+up)
+  <kbd>PgUp</kbd>: scroll up (fn+down)
+</pre>
+
+## Main (Staging)
+
+<pre>
+  <kbd>esc</kbd>: return to files panel
+  <kbd>▲</kbd>: select previous line
+  <kbd>▼</kbd>: select next line
+  <kbd>◄</kbd>: select previous hunk
+  <kbd>►</kbd>: select next hunk
+  <kbd>space</kbd>: stage line
+  <kbd>a</kbd>: stage hunk
+</pre>
+
+## Main (Merging)
+
+<pre>
+  <kbd>esc</kbd>: return to files panel
+  <kbd>space</kbd>: pick hunk
+  <kbd>b</kbd>: pick both hunks
+  <kbd>◄</kbd>: select previous conflict
+  <kbd>►</kbd>: select next conflict
+  <kbd>▲</kbd>: select top hunk
+  <kbd>▼</kbd>: select bottom hunk
+  <kbd>z</kbd>: undo
 </pre>

docs/keybindings/Keybindings_nl.md

@@ -1,169 +1,24 @@
-# Lazygit Sneltoetsen
+# Lazygit menu
 
-## Globale Sneltoetsen
+## Global
 
 <pre>
-  <kbd>ctrl+r</kbd>: wissel naar een recente repo (<c-r>)
-  <kbd>pgup</kbd>: scroll naar beneden vanaf hoofdpaneel (fn+up)
-  <kbd>pgdown</kbd>: scroll naar beneden vanaf hoofdpaneel (fn+down)
   <kbd>m</kbd>: bekijk merge/rebase opties
-  <kbd>ctrl+p</kbd>: bekijk aangepaste patch opties
   <kbd>P</kbd>: push
   <kbd>p</kbd>: pull
   <kbd>R</kbd>: verversen
-  <kbd>x</kbd>: open menu
-  <kbd>z</kbd>: ongedaan maken (via reflog) (experimenteel)
-  <kbd>ctrl+z</kbd>: redo (via reflog) (experimenteel)
-  <kbd>+</kbd>: volgende scherm modus (normaal/half/groot)
-  <kbd>_</kbd>: vorige scherm modus
-  <kbd>:</kbd>: voor aangepaste commando uit
-  <kbd>ctrl+s</kbd>: bekijk scoping opties
-  <kbd>W</kbd>: open diff menu
-  <kbd>ctrl+e</kbd>: open diff menu
-  <kbd>@</kbd>: open command log menu
 </pre>
 
-## Lijstpaneel Navigatie
+## Status
 
 <pre>
-  <kbd>.</kbd>: volgende pagina
-  <kbd>,</kbd>: vorige pagina
-  <kbd><</kbd>: scroll naar boven
-  <kbd>></kbd>: scroll naar beneden
-  <kbd>/</kbd>: start met zoeken
-  <kbd>]</kbd>: volgende tabblad
-  <kbd>[</kbd>: vorige tabblad
+  <kbd>e</kbd>: verander config file
+  <kbd>o</kbd>: open config file
+  <kbd>u</kbd>: check voor updates
+  <kbd>s</kbd>: wissel naar een recente repo
 </pre>
 
-## Branches Paneel (Branches Tabblad)
-
-<pre>
-  <kbd>space</kbd>: uitchecken
-  <kbd>o</kbd>: maak een pull-request
-  <kbd>O</kbd>: bekijk opties voor pull-aanvraag
-  <kbd>ctrl+y</kbd>: kopieer de URL van het pull-verzoek naar het klembord
-  <kbd>c</kbd>: uitchecken bij naam
-  <kbd>F</kbd>: forceer checkout
-  <kbd>n</kbd>: nieuwe branch
-  <kbd>d</kbd>: verwijder branch
-  <kbd>r</kbd>: rebase branch
-  <kbd>M</kbd>: merge in met huidige checked out branch
-  <kbd>i</kbd>: laat git-flow opties zien
-  <kbd>f</kbd>: fast-forward deze branch vanaf zijn upstream
-  <kbd>g</kbd>: bekijk reset opties
-  <kbd>R</kbd>: hernoem branch
-  <kbd>ctrl+o</kbd>: kopieer branch name naar klembord
-  <kbd>enter</kbd>: bekijk commits
-</pre>
-
-## Branches Paneel (Remote Branches (in Remotes tabblad))
-
-<pre>
-  <kbd>esc</kbd>: Ga terug naar remotes lijst
-  <kbd>g</kbd>: bekijk reset opties
-  <kbd>enter</kbd>: bekijk commits
-  <kbd>space</kbd>: uitchecken
-  <kbd>n</kbd>: nieuwe branch
-  <kbd>M</kbd>: merge in met huidige checked out branch
-  <kbd>d</kbd>: verwijder branch
-  <kbd>r</kbd>: rebase branch
-  <kbd>u</kbd>: stel in als upstream van uitgecheckte branch
-</pre>
-
-## Branches Paneel (Remotes Tabblad)
-
-<pre>
-  <kbd>f</kbd>: fetch remote
-  <kbd>n</kbd>: voeg een nieuwe remote toe
-  <kbd>d</kbd>: verwijder remote
-  <kbd>e</kbd>: wijzig remote
-</pre>
-
-## Branches Paneel (Sub-commits)
-
-<pre>
-  <kbd>enter</kbd>: bekijk gecommite bestanden
-  <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: bekijk reset opties
-  <kbd>n</kbd>: nieuwe branch
-  <kbd>c</kbd>: kopieer commit (cherry-pick)
-  <kbd>C</kbd>: kopieer commit reeks (cherry-pick)
-  <kbd>ctrl+r</kbd>: reset cherry-picked (gekopieerde) commits selectie
-  <kbd>ctrl+o</kbd>: kopieer commit SHA naar klembord
-</pre>
-
-## Branches Paneel (Tags Tabblad)
-
-<pre>
-  <kbd>space</kbd>: uitchecken
-  <kbd>d</kbd>: verwijder tag
-  <kbd>P</kbd>: push tag
-  <kbd>n</kbd>: creëer tag
-  <kbd>g</kbd>: bekijk reset opties
-  <kbd>enter</kbd>: bekijk commits
-</pre>
-
-## Commit bestanden Paneel
-
-<pre>
-  <kbd>ctrl+o</kbd>: kopieer de vastgelegde bestandsnaam naar het klembord
-  <kbd>c</kbd>: bestand uitchecken
-  <kbd>d</kbd>: uitsluit deze commit zijn veranderingen aan dit bestand
-  <kbd>o</kbd>: open bestand
-  <kbd>e</kbd>: verander bestand
-  <kbd>space</kbd>: toggle bestand inbegrepen in patch
-  <kbd>enter</kbd>: enter bestand om geselecteerde regels toe te voegen aan de patch
-  <kbd>`</kbd>: toggle bestandsboom weergave
-</pre>
-
-## Commits Paneel (Commits)
-
-<pre>
-  <kbd>s</kbd>: squash beneden
-  <kbd>r</kbd>: hernoem commit
-  <kbd>R</kbd>: hernoem commit met editor
-  <kbd>g</kbd>: reset naar deze commit
-  <kbd>f</kbd>: Fixup commit
-  <kbd>F</kbd>: creëer fixup commit voor deze commit
-  <kbd>S</kbd>: squash bovenstaande commits
-  <kbd>d</kbd>: verwijder commit
-  <kbd>ctrl+j</kbd>: verplaats commit 1 naar beneden
-  <kbd>ctrl+k</kbd>: verplaats commit 1 naar boven
-  <kbd>e</kbd>: wijzig commit
-  <kbd>A</kbd>: wijzig commit met staged veranderingen
-  <kbd>p</kbd>: kies commit (wanneer midden in rebase)
-  <kbd>t</kbd>: commit ongedaan maken
-  <kbd>c</kbd>: kopieer commit (cherry-pick)
-  <kbd>ctrl+o</kbd>: kopieer commit SHA naar klembord
-  <kbd>C</kbd>: kopieer commit reeks (cherry-pick)
-  <kbd>v</kbd>: plak commits (cherry-pick)
-  <kbd>enter</kbd>: bekijk gecommite bestanden
-  <kbd>space</kbd>: checkout commit
-  <kbd>n</kbd>: creëer nieuwe branch van commit
-  <kbd>T</kbd>: tag commit
-  <kbd>ctrl+r</kbd>: reset cherry-picked (gekopieerde) commits selectie
-  <kbd>ctrl+y</kbd>: kopieer commit bericht naar klembord
-</pre>
-
-## Commits Paneel (Reflog Tabblad)
-
-<pre>
-  <kbd>enter</kbd>: bekijk gecommite bestanden
-  <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: bekijk reset opties
-  <kbd>c</kbd>: kopieer commit (cherry-pick)
-  <kbd>C</kbd>: kopieer commit reeks (cherry-pick)
-  <kbd>ctrl+r</kbd>: reset cherry-picked (gekopieerde) commits selectie
-  <kbd>ctrl+o</kbd>: kopieer commit SHA naar klembord
-</pre>
-
-## Extras Paneel
-
-<pre>
-  <kbd>@</kbd>: open command log menu
-</pre>
-
-## Bestanden Paneel (Bestanden)
+## Bestanden
 
 <pre>
   <kbd>c</kbd>: Commit veranderingen
@@ -176,39 +31,88 @@
   <kbd>o</kbd>: open bestand
   <kbd>i</kbd>: voeg toe aan .gitignore
   <kbd>r</kbd>: refresh bestanden
-  <kbd>s</kbd>: stash-bestanden
-  <kbd>S</kbd>: bekijk stash opties
+  <kbd>S</kbd>: stash-bestanden
   <kbd>a</kbd>: toggle staged alle
+  <kbd>t</kbd>: bewerkingen toevoegen
   <kbd>D</kbd>: bekijk reset opties
   <kbd>enter</kbd>: stage individuele hunks/lijnen
   <kbd>f</kbd>: fetch
-  <kbd>ctrl+o</kbd>: kopieer de bestandsnaam naar het klembord
-  <kbd>g</kbd>: bekijk upstream reset opties
-  <kbd>`</kbd>: toggle bestandsboom weergave
-  <kbd>M</kbd>: open external merge tool (git mergetool)
-  <kbd>ctrl+w</kbd>: Toggle whether or not whitespace changes are shown in the diff view
+  <kbd>X</kbd>: voor aangepast commando uit
 </pre>
 
-## Bestanden Paneel (Submodules)
+## Branches
 
 <pre>
-  <kbd>ctrl+o</kbd>: kopieer submodule naam naar klembord
-  <kbd>enter</kbd>: enter submodule
-  <kbd>d</kbd>: bekijk reset en verwijder submodule opties
-  <kbd>u</kbd>: update submodule
-  <kbd>n</kbd>: voeg nieuwe submodule toe
-  <kbd>e</kbd>: update submodule URL
-  <kbd>i</kbd>: initialiseer submodule
-  <kbd>b</kbd>: bekijk bulk submodule opties
+  <kbd>space</kbd>: uitchecken
+  <kbd>o</kbd>: maak een pull-aanvraag
+  <kbd>c</kbd>: uitchecken bij naam
+  <kbd>F</kbd>: forceer checkout
+  <kbd>n</kbd>: nieuwe branch
+  <kbd>d</kbd>: verwijder branch
+  <kbd>r</kbd>: rebase branch
+  <kbd>M</kbd>: merge in met huidige checked out branch
+  <kbd>f</kbd>: fast-forward this branch from its upstream
 </pre>
 
-## Hoofd Paneel (Mergen)
+## Commits
+
+<pre>
+  <kbd>s</kbd>: squash beneden
+  <kbd>r</kbd>: hernoem commit
+  <kbd>R</kbd>: rename commit with editor
+  <kbd>g</kbd>: reset naar deze commit
+  <kbd>f</kbd>: Fixup commit
+  <kbd>F</kbd>: creëer fixup commit voor deze commit
+  <kbd>S</kbd>: squash bovenstaande commits
+  <kbd>d</kbd>: verwijder commit
+  <kbd>ctrl+j</kbd>: verplaats commit 1 omlaag
+  <kbd>ctrl+k</kbd>: verplaats commit 1 omhoog
+  <kbd>e</kbd>: verander commit
+  <kbd>A</kbd>: wijzig commit met staged veranderingen
+  <kbd>p</kbd>: pick commit (when mid-rebase)
+  <kbd>t</kbd>: commit omgedaan maken
+  <kbd>c</kbd>: kopiëer commit (cherry-pick)
+  <kbd>C</kbd>: kopiëer commit reeks (cherry-pick)
+  <kbd>v</kbd>: plak commits (cherry-pick)
+  <kbd>enter</kbd>: bekijk gecommite bestanden
+  <kbd>space</kbd>: select commit to diff with another commit
+</pre>
+
+## Stash
+
+<pre>
+  <kbd>space</kbd>: toepassen
+  <kbd>g</kbd>: pop
+  <kbd>d</kbd>: drop
+</pre>
+
+## Commit bestanden
+
+<pre>
+  <kbd>esc</kbd>: ga terug
+  <kbd>c</kbd>: bestand uitchecken
+  <kbd>d</kbd>: uitsluit deze commit zijn veranderingen aan dit bestand
+  <kbd>o</kbd>: open bestand
+</pre>
+
+## Hoofd (Stage Lines/Hunks)
 
 <pre>
   <kbd>esc</kbd>: ga terug naar het bestanden paneel
-  <kbd>M</kbd>: open external merge tool (git mergetool)
-  <kbd>space</kbd>: kies hunk
-  <kbd>b</kbd>: kies bijde hunks
+  <kbd>▲</kbd>: selecteer de vorige lijn
+  <kbd>▼</kbd>: selecteer de volgende lijn
+  <kbd>◄</kbd>: selecteer de vorige hunk
+  <kbd>►</kbd>: selecteer de volgende hunk
+  <kbd>space</kbd>: stage lijn
+  <kbd>a</kbd>: stage hunk
+</pre>
+
+## Hoofd (Merging)
+
+<pre>
+  <kbd>esc</kbd>: ga terug naar het bestanden paneel
+  <kbd>space</kbd>: pick hunk
+  <kbd>b</kbd>: pick beide hunks
   <kbd>◄</kbd>: selecteer voorgaand conflict
   <kbd>►</kbd>: selecteer volgende conflict
   <kbd>▲</kbd>: selecteer bovenste hunk
@@ -216,72 +120,9 @@
   <kbd>z</kbd>: ongedaan maken
 </pre>
 
-## Hoofd Paneel (Normaal)
+## Hoofd (Normaal)
 
 <pre>
-  <kbd>Ő</kbd>: scroll omlaag (fn+up)
-  <kbd>ő</kbd>: scroll omhoog (fn+down)
-</pre>
-
-## Hoofd Paneel (Patch Bouwen)
-
-<pre>
-  <kbd>esc</kbd>: sluit lijn-bij-lijn modus
-  <kbd>o</kbd>: open bestand
-  <kbd>▲</kbd>: selecteer de vorige lijn
-  <kbd>▼</kbd>: selecteer de volgende lijn
-  <kbd>◄</kbd>: selecteer de vorige hunk
-  <kbd>►</kbd>: selecteer de volgende hunk
-  <kbd>space</kbd>: voeg toe/verwijder lijn(en) in patch
-  <kbd>v</kbd>: toggle drag selecteer
-  <kbd>V</kbd>: toggle drag selecteer
-  <kbd>a</kbd>: toggle selecteer hunk
-</pre>
-
-## Hoofd Paneel (Staging)
-
-<pre>
-  <kbd>esc</kbd>: ga terug naar het bestanden paneel
-  <kbd>space</kbd>: toggle lijnen staged / unstaged
-  <kbd>d</kbd>: verwijdert change (git reset)
-  <kbd>tab</kbd>: ga naar een ander paneel
-  <kbd>o</kbd>: open bestand
-  <kbd>▲</kbd>: selecteer de vorige lijn
-  <kbd>▼</kbd>: selecteer de volgende lijn
-  <kbd>◄</kbd>: selecteer de vorige hunk
-  <kbd>►</kbd>: selecteer de volgende hunk
-  <kbd>e</kbd>: verander bestand
-  <kbd>o</kbd>: open bestand
-  <kbd>v</kbd>: toggle drag selecteer
-  <kbd>V</kbd>: toggle drag selecteer
-  <kbd>a</kbd>: toggle selecteer hunk
-  <kbd>c</kbd>: Commit veranderingen
-  <kbd>w</kbd>: commit veranderingen zonder pre-commit hook
-  <kbd>C</kbd>: commit veranderingen met de git editor
-</pre>
-
-## Menu Paneel
-
-<pre>
-  <kbd>esc</kbd>: sluit menu
-</pre>
-
-## Stash Paneel
-
-<pre>
-  <kbd>enter</kbd>: bekijk bestanden van stash entry
-  <kbd>space</kbd>: toepassen
-  <kbd>g</kbd>: pop
-  <kbd>d</kbd>: laten vallen
-  <kbd>n</kbd>: nieuwe branch
-</pre>
-
-## Status Paneel
-
-<pre>
-  <kbd>e</kbd>: verander config bestand
-  <kbd>o</kbd>: open config bestand
-  <kbd>u</kbd>: check voor updates
-  <kbd>enter</kbd>: wissel naar een recente repo
-  <kbd>a</kbd>: alle logs van de branch laten zien
+  <kbd>PgDn</kbd>: scroll omlaag (fn+up)
+  <kbd>PgUp</kbd>: scroll omhoog (fn+down)
 </pre>

docs/keybindings/Keybindings_pl.md

@@ -1,169 +1,24 @@
-# Lazygit Keybindings
+# Lazygit menu
 
 ## Globalne
 
 <pre>
-  <kbd>ctrl+r</kbd>: switch to a recent repo (<c-r>)
-  <kbd>pgup</kbd>: scroll up main panel (fn+up)
-  <kbd>pgdown</kbd>: scroll down main panel (fn+down)
   <kbd>m</kbd>: view merge/rebase options
-  <kbd>ctrl+p</kbd>: view custom patch options
   <kbd>P</kbd>: push
   <kbd>p</kbd>: pull
   <kbd>R</kbd>: odśwież
-  <kbd>x</kbd>: open menu
-  <kbd>z</kbd>: undo (via reflog) (experimental)
-  <kbd>ctrl+z</kbd>: redo (via reflog) (experimental)
-  <kbd>+</kbd>: next screen mode (normal/half/fullscreen)
-  <kbd>_</kbd>: prev screen mode
-  <kbd>:</kbd>: execute custom command
-  <kbd>ctrl+s</kbd>: view filter-by-path options
-  <kbd>W</kbd>: open diff menu
-  <kbd>ctrl+e</kbd>: open diff menu
-  <kbd>@</kbd>: open command log menu
 </pre>
 
-## List Panel Navigation
+## Status
 
 <pre>
-  <kbd>.</kbd>: next page
-  <kbd>,</kbd>: previous page
-  <kbd><</kbd>: scroll to top
-  <kbd>></kbd>: scroll to bottom
-  <kbd>/</kbd>: start search
-  <kbd>]</kbd>: next tab
-  <kbd>[</kbd>: previous tab
+  <kbd>e</kbd>: edytuj plik konfiguracyjny
+  <kbd>o</kbd>: otwórz plik konfiguracyjny
+  <kbd>u</kbd>: sprawdź aktualizacje
+  <kbd>s</kbd>: switch to a recent repo
 </pre>
 
-## Gałęzie Panel (Branches Tab)
-
-<pre>
-  <kbd>space</kbd>: przełącz
-  <kbd>o</kbd>: utwórz żądanie wyciągnięcia
-  <kbd>O</kbd>: utwórz opcje żądania ściągnięcia
-  <kbd>ctrl+y</kbd>: skopiuj adres URL żądania ściągnięcia do schowka
-  <kbd>c</kbd>: przełącz używając nazwy
-  <kbd>F</kbd>: wymuś przełączenie
-  <kbd>n</kbd>: nowa gałąź
-  <kbd>d</kbd>: usuń gałąź
-  <kbd>r</kbd>: rebase branch
-  <kbd>M</kbd>: scal do obecnej gałęzi
-  <kbd>i</kbd>: show git-flow options
-  <kbd>f</kbd>: fast-forward this branch from its upstream
-  <kbd>g</kbd>: view reset options
-  <kbd>R</kbd>: rename branch
-  <kbd>ctrl+o</kbd>: copy branch name to clipboard
-  <kbd>enter</kbd>: view commits
-</pre>
-
-## Gałęzie Panel (Remote Branches (in Remotes tab))
-
-<pre>
-  <kbd>esc</kbd>: return to remotes list
-  <kbd>g</kbd>: view reset options
-  <kbd>enter</kbd>: view commits
-  <kbd>space</kbd>: przełącz
-  <kbd>n</kbd>: nowa gałąź
-  <kbd>M</kbd>: scal do obecnej gałęzi
-  <kbd>d</kbd>: usuń gałąź
-  <kbd>r</kbd>: rebase branch
-  <kbd>u</kbd>: set as upstream of checked-out branch
-</pre>
-
-## Gałęzie Panel (Remotes Tab)
-
-<pre>
-  <kbd>f</kbd>: fetch remote
-  <kbd>n</kbd>: add new remote
-  <kbd>d</kbd>: remove remote
-  <kbd>e</kbd>: edit remote
-</pre>
-
-## Gałęzie Panel (Sub-commits)
-
-<pre>
-  <kbd>enter</kbd>: view commit's files
-  <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: view reset options
-  <kbd>n</kbd>: nowa gałąź
-  <kbd>c</kbd>: copy commit (cherry-pick)
-  <kbd>C</kbd>: copy commit range (cherry-pick)
-  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
-  <kbd>ctrl+o</kbd>: copy commit SHA to clipboard
-</pre>
-
-## Gałęzie Panel (Tags Tab)
-
-<pre>
-  <kbd>space</kbd>: przełącz
-  <kbd>d</kbd>: delete tag
-  <kbd>P</kbd>: push tag
-  <kbd>n</kbd>: create tag
-  <kbd>g</kbd>: view reset options
-  <kbd>enter</kbd>: view commits
-</pre>
-
-## Commit files Panel
-
-<pre>
-  <kbd>ctrl+o</kbd>: copy the committed file name to the clipboard
-  <kbd>c</kbd>: checkout file
-  <kbd>d</kbd>: discard this commit's changes to this file
-  <kbd>o</kbd>: otwórz plik
-  <kbd>e</kbd>: edytuj plik
-  <kbd>space</kbd>: toggle file included in patch
-  <kbd>enter</kbd>: enter file to add selected lines to the patch (or toggle directory collapsed)
-  <kbd>`</kbd>: toggle file tree view
-</pre>
-
-## Commity Panel (Commity)
-
-<pre>
-  <kbd>s</kbd>: ściśnij w dół
-  <kbd>r</kbd>: przemianuj commit
-  <kbd>R</kbd>: przemianuj commit w edytorze
-  <kbd>g</kbd>: zresetuj do tego commita
-  <kbd>f</kbd>: napraw commit
-  <kbd>F</kbd>: create fixup commit for this commit
-  <kbd>S</kbd>: squash all 'fixup!' commits above selected commits (autosquash)
-  <kbd>d</kbd>: delete commit
-  <kbd>ctrl+j</kbd>: move commit down one
-  <kbd>ctrl+k</kbd>: move commit up one
-  <kbd>e</kbd>: edit commit
-  <kbd>A</kbd>: amend commit with staged changes
-  <kbd>p</kbd>: pick commit (when mid-rebase)
-  <kbd>t</kbd>: revert commit
-  <kbd>c</kbd>: copy commit (cherry-pick)
-  <kbd>ctrl+o</kbd>: copy commit SHA to clipboard
-  <kbd>C</kbd>: copy commit range (cherry-pick)
-  <kbd>v</kbd>: paste commits (cherry-pick)
-  <kbd>enter</kbd>: view commit's files
-  <kbd>space</kbd>: checkout commit
-  <kbd>n</kbd>: create new branch off of commit
-  <kbd>T</kbd>: tag commit
-  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
-  <kbd>ctrl+y</kbd>: copy commit message to clipboard
-</pre>
-
-## Commity Panel (Reflog Tab)
-
-<pre>
-  <kbd>enter</kbd>: view commit's files
-  <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: view reset options
-  <kbd>c</kbd>: copy commit (cherry-pick)
-  <kbd>C</kbd>: copy commit range (cherry-pick)
-  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
-  <kbd>ctrl+o</kbd>: copy commit SHA to clipboard
-</pre>
-
-## Extras Panel
-
-<pre>
-  <kbd>@</kbd>: open command log menu
-</pre>
-
-## Pliki Panel (Pliki)
+## Pliki
 
 <pre>
   <kbd>c</kbd>: commituj zmiany
@@ -176,112 +31,98 @@
   <kbd>o</kbd>: otwórz plik
   <kbd>i</kbd>: dodaj do .gitignore
   <kbd>r</kbd>: odśwież pliki
-  <kbd>s</kbd>: przechowaj pliki
-  <kbd>S</kbd>: view stash options
+  <kbd>S</kbd>: przechowaj pliki
   <kbd>a</kbd>: przełącz wszystkie zatwierdzenia
+  <kbd>t</kbd>: dodaj łatkę
   <kbd>D</kbd>: view reset options
   <kbd>enter</kbd>: zatwierdź pojedyncze linie
   <kbd>f</kbd>: fetch
-  <kbd>ctrl+o</kbd>: copy the file name to the clipboard
-  <kbd>g</kbd>: view upstream reset options
-  <kbd>`</kbd>: toggle file tree view
-  <kbd>M</kbd>: open external merge tool (git mergetool)
-  <kbd>ctrl+w</kbd>: Toggle whether or not whitespace changes are shown in the diff view
+  <kbd>X</kbd>: execute custom command
 </pre>
 
-## Pliki Panel (Submodules)
+## Gałęzie
 
 <pre>
-  <kbd>ctrl+o</kbd>: copy submodule name to clipboard
-  <kbd>enter</kbd>: enter submodule
-  <kbd>d</kbd>: view reset and remove submodule options
-  <kbd>u</kbd>: update submodule
-  <kbd>n</kbd>: add new submodule
-  <kbd>e</kbd>: update submodule URL
-  <kbd>i</kbd>: initialize submodule
-  <kbd>b</kbd>: view bulk submodule options
+  <kbd>space</kbd>: przełącz
+  <kbd>o</kbd>: utwórz żądanie wyciągnięcia
+  <kbd>c</kbd>: przełącz używając nazwy
+  <kbd>F</kbd>: wymuś przełączenie
+  <kbd>n</kbd>: nowa gałąź
+  <kbd>d</kbd>: usuń gałąź
+  <kbd>r</kbd>: rebase branch
+  <kbd>M</kbd>: scal do obecnej gałęzi
+  <kbd>f</kbd>: fast-forward this branch from its upstream
 </pre>
 
-## Main Panel (Merging)
+## Commity
 
 <pre>
-  <kbd>esc</kbd>: wróć do panelu plików
-  <kbd>M</kbd>: open external merge tool (git mergetool)
-  <kbd>space</kbd>: pick hunk
-  <kbd>b</kbd>: pick all hunks
-  <kbd>◄</kbd>: select previous conflict
-  <kbd>►</kbd>: select next conflict
-  <kbd>▲</kbd>: select previous hunk
-  <kbd>▼</kbd>: select next hunk
-  <kbd>z</kbd>: cofnij
+  <kbd>s</kbd>: ściśnij w dół
+  <kbd>r</kbd>: przemianuj commit
+  <kbd>R</kbd>: przemianuj commit w edytorze
+  <kbd>g</kbd>: zresetuj do tego commita
+  <kbd>f</kbd>: napraw commit
+  <kbd>F</kbd>: create fixup commit for this commit
+  <kbd>S</kbd>: squash above commits
+  <kbd>d</kbd>: delete commit
+  <kbd>ctrl+j</kbd>: move commit down one
+  <kbd>ctrl+k</kbd>: move commit up one
+  <kbd>e</kbd>: edit commit
+  <kbd>A</kbd>: amend commit with staged changes
+  <kbd>p</kbd>: pick commit (when mid-rebase)
+  <kbd>t</kbd>: revert commit
+  <kbd>c</kbd>: copy commit (cherry-pick)
+  <kbd>C</kbd>: copy commit range (cherry-pick)
+  <kbd>v</kbd>: paste commits (cherry-pick)
+  <kbd>enter</kbd>: view commit's files
+  <kbd>space</kbd>: select commit to diff with another commit
 </pre>
 
-## Main Panel (Normal)
+## Schowek
 
 <pre>
-  <kbd>Ő</kbd>: scroll down (fn+up)
-  <kbd>ő</kbd>: scroll up (fn+down)
-</pre>
-
-## Main Panel (Patch Building)
-
-<pre>
-  <kbd>esc</kbd>: exit line-by-line mode
-  <kbd>o</kbd>: otwórz plik
-  <kbd>▲</kbd>: select previous line
-  <kbd>▼</kbd>: select next line
-  <kbd>◄</kbd>: select previous hunk
-  <kbd>►</kbd>: select next hunk
-  <kbd>space</kbd>: add/remove line(s) to patch
-  <kbd>v</kbd>: toggle drag select
-  <kbd>V</kbd>: toggle drag select
-  <kbd>a</kbd>: toggle select hunk
-</pre>
-
-## Main Panel (Zatwierdzanie)
-
-<pre>
-  <kbd>esc</kbd>: wróć do panelu plików
-  <kbd>space</kbd>: toggle line staged / unstaged
-  <kbd>d</kbd>: delete change (git reset)
-  <kbd>tab</kbd>: switch to other panel
-  <kbd>o</kbd>: otwórz plik
-  <kbd>▲</kbd>: select previous line
-  <kbd>▼</kbd>: select next line
-  <kbd>◄</kbd>: select previous hunk
-  <kbd>►</kbd>: select next hunk
-  <kbd>e</kbd>: edytuj plik
-  <kbd>o</kbd>: otwórz plik
-  <kbd>v</kbd>: toggle drag select
-  <kbd>V</kbd>: toggle drag select
-  <kbd>a</kbd>: toggle select hunk
-  <kbd>c</kbd>: commituj zmiany
-  <kbd>w</kbd>: commit changes without pre-commit hook
-  <kbd>C</kbd>: commituj zmiany używając edytora z gita
-</pre>
-
-## Menu Panel
-
-<pre>
-  <kbd>esc</kbd>: close menu
-</pre>
-
-## Schowek Panel
-
-<pre>
-  <kbd>enter</kbd>: view stash entry's files
   <kbd>space</kbd>: zastosuj
   <kbd>g</kbd>: wyciągnij
   <kbd>d</kbd>: porzuć
-  <kbd>n</kbd>: nowa gałąź
 </pre>
 
-## Status Panel
+## Commit files
 
 <pre>
-  <kbd>e</kbd>: edytuj plik konfiguracyjny
-  <kbd>o</kbd>: otwórz plik konfiguracyjny
-  <kbd>u</kbd>: sprawdź aktualizacje
-  <kbd>enter</kbd>: switch to a recent repo
-  <kbd>a</kbd>: pokazywać wszystkie logi branżowe
+  <kbd>esc</kbd>: go back
+  <kbd>c</kbd>: checkout file
+  <kbd>d</kbd>: discard this commit's changes to this file
+  <kbd>o</kbd>: otwórz plik
+</pre>
+
+## Main (Normal)
+
+<pre>
+  <kbd>PgDn</kbd>: scroll down (fn+up)
+  <kbd>PgUp</kbd>: scroll up (fn+down)
+</pre>
+
+## Main (Zatwierdzanie)
+
+<pre>
+  <kbd>esc</kbd>: wróć do panelu plików
+  <kbd>▲</kbd>: select previous line
+  <kbd>▼</kbd>: select next line
+  <kbd>◄</kbd>: select previous hunk
+  <kbd>►</kbd>: select next hunk
+  <kbd>space</kbd>: zatwierdź linię
+  <kbd>a</kbd>: zatwierdź kawałek
+</pre>
+
+## Main (Merging)
+
+<pre>
+  <kbd>esc</kbd>: wróć do panelu plików
+  <kbd>space</kbd>: pick hunk
+  <kbd>b</kbd>: pick both hunks
+  <kbd>◄</kbd>: select previous conflict
+  <kbd>►</kbd>: select next conflict
+  <kbd>▲</kbd>: select top hunk
+  <kbd>▼</kbd>: select bottom hunk
+  <kbd>z</kbd>: undo
 </pre>

go.mod

@@ -1,47 +1,69 @@
 module github.com/jesseduffield/lazygit
 
-go 1.14
+go 1.13
 
 require (
-	github.com/OpenPeeDeeP/xdg v1.0.0
-	github.com/atotto/clipboard v0.1.2
-	github.com/aybabtme/humanlog v0.4.1
-	github.com/cli/safeexec v1.0.0
+	github.com/BurntSushi/toml v0.3.1 // indirect
+	github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7 // indirect
+	github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239 // indirect
+	github.com/aws/aws-sdk-go v1.15.21 // indirect
+	github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d // indirect
 	github.com/cloudfoundry/jibber_jabber v0.0.0-20151120183258-bcc4c8345a21
-	github.com/creack/pty v1.1.11
-	github.com/fatih/color v1.9.0 // indirect
-	github.com/fsnotify/fsnotify v1.4.7
-	github.com/go-errors/errors v1.4.1
-	github.com/go-logfmt/logfmt v0.5.0 // indirect
+	github.com/emirpasic/gods v1.9.0 // indirect
+	github.com/fatih/color v1.7.0
+	github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568 // indirect
+	github.com/gliderlabs/ssh v0.2.2 // indirect
+	github.com/go-errors/errors v1.0.1
+	github.com/go-ini/ini v1.38.2 // indirect
 	github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3
-	github.com/golang/protobuf v1.3.2 // indirect
-	github.com/google/go-cmp v0.5.6 // indirect
-	github.com/gookit/color v1.4.2
-	github.com/imdario/mergo v0.3.11
-	github.com/integrii/flaggy v1.4.0
-	github.com/jesseduffield/go-git/v5 v5.1.2-0.20201006095850-341962be15a4
-	github.com/jesseduffield/gocui v0.3.1-0.20211102104458-40df0be5a474
-	github.com/jesseduffield/minimal/gitignore v0.3.3-0.20211018110810-9cde264e6b1e
-	github.com/jesseduffield/yaml v2.1.0+incompatible
-	github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0
-	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
-	github.com/kylelemons/godebug v1.1.0 // indirect
-	github.com/kyokomi/emoji/v2 v2.2.8
-	github.com/lucasb-eyer/go-colorful v1.2.0
-	github.com/mattn/go-colorable v0.1.11 // indirect
-	github.com/mattn/go-runewidth v0.0.13
+	github.com/google/go-cmp v0.3.1 // indirect
+	github.com/hashicorp/go-cleanhttp v0.0.0-20171218145408-d5fe4b57a186 // indirect
+	github.com/hashicorp/go-getter v0.0.0-20180809191950-4bda8fa99001 // indirect
+	github.com/hashicorp/go-safetemp v0.0.0-20180326211150-b1a1dbde6fdc // indirect
+	github.com/hashicorp/go-version v1.0.0 // indirect
+	github.com/hashicorp/hcl v0.0.0-20180404174102-ef8a98b0bbce // indirect
+	github.com/integrii/flaggy v1.2.2
+	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
+	github.com/jesseduffield/go-getter v0.0.0-20180822080847-906e15686e63
+	github.com/jesseduffield/gocui v0.3.1-0.20191110053728-01cdcccd0508
+	github.com/jesseduffield/pty v0.0.0-20181218102224-02db52c7e406
+	github.com/jesseduffield/rollrus v0.0.0-20190701125922-dd028cb0bfd7
+	github.com/jesseduffield/termbox-go v0.0.0-20180919093808-1e272ff78dcb // indirect
+	github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1
+	github.com/kevinburke/ssh_config v0.0.0-20180317175531-9fc7bb800b55 // indirect
+	github.com/magiconair/properties v1.8.0 // indirect
+	github.com/mattn/go-colorable v0.0.9 // indirect
+	github.com/mattn/go-isatty v0.0.3 // indirect
+	github.com/mattn/go-runewidth v0.0.2 // indirect
 	github.com/mgutz/str v1.2.0
-	github.com/onsi/ginkgo v1.10.3 // indirect
-	github.com/onsi/gomega v1.7.1 // indirect
-	github.com/sahilm/fuzzy v0.1.0
-	github.com/sirupsen/logrus v1.4.2
+	github.com/mitchellh/go-homedir v0.0.0-20180801233206-58046073cbff // indirect
+	github.com/mitchellh/go-testing-interface v0.0.0-20171004221916-a61a99592b77 // indirect
+	github.com/mitchellh/mapstructure v0.0.0-20180715050151-f15292f7a699 // indirect
+	github.com/nicksnyder/go-i18n/v2 v2.0.2
+	github.com/onsi/ginkgo v1.9.0 // indirect
+	github.com/onsi/gomega v1.6.0 // indirect
+	github.com/pelletier/go-buffruneio v0.2.0 // indirect
+	github.com/pelletier/go-toml v1.2.0 // indirect
+	github.com/sergi/go-diff v1.0.0 // indirect
+	github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0
+	github.com/sirupsen/logrus v1.3.0
+	github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337 // indirect
+	github.com/spf13/afero v1.1.1 // indirect
+	github.com/spf13/cast v1.2.0 // indirect
+	github.com/spf13/jwalterweatherman v0.0.0-20180814060501-14d3d4c51834 // indirect
+	github.com/spf13/pflag v1.0.2 // indirect
+	github.com/spf13/viper v1.1.0
 	github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad
-	github.com/stretchr/testify v1.7.0
-	github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778
-	golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0 // indirect
-	golang.org/x/net v0.0.0-20201002202402-0a1ea396d57c // indirect
-	golang.org/x/sys v0.0.0-20211102061401-a2f17f7b995c // indirect
-	golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 // indirect
-	golang.org/x/text v0.3.7 // indirect
-	gopkg.in/ozeidan/fuzzy-patricia.v3 v3.0.0
+	github.com/src-d/gcfg v1.3.0 // indirect
+	github.com/stretchr/testify v1.2.2
+	github.com/tcnksm/go-gitconfig v0.1.2
+	github.com/ulikunitz/xz v0.5.4 // indirect
+	github.com/xanzy/ssh-agent v0.2.0 // indirect
+	golang.org/x/text v0.3.2
+	gopkg.in/ini.v1 v1.46.0 // indirect
+	gopkg.in/src-d/go-billy.v4 v4.2.0 // indirect
+	gopkg.in/src-d/go-git-fixtures.v3 v3.5.0 // indirect
+	gopkg.in/src-d/go-git.v4 v4.0.0-20180807092216-43d17e14b714
+	gopkg.in/warnings.v0 v0.1.2 // indirect
+	gopkg.in/yaml.v2 v2.2.1
 )

go.sum

@@ -1,210 +1,184 @@
-github.com/OpenPeeDeeP/xdg v1.0.0 h1:UDLmNjCGFZZCaVMB74DqYEtXkHxnTxcr4FeJVF9uCn8=
-github.com/OpenPeeDeeP/xdg v1.0.0/go.mod h1:tMoSueLQlMf0TCldjrJLNIjAc5qAOIcHt5REi88/Ygo=
+github.com/BurntSushi/toml v0.3.0/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7 h1:uSoVVbwJiQipAclBbw+8quDsfcvFjOpI5iCf4p/cqCs=
 github.com/alcortesm/tgz v0.0.0-20161220082320-9c5fe88206d7/go.mod h1:6zEj6s6u/ghQa61ZWa/C2Aw3RkjiTBOix7dkqa1VLIs=
 github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239 h1:kFOfPq6dUM1hTo4JG6LR5AXSUEsOjtdm0kw0FtQtMJA=
 github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
-github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPdPJAN/hZIm0C4OItdklCFmMRWYpio=
-github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
-github.com/atotto/clipboard v0.1.2 h1:YZCtFu5Ie8qX2VmVTBnrqLSiU9XOWwqNRmdT3gIQzbY=
-github.com/atotto/clipboard v0.1.2/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
-github.com/aybabtme/humanlog v0.4.1 h1:D8d9um55rrthJsP8IGSHBcti9lTb/XknmDAX6Zy8tek=
-github.com/aybabtme/humanlog v0.4.1/go.mod h1:B0bnQX4FTSU3oftPMTTPvENCy8LqixLDvYJA9TUCAGo=
-github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59/go.mod h1:q/89r3U2H7sSsE2t6Kca0lfwTK8JdoNGS/yzM/4iH5I=
-github.com/cli/safeexec v1.0.0 h1:0VngyaIyqACHdcMNWfo6+KdUYnqEr2Sg+bSP1pdF+dI=
-github.com/cli/safeexec v1.0.0/go.mod h1:Z/D4tTN8Vs5gXYHDCbaM1S/anmEDnJb1iW0+EJ5zx3Q=
+github.com/aws/aws-sdk-go v1.15.21 h1:STLvc6RrpycslC1NRtTvt/YSgDkIGCTrB9K9vE5R2oQ=
+github.com/aws/aws-sdk-go v1.15.21/go.mod h1:mFuSZ37Z9YOHbQEwBWztmVzqXrEkub65tZoCYDt7FT0=
+github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas=
+github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d/go.mod h1:6QX/PXZ00z/TKoufEY6K/a0k6AhaJrQKdFe6OfVXsa4=
 github.com/cloudfoundry/jibber_jabber v0.0.0-20151120183258-bcc4c8345a21 h1:tuijfIjZyjZaHq9xDUh0tNitwXshJpbLkqMOJv4H3do=
 github.com/cloudfoundry/jibber_jabber v0.0.0-20151120183258-bcc4c8345a21/go.mod h1:po7NpZ/QiTKzBKyrsEAxwnTamCoh8uDk/egRpQ7siIc=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/creack/pty v1.1.11 h1:07n33Z8lZxZ2qwegKbObQohDhXDQxiMMz1NOUGYlesw=
-github.com/creack/pty v1.1.11/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods v1.12.0 h1:QAUIPSaCu4G+POclxeqb3F+WPpdKqFGlw36+yOzGlrg=
-github.com/emirpasic/gods v1.12.0/go.mod h1:YfzfFFoVP/catgzJb4IKIqXjX78Ha8FMSDh3ymbK86o=
-github.com/fatih/color v1.7.1-0.20180516100307-2d684516a886/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/fatih/color v1.9.0 h1:8xPHl4/q1VyqGIPif1F+1V3Y3lSmrq01EabUW3CoW5s=
-github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU=
+github.com/emirpasic/gods v1.9.0 h1:rUF4PuzEjMChMiNsVjdI+SyLu7rEqpQ5reNFnhC7oFo=
+github.com/emirpasic/gods v1.9.0/go.mod h1:YfzfFFoVP/catgzJb4IKIqXjX78Ha8FMSDh3ymbK86o=
+github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568 h1:BHsljHzVlRcyQhjrss6TZTdY2VfCqZPbv5k3iBFa2ZQ=
 github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
 github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdko=
-github.com/gdamore/encoding v1.0.0/go.mod h1:alR0ol34c49FCSBLjhosxzcPHQbf2trDkoo5dl+VrEg=
-github.com/gdamore/tcell/v2 v2.4.0 h1:W6dxJEmaxYvhICFoTY3WrLLEXsQ11SaFnKGVEXW57KM=
-github.com/gdamore/tcell/v2 v2.4.0/go.mod h1:cTTuF84Dlj/RqmaCIV5p4w8uG1zWdk0SF6oBpwHp4fU=
 github.com/gliderlabs/ssh v0.2.2 h1:6zsha5zo/TWhRhwqCD3+EarCAgZ2yN28ipRnGPnwkI0=
 github.com/gliderlabs/ssh v0.2.2/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
-github.com/go-errors/errors v1.0.2/go.mod h1:psDX2osz5VnTOnFWbDeWwS7yejl+uV3FEWEp4lssFEs=
-github.com/go-errors/errors v1.4.1 h1:IvVlgbzSsaUNudsw5dcXSzF3EWyXTi5XrAdngnuhRyg=
-github.com/go-errors/errors v1.4.1/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
-github.com/go-git/gcfg v1.5.0 h1:Q5ViNfGF8zFgyJWPqYwA7qGFoMTEiBmdlkcfRmpIMa4=
-github.com/go-git/gcfg v1.5.0/go.mod h1:5m20vg6GwYabIxaOonVkTdrILxQMpEShl1xiMF4ua+E=
-github.com/go-git/go-billy/v5 v5.0.0 h1:7NQHvd9FVid8VL4qVUMm8XifBK+2xCoZ2lSk0agRrHM=
-github.com/go-git/go-billy/v5 v5.0.0/go.mod h1:pmpqyWchKfYfrkb/UVH4otLvyi/5gJlGI4Hb3ZqZ3W0=
-github.com/go-git/go-git-fixtures/v4 v4.0.2-0.20200613231340-f56387b50c12 h1:PbKy9zOy4aAKrJ5pibIRpVO2BXnK1Tlcg+caKI7Ox5M=
-github.com/go-git/go-git-fixtures/v4 v4.0.2-0.20200613231340-f56387b50c12/go.mod h1:m+ICp2rF3jDhFgEZ/8yziagdT1C+ZpZcrJjappBCDSw=
-github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
-github.com/go-logfmt/logfmt v0.5.0 h1:TrB8swr/68K7m9CcGut2g3UOihhbcbiMAYiuTXdEih4=
-github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
-github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y=
-github.com/gobwas/glob v0.2.3/go.mod h1:d3Ez4x06l9bZtSvzIay5+Yzi0fmZzPgnTbPcKjJAkT8=
+github.com/go-errors/errors v1.0.1 h1:LUHzmkK3GUKUrL/1gfBUxAHzcev3apQlezX/+O7ma6w=
+github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
+github.com/go-ini/ini v1.25.4/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
+github.com/go-ini/ini v1.38.2 h1:6Hl/z3p3iFkA0dlDfzYxuFuUGD+kaweypF6btsR2/Q4=
+github.com/go-ini/ini v1.38.2/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8=
 github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3 h1:zN2lZNZRflqFyxVaTIU61KNKQ9C0055u9CAfpmqUvo4=
 github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3/go.mod h1:nPpo7qLxd6XL3hWJG/O60sR8ZKfMCiIoNap5GvD12KU=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/gookit/color v1.4.2 h1:tXy44JFSFkKnELV6WaMo/lLfu/meqITX3iAV52do7lk=
-github.com/gookit/color v1.4.2/go.mod h1:fqRyamkC1W8uxl+lxCQxOT09l/vYfZ+QeiX3rKQHCoQ=
+github.com/google/go-cmp v0.3.1 h1:Xye71clBPdm5HgqGwUkwhbynsUJZhDbS20FvLhQ2izg=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/hashicorp/go-cleanhttp v0.0.0-20171218145408-d5fe4b57a186 h1:URgjUo+bs1KwatoNbwG0uCO4dHN4r1jsp4a5AGgHRjo=
+github.com/hashicorp/go-cleanhttp v0.0.0-20171218145408-d5fe4b57a186/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-getter v0.0.0-20180809191950-4bda8fa99001 h1:MFPzqpPED05pFyGjNPJEC2sXM6EHTzFyvX+0s0JoZ48=
+github.com/hashicorp/go-getter v0.0.0-20180809191950-4bda8fa99001/go.mod h1:6rdJFnhkXnzGOJbvkrdv4t9nLwKcVA+tmbQeUlkIzrU=
+github.com/hashicorp/go-safetemp v0.0.0-20180326211150-b1a1dbde6fdc h1:wAa9fGALVHfjYxZuXRnmuJG2CnwRpJYOTvY6YdErAh0=
+github.com/hashicorp/go-safetemp v0.0.0-20180326211150-b1a1dbde6fdc/go.mod h1:oaerMy3BhqiTbVye6QuFhFtIceqFoDHxNAB65b+Rj1I=
+github.com/hashicorp/go-version v1.0.0 h1:21MVWPKDphxa7ineQQTrCU5brh7OuVVAzGOCnnCPtE8=
+github.com/hashicorp/go-version v1.0.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/hcl v0.0.0-20180404174102-ef8a98b0bbce h1:xdsDDbiBDQTKASoGEZ+pEmF1OnWuu8AQ9I8iNbHNeno=
+github.com/hashicorp/hcl v0.0.0-20180404174102-ef8a98b0bbce/go.mod h1:oZtUIOe8dh44I2q6ScRibXws4Ajl+d+nod3AaR9vL5w=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
-github.com/imdario/mergo v0.3.9/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
-github.com/imdario/mergo v0.3.11 h1:3tnifQM4i+fbajXKBHXWEH+KvNHqojZ778UH75j3bGA=
-github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
-github.com/integrii/flaggy v1.4.0 h1:A1x7SYx4jqu5NSrY14z8Z+0UyX2S5ygfJJrfolWR3zM=
-github.com/integrii/flaggy v1.4.0/go.mod h1:tnTxHeTJbah0gQ6/K0RW0J7fMUBk9MCF5blhm43LNpI=
+github.com/integrii/flaggy v1.2.2 h1:SzL5kyEaW+Cb3RLxGG1ch9FFDLQPB6QuMdYoNu5JIo0=
+github.com/integrii/flaggy v1.2.2/go.mod h1:tnTxHeTJbah0gQ6/K0RW0J7fMUBk9MCF5blhm43LNpI=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
-github.com/jesseduffield/go-git/v5 v5.1.2-0.20201006095850-341962be15a4 h1:GOQrmaE8i+KEdB8NzAegKYd4tPn/inM0I1uo0NXFerg=
-github.com/jesseduffield/go-git/v5 v5.1.2-0.20201006095850-341962be15a4/go.mod h1:nGNEErzf+NRznT+N2SWqmHnDnF9aLgANB1CUNEan09o=
-github.com/jesseduffield/gocui v0.3.1-0.20211102104458-40df0be5a474 h1:4H/oJcUmwJpqyXzqfn+lsjQ/bjpm/HszzLrVbCjgqj4=
-github.com/jesseduffield/gocui v0.3.1-0.20211102104458-40df0be5a474/go.mod h1:znJuCDnF2Ph40YZSlBwdX/4GEofnIoWLGdT4mK5zRAU=
-github.com/jesseduffield/minimal/gitignore v0.3.3-0.20211018110810-9cde264e6b1e h1:uw/oo+kg7t/oeMs6sqlAwr85ND/9cpO3up3VxphxY0U=
-github.com/jesseduffield/minimal/gitignore v0.3.3-0.20211018110810-9cde264e6b1e/go.mod h1:u60qdFGXRd36jyEXxetz0vQceQIxzI13lIo3EFUDf4I=
-github.com/jesseduffield/yaml v2.1.0+incompatible h1:HWQJ1gIv2zHKbDYNp0Jwjlj24K8aqpFHnMCynY1EpmE=
-github.com/jesseduffield/yaml v2.1.0+incompatible/go.mod h1:w0xGhOSIJCGYYW+hnFPTutCy5aACpkcwbmORt5axGqk=
-github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
-github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0 h1:iQTw/8FWTuc7uiaSepXwyf3o52HaUYcV+Tu66S3F5GA=
-github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0/go.mod h1:1NbS8ALrpOvjt0rHPNLyCIeMtbizbir8U//inJ+zuB8=
-github.com/kevinburke/ssh_config v0.0.0-20190725054713-01f96b0aa0cd h1:Coekwdh0v2wtGp9Gmz1Ze3eVRAWJMLokvN3QjdzCHLY=
-github.com/kevinburke/ssh_config v0.0.0-20190725054713-01f96b0aa0cd/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
+github.com/jesseduffield/go-getter v0.0.0-20180822080847-906e15686e63 h1:Nrr/yUxNjXWYK0B3IqcFlYh1ICnesJDB4ogcfOVc5Ns=
+github.com/jesseduffield/go-getter v0.0.0-20180822080847-906e15686e63/go.mod h1:fNqjRf+4XnTo2PrGN1JRb79b/BeoHwP4lU00f39SQY0=
+github.com/jesseduffield/gocui v0.3.1-0.20191030094731-3cf1932858a3 h1:f28aZSb9uu/yTb2rCLmhLRZTsIzz2JkktXUhwvILAn0=
+github.com/jesseduffield/gocui v0.3.1-0.20191030094731-3cf1932858a3/go.mod h1:2RtZznzYKt8RLRwvFiSkXjU0Ei8WwHdubgnlaYH47dw=
+github.com/jesseduffield/gocui v0.3.1-0.20191110053728-01cdcccd0508 h1:8CPQLUe+0QXxnbnUfaMxh1UGxg3rYCqCvbxecC9rrIY=
+github.com/jesseduffield/gocui v0.3.1-0.20191110053728-01cdcccd0508/go.mod h1:2RtZznzYKt8RLRwvFiSkXjU0Ei8WwHdubgnlaYH47dw=
+github.com/jesseduffield/pty v0.0.0-20181218102224-02db52c7e406 h1:iYMH6h6SuWuBkIzRtymosE8NpSgTK0oRMfyTdVWgxzc=
+github.com/jesseduffield/pty v0.0.0-20181218102224-02db52c7e406/go.mod h1:7jlS40+UhOqkZJDIG1B/H21xnuET/+fvbbnHCa8wSIo=
+github.com/jesseduffield/roll v0.0.0-20190629104057-695be2e62b00 h1:+JaOkfBNYQYlGD7dgru8mCwYNEc5tRRI8mThlVANhSM=
+github.com/jesseduffield/roll v0.0.0-20190629104057-695be2e62b00/go.mod h1:cWNQljQAWYBp4wchyGfql4q2jRNZXxiE1KhVQgz+JaM=
+github.com/jesseduffield/rollrus v0.0.0-20190701125922-dd028cb0bfd7 h1:CRD7bVjlGIiV+M0jlsa+XWpneW0KY0e7Y4z3GWb5S4o=
+github.com/jesseduffield/rollrus v0.0.0-20190701125922-dd028cb0bfd7/go.mod h1:VspA3aTkEo0Q7TPCLmX1uHNP+Wb4iSDX09hmTRo1QYc=
+github.com/jesseduffield/termbox-go v0.0.0-20180919093808-1e272ff78dcb h1:cFHYEWpQEfzFZVKiKZytCUX4UwQixKSw0kd3WhluPsY=
+github.com/jesseduffield/termbox-go v0.0.0-20180919093808-1e272ff78dcb/go.mod h1:anMibpZtqNxjDbxrcDEAwSdaJ37vyUeM1f/M4uekib4=
+github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8 h1:12VvqtR6Aowv3l/EQUlocDHW2Cp4G9WJVH7uyH8QFJE=
+github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1 h1:PJPDf8OUfOK1bb/NeTKd4f1QXZItOX389VN3B6qC8ro=
+github.com/kardianos/osext v0.0.0-20170510131534-ae77be60afb1/go.mod h1:1NbS8ALrpOvjt0rHPNLyCIeMtbizbir8U//inJ+zuB8=
+github.com/kevinburke/ssh_config v0.0.0-20180317175531-9fc7bb800b55 h1:S38dC4mEwxdw/U41+97VWdbun8mTcTjwg5Ujfg8QPME=
+github.com/kevinburke/ssh_config v0.0.0-20180317175531-9fc7bb800b55/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2 h1:DB17ag19krx9CFsz4o3enTrPXyIXCl+2iCXH/aMAp9s=
-github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj2vyii2bbUNDw3kt9VxK2EY=
-github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
-github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
-github.com/kyokomi/emoji/v2 v2.2.8 h1:jcofPxjHWEkJtkIbcLHvZhxKgCPl6C7MyjTrD4KDqUE=
-github.com/kyokomi/emoji/v2 v2.2.8/go.mod h1:JUcn42DTdsXJo1SWanHh4HKDEyPaR5CqkmoirZZP9qE=
-github.com/lucasb-eyer/go-colorful v1.0.3/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
-github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
-github.com/mattn/go-colorable v0.1.0/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
-github.com/mattn/go-colorable v0.1.11 h1:nQ+aFkoE2TMGc0b68U2OKSexC+eq46+XwZzWXHRmPYs=
-github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4=
-github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
-github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
-github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
-github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
-github.com/mattn/go-runewidth v0.0.10/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
-github.com/mattn/go-runewidth v0.0.13 h1:lTGmDsbAYt5DmK6OnoV7EuIF1wEIFAcxld6ypU4OSgU=
-github.com/mattn/go-runewidth v0.0.13/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
+github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4=
+github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
+github.com/mattn/go-isatty v0.0.3 h1:ns/ykhmWi7G9O+8a448SecJU3nSMBXJfqQkl0upE1jI=
+github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-runewidth v0.0.2 h1:UnlwIPBGaTZfPQ6T1IGzPI0EkYAQmT9fAEJ/poFC63o=
+github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/mgutz/str v1.2.0 h1:4IzWSdIz9qPQWLfKZ0rJcV0jcUDpxvP4JVZ4GXQyvSw=
 github.com/mgutz/str v1.2.0/go.mod h1:w1v0ofgLaJdoD0HpQ3fycxKD1WtxpjSo151pK/31q6w=
-github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
-github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
-github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/mitchellh/go-homedir v0.0.0-20180801233206-58046073cbff h1:jM4Eo4qMmmcqePS3u6X2lcEELtVuXWkWJIS/pRI3oSk=
+github.com/mitchellh/go-homedir v0.0.0-20180801233206-58046073cbff/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-testing-interface v0.0.0-20171004221916-a61a99592b77 h1:7GoSOOW2jpsfkntVKaS2rAr1TJqfcxotyaUcuxoZSzg=
+github.com/mitchellh/go-testing-interface v0.0.0-20171004221916-a61a99592b77/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
+github.com/mitchellh/mapstructure v0.0.0-20180715050151-f15292f7a699 h1:KXZJFdun9knAVAR8tg/aHJEr5DgtcbqyvzacK+CDCaI=
+github.com/mitchellh/mapstructure v0.0.0-20180715050151-f15292f7a699/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/nicksnyder/go-i18n/v2 v2.0.2 h1:KsHGcTByIM0mHZKQGy0nlJLOjPNjQ6MVib/3PvsBDNY=
+github.com/nicksnyder/go-i18n/v2 v2.0.2/go.mod h1:JXS4+OKhbcwDoVTEj0sLFWL1vOwec2g/YBAxZ9owJqY=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.10.3 h1:OoxbjfXVZyod1fmWYhI7SEyaD8B00ynP3T+D5GiyHOY=
-github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/gomega v1.7.1 h1:K0jcRCwNQM3vFGh1ppMtDh/+7ApJrjldlX8fA0jDTLQ=
-github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/ginkgo v1.9.0 h1:SZjF721BByVj8QH636/8S2DnX4n0Re3SteMmw3N+tzc=
+github.com/onsi/ginkgo v1.9.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.6.0 h1:8XTW0fcJZEq9q+Upcyws4JSGua2MFysCL5xkaSgHc+M=
+github.com/onsi/gomega v1.6.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/pelletier/go-buffruneio v0.2.0 h1:U4t4R6YkofJ5xHm3dJzuRpPZ0mr5MMCoAWooScCR7aA=
+github.com/pelletier/go-buffruneio v0.2.0/go.mod h1:JkE26KsDizTr40EUHkXVtNPvgGtbSNq5BcowyYOWdKo=
+github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/sahilm/fuzzy v0.1.0 h1:FzWGaw2Opqyu+794ZQ9SYifWv2EIXpwP4q8dY1kDAwI=
-github.com/sahilm/fuzzy v0.1.0/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
-github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
-github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
-github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
-github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0 h1:Xuk8ma/ibJ1fOy4Ee11vHhUFHQNpHhrBneOCNHVXS5w=
+github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0/go.mod h1:7AwjWCpdPhkSmNAgUv5C7EJ4AbmjEB3r047r3DXWu3Y=
+github.com/sirupsen/logrus v1.3.0 h1:hI/7Q+DtNZ2kINb6qt/lS+IyXnHQe9e90POfeewL/ME=
+github.com/sirupsen/logrus v1.3.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337 h1:WN9BUFbdyOsSH/XohnWpXOlq9NBD5sGAB2FciQMUEe8=
+github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/spf13/afero v1.1.1 h1:Lt3ihYMlE+lreX1GS4Qw4ZsNpYQLxIXKBTEOXm3nt6I=
+github.com/spf13/afero v1.1.1/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
+github.com/spf13/cast v1.2.0 h1:HHl1DSRbEQN2i8tJmtS6ViPyHx35+p51amrdsiTCrkg=
+github.com/spf13/cast v1.2.0/go.mod h1:r2rcYCSwa1IExKTDiTfzaxqT2FNHs8hODu4LnUfgKEg=
+github.com/spf13/jwalterweatherman v0.0.0-20180814060501-14d3d4c51834 h1:kJI9pPzfsULT/72wy7mxkRQZPtKWgFdCA2RTGZ4v8/E=
+github.com/spf13/jwalterweatherman v0.0.0-20180814060501-14d3d4c51834/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/pflag v1.0.2 h1:Fy0orTDgHdbnzHcsOgfCN4LtHf0ec3wwtiwJqwvf3Gc=
+github.com/spf13/pflag v1.0.2/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/viper v1.1.0 h1:V7OZpY8i3C1x/pDmU0zNNlfVoDz112fSYvtWMjjS3f4=
+github.com/spf13/viper v1.1.0/go.mod h1:A8kyI5cUJhb8N+3pkfONlcEcZbueH6nhAm0Fq7SrnBM=
 github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad h1:fiWzISvDn0Csy5H0iwgAuJGQTUpVfEMJJd4nRFXogbc=
 github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKkMo8ZTx3f+BZEkzsRUY10Xsm2mwU0=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
+github.com/src-d/gcfg v1.3.0 h1:2BEDr8r0I0b8h/fOqwtxCEiq2HJu8n2JGZJQFGXWLjg=
+github.com/src-d/gcfg v1.3.0/go.mod h1:p/UMsR43ujA89BJY9duynAwIpvqEujIH/jFlfL7jWoI=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/urfave/cli v1.20.1-0.20180226030253-8e01ec4cd3e2/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
-github.com/xanzy/ssh-agent v0.2.1 h1:TCbipTQL2JiiCprBWx9frJ2eJlCYT00NmctrHxVAr70=
-github.com/xanzy/ssh-agent v0.2.1/go.mod h1:mLlQY/MoOhWBj+gOGMQkOeiEvkx+8pJSI+0Bx9h2kr4=
-github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778 h1:QldyIu/L63oPpyvQmHgvgickp1Yw510KJOqX7H24mg8=
-github.com/xo/terminfo v0.0.0-20210125001918-ca9a967f8778/go.mod h1:2MuV+tbUrU1zIOPMxZ5EncGwgmMJsa+9ucAQZXxsObs=
-golang.org/x/crypto v0.0.0-20190219172222-a4c6cb3142f2/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+github.com/tcnksm/go-gitconfig v0.1.2 h1:iiDhRitByXAEyjgBqsKi9QU4o2TNtv9kPP3RgPgXBPw=
+github.com/tcnksm/go-gitconfig v0.1.2/go.mod h1:/8EhP4H7oJZdIPyT+/UIsG87kTzrzM4UsLGSItWYCpE=
+github.com/ulikunitz/xz v0.5.4 h1:zATC2OoZ8H1TZll3FpbX+ikwmadbO699PE06cIkm9oU=
+github.com/ulikunitz/xz v0.5.4/go.mod h1:2bypXElzHzzJZwzH67Y6wb67pO62Rzfn7BSiF4ABRW8=
+github.com/xanzy/ssh-agent v0.2.0 h1:Adglfbi5p9Z0BmK2oKU9nTG+zKfniSfnaMYB+ULd+Ro=
+github.com/xanzy/ssh-agent v0.2.0/go.mod h1:0NyE30eGUDliuLEHJgYte/zncp2zdTStcOnWhgSqHD8=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0 h1:hb9wdF1z5waM+dSIICn1l0DkLVDT3hqhhQsDNUmHPRE=
-golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20190506204251-e1dfcc566284 h1:rlLehGeYg6jfoyz/eDqDU1iRXLKfR42nnNh57ytKEWo=
+golang.org/x/crypto v0.0.0-20190506204251-e1dfcc566284/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20201002202402-0a1ea396d57c h1:dk0ukUIHmGHqASjP0iue2261isepFCC6XRCSd1nHgDw=
-golang.org/x/net v0.0.0-20201002202402-0a1ea396d57c/go.mod h1:iQL9McJNjoIa5mjH6nYTCTZXUN6RP+XW3eib7Ya3XcI=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c h1:uOCk1iQW6Vc18bnC13MfzScl+wdKBmM9Y9kU7Z83/lw=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20170407050850-f3918c30c5c2/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190221075227-b4e8571b14e0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20211102061401-a2f17f7b995c h1:QOfDMdrf/UwlVR0UBq2Mpr58UzNtvgJRXA4BgPfFACs=
-golang.org/x/sys v0.0.0-20211102061401-a2f17f7b995c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211 h1:JGgROgKl9N8DuW20oFS5gxc+lE67/N3FcwmBPMe7ArY=
-golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b h1:ag/x1USPSsqHud38I9BAC88qdNLDHHtQ4mlgQIZPPNA=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
-golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
-gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
-gopkg.in/ozeidan/fuzzy-patricia.v3 v3.0.0 h1:KzcWKJ0nMAmGoBhYVMnkWc1rXjB42lKy5aIys4TdLOA=
-gopkg.in/ozeidan/fuzzy-patricia.v3 v3.0.0/go.mod h1:XoytMOotjRRJVkIsQdxsPIioRLYFISEaY9a4tftOXAo=
+gopkg.in/ini.v1 v1.46.0 h1:VeDZbLYGaupuvIrsYCEOe/L/2Pcs5n7hdO1ZTjporag=
+gopkg.in/ini.v1 v1.46.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/src-d/go-billy.v4 v4.2.0 h1:VGbrP1EsYxtvVPEiHui+4//imr4E5MGEFLx66bQtusg=
+gopkg.in/src-d/go-billy.v4 v4.2.0/go.mod h1:ZHSF0JP+7oD97194otDUCD7Ofbk63+xFcfWP5bT6h+Q=
+gopkg.in/src-d/go-git-fixtures.v3 v3.5.0 h1:ivZFOIltbce2Mo8IjzUHAFoq/IylO9WHhNOAJK+LsJg=
+gopkg.in/src-d/go-git-fixtures.v3 v3.5.0/go.mod h1:dLBcvytrw/TYZsNTWCnkNF2DSIlzWYqTe3rJR56Ac7g=
+gopkg.in/src-d/go-git.v4 v4.0.0-20180807092216-43d17e14b714 h1:+wM2BGgQ1znCKBexOB4OrGVSDw8mtKNUSq3wqxZhi/k=
+gopkg.in/src-d/go-git.v4 v4.0.0-20180807092216-43d17e14b714/go.mod h1:CzbUWqMn4pvmvndg3gnh5iZFmSsbhyhUWdI0IQ60AQo=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/warnings.v0 v0.1.2 h1:wFXVbFY8DY5/xOe1ECiWdKCzZlxgshcYVNkBHstARME=
 gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"bytes"
 	"fmt"
 	"log"
 	"os"
@@ -12,9 +11,6 @@ import (
 	"github.com/integrii/flaggy"
 	"github.com/jesseduffield/lazygit/pkg/app"
 	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/jesseduffield/lazygit/pkg/constants"
-	"github.com/jesseduffield/lazygit/pkg/env"
-	yaml "github.com/jesseduffield/yaml"
 )
 
 var (
@@ -24,14 +20,16 @@ var (
 	buildSource = "unknown"
 )
 
+func projectPath(path string) string {
+	gopath := os.Getenv("GOPATH")
+	return filepath.FromSlash(gopath + "/src/github.com/jesseduffield/lazygit/" + path)
+}
+
 func main() {
 	flaggy.DefaultParser.ShowVersionWithVersionFlag = false
 
-	repoPath := ""
-	flaggy.String(&repoPath, "p", "path", "Path of git repo. (equivalent to --work-tree=<path> --git-dir=<path>/.git/)")
-
-	filterPath := ""
-	flaggy.String(&filterPath, "f", "filter", "Path to filter on in `git log -- <path>`. When in filter mode, the commits, reflog, and stash are filtered based on the given path, and some operations are restricted")
+	repoPath := "."
+	flaggy.String(&repoPath, "p", "path", "Path of git repo")
 
 	dump := ""
 	flaggy.AddPositionalValue(&dump, "gitargs", 1, false, "Todo file")
@@ -41,84 +39,25 @@ func main() {
 	flaggy.Bool(&versionFlag, "v", "version", "Print the current version")
 
 	debuggingFlag := false
-	flaggy.Bool(&debuggingFlag, "d", "debug", "Run in debug mode with logging (see --logs flag below). Use the LOG_LEVEL env var to set the log level (debug/info/warn/error)")
-
-	logFlag := false
-	flaggy.Bool(&logFlag, "l", "logs", "Tail lazygit logs (intended to be used when `lazygit --debug` is called in a separate terminal tab)")
+	flaggy.Bool(&debuggingFlag, "d", "debug", "Run in debug mode with logging")
 
 	configFlag := false
-	flaggy.Bool(&configFlag, "c", "config", "Print the default config")
-
-	configDirFlag := false
-	flaggy.Bool(&configDirFlag, "cd", "print-config-dir", "Print the config directory")
-
-	useConfigDir := ""
-	flaggy.String(&useConfigDir, "ucd", "use-config-dir", "override default config directory with provided directory")
-
-	workTree := ""
-	flaggy.String(&workTree, "w", "work-tree", "equivalent of the --work-tree git argument")
-
-	gitDir := ""
-	flaggy.String(&gitDir, "g", "git-dir", "equivalent of the --git-dir git argument")
-
-	customConfig := ""
-	flaggy.String(&customConfig, "ucf", "use-config-file", "Comma seperated list to custom config file(s)")
+	flaggy.Bool(&configFlag, "c", "config", "Print the current default config")
 
 	flaggy.Parse()
 
-	if repoPath != "" {
-		if workTree != "" || gitDir != "" {
-			log.Fatal("--path option is incompatible with the --work-tree and --git-dir options")
-		}
-
-		workTree = repoPath
-		gitDir = filepath.Join(repoPath, ".git")
-	}
-
-	if customConfig != "" {
-		os.Setenv("LG_CONFIG_FILE", customConfig)
-	}
-
-	if useConfigDir != "" {
-		os.Setenv("CONFIG_DIR", useConfigDir)
-	}
-
-	if workTree != "" {
-		env.SetGitWorkTreeEnv(workTree)
-	}
-
-	if gitDir != "" {
-		env.SetGitDirEnv(gitDir)
-	}
-
 	if versionFlag {
 		fmt.Printf("commit=%s, build date=%s, build source=%s, version=%s, os=%s, arch=%s\n", commit, date, buildSource, version, runtime.GOOS, runtime.GOARCH)
 		os.Exit(0)
 	}
 
 	if configFlag {
-		var buf bytes.Buffer
-		encoder := yaml.NewEncoder(&buf)
-		err := encoder.Encode(config.GetDefaultConfig())
-		if err != nil {
-			log.Fatal(err.Error())
-		}
-		fmt.Printf("%s\n", buf.String())
+		fmt.Printf("%s\n", config.GetDefaultConfig())
 		os.Exit(0)
 	}
 
-	if configDirFlag {
-		fmt.Printf("%s\n", config.ConfigDir())
-		os.Exit(0)
-	}
-
-	if logFlag {
-		app.TailLogs()
-		os.Exit(0)
-	}
-
-	if workTree != "" {
-		if err := os.Chdir(workTree); err != nil {
+	if repoPath != "." {
+		if err := os.Chdir(repoPath); err != nil {
 			log.Fatal(err.Error())
 		}
 	}
@@ -128,7 +67,7 @@ func main() {
 		log.Fatal(err.Error())
 	}
 
-	app, err := app.NewApp(appConfig, filterPath)
+	app, err := app.NewApp(appConfig)
 
 	if err == nil {
 		err = app.Run()
@@ -142,6 +81,6 @@ func main() {
 		stackTrace := newErr.ErrorStack()
 		app.Log.Error(stackTrace)
 
-		log.Fatal(fmt.Sprintf("%s: %s\n\n%s", app.Tr.ErrorOccurred, constants.Links.Issues, stackTrace))
+		log.Fatal(fmt.Sprintf("%s\n\n%s", app.Tr.SLocalize("ErrorOccurred"), stackTrace))
 	}
 }

pkg/app/app.go

@@ -2,38 +2,33 @@ package app
 
 import (
 	"bufio"
-	"errors"
 	"fmt"
 	"io"
 	"io/ioutil"
-	"log"
 	"os"
 	"path/filepath"
-	"regexp"
-	"strconv"
 	"strings"
 
-	"github.com/aybabtme/humanlog"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/common"
 	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/jesseduffield/lazygit/pkg/env"
 	"github.com/jesseduffield/lazygit/pkg/gui"
 	"github.com/jesseduffield/lazygit/pkg/i18n"
 	"github.com/jesseduffield/lazygit/pkg/updates"
+	"github.com/jesseduffield/rollrus"
+	"github.com/shibukawa/configdir"
 	"github.com/sirupsen/logrus"
 )
 
 // App struct
 type App struct {
-	*common.Common
-	closers       []io.Closer
+	closers []io.Closer
+
 	Config        config.AppConfigurer
-	OSCommand     *oscommands.OSCommand
+	Log           *logrus.Entry
+	OSCommand     *commands.OSCommand
 	GitCommand    *commands.GitCommand
 	Gui           *gui.Gui
+	Tr            *i18n.Localizer
 	Updater       *updates.Updater // may only need this on the Gui
 	ClientContext string
 }
@@ -50,6 +45,12 @@ func newProductionLogger(config config.AppConfigurer) *logrus.Logger {
 	return log
 }
 
+func globalConfigDir() string {
+	configDirs := configdir.New("jesseduffield", "lazygit")
+	configDir := configDirs.QueryFolders(configdir.Global)[0]
+	return configDir.Path
+}
+
 func getLogLevel() logrus.Level {
 	strLevel := os.Getenv("LOG_LEVEL")
 	level, err := logrus.ParseLevel(strLevel)
@@ -59,24 +60,22 @@ func getLogLevel() logrus.Level {
 	return level
 }
 
-func newDevelopmentLogger(configurer config.AppConfigurer) *logrus.Logger {
-	logger := logrus.New()
-	logger.SetLevel(getLogLevel())
-	logPath, err := config.LogPath()
-	if err != nil {
-		log.Fatal(err)
-	}
-	file, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+func newDevelopmentLogger(config config.AppConfigurer) *logrus.Logger {
+	log := logrus.New()
+	log.SetLevel(getLogLevel())
+	file, err := os.OpenFile(filepath.Join(globalConfigDir(), "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)
 	}
-	logger.SetOutput(file)
-	return logger
+	log.SetOutput(file)
+	return log
 }
 
 func newLogger(config config.AppConfigurer) *logrus.Entry {
 	var log *logrus.Logger
+	environment := "production"
 	if config.GetDebug() || os.Getenv("DEBUG") == "TRUE" {
+		environment = "development"
 		log = newDevelopmentLogger(config)
 	} else {
 		log = newProductionLogger(config)
@@ -86,6 +85,11 @@ func newLogger(config config.AppConfigurer) *logrus.Entry {
 	// https://github.com/aybabtme/humanlog
 	log.Formatter = &logrus.JSONFormatter{}
 
+	if config.GetUserConfig().GetString("reporting") == "on" {
+		// this isn't really a secret token: it only has permission to push new rollbar items
+		hook := rollrus.NewHook("23432119147a4367abf7c0de2aa99a2d", environment)
+		log.Hooks.Add(hook)
+	}
 	return log.WithFields(logrus.Fields{
 		"debug":     config.GetDebug(),
 		"version":   config.GetVersion(),
@@ -95,26 +99,14 @@ func newLogger(config config.AppConfigurer) *logrus.Entry {
 }
 
 // NewApp bootstrap a new application
-func NewApp(config config.AppConfigurer, filterPath string) (*App, error) {
-	userConfig := config.GetUserConfig()
-
+func NewApp(config config.AppConfigurer) (*App, error) {
 	app := &App{
 		closers: []io.Closer{},
 		Config:  config,
 	}
 	var err error
-	log := newLogger(config)
-	tr, err := i18n.NewTranslationSetFromConfig(log, userConfig.Gui.Language)
-	if err != nil {
-		return app, err
-	}
-
-	app.Common = &common.Common{
-		Log:        log,
-		Tr:         tr,
-		UserConfig: userConfig,
-		Debug:      config.GetDebug(),
-	}
+	app.Log = newLogger(config)
+	app.Tr = i18n.NewLocalizer(app.Log)
 
 	// if we are being called in 'demon' mode, we can just return here
 	app.ClientContext = os.Getenv("LAZYGIT_CLIENT_COMMAND")
@@ -122,126 +114,44 @@ func NewApp(config config.AppConfigurer, filterPath string) (*App, error) {
 		return app, nil
 	}
 
-	app.OSCommand = oscommands.NewOSCommand(app.Common)
+	app.OSCommand = commands.NewOSCommand(app.Log, config)
 
-	app.Updater, err = updates.NewUpdater(app.Common, config, app.OSCommand)
+	app.Updater, err = updates.NewUpdater(app.Log, config, app.OSCommand, app.Tr)
 	if err != nil {
 		return app, err
 	}
 
-	showRecentRepos, err := app.setupRepo()
-	if err != nil {
+	if err := app.setupRepo(); err != nil {
 		return app, err
 	}
 
-	app.GitCommand, err = commands.NewGitCommand(
-		app.Common,
-		app.OSCommand,
-		git_config.NewStdCachedGitConfig(app.Log),
-	)
+	app.GitCommand, err = commands.NewGitCommand(app.Log, app.OSCommand, app.Tr, app.Config)
 	if err != nil {
 		return app, err
 	}
-
-	app.Gui, err = gui.NewGui(app.Common, app.GitCommand, app.OSCommand, config, app.Updater, filterPath, showRecentRepos)
+	app.Gui, err = gui.NewGui(app.Log, app.GitCommand, app.OSCommand, app.Tr, config, app.Updater)
 	if err != nil {
 		return app, err
 	}
 	return app, nil
 }
 
-func (app *App) validateGitVersion() error {
-	output, err := app.OSCommand.Cmd.New("git --version").RunWithOutput()
-	// if we get an error anywhere here we'll show the same status
-	minVersionError := errors.New(app.Tr.MinGitVersionError)
-	if err != nil {
-		return minVersionError
-	}
-
-	if isGitVersionValid(output) {
-		return nil
-	}
-
-	return minVersionError
-}
-
-func isGitVersionValid(versionStr string) bool {
-	// output should be something like: 'git version 2.23.0 (blah)'
-	re := regexp.MustCompile(`[^\d]+([\d\.]+)`)
-	matches := re.FindStringSubmatch(versionStr)
-
-	if len(matches) == 0 {
-		return false
-	}
-
-	gitVersion := matches[1]
-	majorVersion, err := strconv.Atoi(gitVersion[0:1])
-	if err != nil {
-		return false
-	}
-	if majorVersion < 2 {
-		return false
-	}
-
-	return true
-}
-
-func (app *App) setupRepo() (bool, error) {
-	if err := app.validateGitVersion(); err != nil {
-		return false, err
-	}
-
-	if env.GetGitDirEnv() != "" {
-		// we've been given the git dir directly. We'll verify this dir when initializing our GitCommand object
-		return false, nil
-	}
-
+func (app *App) setupRepo() error {
 	// if we are not in a git repo, we ask if we want to `git init`
-	if err := commands.VerifyInGitRepo(app.OSCommand); err != nil {
-		cwd, err := os.Getwd()
-		if err != nil {
-			return false, err
+	if err := app.OSCommand.RunCommand("git status"); err != nil {
+		if !strings.Contains(err.Error(), "Not a git repository") {
+			return err
 		}
-		info, _ := os.Stat(filepath.Join(cwd, ".git"))
-		if info != nil && info.IsDir() {
-			return false, err // Current directory appears to be a git repository.
-		}
-
-		shouldInitRepo := true
-		notARepository := app.UserConfig.NotARepository
-		if notARepository == "prompt" {
-			// Offer to initialize a new repository in current directory.
-			fmt.Print(app.Tr.CreateRepo)
-			response, _ := bufio.NewReader(os.Stdin).ReadString('\n')
-			if strings.Trim(response, " \n") != "y" {
-				shouldInitRepo = false
-			}
-		} else if notARepository == "skip" {
-			shouldInitRepo = false
-		}
-
-		if !shouldInitRepo {
-			// check if we have a recent repo we can open
-			recentRepos := app.Config.GetAppState().RecentRepos
-			if len(recentRepos) > 0 {
-				var err error
-				// try opening each repo in turn, in case any have been deleted
-				for _, repoDir := range recentRepos {
-					if err = os.Chdir(repoDir); err == nil {
-						return true, nil
-					}
-				}
-				return false, err
-			}
-
+		fmt.Print(app.Tr.SLocalize("CreateRepo"))
+		response, _ := bufio.NewReader(os.Stdin).ReadString('\n')
+		if strings.Trim(response, " \n") != "y" {
 			os.Exit(1)
 		}
-		if err := app.OSCommand.Cmd.New("git init").Run(); err != nil {
-			return false, err
+		if err := app.OSCommand.RunCommand("git init"); err != nil {
+			return err
 		}
 	}
-
-	return false, nil
+	return nil
 }
 
 func (app *App) Run() error {
@@ -253,18 +163,10 @@ func (app *App) Run() error {
 		os.Exit(0)
 	}
 
-	err := app.Gui.RunAndHandleError()
+	err := app.Gui.RunWithSubprocesses()
 	return err
 }
 
-func gitDir() string {
-	dir := env.GetGitDirEnv()
-	if dir == "" {
-		return ".git"
-	}
-	return dir
-}
-
 // Rebase contains logic for when we've been run in demon mode, meaning we've
 // given lazygit as a command for git to call e.g. to edit a file
 func (app *App) Rebase() error {
@@ -276,7 +178,7 @@ func (app *App) Rebase() error {
 			return err
 		}
 
-	} else if strings.HasSuffix(os.Args[1], filepath.Join(gitDir(), "COMMIT_EDITMSG")) { // TODO: test
+	} else if strings.HasSuffix(os.Args[1], ".git/COMMIT_EDITMSG") {
 		// if we are rebasing and squashing, we'll see a COMMIT_EDITMSG
 		// but in this case we don't need to edit it, so we'll just return
 	} else {
@@ -301,18 +203,10 @@ func (app *App) Close() error {
 func (app *App) KnownError(err error) (string, bool) {
 	errorMessage := err.Error()
 
-	knownErrorMessages := []string{app.Tr.MinGitVersionError}
-
-	for _, message := range knownErrorMessages {
-		if errorMessage == message {
-			return message, true
-		}
-	}
-
 	mappings := []errorMapping{
 		{
-			originalError: "fatal: not a git repository",
-			newError:      app.Tr.NotARepository,
+			originalError: "fatal: not a git repository (or any of the parent directories): .git",
+			newError:      app.Tr.SLocalize("notARepository"),
 		},
 	}
 
@@ -323,25 +217,3 @@ func (app *App) KnownError(err error) (string, bool) {
 	}
 	return "", false
 }
-
-func TailLogs() {
-	logFilePath, err := config.LogPath()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	fmt.Printf("Tailing log file %s\n\n", logFilePath)
-
-	opts := humanlog.DefaultOptions
-	opts.Truncates = false
-
-	_, err = os.Stat(logFilePath)
-	if err != nil {
-		if os.IsNotExist(err) {
-			log.Fatal("Log file does not exist. Run `lazygit --debug` first to create the log file")
-		}
-		log.Fatal(err)
-	}
-
-	TailLogsForPlatform(logFilePath, opts)
-}

pkg/app/app_test.go

@@ -1,44 +0,0 @@
-package app
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestIsGitVersionValid(t *testing.T) {
-	type scenario struct {
-		versionStr     string
-		expectedResult bool
-	}
-
-	scenarios := []scenario{
-		{
-			"",
-			false,
-		},
-		{
-			"git version 1.9.0",
-			false,
-		},
-		{
-			"git version 1.9.0 (Apple Git-128)",
-			false,
-		},
-		{
-			"git version 2.4.0",
-			true,
-		},
-		{
-			"git version 2.24.3 (Apple Git-128)",
-			true,
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.versionStr, func(t *testing.T) {
-			result := isGitVersionValid(s.versionStr)
-			assert.Equal(t, result, s.expectedResult)
-		})
-	}
-}

pkg/app/logging.go

@@ -1,30 +0,0 @@
-//go:build !windows
-// +build !windows
-
-package app
-
-import (
-	"github.com/aybabtme/humanlog"
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"log"
-	"os"
-)
-
-func TailLogsForPlatform(logFilePath string, opts *humanlog.HandlerOptions) {
-	cmd := secureexec.Command("tail", "-f", logFilePath)
-
-	stdout, _ := cmd.StdoutPipe()
-	if err := cmd.Start(); err != nil {
-		log.Fatal(err)
-	}
-
-	if err := humanlog.Scanner(stdout, os.Stdout, opts); err != nil {
-		log.Fatal(err)
-	}
-
-	if err := cmd.Wait(); err != nil {
-		log.Fatal(err)
-	}
-
-	os.Exit(0)
-}

pkg/app/logging_windows.go

@@ -1,72 +0,0 @@
-//go:build windows
-// +build windows
-
-package app
-
-import (
-	"bufio"
-	"github.com/aybabtme/humanlog"
-	"log"
-	"os"
-	"strings"
-	"time"
-)
-
-func TailLogsForPlatform(logFilePath string, opts *humanlog.HandlerOptions) {
-	var lastModified int64 = 0
-	var lastOffset int64 = 0
-	for {
-		stat, err := os.Stat(logFilePath)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if stat.ModTime().Unix() > lastModified {
-			err = TailFrom(lastOffset, logFilePath, opts)
-			if err != nil {
-				log.Fatal(err)
-			}
-		}
-		lastOffset = stat.Size()
-		time.Sleep(1 * time.Second)
-	}
-}
-
-func OpenAndSeek(filepath string, offset int64) (*os.File, error) {
-	file, err := os.Open(filepath)
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = file.Seek(offset, 0)
-	if err != nil {
-		_ = file.Close()
-		return nil, err
-	}
-	return file, nil
-}
-
-func TailFrom(lastOffset int64, logFilePath string, opts *humanlog.HandlerOptions) error {
-	file, err := OpenAndSeek(logFilePath, lastOffset)
-	if err != nil {
-		return err
-	}
-
-	fileScanner := bufio.NewScanner(file)
-	var lines []string
-	for fileScanner.Scan() {
-		lines = append(lines, fileScanner.Text())
-	}
-	file.Close()
-	lineCount := len(lines)
-	lastTen := lines
-	if lineCount > 10 {
-		lastTen = lines[lineCount-10:]
-	}
-	for _, line := range lastTen {
-		reader := strings.NewReader(line)
-		if err := humanlog.Scanner(reader, os.Stdout, opts); err != nil {
-			log.Fatal(err)
-		}
-	}
-	return nil
-}

pkg/commands/branch.go

@@ -0,0 +1,50 @@
+package commands
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/theme"
+
+	"github.com/fatih/color"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
+// Branch : A git branch
+// duplicating this for now
+type Branch struct {
+	Name      string
+	Recency   string
+	Pushables string
+	Pullables string
+	Selected  bool
+}
+
+// GetDisplayStrings returns the display string of branch
+func (b *Branch) GetDisplayStrings(isFocused bool) []string {
+	displayName := utils.ColoredString(b.Name, b.GetColor())
+	if isFocused && b.Selected && b.Pushables != "" && b.Pullables != "" {
+		displayName = fmt.Sprintf("%s ↑%s↓%s", displayName, b.Pushables, b.Pullables)
+	}
+
+	return []string{b.Recency, displayName}
+}
+
+// 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 theme.DefaultTextColor
+	}
+}
+
+// expected to return feature/bugfix/hotfix or blank string
+func (b *Branch) getType() string {
+	return strings.Split(b.Name, "/")[0]
+}

pkg/commands/branch_list_builder.go

@@ -0,0 +1,164 @@
+package commands
+
+import (
+	"regexp"
+	"strings"
+
+	"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
+
+// if we find out we need to use one of these functions in the git.go file, we
+// can just pull them out of here and put them there and then call them from in here
+
+// BranchListBuilder returns a list of Branch objects for the current repo
+type BranchListBuilder struct {
+	Log        *logrus.Entry
+	GitCommand *GitCommand
+}
+
+// NewBranchListBuilder builds a new branch list builder
+func NewBranchListBuilder(log *logrus.Entry, gitCommand *GitCommand) (*BranchListBuilder, error) {
+	return &BranchListBuilder{
+		Log:        log,
+		GitCommand: gitCommand,
+	}, nil
+}
+
+func (b *BranchListBuilder) obtainCurrentBranch() *Branch {
+	branchName, err := b.GitCommand.CurrentBranchName()
+	if err != nil {
+		panic(err.Error())
+	}
+
+	return &Branch{Name: strings.TrimSpace(branchName)}
+}
+
+func (b *BranchListBuilder) obtainReflogBranches() []*Branch {
+	branches := make([]*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 := &Branch{Name: branchName, Recency: timeNumber + timeUnit}
+		branches = append(branches, branch)
+	}
+	return uniqueByName(branches)
+}
+
+func (b *BranchListBuilder) obtainSafeBranches() []*Branch {
+	branches := make([]*Branch, 0)
+
+	bIter, err := b.GitCommand.Repo.Branches()
+	if err != nil {
+		panic(err)
+	}
+	bIter.ForEach(func(b *plumbing.Reference) error {
+		name := b.Name().Short()
+		branches = append(branches, &Branch{Name: name})
+		return nil
+	})
+
+	return branches
+}
+
+func (b *BranchListBuilder) appendNewBranches(finalBranches, newBranches, existingBranches []*Branch, included bool) []*Branch {
+	for _, newBranch := range newBranches {
+		if included == branchIncluded(newBranch.Name, existingBranches) {
+			finalBranches = append(finalBranches, newBranch)
+		}
+	}
+	return finalBranches
+}
+
+func sanitisedReflogName(reflogBranch *Branch, safeBranches []*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() []*Branch {
+	branches := make([]*Branch, 0)
+	head := b.obtainCurrentBranch()
+	safeBranches := b.obtainSafeBranches()
+
+	reflogBranches := b.obtainReflogBranches()
+	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)
+
+	if len(branches) == 0 || branches[0].Name != head.Name {
+		branches = append([]*Branch{head}, branches...)
+	}
+
+	branches[0].Recency = "  *"
+
+	return branches
+}
+
+func branchIncluded(branchName string, branches []*Branch) bool {
+	for _, existingBranch := range branches {
+		if strings.ToLower(existingBranch.Name) == strings.ToLower(branchName) {
+			return true
+		}
+	}
+	return false
+}
+
+func uniqueByName(branches []*Branch) []*Branch {
+	finalBranches := make([]*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/commands/branches.go

@@ -1,173 +0,0 @@
-package commands
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// NewBranch create new branch
-func (c *GitCommand) NewBranch(name string, base string) error {
-	return c.Cmd.New(fmt.Sprintf("git checkout -b %s %s", c.OSCommand.Quote(name), c.OSCommand.Quote(base))).Run()
-}
-
-// CurrentBranchName get the current branch name and displayname.
-// the first returned string is the name and the second is the displayname
-// e.g. name is 123asdf and displayname is '(HEAD detached at 123asdf)'
-func (c *GitCommand) CurrentBranchName() (string, string, error) {
-	branchName, err := c.Cmd.New("git symbolic-ref --short HEAD").RunWithOutput()
-	if err == nil && branchName != "HEAD\n" {
-		trimmedBranchName := strings.TrimSpace(branchName)
-		return trimmedBranchName, trimmedBranchName, nil
-	}
-	output, err := c.Cmd.New("git branch --contains").RunWithOutput()
-	if err != nil {
-		return "", "", err
-	}
-	for _, line := range utils.SplitLines(output) {
-		re := regexp.MustCompile(CurrentBranchNameRegex)
-		match := re.FindStringSubmatch(line)
-		if len(match) > 0 {
-			branchName = match[1]
-			displayBranchName := match[0][2:]
-			return branchName, displayBranchName, nil
-		}
-	}
-	return "HEAD", "HEAD", nil
-}
-
-// DeleteBranch delete branch
-func (c *GitCommand) DeleteBranch(branch string, force bool) error {
-	command := "git branch -d"
-
-	if force {
-		command = "git branch -D"
-	}
-
-	return c.Cmd.New(fmt.Sprintf("%s %s", command, c.OSCommand.Quote(branch))).Run()
-}
-
-// Checkout checks out a branch (or commit), with --force if you set the force arg to true
-type CheckoutOptions struct {
-	Force   bool
-	EnvVars []string
-}
-
-func (c *GitCommand) Checkout(branch string, options CheckoutOptions) error {
-	forceArg := ""
-	if options.Force {
-		forceArg = " --force"
-	}
-
-	return c.Cmd.New(fmt.Sprintf("git checkout%s %s", forceArg, c.OSCommand.Quote(branch))).
-		// prevents git from prompting us for input which would freeze the program
-		// TODO: see if this is actually needed here
-		AddEnvVars("GIT_TERMINAL_PROMPT=0").
-		AddEnvVars(options.EnvVars...).
-		Run()
-}
-
-// 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.GetBranchGraphCmdObj(branchName).RunWithOutput()
-}
-
-func (c *GitCommand) GetUpstreamForBranch(branchName string) (string, error) {
-	output, err := c.Cmd.New(fmt.Sprintf("git rev-parse --abbrev-ref --symbolic-full-name %s@{u}", c.OSCommand.Quote(branchName))).RunWithOutput()
-	return strings.TrimSpace(output), err
-}
-
-func (c *GitCommand) GetBranchGraphCmdObj(branchName string) oscommands.ICmdObj {
-	branchLogCmdTemplate := c.UserConfig.Git.BranchLogCmd
-	templateValues := map[string]string{
-		"branchName": c.OSCommand.Quote(branchName),
-	}
-	return c.Cmd.New(utils.ResolvePlaceholderString(branchLogCmdTemplate, templateValues))
-}
-
-func (c *GitCommand) SetUpstreamBranch(upstream string) error {
-	return c.Cmd.New("git branch -u " + c.OSCommand.Quote(upstream)).Run()
-}
-
-func (c *GitCommand) SetBranchUpstream(remoteName string, remoteBranchName string, branchName string) error {
-	return c.Cmd.New(fmt.Sprintf("git branch --set-upstream-to=%s/%s %s", c.OSCommand.Quote(remoteName), c.OSCommand.Quote(remoteBranchName), c.OSCommand.Quote(branchName))).Run()
-}
-
-func (c *GitCommand) GetCurrentBranchUpstreamDifferenceCount() (string, string) {
-	return c.GetCommitDifferences("HEAD", "HEAD@{u}")
-}
-
-func (c *GitCommand) GetBranchUpstreamDifferenceCount(branchName string) (string, string) {
-	return c.GetCommitDifferences(branchName, branchName+"@{u}")
-}
-
-// GetCommitDifferences checks how many pushables/pullables there are for the
-// current branch
-func (c *GitCommand) GetCommitDifferences(from, to string) (string, string) {
-	command := "git rev-list %s..%s --count"
-	pushableCount, err := c.Cmd.New(fmt.Sprintf(command, to, from)).RunWithOutput()
-	if err != nil {
-		return "?", "?"
-	}
-	pullableCount, err := c.Cmd.New(fmt.Sprintf(command, from, to)).RunWithOutput()
-	if err != nil {
-		return "?", "?"
-	}
-	return strings.TrimSpace(pushableCount), strings.TrimSpace(pullableCount)
-}
-
-type MergeOpts struct {
-	FastForwardOnly bool
-}
-
-// Merge merge
-func (c *GitCommand) Merge(branchName string, opts MergeOpts) error {
-	mergeArg := ""
-	if c.UserConfig.Git.Merging.Args != "" {
-		mergeArg = " " + c.UserConfig.Git.Merging.Args
-	}
-
-	command := fmt.Sprintf("git merge --no-edit%s %s", mergeArg, c.OSCommand.Quote(branchName))
-	if opts.FastForwardOnly {
-		command = fmt.Sprintf("%s --ff-only", command)
-	}
-
-	return c.OSCommand.Cmd.New(command).Run()
-}
-
-// AbortMerge abort merge
-func (c *GitCommand) AbortMerge() error {
-	return c.Cmd.New("git merge --abort").Run()
-}
-
-func (c *GitCommand) IsHeadDetached() bool {
-	err := c.Cmd.New("git symbolic-ref -q HEAD").Run()
-	return err != nil
-}
-
-// ResetHardHead runs `git reset --hard`
-func (c *GitCommand) ResetHard(ref string) error {
-	return c.Cmd.New("git reset --hard " + c.OSCommand.Quote(ref)).Run()
-}
-
-// ResetSoft runs `git reset --soft HEAD`
-func (c *GitCommand) ResetSoft(ref string) error {
-	return c.Cmd.New("git reset --soft " + c.OSCommand.Quote(ref)).Run()
-}
-
-func (c *GitCommand) ResetMixed(ref string) error {
-	return c.Cmd.New("git reset --mixed " + c.OSCommand.Quote(ref)).Run()
-}
-
-func (c *GitCommand) RenameBranch(oldName string, newName string) error {
-	return c.Cmd.New(fmt.Sprintf("git branch --move %s %s", c.OSCommand.Quote(oldName), c.OSCommand.Quote(newName))).Run()
-}
-
-func (c *GitCommand) GetRawBranches() (string, error) {
-	return c.Cmd.New(`git for-each-ref --sort=-committerdate --format="%(HEAD)|%(refname:short)|%(upstream:short)|%(upstream:track)" refs/heads`).RunWithOutput()
-}

pkg/commands/branches_test.go

@@ -1,250 +0,0 @@
-package commands
-
-import (
-	"testing"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGitCommandGetCommitDifferences(t *testing.T) {
-	type scenario struct {
-		testName          string
-		runner            *oscommands.FakeCmdObjRunner
-		expectedPushables string
-		expectedPullables string
-	}
-
-	scenarios := []scenario{
-		{
-			"Can't retrieve pushable count",
-			oscommands.NewFakeRunner(t).
-				Expect("git rev-list @{u}..HEAD --count", "", errors.New("error")),
-			"?", "?",
-		},
-		{
-			"Can't retrieve pullable count",
-			oscommands.NewFakeRunner(t).
-				Expect("git rev-list @{u}..HEAD --count", "1\n", nil).
-				Expect("git rev-list HEAD..@{u} --count", "", errors.New("error")),
-			"?", "?",
-		},
-		{
-			"Retrieve pullable and pushable count",
-			oscommands.NewFakeRunner(t).
-				Expect("git rev-list @{u}..HEAD --count", "1\n", nil).
-				Expect("git rev-list HEAD..@{u} --count", "2\n", nil),
-			"1", "2",
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			pushables, pullables := gitCmd.GetCommitDifferences("HEAD", "@{u}")
-			assert.EqualValues(t, s.expectedPushables, pushables)
-			assert.EqualValues(t, s.expectedPullables, pullables)
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandNewBranch(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		Expect(`git checkout -b "test" "master"`, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-
-	assert.NoError(t, gitCmd.NewBranch("test", "master"))
-	runner.CheckForMissingCalls()
-}
-
-func TestGitCommandDeleteBranch(t *testing.T) {
-	type scenario struct {
-		testName string
-		force    bool
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"Delete a branch",
-			false,
-			oscommands.NewFakeRunner(t).Expect(`git branch -d "test"`, "", nil),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			"Force delete a branch",
-			true,
-			oscommands.NewFakeRunner(t).Expect(`git branch -D "test"`, "", nil),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-
-			s.test(gitCmd.DeleteBranch("test", s.force))
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandMerge(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		Expect(`git merge --no-edit "test"`, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-
-	assert.NoError(t, gitCmd.Merge("test", MergeOpts{}))
-	runner.CheckForMissingCalls()
-}
-
-func TestGitCommandCheckout(t *testing.T) {
-	type scenario struct {
-		testName string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-		force    bool
-	}
-
-	scenarios := []scenario{
-		{
-			"Checkout",
-			oscommands.NewFakeRunner(t).Expect(`git checkout "test"`, "", nil),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-			false,
-		},
-		{
-			"Checkout forced",
-			oscommands.NewFakeRunner(t).Expect(`git checkout --force "test"`, "", nil),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-			true,
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.Checkout("test", CheckoutOptions{Force: s.force}))
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandGetBranchGraph(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).ExpectArgs([]string{
-		"git", "log", "--graph", "--color=always", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium", "test", "--",
-	}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-	_, err := gitCmd.GetBranchGraph("test")
-	assert.NoError(t, err)
-}
-
-func TestGitCommandGetAllBranchGraph(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).ExpectArgs([]string{
-		"git", "log", "--graph", "--all", "--color=always", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium",
-	}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-	cmdStr := gitCmd.UserConfig.Git.AllBranchesLogCmd
-	_, err := gitCmd.Cmd.New(cmdStr).RunWithOutput()
-	assert.NoError(t, err)
-}
-
-func TestGitCommandCurrentBranchName(t *testing.T) {
-	type scenario struct {
-		testName string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(string, string, error)
-	}
-
-	scenarios := []scenario{
-		{
-			"says we are on the master branch if we are",
-			oscommands.NewFakeRunner(t).Expect(`git symbolic-ref --short HEAD`, "master", nil),
-			func(name string, displayname string, err error) {
-				assert.NoError(t, err)
-				assert.EqualValues(t, "master", name)
-				assert.EqualValues(t, "master", displayname)
-			},
-		},
-		{
-			"falls back to git `git branch --contains` if symbolic-ref fails",
-			oscommands.NewFakeRunner(t).
-				Expect(`git symbolic-ref --short HEAD`, "", errors.New("error")).
-				Expect(`git branch --contains`, "* master", nil),
-			func(name string, displayname string, err error) {
-				assert.NoError(t, err)
-				assert.EqualValues(t, "master", name)
-				assert.EqualValues(t, "master", displayname)
-			},
-		},
-		{
-			"handles a detached head",
-			oscommands.NewFakeRunner(t).
-				Expect(`git symbolic-ref --short HEAD`, "", errors.New("error")).
-				Expect(`git branch --contains`, "* (HEAD detached at 123abcd)", nil),
-			func(name string, displayname string, err error) {
-				assert.NoError(t, err)
-				assert.EqualValues(t, "123abcd", name)
-				assert.EqualValues(t, "(HEAD detached at 123abcd)", displayname)
-			},
-		},
-		{
-			"bubbles up error if there is one",
-			oscommands.NewFakeRunner(t).
-				Expect(`git symbolic-ref --short HEAD`, "", errors.New("error")).
-				Expect(`git branch --contains`, "", errors.New("error")),
-			func(name string, displayname string, err error) {
-				assert.Error(t, err)
-				assert.EqualValues(t, "", name)
-				assert.EqualValues(t, "", displayname)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.CurrentBranchName())
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandResetHard(t *testing.T) {
-	type scenario struct {
-		testName string
-		ref      string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			"valid case",
-			"HEAD",
-			oscommands.NewFakeRunner(t).
-				Expect(`git reset --hard "HEAD"`, "", nil),
-			func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.ResetHard(s.ref))
-		})
-	}
-}

pkg/commands/commit.go

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

pkg/commands/commit_file.go

@@ -0,0 +1,42 @@
+package commands
+
+import (
+	"github.com/fatih/color"
+	"github.com/jesseduffield/lazygit/pkg/theme"
+)
+
+// CommitFile : A git commit file
+type CommitFile struct {
+	Sha           string
+	Name          string
+	DisplayString string
+	Status        int // one of 'WHOLE' 'PART' 'NONE'
+}
+
+const (
+	// UNSELECTED is for when the commit file has not been added to the patch in any way
+	UNSELECTED = iota
+	// WHOLE is for when you want to add the whole diff of a file to the patch,
+	// including e.g. if it was deleted
+	WHOLE = iota
+	// PART is for when you're only talking about specific lines that have been modified
+	PART
+)
+
+// GetDisplayStrings is a function.
+func (f *CommitFile) GetDisplayStrings(isFocused bool) []string {
+	yellow := color.New(color.FgYellow)
+	green := color.New(color.FgGreen)
+	defaultColor := color.New(theme.DefaultTextColor)
+
+	var colour *color.Color
+	switch f.Status {
+	case UNSELECTED:
+		colour = defaultColor
+	case WHOLE:
+		colour = green
+	case PART:
+		colour = yellow
+	}
+	return []string{colour.Sprint(f.DisplayString)}
+}

pkg/commands/commit_list_builder.go

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

pkg/commands/commit_list_builder_test.go

@@ -0,0 +1,314 @@
+package commands
+
+import (
+	"os/exec"
+	"testing"
+
+	"github.com/jesseduffield/lazygit/pkg/i18n"
+	"github.com/stretchr/testify/assert"
+)
+
+// NewDummyCommitListBuilder creates a new dummy CommitListBuilder for testing
+func NewDummyCommitListBuilder() *CommitListBuilder {
+	osCommand := NewDummyOSCommand()
+
+	return &CommitListBuilder{
+		Log:                 NewDummyLog(),
+		GitCommand:          NewDummyGitCommandWithOSCommand(osCommand),
+		OSCommand:           osCommand,
+		Tr:                  i18n.NewLocalizer(NewDummyLog()),
+		CherryPickedCommits: []*Commit{},
+	}
+}
+
+// TestCommitListBuilderGetUnpushedCommits is a function.
+func TestCommitListBuilderGetUnpushedCommits(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		test     func(map[string]bool)
+	}
+
+	scenarios := []scenario{
+		{
+			"Can't retrieve pushable commits",
+			func(string, ...string) *exec.Cmd {
+				return exec.Command("test")
+			},
+			func(pushables map[string]bool) {
+				assert.EqualValues(t, map[string]bool{}, pushables)
+			},
+		},
+		{
+			"Retrieve pushable commits",
+			func(cmd string, args ...string) *exec.Cmd {
+				return exec.Command("echo", "8a2bb0e\n78976bc")
+			},
+			func(pushables map[string]bool) {
+				assert.Len(t, pushables, 2)
+				assert.EqualValues(t, map[string]bool{"8a2bb0e": true, "78976bc": true}, pushables)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			c := NewDummyCommitListBuilder()
+			c.OSCommand.SetCommand(s.command)
+			s.test(c.getUnpushedCommits())
+		})
+	}
+}
+
+// TestCommitListBuilderGetMergeBase is a function.
+func TestCommitListBuilderGetMergeBase(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		test     func(string, error)
+	}
+
+	scenarios := []scenario{
+		{
+			"swallows an error if the call to merge-base returns an error",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "master")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("test")
+				}
+				return nil
+			},
+			func(output string, err error) {
+				assert.NoError(t, err)
+				assert.EqualValues(t, "", output)
+			},
+		},
+		{
+			"returns the commit when master",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "master")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("echo", "blah")
+				}
+				return nil
+			},
+			func(output string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, "blah\n", output)
+			},
+		},
+		{
+			"checks against develop when a feature branch",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "feature/test")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "develop"}, args)
+					return exec.Command("echo", "blah")
+				}
+				return nil
+			},
+			func(output string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, "blah\n", output)
+			},
+		},
+		{
+			"bubbles up error if there is one",
+			func(cmd string, args ...string) *exec.Cmd {
+				return exec.Command("test")
+			},
+			func(output string, err error) {
+				assert.Error(t, err)
+				assert.Equal(t, "", output)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			c := NewDummyCommitListBuilder()
+			c.OSCommand.SetCommand(s.command)
+			s.test(c.getMergeBase())
+		})
+	}
+}
+
+// TestCommitListBuilderGetLog is a function.
+func TestCommitListBuilderGetLog(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		test     func(string)
+	}
+
+	scenarios := []scenario{
+		{
+			"Retrieves logs",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"log", "--oneline", "-30"}, args)
+
+				return exec.Command("echo", "6f0b32f commands/git : add GetCommits tests refactor\n9d9d775 circle : remove new line")
+			},
+			func(output string) {
+				assert.EqualValues(t, "6f0b32f commands/git : add GetCommits tests refactor\n9d9d775 circle : remove new line\n", output)
+			},
+		},
+		{
+			"An error occurred when retrieving logs",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"log", "--oneline", "-30"}, args)
+				return exec.Command("test")
+			},
+			func(output string) {
+				assert.Empty(t, output)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			c := NewDummyCommitListBuilder()
+			c.OSCommand.SetCommand(s.command)
+			s.test(c.getLog())
+		})
+	}
+}
+
+// TestCommitListBuilderGetCommits is a function.
+func TestCommitListBuilderGetCommits(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		test     func([]*Commit, error)
+	}
+
+	scenarios := []scenario{
+		{
+			"No data found",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "rev-list":
+					assert.EqualValues(t, []string{"rev-list", "@{u}..HEAD", "--abbrev-commit"}, args)
+					return exec.Command("echo")
+				case "log":
+					assert.EqualValues(t, []string{"log", "--oneline", "-30"}, args)
+					return exec.Command("echo")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("test")
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "master")
+				}
+
+				return nil
+			},
+			func(commits []*Commit, err error) {
+				assert.NoError(t, err)
+				assert.Len(t, commits, 0)
+			},
+		},
+		{
+			"GetCommits returns 2 commits, 1 unpushed, the other merged",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "rev-list":
+					assert.EqualValues(t, []string{"rev-list", "@{u}..HEAD", "--abbrev-commit"}, args)
+					return exec.Command("echo", "8a2bb0e")
+				case "log":
+					assert.EqualValues(t, []string{"log", "--oneline", "-30"}, args)
+					return exec.Command("echo", "8a2bb0e commit 1\n78976bc commit 2")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("echo", "78976bc")
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "master")
+				}
+
+				return nil
+			},
+			func(commits []*Commit, err error) {
+				assert.NoError(t, err)
+				assert.Len(t, commits, 2)
+				assert.EqualValues(t, []*Commit{
+					{
+						Sha:           "8a2bb0e",
+						Name:          "commit 1",
+						Status:        "unpushed",
+						DisplayString: "8a2bb0e commit 1",
+					},
+					{
+						Sha:           "78976bc",
+						Name:          "commit 2",
+						Status:        "merged",
+						DisplayString: "78976bc commit 2",
+					},
+				}, commits)
+			},
+		},
+		{
+			"GetCommits bubbles up an error from setCommitMergedStatuses",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "rev-list":
+					assert.EqualValues(t, []string{"rev-list", "@{u}..HEAD", "--abbrev-commit"}, args)
+					return exec.Command("echo", "8a2bb0e")
+				case "log":
+					assert.EqualValues(t, []string{"log", "--oneline", "-30"}, args)
+					return exec.Command("echo", "8a2bb0e commit 1\n78976bc commit 2")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("echo", "78976bc")
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					// here's where we are returning the error
+					return exec.Command("test")
+				case "rev-parse":
+					assert.EqualValues(t, []string{"rev-parse", "--short", "HEAD"}, args)
+					// here too
+					return exec.Command("test")
+				}
+
+				return nil
+			},
+			func(commits []*Commit, err error) {
+				assert.Error(t, err)
+				assert.Len(t, commits, 0)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			c := NewDummyCommitListBuilder()
+			c.OSCommand.SetCommand(s.command)
+			s.test(c.GetCommits())
+		})
+	}
+}

pkg/commands/commits.go

@@ -1,105 +0,0 @@
-package commands
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-)
-
-// RenameCommit renames the topmost commit with the given name
-func (c *GitCommand) RenameCommit(name string) error {
-	return c.Cmd.New("git commit --allow-empty --amend --only -m " + c.OSCommand.Quote(name)).Run()
-}
-
-// ResetToCommit reset to commit
-func (c *GitCommand) ResetToCommit(sha string, strength string, envVars []string) error {
-	return c.Cmd.New(fmt.Sprintf("git reset --%s %s", strength, sha)).
-		// prevents git from prompting us for input which would freeze the program
-		// TODO: see if this is actually needed here
-		AddEnvVars("GIT_TERMINAL_PROMPT=0").
-		AddEnvVars(envVars...).
-		Run()
-}
-
-func (c *GitCommand) CommitCmdObj(message string, flags string) oscommands.ICmdObj {
-	splitMessage := strings.Split(message, "\n")
-	lineArgs := ""
-	for _, line := range splitMessage {
-		lineArgs += fmt.Sprintf(" -m %s", c.OSCommand.Quote(line))
-	}
-
-	flagsStr := ""
-	if flags != "" {
-		flagsStr = fmt.Sprintf(" %s", flags)
-	}
-
-	return c.Cmd.New(fmt.Sprintf("git commit%s%s", flagsStr, lineArgs))
-}
-
-// Get the subject of the HEAD commit
-func (c *GitCommand) GetHeadCommitMessage() (string, error) {
-	message, err := c.Cmd.New("git log -1 --pretty=%s").RunWithOutput()
-	return strings.TrimSpace(message), err
-}
-
-func (c *GitCommand) GetCommitMessage(commitSha string) (string, error) {
-	cmdStr := "git rev-list --format=%B --max-count=1 " + commitSha
-	messageWithHeader, err := c.Cmd.New(cmdStr).RunWithOutput()
-	message := strings.Join(strings.SplitAfter(messageWithHeader, "\n")[1:], "\n")
-	return strings.TrimSpace(message), err
-}
-
-func (c *GitCommand) GetCommitMessageFirstLine(sha string) (string, error) {
-	return c.Cmd.New(fmt.Sprintf("git show --no-patch --pretty=format:%%s %s", sha)).RunWithOutput()
-}
-
-// AmendHead amends HEAD with whatever is staged in your working tree
-func (c *GitCommand) AmendHead() error {
-	return c.AmendHeadCmdObj().Run()
-}
-
-func (c *GitCommand) AmendHeadCmdObj() oscommands.ICmdObj {
-	return c.Cmd.New("git commit --amend --no-edit --allow-empty")
-}
-
-func (c *GitCommand) ShowCmdObj(sha string, filterPath string) oscommands.ICmdObj {
-	contextSize := c.UserConfig.Git.DiffContextSize
-	filterPathArg := ""
-	if filterPath != "" {
-		filterPathArg = fmt.Sprintf(" -- %s", c.OSCommand.Quote(filterPath))
-	}
-
-	cmdStr := fmt.Sprintf("git show --submodule --color=%s --unified=%d --no-renames --stat -p %s %s", c.colorArg(), contextSize, sha, filterPathArg)
-	return c.Cmd.New(cmdStr)
-}
-
-// Revert reverts the selected commit by sha
-func (c *GitCommand) Revert(sha string) error {
-	return c.Cmd.New(fmt.Sprintf("git revert %s", sha)).Run()
-}
-
-func (c *GitCommand) RevertMerge(sha string, parentNumber int) error {
-	return c.Cmd.New(fmt.Sprintf("git revert %s -m %d", sha, parentNumber)).Run()
-}
-
-// CherryPickCommits begins an interactive rebase with the given shas being cherry picked onto HEAD
-func (c *GitCommand) CherryPickCommits(commits []*models.Commit) error {
-	todo := ""
-	for _, commit := range commits {
-		todo = "pick " + commit.Sha + " " + commit.Name + "\n" + todo
-	}
-
-	cmdObj, err := c.PrepareInteractiveRebaseCommand("HEAD", todo, false)
-	if err != nil {
-		return err
-	}
-
-	return cmdObj.Run()
-}
-
-// CreateFixupCommit creates a commit that fixes up a previous commit
-func (c *GitCommand) CreateFixupCommit(sha string) error {
-	return c.Cmd.New(fmt.Sprintf("git commit --fixup=%s", sha)).Run()
-}

pkg/commands/commits_test.go

@@ -1,134 +0,0 @@
-package commands
-
-import (
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGitCommandRenameCommit(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectArgs([]string{"git", "commit", "--allow-empty", "--amend", "--only", "-m", "test"}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-
-	assert.NoError(t, gitCmd.RenameCommit("test"))
-	runner.CheckForMissingCalls()
-}
-
-func TestGitCommandResetToCommit(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectArgs([]string{"git", "reset", "--hard", "78976bc"}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-
-	assert.NoError(t, gitCmd.ResetToCommit("78976bc", "hard", []string{}))
-	runner.CheckForMissingCalls()
-}
-
-func TestGitCommandCommitObj(t *testing.T) {
-	gitCmd := NewDummyGitCommand()
-
-	type scenario struct {
-		testName string
-		message  string
-		flags    string
-		expected string
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "Commit",
-			message:  "test",
-			flags:    "",
-			expected: "git commit -m " + gitCmd.OSCommand.Quote("test"),
-		},
-		{
-			testName: "Commit with --no-verify flag",
-			message:  "test",
-			flags:    "--no-verify",
-			expected: "git commit --no-verify -m " + gitCmd.OSCommand.Quote("test"),
-		},
-		{
-			testName: "Commit with multiline message",
-			message:  "line1\nline2",
-			flags:    "",
-			expected: "git commit -m " + gitCmd.OSCommand.Quote("line1") + " -m " + gitCmd.OSCommand.Quote("line2"),
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			cmdStr := gitCmd.CommitCmdObj(s.message, s.flags).ToString()
-			assert.Equal(t, s.expected, cmdStr)
-		})
-	}
-}
-
-func TestGitCommandCreateFixupCommit(t *testing.T) {
-	type scenario struct {
-		testName string
-		sha      string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "valid case",
-			sha:      "12345",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git commit --fixup=12345`, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.CreateFixupCommit(s.sha))
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandShowCmdObj(t *testing.T) {
-	type scenario struct {
-		testName    string
-		filterPath  string
-		contextSize int
-		expected    string
-	}
-
-	gitCmd := NewDummyGitCommand()
-
-	scenarios := []scenario{
-		{
-			testName:    "Default case without filter path",
-			filterPath:  "",
-			contextSize: 3,
-			expected:    "git show --submodule --color=always --unified=3 --no-renames --stat -p 1234567890 ",
-		},
-		{
-			testName:    "Default case with filter path",
-			filterPath:  "file.txt",
-			contextSize: 3,
-			expected:    "git show --submodule --color=always --unified=3 --no-renames --stat -p 1234567890  -- " + gitCmd.OSCommand.Quote("file.txt"),
-		},
-		{
-			testName:    "Show diff with custom context size",
-			filterPath:  "",
-			contextSize: 77,
-			expected:    "git show --submodule --color=always --unified=77 --no-renames --stat -p 1234567890 ",
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd.UserConfig.Git.DiffContextSize = s.contextSize
-			cmdStr := gitCmd.ShowCmdObj("1234567890", s.filterPath).ToString()
-			assert.Equal(t, s.expected, cmdStr)
-		})
-	}
-}

pkg/commands/config.go

@@ -1,50 +0,0 @@
-package commands
-
-import (
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-func (c *GitCommand) ConfiguredPager() string {
-	if os.Getenv("GIT_PAGER") != "" {
-		return os.Getenv("GIT_PAGER")
-	}
-	if os.Getenv("PAGER") != "" {
-		return os.Getenv("PAGER")
-	}
-	output := c.GitConfig.Get("core.pager")
-	return strings.Split(output, "\n")[0]
-}
-
-func (c *GitCommand) GetPager(width int) string {
-	useConfig := c.UserConfig.Git.Paging.UseConfig
-	if useConfig {
-		pager := c.ConfiguredPager()
-		return strings.Split(pager, "| less")[0]
-	}
-
-	templateValues := map[string]string{
-		"columnWidth": strconv.Itoa(width/2 - 6),
-	}
-
-	pagerTemplate := c.UserConfig.Git.Paging.Pager
-	return utils.ResolvePlaceholderString(pagerTemplate, templateValues)
-}
-
-func (c *GitCommand) colorArg() string {
-	return c.UserConfig.Git.Paging.ColorArg
-}
-
-// 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 {
-	overrideGpg := c.UserConfig.Git.OverrideGpg
-	if overrideGpg {
-		return false
-	}
-
-	return c.GitConfig.GetBool("commit.gpgsign")
-}

pkg/commands/dummies.go

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

pkg/commands/errors.go

@@ -0,0 +1,14 @@
+package commands
+
+import "github.com/go-errors/errors"
+
+// WrapError wraps an error for the sake of showing a stack trace at the top level
+// the go-errors package, for some reason, does not return nil when you try to wrap
+// a non-error, so we're just doing it here
+func WrapError(err error) error {
+	if err == nil {
+		return err
+	}
+
+	return errors.Wrap(err, 0)
+}

pkg/commands/exec_live_default.go

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

pkg/commands/exec_live_win.go

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

pkg/commands/file.go

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

pkg/commands/files.go

@@ -1,372 +0,0 @@
-package commands
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strconv"
-	"time"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/loaders"
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/gui/filetree"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// CatFile obtains the content of a file
-func (c *GitCommand) CatFile(fileName string) (string, error) {
-	buf, err := ioutil.ReadFile(fileName)
-	if err != nil {
-		return "", nil
-	}
-	return string(buf), nil
-}
-
-func (c *GitCommand) OpenMergeToolCmdObj() oscommands.ICmdObj {
-	return c.Cmd.New("git mergetool")
-}
-
-func (c *GitCommand) OpenMergeTool() error {
-	return c.OpenMergeToolCmdObj().Run()
-}
-
-// StageFile stages a file
-func (c *GitCommand) StageFile(fileName string) error {
-	return c.Cmd.New("git add -- " + c.OSCommand.Quote(fileName)).Run()
-}
-
-// StageAll stages all files
-func (c *GitCommand) StageAll() error {
-	return c.Cmd.New("git add -A").Run()
-}
-
-// UnstageAll unstages all files
-func (c *GitCommand) UnstageAll() error {
-	return c.Cmd.New("git reset").Run()
-}
-
-// UnStageFile unstages a file
-// we accept an array of filenames for the cases where a file has been renamed i.e.
-// we accept the current name and the previous name
-func (c *GitCommand) UnStageFile(fileNames []string, reset bool) error {
-	command := "git rm --cached --force -- %s"
-	if reset {
-		command = "git reset HEAD -- %s"
-	}
-
-	for _, name := range fileNames {
-		err := c.Cmd.New(fmt.Sprintf(command, c.OSCommand.Quote(name))).Run()
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (c *GitCommand) BeforeAndAfterFileForRename(file *models.File) (*models.File, *models.File, error) {
-
-	if !file.IsRename() {
-		return nil, nil, errors.New("Expected renamed file")
-	}
-
-	// we've got a file that represents a rename from one file to another. Here we will refetch
-	// all files, passing the --no-renames flag and then recursively call the function
-	// again for the before file and after file.
-
-	filesWithoutRenames := loaders.
-		NewFileLoader(c.Common, c.Cmd, c.GitConfig).
-		GetStatusFiles(loaders.GetStatusFileOptions{NoRenames: true})
-
-	var beforeFile *models.File
-	var afterFile *models.File
-	for _, f := range filesWithoutRenames {
-		if f.Name == file.PreviousName {
-			beforeFile = f
-		}
-
-		if f.Name == file.Name {
-			afterFile = f
-		}
-	}
-
-	if beforeFile == nil || afterFile == nil {
-		return nil, nil, errors.New("Could not find deleted file or new file for file rename")
-	}
-
-	if beforeFile.IsRename() || afterFile.IsRename() {
-		// probably won't happen but we want to ensure we don't get an infinite loop
-		return nil, nil, errors.New("Nested rename found")
-	}
-
-	return beforeFile, afterFile, nil
-}
-
-// DiscardAllFileChanges directly
-func (c *GitCommand) DiscardAllFileChanges(file *models.File) error {
-	if file.IsRename() {
-		beforeFile, afterFile, err := c.BeforeAndAfterFileForRename(file)
-		if err != nil {
-			return err
-		}
-
-		if err := c.DiscardAllFileChanges(beforeFile); err != nil {
-			return err
-		}
-
-		if err := c.DiscardAllFileChanges(afterFile); err != nil {
-			return err
-		}
-
-		return nil
-	}
-
-	quotedFileName := c.OSCommand.Quote(file.Name)
-
-	if file.ShortStatus == "AA" {
-		if err := c.Cmd.New("git checkout --ours --  " + quotedFileName).Run(); err != nil {
-			return err
-		}
-		if err := c.Cmd.New("git add -- " + quotedFileName).Run(); err != nil {
-			return err
-		}
-		return nil
-	}
-
-	if file.ShortStatus == "DU" {
-		return c.Cmd.New("git rm -- " + quotedFileName).Run()
-	}
-
-	// if the file isn't tracked, we assume you want to delete it
-	if file.HasStagedChanges || file.HasMergeConflicts {
-		if err := c.Cmd.New("git reset -- " + quotedFileName).Run(); err != nil {
-			return err
-		}
-	}
-
-	if file.ShortStatus == "DD" || file.ShortStatus == "AU" {
-		return nil
-	}
-
-	if file.Added {
-		return c.OSCommand.RemoveFile(file.Name)
-	}
-	return c.DiscardUnstagedFileChanges(file)
-}
-
-func (c *GitCommand) DiscardAllDirChanges(node *filetree.FileNode) error {
-	// this could be more efficient but we would need to handle all the edge cases
-	return node.ForEachFile(c.DiscardAllFileChanges)
-}
-
-func (c *GitCommand) DiscardUnstagedDirChanges(node *filetree.FileNode) error {
-	if err := c.RemoveUntrackedDirFiles(node); err != nil {
-		return err
-	}
-
-	quotedPath := c.OSCommand.Quote(node.GetPath())
-	if err := c.Cmd.New("git checkout -- " + quotedPath).Run(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (c *GitCommand) RemoveUntrackedDirFiles(node *filetree.FileNode) error {
-	untrackedFilePaths := node.GetPathsMatching(
-		func(n *filetree.FileNode) bool { return n.File != nil && !n.File.GetIsTracked() },
-	)
-
-	for _, path := range untrackedFilePaths {
-		err := os.Remove(path)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// DiscardUnstagedFileChanges directly
-func (c *GitCommand) DiscardUnstagedFileChanges(file *models.File) error {
-	quotedFileName := c.OSCommand.Quote(file.Name)
-	return c.Cmd.New("git checkout -- " + quotedFileName).Run()
-}
-
-// Ignore adds a file to the gitignore for the repo
-func (c *GitCommand) Ignore(filename string) error {
-	return c.OSCommand.AppendLineToFile(".gitignore", filename)
-}
-
-// WorktreeFileDiff returns the diff of a file
-func (c *GitCommand) WorktreeFileDiff(file *models.File, plain bool, cached bool, ignoreWhitespace bool) string {
-	// for now we assume an error means the file was deleted
-	s, _ := c.WorktreeFileDiffCmdObj(file, plain, cached, ignoreWhitespace).RunWithOutput()
-	return s
-}
-
-func (c *GitCommand) WorktreeFileDiffCmdObj(node models.IFile, plain bool, cached bool, ignoreWhitespace bool) oscommands.ICmdObj {
-	cachedArg := ""
-	trackedArg := "--"
-	colorArg := c.colorArg()
-	quotedPath := c.OSCommand.Quote(node.GetPath())
-	ignoreWhitespaceArg := ""
-	contextSize := c.UserConfig.Git.DiffContextSize
-	if cached {
-		cachedArg = "--cached"
-	}
-	if !node.GetIsTracked() && !node.GetHasStagedChanges() && !cached {
-		trackedArg = "--no-index -- /dev/null"
-	}
-	if plain {
-		colorArg = "never"
-	}
-	if ignoreWhitespace {
-		ignoreWhitespaceArg = "--ignore-all-space"
-	}
-
-	cmdStr := fmt.Sprintf("git diff --submodule --no-ext-diff --unified=%d --color=%s %s %s %s %s", contextSize, colorArg, ignoreWhitespaceArg, cachedArg, trackedArg, quotedPath)
-
-	return c.Cmd.New(cmdStr)
-}
-
-func (c *GitCommand) ApplyPatch(patch string, flags ...string) error {
-	filepath := filepath.Join(oscommands.GetTempDir(), utils.GetCurrentRepoName(), time.Now().Format("Jan _2 15.04.05.000000000")+".patch")
-	c.Log.Infof("saving temporary patch to %s", filepath)
-	if err := c.OSCommand.CreateFileWithContent(filepath, patch); err != nil {
-		return err
-	}
-
-	flagStr := ""
-	for _, flag := range flags {
-		flagStr += " --" + flag
-	}
-
-	return c.Cmd.New(fmt.Sprintf("git apply%s %s", flagStr, c.OSCommand.Quote(filepath))).Run()
-}
-
-// ShowFileDiff get the diff of specified from and to. Typically this will be used for a single commit so it'll be 123abc^..123abc
-// but when we're in diff mode it could be any 'from' to any 'to'. The reverse flag is also here thanks to diff mode.
-func (c *GitCommand) ShowFileDiff(from string, to string, reverse bool, fileName string, plain bool) (string, error) {
-	return c.ShowFileDiffCmdObj(from, to, reverse, fileName, plain).RunWithOutput()
-}
-
-func (c *GitCommand) ShowFileDiffCmdObj(from string, to string, reverse bool, fileName string, plain bool) oscommands.ICmdObj {
-	colorArg := c.colorArg()
-	contextSize := c.UserConfig.Git.DiffContextSize
-	if plain {
-		colorArg = "never"
-	}
-
-	reverseFlag := ""
-	if reverse {
-		reverseFlag = " -R "
-	}
-
-	return c.Cmd.New(fmt.Sprintf("git diff --submodule --no-ext-diff --unified=%d --no-renames --color=%s %s %s %s -- %s", contextSize, colorArg, from, to, reverseFlag, c.OSCommand.Quote(fileName)))
-}
-
-// CheckoutFile checks out the file for the given commit
-func (c *GitCommand) CheckoutFile(commitSha, fileName string) error {
-	return c.Cmd.New(fmt.Sprintf("git checkout %s -- %s", commitSha, c.OSCommand.Quote(fileName))).Run()
-}
-
-// DiscardOldFileChanges discards changes to a file from an old commit
-func (c *GitCommand) DiscardOldFileChanges(commits []*models.Commit, commitIndex int, fileName string) error {
-	if err := c.BeginInteractiveRebaseForCommit(commits, commitIndex); err != nil {
-		return err
-	}
-
-	// check if file exists in previous commit (this command returns an error if the file doesn't exist)
-	if err := c.Cmd.New("git cat-file -e HEAD^:" + c.OSCommand.Quote(fileName)).Run(); err != nil {
-		if err := c.OSCommand.Remove(fileName); err != nil {
-			return err
-		}
-		if err := c.StageFile(fileName); err != nil {
-			return err
-		}
-	} else if err := c.CheckoutFile("HEAD^", fileName); err != nil {
-		return err
-	}
-
-	// amend the commit
-	err := c.AmendHead()
-	if err != nil {
-		return err
-	}
-
-	// continue
-	return c.GenericMergeOrRebaseAction("rebase", "continue")
-}
-
-// DiscardAnyUnstagedFileChanges discards any unstages file changes via `git checkout -- .`
-func (c *GitCommand) DiscardAnyUnstagedFileChanges() error {
-	return c.Cmd.New("git checkout -- .").Run()
-}
-
-// RemoveTrackedFiles will delete the given file(s) even if they are currently tracked
-func (c *GitCommand) RemoveTrackedFiles(name string) error {
-	return c.Cmd.New("git rm -r --cached -- " + c.OSCommand.Quote(name)).Run()
-}
-
-// RemoveUntrackedFiles runs `git clean -fd`
-func (c *GitCommand) RemoveUntrackedFiles() error {
-	return c.Cmd.New("git clean -fd").Run()
-}
-
-// ResetAndClean removes all unstaged changes and removes all untracked files
-func (c *GitCommand) ResetAndClean() error {
-	submoduleConfigs, err := c.Submodules.GetConfigs()
-	if err != nil {
-		return err
-	}
-
-	if len(submoduleConfigs) > 0 {
-		if err := c.Submodules.ResetSubmodules(submoduleConfigs); err != nil {
-			return err
-		}
-	}
-
-	if err := c.ResetHard("HEAD"); err != nil {
-		return err
-	}
-
-	return c.RemoveUntrackedFiles()
-}
-
-func (c *GitCommand) EditFileCmdStr(filename string, lineNumber int) (string, error) {
-	editor := c.UserConfig.OS.EditCommand
-
-	if editor == "" {
-		editor = c.GitConfig.Get("core.editor")
-	}
-
-	if editor == "" {
-		editor = c.OSCommand.Getenv("GIT_EDITOR")
-	}
-	if editor == "" {
-		editor = c.OSCommand.Getenv("VISUAL")
-	}
-	if editor == "" {
-		editor = c.OSCommand.Getenv("EDITOR")
-	}
-	if editor == "" {
-		if err := c.OSCommand.Cmd.New("which vi").Run(); err == nil {
-			editor = "vi"
-		}
-	}
-	if editor == "" {
-		return "", errors.New("No editor defined in config file, $GIT_EDITOR, $VISUAL, $EDITOR, or git config")
-	}
-
-	templateValues := map[string]string{
-		"editor":   editor,
-		"filename": c.OSCommand.Quote(filename),
-		"line":     strconv.Itoa(lineNumber),
-	}
-
-	editCmdTemplate := c.UserConfig.OS.EditCommandTemplate
-	return utils.ResolvePlaceholderString(editCmdTemplate, templateValues), nil
-}

pkg/commands/files_test.go

@@ -1,744 +0,0 @@
-package commands
-
-import (
-	"fmt"
-	"io/ioutil"
-	"regexp"
-	"testing"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGitCommandStageFile(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectArgs([]string{"git", "add", "--", "test.txt"}, "", nil)
-	gitCmd := NewDummyGitCommandWithRunner(runner)
-
-	assert.NoError(t, gitCmd.StageFile("test.txt"))
-	runner.CheckForMissingCalls()
-}
-
-func TestGitCommandUnstageFile(t *testing.T) {
-	type scenario struct {
-		testName string
-		reset    bool
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "Remove an untracked file from staging",
-			reset:    false,
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "rm", "--cached", "--force", "--", "test.txt"}, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			testName: "Remove a tracked file from staging",
-			reset:    true,
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "reset", "HEAD", "--", "test.txt"}, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.UnStageFile([]string{"test.txt"}, s.reset))
-		})
-	}
-}
-
-// these tests don't cover everything, in part because we already have an integration
-// test which does cover everything. I don't want to unnecessarily assert on the 'how'
-// when the 'what' is what matters
-func TestGitCommandDiscardAllFileChanges(t *testing.T) {
-	type scenario struct {
-		testName      string
-		file          *models.File
-		removeFile    func(string) error
-		runner        *oscommands.FakeCmdObjRunner
-		expectedError string
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "An error occurred when resetting",
-			file: &models.File{
-				Name:             "test",
-				HasStagedChanges: true,
-			},
-			removeFile: func(string) error { return nil },
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "reset", "--", "test"}, "", errors.New("error")),
-			expectedError: "error",
-		},
-		{
-			testName: "An error occurred when removing file",
-			file: &models.File{
-				Name:    "test",
-				Tracked: false,
-				Added:   true,
-			},
-			removeFile: func(string) error {
-				return fmt.Errorf("an error occurred when removing file")
-			},
-			runner:        oscommands.NewFakeRunner(t),
-			expectedError: "an error occurred when removing file",
-		},
-		{
-			testName: "An error occurred with checkout",
-			file: &models.File{
-				Name:             "test",
-				Tracked:          true,
-				HasStagedChanges: false,
-			},
-			removeFile: func(string) error { return nil },
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", errors.New("error")),
-			expectedError: "error",
-		},
-		{
-			testName: "Checkout only",
-			file: &models.File{
-				Name:             "test",
-				Tracked:          true,
-				HasStagedChanges: false,
-			},
-			removeFile: func(string) error { return nil },
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", nil),
-			expectedError: "",
-		},
-		{
-			testName: "Reset and checkout staged changes",
-			file: &models.File{
-				Name:             "test",
-				Tracked:          true,
-				HasStagedChanges: true,
-			},
-			removeFile: func(string) error { return nil },
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "reset", "--", "test"}, "", nil).
-				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", nil),
-			expectedError: "",
-		},
-		{
-			testName: "Reset and checkout merge conflicts",
-			file: &models.File{
-				Name:              "test",
-				Tracked:           true,
-				HasMergeConflicts: true,
-			},
-			removeFile: func(string) error { return nil },
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "reset", "--", "test"}, "", nil).
-				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", nil),
-			expectedError: "",
-		},
-		{
-			testName: "Reset and remove",
-			file: &models.File{
-				Name:             "test",
-				Tracked:          false,
-				Added:            true,
-				HasStagedChanges: true,
-			},
-			removeFile: func(filename string) error {
-				assert.Equal(t, "test", filename)
-				return nil
-			},
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "reset", "--", "test"}, "", nil),
-			expectedError: "",
-		},
-		{
-			testName: "Remove only",
-			file: &models.File{
-				Name:             "test",
-				Tracked:          false,
-				Added:            true,
-				HasStagedChanges: false,
-			},
-			removeFile: func(filename string) error {
-				assert.Equal(t, "test", filename)
-				return nil
-			},
-			runner:        oscommands.NewFakeRunner(t),
-			expectedError: "",
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			gitCmd.OSCommand.SetRemoveFile(s.removeFile)
-			err := gitCmd.DiscardAllFileChanges(s.file)
-
-			if s.expectedError == "" {
-				assert.Nil(t, err)
-			} else {
-				assert.Equal(t, s.expectedError, err.Error())
-			}
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandDiff(t *testing.T) {
-	type scenario struct {
-		testName         string
-		file             *models.File
-		plain            bool
-		cached           bool
-		ignoreWhitespace bool
-		contextSize      int
-		runner           *oscommands.FakeCmdObjRunner
-	}
-
-	const expectedResult = "pretend this is an actual git diff"
-
-	scenarios := []scenario{
-		{
-			testName: "Default case",
-			file: &models.File{
-				Name:             "test.txt",
-				HasStagedChanges: false,
-				Tracked:          true,
-			},
-			plain:            false,
-			cached:           false,
-			ignoreWhitespace: false,
-			contextSize:      3,
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=always", "--", "test.txt"}, expectedResult, nil),
-		},
-		{
-			testName: "cached",
-			file: &models.File{
-				Name:             "test.txt",
-				HasStagedChanges: false,
-				Tracked:          true,
-			},
-			plain:            false,
-			cached:           true,
-			ignoreWhitespace: false,
-			contextSize:      3,
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=always", "--cached", "--", "test.txt"}, expectedResult, nil),
-		},
-		{
-			testName: "plain",
-			file: &models.File{
-				Name:             "test.txt",
-				HasStagedChanges: false,
-				Tracked:          true,
-			},
-			plain:            true,
-			cached:           false,
-			ignoreWhitespace: false,
-			contextSize:      3,
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=never", "--", "test.txt"}, expectedResult, nil),
-		},
-		{
-			testName: "File not tracked and file has no staged changes",
-			file: &models.File{
-				Name:             "test.txt",
-				HasStagedChanges: false,
-				Tracked:          false,
-			},
-			plain:            false,
-			cached:           false,
-			ignoreWhitespace: false,
-			contextSize:      3,
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=always", "--no-index", "--", "/dev/null", "test.txt"}, expectedResult, nil),
-		},
-		{
-			testName: "Default case (ignore whitespace)",
-			file: &models.File{
-				Name:             "test.txt",
-				HasStagedChanges: false,
-				Tracked:          true,
-			},
-			plain:            false,
-			cached:           false,
-			ignoreWhitespace: true,
-			contextSize:      3,
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=always", "--ignore-all-space", "--", "test.txt"}, expectedResult, nil),
-		},
-		{
-			testName: "Show diff with custom context size",
-			file: &models.File{
-				Name:             "test.txt",
-				HasStagedChanges: false,
-				Tracked:          true,
-			},
-			plain:            false,
-			cached:           false,
-			ignoreWhitespace: false,
-			contextSize:      17,
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=17", "--color=always", "--", "test.txt"}, expectedResult, nil),
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			gitCmd.UserConfig.Git.DiffContextSize = s.contextSize
-			result := gitCmd.WorktreeFileDiff(s.file, s.plain, s.cached, s.ignoreWhitespace)
-			assert.Equal(t, expectedResult, result)
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandShowFileDiff(t *testing.T) {
-	type scenario struct {
-		testName    string
-		from        string
-		to          string
-		reverse     bool
-		plain       bool
-		contextSize int
-		runner      *oscommands.FakeCmdObjRunner
-	}
-
-	const expectedResult = "pretend this is an actual git diff"
-
-	scenarios := []scenario{
-		{
-			testName:    "Default case",
-			from:        "1234567890",
-			to:          "0987654321",
-			reverse:     false,
-			plain:       false,
-			contextSize: 3,
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--no-renames", "--color=always", "1234567890", "0987654321", "--", "test.txt"}, expectedResult, nil),
-		},
-		{
-			testName:    "Show diff with custom context size",
-			from:        "1234567890",
-			to:          "0987654321",
-			reverse:     false,
-			plain:       false,
-			contextSize: 123,
-			runner: oscommands.NewFakeRunner(t).
-				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=123", "--no-renames", "--color=always", "1234567890", "0987654321", "--", "test.txt"}, expectedResult, nil),
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			gitCmd.UserConfig.Git.DiffContextSize = s.contextSize
-			result, err := gitCmd.ShowFileDiff(s.from, s.to, s.reverse, "test.txt", s.plain)
-			assert.NoError(t, err)
-			assert.Equal(t, expectedResult, result)
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandCheckoutFile(t *testing.T) {
-	type scenario struct {
-		testName  string
-		commitSha string
-		fileName  string
-		runner    *oscommands.FakeCmdObjRunner
-		test      func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName:  "typical case",
-			commitSha: "11af912",
-			fileName:  "test999.txt",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git checkout 11af912 -- "test999.txt"`, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			testName:  "returns error if there is one",
-			commitSha: "11af912",
-			fileName:  "test999.txt",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git checkout 11af912 -- "test999.txt"`, "", errors.New("error")),
-			test: func(err error) {
-				assert.Error(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.CheckoutFile(s.commitSha, s.fileName))
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandApplyPatch(t *testing.T) {
-	type scenario struct {
-		testName string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	expectFn := func(regexStr string, errToReturn error) func(cmdObj oscommands.ICmdObj) (string, error) {
-		return func(cmdObj oscommands.ICmdObj) (string, error) {
-			re := regexp.MustCompile(regexStr)
-			matches := re.FindStringSubmatch(cmdObj.ToString())
-			assert.Equal(t, 2, len(matches))
-
-			filename := matches[1]
-
-			content, err := ioutil.ReadFile(filename)
-			assert.NoError(t, err)
-
-			assert.Equal(t, "test", string(content))
-
-			return "", errToReturn
-		}
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "valid case",
-			runner: oscommands.NewFakeRunner(t).
-				ExpectFunc(expectFn(`git apply --cached "(.*)"`, nil)),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			testName: "command returns error",
-			runner: oscommands.NewFakeRunner(t).
-				ExpectFunc(expectFn(`git apply --cached "(.*)"`, errors.New("error"))),
-			test: func(err error) {
-				assert.Error(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.ApplyPatch("test", "cached"))
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandDiscardOldFileChanges(t *testing.T) {
-	type scenario struct {
-		testName               string
-		gitConfigMockResponses map[string]string
-		commits                []*models.Commit
-		commitIndex            int
-		fileName               string
-		runner                 *oscommands.FakeCmdObjRunner
-		test                   func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName:               "returns error when index outside of range of commits",
-			gitConfigMockResponses: nil,
-			commits:                []*models.Commit{},
-			commitIndex:            0,
-			fileName:               "test999.txt",
-			runner:                 oscommands.NewFakeRunner(t),
-			test: func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			testName:               "returns error when using gpg",
-			gitConfigMockResponses: map[string]string{"commit.gpgsign": "true"},
-			commits:                []*models.Commit{{Name: "commit", Sha: "123456"}},
-			commitIndex:            0,
-			fileName:               "test999.txt",
-			runner:                 oscommands.NewFakeRunner(t),
-			test: func(err error) {
-				assert.Error(t, err)
-			},
-		},
-		{
-			testName:               "checks out file if it already existed",
-			gitConfigMockResponses: nil,
-			commits: []*models.Commit{
-				{Name: "commit", Sha: "123456"},
-				{Name: "commit2", Sha: "abcdef"},
-			},
-			commitIndex: 0,
-			fileName:    "test999.txt",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git rebase --interactive --autostash --keep-empty abcdef`, "", nil).
-				Expect(`git cat-file -e HEAD^:"test999.txt"`, "", nil).
-				Expect(`git checkout HEAD^ -- "test999.txt"`, "", nil).
-				Expect(`git commit --amend --no-edit --allow-empty`, "", nil).
-				Expect(`git rebase --continue`, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		// test for when the file was created within the commit requires a refactor to support proper mocks
-		// currently we'd need to mock out the os.Remove function and that's gonna introduce tech debt
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			gitCmd.GitConfig = git_config.NewFakeGitConfig(s.gitConfigMockResponses)
-			s.test(gitCmd.DiscardOldFileChanges(s.commits, s.commitIndex, s.fileName))
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandDiscardUnstagedFileChanges(t *testing.T) {
-	type scenario struct {
-		testName string
-		file     *models.File
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "valid case",
-			file:     &models.File{Name: "test.txt"},
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git checkout -- "test.txt"`, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.DiscardUnstagedFileChanges(s.file))
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandDiscardAnyUnstagedFileChanges(t *testing.T) {
-	type scenario struct {
-		testName string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "valid case",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git checkout -- .`, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.DiscardAnyUnstagedFileChanges())
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestGitCommandRemoveUntrackedFiles(t *testing.T) {
-	type scenario struct {
-		testName string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "valid case",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git clean -fd`, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			gitCmd := NewDummyGitCommandWithRunner(s.runner)
-			s.test(gitCmd.RemoveUntrackedFiles())
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestEditFileCmdStr(t *testing.T) {
-	type scenario struct {
-		filename                  string
-		configEditCommand         string
-		configEditCommandTemplate string
-		runner                    *oscommands.FakeCmdObjRunner
-		getenv                    func(string) string
-		gitConfigMockResponses    map[string]string
-		test                      func(string, error)
-	}
-
-	scenarios := []scenario{
-		{
-			filename:                  "test",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`which vi`, "", errors.New("error")),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.EqualError(t, err, "No editor defined in config file, $GIT_EDITOR, $VISUAL, $EDITOR, or git config")
-			},
-		},
-		{
-			filename:                  "test",
-			configEditCommand:         "nano",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner:                    oscommands.NewFakeRunner(t),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, `nano "test"`, cmdStr)
-			},
-		},
-		{
-			filename:                  "test",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner:                    oscommands.NewFakeRunner(t),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: map[string]string{"core.editor": "nano"},
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, `nano "test"`, cmdStr)
-			},
-		},
-		{
-			filename:                  "test",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner:                    oscommands.NewFakeRunner(t),
-			getenv: func(env string) string {
-				if env == "VISUAL" {
-					return "nano"
-				}
-
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			filename:                  "test",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner:                    oscommands.NewFakeRunner(t),
-			getenv: func(env string) string {
-				if env == "EDITOR" {
-					return "emacs"
-				}
-
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, `emacs "test"`, cmdStr)
-			},
-		},
-		{
-			filename:                  "test",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`which vi`, "/usr/bin/vi", nil),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, `vi "test"`, cmdStr)
-			},
-		},
-		{
-			filename:                  "file/with space",
-			configEditCommand:         "",
-			configEditCommandTemplate: "{{editor}} {{filename}}",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`which vi`, "/usr/bin/vi", nil),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, `vi "file/with space"`, cmdStr)
-			},
-		},
-		{
-			filename:                  "open file/at line",
-			configEditCommand:         "vim",
-			configEditCommandTemplate: "{{editor}} +{{line}} {{filename}}",
-			runner:                    oscommands.NewFakeRunner(t),
-			getenv: func(env string) string {
-				return ""
-			},
-			gitConfigMockResponses: nil,
-			test: func(cmdStr string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, `vim +1 "open file/at line"`, cmdStr)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		gitCmd := NewDummyGitCommandWithRunner(s.runner)
-		gitCmd.UserConfig.OS.EditCommand = s.configEditCommand
-		gitCmd.UserConfig.OS.EditCommandTemplate = s.configEditCommandTemplate
-		gitCmd.OSCommand.Getenv = s.getenv
-		gitCmd.GitConfig = git_config.NewFakeGitConfig(s.gitConfigMockResponses)
-		s.test(gitCmd.EditFileCmdStr(s.filename, 1))
-		s.runner.CheckForMissingCalls()
-	}
-}

pkg/commands/git_cmd_obj_builder.go

@@ -1,47 +0,0 @@
-package commands
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/sirupsen/logrus"
-)
-
-// all we're doing here is wrapping the default command object builder with
-// some git-specific stuff: e.g. adding a git-specific env var
-
-type gitCmdObjBuilder struct {
-	innerBuilder *oscommands.CmdObjBuilder
-}
-
-var _ oscommands.ICmdObjBuilder = &gitCmdObjBuilder{}
-
-func NewGitCmdObjBuilder(log *logrus.Entry, innerBuilder *oscommands.CmdObjBuilder) *gitCmdObjBuilder {
-	// the price of having a convenient interface where we can say .New(...).Run() is that our builder now depends on our runner, so when we want to wrap the default builder/runner in new functionality we need to jump through some hoops. We could avoid the use of a decorator function here by just exporting the runner field on the default builder but that would be misleading because we don't want anybody using that to run commands (i.e. we want there to be a single API used across the codebase)
-	updatedBuilder := innerBuilder.CloneWithNewRunner(func(runner oscommands.ICmdObjRunner) oscommands.ICmdObjRunner {
-		return &gitCmdObjRunner{
-			log:         log,
-			innerRunner: runner,
-		}
-	})
-
-	return &gitCmdObjBuilder{
-		innerBuilder: updatedBuilder,
-	}
-}
-
-var defaultEnvVar = "GIT_OPTIONAL_LOCKS=0"
-
-func (self *gitCmdObjBuilder) New(cmdStr string) oscommands.ICmdObj {
-	return self.innerBuilder.New(cmdStr).AddEnvVars(defaultEnvVar)
-}
-
-func (self *gitCmdObjBuilder) NewFromArgs(args []string) oscommands.ICmdObj {
-	return self.innerBuilder.NewFromArgs(args).AddEnvVars(defaultEnvVar)
-}
-
-func (self *gitCmdObjBuilder) NewShell(cmdStr string) oscommands.ICmdObj {
-	return self.innerBuilder.NewShell(cmdStr).AddEnvVars(defaultEnvVar)
-}
-
-func (self *gitCmdObjBuilder) Quote(str string) string {
-	return self.innerBuilder.Quote(str)
-}

pkg/commands/git_cmd_obj_runner.go

@@ -1,49 +0,0 @@
-package commands
-
-import (
-	"strings"
-	"time"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/sirupsen/logrus"
-)
-
-// here we're wrapping the default command runner in some git-specific stuff e.g. retry logic if we get an error due to the presence of .git/index.lock
-
-type gitCmdObjRunner struct {
-	log         *logrus.Entry
-	innerRunner oscommands.ICmdObjRunner
-}
-
-func (self *gitCmdObjRunner) Run(cmdObj oscommands.ICmdObj) error {
-	_, err := self.RunWithOutput(cmdObj)
-	return err
-}
-
-func (self *gitCmdObjRunner) RunWithOutput(cmdObj oscommands.ICmdObj) (string, error) {
-	// TODO: have this retry logic in other places we run the command
-	waitTime := 50 * time.Millisecond
-	retryCount := 5
-	attempt := 0
-
-	for {
-		output, err := self.innerRunner.RunWithOutput(cmdObj)
-		if err != nil {
-			// if we have an error based on the index lock, we should wait a bit and then retry
-			if strings.Contains(output, ".git/index.lock") {
-				self.log.Error(output)
-				self.log.Info("index.lock prevented command from running. Retrying command after a small wait")
-				attempt++
-				time.Sleep(waitTime)
-				if attempt < retryCount {
-					continue
-				}
-			}
-		}
-		return output, err
-	}
-}
-
-func (self *gitCmdObjRunner) RunAndProcessLines(cmdObj oscommands.ICmdObj, onLine func(line string) (bool, error)) error {
-	return self.innerRunner.RunAndProcessLines(cmdObj, onLine)
-}

pkg/commands/git_config/cached_git_config.go

@@ -1,59 +0,0 @@
-package git_config
-
-import (
-	"strings"
-
-	"github.com/sirupsen/logrus"
-)
-
-type IGitConfig interface {
-	Get(string) string
-	GetBool(string) bool
-}
-
-type CachedGitConfig struct {
-	cache  map[string]string
-	getKey func(string) (string, error)
-	log    *logrus.Entry
-}
-
-func NewStdCachedGitConfig(log *logrus.Entry) *CachedGitConfig {
-	return NewCachedGitConfig(getGitConfigValue, log)
-}
-
-func NewCachedGitConfig(getKey func(string) (string, error), log *logrus.Entry) *CachedGitConfig {
-	return &CachedGitConfig{
-		cache:  make(map[string]string),
-		getKey: getKey,
-		log:    log,
-	}
-}
-
-func (self *CachedGitConfig) Get(key string) string {
-	if value, ok := self.cache[key]; ok {
-		self.log.Debugf("using cache for key " + key)
-		return value
-	}
-
-	value := self.getAux(key)
-	self.cache[key] = value
-	return value
-}
-
-func (self *CachedGitConfig) getAux(key string) string {
-	value, err := self.getKey(key)
-	if err != nil {
-		self.log.Debugf("Error getting git config value for key: " + key + ". Error: " + err.Error())
-		return ""
-	}
-	return strings.TrimSpace(value)
-}
-
-func (self *CachedGitConfig) GetBool(key string) bool {
-	return isTruthy(self.Get(key))
-}
-
-func isTruthy(value string) bool {
-	lcValue := strings.ToLower(value)
-	return lcValue == "true" || lcValue == "1" || lcValue == "yes" || lcValue == "on"
-}

pkg/commands/git_config/cached_git_config_test.go

@@ -1,116 +0,0 @@
-package git_config
-
-import (
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGetBool(t *testing.T) {
-	type scenario struct {
-		testName      string
-		mockResponses map[string]string
-		expected      bool
-	}
-
-	scenarios := []scenario{
-		{
-			"Option global and local config commit.gpgsign is not set",
-			map[string]string{},
-			false,
-		},
-		{
-			"Some other random key is set",
-			map[string]string{"blah": "blah"},
-			false,
-		},
-		{
-			"Option commit.gpgsign is true",
-			map[string]string{"commit.gpgsign": "True"},
-			true,
-		},
-		{
-			"Option commit.gpgsign is on",
-			map[string]string{"commit.gpgsign": "ON"},
-			true,
-		},
-		{
-			"Option commit.gpgsign is yes",
-			map[string]string{"commit.gpgsign": "YeS"},
-			true,
-		},
-		{
-			"Option commit.gpgsign is 1",
-			map[string]string{"commit.gpgsign": "1"},
-			true,
-		},
-	}
-
-	for _, s := range scenarios {
-		s := s
-		t.Run(s.testName, func(t *testing.T) {
-			fake := NewFakeGitConfig(s.mockResponses)
-			real := NewCachedGitConfig(
-				func(key string) (string, error) {
-					return fake.Get(key), nil
-				},
-				utils.NewDummyLog(),
-			)
-			result := real.GetBool("commit.gpgsign")
-			assert.Equal(t, s.expected, result)
-		})
-	}
-}
-
-func TestGet(t *testing.T) {
-	type scenario struct {
-		testName      string
-		mockResponses map[string]string
-		expected      string
-	}
-
-	scenarios := []scenario{
-		{
-			"not set",
-			map[string]string{},
-			"",
-		},
-		{
-			"is set",
-			map[string]string{"commit.gpgsign": "blah"},
-			"blah",
-		},
-	}
-
-	for _, s := range scenarios {
-		s := s
-		t.Run(s.testName, func(t *testing.T) {
-			fake := NewFakeGitConfig(s.mockResponses)
-			real := NewCachedGitConfig(
-				func(key string) (string, error) {
-					return fake.Get(key), nil
-				},
-				utils.NewDummyLog(),
-			)
-			result := real.Get("commit.gpgsign")
-			assert.Equal(t, s.expected, result)
-		})
-	}
-
-	// verifying that the cache is used
-	count := 0
-	real := NewCachedGitConfig(
-		func(key string) (string, error) {
-			count++
-			assert.Equal(t, "commit.gpgsign", key)
-			return "blah", nil
-		},
-		utils.NewDummyLog(),
-	)
-	result := real.Get("commit.gpgsign")
-	assert.Equal(t, "blah", result)
-	result = real.Get("commit.gpgsign")
-	assert.Equal(t, "blah", result)
-	assert.Equal(t, 1, count)
-}

pkg/commands/git_config/fake_git_config.go

@@ -1,22 +0,0 @@
-package git_config
-
-type FakeGitConfig struct {
-	mockResponses map[string]string
-}
-
-func NewFakeGitConfig(mockResponses map[string]string) *FakeGitConfig {
-	return &FakeGitConfig{
-		mockResponses: mockResponses,
-	}
-}
-
-func (self *FakeGitConfig) Get(key string) string {
-	if self.mockResponses == nil {
-		return ""
-	}
-	return self.mockResponses[key]
-}
-
-func (self *FakeGitConfig) GetBool(key string) bool {
-	return isTruthy(self.Get(key))
-}

pkg/commands/git_config/get_key.go

@@ -1,56 +0,0 @@
-package git_config
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"os/exec"
-	"strings"
-	"syscall"
-
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-)
-
-// including license from https://github.com/tcnksm/go-gitconfig because this file is an adaptation of that repo's code
-// Copyright (c) 2014 tcnksm
-
-// MIT License
-
-// 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.
-
-func getGitConfigValue(key string) (string, error) {
-	gitArgs := []string{"config", "--get", "--null", key}
-	var stdout bytes.Buffer
-	cmd := secureexec.Command("git", gitArgs...)
-	cmd.Stdout = &stdout
-	cmd.Stderr = ioutil.Discard
-
-	err := cmd.Run()
-	if exitError, ok := err.(*exec.ExitError); ok {
-		if waitStatus, ok := exitError.Sys().(syscall.WaitStatus); ok {
-			if waitStatus.ExitStatus() == 1 {
-				return "", fmt.Errorf("the key `%s` is not found", key)
-			}
-		}
-		return "", err
-	}
-
-	return strings.TrimRight(stdout.String(), "\000"), nil
-}

pkg/commands/git_structs.go

@@ -0,0 +1,9 @@
+package commands
+
+// 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/hosting_service/definitions.go

@@ -1,54 +0,0 @@
-package hosting_service
-
-// if you want to make a custom regex for a given service feel free to test it out
-// at regoio.herokuapp.com
-var defaultUrlRegexStrings = []string{
-	`^(?:https?|ssh)://.*/(?P<owner>.*)/(?P<repo>.*?)(?:\.git)?$`,
-	`^git@.*:(?P<owner>.*)/(?P<repo>.*?)(?:\.git)?$`,
-}
-
-// we've got less type safety using go templates but this lends itself better to
-// users adding custom service definitions in their config
-var githubServiceDef = ServiceDefinition{
-	provider:                        "github",
-	pullRequestURLIntoDefaultBranch: "/compare/{{.From}}?expand=1",
-	pullRequestURLIntoTargetBranch:  "/compare/{{.To}}...{{.From}}?expand=1",
-	commitURL:                       "/commit/{{.CommitSha}}",
-	regexStrings:                    defaultUrlRegexStrings,
-}
-
-var bitbucketServiceDef = ServiceDefinition{
-	provider:                        "bitbucket",
-	pullRequestURLIntoDefaultBranch: "/pull-requests/new?source={{.From}}&t=1",
-	pullRequestURLIntoTargetBranch:  "/pull-requests/new?source={{.From}}&dest={{.To}}&t=1",
-	commitURL:                       "/commits/{{.CommitSha}}",
-	regexStrings:                    defaultUrlRegexStrings,
-}
-
-var gitLabServiceDef = ServiceDefinition{
-	provider:                        "gitlab",
-	pullRequestURLIntoDefaultBranch: "/merge_requests/new?merge_request[source_branch]={{.From}}",
-	pullRequestURLIntoTargetBranch:  "/merge_requests/new?merge_request[source_branch]={{.From}}&merge_request[target_branch]={{.To}}",
-	commitURL:                       "/commit/{{.CommitSha}}",
-	regexStrings:                    defaultUrlRegexStrings,
-}
-
-var serviceDefinitions = []ServiceDefinition{githubServiceDef, bitbucketServiceDef, gitLabServiceDef}
-
-var defaultServiceDomains = []ServiceDomain{
-	{
-		serviceDefinition: githubServiceDef,
-		gitDomain:         "github.com",
-		webDomain:         "github.com",
-	},
-	{
-		serviceDefinition: bitbucketServiceDef,
-		gitDomain:         "bitbucket.org",
-		webDomain:         "bitbucket.org",
-	},
-	{
-		serviceDefinition: gitLabServiceDef,
-		gitDomain:         "gitlab.com",
-		webDomain:         "gitlab.com",
-	},
-}

pkg/commands/hosting_service/hosting_service.go

@@ -1,201 +0,0 @@
-package hosting_service
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/sirupsen/logrus"
-)
-
-// This package is for handling logic specific to a git hosting service like github, gitlab, bitbucket, etc.
-// Different git hosting services have different URL formats for when you want to open a PR or view a commit,
-// and this package's responsibility is to determine which service you're using based on the remote URL,
-// and then which URL you need for whatever use case you have.
-
-type HostingServiceMgr struct {
-	log       logrus.FieldLogger
-	tr        *i18n.TranslationSet
-	remoteURL string // e.g. https://github.com/jesseduffield/lazygit
-
-	// see https://github.com/jesseduffield/lazygit/blob/master/docs/Config.md#custom-pull-request-urls
-	configServiceDomains map[string]string
-}
-
-// NewHostingServiceMgr creates new instance of PullRequest
-func NewHostingServiceMgr(log logrus.FieldLogger, tr *i18n.TranslationSet, remoteURL string, configServiceDomains map[string]string) *HostingServiceMgr {
-	return &HostingServiceMgr{
-		log:                  log,
-		tr:                   tr,
-		remoteURL:            remoteURL,
-		configServiceDomains: configServiceDomains,
-	}
-}
-
-func (self *HostingServiceMgr) GetPullRequestURL(from string, to string) (string, error) {
-	gitService, err := self.getService()
-	if err != nil {
-		return "", err
-	}
-
-	if to == "" {
-		return gitService.getPullRequestURLIntoDefaultBranch(from), nil
-	} else {
-		return gitService.getPullRequestURLIntoTargetBranch(from, to), nil
-	}
-}
-
-func (self *HostingServiceMgr) GetCommitURL(commitSha string) (string, error) {
-	gitService, err := self.getService()
-	if err != nil {
-		return "", err
-	}
-
-	pullRequestURL := gitService.getCommitURL(commitSha)
-
-	return pullRequestURL, nil
-}
-
-func (self *HostingServiceMgr) getService() (*Service, error) {
-	serviceDomain, err := self.getServiceDomain(self.remoteURL)
-	if err != nil {
-		return nil, err
-	}
-
-	root, err := serviceDomain.getRootFromRemoteURL(self.remoteURL)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Service{
-		root:              root,
-		ServiceDefinition: serviceDomain.serviceDefinition,
-	}, nil
-}
-
-func (self *HostingServiceMgr) getServiceDomain(repoURL string) (*ServiceDomain, error) {
-	candidateServiceDomains := self.getCandidateServiceDomains()
-
-	for _, serviceDomain := range candidateServiceDomains {
-		// I feel like it makes more sense to see if the repo url contains the service domain's git domain,
-		// but I don't want to break anything by changing that right now.
-		if strings.Contains(repoURL, serviceDomain.serviceDefinition.provider) {
-			return &serviceDomain, nil
-		}
-	}
-
-	return nil, errors.New(self.tr.UnsupportedGitService)
-}
-
-func (self *HostingServiceMgr) getCandidateServiceDomains() []ServiceDomain {
-	serviceDefinitionByProvider := map[string]ServiceDefinition{}
-	for _, serviceDefinition := range serviceDefinitions {
-		serviceDefinitionByProvider[serviceDefinition.provider] = serviceDefinition
-	}
-
-	var serviceDomains = make([]ServiceDomain, len(defaultServiceDomains))
-	copy(serviceDomains, defaultServiceDomains)
-
-	if len(self.configServiceDomains) > 0 {
-		for gitDomain, typeAndDomain := range self.configServiceDomains {
-			splitData := strings.Split(typeAndDomain, ":")
-			if len(splitData) != 2 {
-				self.log.Errorf("Unexpected format for git service: '%s'. Expected something like 'github.com:github.com'", typeAndDomain)
-				continue
-			}
-
-			provider := splitData[0]
-			webDomain := splitData[1]
-
-			serviceDefinition, ok := serviceDefinitionByProvider[provider]
-			if !ok {
-				providerNames := []string{}
-				for _, serviceDefinition := range serviceDefinitions {
-					providerNames = append(providerNames, serviceDefinition.provider)
-				}
-				self.log.Errorf("Unknown git service type: '%s'. Expected one of %s", provider, strings.Join(providerNames, ", "))
-				continue
-			}
-
-			serviceDomains = append(serviceDomains, ServiceDomain{
-				gitDomain:         gitDomain,
-				webDomain:         webDomain,
-				serviceDefinition: serviceDefinition,
-			})
-		}
-	}
-
-	return serviceDomains
-}
-
-// a service domains pairs a service definition with the actual domain it's being served from.
-// Sometimes the git service is hosted in a custom domains so although it'll use say
-// the github service definition, it'll actually be served from e.g. my-custom-github.com
-type ServiceDomain struct {
-	gitDomain         string // the one that appears in the git remote url
-	webDomain         string // the one that appears in the web url
-	serviceDefinition ServiceDefinition
-}
-
-func (self ServiceDomain) getRootFromRemoteURL(repoURL string) (string, error) {
-	// we may want to make this more specific to the service in future e.g. if
-	// some new service comes along which has a different root url structure.
-	repoInfo, err := self.serviceDefinition.getRepoInfoFromURL(repoURL)
-	if err != nil {
-		return "", err
-	}
-	return fmt.Sprintf("https://%s/%s/%s", self.webDomain, repoInfo.Owner, repoInfo.Repository), nil
-}
-
-// RepoInformation holds some basic information about the repo
-type RepoInformation struct {
-	Owner      string
-	Repository string
-}
-
-type ServiceDefinition struct {
-	provider                        string
-	pullRequestURLIntoDefaultBranch string
-	pullRequestURLIntoTargetBranch  string
-	commitURL                       string
-	regexStrings                    []string
-}
-
-func (self ServiceDefinition) getRepoInfoFromURL(url string) (*RepoInformation, error) {
-	for _, regexStr := range self.regexStrings {
-		re := regexp.MustCompile(regexStr)
-		matches := utils.FindNamedMatches(re, url)
-		if matches != nil {
-			return &RepoInformation{
-				Owner:      matches["owner"],
-				Repository: matches["repo"],
-			}, nil
-		}
-	}
-
-	return nil, errors.New("Failed to parse repo information from url")
-}
-
-type Service struct {
-	root string
-	ServiceDefinition
-}
-
-func (self *Service) getPullRequestURLIntoDefaultBranch(from string) string {
-	return self.resolveUrl(self.pullRequestURLIntoDefaultBranch, map[string]string{"From": from})
-}
-
-func (self *Service) getPullRequestURLIntoTargetBranch(from string, to string) string {
-	return self.resolveUrl(self.pullRequestURLIntoTargetBranch, map[string]string{"From": from, "To": to})
-}
-
-func (self *Service) getCommitURL(commitSha string) string {
-	return self.resolveUrl(self.commitURL, map[string]string{"CommitSha": commitSha})
-}
-
-func (self *Service) resolveUrl(templateString string, args map[string]string) string {
-	return self.root + utils.ResolvePlaceholderString(templateString, args)
-}

pkg/commands/hosting_service/hosting_service_test.go

@@ -1,233 +0,0 @@
-package hosting_service
-
-import (
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/jesseduffield/lazygit/pkg/test"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGetRepoInfoFromURL(t *testing.T) {
-	type scenario struct {
-		serviceDefinition ServiceDefinition
-		testName          string
-		repoURL           string
-		test              func(*RepoInformation)
-	}
-
-	scenarios := []scenario{
-		{
-			githubServiceDef,
-			"Returns repository information for git remote url",
-			"git@github.com:petersmith/super_calculator",
-			func(repoInfo *RepoInformation) {
-				assert.EqualValues(t, repoInfo.Owner, "petersmith")
-				assert.EqualValues(t, repoInfo.Repository, "super_calculator")
-			},
-		},
-		{
-			githubServiceDef,
-			"Returns repository information for git remote url, trimming trailing '.git'",
-			"git@github.com:petersmith/super_calculator.git",
-			func(repoInfo *RepoInformation) {
-				assert.EqualValues(t, repoInfo.Owner, "petersmith")
-				assert.EqualValues(t, repoInfo.Repository, "super_calculator")
-			},
-		},
-		{
-			githubServiceDef,
-			"Returns repository information for ssh remote url",
-			"ssh://git@github.com/petersmith/super_calculator",
-			func(repoInfo *RepoInformation) {
-				assert.EqualValues(t, repoInfo.Owner, "petersmith")
-				assert.EqualValues(t, repoInfo.Repository, "super_calculator")
-			},
-		},
-		{
-			githubServiceDef,
-			"Returns repository information for http remote url",
-			"https://my_username@bitbucket.org/johndoe/social_network.git",
-			func(repoInfo *RepoInformation) {
-				assert.EqualValues(t, repoInfo.Owner, "johndoe")
-				assert.EqualValues(t, repoInfo.Repository, "social_network")
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			result, err := s.serviceDefinition.getRepoInfoFromURL(s.repoURL)
-			assert.NoError(t, err)
-			s.test(result)
-		})
-	}
-}
-
-func TestGetPullRequestURL(t *testing.T) {
-	type scenario struct {
-		testName             string
-		from                 string
-		to                   string
-		remoteUrl            string
-		configServiceDomains map[string]string
-		test                 func(url string, err error)
-		expectedLoggedErrors []string
-	}
-
-	scenarios := []scenario{
-		{
-			testName:  "Opens a link to new pull request on bitbucket",
-			from:      "feature/profile-page",
-			remoteUrl: "git@bitbucket.org:johndoe/social_network.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on bitbucket with http remote url",
-			from:      "feature/events",
-			remoteUrl: "https://my_username@bitbucket.org/johndoe/social_network.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/events&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on github",
-			from:      "feature/sum-operation",
-			remoteUrl: "git@github.com:peter/calculator.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://github.com/peter/calculator/compare/feature/sum-operation?expand=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on bitbucket with specific target branch",
-			from:      "feature/profile-page/avatar",
-			to:        "feature/profile-page",
-			remoteUrl: "git@bitbucket.org:johndoe/social_network.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page/avatar&dest=feature/profile-page&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on bitbucket with http remote url with specified target branch",
-			from:      "feature/remote-events",
-			to:        "feature/events",
-			remoteUrl: "https://my_username@bitbucket.org/johndoe/social_network.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/remote-events&dest=feature/events&t=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on github with specific target branch",
-			from:      "feature/sum-operation",
-			to:        "feature/operations",
-			remoteUrl: "git@github.com:peter/calculator.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://github.com/peter/calculator/compare/feature/operations...feature/sum-operation?expand=1", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab",
-			from:      "feature/ui",
-			remoteUrl: "git@gitlab.com:peter/calculator.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/ui", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab in nested groups",
-			from:      "feature/ui",
-			remoteUrl: "git@gitlab.com:peter/public/calculator.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/public/calculator/merge_requests/new?merge_request[source_branch]=feature/ui", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab with specific target branch",
-			from:      "feature/commit-ui",
-			to:        "epic/ui",
-			remoteUrl: "git@gitlab.com:peter/calculator.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/commit-ui&merge_request[target_branch]=epic/ui", url)
-			},
-		},
-		{
-			testName:  "Opens a link to new pull request on gitlab with specific target branch in nested groups",
-			from:      "feature/commit-ui",
-			to:        "epic/ui",
-			remoteUrl: "git@gitlab.com:peter/public/calculator.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/peter/public/calculator/merge_requests/new?merge_request[source_branch]=feature/commit-ui&merge_request[target_branch]=epic/ui", url)
-			},
-		},
-		{
-			testName:  "Throws an error if git service is unsupported",
-			from:      "feature/divide-operation",
-			remoteUrl: "git@something.com:peter/calculator.git",
-			test: func(url string, err error) {
-				assert.EqualError(t, err, "Unsupported git service")
-			},
-		},
-		{
-			testName:  "Does not log error when config service domains are valid",
-			from:      "feature/profile-page",
-			remoteUrl: "git@bitbucket.org:johndoe/social_network.git",
-			configServiceDomains: map[string]string{
-				// valid configuration for a custom service URL
-				"git.work.com": "gitlab:code.work.com",
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page&t=1", url)
-			},
-			expectedLoggedErrors: nil,
-		},
-		{
-			testName:  "Logs error when config service domain is malformed",
-			from:      "feature/profile-page",
-			remoteUrl: "git@bitbucket.org:johndoe/social_network.git",
-			configServiceDomains: map[string]string{
-				"noservice.work.com": "noservice.work.com",
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page&t=1", url)
-			},
-			expectedLoggedErrors: []string{"Unexpected format for git service: 'noservice.work.com'. Expected something like 'github.com:github.com'"},
-		},
-		{
-			testName:  "Logs error when config service domain uses unknown provider",
-			from:      "feature/profile-page",
-			remoteUrl: "git@bitbucket.org:johndoe/social_network.git",
-			configServiceDomains: map[string]string{
-				"invalid.work.com": "noservice:invalid.work.com",
-			},
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page&t=1", url)
-			},
-			expectedLoggedErrors: []string{"Unknown git service type: 'noservice'. Expected one of github, bitbucket, gitlab"},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			tr := i18n.EnglishTranslationSet()
-			log := &test.FakeFieldLogger{}
-			hostingServiceMgr := NewHostingServiceMgr(log, &tr, s.remoteUrl, s.configServiceDomains)
-			s.test(hostingServiceMgr.GetPullRequestURL(s.from, s.to))
-			log.AssertErrors(t, s.expectedLoggedErrors)
-		})
-	}
-}

pkg/commands/loaders/branches.go

@@ -1,173 +0,0 @@
-package loaders
-
-import (
-	"regexp"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/common"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// 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
-
-// if we find out we need to use one of these functions in the git.go file, we
-// can just pull them out of here and put them there and then call them from in here
-
-// BranchLoader returns a list of Branch objects for the current repo
-type BranchLoader struct {
-	*common.Common
-	getRawBranches       func() (string, error)
-	getCurrentBranchName func() (string, string, error)
-}
-
-type BranchLoaderGitCommand interface {
-	GetRawBranches() (string, error)
-	CurrentBranchName() (string, string, error)
-}
-
-func NewBranchLoader(
-	cmn *common.Common,
-	gitCommand BranchLoaderGitCommand,
-) *BranchLoader {
-	return &BranchLoader{
-		Common:               cmn,
-		getRawBranches:       gitCommand.GetRawBranches,
-		getCurrentBranchName: gitCommand.CurrentBranchName,
-	}
-}
-
-// Load the list of branches for the current repo
-func (self *BranchLoader) Load(reflogCommits []*models.Commit) []*models.Branch {
-	branches := self.obtainBranches()
-
-	reflogBranches := self.obtainReflogBranches(reflogCommits)
-
-	// loop through reflog branches. If there is a match, merge them, then remove it from the branches and keep it in the reflog branches
-	branchesWithRecency := make([]*models.Branch, 0)
-outer:
-	for _, reflogBranch := range reflogBranches {
-		for j, branch := range branches {
-			if branch.Head {
-				continue
-			}
-			if strings.EqualFold(reflogBranch.Name, branch.Name) {
-				branch.Recency = reflogBranch.Recency
-				branchesWithRecency = append(branchesWithRecency, branch)
-				branches = append(branches[0:j], branches[j+1:]...)
-				continue outer
-			}
-		}
-	}
-
-	branches = append(branchesWithRecency, branches...)
-
-	foundHead := false
-	for i, branch := range branches {
-		if branch.Head {
-			foundHead = true
-			branch.Recency = "  *"
-			branches = append(branches[0:i], branches[i+1:]...)
-			branches = append([]*models.Branch{branch}, branches...)
-			break
-		}
-	}
-	if !foundHead {
-		currentBranchName, currentBranchDisplayName, err := self.getCurrentBranchName()
-		if err != nil {
-			panic(err)
-		}
-		branches = append([]*models.Branch{{Name: currentBranchName, DisplayName: currentBranchDisplayName, Head: true, Recency: "  *"}}, branches...)
-	}
-	return branches
-}
-
-func (self *BranchLoader) obtainBranches() []*models.Branch {
-	output, err := self.getRawBranches()
-	if err != nil {
-		panic(err)
-	}
-
-	trimmedOutput := strings.TrimSpace(output)
-	outputLines := strings.Split(trimmedOutput, "\n")
-	branches := make([]*models.Branch, 0, len(outputLines))
-	for _, line := range outputLines {
-		if line == "" {
-			continue
-		}
-
-		split := strings.Split(line, SEPARATION_CHAR)
-		if len(split) != 4 {
-			// Ignore line if it isn't separated into 4 parts
-			// This is probably a warning message, for more info see:
-			// https://github.com/jesseduffield/lazygit/issues/1385#issuecomment-885580439
-			continue
-		}
-
-		name := strings.TrimPrefix(split[1], "heads/")
-		branch := &models.Branch{
-			Name:      name,
-			Pullables: "?",
-			Pushables: "?",
-			Head:      split[0] == "*",
-		}
-
-		upstreamName := split[2]
-		if upstreamName == "" {
-			branches = append(branches, branch)
-			continue
-		}
-
-		branch.UpstreamName = upstreamName
-
-		track := split[3]
-		re := regexp.MustCompile(`ahead (\d+)`)
-		match := re.FindStringSubmatch(track)
-		if len(match) > 1 {
-			branch.Pushables = match[1]
-		} else {
-			branch.Pushables = "0"
-		}
-
-		re = regexp.MustCompile(`behind (\d+)`)
-		match = re.FindStringSubmatch(track)
-		if len(match) > 1 {
-			branch.Pullables = match[1]
-		} else {
-			branch.Pullables = "0"
-		}
-
-		branches = append(branches, branch)
-	}
-
-	return branches
-}
-
-// TODO: only look at the new reflog commits, and otherwise store the recencies in
-// int form against the branch to recalculate the time ago
-func (self *BranchLoader) obtainReflogBranches(reflogCommits []*models.Commit) []*models.Branch {
-	foundBranchesMap := map[string]bool{}
-	re := regexp.MustCompile(`checkout: moving from ([\S]+) to ([\S]+)`)
-	reflogBranches := make([]*models.Branch, 0, len(reflogCommits))
-	for _, commit := range reflogCommits {
-		if match := re.FindStringSubmatch(commit.Name); len(match) == 3 {
-			recency := utils.UnixToTimeAgo(commit.UnixTimestamp)
-			for _, branchName := range match[1:] {
-				if !foundBranchesMap[branchName] {
-					foundBranchesMap[branchName] = true
-					reflogBranches = append(reflogBranches, &models.Branch{
-						Recency: recency,
-						Name:    branchName,
-					})
-				}
-			}
-		}
-	}
-	return reflogBranches
-}

pkg/commands/loaders/commit_files.go

@@ -1,57 +0,0 @@
-package loaders
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/common"
-)
-
-type CommitFileLoader struct {
-	*common.Common
-	cmd oscommands.ICmdObjBuilder
-}
-
-func NewCommitFileLoader(common *common.Common, cmd oscommands.ICmdObjBuilder) *CommitFileLoader {
-	return &CommitFileLoader{
-		Common: common,
-		cmd:    cmd,
-	}
-}
-
-// GetFilesInDiff get the specified commit files
-func (self *CommitFileLoader) GetFilesInDiff(from string, to string, reverse bool) ([]*models.CommitFile, error) {
-	reverseFlag := ""
-	if reverse {
-		reverseFlag = " -R "
-	}
-
-	filenames, err := self.cmd.New(fmt.Sprintf("git diff --submodule --no-ext-diff --name-status -z --no-renames %s %s %s", reverseFlag, from, to)).RunWithOutput()
-	if err != nil {
-		return nil, err
-	}
-
-	return self.getCommitFilesFromFilenames(filenames), nil
-}
-
-// filenames string is something like "file1\nfile2\nfile3"
-func (self *CommitFileLoader) getCommitFilesFromFilenames(filenames string) []*models.CommitFile {
-	commitFiles := make([]*models.CommitFile, 0)
-
-	lines := strings.Split(strings.TrimRight(filenames, "\x00"), "\x00")
-	n := len(lines)
-	for i := 0; i < n-1; i += 2 {
-		// typical result looks like 'A my_file' meaning my_file was added
-		changeStatus := lines[i]
-		name := lines[i+1]
-
-		commitFiles = append(commitFiles, &models.CommitFile{
-			Name:         name,
-			ChangeStatus: changeStatus,
-		})
-	}
-
-	return commitFiles
-}

pkg/commands/loaders/commits.go

@@ -1,461 +0,0 @@
-package loaders
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/commands/types/enums"
-	"github.com/jesseduffield/lazygit/pkg/common"
-	"github.com/jesseduffield/lazygit/pkg/gui/style"
-)
-
-// context:
-// here we get the commits from git log but format them to show whether they're
-// unpushed/pushed/merged into the base branch or not, or if they're yet to
-// be processed as part of a rebase (these won't appear in git log but we
-// grab them from the rebase-related files in the .git directory to show them
-
-const SEPARATION_CHAR = "|"
-
-// CommitLoader returns a list of Commit objects for the current repo
-type CommitLoader struct {
-	*common.Common
-	cmd oscommands.ICmdObjBuilder
-
-	getCurrentBranchName func() (string, string, error)
-	getRebaseMode        func() (enums.RebaseMode, error)
-	readFile             func(filename string) ([]byte, error)
-	walkFiles            func(root string, fn filepath.WalkFunc) error
-	dotGitDir            string
-}
-
-type CommitLoaderGitCommand interface {
-	CurrentBranchName() (string, string, error)
-	RebaseMode() (enums.RebaseMode, error)
-	GetCmd() oscommands.ICmdObjBuilder
-	GetDotGitDir() string
-}
-
-// making our dependencies explicit for the sake of easier testing
-func NewCommitLoader(
-	cmn *common.Common,
-	gitCommand CommitLoaderGitCommand,
-) *CommitLoader {
-	return &CommitLoader{
-		Common:               cmn,
-		cmd:                  gitCommand.GetCmd(),
-		getCurrentBranchName: gitCommand.CurrentBranchName,
-		getRebaseMode:        gitCommand.RebaseMode,
-		readFile:             ioutil.ReadFile,
-		walkFiles:            filepath.Walk,
-		dotGitDir:            gitCommand.GetDotGitDir(),
-	}
-}
-
-type GetCommitsOptions struct {
-	Limit                bool
-	FilterPath           string
-	IncludeRebaseCommits bool
-	RefName              string // e.g. "HEAD" or "my_branch"
-	// determines if we show the whole git graph i.e. pass the '--all' flag
-	All bool
-}
-
-// GetCommits obtains the commits of the current branch
-func (self *CommitLoader) GetCommits(opts GetCommitsOptions) ([]*models.Commit, error) {
-	commits := []*models.Commit{}
-	var rebasingCommits []*models.Commit
-	rebaseMode, err := self.getRebaseMode()
-	if err != nil {
-		return nil, err
-	}
-
-	if opts.IncludeRebaseCommits && opts.FilterPath == "" {
-		var err error
-		rebasingCommits, err = self.MergeRebasingCommits(commits)
-		if err != nil {
-			return nil, err
-		}
-		commits = append(commits, rebasingCommits...)
-	}
-
-	passedFirstPushedCommit := false
-	firstPushedCommit, err := self.getFirstPushedCommit(opts.RefName)
-	if err != nil {
-		// must have no upstream branch so we'll consider everything as pushed
-		passedFirstPushedCommit = true
-	}
-
-	err = self.getLogCmd(opts).RunAndProcessLines(func(line string) (bool, error) {
-		if canExtractCommit(line) {
-			commit := self.extractCommitFromLine(line)
-			if commit.Sha == firstPushedCommit {
-				passedFirstPushedCommit = true
-			}
-			commit.Status = map[bool]string{true: "unpushed", false: "pushed"}[!passedFirstPushedCommit]
-			commits = append(commits, commit)
-		}
-		return false, nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	if len(commits) == 0 {
-		return commits, nil
-	}
-
-	if rebaseMode != enums.REBASE_MODE_NONE {
-		currentCommit := commits[len(rebasingCommits)]
-		youAreHere := style.FgYellow.Sprintf("<-- %s ---", self.Tr.YouAreHere)
-		currentCommit.Name = fmt.Sprintf("%s %s", youAreHere, currentCommit.Name)
-	}
-
-	commits, err = self.setCommitMergedStatuses(opts.RefName, commits)
-	if err != nil {
-		return nil, err
-	}
-
-	return commits, nil
-}
-
-func (self *CommitLoader) MergeRebasingCommits(commits []*models.Commit) ([]*models.Commit, error) {
-	// chances are we have as many commits as last time so we'll set the capacity to be the old length
-	result := make([]*models.Commit, 0, len(commits))
-	for i, commit := range commits {
-		if commit.Status != "rebasing" { // removing the existing rebase commits so we can add the refreshed ones
-			result = append(result, commits[i:]...)
-			break
-		}
-	}
-
-	rebaseMode, err := self.getRebaseMode()
-	if err != nil {
-		return nil, err
-	}
-
-	if rebaseMode == enums.REBASE_MODE_NONE {
-		// not in rebase mode so return original commits
-		return result, nil
-	}
-
-	rebasingCommits, err := self.getHydratedRebasingCommits(rebaseMode)
-	if err != nil {
-		return nil, err
-	}
-	if len(rebasingCommits) > 0 {
-		result = append(rebasingCommits, result...)
-	}
-
-	return result, nil
-}
-
-// extractCommitFromLine takes a line from a git log and extracts the sha, message, date, and tag if present
-// then puts them into a commit object
-// example input:
-// 8ad01fe32fcc20f07bc6693f87aa4977c327f1e1|10 hours ago|Jesse Duffield| (HEAD -> master, tag: v0.15.2)|refresh commits when adding a tag
-func (self *CommitLoader) extractCommitFromLine(line string) *models.Commit {
-	split := strings.Split(line, SEPARATION_CHAR)
-
-	sha := split[0]
-	unixTimestamp := split[1]
-	author := split[2]
-	extraInfo := strings.TrimSpace(split[3])
-	parentHashes := split[4]
-
-	message := strings.Join(split[5:], SEPARATION_CHAR)
-	tags := []string{}
-
-	if extraInfo != "" {
-		re := regexp.MustCompile(`tag: ([^,\)]+)`)
-		tagMatch := re.FindStringSubmatch(extraInfo)
-		if len(tagMatch) > 1 {
-			tags = append(tags, tagMatch[1])
-		}
-	}
-
-	unitTimestampInt, _ := strconv.Atoi(unixTimestamp)
-
-	return &models.Commit{
-		Sha:           sha,
-		Name:          message,
-		Tags:          tags,
-		ExtraInfo:     extraInfo,
-		UnixTimestamp: int64(unitTimestampInt),
-		Author:        author,
-		Parents:       strings.Split(parentHashes, " "),
-	}
-}
-
-func (self *CommitLoader) getHydratedRebasingCommits(rebaseMode enums.RebaseMode) ([]*models.Commit, error) {
-	commits, err := self.getRebasingCommits(rebaseMode)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(commits) == 0 {
-		return nil, nil
-	}
-
-	commitShas := make([]string, len(commits))
-	for i, commit := range commits {
-		commitShas[i] = commit.Sha
-	}
-
-	// note that we're not filtering these as we do non-rebasing commits just because
-	// I suspect that will cause some damage
-	cmdObj := self.cmd.New(
-		fmt.Sprintf(
-			"git show %s --no-patch --oneline %s --abbrev=%d",
-			strings.Join(commitShas, " "),
-			prettyFormat,
-			20,
-		),
-	)
-
-	hydratedCommits := make([]*models.Commit, 0, len(commits))
-	i := 0
-	err = cmdObj.RunAndProcessLines(func(line string) (bool, error) {
-		if canExtractCommit(line) {
-			commit := self.extractCommitFromLine(line)
-			matchingCommit := commits[i]
-			commit.Action = matchingCommit.Action
-			commit.Status = matchingCommit.Status
-			hydratedCommits = append(hydratedCommits, commit)
-			i++
-		}
-		return false, nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return hydratedCommits, nil
-}
-
-// getRebasingCommits obtains the commits that we're in the process of rebasing
-func (self *CommitLoader) getRebasingCommits(rebaseMode enums.RebaseMode) ([]*models.Commit, error) {
-	switch rebaseMode {
-	case enums.REBASE_MODE_MERGING:
-		return self.getNormalRebasingCommits()
-	case enums.REBASE_MODE_INTERACTIVE:
-		return self.getInteractiveRebasingCommits()
-	default:
-		return nil, nil
-	}
-}
-
-func (self *CommitLoader) getNormalRebasingCommits() ([]*models.Commit, error) {
-	rewrittenCount := 0
-	bytesContent, err := self.readFile(filepath.Join(self.dotGitDir, "rebase-apply/rewritten"))
-	if err == nil {
-		content := string(bytesContent)
-		rewrittenCount = len(strings.Split(content, "\n"))
-	}
-
-	// we know we're rebasing, so lets get all the files whose names have numbers
-	commits := []*models.Commit{}
-	err = self.walkFiles(filepath.Join(self.dotGitDir, "rebase-apply"), func(path string, f os.FileInfo, err error) error {
-		if rewrittenCount > 0 {
-			rewrittenCount--
-			return nil
-		}
-		if err != nil {
-			return err
-		}
-		re := regexp.MustCompile(`^\d+$`)
-		if !re.MatchString(f.Name()) {
-			return nil
-		}
-		bytesContent, err := self.readFile(path)
-		if err != nil {
-			return err
-		}
-		content := string(bytesContent)
-		commit, err := self.commitFromPatch(content)
-		if err != nil {
-			return err
-		}
-		commits = append([]*models.Commit{commit}, commits...)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return commits, nil
-}
-
-// git-rebase-todo example:
-// pick ac446ae94ee560bdb8d1d057278657b251aaef17 ac446ae
-// pick afb893148791a2fbd8091aeb81deba4930c73031 afb8931
-
-// git-rebase-todo.backup example:
-// pick 49cbba374296938ea86bbd4bf4fee2f6ba5cccf6 third commit on master
-// pick ac446ae94ee560bdb8d1d057278657b251aaef17 blah  commit on master
-// pick afb893148791a2fbd8091aeb81deba4930c73031 fourth commit on master
-
-// getInteractiveRebasingCommits takes our git-rebase-todo and our git-rebase-todo.backup files
-// and extracts out the sha and names of commits that we still have to go
-// in the rebase:
-func (self *CommitLoader) getInteractiveRebasingCommits() ([]*models.Commit, error) {
-	bytesContent, err := self.readFile(filepath.Join(self.dotGitDir, "rebase-merge/git-rebase-todo"))
-	if err != nil {
-		self.Log.Error(fmt.Sprintf("error occurred reading git-rebase-todo: %s", err.Error()))
-		// we assume an error means the file doesn't exist so we just return
-		return nil, nil
-	}
-
-	commits := []*models.Commit{}
-	lines := strings.Split(string(bytesContent), "\n")
-	for _, line := range lines {
-		if line == "" || line == "noop" {
-			return commits, nil
-		}
-		if strings.HasPrefix(line, "#") {
-			continue
-		}
-		splitLine := strings.Split(line, " ")
-		commits = append([]*models.Commit{{
-			Sha:    splitLine[1],
-			Name:   strings.Join(splitLine[2:], " "),
-			Status: "rebasing",
-			Action: splitLine[0],
-		}}, commits...)
-	}
-
-	return commits, nil
-}
-
-// assuming the file starts like this:
-// From e93d4193e6dd45ca9cf3a5a273d7ba6cd8b8fb20 Mon Sep 17 00:00:00 2001
-// From: Lazygit Tester <test@example.com>
-// Date: Wed, 5 Dec 2018 21:03:23 +1100
-// Subject: second commit on master
-func (self *CommitLoader) commitFromPatch(content string) (*models.Commit, error) {
-	lines := strings.Split(content, "\n")
-	sha := strings.Split(lines[0], " ")[1]
-	name := strings.TrimPrefix(lines[3], "Subject: ")
-	return &models.Commit{
-		Sha:    sha,
-		Name:   name,
-		Status: "rebasing",
-	}, nil
-}
-
-func (self *CommitLoader) setCommitMergedStatuses(refName string, commits []*models.Commit) ([]*models.Commit, error) {
-	ancestor, err := self.getMergeBase(refName)
-	if err != nil {
-		return nil, err
-	}
-	if ancestor == "" {
-		return commits, nil
-	}
-	passedAncestor := false
-	for i, commit := range commits {
-		if strings.HasPrefix(ancestor, commit.Sha) {
-			passedAncestor = true
-		}
-		if commit.Status != "pushed" {
-			continue
-		}
-		if passedAncestor {
-			commits[i].Status = "merged"
-		}
-	}
-	return commits, nil
-}
-
-func (self *CommitLoader) getMergeBase(refName string) (string, error) {
-	currentBranch, _, err := self.getCurrentBranchName()
-	if err != nil {
-		return "", err
-	}
-
-	baseBranch := "master"
-	if strings.HasPrefix(currentBranch, "feature/") {
-		baseBranch = "develop"
-	}
-
-	// swallowing error because it's not a big deal; probably because there are no commits yet
-	output, _ := self.cmd.New(fmt.Sprintf("git merge-base %s %s", self.cmd.Quote(refName), self.cmd.Quote(baseBranch))).RunWithOutput()
-	return ignoringWarnings(output), nil
-}
-
-func ignoringWarnings(commandOutput string) string {
-	trimmedOutput := strings.TrimSpace(commandOutput)
-	split := strings.Split(trimmedOutput, "\n")
-	// need to get last line in case the first line is a warning about how the error is ambiguous.
-	// At some point we should find a way to make it unambiguous
-	lastLine := split[len(split)-1]
-
-	return lastLine
-}
-
-// getFirstPushedCommit returns the first commit SHA which has been pushed to the ref's upstream.
-// all commits above this are deemed unpushed and marked as such.
-func (self *CommitLoader) getFirstPushedCommit(refName string) (string, error) {
-	output, err := self.cmd.
-		New(
-			fmt.Sprintf("git merge-base %s %s@{u}", self.cmd.Quote(refName), self.cmd.Quote(refName)),
-		).
-		RunWithOutput()
-	if err != nil {
-		return "", err
-	}
-
-	return ignoringWarnings(output), nil
-}
-
-// getLog gets the git log.
-func (self *CommitLoader) getLogCmd(opts GetCommitsOptions) oscommands.ICmdObj {
-	limitFlag := ""
-	if opts.Limit {
-		limitFlag = " -300"
-	}
-
-	filterFlag := ""
-	if opts.FilterPath != "" {
-		filterFlag = fmt.Sprintf(" --follow -- %s", self.cmd.Quote(opts.FilterPath))
-	}
-
-	config := self.UserConfig.Git.Log
-
-	orderFlag := "--" + config.Order
-	allFlag := ""
-	if opts.All {
-		allFlag = " --all"
-	}
-
-	return self.cmd.New(
-		fmt.Sprintf(
-			"git log %s %s %s --oneline %s%s --abbrev=%d%s",
-			self.cmd.Quote(opts.RefName),
-			orderFlag,
-			allFlag,
-			prettyFormat,
-			limitFlag,
-			20,
-			filterFlag,
-		),
-	)
-}
-
-var prettyFormat = fmt.Sprintf(
-	"--pretty=format:\"%%H%s%%at%s%%aN%s%%d%s%%p%s%%s\"",
-	SEPARATION_CHAR,
-	SEPARATION_CHAR,
-	SEPARATION_CHAR,
-	SEPARATION_CHAR,
-	SEPARATION_CHAR,
-)
-
-func canExtractCommit(line string) bool {
-	return line != "" && strings.Split(line, " ")[0] != "gpg:"
-}

pkg/commands/loaders/commits_test.go

@@ -1,212 +0,0 @@
-package loaders
-
-import (
-	"path/filepath"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/commands/types/enums"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/stretchr/testify/assert"
-)
-
-func NewDummyCommitLoader() *CommitLoader {
-	cmn := utils.NewDummyCommon()
-
-	return &CommitLoader{
-		Common:               cmn,
-		cmd:                  nil,
-		getCurrentBranchName: func() (string, string, error) { return "master", "master", nil },
-		getRebaseMode:        func() (enums.RebaseMode, error) { return enums.REBASE_MODE_NONE, nil },
-		dotGitDir:            ".git",
-		readFile: func(filename string) ([]byte, error) {
-			return []byte(""), nil
-		},
-		walkFiles: func(root string, fn filepath.WalkFunc) error {
-			return nil
-		},
-	}
-}
-
-const commitsOutput = `0eea75e8c631fba6b58135697835d58ba4c18dbc|1640826609|Jesse Duffield| (HEAD -> better-tests)|b21997d6b4cbdf84b149|better typing for rebase mode
-b21997d6b4cbdf84b149d8e6a2c4d06a8e9ec164|1640824515|Jesse Duffield| (origin/better-tests)|e94e8fc5b6fab4cb755f|fix logging
-e94e8fc5b6fab4cb755f29f1bdb3ee5e001df35c|1640823749|Jesse Duffield||d8084cd558925eb7c9c3|refactor
-d8084cd558925eb7c9c38afeed5725c21653ab90|1640821426|Jesse Duffield||65f910ebd85283b5cce9|WIP
-65f910ebd85283b5cce9bf67d03d3f1a9ea3813a|1640821275|Jesse Duffield||26c07b1ab33860a1a759|WIP
-26c07b1ab33860a1a7591a0638f9925ccf497ffa|1640750752|Jesse Duffield||3d4470a6c072208722e5|WIP
-3d4470a6c072208722e5ae9a54bcb9634959a1c5|1640748818|Jesse Duffield||053a66a7be3da43aacdc|WIP
-053a66a7be3da43aacdc7aa78e1fe757b82c4dd2|1640739815|Jesse Duffield||985fe482e806b172aea4|refactoring the config struct`
-
-func TestGetCommits(t *testing.T) {
-	type scenario struct {
-		testName          string
-		runner            oscommands.ICmdObjRunner
-		expectedCommits   []*models.Commit
-		expectedError     error
-		rebaseMode        enums.RebaseMode
-		currentBranchName string
-		opts              GetCommitsOptions
-	}
-
-	scenarios := []scenario{
-		{
-			testName:          "should return no commits if there are none",
-			rebaseMode:        enums.REBASE_MODE_NONE,
-			currentBranchName: "master",
-			opts:              GetCommitsOptions{RefName: "HEAD", IncludeRebaseCommits: false},
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git merge-base "HEAD" "HEAD"@{u}`, "b21997d6b4cbdf84b149d8e6a2c4d06a8e9ec164", nil).
-				Expect(`git log "HEAD" --topo-order  --oneline --pretty=format:"%H|%at|%aN|%d|%p|%s" --abbrev=20`, "", nil),
-
-			expectedCommits: []*models.Commit{},
-			expectedError:   nil,
-		},
-		{
-			testName:          "should return commits if they are present",
-			rebaseMode:        enums.REBASE_MODE_NONE,
-			currentBranchName: "master",
-			opts:              GetCommitsOptions{RefName: "HEAD", IncludeRebaseCommits: false},
-			runner: oscommands.NewFakeRunner(t).
-				// here it's seeing which commits are yet to be pushed
-				Expect(`git merge-base "HEAD" "HEAD"@{u}`, "b21997d6b4cbdf84b149d8e6a2c4d06a8e9ec164", nil).
-				// here it's actually getting all the commits in a formatted form, one per line
-				Expect(`git log "HEAD" --topo-order  --oneline --pretty=format:"%H|%at|%aN|%d|%p|%s" --abbrev=20`, commitsOutput, nil).
-				// here it's seeing where our branch diverged from the master branch so that we can mark that commit and parent commits as 'merged'
-				Expect(`git merge-base "HEAD" "master"`, "26c07b1ab33860a1a7591a0638f9925ccf497ffa", nil),
-
-			expectedCommits: []*models.Commit{
-				{
-					Sha:           "0eea75e8c631fba6b58135697835d58ba4c18dbc",
-					Name:          "better typing for rebase mode",
-					Status:        "unpushed",
-					Action:        "",
-					Tags:          []string{},
-					ExtraInfo:     "(HEAD -> better-tests)",
-					Author:        "Jesse Duffield",
-					UnixTimestamp: 1640826609,
-					Parents: []string{
-						"b21997d6b4cbdf84b149",
-					},
-				},
-				{
-					Sha:           "b21997d6b4cbdf84b149d8e6a2c4d06a8e9ec164",
-					Name:          "fix logging",
-					Status:        "pushed",
-					Action:        "",
-					Tags:          []string{},
-					ExtraInfo:     "(origin/better-tests)",
-					Author:        "Jesse Duffield",
-					UnixTimestamp: 1640824515,
-					Parents: []string{
-						"e94e8fc5b6fab4cb755f",
-					},
-				},
-				{
-					Sha:           "e94e8fc5b6fab4cb755f29f1bdb3ee5e001df35c",
-					Name:          "refactor",
-					Status:        "pushed",
-					Action:        "",
-					Tags:          []string{},
-					ExtraInfo:     "",
-					Author:        "Jesse Duffield",
-					UnixTimestamp: 1640823749,
-					Parents: []string{
-						"d8084cd558925eb7c9c3",
-					},
-				},
-				{
-					Sha:           "d8084cd558925eb7c9c38afeed5725c21653ab90",
-					Name:          "WIP",
-					Status:        "pushed",
-					Action:        "",
-					Tags:          []string{},
-					ExtraInfo:     "",
-					Author:        "Jesse Duffield",
-					UnixTimestamp: 1640821426,
-					Parents: []string{
-						"65f910ebd85283b5cce9",
-					},
-				},
-				{
-					Sha:           "65f910ebd85283b5cce9bf67d03d3f1a9ea3813a",
-					Name:          "WIP",
-					Status:        "pushed",
-					Action:        "",
-					Tags:          []string{},
-					ExtraInfo:     "",
-					Author:        "Jesse Duffield",
-					UnixTimestamp: 1640821275,
-					Parents: []string{
-						"26c07b1ab33860a1a759",
-					},
-				},
-				{
-					Sha:           "26c07b1ab33860a1a7591a0638f9925ccf497ffa",
-					Name:          "WIP",
-					Status:        "merged",
-					Action:        "",
-					Tags:          []string{},
-					ExtraInfo:     "",
-					Author:        "Jesse Duffield",
-					UnixTimestamp: 1640750752,
-					Parents: []string{
-						"3d4470a6c072208722e5",
-					},
-				},
-				{
-					Sha:           "3d4470a6c072208722e5ae9a54bcb9634959a1c5",
-					Name:          "WIP",
-					Status:        "merged",
-					Action:        "",
-					Tags:          []string{},
-					ExtraInfo:     "",
-					Author:        "Jesse Duffield",
-					UnixTimestamp: 1640748818,
-					Parents: []string{
-						"053a66a7be3da43aacdc",
-					},
-				},
-				{
-					Sha:           "053a66a7be3da43aacdc7aa78e1fe757b82c4dd2",
-					Name:          "refactoring the config struct",
-					Status:        "merged",
-					Action:        "",
-					Tags:          []string{},
-					ExtraInfo:     "",
-					Author:        "Jesse Duffield",
-					UnixTimestamp: 1640739815,
-					Parents: []string{
-						"985fe482e806b172aea4",
-					},
-				},
-			},
-			expectedError: nil,
-		},
-	}
-
-	for _, scenario := range scenarios {
-		t.Run(scenario.testName, func(t *testing.T) {
-			builder := &CommitLoader{
-				Common: utils.NewDummyCommon(),
-				cmd:    oscommands.NewDummyCmdObjBuilder(scenario.runner),
-				getCurrentBranchName: func() (string, string, error) {
-					return scenario.currentBranchName, scenario.currentBranchName, nil
-				},
-				getRebaseMode: func() (enums.RebaseMode, error) { return scenario.rebaseMode, nil },
-				dotGitDir:     ".git",
-				readFile: func(filename string) ([]byte, error) {
-					return []byte(""), nil
-				},
-				walkFiles: func(root string, fn filepath.WalkFunc) error {
-					return nil
-				},
-			}
-
-			commits, err := builder.GetCommits(scenario.opts)
-
-			assert.Equal(t, scenario.expectedCommits, commits)
-			assert.Equal(t, scenario.expectedError, err)
-		})
-	}
-}

pkg/commands/loaders/files.go

@@ -1,134 +0,0 @@
-package loaders
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/common"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-type FileLoader struct {
-	*common.Common
-	cmd         oscommands.ICmdObjBuilder
-	gitConfig   git_config.IGitConfig
-	getFileType func(string) string
-}
-
-func NewFileLoader(cmn *common.Common, cmd oscommands.ICmdObjBuilder, gitConfig git_config.IGitConfig) *FileLoader {
-	return &FileLoader{
-		Common:      cmn,
-		cmd:         cmd,
-		gitConfig:   gitConfig,
-		getFileType: oscommands.FileType,
-	}
-}
-
-type GetStatusFileOptions struct {
-	NoRenames bool
-}
-
-func (self *FileLoader) GetStatusFiles(opts GetStatusFileOptions) []*models.File {
-	// check if config wants us ignoring untracked files
-	untrackedFilesSetting := self.gitConfig.Get("status.showUntrackedFiles")
-
-	if untrackedFilesSetting == "" {
-		untrackedFilesSetting = "all"
-	}
-	untrackedFilesArg := fmt.Sprintf("--untracked-files=%s", untrackedFilesSetting)
-
-	statuses, err := self.GitStatus(GitStatusOptions{NoRenames: opts.NoRenames, UntrackedFilesArg: untrackedFilesArg})
-	if err != nil {
-		self.Log.Error(err)
-	}
-	files := []*models.File{}
-
-	for _, status := range statuses {
-		if strings.HasPrefix(status.StatusString, "warning") {
-			self.Log.Warningf("warning when calling git status: %s", status.StatusString)
-			continue
-		}
-		change := status.Change
-		stagedChange := change[0:1]
-		unstagedChange := change[1:2]
-		untracked := utils.IncludesString([]string{"??", "A ", "AM"}, change)
-		hasNoStagedChanges := utils.IncludesString([]string{" ", "U", "?"}, stagedChange)
-		hasMergeConflicts := utils.IncludesString([]string{"DD", "AA", "UU", "AU", "UA", "UD", "DU"}, change)
-		hasInlineMergeConflicts := utils.IncludesString([]string{"UU", "AA"}, change)
-
-		file := &models.File{
-			Name:                    status.Name,
-			PreviousName:            status.PreviousName,
-			DisplayString:           status.StatusString,
-			HasStagedChanges:        !hasNoStagedChanges,
-			HasUnstagedChanges:      unstagedChange != " ",
-			Tracked:                 !untracked,
-			Deleted:                 unstagedChange == "D" || stagedChange == "D",
-			Added:                   unstagedChange == "A" || untracked,
-			HasMergeConflicts:       hasMergeConflicts,
-			HasInlineMergeConflicts: hasInlineMergeConflicts,
-			Type:                    self.getFileType(status.Name),
-			ShortStatus:             change,
-		}
-		files = append(files, file)
-	}
-
-	return files
-}
-
-// GitStatus returns the file status of the repo
-type GitStatusOptions struct {
-	NoRenames         bool
-	UntrackedFilesArg string
-}
-
-type FileStatus struct {
-	StatusString string
-	Change       string // ??, MM, AM, ...
-	Name         string
-	PreviousName string
-}
-
-func (c *FileLoader) GitStatus(opts GitStatusOptions) ([]FileStatus, error) {
-	noRenamesFlag := ""
-	if opts.NoRenames {
-		noRenamesFlag = " --no-renames"
-	}
-
-	statusLines, err := c.cmd.New(fmt.Sprintf("git status %s --porcelain -z%s", opts.UntrackedFilesArg, noRenamesFlag)).RunWithOutput()
-	if err != nil {
-		return []FileStatus{}, err
-	}
-
-	splitLines := strings.Split(statusLines, "\x00")
-	response := []FileStatus{}
-
-	for i := 0; i < len(splitLines); i++ {
-		original := splitLines[i]
-
-		if len(original) < 3 {
-			continue
-		}
-
-		status := FileStatus{
-			StatusString: original,
-			Change:       original[:2],
-			Name:         original[3:],
-			PreviousName: "",
-		}
-
-		if strings.HasPrefix(status.Change, "R") {
-			// if a line starts with 'R' then the next line is the original file.
-			status.PreviousName = strings.TrimSpace(splitLines[i+1])
-			status.StatusString = fmt.Sprintf("%s %s -> %s", status.Change, status.PreviousName, status.Name)
-			i++
-		}
-
-		response = append(response, status)
-	}
-
-	return response, nil
-}

pkg/commands/loaders/files_test.go

@@ -1,203 +0,0 @@
-package loaders
-
-import (
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGitCommandGetStatusFiles(t *testing.T) {
-	type scenario struct {
-		testName      string
-		runner        oscommands.ICmdObjRunner
-		expectedFiles []*models.File
-	}
-
-	scenarios := []scenario{
-		{
-			"No files found",
-			oscommands.NewFakeRunner(t).
-				Expect(`git status --untracked-files=yes --porcelain -z`, "", nil),
-			[]*models.File{},
-		},
-		{
-			"Several files found",
-			oscommands.NewFakeRunner(t).
-				Expect(
-					`git status --untracked-files=yes --porcelain -z`,
-					"MM file1.txt\x00A  file3.txt\x00AM file2.txt\x00?? file4.txt\x00UU file5.txt",
-					nil,
-				),
-			[]*models.File{
-				{
-					Name:                    "file1.txt",
-					HasStagedChanges:        true,
-					HasUnstagedChanges:      true,
-					Tracked:                 true,
-					Added:                   false,
-					Deleted:                 false,
-					HasMergeConflicts:       false,
-					HasInlineMergeConflicts: false,
-					DisplayString:           "MM file1.txt",
-					Type:                    "file",
-					ShortStatus:             "MM",
-				},
-				{
-					Name:                    "file3.txt",
-					HasStagedChanges:        true,
-					HasUnstagedChanges:      false,
-					Tracked:                 false,
-					Added:                   true,
-					Deleted:                 false,
-					HasMergeConflicts:       false,
-					HasInlineMergeConflicts: false,
-					DisplayString:           "A  file3.txt",
-					Type:                    "file",
-					ShortStatus:             "A ",
-				},
-				{
-					Name:                    "file2.txt",
-					HasStagedChanges:        true,
-					HasUnstagedChanges:      true,
-					Tracked:                 false,
-					Added:                   true,
-					Deleted:                 false,
-					HasMergeConflicts:       false,
-					HasInlineMergeConflicts: false,
-					DisplayString:           "AM file2.txt",
-					Type:                    "file",
-					ShortStatus:             "AM",
-				},
-				{
-					Name:                    "file4.txt",
-					HasStagedChanges:        false,
-					HasUnstagedChanges:      true,
-					Tracked:                 false,
-					Added:                   true,
-					Deleted:                 false,
-					HasMergeConflicts:       false,
-					HasInlineMergeConflicts: false,
-					DisplayString:           "?? file4.txt",
-					Type:                    "file",
-					ShortStatus:             "??",
-				},
-				{
-					Name:                    "file5.txt",
-					HasStagedChanges:        false,
-					HasUnstagedChanges:      true,
-					Tracked:                 true,
-					Added:                   false,
-					Deleted:                 false,
-					HasMergeConflicts:       true,
-					HasInlineMergeConflicts: true,
-					DisplayString:           "UU file5.txt",
-					Type:                    "file",
-					ShortStatus:             "UU",
-				},
-			},
-		},
-		{
-			"File with new line char",
-			oscommands.NewFakeRunner(t).
-				Expect(`git status --untracked-files=yes --porcelain -z`, "MM a\nb.txt", nil),
-			[]*models.File{
-				{
-					Name:                    "a\nb.txt",
-					HasStagedChanges:        true,
-					HasUnstagedChanges:      true,
-					Tracked:                 true,
-					Added:                   false,
-					Deleted:                 false,
-					HasMergeConflicts:       false,
-					HasInlineMergeConflicts: false,
-					DisplayString:           "MM a\nb.txt",
-					Type:                    "file",
-					ShortStatus:             "MM",
-				},
-			},
-		},
-		{
-			"Renamed files",
-			oscommands.NewFakeRunner(t).
-				Expect(
-					`git status --untracked-files=yes --porcelain -z`,
-					"R  after1.txt\x00before1.txt\x00RM after2.txt\x00before2.txt",
-					nil,
-				),
-			[]*models.File{
-				{
-					Name:                    "after1.txt",
-					PreviousName:            "before1.txt",
-					HasStagedChanges:        true,
-					HasUnstagedChanges:      false,
-					Tracked:                 true,
-					Added:                   false,
-					Deleted:                 false,
-					HasMergeConflicts:       false,
-					HasInlineMergeConflicts: false,
-					DisplayString:           "R  before1.txt -> after1.txt",
-					Type:                    "file",
-					ShortStatus:             "R ",
-				},
-				{
-					Name:                    "after2.txt",
-					PreviousName:            "before2.txt",
-					HasStagedChanges:        true,
-					HasUnstagedChanges:      true,
-					Tracked:                 true,
-					Added:                   false,
-					Deleted:                 false,
-					HasMergeConflicts:       false,
-					HasInlineMergeConflicts: false,
-					DisplayString:           "RM before2.txt -> after2.txt",
-					Type:                    "file",
-					ShortStatus:             "RM",
-				},
-			},
-		},
-		{
-			"File with arrow in name",
-			oscommands.NewFakeRunner(t).
-				Expect(
-					`git status --untracked-files=yes --porcelain -z`,
-					`?? a -> b.txt`,
-					nil,
-				),
-			[]*models.File{
-				{
-					Name:                    "a -> b.txt",
-					HasStagedChanges:        false,
-					HasUnstagedChanges:      true,
-					Tracked:                 false,
-					Added:                   true,
-					Deleted:                 false,
-					HasMergeConflicts:       false,
-					HasInlineMergeConflicts: false,
-					DisplayString:           "?? a -> b.txt",
-					Type:                    "file",
-					ShortStatus:             "??",
-				},
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			cmd := oscommands.NewDummyCmdObjBuilder(s.runner)
-			gitConfig := git_config.NewFakeGitConfig(map[string]string{"status.showUntrackedFiles": "yes"})
-
-			loader := &FileLoader{
-				Common:      utils.NewDummyCommon(),
-				cmd:         cmd,
-				gitConfig:   gitConfig,
-				getFileType: func(string) string { return "file" },
-			}
-
-			assert.EqualValues(t, s.expectedFiles, loader.GetStatusFiles(GetStatusFileOptions{}))
-		})
-	}
-}

pkg/commands/loaders/reflog_commits.go

@@ -1,66 +0,0 @@
-package loaders
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/common"
-)
-
-type ReflogCommitLoader struct {
-	*common.Common
-	cmd oscommands.ICmdObjBuilder
-}
-
-func NewReflogCommitLoader(common *common.Common, cmd oscommands.ICmdObjBuilder) *ReflogCommitLoader {
-	return &ReflogCommitLoader{
-		Common: common,
-		cmd:    cmd,
-	}
-}
-
-// GetReflogCommits only returns the new reflog commits since the given lastReflogCommit
-// if none is passed (i.e. it's value is nil) then we get all the reflog commits
-func (self *ReflogCommitLoader) GetReflogCommits(lastReflogCommit *models.Commit, filterPath string) ([]*models.Commit, bool, error) {
-	commits := make([]*models.Commit, 0)
-
-	filterPathArg := ""
-	if filterPath != "" {
-		filterPathArg = fmt.Sprintf(" --follow -- %s", self.cmd.Quote(filterPath))
-	}
-
-	cmdObj := self.cmd.New(fmt.Sprintf(`git log -g --abbrev=20 --format="%%h %%ct %%gs" %s`, filterPathArg))
-	onlyObtainedNewReflogCommits := false
-	err := cmdObj.RunAndProcessLines(func(line string) (bool, error) {
-		fields := strings.SplitN(line, " ", 3)
-		if len(fields) <= 2 {
-			return false, nil
-		}
-
-		unixTimestamp, _ := strconv.Atoi(fields[1])
-
-		commit := &models.Commit{
-			Sha:           fields[0],
-			Name:          fields[2],
-			UnixTimestamp: int64(unixTimestamp),
-			Status:        "reflog",
-		}
-
-		if lastReflogCommit != nil && commit.Sha == lastReflogCommit.Sha && commit.UnixTimestamp == lastReflogCommit.UnixTimestamp {
-			onlyObtainedNewReflogCommits = true
-			// after this point we already have these reflogs loaded so we'll simply return the new ones
-			return true, nil
-		}
-
-		commits = append(commits, commit)
-		return false, nil
-	})
-	if err != nil {
-		return nil, false, err
-	}
-
-	return commits, onlyObtainedNewReflogCommits, nil
-}

pkg/commands/loaders/remotes.go

@@ -1,79 +0,0 @@
-package loaders
-
-import (
-	"fmt"
-	"regexp"
-	"sort"
-	"strings"
-
-	gogit "github.com/jesseduffield/go-git/v5"
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/common"
-)
-
-type RemoteLoader struct {
-	*common.Common
-	cmd             oscommands.ICmdObjBuilder
-	getGoGitRemotes func() ([]*gogit.Remote, error)
-}
-
-func NewRemoteLoader(
-	common *common.Common,
-	cmd oscommands.ICmdObjBuilder,
-	getGoGitRemotes func() ([]*gogit.Remote, error),
-) *RemoteLoader {
-	return &RemoteLoader{
-		Common:          common,
-		cmd:             cmd,
-		getGoGitRemotes: getGoGitRemotes,
-	}
-}
-
-func (self *RemoteLoader) GetRemotes() ([]*models.Remote, error) {
-	remoteBranchesStr, err := self.cmd.New("git branch -r").RunWithOutput()
-	if err != nil {
-		return nil, err
-	}
-
-	goGitRemotes, err := self.getGoGitRemotes()
-	if err != nil {
-		return nil, err
-	}
-
-	// first step is to get our remotes from go-git
-	remotes := make([]*models.Remote, len(goGitRemotes))
-	for i, goGitRemote := range goGitRemotes {
-		remoteName := goGitRemote.Config().Name
-
-		re := regexp.MustCompile(fmt.Sprintf(`(?m)^\s*%s\/([\S]+)`, remoteName))
-		matches := re.FindAllStringSubmatch(remoteBranchesStr, -1)
-		branches := make([]*models.RemoteBranch, len(matches))
-		for j, match := range matches {
-			branches[j] = &models.RemoteBranch{
-				Name:       match[1],
-				RemoteName: remoteName,
-			}
-		}
-
-		remotes[i] = &models.Remote{
-			Name:     goGitRemote.Config().Name,
-			Urls:     goGitRemote.Config().URLs,
-			Branches: branches,
-		}
-	}
-
-	// now lets sort our remotes by name alphabetically
-	sort.Slice(remotes, func(i, j int) bool {
-		// we want origin at the top because we'll be most likely to want it
-		if remotes[i].Name == "origin" {
-			return true
-		}
-		if remotes[j].Name == "origin" {
-			return false
-		}
-		return strings.ToLower(remotes[i].Name) < strings.ToLower(remotes[j].Name)
-	})
-
-	return remotes, nil
-}

pkg/commands/loaders/stash.go

@@ -1,80 +0,0 @@
-package loaders
-
-import (
-	"regexp"
-	"strconv"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/common"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-type StashLoader struct {
-	*common.Common
-	cmd oscommands.ICmdObjBuilder
-}
-
-func NewStashLoader(
-	common *common.Common,
-	cmd oscommands.ICmdObjBuilder,
-) *StashLoader {
-	return &StashLoader{
-		Common: common,
-		cmd:    cmd,
-	}
-}
-
-func (self *StashLoader) GetStashEntries(filterPath string) []*models.StashEntry {
-	if filterPath == "" {
-		return self.getUnfilteredStashEntries()
-	}
-
-	rawString, err := self.cmd.New("git stash list --name-only").RunWithOutput()
-	if err != nil {
-		return self.getUnfilteredStashEntries()
-	}
-	stashEntries := []*models.StashEntry{}
-	var currentStashEntry *models.StashEntry
-	lines := utils.SplitLines(rawString)
-	isAStash := func(line string) bool { return strings.HasPrefix(line, "stash@{") }
-	re := regexp.MustCompile(`stash@\{(\d+)\}`)
-
-outer:
-	for i := 0; i < len(lines); i++ {
-		if !isAStash(lines[i]) {
-			continue
-		}
-		match := re.FindStringSubmatch(lines[i])
-		idx, err := strconv.Atoi(match[1])
-		if err != nil {
-			return self.getUnfilteredStashEntries()
-		}
-		currentStashEntry = self.stashEntryFromLine(lines[i], idx)
-		for i+1 < len(lines) && !isAStash(lines[i+1]) {
-			i++
-			if lines[i] == filterPath {
-				stashEntries = append(stashEntries, currentStashEntry)
-				continue outer
-			}
-		}
-	}
-	return stashEntries
-}
-
-func (self *StashLoader) getUnfilteredStashEntries() []*models.StashEntry {
-	rawString, _ := self.cmd.New("git stash list --pretty='%gs'").RunWithOutput()
-	stashEntries := []*models.StashEntry{}
-	for i, line := range utils.SplitLines(rawString) {
-		stashEntries = append(stashEntries, self.stashEntryFromLine(line, i))
-	}
-	return stashEntries
-}
-
-func (c *StashLoader) stashEntryFromLine(line string, index int) *models.StashEntry {
-	return &models.StashEntry{
-		Name:  line,
-		Index: index,
-	}
-}

pkg/commands/loaders/stash_test.go

@@ -1,59 +0,0 @@
-package loaders
-
-import (
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGitCommandGetStashEntries(t *testing.T) {
-	type scenario struct {
-		testName             string
-		filterPath           string
-		runner               oscommands.ICmdObjRunner
-		expectedStashEntries []*models.StashEntry
-	}
-
-	scenarios := []scenario{
-		{
-			"No stash entries found",
-			"",
-			oscommands.NewFakeRunner(t).
-				Expect(`git stash list --pretty='%gs'`, "", nil),
-			[]*models.StashEntry{},
-		},
-		{
-			"Several stash entries found",
-			"",
-			oscommands.NewFakeRunner(t).
-				Expect(
-					`git stash list --pretty='%gs'`,
-					"WIP on add-pkg-commands-test: 55c6af2 increase parallel build\nWIP on master: bb86a3f update github template",
-					nil,
-				),
-			[]*models.StashEntry{
-				{
-					Index: 0,
-					Name:  "WIP on add-pkg-commands-test: 55c6af2 increase parallel build",
-				},
-				{
-					Index: 1,
-					Name:  "WIP on master: bb86a3f update github template",
-				},
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.testName, func(t *testing.T) {
-			cmd := oscommands.NewDummyCmdObjBuilder(s.runner)
-
-			loader := NewStashLoader(utils.NewDummyCommon(), cmd)
-
-			assert.EqualValues(t, s.expectedStashEntries, loader.GetStashEntries(""))
-		})
-	}
-}

pkg/commands/loaders/tags.go

@@ -1,51 +0,0 @@
-package loaders
-
-import (
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/common"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-type TagLoader struct {
-	*common.Common
-	cmd oscommands.ICmdObjBuilder
-}
-
-func NewTagLoader(
-	common *common.Common,
-	cmd oscommands.ICmdObjBuilder,
-) *TagLoader {
-	return &TagLoader{
-		Common: common,
-		cmd:    cmd,
-	}
-}
-
-func (self *TagLoader) GetTags() ([]*models.Tag, error) {
-	// get remote branches, sorted  by creation date (descending)
-	// see: https://git-scm.com/docs/git-tag#Documentation/git-tag.txt---sortltkeygt
-	remoteBranchesStr, err := self.cmd.New(`git tag --list --sort=-creatordate`).RunWithOutput()
-	if err != nil {
-		return nil, err
-	}
-
-	content := utils.TrimTrailingNewline(remoteBranchesStr)
-	if content == "" {
-		return nil, nil
-	}
-
-	split := strings.Split(content, "\n")
-
-	// first step is to get our remotes from go-git
-	tags := make([]*models.Tag, len(split))
-	for i, tagName := range split {
-		tags[i] = &models.Tag{
-			Name: tagName,
-		}
-	}
-
-	return tags, nil
-}

pkg/commands/models/branch.go

@@ -1,49 +0,0 @@
-package models
-
-// Branch : A git branch
-// duplicating this for now
-type Branch struct {
-	Name string
-	// the displayname is something like '(HEAD detached at 123asdf)', whereas in that case the name would be '123asdf'
-	DisplayName  string
-	Recency      string
-	Pushables    string
-	Pullables    string
-	UpstreamName string
-	Head         bool
-}
-
-func (b *Branch) RefName() string {
-	return b.Name
-}
-
-func (b *Branch) ID() string {
-	return b.RefName()
-}
-
-func (b *Branch) Description() string {
-	return b.RefName()
-}
-
-// this method does not consider the case where the git config states that a branch is tracking the config.
-// The Pullables value here is based on whether or not we saw an upstream when doing `git branch`
-func (b *Branch) IsTrackingRemote() bool {
-	return b.IsRealBranch() && b.Pullables != "?"
-}
-
-func (b *Branch) MatchesUpstream() bool {
-	return b.IsRealBranch() && b.Pushables == "0" && b.Pullables == "0"
-}
-
-func (b *Branch) HasCommitsToPush() bool {
-	return b.IsRealBranch() && b.Pushables != "0"
-}
-
-func (b *Branch) HasCommitsToPull() bool {
-	return b.IsRealBranch() && b.Pullables != "0"
-}
-
-// for when we're in a detached head state
-func (b *Branch) IsRealBranch() bool {
-	return b.Pushables != "" && b.Pullables != ""
-}

pkg/commands/models/commit.go

@@ -1,41 +0,0 @@
-package models
-
-import "fmt"
-
-// Commit : A git commit
-type Commit struct {
-	Sha           string
-	Name          string
-	Status        string // one of "unpushed", "pushed", "merged", "rebasing" or "selected"
-	Action        string // one of "", "pick", "edit", "squash", "reword", "drop", "fixup"
-	Tags          []string
-	ExtraInfo     string // something like 'HEAD -> master, tag: v0.15.2'
-	Author        string
-	UnixTimestamp int64
-
-	// SHAs of parent commits (will be multiple if it's a merge commit)
-	Parents []string
-}
-
-func (c *Commit) ShortSha() string {
-	if len(c.Sha) < 8 {
-		return c.Sha
-	}
-	return c.Sha[:8]
-}
-
-func (c *Commit) RefName() string {
-	return c.Sha
-}
-
-func (c *Commit) ID() string {
-	return c.RefName()
-}
-
-func (c *Commit) Description() string {
-	return fmt.Sprintf("%s %s", c.Sha[:7], c.Name)
-}
-
-func (c *Commit) IsMerge() bool {
-	return len(c.Parents) > 1
-}

pkg/commands/models/commit_file.go

@@ -1,17 +0,0 @@
-package models
-
-// CommitFile : A git commit file
-type CommitFile struct {
-	// TODO: rename this to Path
-	Name string
-
-	ChangeStatus string // e.g. 'A' for added or 'M' for modified. This is based on the result from git diff --name-status
-}
-
-func (f *CommitFile) ID() string {
-	return f.Name
-}
-
-func (f *CommitFile) Description() string {
-	return f.Name
-}

pkg/commands/models/file.go

@@ -1,87 +0,0 @@
-package models
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// File : A file from git status
-// duplicating this for now
-type File struct {
-	Name                    string
-	PreviousName            string
-	HasStagedChanges        bool
-	HasUnstagedChanges      bool
-	Tracked                 bool
-	Added                   bool
-	Deleted                 bool
-	HasMergeConflicts       bool
-	HasInlineMergeConflicts bool
-	DisplayString           string
-	Type                    string // one of 'file', 'directory', and 'other'
-	ShortStatus             string // e.g. 'AD', ' A', 'M ', '??'
-}
-
-// sometimes we need to deal with either a node (which contains a file) or an actual file
-type IFile interface {
-	GetHasUnstagedChanges() bool
-	GetHasStagedChanges() bool
-	GetIsTracked() bool
-	GetPath() string
-}
-
-func (f *File) IsRename() bool {
-	return f.PreviousName != ""
-}
-
-// Names returns an array containing just the filename, or in the case of a rename, the after filename and the before filename
-func (f *File) Names() []string {
-	result := []string{f.Name}
-	if f.PreviousName != "" {
-		result = append(result, f.PreviousName)
-	}
-	return result
-}
-
-// returns true if the file names are the same or if a a file rename includes the filename of the other
-func (f *File) Matches(f2 *File) bool {
-	return utils.StringArraysOverlap(f.Names(), f2.Names())
-}
-
-func (f *File) ID() string {
-	return f.Name
-}
-
-func (f *File) Description() string {
-	return f.Name
-}
-
-func (f *File) IsSubmodule(configs []*SubmoduleConfig) bool {
-	return f.SubmoduleConfig(configs) != nil
-}
-
-func (f *File) SubmoduleConfig(configs []*SubmoduleConfig) *SubmoduleConfig {
-	for _, config := range configs {
-		if f.Name == config.Path {
-			return config
-		}
-	}
-
-	return nil
-}
-
-func (f *File) GetHasUnstagedChanges() bool {
-	return f.HasUnstagedChanges
-}
-
-func (f *File) GetHasStagedChanges() bool {
-	return f.HasStagedChanges
-}
-
-func (f *File) GetIsTracked() bool {
-	return f.Tracked
-}
-
-func (f *File) GetPath() string {
-	// TODO: remove concept of name; just use path
-	return f.Name
-}

pkg/commands/models/remote.go

@@ -1,20 +0,0 @@
-package models
-
-// Remote : A git remote
-type Remote struct {
-	Name     string
-	Urls     []string
-	Branches []*RemoteBranch
-}
-
-func (r *Remote) RefName() string {
-	return r.Name
-}
-
-func (r *Remote) ID() string {
-	return r.RefName()
-}
-
-func (r *Remote) Description() string {
-	return r.RefName()
-}

pkg/commands/models/remote_branch.go

@@ -1,23 +0,0 @@
-package models
-
-// Remote Branch : A git remote branch
-type RemoteBranch struct {
-	Name       string
-	RemoteName string
-}
-
-func (r *RemoteBranch) FullName() string {
-	return r.RemoteName + "/" + r.Name
-}
-
-func (r *RemoteBranch) RefName() string {
-	return r.FullName()
-}
-
-func (r *RemoteBranch) ID() string {
-	return r.RefName()
-}
-
-func (r *RemoteBranch) Description() string {
-	return r.RefName()
-}

pkg/commands/models/stash_entry.go

@@ -1,21 +0,0 @@
-package models
-
-import "fmt"
-
-// StashEntry : A git stash entry
-type StashEntry struct {
-	Index int
-	Name  string
-}
-
-func (s *StashEntry) RefName() string {
-	return fmt.Sprintf("stash@{%d}", s.Index)
-}
-
-func (s *StashEntry) ID() string {
-	return s.RefName()
-}
-
-func (s *StashEntry) Description() string {
-	return s.RefName() + ": " + s.Name
-}

pkg/commands/models/submodule_config.go

@@ -1,19 +0,0 @@
-package models
-
-type SubmoduleConfig struct {
-	Name string
-	Path string
-	Url  string
-}
-
-func (r *SubmoduleConfig) RefName() string {
-	return r.Name
-}
-
-func (r *SubmoduleConfig) ID() string {
-	return r.RefName()
-}
-
-func (r *SubmoduleConfig) Description() string {
-	return r.RefName()
-}

pkg/commands/models/tag.go

@@ -1,18 +0,0 @@
-package models
-
-// Tag : A git tag
-type Tag struct {
-	Name string
-}
-
-func (t *Tag) RefName() string {
-	return t.Name
-}
-
-func (t *Tag) ID() string {
-	return t.RefName()
-}
-
-func (t *Tag) Description() string {
-	return "tag " + t.Name
-}

pkg/commands/os.go

@@ -0,0 +1,385 @@
+package commands
+
+import (
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+
+	"github.com/go-errors/errors"
+
+	"github.com/jesseduffield/lazygit/pkg/config"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+	"github.com/mgutz/str"
+	"github.com/sirupsen/logrus"
+	gitconfig "github.com/tcnksm/go-gitconfig"
+)
+
+// Platform stores the os state
+type Platform struct {
+	os                   string
+	shell                string
+	shellArg             string
+	escapedQuote         string
+	openCommand          string
+	openLinkCommand      string
+	fallbackEscapedQuote string
+}
+
+// OSCommand holds all the os commands
+type OSCommand struct {
+	Log                *logrus.Entry
+	Platform           *Platform
+	Config             config.AppConfigurer
+	command            func(string, ...string) *exec.Cmd
+	getGlobalGitConfig func(string) (string, error)
+	getenv             func(string) string
+}
+
+// NewOSCommand os command runner
+func NewOSCommand(log *logrus.Entry, config config.AppConfigurer) *OSCommand {
+	return &OSCommand{
+		Log:                log,
+		Platform:           getPlatform(),
+		Config:             config,
+		command:            exec.Command,
+		getGlobalGitConfig: gitconfig.Global,
+		getenv:             os.Getenv,
+	}
+}
+
+// SetCommand sets the command function used by the struct.
+// To be used for testing only
+func (c *OSCommand) SetCommand(cmd func(string, ...string) *exec.Cmd) {
+	c.command = cmd
+}
+
+// RunCommandWithOutput wrapper around commands returning their output and error
+func (c *OSCommand) RunCommandWithOutput(command string) (string, error) {
+	c.Log.WithField("command", command).Info("RunCommand")
+	cmd := c.ExecutableFromString(command)
+	return sanitisedCommandOutput(cmd.CombinedOutput())
+}
+
+// RunExecutableWithOutput runs an executable file and returns its output
+func (c *OSCommand) RunExecutableWithOutput(cmd *exec.Cmd) (string, error) {
+	return sanitisedCommandOutput(cmd.CombinedOutput())
+}
+
+// RunExecutable runs an executable file and returns an error if there was one
+func (c *OSCommand) RunExecutable(cmd *exec.Cmd) error {
+	_, err := c.RunExecutableWithOutput(cmd)
+	return err
+}
+
+// ExecutableFromString takes a string like `git status` and returns an executable command for it
+func (c *OSCommand) ExecutableFromString(commandStr string) *exec.Cmd {
+	splitCmd := str.ToArgv(commandStr)
+	cmd := c.command(splitCmd[0], splitCmd[1:]...)
+	cmd.Env = append(os.Environ(), "GIT_OPTIONAL_LOCKS=0")
+	return cmd
+}
+
+// RunCommandWithOutputLive runs RunCommandWithOutputLiveWrapper
+func (c *OSCommand) RunCommandWithOutputLive(command string, output func(string) string) error {
+	return RunCommandWithOutputLiveWrapper(c, command, output)
+}
+
+// DetectUnamePass detect a username / password question in a command
+// ask is a function that gets executen when this function detect you need to fillin a password
+// The ask argument will be "username" or "password" and expects the user's password or username back
+func (c *OSCommand) DetectUnamePass(command string, ask func(string) string) error {
+	ttyText := ""
+	errMessage := c.RunCommandWithOutputLive(command, func(word string) string {
+		ttyText = ttyText + " " + word
+
+		prompts := map[string]string{
+			"password": `Password\s*for\s*'.+':`,
+			"username": `Username\s*for\s*'.+':`,
+		}
+
+		for askFor, pattern := range prompts {
+			if match, _ := regexp.MatchString(pattern, ttyText); match {
+				ttyText = ""
+				return ask(askFor)
+			}
+		}
+
+		return ""
+	})
+	return errMessage
+}
+
+// RunCommand runs a command and just returns the error
+func (c *OSCommand) RunCommand(command string) error {
+	_, err := c.RunCommandWithOutput(command)
+	return err
+}
+
+// FileType tells us if the file is a file, directory or other
+func (c *OSCommand) FileType(path string) string {
+	fileInfo, err := os.Stat(path)
+	if err != nil {
+		return "other"
+	}
+	if fileInfo.IsDir() {
+		return "directory"
+	}
+	return "file"
+}
+
+// RunDirectCommand wrapper around direct commands
+func (c *OSCommand) RunDirectCommand(command string) (string, error) {
+	c.Log.WithField("command", command).Info("RunDirectCommand")
+
+	return sanitisedCommandOutput(
+		c.command(c.Platform.shell, c.Platform.shellArg, command).
+			CombinedOutput(),
+	)
+}
+
+func sanitisedCommandOutput(output []byte, err error) (string, error) {
+	outputString := string(output)
+	if err != nil {
+		// errors like 'exit status 1' are not very useful so we'll create an error
+		// from the combined output
+		if outputString == "" {
+			return "", WrapError(err)
+		}
+		return outputString, errors.New(outputString)
+	}
+	return outputString, nil
+}
+
+// OpenFile opens a file with the given
+func (c *OSCommand) OpenFile(filename string) error {
+	commandTemplate := c.Config.GetUserConfig().GetString("os.openCommand")
+	templateValues := map[string]string{
+		"filename": c.Quote(filename),
+	}
+
+	command := utils.ResolvePlaceholderString(commandTemplate, templateValues)
+	err := c.RunCommand(command)
+	return err
+}
+
+// OpenLink opens a file with the given
+func (c *OSCommand) OpenLink(link string) error {
+	commandTemplate := c.Config.GetUserConfig().GetString("os.openLinkCommand")
+	templateValues := map[string]string{
+		"link": c.Quote(link),
+	}
+
+	command := utils.ResolvePlaceholderString(commandTemplate, templateValues)
+	err := c.RunCommand(command)
+	return err
+}
+
+// EditFile opens a file in a subprocess using whatever editor is available,
+// falling back to core.editor, VISUAL, EDITOR, then vi
+func (c *OSCommand) EditFile(filename string) (*exec.Cmd, error) {
+	editor, _ := c.getGlobalGitConfig("core.editor")
+
+	if editor == "" {
+		editor = c.getenv("VISUAL")
+	}
+	if editor == "" {
+		editor = c.getenv("EDITOR")
+	}
+	if editor == "" {
+		if err := c.RunCommand("which vi"); err == nil {
+			editor = "vi"
+		}
+	}
+	if editor == "" {
+		return nil, errors.New("No editor defined in $VISUAL, $EDITOR, or git config")
+	}
+
+	return c.PrepareSubProcess(editor, filename), nil
+}
+
+// PrepareSubProcess iniPrepareSubProcessrocess then tells the Gui to switch to it
+// TODO: see if this needs to exist, given that ExecutableFromString does the same things
+func (c *OSCommand) PrepareSubProcess(cmdName string, commandArgs ...string) *exec.Cmd {
+	cmd := c.command(cmdName, commandArgs...)
+	if cmd != nil {
+		cmd.Env = append(os.Environ(), "GIT_OPTIONAL_LOCKS=0")
+	}
+	return cmd
+}
+
+// Quote wraps a message in platform-specific quotation marks
+func (c *OSCommand) Quote(message string) string {
+	message = strings.Replace(message, "`", "\\`", -1)
+	escapedQuote := c.Platform.escapedQuote
+	if strings.Contains(message, c.Platform.escapedQuote) {
+		escapedQuote = c.Platform.fallbackEscapedQuote
+	}
+	return escapedQuote + message + escapedQuote
+}
+
+// Unquote removes wrapping quotations marks if they are present
+// this is needed for removing quotes from staged filenames with spaces
+func (c *OSCommand) Unquote(message string) string {
+	return strings.Replace(message, `"`, "", -1)
+}
+
+// AppendLineToFile adds a new line in file
+func (c *OSCommand) AppendLineToFile(filename, line string) error {
+	f, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
+	if err != nil {
+		return WrapError(err)
+	}
+	defer f.Close()
+
+	_, err = f.WriteString("\n" + line)
+	if err != nil {
+		return WrapError(err)
+	}
+	return nil
+}
+
+// CreateTempFile writes a string to a new temp file and returns the file's name
+func (c *OSCommand) CreateTempFile(filename, content string) (string, error) {
+	tmpfile, err := ioutil.TempFile("", filename)
+	if err != nil {
+		c.Log.Error(err)
+		return "", WrapError(err)
+	}
+
+	if _, err := tmpfile.WriteString(content); err != nil {
+		c.Log.Error(err)
+		return "", WrapError(err)
+	}
+	if err := tmpfile.Close(); err != nil {
+		c.Log.Error(err)
+		return "", WrapError(err)
+	}
+
+	return tmpfile.Name(), nil
+}
+
+// CreateFileWithContent creates a file with the given content
+func (c *OSCommand) CreateFileWithContent(path string, content string) error {
+	if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
+		c.Log.Error(err)
+		return err
+	}
+
+	if err := ioutil.WriteFile(path, []byte(content), 0644); err != nil {
+		c.Log.Error(err)
+		return WrapError(err)
+	}
+
+	return nil
+}
+
+// Remove removes a file or directory at the specified path
+func (c *OSCommand) Remove(filename string) error {
+	err := os.RemoveAll(filename)
+	return WrapError(err)
+}
+
+// FileExists checks whether a file exists at the specified path
+func (c *OSCommand) FileExists(path string) (bool, error) {
+	if _, err := os.Stat(path); err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, err
+	}
+	return true, nil
+}
+
+// RunPreparedCommand takes a pointer to an exec.Cmd and runs it
+// this is useful if you need to give your command some environment variables
+// before running it
+func (c *OSCommand) RunPreparedCommand(cmd *exec.Cmd) error {
+	out, err := cmd.CombinedOutput()
+	outString := string(out)
+	c.Log.Info(outString)
+	if err != nil {
+		if len(outString) == 0 {
+			return err
+		}
+		return errors.New(outString)
+	}
+	return nil
+}
+
+// GetLazygitPath returns the path of the currently executed file
+func (c *OSCommand) GetLazygitPath() string {
+	ex, err := os.Executable() // get the executable path for git to use
+	if err != nil {
+		ex = os.Args[0] // fallback to the first call argument if needed
+	}
+	return filepath.ToSlash(ex)
+}
+
+// RunCustomCommand returns the pointer to a custom command
+func (c *OSCommand) RunCustomCommand(command string) *exec.Cmd {
+	return c.PrepareSubProcess(c.Platform.shell, c.Platform.shellArg, command)
+}
+
+// PipeCommands runs a heap of commands and pipes their inputs/outputs together like A | B | C
+func (c *OSCommand) PipeCommands(commandStrings ...string) error {
+
+	cmds := make([]*exec.Cmd, len(commandStrings))
+
+	for i, str := range commandStrings {
+		cmds[i] = c.ExecutableFromString(str)
+	}
+
+	for i := 0; i < len(cmds)-1; i++ {
+		stdout, err := cmds[i].StdoutPipe()
+		if err != nil {
+			return err
+		}
+
+		cmds[i+1].Stdin = stdout
+	}
+
+	// keeping this here in case I adapt this code for some other purpose in the future
+	// cmds[len(cmds)-1].Stdout = os.Stdout
+
+	finalErrors := []string{}
+
+	wg := sync.WaitGroup{}
+	wg.Add(len(cmds))
+
+	for _, cmd := range cmds {
+		currentCmd := cmd
+		go func() {
+			stderr, err := currentCmd.StderrPipe()
+			if err != nil {
+				c.Log.Error(err)
+			}
+
+			if err := currentCmd.Start(); err != nil {
+				c.Log.Error(err)
+			}
+
+			if b, err := ioutil.ReadAll(stderr); err == nil {
+				if len(b) > 0 {
+					finalErrors = append(finalErrors, string(b))
+				}
+			}
+
+			if err := currentCmd.Wait(); err != nil {
+				c.Log.Error(err)
+			}
+
+			wg.Done()
+		}()
+	}
+
+	wg.Wait()
+
+	if len(finalErrors) > 0 {
+		return errors.New(strings.Join(finalErrors, "\n"))
+	}
+	return nil
+}

pkg/commands/os_default_platform.go

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

pkg/commands/os_test.go

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

pkg/commands/os_windows.go

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

pkg/commands/oscommands/cmd_obj.go

@@ -1,71 +0,0 @@
-package oscommands
-
-import (
-	"os/exec"
-)
-
-// A command object is a general way to represent a command to be run on the
-// command line.
-type ICmdObj interface {
-	GetCmd() *exec.Cmd
-	// outputs string representation of command. Note that if the command was built
-	// using NewFromArgs, the output won't be quite the same as what you would type
-	// into a terminal e.g. 'sh -c git commit' as opposed to 'sh -c "git commit"'
-	ToString() string
-	AddEnvVars(...string) ICmdObj
-	GetEnvVars() []string
-
-	// runs the command and returns an error if any
-	Run() error
-	// runs the command and returns the output as a string, and an error if any
-	RunWithOutput() (string, error)
-	// runs the command and runs a callback function on each line of the output. If the callback returns true for the boolean value, we kill the process and return.
-	RunAndProcessLines(onLine func(line string) (bool, error)) error
-
-	// logs command
-	Log() ICmdObj
-}
-
-type CmdObj struct {
-	cmdStr string
-	cmd    *exec.Cmd
-
-	runner     ICmdObjRunner
-	logCommand func(ICmdObj)
-}
-
-func (self *CmdObj) GetCmd() *exec.Cmd {
-	return self.cmd
-}
-
-func (self *CmdObj) ToString() string {
-	return self.cmdStr
-}
-
-func (self *CmdObj) AddEnvVars(vars ...string) ICmdObj {
-	self.cmd.Env = append(self.cmd.Env, vars...)
-
-	return self
-}
-
-func (self *CmdObj) GetEnvVars() []string {
-	return self.cmd.Env
-}
-
-func (self *CmdObj) Log() ICmdObj {
-	self.logCommand(self)
-
-	return self
-}
-
-func (self *CmdObj) Run() error {
-	return self.runner.Run(self)
-}
-
-func (self *CmdObj) RunWithOutput() (string, error) {
-	return self.runner.RunWithOutput(self)
-}
-
-func (self *CmdObj) RunAndProcessLines(onLine func(line string) (bool, error)) error {
-	return self.runner.RunAndProcessLines(self, onLine)
-}

pkg/commands/oscommands/cmd_obj_builder.go

@@ -1,68 +0,0 @@
-package oscommands
-
-import (
-	"os"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/secureexec"
-	"github.com/mgutz/str"
-)
-
-type ICmdObjBuilder interface {
-	// New returns a new command object based on the string provided
-	New(cmdStr string) ICmdObj
-	// NewShell takes a string like `git commit` and returns an executable shell command for it e.g. `sh -c 'git commit'`
-	NewShell(commandStr string) ICmdObj
-	// NewFromArgs takes a slice of strings like []string{"git", "commit"} and returns a new command object. This can be useful when you don't want to worry about whitespace and quoting and stuff.
-	NewFromArgs(args []string) ICmdObj
-	// Quote wraps a string in quotes with any necessary escaping applied. The reason for bundling this up with the other methods in this interface is that we basically always need to make use of this when creating new command objects.
-	Quote(str string) string
-}
-
-type CmdObjBuilder struct {
-	runner    ICmdObjRunner
-	logCmdObj func(ICmdObj)
-	platform  *Platform
-}
-
-// poor man's version of explicitly saying that struct X implements interface Y
-var _ ICmdObjBuilder = &CmdObjBuilder{}
-
-func (self *CmdObjBuilder) New(cmdStr string) ICmdObj {
-	args := str.ToArgv(cmdStr)
-	cmd := secureexec.Command(args[0], args[1:]...)
-	cmd.Env = os.Environ()
-
-	return &CmdObj{
-		cmdStr:     cmdStr,
-		cmd:        cmd,
-		runner:     self.runner,
-		logCommand: self.logCmdObj,
-	}
-}
-
-func (self *CmdObjBuilder) NewFromArgs(args []string) ICmdObj {
-	cmd := secureexec.Command(args[0], args[1:]...)
-	cmd.Env = os.Environ()
-
-	return &CmdObj{
-		cmdStr:     strings.Join(args, " "),
-		cmd:        cmd,
-		runner:     self.runner,
-		logCommand: self.logCmdObj,
-	}
-}
-
-func (self *CmdObjBuilder) NewShell(commandStr string) ICmdObj {
-	return self.NewFromArgs([]string{self.platform.Shell, self.platform.ShellArg, commandStr})
-}
-
-func (self *CmdObjBuilder) CloneWithNewRunner(decorate func(ICmdObjRunner) ICmdObjRunner) *CmdObjBuilder {
-	decoratedRunner := decorate(self.runner)
-
-	return &CmdObjBuilder{
-		runner:    decoratedRunner,
-		logCmdObj: self.logCmdObj,
-		platform:  self.platform,
-	}
-}

pkg/commands/oscommands/cmd_obj_runner.go

@@ -1,79 +0,0 @@
-package oscommands
-
-import (
-	"bufio"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/sirupsen/logrus"
-)
-
-type ICmdObjRunner interface {
-	Run(cmdObj ICmdObj) error
-	RunWithOutput(cmdObj ICmdObj) (string, error)
-	RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error
-}
-
-type cmdObjRunner struct {
-	log       *logrus.Entry
-	logCmdObj func(ICmdObj)
-}
-
-var _ ICmdObjRunner = &cmdObjRunner{}
-
-func (self *cmdObjRunner) Run(cmdObj ICmdObj) error {
-	_, err := self.RunWithOutput(cmdObj)
-	return err
-}
-
-func (self *cmdObjRunner) RunWithOutput(cmdObj ICmdObj) (string, error) {
-	self.logCmdObj(cmdObj)
-	output, err := sanitisedCommandOutput(cmdObj.GetCmd().CombinedOutput())
-	if err != nil {
-		self.log.WithField("command", cmdObj.ToString()).Error(output)
-	}
-	return output, err
-}
-
-func (self *cmdObjRunner) RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error {
-	cmd := cmdObj.GetCmd()
-	stdoutPipe, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-
-	scanner := bufio.NewScanner(stdoutPipe)
-	scanner.Split(bufio.ScanLines)
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	for scanner.Scan() {
-		line := scanner.Text()
-		stop, err := onLine(line)
-		if err != nil {
-			return err
-		}
-		if stop {
-			_ = cmd.Process.Kill()
-			break
-		}
-	}
-
-	_ = cmd.Wait()
-
-	return nil
-}
-
-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
-		if outputString == "" {
-			return "", utils.WrapError(err)
-		}
-		return outputString, errors.New(outputString)
-	}
-	return outputString, nil
-}

pkg/commands/oscommands/copy.go

@@ -1,137 +0,0 @@
-package oscommands
-
-import (
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-)
-
-/* MIT License
- *
- * Copyright (c) 2017 Roland Singer [roland.singer@desertbit.com]
- *
- * 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.
- */
-
-// CopyFile copies the contents of the file named src to the file named
-// by dst. The file will be created if it does not already exist. If the
-// destination file exists, all it's contents will be replaced by the contents
-// of the source file. The file mode will be copied from the source and
-// the copied data is synced/flushed to stable storage.
-func CopyFile(src, dst string) (err error) {
-	in, err := os.Open(src)
-	if err != nil {
-		return
-	}
-	defer in.Close()
-
-	out, err := os.Create(dst)
-	if err != nil {
-		return
-	}
-	defer func() {
-		if e := out.Close(); e != nil {
-			err = e
-		}
-	}()
-
-	_, err = io.Copy(out, in)
-	if err != nil {
-		return
-	}
-
-	err = out.Sync()
-	if err != nil {
-		return
-	}
-
-	si, err := os.Stat(src)
-	if err != nil {
-		return
-	}
-	err = os.Chmod(dst, si.Mode())
-	if err != nil {
-		return
-	}
-
-	return
-}
-
-// CopyDir recursively copies a directory tree, attempting to preserve permissions.
-// Source directory must exist. If destination already exists we'll clobber it.
-// Symlinks are ignored and skipped.
-func CopyDir(src string, dst string) (err error) {
-	src = filepath.Clean(src)
-	dst = filepath.Clean(dst)
-
-	si, err := os.Stat(src)
-	if err != nil {
-		return err
-	}
-	if !si.IsDir() {
-		return fmt.Errorf("source is not a directory")
-	}
-
-	_, err = os.Stat(dst)
-	if err != nil && !os.IsNotExist(err) {
-		return
-	}
-	if err == nil {
-		// it exists so let's remove it
-		if err := os.RemoveAll(dst); err != nil {
-			return err
-		}
-	}
-
-	err = os.MkdirAll(dst, si.Mode())
-	if err != nil {
-		return
-	}
-
-	entries, err := ioutil.ReadDir(src)
-	if err != nil {
-		return
-	}
-
-	for _, entry := range entries {
-		srcPath := filepath.Join(src, entry.Name())
-		dstPath := filepath.Join(dst, entry.Name())
-
-		if entry.IsDir() {
-			err = CopyDir(srcPath, dstPath)
-			if err != nil {
-				return
-			}
-		} else {
-			// Skip symlinks.
-			if entry.Mode()&os.ModeSymlink != 0 {
-				continue
-			}
-
-			err = CopyFile(srcPath, dstPath)
-			if err != nil {
-				return
-			}
-		}
-	}
-
-	return
-}

pkg/commands/oscommands/dummies.go

@@ -1,31 +0,0 @@
-package oscommands
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// NewDummyOSCommand creates a new dummy OSCommand for testing
-func NewDummyOSCommand() *OSCommand {
-	return NewOSCommand(utils.NewDummyCommon())
-}
-
-func NewDummyCmdObjBuilder(runner ICmdObjRunner) *CmdObjBuilder {
-	return &CmdObjBuilder{
-		runner:    runner,
-		logCmdObj: func(ICmdObj) {},
-		platform: &Platform{
-			OS:              "darwin",
-			Shell:           "bash",
-			ShellArg:        "-c",
-			OpenCommand:     "open {{filename}}",
-			OpenLinkCommand: "open {{link}}",
-		},
-	}
-}
-
-func NewDummyOSCommandWithRunner(runner *FakeCmdObjRunner) *OSCommand {
-	osCommand := NewOSCommand(utils.NewDummyCommon())
-	osCommand.Cmd = NewDummyCmdObjBuilder(runner)
-
-	return osCommand
-}

pkg/commands/oscommands/exec_live.go

@@ -1,153 +0,0 @@
-package oscommands
-
-import (
-	"bufio"
-	"bytes"
-	"io"
-	"os/exec"
-	"regexp"
-	"strings"
-	"unicode/utf8"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// DetectUnamePass detect a username / password / passphrase question in a command
-// promptUserForCredential is a function that gets executed when this function detect you need to fillin a password or passphrase
-// The promptUserForCredential argument will be "username", "password" or "passphrase" and expects the user's password/passphrase or username back
-func (c *OSCommand) DetectUnamePass(cmdObj ICmdObj, writer io.Writer, promptUserForCredential func(string) string) error {
-	ttyText := ""
-	errMessage := c.RunCommandWithOutputLive(cmdObj, writer, func(word string) string {
-		ttyText = ttyText + " " + word
-
-		prompts := map[string]string{
-			`.+'s password:`:                         "password",
-			`Password\s*for\s*'.+':`:                 "password",
-			`Username\s*for\s*'.+':`:                 "username",
-			`Enter\s*passphrase\s*for\s*key\s*'.+':`: "passphrase",
-		}
-
-		for pattern, askFor := range prompts {
-			if match, _ := regexp.MatchString(pattern, ttyText); match {
-				ttyText = ""
-				return promptUserForCredential(askFor)
-			}
-		}
-
-		return ""
-	})
-	return errMessage
-}
-
-// Due to a lack of pty support on windows we have RunCommandWithOutputLiveWrapper being defined
-// separate for windows and other OS's
-func (c *OSCommand) RunCommandWithOutputLive(cmdObj ICmdObj, writer io.Writer, handleOutput func(string) string) error {
-	return RunCommandWithOutputLiveWrapper(c, cmdObj, writer, handleOutput)
-}
-
-type cmdHandler struct {
-	stdoutPipe io.Reader
-	stdinPipe  io.Writer
-	close      func() error
-}
-
-// RunCommandWithOutputLiveAux runs a command and return every word that gets written in stdout
-// Output is a function that executes by every word that gets read by bufio
-// As return of output you need to give a string that will be written to stdin
-// NOTE: If the return data is empty it won't write anything to stdin
-func RunCommandWithOutputLiveAux(
-	c *OSCommand,
-	cmdObj ICmdObj,
-	writer io.Writer,
-	// handleOutput takes a word from stdout and returns a string to be written to stdin.
-	// See DetectUnamePass above for how this is used to check for a username/password request
-	handleOutput func(string) string,
-	startCmd func(cmd *exec.Cmd) (*cmdHandler, error),
-) error {
-	c.Log.WithField("command", cmdObj.ToString()).Info("RunCommand")
-	c.LogCommand(cmdObj.ToString(), true)
-	cmd := cmdObj.AddEnvVars("LANG=en_US.UTF-8", "LC_ALL=en_US.UTF-8").GetCmd()
-
-	var stderr bytes.Buffer
-	cmd.Stderr = io.MultiWriter(writer, &stderr)
-
-	handler, err := startCmd(cmd)
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		if closeErr := handler.close(); closeErr != nil {
-			c.Log.Error(closeErr)
-		}
-	}()
-
-	tr := io.TeeReader(handler.stdoutPipe, writer)
-
-	go utils.Safe(func() {
-		scanner := bufio.NewScanner(tr)
-		scanner.Split(scanWordsWithNewLines)
-		for scanner.Scan() {
-			text := scanner.Text()
-			output := strings.Trim(text, " ")
-			toInput := handleOutput(output)
-			if toInput != "" {
-				_, _ = handler.stdinPipe.Write([]byte(toInput))
-			}
-		}
-	})
-
-	err = cmd.Wait()
-	if err != nil {
-		return errors.New(stderr.String())
-	}
-
-	return nil
-}
-
-// scanWordsWithNewLines is a copy of bufio.ScanWords but this also captures new lines
-// For specific comments about this function take a look at: bufio.ScanWords
-func scanWordsWithNewLines(data []byte, atEOF bool) (advance int, token []byte, err error) {
-	start := 0
-	for width := 0; start < len(data); start += width {
-		var r rune
-		r, width = utf8.DecodeRune(data[start:])
-		if !isSpace(r) {
-			break
-		}
-	}
-	for width, i := 0, start; i < len(data); i += width {
-		var r rune
-		r, width = utf8.DecodeRune(data[i:])
-		if isSpace(r) {
-			return i + width, data[start:i], nil
-		}
-	}
-	if atEOF && len(data) > start {
-		return len(data), data[start:], nil
-	}
-	return start, nil, nil
-}
-
-// isSpace is also copied from the bufio package and has been modified to also captures new lines
-// For specific comments about this function take a look at: bufio.isSpace
-func isSpace(r rune) bool {
-	if r <= '\u00FF' {
-		switch r {
-		case ' ', '\t', '\v', '\f':
-			return true
-		case '\u0085', '\u00A0':
-			return true
-		}
-		return false
-	}
-	if '\u2000' <= r && r <= '\u200a' {
-		return true
-	}
-	switch r {
-	case '\u1680', '\u2028', '\u2029', '\u202f', '\u205f', '\u3000':
-		return true
-	}
-	return false
-}

pkg/commands/oscommands/exec_live_default.go

@@ -1,37 +0,0 @@
-//go:build !windows
-// +build !windows
-
-package oscommands
-
-import (
-	"io"
-	"os/exec"
-
-	"github.com/creack/pty"
-)
-
-func RunCommandWithOutputLiveWrapper(
-	c *OSCommand,
-	cmdObj ICmdObj,
-	writer io.Writer,
-	output func(string) string,
-) error {
-	return RunCommandWithOutputLiveAux(
-		c,
-		cmdObj,
-		writer,
-		output,
-		func(cmd *exec.Cmd) (*cmdHandler, error) {
-			ptmx, err := pty.Start(cmd)
-			if err != nil {
-				return nil, err
-			}
-
-			return &cmdHandler{
-				stdoutPipe: ptmx,
-				stdinPipe:  ptmx,
-				close:      ptmx.Close,
-			}, nil
-		},
-	)
-}

pkg/commands/oscommands/exec_live_win.go

@@ -1,63 +0,0 @@
-//go:build windows
-// +build windows
-
-package oscommands
-
-import (
-	"bytes"
-	"io"
-	"os/exec"
-	"sync"
-)
-
-type Buffer struct {
-	b bytes.Buffer
-	m sync.Mutex
-}
-
-func (b *Buffer) Read(p []byte) (n int, err error) {
-	b.m.Lock()
-	defer b.m.Unlock()
-	return b.b.Read(p)
-}
-func (b *Buffer) Write(p []byte) (n int, err error) {
-	b.m.Lock()
-	defer b.m.Unlock()
-	return b.b.Write(p)
-}
-
-// RunCommandWithOutputLiveWrapper runs a command live but because of windows compatibility this command can't be ran there
-// TODO: Remove this hack and replace it with a proper way to run commands live on windows. We still have an issue where if a password is requested, the request for a password is written straight to stdout because we can't control the stdout of a subprocess of a subprocess. Keep an eye on https://github.com/creack/pty/pull/109
-func RunCommandWithOutputLiveWrapper(
-	c *OSCommand,
-	cmdObj ICmdObj,
-	writer io.Writer,
-	output func(string) string,
-) error {
-	return RunCommandWithOutputLiveAux(
-		c,
-		cmdObj,
-		writer,
-		output,
-		func(cmd *exec.Cmd) (*cmdHandler, error) {
-			stdoutReader, stdoutWriter := io.Pipe()
-			cmd.Stdout = stdoutWriter
-
-			buf := &Buffer{}
-			cmd.Stdin = buf
-
-			if err := cmd.Start(); err != nil {
-				return nil, err
-			}
-
-			// because we don't yet have windows support for a pty, we instead just
-			// pass our standard stream handlers and because there's no pty to close
-			// we pass a no-op function for that.
-			return &cmdHandler{
-				stdoutPipe: stdoutReader,
-				stdinPipe:  buf,
-				close:      func() error { return nil },
-			}, nil
-		},
-	)
-}

pkg/commands/oscommands/fake_cmd_obj_runner.go

@@ -1,102 +0,0 @@
-package oscommands
-
-import (
-	"bufio"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/go-errors/errors"
-	"github.com/stretchr/testify/assert"
-)
-
-// for use in testing
-
-type FakeCmdObjRunner struct {
-	t                *testing.T
-	expectedCmds     []func(ICmdObj) (string, error)
-	expectedCmdIndex int
-}
-
-var _ ICmdObjRunner = &FakeCmdObjRunner{}
-
-func NewFakeRunner(t *testing.T) *FakeCmdObjRunner {
-	return &FakeCmdObjRunner{t: t}
-}
-
-func (self *FakeCmdObjRunner) Run(cmdObj ICmdObj) error {
-	_, err := self.RunWithOutput(cmdObj)
-	return err
-}
-
-func (self *FakeCmdObjRunner) RunWithOutput(cmdObj ICmdObj) (string, error) {
-	if self.expectedCmdIndex > len(self.expectedCmds)-1 {
-		self.t.Errorf("ran too many commands. Unexpected command: `%s`", cmdObj.ToString())
-		return "", errors.New("ran too many commands")
-	}
-
-	expectedCmd := self.expectedCmds[self.expectedCmdIndex]
-	output, err := expectedCmd(cmdObj)
-
-	self.expectedCmdIndex++
-
-	return output, err
-}
-
-func (self *FakeCmdObjRunner) RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error {
-	output, err := self.RunWithOutput(cmdObj)
-	if err != nil {
-		return err
-	}
-
-	scanner := bufio.NewScanner(strings.NewReader(output))
-	scanner.Split(bufio.ScanLines)
-	for scanner.Scan() {
-		line := scanner.Text()
-		stop, err := onLine(line)
-		if err != nil {
-			return err
-		}
-		if stop {
-			break
-		}
-	}
-
-	return nil
-}
-
-func (self *FakeCmdObjRunner) ExpectFunc(fn func(cmdObj ICmdObj) (string, error)) *FakeCmdObjRunner {
-	self.expectedCmds = append(self.expectedCmds, fn)
-
-	return self
-}
-
-func (self *FakeCmdObjRunner) Expect(expectedCmdStr string, output string, err error) *FakeCmdObjRunner {
-	self.ExpectFunc(func(cmdObj ICmdObj) (string, error) {
-		cmdStr := cmdObj.ToString()
-		assert.Equal(self.t, expectedCmdStr, cmdStr, fmt.Sprintf("expected command %d to be %s, but was %s", self.expectedCmdIndex+1, expectedCmdStr, cmdStr))
-
-		return output, err
-	})
-
-	return self
-}
-
-func (self *FakeCmdObjRunner) ExpectArgs(expectedArgs []string, output string, err error) *FakeCmdObjRunner {
-	self.ExpectFunc(func(cmdObj ICmdObj) (string, error) {
-		args := cmdObj.GetCmd().Args
-		assert.EqualValues(self.t, expectedArgs, args, fmt.Sprintf("command %d did not match expectation", self.expectedCmdIndex+1))
-
-		return output, err
-	})
-
-	return self
-}
-
-func (self *FakeCmdObjRunner) CheckForMissingCalls() {
-	if self.expectedCmdIndex < len(self.expectedCmds) {
-		self.t.Errorf("expected command %d to be called, but was not", self.expectedCmdIndex+1)
-	}
-
-	return
-}

pkg/commands/oscommands/os.go

@@ -1,355 +0,0 @@
-package oscommands
-
-import (
-	"fmt"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"sync"
-
-	"github.com/go-errors/errors"
-
-	"github.com/atotto/clipboard"
-	"github.com/jesseduffield/lazygit/pkg/common"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// OSCommand holds all the os commands
-type OSCommand struct {
-	*common.Common
-	Platform *Platform
-	Getenv   func(string) string
-
-	// callback to run before running a command, i.e. for the purposes of logging
-	onRunCommand func(CmdLogEntry)
-
-	// something like 'Staging File': allows us to group cmd logs under a single title
-	CmdLogSpan string
-
-	removeFile func(string) error
-
-	Cmd *CmdObjBuilder
-}
-
-// Platform stores the os state
-type Platform struct {
-	OS              string
-	Shell           string
-	ShellArg        string
-	OpenCommand     string
-	OpenLinkCommand string
-}
-
-// TODO: make these fields private
-type CmdLogEntry struct {
-	// e.g. 'git commit -m "haha"'
-	cmdStr string
-	// Span is something like 'Staging File'. Multiple commands can be grouped under the same
-	// span
-	span string
-
-	// sometimes our command is direct like 'git commit', and sometimes it's a
-	// command to remove a file but through Go's standard library rather than the
-	// command line
-	commandLine bool
-}
-
-func (e CmdLogEntry) GetCmdStr() string {
-	return e.cmdStr
-}
-
-func (e CmdLogEntry) GetSpan() string {
-	return e.span
-}
-
-func (e CmdLogEntry) GetCommandLine() bool {
-	return e.commandLine
-}
-
-func NewCmdLogEntry(cmdStr string, span string, commandLine bool) CmdLogEntry {
-	return CmdLogEntry{cmdStr: cmdStr, span: span, commandLine: commandLine}
-}
-
-// NewOSCommand os command runner
-func NewOSCommand(common *common.Common) *OSCommand {
-	platform := getPlatform()
-
-	c := &OSCommand{
-		Common:     common,
-		Platform:   platform,
-		Getenv:     os.Getenv,
-		removeFile: os.RemoveAll,
-	}
-
-	runner := &cmdObjRunner{log: common.Log, logCmdObj: c.LogCmdObj}
-	c.Cmd = &CmdObjBuilder{runner: runner, logCmdObj: c.LogCmdObj, platform: platform}
-
-	return c
-}
-
-func (c *OSCommand) WithSpan(span string) *OSCommand {
-	// sometimes .WithSpan(span) will be called where span actually is empty, in
-	// which case we don't need to log anything so we can just return early here
-	// with the original struct
-	if span == "" {
-		return c
-	}
-
-	newOSCommand := &OSCommand{}
-	*newOSCommand = *c
-	newOSCommand.CmdLogSpan = span
-	newOSCommand.Cmd.logCmdObj = newOSCommand.LogCmdObj
-	newOSCommand.Cmd.runner = &cmdObjRunner{log: c.Log, logCmdObj: newOSCommand.LogCmdObj}
-	return newOSCommand
-}
-
-func (c *OSCommand) LogCmdObj(cmdObj ICmdObj) {
-	c.LogCommand(cmdObj.ToString(), true)
-}
-
-func (c *OSCommand) LogCommand(cmdStr string, commandLine bool) {
-	c.Log.WithField("command", cmdStr).Info("RunCommand")
-
-	if c.onRunCommand != nil && c.CmdLogSpan != "" {
-		c.onRunCommand(NewCmdLogEntry(cmdStr, c.CmdLogSpan, commandLine))
-	}
-}
-
-func (c *OSCommand) SetOnRunCommand(f func(CmdLogEntry)) {
-	c.onRunCommand = f
-}
-
-// To be used for testing only
-func (c *OSCommand) SetRemoveFile(f func(string) error) {
-	c.removeFile = f
-}
-
-// FileType tells us if the file is a file, directory or other
-func FileType(path string) string {
-	fileInfo, err := os.Stat(path)
-	if err != nil {
-		return "other"
-	}
-	if fileInfo.IsDir() {
-		return "directory"
-	}
-	return "file"
-}
-
-// OpenFile opens a file with the given
-func (c *OSCommand) OpenFile(filename string) error {
-	commandTemplate := c.UserConfig.OS.OpenCommand
-	templateValues := map[string]string{
-		"filename": c.Quote(filename),
-	}
-	command := utils.ResolvePlaceholderString(commandTemplate, templateValues)
-	return c.Cmd.NewShell(command).Run()
-}
-
-// OpenLink opens a file with the given
-func (c *OSCommand) OpenLink(link string) error {
-	c.LogCommand(fmt.Sprintf("Opening link '%s'", link), false)
-	commandTemplate := c.UserConfig.OS.OpenLinkCommand
-	templateValues := map[string]string{
-		"link": c.Quote(link),
-	}
-
-	command := utils.ResolvePlaceholderString(commandTemplate, templateValues)
-	return c.Cmd.NewShell(command).Run()
-}
-
-// Quote wraps a message in platform-specific quotation marks
-func (c *OSCommand) Quote(message string) string {
-	return c.Cmd.Quote(message)
-}
-
-func (self *CmdObjBuilder) Quote(message string) string {
-	var quote string
-	if self.platform.OS == "windows" {
-		quote = `\"`
-		message = strings.NewReplacer(
-			`"`, `"'"'"`,
-			`\"`, `\\"`,
-		).Replace(message)
-	} else {
-		quote = `"`
-		message = strings.NewReplacer(
-			`\`, `\\`,
-			`"`, `\"`,
-			`$`, `\$`,
-			"`", "\\`",
-		).Replace(message)
-	}
-	return quote + message + quote
-}
-
-// AppendLineToFile adds a new line in file
-func (c *OSCommand) AppendLineToFile(filename, line string) error {
-	c.LogCommand(fmt.Sprintf("Appending '%s' to file '%s'", line, filename), false)
-	f, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
-	if err != nil {
-		return utils.WrapError(err)
-	}
-	defer f.Close()
-
-	_, err = f.WriteString("\n" + line)
-	if err != nil {
-		return utils.WrapError(err)
-	}
-	return nil
-}
-
-// CreateTempFile writes a string to a new temp file and returns the file's name
-func (c *OSCommand) CreateTempFile(filename, content string) (string, error) {
-	tmpfile, err := ioutil.TempFile("", filename)
-	if err != nil {
-		c.Log.Error(err)
-		return "", utils.WrapError(err)
-	}
-	c.LogCommand(fmt.Sprintf("Creating temp file '%s'", tmpfile.Name()), false)
-
-	if _, err := tmpfile.WriteString(content); err != nil {
-		c.Log.Error(err)
-		return "", utils.WrapError(err)
-	}
-	if err := tmpfile.Close(); err != nil {
-		c.Log.Error(err)
-		return "", utils.WrapError(err)
-	}
-
-	return tmpfile.Name(), nil
-}
-
-// CreateFileWithContent creates a file with the given content
-func (c *OSCommand) CreateFileWithContent(path string, content string) error {
-	c.LogCommand(fmt.Sprintf("Creating file '%s'", path), false)
-	if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
-		c.Log.Error(err)
-		return err
-	}
-
-	if err := ioutil.WriteFile(path, []byte(content), 0644); err != nil {
-		c.Log.Error(err)
-		return utils.WrapError(err)
-	}
-
-	return nil
-}
-
-// Remove removes a file or directory at the specified path
-func (c *OSCommand) Remove(filename string) error {
-	c.LogCommand(fmt.Sprintf("Removing '%s'", filename), false)
-	err := os.RemoveAll(filename)
-	return utils.WrapError(err)
-}
-
-// FileExists checks whether a file exists at the specified path
-func (c *OSCommand) FileExists(path string) (bool, error) {
-	if _, err := os.Stat(path); err != nil {
-		if os.IsNotExist(err) {
-			return false, nil
-		}
-		return false, err
-	}
-	return true, nil
-}
-
-// GetLazygitPath returns the path of the currently executed file
-func (c *OSCommand) GetLazygitPath() string {
-	ex, err := os.Executable() // get the executable path for git to use
-	if err != nil {
-		ex = os.Args[0] // fallback to the first call argument if needed
-	}
-	return `"` + filepath.ToSlash(ex) + `"`
-}
-
-// PipeCommands runs a heap of commands and pipes their inputs/outputs together like A | B | C
-func (c *OSCommand) PipeCommands(commandStrings ...string) error {
-	cmds := make([]*exec.Cmd, len(commandStrings))
-	logCmdStr := ""
-	for i, str := range commandStrings {
-		if i > 0 {
-			logCmdStr += " | "
-		}
-		logCmdStr += str
-		cmds[i] = c.Cmd.New(str).GetCmd()
-	}
-	c.LogCommand(logCmdStr, true)
-
-	for i := 0; i < len(cmds)-1; i++ {
-		stdout, err := cmds[i].StdoutPipe()
-		if err != nil {
-			return err
-		}
-
-		cmds[i+1].Stdin = stdout
-	}
-
-	// keeping this here in case I adapt this code for some other purpose in the future
-	// cmds[len(cmds)-1].Stdout = os.Stdout
-
-	finalErrors := []string{}
-
-	wg := sync.WaitGroup{}
-	wg.Add(len(cmds))
-
-	for _, cmd := range cmds {
-		currentCmd := cmd
-		go utils.Safe(func() {
-			stderr, err := currentCmd.StderrPipe()
-			if err != nil {
-				c.Log.Error(err)
-			}
-
-			if err := currentCmd.Start(); err != nil {
-				c.Log.Error(err)
-			}
-
-			if b, err := ioutil.ReadAll(stderr); err == nil {
-				if len(b) > 0 {
-					finalErrors = append(finalErrors, string(b))
-				}
-			}
-
-			if err := currentCmd.Wait(); err != nil {
-				c.Log.Error(err)
-			}
-
-			wg.Done()
-		})
-	}
-
-	wg.Wait()
-
-	if len(finalErrors) > 0 {
-		return errors.New(strings.Join(finalErrors, "\n"))
-	}
-	return nil
-}
-
-func Kill(cmd *exec.Cmd) error {
-	if cmd.Process == nil {
-		// somebody got to it before we were able to, poor bastard
-		return nil
-	}
-	return cmd.Process.Kill()
-}
-
-func (c *OSCommand) CopyToClipboard(str string) error {
-	escaped := strings.Replace(str, "\n", "\\n", -1)
-	truncated := utils.TruncateWithEllipsis(escaped, 40)
-	c.LogCommand(fmt.Sprintf("Copying '%s' to clipboard", truncated), false)
-	return clipboard.WriteAll(str)
-}
-
-func (c *OSCommand) RemoveFile(path string) error {
-	c.LogCommand(fmt.Sprintf("Deleting path '%s'", path), false)
-
-	return c.removeFile(path)
-}
-
-func GetTempDir() string {
-	return filepath.Join(os.TempDir(), "lazygit")
-}