start breaking up git struct

.github/ISSUE_TEMPLATE/bug_report.md

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

.github/workflows/ci.yml

@@ -63,43 +63,3 @@ jobs:
       - name: Build darwin binary
         run: |
           GOOS=darwin go build
-  check-cheatsheet:
-    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: Check Cheatsheet
-        run: |
-          go run scripts/cheatsheet/main.go check
-  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
-      - name: errors
-        run: golangci-lint run
-        if: ${{ failure() }}

.github/workflows/lint.yml

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

@@ -18,21 +18,19 @@ coverage.txt
 
 # Binaries
 lazygit
-lazygit.exe
 
 # Exceptions
 !.gitignore
 !.goreleaser.yml
 !.circleci/
 !.github/
-# these are for our integration tests
-!.git_keep
-!.gitmodules_keep
 
 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/**/hooks/
-test/integration/*/expected_remote/**/hooks/
+test/integration/*/expected/.git_keep/hooks/
+test/integration/*/expected_remote/hooks/
+!.git_keep/
+lazygit.exe

CODE-OF-CONDUCT.md

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

CONTRIBUTING.md

@@ -6,7 +6,7 @@ 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.
 
-## All code changes happen through Pull Requests
+## 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:
@@ -14,10 +14,10 @@ welcome your pull requests:
 1. Fork the repo and create your branch from `master`.
 2. If you've added code that should be tested, add tests.
 3. If you've added code that need documentation, update the documentation.
-4. Write a [good commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
-5. Issue that pull request!
-
-If you've never written Go in your life, then join the club! Lazygit was the maintainer's first Go program, and most contributors have never used Go before. Go is widely considered an easy-to-learn language, so if you're looking for an open source project to gain dev experience, you've come to the right place.
+4. Make sure your code follows the [effective go](https://golang.org/doc/effective_go.html) guidelines as much as possible.
+5. Be sure to test your modifications.
+6. Write a [good commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+7. Issue that pull request!
 
 ## Code of conduct
 
@@ -36,60 +36,9 @@ covers the project. Feel free to contact the maintainers if that's a concern.
 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!
 
-## Go
-
-This project is written in Go. Go is an opinionated language with strict idioms, but some of those idioms are a little extreme. Some things we do differently:
-
-1. There is no shame in using `self` as a receiver name in a struct method. In fact we encourage it
-2. There is no shame in prefixing an interface with 'I' instead of suffixing with 'er' when there are several methods on the interface.
-3. If a struct implements an interface, we make it explicit with something like:
-
-```go
-var _ MyInterface = &MyStruct{}
-```
-
-This makes the intent clearer and means that if we fail to satisfy the interface we'll get an error in the file that needs fixing.
-
-## Internationalisation
-
-Boy that's a hard word to spell. Anyway, lazygit is translated into several languages within the pkg/i18n package. If you need to render text to the user, you should add a new field to the TranslationSet struct in `pkg/i18n/english.go` and add the actual content within the `EnglishTranslationSet()` method in the same file. Although it is appreciated if you translate the text into other languages, it's not expected of you (google translate will likely do a bad job anyway!).
-
-## Debugging
-
-The easiest way to debug lazygit is to have two terminal tabs open at once: one for running lazygit (via `go run main.go -debug` in the project root) and one for viewing lazygit's logs (which can be done via `go run main.go --logs` or just `lazygit --logs`).
-
-From most places in the codebase you have access to a logger e.g. `gui.Log.Warn("blah")`
-
-If you find that the existing logs are too noisy, you can set the log level with e.g. `LOG_LEVEL=warn go run main.go -debug` and then only use `Warn` logs yourself.
-
-If you keep having to do some setup steps to reproduce an issue, read the Testing section below to see how to create an integration test by recording a lazygit session. It's pretty easy!
-
-If you want to trigger a debug session from VSCode, you can use the following snippet. Note that the 'console' key is not, at the time of writing, in a stable release.
-
-```jsonc
-// .vscode/launch.json
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "name": "debug lazygit",
-      "type": "go",
-      "request": "launch",
-      "mode": "auto",
-      "program": "main.go",
-      "console": "externalTerminal" // <-- you need this to actually see the lazygit UI in a window while debugging
-    }
-  ]
-}
-```
-
-## Testing
-
-Lazygit has two kinds of tests: unit tests and integration tests. Unit tests go in files that end in `_test.go`, and are written in Go. Lazygit has its own integration test system where you can build a sandbox repo with a shell script, record yourself doing something, and commit the resulting repo snapshot. It's pretty damn cool! To learn more see [here](https://github.com/jesseduffield/lazygit/blob/master/docs/Integration_Tests.md)
-
 ## 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 rendering windows and handling user input. Here's the typical process to follow:
+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`)
@@ -97,11 +46,7 @@ Sometimes you will need to make a change in the gocui fork (https://github.com/j
 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
-./scripts/bump_gocui.sh
+./bump_gocui.sh
 ```
 
 5. Raise a PR in lazygit with those changes
-
-## Improvements
-
-If you can think of any way to improve these docs let us know.

README.md

@@ -169,7 +169,7 @@ conda install -c conda-forge lazygit
 ### Go
 
 ```sh
-go install github.com/jesseduffield/lazygit@latest
+go get github.com/jesseduffield/lazygit
 ```
 
 Please note:

docs/Config.md

@@ -44,7 +44,7 @@ gui:
     show: true
   mouseEvents: true
   skipUnstageLineWarning: false
-  skipStashWarning: 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
@@ -205,7 +205,6 @@ keybinding:
     resetCherryPick: '<c-R>'
     copyCommitMessageToClipboard: '<c-y>'
     openLogMenu: '<c-l>'
-    viewBisectOptions: 'b'
   stash:
     popStash: 'g'
   commitFiles:
@@ -390,7 +389,6 @@ gui:
 ```
 
 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:
@@ -400,16 +398,6 @@ gui:
     '*': '#0000ff'
 ```
 
-## Custom Branch Color
-
-You can customize the color of branches based on the branch prefix:
-
-```yaml
-gui:
-  branchColors:
-    'docs': '#11aaff' # use a light blue for branches beginning with 'docs/'
-```
-
 ## Example Coloring
 
 ![border example](../../assets/colored-border-example.png)

docs/Custom_Command_Keybindings.md

@@ -69,7 +69,6 @@ For a given custom command, here are the allowed fields:
 | 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 |
-| stream | whether you want to stream the command's output to the Command Log panel | no |
 
 ### Contexts
 

docs/Integration_Tests.md

@@ -33,32 +33,17 @@ git commit -am "myfile1"
 
 ## Running tests
 
-### From a TUI
-
-You can run/record/sandbox tests via a TUI with the following command:
-
-```
-go run test/lazyintegration/main.go
-```
-
-This TUI makes much of the following documentation redundant, but feel free to read through anyway!
-
-### From command line
-
 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:
@@ -66,35 +51,29 @@ 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
-
 ```
-MODE=updateSnapshot go test ./pkg/gui -run /<test name>
+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:
-
+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:
 ```
-MODE=record go test ./pkg/gui -run /<test name>
+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.
+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)
@@ -106,14 +85,6 @@ recording.json
 
 Feel free to create a hierarchy of directories in the `test/integration` directory to group tests by feature.
 
-## Sandboxing
-
-The integration tests serve a secondary purpose of providing a setup for easy sandboxing. If you want to run a test in sandbox mode (meaning the session won't be recorded and we won't create/update snapshots), go:
-
-```
-MODE=sandbox go test ./pkg/gui -run /<test name>
-```
-
 ## Feedback
 
 If you think this process can be improved, let me know! It shouldn't be too hard to change things.

docs/keybindings/Keybindings_en.md

@@ -1,5 +1,3 @@
-_This file is auto-generated. To update, make the changes in the pkg/i18n directory and then run `go run scripts/cheatsheet/main.go generate` from the project root._
-
 # Lazygit Keybindings
 
 ## Global Keybindings
@@ -23,8 +21,6 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>W</kbd>: open diff menu
   <kbd>ctrl+e</kbd>: open diff menu
   <kbd>@</kbd>: open command log menu
-  <kbd>}</kbd>: Increase the size of the context shown around changes in the diff view
-  <kbd>{</kbd>: Decrease the size of the context shown around changes in the diff view
 </pre>
 
 ## List Panel Navigation
@@ -123,7 +119,6 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 ## Commits Panel (Commits)
 
 <pre>
-  <kbd>ctrl+l</kbd>: open log menu
   <kbd>s</kbd>: squash down
   <kbd>r</kbd>: reword commit
   <kbd>R</kbd>: reword commit with editor
@@ -148,8 +143,6 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>T</kbd>: tag commit
   <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
   <kbd>ctrl+y</kbd>: copy commit message to clipboard
-  <kbd>o</kbd>: open commit in browser
-  <kbd>b</kbd>: view bisect options
 </pre>
 
 ## Commits Panel (Reflog Tab)
@@ -170,12 +163,6 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>@</kbd>: open command log menu
 </pre>
 
-## Files Panel
-
-<pre>
-  <kbd>ctrl+b</kbd>: Filter commit files
-</pre>
-
 ## Files Panel (Files)
 
 <pre>
@@ -207,7 +194,7 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 <pre>
   <kbd>ctrl+o</kbd>: copy submodule name to clipboard
   <kbd>enter</kbd>: enter submodule
-  <kbd>d</kbd>: remove 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
@@ -218,8 +205,6 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 ## Main Panel (Merging)
 
 <pre>
-  <kbd>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
   <kbd>esc</kbd>: return to files panel
   <kbd>M</kbd>: open external merge tool (git mergetool)
   <kbd>space</kbd>: pick hunk
@@ -247,13 +232,10 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>▼</kbd>: select next line
   <kbd>◄</kbd>: select previous hunk
   <kbd>►</kbd>: select next hunk
-  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
   <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
-  <kbd>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
 </pre>
 
 ## Main Panel (Staging)
@@ -268,14 +250,11 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>▼</kbd>: select next line
   <kbd>◄</kbd>: select previous hunk
   <kbd>►</kbd>: select next hunk
-  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
   <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>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
   <kbd>c</kbd>: commit changes
   <kbd>w</kbd>: commit changes without pre-commit hook
   <kbd>C</kbd>: commit changes using git editor

docs/keybindings/Keybindings_nl.md

@@ -1,5 +1,3 @@
-_This file is auto-generated. To update, make the changes in the pkg/i18n directory and then run `go run scripts/cheatsheet/main.go generate` from the project root._
-
 # Lazygit Sneltoetsen
 
 ## Globale Sneltoetsen
@@ -23,8 +21,6 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>W</kbd>: open diff menu
   <kbd>ctrl+e</kbd>: open diff menu
   <kbd>@</kbd>: open command log menu
-  <kbd>}</kbd>: Increase the size of the context shown around changes in the diff view
-  <kbd>{</kbd>: Decrease the size of the context shown around changes in the diff view
 </pre>
 
 ## Lijstpaneel Navigatie
@@ -123,7 +119,6 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 ## Commits Paneel (Commits)
 
 <pre>
-  <kbd>ctrl+l</kbd>: open log menu
   <kbd>s</kbd>: squash beneden
   <kbd>r</kbd>: hernoem commit
   <kbd>R</kbd>: hernoem commit met editor
@@ -148,8 +143,6 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>T</kbd>: tag commit
   <kbd>ctrl+r</kbd>: reset cherry-picked (gekopieerde) commits selectie
   <kbd>ctrl+y</kbd>: kopieer commit bericht naar klembord
-  <kbd>o</kbd>: open commit in browser
-  <kbd>b</kbd>: view bisect options
 </pre>
 
 ## Commits Paneel (Reflog Tabblad)
@@ -170,12 +163,6 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>@</kbd>: open command log menu
 </pre>
 
-## Bestanden Paneel
-
-<pre>
-  <kbd>ctrl+b</kbd>: Commit dossiers filteren
-</pre>
-
 ## Bestanden Paneel (Bestanden)
 
 <pre>
@@ -207,7 +194,7 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 <pre>
   <kbd>ctrl+o</kbd>: kopieer submodule naam naar klembord
   <kbd>enter</kbd>: enter submodule
-  <kbd>d</kbd>: remove 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
@@ -218,8 +205,6 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 ## Hoofd Paneel (Mergen)
 
 <pre>
-  <kbd>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
   <kbd>esc</kbd>: ga terug naar het bestanden paneel
   <kbd>M</kbd>: open external merge tool (git mergetool)
   <kbd>space</kbd>: kies hunk
@@ -247,13 +232,10 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>▼</kbd>: selecteer de volgende lijn
   <kbd>◄</kbd>: selecteer de vorige hunk
   <kbd>►</kbd>: selecteer de volgende hunk
-  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
   <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
-  <kbd>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
 </pre>
 
 ## Hoofd Paneel (Staging)
@@ -268,14 +250,11 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>▼</kbd>: selecteer de volgende lijn
   <kbd>◄</kbd>: selecteer de vorige hunk
   <kbd>►</kbd>: selecteer de volgende hunk
-  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
   <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>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
   <kbd>c</kbd>: Commit veranderingen
   <kbd>w</kbd>: commit veranderingen zonder pre-commit hook
   <kbd>C</kbd>: commit veranderingen met de git editor

docs/keybindings/Keybindings_pl.md

@@ -1,5 +1,3 @@
-_This file is auto-generated. To update, make the changes in the pkg/i18n directory and then run `go run scripts/cheatsheet/main.go generate` from the project root._
-
 # Lazygit Keybindings
 
 ## Globalne
@@ -8,7 +6,7 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <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>: widok scalenia/opcje zmiany bazy
+  <kbd>m</kbd>: view merge/rebase options
   <kbd>ctrl+p</kbd>: view custom patch options
   <kbd>P</kbd>: push
   <kbd>p</kbd>: pull
@@ -18,13 +16,11 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>ctrl+z</kbd>: redo (via reflog) (experimental)
   <kbd>+</kbd>: next screen mode (normal/half/fullscreen)
   <kbd>_</kbd>: prev screen mode
-  <kbd>:</kbd>: wykonaj własną komendę
+  <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
-  <kbd>}</kbd>: Increase the size of the context shown around changes in the diff view
-  <kbd>{</kbd>: Decrease the size of the context shown around changes in the diff view
 </pre>
 
 ## List Panel Navigation
@@ -43,18 +39,18 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 
 <pre>
   <kbd>space</kbd>: przełącz
-  <kbd>o</kbd>: utwórz żądanie pobrania
+  <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 pobrania do schowka
+  <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>: zmiana bazy gałęzi
+  <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>: wyświetl opcje resetu
+  <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
@@ -63,14 +59,14 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 ## Gałęzie Panel (Remote Branches (in Remotes tab))
 
 <pre>
-  <kbd>esc</kbd>: wróć do listy repozytoriów zdalnych
-  <kbd>g</kbd>: wyświetl opcje resetu
+  <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>: zmiana bazy gałęzi
+  <kbd>r</kbd>: rebase branch
   <kbd>u</kbd>: set as upstream of checked-out branch
 </pre>
 
@@ -86,12 +82,12 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 ## Gałęzie Panel (Sub-commits)
 
 <pre>
-  <kbd>enter</kbd>: przeglądaj pliki commita
+  <kbd>enter</kbd>: view commit's files
   <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: wyświetl opcje resetu
+  <kbd>g</kbd>: view reset options
   <kbd>n</kbd>: nowa gałąź
-  <kbd>c</kbd>: kopiuj commit (przebieranie)
-  <kbd>C</kbd>: kopiuj zakres commitów (przebieranie)
+  <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>
@@ -103,16 +99,16 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>d</kbd>: delete tag
   <kbd>P</kbd>: push tag
   <kbd>n</kbd>: create tag
-  <kbd>g</kbd>: wyświetl opcje resetu
+  <kbd>g</kbd>: view reset options
   <kbd>enter</kbd>: view commits
 </pre>
 
-## Pliki commita Panel
+## Commit files Panel
 
 <pre>
   <kbd>ctrl+o</kbd>: copy the committed file name to the clipboard
-  <kbd>c</kbd>: plik wybierania
-  <kbd>d</kbd>: porzuć zmiany commita dla tego pliku
+  <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
@@ -123,43 +119,40 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 ## Commity Panel (Commity)
 
 <pre>
-  <kbd>ctrl+l</kbd>: open log menu
-  <kbd>s</kbd>: ściśnij
-  <kbd>r</kbd>: zmień nazwę commita
-  <kbd>R</kbd>: zmień nazwę commita w edytorze
+  <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>: utwórz commit naprawczy dla tego commita
-  <kbd>S</kbd>: spłaszcz wszystkie commity naprawcze powyżej zaznaczonych commitów (autosquash)
-  <kbd>d</kbd>: usuń commit
-  <kbd>ctrl+j</kbd>: przenieś commit 1 w dół
-  <kbd>ctrl+k</kbd>: przenieś commit 1 w górę
-  <kbd>e</kbd>: edytuj commit
-  <kbd>A</kbd>: popraw commit zmianami z poczekalni
-  <kbd>p</kbd>: wybierz commit (podczas zmiany bazy)
-  <kbd>t</kbd>: odwróć commit
-  <kbd>c</kbd>: kopiuj commit (przebieranie)
+  <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>: kopiuj zakres commitów (przebieranie)
-  <kbd>v</kbd>: wklej commity (przebieranie)
-  <kbd>enter</kbd>: przeglądaj pliki commita
+  <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
-  <kbd>o</kbd>: open commit in browser
-  <kbd>b</kbd>: view bisect options
 </pre>
 
 ## Commity Panel (Reflog Tab)
 
 <pre>
-  <kbd>enter</kbd>: przeglądaj pliki commita
+  <kbd>enter</kbd>: view commit's files
   <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: wyświetl opcje resetu
-  <kbd>c</kbd>: kopiuj commit (przebieranie)
-  <kbd>C</kbd>: kopiuj zakres commitów (przebieranie)
+  <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>
@@ -170,31 +163,25 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>@</kbd>: open command log menu
 </pre>
 
-## Pliki Panel
-
-<pre>
-  <kbd>ctrl+b</kbd>: Filtrowanie commitów
-</pre>
-
 ## Pliki Panel (Pliki)
 
 <pre>
-  <kbd>c</kbd>: Zatwierdź zmiany
-  <kbd>w</kbd>: zatwierdź zmiany bez skryptu pre-commit
-  <kbd>A</kbd>: Zmień ostatni commit
-  <kbd>C</kbd>: Zatwierdź zmiany używając edytora
-  <kbd>space</kbd>: przełącz stan poczekalni
-  <kbd>d</kbd>: pokaż opcje porzucania zmian
+  <kbd>c</kbd>: commituj zmiany
+  <kbd>w</kbd>: commit changes without pre-commit hook
+  <kbd>A</kbd>: zmień ostatnie zatwierdzenie
+  <kbd>C</kbd>: commituj zmiany używając edytora z gita
+  <kbd>space</kbd>: przełącz zatwierdzenie
+  <kbd>d</kbd>: view 'discard changes' options
   <kbd>e</kbd>: edytuj plik
   <kbd>o</kbd>: otwórz plik
   <kbd>i</kbd>: dodaj do .gitignore
   <kbd>r</kbd>: odśwież pliki
-  <kbd>s</kbd>: przechowaj zmiany
-  <kbd>S</kbd>: wyświetl opcje schowka
-  <kbd>a</kbd>: przełącz stan poczekalni wszystkich
-  <kbd>D</kbd>: wyświetl opcje resetu
+  <kbd>s</kbd>: przechowaj pliki
+  <kbd>S</kbd>: view stash options
+  <kbd>a</kbd>: przełącz wszystkie zatwierdzenia
+  <kbd>D</kbd>: view reset options
   <kbd>enter</kbd>: zatwierdź pojedyncze linie
-  <kbd>f</kbd>: pobierz
+  <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
@@ -207,7 +194,7 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 <pre>
   <kbd>ctrl+o</kbd>: copy submodule name to clipboard
   <kbd>enter</kbd>: enter submodule
-  <kbd>d</kbd>: remove 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
@@ -215,48 +202,43 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>b</kbd>: view bulk submodule options
 </pre>
 
-## Główne Panel (Scalanie)
+## Main Panel (Merging)
 
 <pre>
-  <kbd>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
   <kbd>esc</kbd>: wróć do panelu plików
   <kbd>M</kbd>: open external merge tool (git mergetool)
-  <kbd>space</kbd>: wybierz kawałek
-  <kbd>b</kbd>: wybierz wszystkie kawałki
-  <kbd>◄</kbd>: poprzedni konflikt
-  <kbd>►</kbd>: następny konflikt
-  <kbd>▲</kbd>: wybierz poprzedni kawałek
-  <kbd>▼</kbd>: wybierz następny kawałek
+  <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
 </pre>
 
-## Główne Panel (Zwykłe)
+## Main Panel (Normal)
 
 <pre>
-  <kbd>Ő</kbd>: przewiń w dół (fn+up)
-  <kbd>ő</kbd>: przewiń w górę (fn+down)
+  <kbd>Ő</kbd>: scroll down (fn+up)
+  <kbd>ő</kbd>: scroll up (fn+down)
 </pre>
 
-## Główne Panel (Patch Building)
+## Main Panel (Patch Building)
 
 <pre>
-  <kbd>esc</kbd>: wyście z trybu "linia po linii"
+  <kbd>esc</kbd>: exit line-by-line mode
   <kbd>o</kbd>: otwórz plik
-  <kbd>▲</kbd>: poprzednia linia
-  <kbd>▼</kbd>: następna linia
-  <kbd>◄</kbd>: poprzedni kawałek
-  <kbd>►</kbd>: następny kawałek
-  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
+  <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
-  <kbd>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
 </pre>
 
-## Główne Panel (Poczekalnia)
+## Main Panel (Zatwierdzanie)
 
 <pre>
   <kbd>esc</kbd>: wróć do panelu plików
@@ -264,21 +246,18 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
   <kbd>d</kbd>: delete change (git reset)
   <kbd>tab</kbd>: switch to other panel
   <kbd>o</kbd>: otwórz plik
-  <kbd>▲</kbd>: poprzednia linia
-  <kbd>▼</kbd>: następna linia
-  <kbd>◄</kbd>: poprzedni kawałek
-  <kbd>►</kbd>: następny kawałek
-  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
+  <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>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
-  <kbd>c</kbd>: Zatwierdź zmiany
-  <kbd>w</kbd>: zatwierdź zmiany bez skryptu pre-commit
-  <kbd>C</kbd>: Zatwierdź zmiany używając edytora
+  <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
@@ -300,9 +279,9 @@ _This file is auto-generated. To update, make the changes in the pkg/i18n direct
 ## Status Panel
 
 <pre>
-  <kbd>e</kbd>: edytuj konfigurację
-  <kbd>o</kbd>: otwórz konfigurację
+  <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>: pokaż wszystkie logi gałęzi
+  <kbd>a</kbd>: pokazywać wszystkie logi branżowe
 </pre>

docs/keybindings/Keybindings_zh.md

@@ -1,308 +0,0 @@
-_This file is auto-generated. To update, make the changes in the pkg/i18n directory and then run `go run scripts/cheatsheet/main.go generate` from the project root._
-
-# Lazygit 按键绑定
-
-## 全局键绑定
-
-<pre>
-  <kbd>ctrl+r</kbd>: 切换到最近的仓库 (<c-r>)
-  <kbd>pgup</kbd>: 向上滚动主面板 (fn+up)
-  <kbd>pgdown</kbd>: 向下滚动主面板 (fn+down)
-  <kbd>m</kbd>: 查看 合并/变基 选项
-  <kbd>ctrl+p</kbd>: 查看自定义补丁选项
-  <kbd>P</kbd>: 推送
-  <kbd>p</kbd>: 拉取
-  <kbd>R</kbd>: 刷新
-  <kbd>x</kbd>: 打开菜单
-  <kbd>z</kbd>: （通过 reflog）撤销「实验功能」
-  <kbd>ctrl+z</kbd>: （通过 reflog）重做「实验功能」
-  <kbd>+</kbd>: 下一屏模式（正常/半屏/全屏）
-  <kbd>_</kbd>: 上一屏模式
-  <kbd>:</kbd>: 执行自定义命令
-  <kbd>ctrl+s</kbd>: 查看按路径过滤选项
-  <kbd>W</kbd>: 打开 diff 菜单
-  <kbd>ctrl+e</kbd>: 打开 diff 菜单
-  <kbd>@</kbd>: 打开命令日志菜单
-  <kbd>}</kbd>: Increase the size of the context shown around changes in the diff view
-  <kbd>{</kbd>: Decrease the size of the context shown around changes in the diff view
-</pre>
-
-## 列表面板导航
-
-<pre>
-  <kbd>.</kbd>: 下一页
-  <kbd>,</kbd>: 上一页
-  <kbd><</kbd>: 滚动到顶部
-  <kbd>></kbd>: 滚动到底部
-  <kbd>/</kbd>: 开始搜索
-  <kbd>]</kbd>: 下一个标签
-  <kbd>[</kbd>: 上一个标签
-</pre>
-
-## 分支 面板 (分支标签)
-
-<pre>
-  <kbd>space</kbd>: 检出
-  <kbd>o</kbd>: 创建抓取请求
-  <kbd>O</kbd>: 创建抓取请求选项
-  <kbd>ctrl+y</kbd>: 将抓取请求 URL 复制到剪贴板
-  <kbd>c</kbd>: 按名称检出
-  <kbd>F</kbd>: 强制检出
-  <kbd>n</kbd>: 新分支
-  <kbd>d</kbd>: 删除分支
-  <kbd>r</kbd>: 将已检出的分支变基到该分支
-  <kbd>M</kbd>: 合并到当前检出的分支
-  <kbd>i</kbd>: 显示 git-flow 选项
-  <kbd>f</kbd>: 从上游快进此分支
-  <kbd>g</kbd>: 查看重置选项
-  <kbd>R</kbd>: 重命名分支
-  <kbd>ctrl+o</kbd>: 将分支名称复制到剪贴板
-  <kbd>enter</kbd>: 查看提交
-</pre>
-
-## 分支 面板 (远程分支（在远程页面中）)
-
-<pre>
-  <kbd>esc</kbd>: 返回远程仓库列表
-  <kbd>g</kbd>: 查看重置选项
-  <kbd>enter</kbd>: 查看提交
-  <kbd>space</kbd>: 检出
-  <kbd>n</kbd>: 新分支
-  <kbd>M</kbd>: 合并到当前检出的分支
-  <kbd>d</kbd>: 删除分支
-  <kbd>r</kbd>: 将已检出的分支变基到该分支
-  <kbd>u</kbd>: 设置为检出分支的上游
-</pre>
-
-## 分支 面板 (远程页面)
-
-<pre>
-  <kbd>f</kbd>: 抓取远程仓库
-  <kbd>n</kbd>: 添加新的远程仓库
-  <kbd>d</kbd>: 删除远程
-  <kbd>e</kbd>: 编辑远程仓库
-</pre>
-
-## 分支 面板 (子提交)
-
-<pre>
-  <kbd>enter</kbd>: 查看提交的文件
-  <kbd>space</kbd>: 检出提交
-  <kbd>g</kbd>: 查看重置选项
-  <kbd>n</kbd>: 新分支
-  <kbd>c</kbd>: 复制提交（拣选）
-  <kbd>C</kbd>: 复制提交范围（拣选）
-  <kbd>ctrl+r</kbd>: 重置已拣选（复制）的提交
-  <kbd>ctrl+o</kbd>: 将提交的 SHA 复制到剪贴板
-</pre>
-
-## 分支 面板 (标签页面)
-
-<pre>
-  <kbd>space</kbd>: 检出
-  <kbd>d</kbd>: 删除标签
-  <kbd>P</kbd>: 推送标签
-  <kbd>n</kbd>: 创建标签
-  <kbd>g</kbd>: 查看重置选项
-  <kbd>enter</kbd>: 查看提交
-</pre>
-
-## 提交文件 面板
-
-<pre>
-  <kbd>ctrl+o</kbd>: 将提交的文件名复制到剪贴板
-  <kbd>c</kbd>: 检出文件
-  <kbd>d</kbd>: 放弃对此文件的提交更改
-  <kbd>o</kbd>: 打开文件
-  <kbd>e</kbd>: 编辑文件
-  <kbd>space</kbd>: 补丁中包含的切换文件
-  <kbd>enter</kbd>: 输入文件以将所选行添加到补丁中（或切换目录折叠）
-  <kbd>`</kbd>: 切换文件树视图
-</pre>
-
-## 提交 面板 (提交)
-
-<pre>
-  <kbd>ctrl+l</kbd>: open log menu
-  <kbd>s</kbd>: 向下压缩
-  <kbd>r</kbd>: 改写提交
-  <kbd>R</kbd>: 使用编辑器重命名提交
-  <kbd>g</kbd>: 重置为此提交
-  <kbd>f</kbd>: 修正提交（fixup）
-  <kbd>F</kbd>: 为此提交创建修正
-  <kbd>S</kbd>: 压缩在所选提交之上的所有“fixup!”提交（自动压缩）
-  <kbd>d</kbd>: 删除提交
-  <kbd>ctrl+j</kbd>: 下移提交
-  <kbd>ctrl+k</kbd>: 上移提交
-  <kbd>e</kbd>: 编辑提交
-  <kbd>A</kbd>: 用已暂存的更改来修补提交
-  <kbd>p</kbd>: 选择提交（变基过程中）
-  <kbd>t</kbd>: 还原提交
-  <kbd>c</kbd>: 复制提交（拣选）
-  <kbd>ctrl+o</kbd>: 将提交的 SHA 复制到剪贴板
-  <kbd>C</kbd>: 复制提交范围（拣选）
-  <kbd>v</kbd>: 粘贴提交（拣选）
-  <kbd>enter</kbd>: 查看提交的文件
-  <kbd>space</kbd>: 检出提交
-  <kbd>n</kbd>: 从提交创建新分支
-  <kbd>T</kbd>: 标签提交
-  <kbd>ctrl+r</kbd>: 重置已拣选（复制）的提交
-  <kbd>ctrl+y</kbd>: 将提交消息复制到剪贴板
-  <kbd>o</kbd>: open commit in browser
-  <kbd>b</kbd>: view bisect options
-</pre>
-
-## 提交 面板 (Reflog)
-
-<pre>
-  <kbd>enter</kbd>: 查看提交的文件
-  <kbd>space</kbd>: 检出提交
-  <kbd>g</kbd>: 查看重置选项
-  <kbd>c</kbd>: 复制提交（拣选）
-  <kbd>C</kbd>: 复制提交范围（拣选）
-  <kbd>ctrl+r</kbd>: 重置已拣选（复制）的提交
-  <kbd>ctrl+o</kbd>: 将提交的 SHA 复制到剪贴板
-</pre>
-
-## Extras 面板
-
-<pre>
-  <kbd>@</kbd>: 打开命令日志菜单
-</pre>
-
-## 文件 面板
-
-<pre>
-  <kbd>ctrl+b</kbd>: 过滤提交文件
-</pre>
-
-## 文件 面板 (文件)
-
-<pre>
-  <kbd>c</kbd>: 提交更改
-  <kbd>w</kbd>: 提交更改而无需预先提交钩子
-  <kbd>A</kbd>: 修补最后一次提交
-  <kbd>C</kbd>: 提交更改（使用编辑器编辑提交信息）
-  <kbd>space</kbd>: 切换暂存状态
-  <kbd>d</kbd>: 查看'放弃更改‘选项
-  <kbd>e</kbd>: 编辑文件
-  <kbd>o</kbd>: 打开文件
-  <kbd>i</kbd>: 添加到 .gitignore
-  <kbd>r</kbd>: 刷新文件
-  <kbd>s</kbd>: 将所有更改加入贮藏
-  <kbd>S</kbd>: 查看隐藏选项
-  <kbd>a</kbd>: 切换所有文件的暂存状态
-  <kbd>D</kbd>: 查看重置选项
-  <kbd>enter</kbd>: 暂存单个 块/行 用于文件, 或 折叠/展开 目录
-  <kbd>f</kbd>: 抓取
-  <kbd>ctrl+o</kbd>: 将文件名复制到剪贴板
-  <kbd>g</kbd>: 查看上游重置选项
-  <kbd>`</kbd>: 切换文件树视图
-  <kbd>M</kbd>: 打开合并工具
-  <kbd>ctrl+w</kbd>: 切换是否在差异视图中显示空白更改
-</pre>
-
-## 文件 面板 (子模块)
-
-<pre>
-  <kbd>ctrl+o</kbd>: 将子模块名称复制到剪贴板
-  <kbd>enter</kbd>: 输入子模块
-  <kbd>d</kbd>: 删除子模块
-  <kbd>u</kbd>: 更新子模块
-  <kbd>n</kbd>: 添加新的子模块
-  <kbd>e</kbd>: 更新子模块 URL
-  <kbd>i</kbd>: 初始化子模块
-  <kbd>b</kbd>: 查看批量子模块选项
-</pre>
-
-## 主要 面板 (合并中)
-
-<pre>
-  <kbd>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
-  <kbd>esc</kbd>: 返回文件面板
-  <kbd>M</kbd>: 打开合并工具
-  <kbd>space</kbd>: 选中区块
-  <kbd>b</kbd>: 选中所有区块
-  <kbd>◄</kbd>: 选择上一个冲突
-  <kbd>►</kbd>: 选择下一个冲突
-  <kbd>▲</kbd>: 选择顶部块
-  <kbd>▼</kbd>: 选择底部块
-  <kbd>z</kbd>: 撤销
-</pre>
-
-## 主要 面板 (正常)
-
-<pre>
-  <kbd>Ő</kbd>: 向下滚动 (fn+up)
-  <kbd>ő</kbd>: 向上滚动 (fn+down)
-</pre>
-
-## 主要 面板 (构建补丁中)
-
-<pre>
-  <kbd>esc</kbd>: 退出逐行模式
-  <kbd>o</kbd>: 打开文件
-  <kbd>▲</kbd>: 选择上一行
-  <kbd>▼</kbd>: 选择下一行
-  <kbd>◄</kbd>: 选择上一个区块
-  <kbd>►</kbd>: 选择下一个区块
-  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
-  <kbd>space</kbd>: 添加/移除 行到补丁
-  <kbd>v</kbd>: 切换拖动选择
-  <kbd>V</kbd>: 切换拖动选择
-  <kbd>a</kbd>: 切换选择区块
-  <kbd>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
-</pre>
-
-## 主要 面板 (正在暂存)
-
-<pre>
-  <kbd>esc</kbd>: 返回文件面板
-  <kbd>space</kbd>: 切换行暂存状态
-  <kbd>d</kbd>: 取消变更 (git reset)
-  <kbd>tab</kbd>: 切换到其他面板
-  <kbd>o</kbd>: 打开文件
-  <kbd>▲</kbd>: 选择上一行
-  <kbd>▼</kbd>: 选择下一行
-  <kbd>◄</kbd>: 选择上一个区块
-  <kbd>►</kbd>: 选择下一个区块
-  <kbd>ctrl+o</kbd>: copy the selected text to the clipboard
-  <kbd>e</kbd>: 编辑文件
-  <kbd>o</kbd>: 打开文件
-  <kbd>v</kbd>: 切换拖动选择
-  <kbd>V</kbd>: 切换拖动选择
-  <kbd>a</kbd>: 切换选择区块
-  <kbd>H</kbd>: scroll left
-  <kbd>L</kbd>: scroll right
-  <kbd>c</kbd>: 提交更改
-  <kbd>w</kbd>: 提交更改而无需预先提交钩子
-  <kbd>C</kbd>: 提交更改（使用编辑器编辑提交信息）
-</pre>
-
-## 菜单 面板
-
-<pre>
-  <kbd>esc</kbd>: 关闭菜单
-</pre>
-
-## 贮藏 面板
-
-<pre>
-  <kbd>enter</kbd>: 查看贮藏条目中的文件
-  <kbd>space</kbd>: 应用
-  <kbd>g</kbd>: 应用并删除
-  <kbd>d</kbd>: 删除
-  <kbd>n</kbd>: 新分支
-</pre>
-
-## 状态 面板
-
-<pre>
-  <kbd>e</kbd>: 编辑配置文件
-  <kbd>o</kbd>: 打开配置文件
-  <kbd>u</kbd>: 检查更新
-  <kbd>enter</kbd>: 切换到最近的仓库
-  <kbd>a</kbd>: 显示所有分支的日志
-</pre>

go.mod

@@ -11,7 +11,6 @@ require (
 	github.com/creack/pty v1.1.11
 	github.com/fatih/color v1.9.0 // indirect
 	github.com/fsnotify/fsnotify v1.4.7
-	github.com/gdamore/tcell/v2 v2.4.1-0.20210926162909-66f061b1fc9b // indirect
 	github.com/go-errors/errors v1.4.1
 	github.com/go-logfmt/logfmt v0.5.0 // indirect
 	github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3
@@ -21,7 +20,7 @@ require (
 	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.20220108045521-1945d7b9ed8b
+	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
@@ -34,16 +33,14 @@ require (
 	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/pmezard/go-difflib v1.0.0
 	github.com/sahilm/fuzzy v0.1.0
-	github.com/sanity-io/litter v1.5.2
 	github.com/sirupsen/logrus v1.4.2
 	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-20211216021012-1d35b9e2eb4e // 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

go.sum

@@ -18,7 +18,6 @@ github.com/cloudfoundry/jibber_jabber v0.0.0-20151120183258-bcc4c8345a21/go.mod
 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 v0.0.0-20161028175848-04cdfd42973b/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 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=
@@ -35,8 +34,6 @@ github.com/gdamore/encoding v1.0.0 h1:+7OoQ1Bc6eTm5niUzBa0Ctsh6JbMW6Ra+YNuAtDBdk
 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/gdamore/tcell/v2 v2.4.1-0.20210926162909-66f061b1fc9b h1:eoaSI4eEwM5eTx/HvmRSwmicxuMhL73AyoEfM1oCJLc=
-github.com/gdamore/tcell/v2 v2.4.1-0.20210926162909-66f061b1fc9b/go.mod h1:ZPwXnysybtQqdqKcWMWXux9aGdtMHe+kr+cwEZEe+A4=
 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=
@@ -74,8 +71,8 @@ github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOl
 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.20220108045521-1945d7b9ed8b h1:AUK5nDiPiaahBtGIsf8rITgZ9SC+uddvnNKs0/mrYA8=
-github.com/jesseduffield/gocui v0.3.1-0.20220108045521-1945d7b9ed8b/go.mod h1:znJuCDnF2Ph40YZSlBwdX/4GEofnIoWLGdT4mK5zRAU=
+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=
@@ -127,7 +124,6 @@ github.com/onsi/gomega v1.7.1 h1:K0jcRCwNQM3vFGh1ppMtDh/+7ApJrjldlX8fA0jDTLQ=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 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 v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 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=
@@ -135,8 +131,6 @@ 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/sanity-io/litter v1.5.2 h1:AnC8s9BMORWH5a4atZ4D6FPVvKGzHcnc5/IVTa87myw=
-github.com/sanity-io/litter v1.5.2/go.mod h1:5Z71SvaYy5kcGtyglXOC9rrUi3c1E8CamFWjQsazTh0=
 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=
@@ -146,9 +140,9 @@ github.com/spkg/bom v0.0.0-20160624110644-59b7046e48ad/go.mod h1:qLr4V1qq6nMqFKk
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v0.0.0-20161117074351-18a02ba4a312/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 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=
@@ -184,8 +178,8 @@ golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7w
 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-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM=
-golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/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=

main.go

@@ -71,12 +71,8 @@ func main() {
 			log.Fatal("--path option is incompatible with the --work-tree and --git-dir options")
 		}
 
-		absRepoPath, err := filepath.Abs(repoPath)
-		if err != nil {
-			log.Fatal(err)
-		}
-		workTree = absRepoPath
-		gitDir = filepath.Join(absRepoPath, ".git")
+		workTree = repoPath
+		gitDir = filepath.Join(repoPath, ".git")
 	}
 
 	if customConfig != "" {

pkg/app/app.go

@@ -32,6 +32,7 @@ type App struct {
 	closers       []io.Closer
 	Config        config.AppConfigurer
 	OSCommand     *oscommands.OSCommand
+	GitCommand    *commands.GitCommand
 	Gui           *gui.Gui
 	Updater       *updates.Updater // may only need this on the Gui
 	ClientContext string
@@ -42,7 +43,7 @@ type errorMapping struct {
 	newError      string
 }
 
-func newProductionLogger() *logrus.Logger {
+func newProductionLogger(config config.AppConfigurer) *logrus.Logger {
 	log := logrus.New()
 	log.Out = ioutil.Discard
 	log.SetLevel(logrus.ErrorLevel)
@@ -58,7 +59,7 @@ func getLogLevel() logrus.Level {
 	return level
 }
 
-func newDevelopmentLogger() *logrus.Logger {
+func newDevelopmentLogger(configurer config.AppConfigurer) *logrus.Logger {
 	logger := logrus.New()
 	logger.SetLevel(getLogLevel())
 	logPath, err := config.LogPath()
@@ -67,7 +68,7 @@ func newDevelopmentLogger() *logrus.Logger {
 	}
 	file, err := os.OpenFile(logPath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
 	if err != nil {
-		log.Fatalf("Unable to log to log file: %v", err)
+		panic("unable to log to file") // TODO: don't panic (also, remove this call to the `panic` function)
 	}
 	logger.SetOutput(file)
 	return logger
@@ -76,9 +77,9 @@ func newDevelopmentLogger() *logrus.Logger {
 func newLogger(config config.AppConfigurer) *logrus.Entry {
 	var log *logrus.Logger
 	if config.GetDebug() || os.Getenv("DEBUG") == "TRUE" {
-		log = newDevelopmentLogger()
+		log = newDevelopmentLogger(config)
 	} else {
-		log = newProductionLogger()
+		log = newProductionLogger(config)
 	}
 
 	// highly recommended: tail -f development.log | humanlog
@@ -121,7 +122,7 @@ func NewApp(config config.AppConfigurer, filterPath string) (*App, error) {
 		return app, nil
 	}
 
-	app.OSCommand = oscommands.NewOSCommand(app.Common, oscommands.GetPlatform(), oscommands.NewNullGuiIO(log))
+	app.OSCommand = oscommands.NewOSCommand(app.Common)
 
 	app.Updater, err = updates.NewUpdater(app.Common, config, app.OSCommand)
 	if err != nil {
@@ -133,9 +134,16 @@ func NewApp(config config.AppConfigurer, filterPath string) (*App, error) {
 		return app, err
 	}
 
-	gitConfig := git_config.NewStdCachedGitConfig(app.Log)
+	app.GitCommand, err = commands.NewGitCommand(
+		app.Common,
+		app.OSCommand,
+		git_config.NewStdCachedGitConfig(app.Log),
+	)
+	if err != nil {
+		return app, err
+	}
 
-	app.Gui, err = gui.NewGui(app.Common, config, gitConfig, app.Updater, filterPath, showRecentRepos)
+	app.Gui, err = gui.NewGui(app.Common, app.GitCommand, app.OSCommand, config, app.Updater, filterPath, showRecentRepos)
 	if err != nil {
 		return app, err
 	}
@@ -184,7 +192,7 @@ func (app *App) setupRepo() (bool, error) {
 	}
 
 	if env.GetGitDirEnv() != "" {
-		// we've been given the git dir directly. We'll verify this dir when initializing our Git object
+		// we've been given the git dir directly. We'll verify this dir when initializing our GitCommand object
 		return false, nil
 	}
 

pkg/app/app_test.go

@@ -36,7 +36,6 @@ func TestIsGitVersionValid(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.versionStr, func(t *testing.T) {
 			result := isGitVersionValid(s.versionStr)
 			assert.Equal(t, result, s.expectedResult)

pkg/app/logging.go

@@ -4,11 +4,10 @@
 package app
 
 import (
-	"log"
-	"os"
-
 	"github.com/aybabtme/humanlog"
 	"github.com/jesseduffield/lazygit/pkg/secureexec"
+	"log"
+	"os"
 )
 
 func TailLogsForPlatform(logFilePath string, opts *humanlog.HandlerOptions) {

pkg/cheatsheet/check.go

@@ -1,79 +0,0 @@
-package cheatsheet
-
-import (
-	"fmt"
-	"io/fs"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"regexp"
-
-	"github.com/pmezard/go-difflib/difflib"
-)
-
-func Check() {
-	dir := GetDir()
-	tmpDir := filepath.Join(os.TempDir(), "lazygit_cheatsheet")
-	err := os.RemoveAll(tmpDir)
-	if err != nil {
-		log.Fatalf("Error occured while checking if cheatsheets are up to date: %v", err)
-	}
-	err = os.Mkdir(tmpDir, 0700)
-	if err != nil {
-		log.Fatalf("Error occured while checking if cheatsheets are up to date: %v", err)
-	}
-
-	generateAtDir(tmpDir)
-	defer os.RemoveAll(tmpDir)
-
-	actualContent := obtainContent(dir)
-	expectedContent := obtainContent(tmpDir)
-
-	if expectedContent == "" {
-		log.Fatal("empty expected content")
-	}
-
-	if actualContent != expectedContent {
-		err := difflib.WriteUnifiedDiff(os.Stdout, difflib.UnifiedDiff{
-			A:        difflib.SplitLines(expectedContent),
-			B:        difflib.SplitLines(actualContent),
-			FromFile: "Expected",
-			FromDate: "",
-			ToFile:   "Actual",
-			ToDate:   "",
-			Context:  1,
-		})
-		if err != nil {
-			log.Fatalf("Error occured while checking if cheatsheets are up to date: %v", err)
-		}
-		fmt.Printf("\nCheatsheets are out of date. Please run `%s` at the project root and commit the changes\n", CommandToRun())
-		os.Exit(1)
-	}
-
-	fmt.Println("\nCheatsheets are up to date")
-}
-
-func obtainContent(dir string) string {
-	re := regexp.MustCompile(`Keybindings_\w+\.md$`)
-
-	content := ""
-	err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
-		if re.MatchString(path) {
-			bytes, err := ioutil.ReadFile(path)
-			if err != nil {
-				log.Fatalf("Error occured while checking if cheatsheets are up to date: %v", err)
-			}
-			content += fmt.Sprintf("\n%s\n\n", filepath.Base(path))
-			content += string(bytes)
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		log.Fatalf("Error occured while checking if cheatsheets are up to date: %v", err)
-	}
-
-	return content
-}

pkg/commands/branches.go

@@ -0,0 +1,173 @@
+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,4 +1,4 @@
-package git_commands
+package commands
 
 import (
 	"testing"
@@ -8,7 +8,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestBranchGetCommitDifferences(t *testing.T) {
+func TestGitCommandGetCommitDifferences(t *testing.T) {
 	type scenario struct {
 		testName          string
 		runner            *oscommands.FakeCmdObjRunner
@@ -40,10 +40,9 @@ func TestBranchGetCommitDifferences(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			instance := buildBranchCommands(commonDeps{runner: s.runner})
-			pushables, pullables := instance.GetCommitDifferences("HEAD", "@{u}")
+			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()
@@ -51,16 +50,16 @@ func TestBranchGetCommitDifferences(t *testing.T) {
 	}
 }
 
-func TestBranchNewBranch(t *testing.T) {
+func TestGitCommandNewBranch(t *testing.T) {
 	runner := oscommands.NewFakeRunner(t).
 		Expect(`git checkout -b "test" "master"`, "", nil)
-	instance := buildBranchCommands(commonDeps{runner: runner})
+	gitCmd := NewDummyGitCommandWithRunner(runner)
 
-	assert.NoError(t, instance.New("test", "master"))
+	assert.NoError(t, gitCmd.NewBranch("test", "master"))
 	runner.CheckForMissingCalls()
 }
 
-func TestBranchDeleteBranch(t *testing.T) {
+func TestGitCommandDeleteBranch(t *testing.T) {
 	type scenario struct {
 		testName string
 		force    bool
@@ -88,26 +87,25 @@ func TestBranchDeleteBranch(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			instance := buildBranchCommands(commonDeps{runner: s.runner})
+			gitCmd := NewDummyGitCommandWithRunner(s.runner)
 
-			s.test(instance.Delete("test", s.force))
+			s.test(gitCmd.DeleteBranch("test", s.force))
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }
 
-func TestBranchMerge(t *testing.T) {
+func TestGitCommandMerge(t *testing.T) {
 	runner := oscommands.NewFakeRunner(t).
 		Expect(`git merge --no-edit "test"`, "", nil)
-	instance := buildBranchCommands(commonDeps{runner: runner})
+	gitCmd := NewDummyGitCommandWithRunner(runner)
 
-	assert.NoError(t, instance.Merge("test", MergeOpts{}))
+	assert.NoError(t, gitCmd.Merge("test", MergeOpts{}))
 	runner.CheckForMissingCalls()
 }
 
-func TestBranchCheckout(t *testing.T) {
+func TestGitCommandCheckout(t *testing.T) {
 	type scenario struct {
 		testName string
 		runner   *oscommands.FakeCmdObjRunner
@@ -135,34 +133,34 @@ func TestBranchCheckout(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			instance := buildBranchCommands(commonDeps{runner: s.runner})
-			s.test(instance.Checkout("test", CheckoutOptions{Force: s.force}))
+			gitCmd := NewDummyGitCommandWithRunner(s.runner)
+			s.test(gitCmd.Checkout("test", CheckoutOptions{Force: s.force}))
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }
 
-func TestBranchGetBranchGraph(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).ExpectGitArgs([]string{
-		"log", "--graph", "--color=always", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium", "test", "--",
+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)
-	instance := buildBranchCommands(commonDeps{runner: runner})
-	_, err := instance.GetGraph("test")
+	gitCmd := NewDummyGitCommandWithRunner(runner)
+	_, err := gitCmd.GetBranchGraph("test")
 	assert.NoError(t, err)
 }
 
-func TestBranchGetAllBranchGraph(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).ExpectGitArgs([]string{
-		"log", "--graph", "--all", "--color=always", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium",
+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)
-	instance := buildBranchCommands(commonDeps{runner: runner})
-	err := instance.AllBranchesLogCmdObj().Run()
+	gitCmd := NewDummyGitCommandWithRunner(runner)
+	cmdStr := gitCmd.UserConfig.Git.AllBranchesLogCmd
+	_, err := gitCmd.Cmd.New(cmdStr).RunWithOutput()
 	assert.NoError(t, err)
 }
 
-func TestBranchCurrentBranchName(t *testing.T) {
+func TestGitCommandCurrentBranchName(t *testing.T) {
 	type scenario struct {
 		testName string
 		runner   *oscommands.FakeCmdObjRunner
@@ -215,11 +213,38 @@ func TestBranchCurrentBranchName(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			instance := buildBranchCommands(commonDeps{runner: s.runner})
-			s.test(instance.CurrentBranchName())
+			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/commits.go

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

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

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

@@ -0,0 +1,34 @@
+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"
+)
+
+// NewDummyGitCommand creates a new dummy GitCommand for testing
+func NewDummyGitCommand() *GitCommand {
+	return NewDummyGitCommandWithOSCommand(oscommands.NewDummyOSCommand())
+}
+
+// NewDummyGitCommandWithOSCommand creates a new dummy GitCommand for testing
+func NewDummyGitCommandWithOSCommand(osCommand *oscommands.OSCommand) *GitCommand {
+	return &GitCommand{
+		Common:       utils.NewDummyCommon(),
+		OSCommand:    osCommand,
+		GitConfig:    git_config.NewFakeGitConfig(map[string]string{}),
+		GetCmdWriter: func() io.Writer { return ioutil.Discard },
+	}
+}
+
+func NewDummyGitCommandWithRunner(runner oscommands.ICmdObjRunner) *GitCommand {
+	builder := oscommands.NewDummyCmdObjBuilder(runner)
+	gitCommand := NewDummyGitCommand()
+	gitCommand.Cmd = builder
+	gitCommand.OSCommand.Cmd = builder
+
+	return gitCommand
+}

pkg/commands/files.go

@@ -0,0 +1,372 @@
+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,4 +1,4 @@
-package git_commands
+package commands
 
 import (
 	"fmt"
@@ -7,33 +7,22 @@ import (
 	"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/jesseduffield/lazygit/pkg/config"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestWorkingTreeStageFile(t *testing.T) {
+func TestGitCommandStageFile(t *testing.T) {
 	runner := oscommands.NewFakeRunner(t).
-		Expect(`git add -- "test.txt"`, "", nil)
+		ExpectArgs([]string{"git", "add", "--", "test.txt"}, "", nil)
+	gitCmd := NewDummyGitCommandWithRunner(runner)
 
-	instance := buildWorkingTreeCommands(commonDeps{runner: runner})
-
-	assert.NoError(t, instance.StageFile("test.txt"))
+	assert.NoError(t, gitCmd.StageFile("test.txt"))
 	runner.CheckForMissingCalls()
 }
 
-func TestWorkingTreeStageFiles(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		Expect(`git add -- "test.txt" "test2.txt"`, "", nil)
-
-	instance := buildWorkingTreeCommands(commonDeps{runner: runner})
-
-	assert.NoError(t, instance.StageFiles([]string{"test.txt", "test2.txt"}))
-	runner.CheckForMissingCalls()
-}
-
-func TestWorkingTreeUnstageFile(t *testing.T) {
+func TestGitCommandUnstageFile(t *testing.T) {
 	type scenario struct {
 		testName string
 		reset    bool
@@ -46,7 +35,7 @@ func TestWorkingTreeUnstageFile(t *testing.T) {
 			testName: "Remove an untracked file from staging",
 			reset:    false,
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git rm --cached --force -- "test.txt"`, "", nil),
+				ExpectArgs([]string{"git", "rm", "--cached", "--force", "--", "test.txt"}, "", nil),
 			test: func(err error) {
 				assert.NoError(t, err)
 			},
@@ -55,7 +44,7 @@ func TestWorkingTreeUnstageFile(t *testing.T) {
 			testName: "Remove a tracked file from staging",
 			reset:    true,
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git reset HEAD -- "test.txt"`, "", nil),
+				ExpectArgs([]string{"git", "reset", "HEAD", "--", "test.txt"}, "", nil),
 			test: func(err error) {
 				assert.NoError(t, err)
 			},
@@ -63,10 +52,9 @@ func TestWorkingTreeUnstageFile(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
-			s.test(instance.UnStageFile([]string{"test.txt"}, s.reset))
+			gitCmd := NewDummyGitCommandWithRunner(s.runner)
+			s.test(gitCmd.UnStageFile([]string{"test.txt"}, s.reset))
 		})
 	}
 }
@@ -74,7 +62,7 @@ func TestWorkingTreeUnstageFile(t *testing.T) {
 // 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 TestWorkingTreeDiscardAllFileChanges(t *testing.T) {
+func TestGitCommandDiscardAllFileChanges(t *testing.T) {
 	type scenario struct {
 		testName      string
 		file          *models.File
@@ -92,7 +80,7 @@ func TestWorkingTreeDiscardAllFileChanges(t *testing.T) {
 			},
 			removeFile: func(string) error { return nil },
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git reset -- "test"`, "", errors.New("error")),
+				ExpectArgs([]string{"git", "reset", "--", "test"}, "", errors.New("error")),
 			expectedError: "error",
 		},
 		{
@@ -117,7 +105,7 @@ func TestWorkingTreeDiscardAllFileChanges(t *testing.T) {
 			},
 			removeFile: func(string) error { return nil },
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git checkout -- "test"`, "", errors.New("error")),
+				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", errors.New("error")),
 			expectedError: "error",
 		},
 		{
@@ -129,7 +117,7 @@ func TestWorkingTreeDiscardAllFileChanges(t *testing.T) {
 			},
 			removeFile: func(string) error { return nil },
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git checkout -- "test"`, "", nil),
+				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", nil),
 			expectedError: "",
 		},
 		{
@@ -141,8 +129,8 @@ func TestWorkingTreeDiscardAllFileChanges(t *testing.T) {
 			},
 			removeFile: func(string) error { return nil },
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git reset -- "test"`, "", nil).
-				Expect(`git checkout -- "test"`, "", nil),
+				ExpectArgs([]string{"git", "reset", "--", "test"}, "", nil).
+				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", nil),
 			expectedError: "",
 		},
 		{
@@ -154,8 +142,8 @@ func TestWorkingTreeDiscardAllFileChanges(t *testing.T) {
 			},
 			removeFile: func(string) error { return nil },
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git reset -- "test"`, "", nil).
-				Expect(`git checkout -- "test"`, "", nil),
+				ExpectArgs([]string{"git", "reset", "--", "test"}, "", nil).
+				ExpectArgs([]string{"git", "checkout", "--", "test"}, "", nil),
 			expectedError: "",
 		},
 		{
@@ -171,7 +159,7 @@ func TestWorkingTreeDiscardAllFileChanges(t *testing.T) {
 				return nil
 			},
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git reset -- "test"`, "", nil),
+				ExpectArgs([]string{"git", "reset", "--", "test"}, "", nil),
 			expectedError: "",
 		},
 		{
@@ -192,10 +180,10 @@ func TestWorkingTreeDiscardAllFileChanges(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner, removeFile: s.removeFile})
-			err := instance.DiscardAllFileChanges(s.file)
+			gitCmd := NewDummyGitCommandWithRunner(s.runner)
+			gitCmd.OSCommand.SetRemoveFile(s.removeFile)
+			err := gitCmd.DiscardAllFileChanges(s.file)
 
 			if s.expectedError == "" {
 				assert.Nil(t, err)
@@ -207,7 +195,7 @@ func TestWorkingTreeDiscardAllFileChanges(t *testing.T) {
 	}
 }
 
-func TestWorkingTreeDiff(t *testing.T) {
+func TestGitCommandDiff(t *testing.T) {
 	type scenario struct {
 		testName         string
 		file             *models.File
@@ -233,7 +221,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 			ignoreWhitespace: false,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git diff --submodule --no-ext-diff --unified=3 --color=always -- "test.txt"`, expectedResult, nil),
+				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=always", "--", "test.txt"}, expectedResult, nil),
 		},
 		{
 			testName: "cached",
@@ -247,7 +235,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 			ignoreWhitespace: false,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git diff --submodule --no-ext-diff --unified=3 --color=always --cached -- "test.txt"`, expectedResult, nil),
+				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=3", "--color=always", "--cached", "--", "test.txt"}, expectedResult, nil),
 		},
 		{
 			testName: "plain",
@@ -261,7 +249,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 			ignoreWhitespace: false,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git diff --submodule --no-ext-diff --unified=3 --color=never -- "test.txt"`, expectedResult, nil),
+				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",
@@ -275,7 +263,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 			ignoreWhitespace: false,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git diff --submodule --no-ext-diff --unified=3 --color=always --no-index -- /dev/null "test.txt"`, expectedResult, nil),
+				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)",
@@ -289,7 +277,7 @@ func TestWorkingTreeDiff(t *testing.T) {
 			ignoreWhitespace: true,
 			contextSize:      3,
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git diff --submodule --no-ext-diff --unified=3 --color=always --ignore-all-space -- "test.txt"`, expectedResult, nil),
+				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",
@@ -303,25 +291,22 @@ func TestWorkingTreeDiff(t *testing.T) {
 			ignoreWhitespace: false,
 			contextSize:      17,
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git diff --submodule --no-ext-diff --unified=17 --color=always -- "test.txt"`, expectedResult, nil),
+				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=17", "--color=always", "--", "test.txt"}, expectedResult, nil),
 		},
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			userConfig := config.GetDefaultConfig()
-			userConfig.Git.DiffContextSize = s.contextSize
-
-			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner, userConfig: userConfig})
-			result := instance.WorktreeFileDiff(s.file, s.plain, s.cached, s.ignoreWhitespace)
+			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 TestWorkingTreeShowFileDiff(t *testing.T) {
+func TestGitCommandShowFileDiff(t *testing.T) {
 	type scenario struct {
 		testName    string
 		from        string
@@ -343,7 +328,7 @@ func TestWorkingTreeShowFileDiff(t *testing.T) {
 			plain:       false,
 			contextSize: 3,
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git diff --submodule --no-ext-diff --unified=3 --no-renames --color=always 1234567890 0987654321 -- "test.txt"`, expectedResult, nil),
+				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",
@@ -353,19 +338,15 @@ func TestWorkingTreeShowFileDiff(t *testing.T) {
 			plain:       false,
 			contextSize: 123,
 			runner: oscommands.NewFakeRunner(t).
-				Expect(`git diff --submodule --no-ext-diff --unified=123 --no-renames --color=always 1234567890 0987654321 -- "test.txt"`, expectedResult, nil),
+				ExpectArgs([]string{"git", "diff", "--submodule", "--no-ext-diff", "--unified=123", "--no-renames", "--color=always", "1234567890", "0987654321", "--", "test.txt"}, expectedResult, nil),
 		},
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			userConfig := config.GetDefaultConfig()
-			userConfig.Git.DiffContextSize = s.contextSize
-
-			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner, userConfig: userConfig})
-
-			result, err := instance.ShowFileDiff(s.from, s.to, s.reverse, "test.txt", s.plain)
+			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()
@@ -373,7 +354,7 @@ func TestWorkingTreeShowFileDiff(t *testing.T) {
 	}
 }
 
-func TestWorkingTreeCheckoutFile(t *testing.T) {
+func TestGitCommandCheckoutFile(t *testing.T) {
 	type scenario struct {
 		testName  string
 		commitSha string
@@ -406,17 +387,15 @@ func TestWorkingTreeCheckoutFile(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
-
-			s.test(instance.CheckoutFile(s.commitSha, s.fileName))
+			gitCmd := NewDummyGitCommandWithRunner(s.runner)
+			s.test(gitCmd.CheckoutFile(s.commitSha, s.fileName))
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }
 
-func TestWorkingTreeApplyPatch(t *testing.T) {
+func TestGitCommandApplyPatch(t *testing.T) {
 	type scenario struct {
 		testName string
 		runner   *oscommands.FakeCmdObjRunner
@@ -426,9 +405,8 @@ func TestWorkingTreeApplyPatch(t *testing.T) {
 	expectFn := func(regexStr string, errToReturn error) func(cmdObj oscommands.ICmdObj) (string, error) {
 		return func(cmdObj oscommands.ICmdObj) (string, error) {
 			re := regexp.MustCompile(regexStr)
-			cmdStr := cmdObj.ToString()
-			matches := re.FindStringSubmatch(cmdStr)
-			assert.Equal(t, 2, len(matches), fmt.Sprintf("unexpected command: %s", cmdStr))
+			matches := re.FindStringSubmatch(cmdObj.ToString())
+			assert.Equal(t, 2, len(matches))
 
 			filename := matches[1]
 
@@ -461,16 +439,82 @@ func TestWorkingTreeApplyPatch(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
-			s.test(instance.ApplyPatch("test", "cached"))
+			gitCmd := NewDummyGitCommandWithRunner(s.runner)
+			s.test(gitCmd.ApplyPatch("test", "cached"))
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }
 
-func TestWorkingTreeDiscardUnstagedFileChanges(t *testing.T) {
+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
@@ -491,16 +535,15 @@ func TestWorkingTreeDiscardUnstagedFileChanges(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
-			s.test(instance.DiscardUnstagedFileChanges(s.file))
+			gitCmd := NewDummyGitCommandWithRunner(s.runner)
+			s.test(gitCmd.DiscardUnstagedFileChanges(s.file))
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }
 
-func TestWorkingTreeDiscardAnyUnstagedFileChanges(t *testing.T) {
+func TestGitCommandDiscardAnyUnstagedFileChanges(t *testing.T) {
 	type scenario struct {
 		testName string
 		runner   *oscommands.FakeCmdObjRunner
@@ -519,16 +562,15 @@ func TestWorkingTreeDiscardAnyUnstagedFileChanges(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
-			s.test(instance.DiscardAnyUnstagedFileChanges())
+			gitCmd := NewDummyGitCommandWithRunner(s.runner)
+			s.test(gitCmd.DiscardAnyUnstagedFileChanges())
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }
 
-func TestWorkingTreeRemoveUntrackedFiles(t *testing.T) {
+func TestGitCommandRemoveUntrackedFiles(t *testing.T) {
 	type scenario struct {
 		testName string
 		runner   *oscommands.FakeCmdObjRunner
@@ -547,40 +589,156 @@ func TestWorkingTreeRemoveUntrackedFiles(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
-			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
-			s.test(instance.RemoveUntrackedFiles())
+			gitCmd := NewDummyGitCommandWithRunner(s.runner)
+			s.test(gitCmd.RemoveUntrackedFiles())
 			s.runner.CheckForMissingCalls()
 		})
 	}
 }
 
-func TestWorkingTreeResetHard(t *testing.T) {
+func TestEditFileCmdStr(t *testing.T) {
 	type scenario struct {
-		testName string
-		ref      string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
+		filename                  string
+		configEditCommand         string
+		configEditCommandTemplate string
+		runner                    *oscommands.FakeCmdObjRunner
+		getenv                    func(string) string
+		gitConfigMockResponses    map[string]string
+		test                      func(string, error)
 	}
 
 	scenarios := []scenario{
 		{
-			"valid case",
-			"HEAD",
-			oscommands.NewFakeRunner(t).
-				Expect(`git reset --hard "HEAD"`, "", nil),
-			func(err error) {
+			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 {
-		s := s
-		t.Run(s.testName, func(t *testing.T) {
-			instance := buildWorkingTreeCommands(commonDeps{runner: s.runner})
-			s.test(instance.ResetHard(s.ref))
-		})
+		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.go

@@ -1,6 +1,7 @@
 package commands
 
 import (
+	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -9,7 +10,6 @@ import (
 	"github.com/go-errors/errors"
 
 	gogit "github.com/jesseduffield/go-git/v5"
-	"github.com/jesseduffield/lazygit/pkg/commands/git_commands"
 	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
 	"github.com/jesseduffield/lazygit/pkg/commands/loaders"
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
@@ -19,50 +19,63 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
-// GitCommand is our main git interface
-type GitCommand struct {
-	Branch      *git_commands.BranchCommands
-	Commit      *git_commands.CommitCommands
-	Config      *git_commands.ConfigCommands
-	Custom      *git_commands.CustomCommands
-	File        *git_commands.FileCommands
-	Flow        *git_commands.FlowCommands
-	Patch       *git_commands.PatchCommands
-	Rebase      *git_commands.RebaseCommands
-	Remote      *git_commands.RemoteCommands
-	Stash       *git_commands.StashCommands
-	Status      *git_commands.StatusCommands
-	Submodule   *git_commands.SubmoduleCommands
-	Sync        *git_commands.SyncCommands
-	Tag         *git_commands.TagCommands
-	WorkingTree *git_commands.WorkingTreeCommands
-	Bisect      *git_commands.BisectCommands
-
-	Loaders Loaders
-}
+// this takes something like:
+// * (HEAD detached at 264fc6f5)
+//	remotes
+// and returns '264fc6f5' as the second match
+const CurrentBranchNameRegex = `(?m)^\*.*?([^ ]*?)\)?$`
 
 type Loaders struct {
-	Branches      *loaders.BranchLoader
-	CommitFiles   *loaders.CommitFileLoader
 	Commits       *loaders.CommitLoader
+	Branches      *loaders.BranchLoader
 	Files         *loaders.FileLoader
-	ReflogCommits *loaders.ReflogCommitLoader
+	CommitFiles   *loaders.CommitFileLoader
 	Remotes       *loaders.RemoteLoader
+	ReflogCommits *loaders.ReflogCommitLoader
 	Stash         *loaders.StashLoader
 	Tags          *loaders.TagLoader
 }
 
+// GitCommand is our main git interface
+type GitCommand struct {
+	*common.Common
+	OSCommand            *oscommands.OSCommand
+	Repo                 *gogit.Repository
+	DotGitDir            string
+	onSuccessfulContinue func() error
+	PatchManager         *patch.PatchManager
+	GitConfig            git_config.IGitConfig
+	Loaders              Loaders
+
+	// Push to current determines whether the user has configured to push to the remote branch of the same name as the current or not
+	PushToCurrent bool
+
+	// this is just a view that we write to when running certain commands.
+	// Coincidentally at the moment it's the same view that OnRunCommand logs to
+	// but that need not always be the case.
+	GetCmdWriter func() io.Writer
+
+	Cmd oscommands.ICmdObjBuilder
+
+	Submodules SubmoduleCommands
+}
+
+// NewGitCommand it runs git commands
 func NewGitCommand(
 	cmn *common.Common,
 	osCommand *oscommands.OSCommand,
 	gitConfig git_config.IGitConfig,
 ) (*GitCommand, error) {
+	var repo *gogit.Repository
+
+	pushToCurrent := gitConfig.Get("push.default") == "current"
+
 	if err := navigateToRepoRootDirectory(os.Stat, os.Chdir); err != nil {
 		return nil, err
 	}
 
-	repo, err := setupRepository(gogit.PlainOpen, cmn.Tr.GitconfigParseErr)
-	if err != nil {
+	var err error
+	if repo, err = setupRepository(gogit.PlainOpen, cmn.Tr.GitconfigParseErr); err != nil {
 		return nil, err
 	}
 
@@ -71,79 +84,58 @@ func NewGitCommand(
 		return nil, err
 	}
 
-	return NewGitCommandAux(
-		cmn,
-		osCommand,
-		gitConfig,
-		dotGitDir,
-		repo,
-	), nil
-}
-
-func NewGitCommandAux(
-	cmn *common.Common,
-	osCommand *oscommands.OSCommand,
-	gitConfig git_config.IGitConfig,
-	dotGitDir string,
-	repo *gogit.Repository,
-) *GitCommand {
 	cmd := NewGitCmdObjBuilder(cmn.Log, osCommand.Cmd)
 
-	// here we're doing a bunch of dependency injection for each of our commands structs.
-	// This is admittedly messy, but allows us to test each command struct in isolation,
-	// and allows for better namespacing when compared to having every method living
-	// on the one struct.
-	// common ones are: cmn, osCommand, dotGitDir, configCommands
-	configCommands := git_commands.NewConfigCommands(cmn, gitConfig, repo)
-	gitCommon := git_commands.NewGitCommon(cmn, cmd, osCommand, dotGitDir, repo, configCommands)
-
-	statusCommands := git_commands.NewStatusCommands(gitCommon)
-	fileLoader := loaders.NewFileLoader(cmn, cmd, configCommands)
-	flowCommands := git_commands.NewFlowCommands(gitCommon)
-	remoteCommands := git_commands.NewRemoteCommands(gitCommon)
-	branchCommands := git_commands.NewBranchCommands(gitCommon)
-	syncCommands := git_commands.NewSyncCommands(gitCommon)
-	tagCommands := git_commands.NewTagCommands(gitCommon)
-	commitCommands := git_commands.NewCommitCommands(gitCommon)
-	customCommands := git_commands.NewCustomCommands(gitCommon)
-	fileCommands := git_commands.NewFileCommands(gitCommon)
-	submoduleCommands := git_commands.NewSubmoduleCommands(gitCommon)
-	workingTreeCommands := git_commands.NewWorkingTreeCommands(gitCommon, submoduleCommands, fileLoader)
-	rebaseCommands := git_commands.NewRebaseCommands(gitCommon, commitCommands, workingTreeCommands)
-	stashCommands := git_commands.NewStashCommands(gitCommon, fileLoader, workingTreeCommands)
-	// TODO: have patch manager take workingTreeCommands in its entirety
-	patchManager := patch.NewPatchManager(cmn.Log, workingTreeCommands.ApplyPatch, workingTreeCommands.ShowFileDiff)
-	patchCommands := git_commands.NewPatchCommands(gitCommon, rebaseCommands, commitCommands, statusCommands, stashCommands, patchManager)
-	bisectCommands := git_commands.NewBisectCommands(gitCommon)
-
-	return &GitCommand{
-		Branch:      branchCommands,
-		Commit:      commitCommands,
-		Config:      configCommands,
-		Custom:      customCommands,
-		File:        fileCommands,
-		Flow:        flowCommands,
-		Patch:       patchCommands,
-		Rebase:      rebaseCommands,
-		Remote:      remoteCommands,
-		Stash:       stashCommands,
-		Status:      statusCommands,
-		Submodule:   submoduleCommands,
-		Sync:        syncCommands,
-		Tag:         tagCommands,
-		Bisect:      bisectCommands,
-		WorkingTree: workingTreeCommands,
-		Loaders: Loaders{
-			Branches:      loaders.NewBranchLoader(cmn, branchCommands.GetRawBranches, branchCommands.CurrentBranchName, configCommands),
-			CommitFiles:   loaders.NewCommitFileLoader(cmn, cmd),
-			Commits:       loaders.NewCommitLoader(cmn, cmd, dotGitDir, branchCommands.CurrentBranchName, statusCommands.RebaseMode),
-			Files:         fileLoader,
-			ReflogCommits: loaders.NewReflogCommitLoader(cmn, cmd),
-			Remotes:       loaders.NewRemoteLoader(cmn, cmd, repo.Remotes),
-			Stash:         loaders.NewStashLoader(cmn, cmd),
-			Tags:          loaders.NewTagLoader(cmn, cmd),
-		},
+	gitCommand := &GitCommand{
+		Common:        cmn,
+		OSCommand:     osCommand,
+		Repo:          repo,
+		DotGitDir:     dotGitDir,
+		PushToCurrent: pushToCurrent,
+		GitConfig:     gitConfig,
+		GetCmdWriter:  func() io.Writer { return ioutil.Discard },
+		Cmd:           cmd,
 	}
+
+	gitCommand.Loaders = Loaders{
+		Commits:       loaders.NewCommitLoader(cmn, gitCommand),
+		Branches:      loaders.NewBranchLoader(cmn, gitCommand),
+		Files:         loaders.NewFileLoader(cmn, cmd, gitConfig),
+		CommitFiles:   loaders.NewCommitFileLoader(cmn, cmd),
+		Remotes:       loaders.NewRemoteLoader(cmn, cmd, gitCommand.Repo.Remotes),
+		ReflogCommits: loaders.NewReflogCommitLoader(cmn, cmd),
+		Stash:         loaders.NewStashLoader(cmn, cmd),
+		Tags:          loaders.NewTagLoader(cmn, cmd),
+	}
+
+	gitCommand.Submodules = NewSubmoduleCommands(cmn, cmd, dotGitDir)
+
+	gitCommand.PatchManager = patch.NewPatchManager(gitCommand.Log, gitCommand.ApplyPatch, gitCommand.ShowFileDiff)
+
+	return gitCommand, nil
+}
+
+func (c *GitCommand) WithSpan(span string) *GitCommand {
+	// 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
+	}
+
+	newGitCommand := &GitCommand{}
+	*newGitCommand = *c
+	newGitCommand.OSCommand = c.OSCommand.WithSpan(span)
+
+	newGitCommand.Cmd = NewGitCmdObjBuilder(c.Log, newGitCommand.OSCommand.Cmd)
+
+	// NOTE: unlike the other things here which create shallow clones, this will
+	// actually update the PatchManager on the original struct to have the new span.
+	// This means each time we call ApplyPatch in PatchManager, we need to ensure
+	// we've called .WithSpan() ahead of time with the new span value
+	newGitCommand.PatchManager.ApplyPatch = newGitCommand.ApplyPatch
+
+	return newGitCommand
 }
 
 func navigateToRepoRootDirectory(stat func(string) (os.FileInfo, error), chdir func(string) error) error {
@@ -257,5 +249,13 @@ func findDotGitDir(stat func(string) (os.FileInfo, error), readFile func(filenam
 }
 
 func VerifyInGitRepo(osCommand *oscommands.OSCommand) error {
-	return osCommand.Cmd.New("git rev-parse --git-dir").DontLog().Run()
+	return osCommand.Cmd.New("git rev-parse --git-dir").Run()
+}
+
+func (c *GitCommand) GetDotGitDir() string {
+	return c.DotGitDir
+}
+
+func (c *GitCommand) GetCmd() oscommands.ICmdObjBuilder {
+	return c.Cmd
 }

pkg/commands/git_cmd_obj_runner.go

@@ -1,6 +1,9 @@
 package commands
 
 import (
+	"strings"
+	"time"
+
 	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
 	"github.com/sirupsen/logrus"
 )
@@ -18,7 +21,27 @@ func (self *gitCmdObjRunner) Run(cmdObj oscommands.ICmdObj) error {
 }
 
 func (self *gitCmdObjRunner) RunWithOutput(cmdObj oscommands.ICmdObj) (string, error) {
-	return self.innerRunner.RunWithOutput(cmdObj)
+	// 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 {

pkg/commands/git_commands/bisect.go

@@ -1,175 +0,0 @@
-package git_commands
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-type BisectCommands struct {
-	*GitCommon
-}
-
-func NewBisectCommands(gitCommon *GitCommon) *BisectCommands {
-	return &BisectCommands{
-		GitCommon: gitCommon,
-	}
-}
-
-// This command is pretty cheap to run so we're not storing the result anywhere.
-// But if it becomes problematic we can chang that.
-func (self *BisectCommands) GetInfo() *BisectInfo {
-	var err error
-	info := &BisectInfo{started: false, log: self.Log, newTerm: "bad", oldTerm: "good"}
-	// we return nil if we're not in a git bisect session.
-	// we know we're in a session by the presence of a .git/BISECT_START file
-
-	bisectStartPath := filepath.Join(self.dotGitDir, "BISECT_START")
-	exists, err := self.os.FileExists(bisectStartPath)
-	if err != nil {
-		self.Log.Infof("error getting git bisect info: %s", err.Error())
-		return info
-	}
-
-	if !exists {
-		return info
-	}
-
-	startContent, err := os.ReadFile(bisectStartPath)
-	if err != nil {
-		self.Log.Infof("error getting git bisect info: %s", err.Error())
-		return info
-	}
-
-	info.started = true
-	info.start = strings.TrimSpace(string(startContent))
-
-	termsContent, err := os.ReadFile(filepath.Join(self.dotGitDir, "BISECT_TERMS"))
-	if err != nil {
-		// old git versions won't have this file so we default to bad/good
-	} else {
-		splitContent := strings.Split(string(termsContent), "\n")
-		info.newTerm = splitContent[0]
-		info.oldTerm = splitContent[1]
-	}
-
-	bisectRefsDir := filepath.Join(self.dotGitDir, "refs", "bisect")
-	files, err := os.ReadDir(bisectRefsDir)
-	if err != nil {
-		self.Log.Infof("error getting git bisect info: %s", err.Error())
-		return info
-	}
-
-	info.statusMap = make(map[string]BisectStatus)
-	for _, file := range files {
-		status := BisectStatusSkipped
-		name := file.Name()
-		path := filepath.Join(bisectRefsDir, name)
-
-		fileContent, err := os.ReadFile(path)
-		if err != nil {
-			self.Log.Infof("error getting git bisect info: %s", err.Error())
-			return info
-		}
-
-		sha := strings.TrimSpace(string(fileContent))
-
-		if name == info.newTerm {
-			status = BisectStatusNew
-		} else if strings.HasPrefix(name, info.oldTerm+"-") {
-			status = BisectStatusOld
-		} else if strings.HasPrefix(name, "skipped-") {
-			status = BisectStatusSkipped
-		}
-
-		info.statusMap[sha] = status
-	}
-
-	currentContent, err := os.ReadFile(filepath.Join(self.dotGitDir, "BISECT_EXPECTED_REV"))
-	if err != nil {
-		self.Log.Infof("error getting git bisect info: %s", err.Error())
-		return info
-	}
-	currentSha := strings.TrimSpace(string(currentContent))
-	info.current = currentSha
-
-	return info
-}
-
-func (self *BisectCommands) Reset() error {
-	return self.cmd.New("git bisect reset").StreamOutput().Run()
-}
-
-func (self *BisectCommands) Mark(ref string, term string) error {
-	return self.cmd.New(
-		fmt.Sprintf("git bisect %s %s", term, ref),
-	).
-		IgnoreEmptyError().
-		StreamOutput().
-		Run()
-}
-
-func (self *BisectCommands) Skip(ref string) error {
-	return self.Mark(ref, "skip")
-}
-
-func (self *BisectCommands) Start() error {
-	return self.cmd.New("git bisect start").StreamOutput().Run()
-}
-
-// tells us whether we've found our problem commit(s). We return a string slice of
-// commit sha's if we're done, and that slice may have more that one item if
-// skipped commits are involved.
-func (self *BisectCommands) IsDone() (bool, []string, error) {
-	info := self.GetInfo()
-	if !info.Bisecting() {
-		return false, nil, nil
-	}
-
-	newSha := info.GetNewSha()
-	if newSha == "" {
-		return false, nil, nil
-	}
-
-	// if we start from the new commit and reach the a good commit without
-	// coming across any unprocessed commits, then we're done
-	done := false
-	candidates := []string{}
-
-	err := self.cmd.New(fmt.Sprintf("git rev-list %s", newSha)).RunAndProcessLines(func(line string) (bool, error) {
-		sha := strings.TrimSpace(line)
-
-		if status, ok := info.statusMap[sha]; ok {
-			switch status {
-			case BisectStatusSkipped, BisectStatusNew:
-				candidates = append(candidates, sha)
-				return false, nil
-			case BisectStatusOld:
-				done = true
-				return true, nil
-			}
-		} else {
-			return true, nil
-		}
-
-		// should never land here
-		return true, nil
-	})
-	if err != nil {
-		return false, nil, err
-	}
-
-	return done, candidates, nil
-}
-
-// tells us whether the 'start' ref that we'll be sent back to after we're done
-// bisecting is actually a descendant of our current bisect commit. If it's not, we need to
-// render the commits from the bad commit.
-func (self *BisectCommands) ReachableFromStart(bisectInfo *BisectInfo) bool {
-	err := self.cmd.New(
-		fmt.Sprintf("git merge-base --is-ancestor %s %s", bisectInfo.GetNewSha(), bisectInfo.GetStartSha()),
-	).DontLog().Run()
-
-	return err == nil
-}

pkg/commands/git_commands/bisect_info.go

@@ -1,103 +0,0 @@
-package git_commands
-
-import "github.com/sirupsen/logrus"
-
-// although the typical terms in a git bisect are 'bad' and 'good', they're more
-// generally known as 'new' and 'old'. Semi-recently git allowed the user to define
-// their own terms e.g. when you want to used 'fixed', 'unfixed' in the event
-// that you're looking for a commit that fixed a bug.
-
-// Git bisect only keeps track of a single 'bad' commit. Once you pick a commit
-// that's older than the current bad one, it forgets about the previous one. On
-// the other hand, it does keep track of all the good and skipped commits.
-
-type BisectInfo struct {
-	log *logrus.Entry
-
-	// tells us whether all our git bisect files are there meaning we're in bisect mode.
-	// Doesn't necessarily mean that we've actually picked a good/bad commit yet.
-	started bool
-
-	// this is the ref you started the commit from
-	start string // this will always be defined
-
-	// these will be defined if we've started
-	newTerm string // 'bad' by default
-	oldTerm string // 'good' by default
-
-	// map of commit sha's to their status
-	statusMap map[string]BisectStatus
-
-	// the sha of the commit that's under test
-	current string
-}
-
-type BisectStatus int
-
-const (
-	BisectStatusOld BisectStatus = iota
-	BisectStatusNew
-	BisectStatusSkipped
-)
-
-// null object pattern
-func NewNullBisectInfo() *BisectInfo {
-	return &BisectInfo{started: false}
-}
-
-func (self *BisectInfo) GetNewSha() string {
-	for sha, status := range self.statusMap {
-		if status == BisectStatusNew {
-			return sha
-		}
-	}
-
-	return ""
-}
-
-func (self *BisectInfo) GetCurrentSha() string {
-	return self.current
-}
-
-func (self *BisectInfo) GetStartSha() string {
-	return self.start
-}
-
-func (self *BisectInfo) Status(commitSha string) (BisectStatus, bool) {
-	status, ok := self.statusMap[commitSha]
-	return status, ok
-}
-
-func (self *BisectInfo) NewTerm() string {
-	return self.newTerm
-}
-
-func (self *BisectInfo) OldTerm() string {
-	return self.oldTerm
-}
-
-// this is for when we have called `git bisect start`. It does not
-// mean that we have actually started narrowing things down or selecting good/bad commits
-func (self *BisectInfo) Started() bool {
-	return self.started
-}
-
-// this is where we have both a good and bad revision and we're actually
-// starting to narrow things down
-func (self *BisectInfo) Bisecting() bool {
-	if !self.Started() {
-		return false
-	}
-
-	if self.GetNewSha() == "" {
-		return false
-	}
-
-	for _, status := range self.statusMap {
-		if status == BisectStatusOld {
-			return true
-		}
-	}
-
-	return false
-}

pkg/commands/git_commands/branch.go

@@ -1,168 +0,0 @@
-package git_commands
-
-import (
-	"fmt"
-	"regexp"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-// this takes something like:
-// * (HEAD detached at 264fc6f5)
-//	remotes
-// and returns '264fc6f5' as the second match
-const CurrentBranchNameRegex = `(?m)^\*.*?([^ ]*?)\)?$`
-
-type BranchCommands struct {
-	*GitCommon
-}
-
-func NewBranchCommands(gitCommon *GitCommon) *BranchCommands {
-	return &BranchCommands{
-		GitCommon: gitCommon,
-	}
-}
-
-// New creates a new branch
-func (self *BranchCommands) New(name string, base string) error {
-	return self.cmd.New(fmt.Sprintf("git checkout -b %s %s", self.cmd.Quote(name), self.cmd.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 (self *BranchCommands) CurrentBranchName() (string, string, error) {
-	branchName, err := self.cmd.New("git symbolic-ref --short HEAD").DontLog().RunWithOutput()
-	if err == nil && branchName != "HEAD\n" {
-		trimmedBranchName := strings.TrimSpace(branchName)
-		return trimmedBranchName, trimmedBranchName, nil
-	}
-	output, err := self.cmd.New("git branch --contains").DontLog().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
-}
-
-// Delete delete branch
-func (self *BranchCommands) Delete(branch string, force bool) error {
-	command := "git branch -d"
-
-	if force {
-		command = "git branch -D"
-	}
-
-	return self.cmd.New(fmt.Sprintf("%s %s", command, self.cmd.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 (self *BranchCommands) Checkout(branch string, options CheckoutOptions) error {
-	forceArg := ""
-	if options.Force {
-		forceArg = " --force"
-	}
-
-	return self.cmd.New(fmt.Sprintf("git checkout%s %s", forceArg, self.cmd.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()
-}
-
-// GetGraph 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 (self *BranchCommands) GetGraph(branchName string) (string, error) {
-	return self.GetGraphCmdObj(branchName).DontLog().RunWithOutput()
-}
-
-func (self *BranchCommands) GetGraphCmdObj(branchName string) oscommands.ICmdObj {
-	branchLogCmdTemplate := self.UserConfig.Git.BranchLogCmd
-	templateValues := map[string]string{
-		"branchName": self.cmd.Quote(branchName),
-	}
-	return self.cmd.New(utils.ResolvePlaceholderString(branchLogCmdTemplate, templateValues)).DontLog()
-}
-
-func (self *BranchCommands) SetCurrentBranchUpstream(remoteName string, remoteBranchName string) error {
-	return self.cmd.New(fmt.Sprintf("git branch --set-upstream-to=%s/%s", self.cmd.Quote(remoteName), self.cmd.Quote(remoteBranchName))).Run()
-}
-
-func (self *BranchCommands) SetUpstream(remoteName string, remoteBranchName string, branchName string) error {
-	return self.cmd.New(fmt.Sprintf("git branch --set-upstream-to=%s/%s %s", self.cmd.Quote(remoteName), self.cmd.Quote(remoteBranchName), self.cmd.Quote(branchName))).Run()
-}
-
-func (self *BranchCommands) GetCurrentBranchUpstreamDifferenceCount() (string, string) {
-	return self.GetCommitDifferences("HEAD", "HEAD@{u}")
-}
-
-func (self *BranchCommands) GetUpstreamDifferenceCount(branchName string) (string, string) {
-	return self.GetCommitDifferences(branchName, branchName+"@{u}")
-}
-
-// GetCommitDifferences checks how many pushables/pullables there are for the
-// current branch
-func (self *BranchCommands) GetCommitDifferences(from, to string) (string, string) {
-	command := "git rev-list %s..%s --count"
-	pushableCount, err := self.cmd.New(fmt.Sprintf(command, to, from)).DontLog().RunWithOutput()
-	if err != nil {
-		return "?", "?"
-	}
-	pullableCount, err := self.cmd.New(fmt.Sprintf(command, from, to)).DontLog().RunWithOutput()
-	if err != nil {
-		return "?", "?"
-	}
-	return strings.TrimSpace(pushableCount), strings.TrimSpace(pullableCount)
-}
-
-func (self *BranchCommands) IsHeadDetached() bool {
-	err := self.cmd.New("git symbolic-ref -q HEAD").DontLog().Run()
-	return err != nil
-}
-
-func (self *BranchCommands) Rename(oldName string, newName string) error {
-	return self.cmd.New(fmt.Sprintf("git branch --move %s %s", self.cmd.Quote(oldName), self.cmd.Quote(newName))).Run()
-}
-
-func (self *BranchCommands) GetRawBranches() (string, error) {
-	return self.cmd.New(`git for-each-ref --sort=-committerdate --format="%(HEAD)|%(refname:short)|%(upstream:short)|%(upstream:track)" refs/heads`).DontLog().RunWithOutput()
-}
-
-type MergeOpts struct {
-	FastForwardOnly bool
-}
-
-func (self *BranchCommands) Merge(branchName string, opts MergeOpts) error {
-	mergeArg := ""
-	if self.UserConfig.Git.Merging.Args != "" {
-		mergeArg = " " + self.UserConfig.Git.Merging.Args
-	}
-
-	command := fmt.Sprintf("git merge --no-edit%s %s", mergeArg, self.cmd.Quote(branchName))
-	if opts.FastForwardOnly {
-		command = fmt.Sprintf("%s --ff-only", command)
-	}
-
-	return self.cmd.New(command).Run()
-}
-
-func (self *BranchCommands) AllBranchesLogCmdObj() oscommands.ICmdObj {
-	return self.cmd.New(self.UserConfig.Git.AllBranchesLogCmd).DontLog()
-}

pkg/commands/git_commands/commit.go

@@ -1,125 +0,0 @@
-package git_commands
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-)
-
-type CommitCommands struct {
-	*GitCommon
-}
-
-func NewCommitCommands(gitCommon *GitCommon) *CommitCommands {
-	return &CommitCommands{
-		GitCommon: gitCommon,
-	}
-}
-
-// RewordLastCommit rewords the topmost commit with the given message
-func (self *CommitCommands) RewordLastCommit(message string) error {
-	return self.cmd.New("git commit --allow-empty --amend --only -m " + self.cmd.Quote(message)).Run()
-}
-
-// ResetToCommit reset to commit
-func (self *CommitCommands) ResetToCommit(sha string, strength string, envVars []string) error {
-	return self.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 (self *CommitCommands) CommitCmdObj(message string) oscommands.ICmdObj {
-	splitMessage := strings.Split(message, "\n")
-	lineArgs := ""
-	for _, line := range splitMessage {
-		lineArgs += fmt.Sprintf(" -m %s", self.cmd.Quote(line))
-	}
-
-	skipHookPrefix := self.UserConfig.Git.SkipHookPrefix
-	noVerifyFlag := ""
-	if skipHookPrefix != "" && strings.HasPrefix(message, skipHookPrefix) {
-		noVerifyFlag = " --no-verify"
-	}
-
-	return self.cmd.New(fmt.Sprintf("git commit%s%s%s", noVerifyFlag, self.signoffFlag(), lineArgs))
-}
-
-// runs git commit without the -m argument meaning it will invoke the user's editor
-func (self *CommitCommands) CommitEditorCmdObj() oscommands.ICmdObj {
-	return self.cmd.New(fmt.Sprintf("git commit%s", self.signoffFlag()))
-}
-
-func (self *CommitCommands) signoffFlag() string {
-	if self.UserConfig.Git.Commit.SignOff {
-		return " --signoff"
-	} else {
-		return ""
-	}
-}
-
-// Get the subject of the HEAD commit
-func (self *CommitCommands) GetHeadCommitMessage() (string, error) {
-	message, err := self.cmd.New("git log -1 --pretty=%s").DontLog().RunWithOutput()
-	return strings.TrimSpace(message), err
-}
-
-func (self *CommitCommands) GetCommitMessage(commitSha string) (string, error) {
-	cmdStr := "git rev-list --format=%B --max-count=1 " + commitSha
-	messageWithHeader, err := self.cmd.New(cmdStr).DontLog().RunWithOutput()
-	message := strings.Join(strings.SplitAfter(messageWithHeader, "\n")[1:], "\n")
-	return strings.TrimSpace(message), err
-}
-
-func (self *CommitCommands) GetCommitMessageFirstLine(sha string) (string, error) {
-	return self.GetCommitMessagesFirstLine([]string{sha})
-}
-
-func (self *CommitCommands) GetCommitMessagesFirstLine(shas []string) (string, error) {
-	return self.cmd.New(
-		fmt.Sprintf("git show --no-patch --pretty=format:%%s %s", strings.Join(shas, " ")),
-	).DontLog().RunWithOutput()
-}
-
-func (self *CommitCommands) GetCommitsOneline(shas []string) (string, error) {
-	return self.cmd.New(
-		fmt.Sprintf("git show --no-patch --oneline %s", strings.Join(shas, " ")),
-	).DontLog().RunWithOutput()
-}
-
-// AmendHead amends HEAD with whatever is staged in your working tree
-func (self *CommitCommands) AmendHead() error {
-	return self.AmendHeadCmdObj().Run()
-}
-
-func (self *CommitCommands) AmendHeadCmdObj() oscommands.ICmdObj {
-	return self.cmd.New("git commit --amend --no-edit --allow-empty")
-}
-
-func (self *CommitCommands) ShowCmdObj(sha string, filterPath string) oscommands.ICmdObj {
-	contextSize := self.UserConfig.Git.DiffContextSize
-	filterPathArg := ""
-	if filterPath != "" {
-		filterPathArg = fmt.Sprintf(" -- %s", self.cmd.Quote(filterPath))
-	}
-
-	cmdStr := fmt.Sprintf("git show --submodule --color=%s --unified=%d --no-renames --stat -p %s %s", self.UserConfig.Git.Paging.ColorArg, contextSize, sha, filterPathArg)
-	return self.cmd.New(cmdStr).DontLog()
-}
-
-// Revert reverts the selected commit by sha
-func (self *CommitCommands) Revert(sha string) error {
-	return self.cmd.New(fmt.Sprintf("git revert %s", sha)).Run()
-}
-
-func (self *CommitCommands) RevertMerge(sha string, parentNumber int) error {
-	return self.cmd.New(fmt.Sprintf("git revert %s -m %d", sha, parentNumber)).Run()
-}
-
-// CreateFixupCommit creates a commit that fixes up a previous commit
-func (self *CommitCommands) CreateFixupCommit(sha string) error {
-	return self.cmd.New(fmt.Sprintf("git commit --fixup=%s", sha)).Run()
-}

pkg/commands/git_commands/commit_test.go

@@ -1,163 +0,0 @@
-package git_commands
-
-import (
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestCommitRewordCommit(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectGitArgs([]string{"commit", "--allow-empty", "--amend", "--only", "-m", "test"}, "", nil)
-	instance := buildCommitCommands(commonDeps{runner: runner})
-
-	assert.NoError(t, instance.RewordLastCommit("test"))
-	runner.CheckForMissingCalls()
-}
-
-func TestCommitResetToCommit(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectGitArgs([]string{"reset", "--hard", "78976bc"}, "", nil)
-
-	instance := buildCommitCommands(commonDeps{runner: runner})
-
-	assert.NoError(t, instance.ResetToCommit("78976bc", "hard", []string{}))
-	runner.CheckForMissingCalls()
-}
-
-func TestCommitCommitObj(t *testing.T) {
-	type scenario struct {
-		testName             string
-		message              string
-		configSignoff        bool
-		configSkipHookPrefix string
-		expected             string
-	}
-
-	scenarios := []scenario{
-		{
-			testName:             "Commit",
-			message:              "test",
-			configSignoff:        false,
-			configSkipHookPrefix: "",
-			expected:             `git commit -m "test"`,
-		},
-		{
-			testName:             "Commit with --no-verify flag",
-			message:              "WIP: test",
-			configSignoff:        false,
-			configSkipHookPrefix: "WIP",
-			expected:             `git commit --no-verify -m "WIP: test"`,
-		},
-		{
-			testName:             "Commit with multiline message",
-			message:              "line1\nline2",
-			configSignoff:        false,
-			configSkipHookPrefix: "",
-			expected:             `git commit -m "line1" -m "line2"`,
-		},
-		{
-			testName:             "Commit with signoff",
-			message:              "test",
-			configSignoff:        true,
-			configSkipHookPrefix: "",
-			expected:             `git commit --signoff -m "test"`,
-		},
-		{
-			testName:             "Commit with signoff and no-verify",
-			message:              "WIP: test",
-			configSignoff:        true,
-			configSkipHookPrefix: "WIP",
-			expected:             `git commit --no-verify --signoff -m "WIP: test"`,
-		},
-	}
-
-	for _, s := range scenarios {
-		s := s
-		t.Run(s.testName, func(t *testing.T) {
-			userConfig := config.GetDefaultConfig()
-			userConfig.Git.Commit.SignOff = s.configSignoff
-			userConfig.Git.SkipHookPrefix = s.configSkipHookPrefix
-
-			instance := buildCommitCommands(commonDeps{userConfig: userConfig})
-
-			cmdStr := instance.CommitCmdObj(s.message).ToString()
-			assert.Equal(t, s.expected, cmdStr)
-		})
-	}
-}
-
-func TestCommitCreateFixupCommit(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 {
-		s := s
-		t.Run(s.testName, func(t *testing.T) {
-			instance := buildCommitCommands(commonDeps{runner: s.runner})
-			s.test(instance.CreateFixupCommit(s.sha))
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}
-
-func TestCommitShowCmdObj(t *testing.T) {
-	type scenario struct {
-		testName    string
-		filterPath  string
-		contextSize int
-		expected    string
-	}
-
-	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  -- "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 {
-		s := s
-		t.Run(s.testName, func(t *testing.T) {
-			userConfig := config.GetDefaultConfig()
-			userConfig.Git.DiffContextSize = s.contextSize
-
-			instance := buildCommitCommands(commonDeps{userConfig: userConfig})
-
-			cmdStr := instance.ShowCmdObj("1234567890", s.filterPath).ToString()
-			assert.Equal(t, s.expected, cmdStr)
-		})
-	}
-}

pkg/commands/git_commands/common.go

@@ -1,34 +0,0 @@
-package git_commands
-
-import (
-	gogit "github.com/jesseduffield/go-git/v5"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/common"
-)
-
-type GitCommon struct {
-	*common.Common
-	cmd       oscommands.ICmdObjBuilder
-	os        *oscommands.OSCommand
-	dotGitDir string
-	repo      *gogit.Repository
-	config    *ConfigCommands
-}
-
-func NewGitCommon(
-	cmn *common.Common,
-	cmd oscommands.ICmdObjBuilder,
-	osCommand *oscommands.OSCommand,
-	dotGitDir string,
-	repo *gogit.Repository,
-	config *ConfigCommands,
-) *GitCommon {
-	return &GitCommon{
-		Common:    cmn,
-		cmd:       cmd,
-		os:        osCommand,
-		dotGitDir: dotGitDir,
-		repo:      repo,
-		config:    config,
-	}
-}

pkg/commands/git_commands/config.go

@@ -1,101 +0,0 @@
-package git_commands
-
-import (
-	"os"
-	"strconv"
-	"strings"
-
-	gogit "github.com/jesseduffield/go-git/v5"
-	"github.com/jesseduffield/go-git/v5/config"
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
-	"github.com/jesseduffield/lazygit/pkg/common"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-type ConfigCommands struct {
-	*common.Common
-
-	gitConfig git_config.IGitConfig
-	repo      *gogit.Repository
-}
-
-func NewConfigCommands(
-	common *common.Common,
-	gitConfig git_config.IGitConfig,
-	repo *gogit.Repository,
-) *ConfigCommands {
-	return &ConfigCommands{
-		Common:    common,
-		gitConfig: gitConfig,
-		repo:      repo,
-	}
-}
-
-func (self *ConfigCommands) ConfiguredPager() string {
-	if os.Getenv("GIT_PAGER") != "" {
-		return os.Getenv("GIT_PAGER")
-	}
-	if os.Getenv("PAGER") != "" {
-		return os.Getenv("PAGER")
-	}
-	output := self.gitConfig.Get("core.pager")
-	return strings.Split(output, "\n")[0]
-}
-
-func (self *ConfigCommands) GetPager(width int) string {
-	useConfig := self.UserConfig.Git.Paging.UseConfig
-	if useConfig {
-		pager := self.ConfiguredPager()
-		return strings.Split(pager, "| less")[0]
-	}
-
-	templateValues := map[string]string{
-		"columnWidth": strconv.Itoa(width/2 - 6),
-	}
-
-	pagerTemplate := self.UserConfig.Git.Paging.Pager
-	return utils.ResolvePlaceholderString(pagerTemplate, templateValues)
-}
-
-// 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 (self *ConfigCommands) UsingGpg() bool {
-	overrideGpg := self.UserConfig.Git.OverrideGpg
-	if overrideGpg {
-		return false
-	}
-
-	return self.gitConfig.GetBool("commit.gpgsign")
-}
-
-func (self *ConfigCommands) GetCoreEditor() string {
-	return self.gitConfig.Get("core.editor")
-}
-
-// GetRemoteURL returns current repo remote url
-func (self *ConfigCommands) GetRemoteURL() string {
-	return self.gitConfig.Get("remote.origin.url")
-}
-
-func (self *ConfigCommands) GetShowUntrackedFiles() string {
-	return self.gitConfig.Get("status.showUntrackedFiles")
-}
-
-// this determines whether the user has configured to push to the remote branch of the same name as the current or not
-func (self *ConfigCommands) GetPushToCurrent() bool {
-	return self.gitConfig.Get("push.default") == "current"
-}
-
-// returns the repo's branches as specified in the git config
-func (self *ConfigCommands) Branches() (map[string]*config.Branch, error) {
-	conf, err := self.repo.Config()
-	if err != nil {
-		return nil, err
-	}
-
-	return conf.Branches, nil
-}
-
-func (self *ConfigCommands) GetGitFlowPrefixes() string {
-	return self.gitConfig.GetGeneral("--local --get-regexp gitflow.prefix")
-}

pkg/commands/git_commands/custom.go

@@ -1,18 +0,0 @@
-package git_commands
-
-type CustomCommands struct {
-	*GitCommon
-}
-
-func NewCustomCommands(gitCommon *GitCommon) *CustomCommands {
-	return &CustomCommands{
-		GitCommon: gitCommon,
-	}
-}
-
-// Only to be used for the sake of running custom commands specified by the user.
-// If you want to run a new command, try finding a place for it in one of the neighbouring
-// files, or creating a new BlahCommands struct to hold it.
-func (self *CustomCommands) RunWithOutput(cmdStr string) (string, error) {
-	return self.cmd.New(cmdStr).RunWithOutput()
-}

pkg/commands/git_commands/deps_test.go

@@ -1,144 +0,0 @@
-package git_commands
-
-import (
-	"github.com/go-errors/errors"
-	gogit "github.com/jesseduffield/go-git/v5"
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
-	"github.com/jesseduffield/lazygit/pkg/commands/loaders"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/common"
-	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-type commonDeps struct {
-	runner     *oscommands.FakeCmdObjRunner
-	userConfig *config.UserConfig
-	gitConfig  *git_config.FakeGitConfig
-	getenv     func(string) string
-	removeFile func(string) error
-	dotGitDir  string
-	common     *common.Common
-	cmd        *oscommands.CmdObjBuilder
-}
-
-func buildGitCommon(deps commonDeps) *GitCommon {
-	gitCommon := &GitCommon{}
-
-	gitCommon.Common = deps.common
-	if gitCommon.Common == nil {
-		gitCommon.Common = utils.NewDummyCommonWithUserConfig(deps.userConfig)
-	}
-
-	runner := deps.runner
-	if runner == nil {
-		runner = oscommands.NewFakeRunner(nil)
-	}
-
-	cmd := deps.cmd
-	// gotta check deps.cmd because it's not an interface type and an interface value of nil is not considered to be nil
-	if cmd == nil {
-		cmd = oscommands.NewDummyCmdObjBuilder(runner)
-	}
-	gitCommon.cmd = cmd
-
-	gitCommon.Common.UserConfig = deps.userConfig
-	if gitCommon.Common.UserConfig == nil {
-		gitCommon.Common.UserConfig = config.GetDefaultConfig()
-	}
-
-	gitConfig := deps.gitConfig
-	if gitConfig == nil {
-		gitConfig = git_config.NewFakeGitConfig(nil)
-	}
-
-	gitCommon.repo = buildRepo()
-	gitCommon.config = NewConfigCommands(gitCommon.Common, gitConfig, gitCommon.repo)
-
-	getenv := deps.getenv
-	if getenv == nil {
-		getenv = func(string) string { return "" }
-	}
-
-	removeFile := deps.removeFile
-	if removeFile == nil {
-		removeFile = func(string) error { return errors.New("unexpected call to removeFile") }
-	}
-
-	gitCommon.os = oscommands.NewDummyOSCommandWithDeps(oscommands.OSCommandDeps{
-		Common:       gitCommon.Common,
-		GetenvFn:     getenv,
-		Cmd:          cmd,
-		RemoveFileFn: removeFile,
-	})
-
-	gitCommon.dotGitDir = deps.dotGitDir
-	if gitCommon.dotGitDir == "" {
-		gitCommon.dotGitDir = ".git"
-	}
-
-	return gitCommon
-}
-
-func buildRepo() *gogit.Repository {
-	// TODO: think of a way to actually mock this out
-	var repo *gogit.Repository = nil
-	return repo
-}
-
-func buildFileLoader(gitCommon *GitCommon) *loaders.FileLoader {
-	return loaders.NewFileLoader(gitCommon.Common, gitCommon.cmd, gitCommon.config)
-}
-
-func buildSubmoduleCommands(deps commonDeps) *SubmoduleCommands {
-	gitCommon := buildGitCommon(deps)
-
-	return NewSubmoduleCommands(gitCommon)
-}
-
-func buildCommitCommands(deps commonDeps) *CommitCommands {
-	gitCommon := buildGitCommon(deps)
-	return NewCommitCommands(gitCommon)
-}
-
-func buildWorkingTreeCommands(deps commonDeps) *WorkingTreeCommands {
-	gitCommon := buildGitCommon(deps)
-	submoduleCommands := buildSubmoduleCommands(deps)
-	fileLoader := buildFileLoader(gitCommon)
-
-	return NewWorkingTreeCommands(gitCommon, submoduleCommands, fileLoader)
-}
-
-func buildStashCommands(deps commonDeps) *StashCommands {
-	gitCommon := buildGitCommon(deps)
-	fileLoader := buildFileLoader(gitCommon)
-	workingTreeCommands := buildWorkingTreeCommands(deps)
-
-	return NewStashCommands(gitCommon, fileLoader, workingTreeCommands)
-}
-
-func buildRebaseCommands(deps commonDeps) *RebaseCommands {
-	gitCommon := buildGitCommon(deps)
-	workingTreeCommands := buildWorkingTreeCommands(deps)
-	commitCommands := buildCommitCommands(deps)
-
-	return NewRebaseCommands(gitCommon, commitCommands, workingTreeCommands)
-}
-
-func buildSyncCommands(deps commonDeps) *SyncCommands {
-	gitCommon := buildGitCommon(deps)
-
-	return NewSyncCommands(gitCommon)
-}
-
-func buildFileCommands(deps commonDeps) *FileCommands {
-	gitCommon := buildGitCommon(deps)
-
-	return NewFileCommands(gitCommon)
-}
-
-func buildBranchCommands(deps commonDeps) *BranchCommands {
-	gitCommon := buildGitCommon(deps)
-
-	return NewBranchCommands(gitCommon)
-}

pkg/commands/git_commands/file.go

@@ -1,62 +0,0 @@
-package git_commands
-
-import (
-	"io/ioutil"
-	"strconv"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-type FileCommands struct {
-	*GitCommon
-}
-
-func NewFileCommands(gitCommon *GitCommon) *FileCommands {
-	return &FileCommands{
-		GitCommon: gitCommon,
-	}
-}
-
-// Cat obtains the content of a file
-func (self *FileCommands) Cat(fileName string) (string, error) {
-	buf, err := ioutil.ReadFile(fileName)
-	if err != nil {
-		return "", nil
-	}
-	return string(buf), nil
-}
-
-func (self *FileCommands) GetEditCmdStr(filename string, lineNumber int) (string, error) {
-	editor := self.UserConfig.OS.EditCommand
-
-	if editor == "" {
-		editor = self.config.GetCoreEditor()
-	}
-	if editor == "" {
-		editor = self.os.Getenv("GIT_EDITOR")
-	}
-	if editor == "" {
-		editor = self.os.Getenv("VISUAL")
-	}
-	if editor == "" {
-		editor = self.os.Getenv("EDITOR")
-	}
-	if editor == "" {
-		if err := self.cmd.New("which vi").DontLog().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": self.cmd.Quote(filename),
-		"line":     strconv.Itoa(lineNumber),
-	}
-
-	editCmdTemplate := self.UserConfig.OS.EditCommandTemplate
-	return utils.ResolvePlaceholderString(editCmdTemplate, templateValues), nil
-}

pkg/commands/git_commands/file_test.go

@@ -1,163 +0,0 @@
-package git_commands
-
-import (
-	"testing"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/git_config"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/stretchr/testify/assert"
-)
-
-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 {
-		userConfig := config.GetDefaultConfig()
-		userConfig.OS.EditCommand = s.configEditCommand
-		userConfig.OS.EditCommandTemplate = s.configEditCommandTemplate
-
-		instance := buildFileCommands(commonDeps{
-			runner:     s.runner,
-			userConfig: userConfig,
-			gitConfig:  git_config.NewFakeGitConfig(s.gitConfigMockResponses),
-			getenv:     s.getenv,
-		})
-
-		s.test(instance.GetEditCmdStr(s.filename, 1))
-		s.runner.CheckForMissingCalls()
-	}
-}

pkg/commands/git_commands/flow.go

@@ -1,56 +0,0 @@
-package git_commands
-
-import (
-	"regexp"
-	"strings"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-)
-
-type FlowCommands struct {
-	*GitCommon
-}
-
-func NewFlowCommands(
-	gitCommon *GitCommon,
-) *FlowCommands {
-	return &FlowCommands{
-		GitCommon: gitCommon,
-	}
-}
-
-func (self *FlowCommands) GitFlowEnabled() bool {
-	return self.config.GetGitFlowPrefixes() != ""
-}
-
-func (self *FlowCommands) FinishCmdObj(branchName string) (oscommands.ICmdObj, error) {
-	prefixes := self.config.GetGitFlowPrefixes()
-
-	// need to find out what kind of branch this is
-	prefix := strings.SplitAfterN(branchName, "/", 2)[0]
-	suffix := strings.Replace(branchName, prefix, "", 1)
-
-	branchType := ""
-	for _, line := range strings.Split(strings.TrimSpace(prefixes), "\n") {
-		if strings.HasPrefix(line, "gitflow.prefix.") && strings.HasSuffix(line, prefix) {
-			regex := regexp.MustCompile("gitflow.prefix.([^ ]*) .*")
-			matches := regex.FindAllStringSubmatch(line, 1)
-
-			if len(matches) > 0 && len(matches[0]) > 1 {
-				branchType = matches[0][1]
-				break
-			}
-		}
-	}
-
-	if branchType == "" {
-		return nil, errors.New(self.Tr.NotAGitFlowBranch)
-	}
-
-	return self.cmd.New("git flow " + branchType + " finish " + suffix), nil
-}
-
-func (self *FlowCommands) StartCmdObj(branchType string, name string) oscommands.ICmdObj {
-	return self.cmd.New("git flow " + branchType + " start " + name)
-}

pkg/commands/git_commands/patch.go

@@ -1,256 +0,0 @@
-package git_commands
-
-import (
-	"fmt"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/patch"
-	"github.com/jesseduffield/lazygit/pkg/commands/types/enums"
-)
-
-type PatchCommands struct {
-	*GitCommon
-	rebase *RebaseCommands
-	commit *CommitCommands
-	status *StatusCommands
-	stash  *StashCommands
-
-	PatchManager *patch.PatchManager
-}
-
-func NewPatchCommands(
-	gitCommon *GitCommon,
-	rebase *RebaseCommands,
-	commit *CommitCommands,
-	status *StatusCommands,
-	stash *StashCommands,
-	patchManager *patch.PatchManager,
-) *PatchCommands {
-	return &PatchCommands{
-		GitCommon:    gitCommon,
-		rebase:       rebase,
-		commit:       commit,
-		status:       status,
-		stash:        stash,
-		PatchManager: patchManager,
-	}
-}
-
-// DeletePatchesFromCommit applies a patch in reverse for a commit
-func (self *PatchCommands) DeletePatchesFromCommit(commits []*models.Commit, commitIndex int) error {
-	if err := self.rebase.BeginInteractiveRebaseForCommit(commits, commitIndex); err != nil {
-		return err
-	}
-
-	// apply each patch in reverse
-	if err := self.PatchManager.ApplyPatches(true); err != nil {
-		if err := self.rebase.AbortRebase(); err != nil {
-			return err
-		}
-		return err
-	}
-
-	// time to amend the selected commit
-	if err := self.commit.AmendHead(); err != nil {
-		return err
-	}
-
-	self.rebase.onSuccessfulContinue = func() error {
-		self.PatchManager.Reset()
-		return nil
-	}
-
-	// continue
-	return self.rebase.ContinueRebase()
-}
-
-func (self *PatchCommands) MovePatchToSelectedCommit(commits []*models.Commit, sourceCommitIdx int, destinationCommitIdx int) error {
-	if sourceCommitIdx < destinationCommitIdx {
-		if err := self.rebase.BeginInteractiveRebaseForCommit(commits, destinationCommitIdx); err != nil {
-			return err
-		}
-
-		// apply each patch forward
-		if err := self.PatchManager.ApplyPatches(false); err != nil {
-			if err := self.rebase.AbortRebase(); err != nil {
-				return err
-			}
-			return err
-		}
-
-		// amend the destination commit
-		if err := self.commit.AmendHead(); err != nil {
-			return err
-		}
-
-		self.rebase.onSuccessfulContinue = func() error {
-			self.PatchManager.Reset()
-			return nil
-		}
-
-		// continue
-		return self.rebase.ContinueRebase()
-	}
-
-	if len(commits)-1 < sourceCommitIdx {
-		return errors.New("index outside of range of commits")
-	}
-
-	// we can make this GPG thing possible it just means we need to do this in two parts:
-	// one where we handle the possibility of a credential request, and the other
-	// where we continue the rebase
-	if self.config.UsingGpg() {
-		return errors.New(self.Tr.DisabledForGPG)
-	}
-
-	baseIndex := sourceCommitIdx + 1
-	todo := ""
-	for i, commit := range commits[0:baseIndex] {
-		a := "pick"
-		if i == sourceCommitIdx || i == destinationCommitIdx {
-			a = "edit"
-		}
-		todo = a + " " + commit.Sha + " " + commit.Name + "\n" + todo
-	}
-
-	err := self.rebase.PrepareInteractiveRebaseCommand(commits[baseIndex].Sha, todo, true).Run()
-	if err != nil {
-		return err
-	}
-
-	// apply each patch in reverse
-	if err := self.PatchManager.ApplyPatches(true); err != nil {
-		if err := self.rebase.AbortRebase(); err != nil {
-			return err
-		}
-		return err
-	}
-
-	// amend the source commit
-	if err := self.commit.AmendHead(); err != nil {
-		return err
-	}
-
-	if self.rebase.onSuccessfulContinue != nil {
-		return errors.New("You are midway through another rebase operation. Please abort to start again")
-	}
-
-	self.rebase.onSuccessfulContinue = func() error {
-		// now we should be up to the destination, so let's apply forward these patches to that.
-		// ideally we would ensure we're on the right commit but I'm not sure if that check is necessary
-		if err := self.PatchManager.ApplyPatches(false); err != nil {
-			if err := self.rebase.AbortRebase(); err != nil {
-				return err
-			}
-			return err
-		}
-
-		// amend the destination commit
-		if err := self.commit.AmendHead(); err != nil {
-			return err
-		}
-
-		self.rebase.onSuccessfulContinue = func() error {
-			self.PatchManager.Reset()
-			return nil
-		}
-
-		return self.rebase.ContinueRebase()
-	}
-
-	return self.rebase.ContinueRebase()
-}
-
-func (self *PatchCommands) MovePatchIntoIndex(commits []*models.Commit, commitIdx int, stash bool) error {
-	if stash {
-		if err := self.stash.Save(self.Tr.StashPrefix + commits[commitIdx].Sha); err != nil {
-			return err
-		}
-	}
-
-	if err := self.rebase.BeginInteractiveRebaseForCommit(commits, commitIdx); err != nil {
-		return err
-	}
-
-	if err := self.PatchManager.ApplyPatches(true); err != nil {
-		if self.status.WorkingTreeState() == enums.REBASE_MODE_REBASING {
-			if err := self.rebase.AbortRebase(); err != nil {
-				return err
-			}
-		}
-		return err
-	}
-
-	// amend the commit
-	if err := self.commit.AmendHead(); err != nil {
-		return err
-	}
-
-	if self.rebase.onSuccessfulContinue != nil {
-		return errors.New("You are midway through another rebase operation. Please abort to start again")
-	}
-
-	self.rebase.onSuccessfulContinue = func() error {
-		// add patches to index
-		if err := self.PatchManager.ApplyPatches(false); err != nil {
-			if self.status.WorkingTreeState() == enums.REBASE_MODE_REBASING {
-				if err := self.rebase.AbortRebase(); err != nil {
-					return err
-				}
-			}
-			return err
-		}
-
-		if stash {
-			if err := self.stash.Apply(0); err != nil {
-				return err
-			}
-		}
-
-		self.PatchManager.Reset()
-		return nil
-	}
-
-	return self.rebase.ContinueRebase()
-}
-
-func (self *PatchCommands) PullPatchIntoNewCommit(commits []*models.Commit, commitIdx int) error {
-	if err := self.rebase.BeginInteractiveRebaseForCommit(commits, commitIdx); err != nil {
-		return err
-	}
-
-	if err := self.PatchManager.ApplyPatches(true); err != nil {
-		if err := self.rebase.AbortRebase(); err != nil {
-			return err
-		}
-		return err
-	}
-
-	// amend the commit
-	if err := self.commit.AmendHead(); err != nil {
-		return err
-	}
-
-	// add patches to index
-	if err := self.PatchManager.ApplyPatches(false); err != nil {
-		if err := self.rebase.AbortRebase(); err != nil {
-			return err
-		}
-		return err
-	}
-
-	head_message, _ := self.commit.GetHeadCommitMessage()
-	new_message := fmt.Sprintf("Split from \"%s\"", head_message)
-	err := self.commit.CommitCmdObj(new_message).Run()
-	if err != nil {
-		return err
-	}
-
-	if self.rebase.onSuccessfulContinue != nil {
-		return errors.New("You are midway through another rebase operation. Please abort to start again")
-	}
-
-	self.PatchManager.Reset()
-	return self.rebase.ContinueRebase()
-}

pkg/commands/git_commands/rebase.go

@@ -1,345 +0,0 @@
-package git_commands
-
-import (
-	"fmt"
-	"io/ioutil"
-	"path/filepath"
-	"strings"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-)
-
-type RebaseCommands struct {
-	*GitCommon
-	commit      *CommitCommands
-	workingTree *WorkingTreeCommands
-
-	onSuccessfulContinue func() error
-}
-
-func NewRebaseCommands(
-	gitCommon *GitCommon,
-	commitCommands *CommitCommands,
-	workingTreeCommands *WorkingTreeCommands,
-) *RebaseCommands {
-	return &RebaseCommands{
-		GitCommon:   gitCommon,
-		commit:      commitCommands,
-		workingTree: workingTreeCommands,
-	}
-}
-
-func (self *RebaseCommands) RewordCommit(commits []*models.Commit, index int, message string) error {
-	if index == 0 {
-		// we've selected the top commit so no rebase is required
-		return self.commit.RewordLastCommit(message)
-	}
-
-	err := self.BeginInteractiveRebaseForCommit(commits, index)
-	if err != nil {
-		return err
-	}
-
-	// now the selected commit should be our head so we'll amend it with the new message
-	err = self.commit.RewordLastCommit(message)
-	if err != nil {
-		return err
-	}
-
-	return self.ContinueRebase()
-}
-
-func (self *RebaseCommands) RewordCommitInEditor(commits []*models.Commit, index int) (oscommands.ICmdObj, error) {
-	todo, sha, err := self.GenerateGenericRebaseTodo(commits, index, "reword")
-	if err != nil {
-		return nil, err
-	}
-
-	return self.PrepareInteractiveRebaseCommand(sha, todo, false), nil
-}
-
-func (self *RebaseCommands) MoveCommitDown(commits []*models.Commit, index int) error {
-	// we must ensure that we have at least two commits after the selected one
-	if len(commits) <= index+2 {
-		// assuming they aren't picking the bottom commit
-		return errors.New(self.Tr.NoRoom)
-	}
-
-	todo := ""
-	orderedCommits := append(commits[0:index], commits[index+1], commits[index])
-	for _, commit := range orderedCommits {
-		todo = "pick " + commit.Sha + " " + commit.Name + "\n" + todo
-	}
-
-	return self.PrepareInteractiveRebaseCommand(commits[index+2].Sha, todo, true).Run()
-}
-
-func (self *RebaseCommands) InteractiveRebase(commits []*models.Commit, index int, action string) error {
-	todo, sha, err := self.GenerateGenericRebaseTodo(commits, index, action)
-	if err != nil {
-		return err
-	}
-
-	return self.PrepareInteractiveRebaseCommand(sha, todo, true).Run()
-}
-
-// PrepareInteractiveRebaseCommand returns the cmd for an interactive rebase
-// we tell git to run lazygit to edit the todo list, and we pass the client
-// lazygit a todo string to write to the todo file
-func (self *RebaseCommands) PrepareInteractiveRebaseCommand(baseSha string, todo string, overrideEditor bool) oscommands.ICmdObj {
-	ex := oscommands.GetLazygitPath()
-
-	debug := "FALSE"
-	if self.Debug {
-		debug = "TRUE"
-	}
-
-	cmdStr := fmt.Sprintf("git rebase --interactive --autostash --keep-empty %s", baseSha)
-	self.Log.WithField("command", cmdStr).Info("RunCommand")
-
-	cmdObj := self.cmd.New(cmdStr)
-
-	gitSequenceEditor := ex
-	if todo == "" {
-		gitSequenceEditor = "true"
-	} else {
-		self.os.LogCommand(fmt.Sprintf("Creating TODO file for interactive rebase: \n\n%s", todo), false)
-	}
-
-	cmdObj.AddEnvVars(
-		"LAZYGIT_CLIENT_COMMAND=INTERACTIVE_REBASE",
-		"LAZYGIT_REBASE_TODO="+todo,
-		"DEBUG="+debug,
-		"LANG=en_US.UTF-8",   // Force using EN as language
-		"LC_ALL=en_US.UTF-8", // Force using EN as language
-		"GIT_SEQUENCE_EDITOR="+gitSequenceEditor,
-	)
-
-	if overrideEditor {
-		cmdObj.AddEnvVars("GIT_EDITOR=" + ex)
-	}
-
-	return cmdObj
-}
-
-func (self *RebaseCommands) GenerateGenericRebaseTodo(commits []*models.Commit, actionIndex int, action string) (string, string, error) {
-	baseIndex := actionIndex + 1
-
-	if len(commits) <= baseIndex {
-		return "", "", errors.New(self.Tr.CannotRebaseOntoFirstCommit)
-	}
-
-	if action == "squash" || action == "fixup" {
-		baseIndex++
-
-		if len(commits) <= baseIndex {
-			return "", "", errors.New(self.Tr.CannotSquashOntoSecondCommit)
-		}
-	}
-
-	todo := ""
-	for i, commit := range commits[0:baseIndex] {
-		var commitAction string
-		if i == actionIndex {
-			commitAction = action
-		} else if commit.IsMerge() {
-			// your typical interactive rebase will actually drop merge commits by default. Damn git CLI, you scary!
-			// doing this means we don't need to worry about rebasing over merges which always causes problems.
-			// you typically shouldn't be doing rebases that pass over merge commits anyway.
-			commitAction = "drop"
-		} else {
-			commitAction = "pick"
-		}
-		todo = commitAction + " " + commit.Sha + " " + commit.Name + "\n" + todo
-	}
-
-	return todo, commits[baseIndex].Sha, nil
-}
-
-// AmendTo amends the given commit with whatever files are staged
-func (self *RebaseCommands) AmendTo(sha string) error {
-	if err := self.commit.CreateFixupCommit(sha); err != nil {
-		return err
-	}
-
-	return self.SquashAllAboveFixupCommits(sha)
-}
-
-// EditRebaseTodo sets the action at a given index in the git-rebase-todo file
-func (self *RebaseCommands) EditRebaseTodo(index int, action string) error {
-	fileName := filepath.Join(self.dotGitDir, "rebase-merge/git-rebase-todo")
-	bytes, err := ioutil.ReadFile(fileName)
-	if err != nil {
-		return err
-	}
-
-	content := strings.Split(string(bytes), "\n")
-	commitCount := self.getTodoCommitCount(content)
-
-	// we have the most recent commit at the bottom whereas the todo file has
-	// it at the bottom, so we need to subtract our index from the commit count
-	contentIndex := commitCount - 1 - index
-	splitLine := strings.Split(content[contentIndex], " ")
-	content[contentIndex] = action + " " + strings.Join(splitLine[1:], " ")
-	result := strings.Join(content, "\n")
-
-	return ioutil.WriteFile(fileName, []byte(result), 0644)
-}
-
-func (self *RebaseCommands) getTodoCommitCount(content []string) int {
-	// count lines that are not blank and are not comments
-	commitCount := 0
-	for _, line := range content {
-		if line != "" && !strings.HasPrefix(line, "#") {
-			commitCount++
-		}
-	}
-	return commitCount
-}
-
-// MoveTodoDown moves a rebase todo item down by one position
-func (self *RebaseCommands) MoveTodoDown(index int) error {
-	fileName := filepath.Join(self.dotGitDir, "rebase-merge/git-rebase-todo")
-	bytes, err := ioutil.ReadFile(fileName)
-	if err != nil {
-		return err
-	}
-
-	content := strings.Split(string(bytes), "\n")
-	commitCount := self.getTodoCommitCount(content)
-	contentIndex := commitCount - 1 - index
-
-	rearrangedContent := append(content[0:contentIndex-1], content[contentIndex], content[contentIndex-1])
-	rearrangedContent = append(rearrangedContent, content[contentIndex+1:]...)
-	result := strings.Join(rearrangedContent, "\n")
-
-	return ioutil.WriteFile(fileName, []byte(result), 0644)
-}
-
-// SquashAllAboveFixupCommits squashes all fixup! commits above the given one
-func (self *RebaseCommands) SquashAllAboveFixupCommits(sha string) error {
-	return self.runSkipEditorCommand(
-		self.cmd.New(
-			fmt.Sprintf(
-				"git rebase --interactive --autostash --autosquash %s^",
-				sha,
-			),
-		),
-	)
-}
-
-// BeginInteractiveRebaseForCommit starts an interactive rebase to edit the current
-// commit and pick all others. After this you'll want to call `self.ContinueRebase()
-func (self *RebaseCommands) BeginInteractiveRebaseForCommit(commits []*models.Commit, commitIndex int) error {
-	if len(commits)-1 < commitIndex {
-		return errors.New("index outside of range of commits")
-	}
-
-	// we can make this GPG thing possible it just means we need to do this in two parts:
-	// one where we handle the possibility of a credential request, and the other
-	// where we continue the rebase
-	if self.config.UsingGpg() {
-		return errors.New(self.Tr.DisabledForGPG)
-	}
-
-	todo, sha, err := self.GenerateGenericRebaseTodo(commits, commitIndex, "edit")
-	if err != nil {
-		return err
-	}
-
-	return self.PrepareInteractiveRebaseCommand(sha, todo, true).Run()
-}
-
-// RebaseBranch interactive rebases onto a branch
-func (self *RebaseCommands) RebaseBranch(branchName string) error {
-	return self.PrepareInteractiveRebaseCommand(branchName, "", false).Run()
-}
-
-func (self *RebaseCommands) GenericMergeOrRebaseActionCmdObj(commandType string, command string) oscommands.ICmdObj {
-	return self.cmd.New("git " + commandType + " --" + command)
-}
-
-func (self *RebaseCommands) ContinueRebase() error {
-	return self.GenericMergeOrRebaseAction("rebase", "continue")
-}
-
-func (self *RebaseCommands) AbortRebase() error {
-	return self.GenericMergeOrRebaseAction("rebase", "abort")
-}
-
-// GenericMerge takes a commandType of "merge" or "rebase" and a command of "abort", "skip" or "continue"
-// By default we skip the editor in the case where a commit will be made
-func (self *RebaseCommands) GenericMergeOrRebaseAction(commandType string, command string) error {
-	err := self.runSkipEditorCommand(self.GenericMergeOrRebaseActionCmdObj(commandType, command))
-	if err != nil {
-		if !strings.Contains(err.Error(), "no rebase in progress") {
-			return err
-		}
-		self.Log.Warn(err)
-	}
-
-	// sometimes we need to do a sequence of things in a rebase but the user needs to
-	// fix merge conflicts along the way. When this happens we queue up the next step
-	// so that after the next successful rebase continue we can continue from where we left off
-	if commandType == "rebase" && command == "continue" && self.onSuccessfulContinue != nil {
-		f := self.onSuccessfulContinue
-		self.onSuccessfulContinue = nil
-		return f()
-	}
-	if command == "abort" {
-		self.onSuccessfulContinue = nil
-	}
-	return nil
-}
-
-func (self *RebaseCommands) runSkipEditorCommand(cmdObj oscommands.ICmdObj) error {
-	lazyGitPath := oscommands.GetLazygitPath()
-	return cmdObj.
-		AddEnvVars(
-			"LAZYGIT_CLIENT_COMMAND=EXIT_IMMEDIATELY",
-			"GIT_EDITOR="+lazyGitPath,
-			"EDITOR="+lazyGitPath,
-			"VISUAL="+lazyGitPath,
-		).
-		Run()
-}
-
-// DiscardOldFileChanges discards changes to a file from an old commit
-func (self *RebaseCommands) DiscardOldFileChanges(commits []*models.Commit, commitIndex int, fileName string) error {
-	if err := self.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 := self.cmd.New("git cat-file -e HEAD^:" + self.cmd.Quote(fileName)).Run(); err != nil {
-		if err := self.os.Remove(fileName); err != nil {
-			return err
-		}
-		if err := self.workingTree.StageFile(fileName); err != nil {
-			return err
-		}
-	} else if err := self.workingTree.CheckoutFile("HEAD^", fileName); err != nil {
-		return err
-	}
-
-	// amend the commit
-	err := self.commit.AmendHead()
-	if err != nil {
-		return err
-	}
-
-	// continue
-	return self.ContinueRebase()
-}
-
-// CherryPickCommits begins an interactive rebase with the given shas being cherry picked onto HEAD
-func (self *RebaseCommands) CherryPickCommits(commits []*models.Commit) error {
-	todo := ""
-	for _, commit := range commits {
-		todo = "pick " + commit.Sha + " " + commit.Name + "\n" + todo
-	}
-
-	return self.PrepareInteractiveRebaseCommand("HEAD", todo, false).Run()
-}

pkg/commands/git_commands/rebase_test.go

@@ -1,151 +0,0 @@
-package git_commands
-
-import (
-	"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/jesseduffield/lazygit/pkg/utils"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestRebaseRebaseBranch(t *testing.T) {
-	type scenario struct {
-		testName string
-		arg      string
-		runner   *oscommands.FakeCmdObjRunner
-		test     func(error)
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "successful rebase",
-			arg:      "master",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git rebase --interactive --autostash --keep-empty master`, "", nil),
-			test: func(err error) {
-				assert.NoError(t, err)
-			},
-		},
-		{
-			testName: "unsuccessful rebase",
-			arg:      "master",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git rebase --interactive --autostash --keep-empty master`, "", errors.New("error")),
-			test: func(err error) {
-				assert.Error(t, err)
-			},
-		},
-	}
-
-	for _, s := range scenarios {
-		s := s
-		t.Run(s.testName, func(t *testing.T) {
-			instance := buildRebaseCommands(commonDeps{runner: s.runner})
-			s.test(instance.RebaseBranch(s.arg))
-		})
-	}
-}
-
-// TestRebaseSkipEditorCommand confirms that SkipEditorCommand injects
-// environment variables that suppress an interactive editor
-func TestRebaseSkipEditorCommand(t *testing.T) {
-	commandStr := "git blah"
-	runner := oscommands.NewFakeRunner(t).ExpectFunc(func(cmdObj oscommands.ICmdObj) (string, error) {
-		assert.Equal(t, commandStr, cmdObj.ToString())
-		envVars := cmdObj.GetEnvVars()
-		for _, regexStr := range []string{
-			`^VISUAL=.*$`,
-			`^EDITOR=.*$`,
-			`^GIT_EDITOR=.*$`,
-			"^LAZYGIT_CLIENT_COMMAND=EXIT_IMMEDIATELY$",
-		} {
-			regexStr := regexStr
-			foundMatch := utils.IncludesStringFunc(envVars, func(envVar string) bool {
-				return regexp.MustCompile(regexStr).MatchString(envVar)
-			})
-			if !foundMatch {
-				t.Errorf("expected environment variable %s to be set", regexStr)
-			}
-		}
-		return "", nil
-	})
-	instance := buildRebaseCommands(commonDeps{runner: runner})
-	err := instance.runSkipEditorCommand(instance.cmd.New(commandStr))
-	assert.NoError(t, err)
-	runner.CheckForMissingCalls()
-}
-
-func TestRebaseDiscardOldFileChanges(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 {
-		s := s
-		t.Run(s.testName, func(t *testing.T) {
-			instance := buildRebaseCommands(commonDeps{
-				runner:    s.runner,
-				gitConfig: git_config.NewFakeGitConfig(s.gitConfigMockResponses),
-			})
-
-			s.test(instance.DiscardOldFileChanges(s.commits, s.commitIndex, s.fileName))
-			s.runner.CheckForMissingCalls()
-		})
-	}
-}

pkg/commands/git_commands/remote.go

@@ -1,58 +0,0 @@
-package git_commands
-
-import (
-	"fmt"
-)
-
-type RemoteCommands struct {
-	*GitCommon
-}
-
-func NewRemoteCommands(gitCommon *GitCommon) *RemoteCommands {
-	return &RemoteCommands{
-		GitCommon: gitCommon,
-	}
-}
-
-func (self *RemoteCommands) AddRemote(name string, url string) error {
-	return self.cmd.
-		New(fmt.Sprintf("git remote add %s %s", self.cmd.Quote(name), self.cmd.Quote(url))).
-		Run()
-}
-
-func (self *RemoteCommands) RemoveRemote(name string) error {
-	return self.cmd.
-		New(fmt.Sprintf("git remote remove %s", self.cmd.Quote(name))).
-		Run()
-}
-
-func (self *RemoteCommands) RenameRemote(oldRemoteName string, newRemoteName string) error {
-	return self.cmd.
-		New(fmt.Sprintf("git remote rename %s %s", self.cmd.Quote(oldRemoteName), self.cmd.Quote(newRemoteName))).
-		Run()
-}
-
-func (self *RemoteCommands) UpdateRemoteUrl(remoteName string, updatedUrl string) error {
-	return self.cmd.
-		New(fmt.Sprintf("git remote set-url %s %s", self.cmd.Quote(remoteName), self.cmd.Quote(updatedUrl))).
-		Run()
-}
-
-func (self *RemoteCommands) DeleteRemoteBranch(remoteName string, branchName string) error {
-	command := fmt.Sprintf("git push %s --delete %s", self.cmd.Quote(remoteName), self.cmd.Quote(branchName))
-	return self.cmd.New(command).PromptOnCredentialRequest().Run()
-}
-
-// CheckRemoteBranchExists Returns remote branch
-func (self *RemoteCommands) CheckRemoteBranchExists(branchName string) bool {
-	_, err := self.cmd.
-		New(
-			fmt.Sprintf("git show-ref --verify -- refs/remotes/origin/%s",
-				self.cmd.Quote(branchName),
-			),
-		).
-		DontLog().
-		RunWithOutput()
-
-	return err == nil
-}

pkg/commands/git_commands/stash.go

@@ -1,91 +0,0 @@
-package git_commands
-
-import (
-	"fmt"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/loaders"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-)
-
-type StashCommands struct {
-	*GitCommon
-	fileLoader  *loaders.FileLoader
-	workingTree *WorkingTreeCommands
-}
-
-func NewStashCommands(
-	gitCommon *GitCommon,
-	fileLoader *loaders.FileLoader,
-	workingTree *WorkingTreeCommands,
-) *StashCommands {
-	return &StashCommands{
-		GitCommon:   gitCommon,
-		fileLoader:  fileLoader,
-		workingTree: workingTree,
-	}
-}
-
-func (self *StashCommands) Drop(index int) error {
-	return self.cmd.New(fmt.Sprintf("git stash drop stash@{%d}", index)).Run()
-}
-
-func (self *StashCommands) Pop(index int) error {
-	return self.cmd.New(fmt.Sprintf("git stash pop stash@{%d}", index)).Run()
-}
-
-func (self *StashCommands) Apply(index int) error {
-	return self.cmd.New(fmt.Sprintf("git stash apply stash@{%d}", index)).Run()
-}
-
-// Save save stash
-// TODO: before calling this, check if there is anything to save
-func (self *StashCommands) Save(message string) error {
-	return self.cmd.New("git stash save " + self.cmd.Quote(message)).Run()
-}
-
-func (self *StashCommands) ShowStashEntryCmdObj(index int) oscommands.ICmdObj {
-	cmdStr := fmt.Sprintf("git stash show -p --stat --color=%s --unified=%d stash@{%d}", self.UserConfig.Git.Paging.ColorArg, self.UserConfig.Git.DiffContextSize, index)
-
-	return self.cmd.New(cmdStr).DontLog()
-}
-
-// SaveStagedChanges stashes only the currently staged changes. This takes a few steps
-// shoutouts to Joe on https://stackoverflow.com/questions/14759748/stashing-only-staged-changes-in-git-is-it-possible
-func (self *StashCommands) SaveStagedChanges(message string) error {
-	// wrap in 'writing', which uses a mutex
-	if err := self.cmd.New("git stash --keep-index").Run(); err != nil {
-		return err
-	}
-
-	if err := self.Save(message); err != nil {
-		return err
-	}
-
-	if err := self.cmd.New("git stash apply stash@{1}").Run(); err != nil {
-		return err
-	}
-
-	if err := self.os.PipeCommands("git stash show -p", "git apply -R"); err != nil {
-		return err
-	}
-
-	if err := self.cmd.New("git stash drop stash@{1}").Run(); err != nil {
-		return err
-	}
-
-	// if you had staged an untracked file, that will now appear as 'AD' in git status
-	// meaning it's deleted in your working tree but added in your index. Given that it's
-	// now safely stashed, we need to remove it.
-	files := self.fileLoader.
-		GetStatusFiles(loaders.GetStatusFileOptions{})
-
-	for _, file := range files {
-		if file.ShortStatus == "AD" {
-			if err := self.workingTree.UnStageFile(file.Names(), false); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}

pkg/commands/git_commands/stash_test.go

@@ -1,81 +0,0 @@
-package git_commands
-
-import (
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/config"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestStashDrop(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectGitArgs([]string{"stash", "drop", "stash@{1}"}, "", nil)
-	instance := buildStashCommands(commonDeps{runner: runner})
-
-	assert.NoError(t, instance.Drop(1))
-	runner.CheckForMissingCalls()
-}
-
-func TestStashApply(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectGitArgs([]string{"stash", "apply", "stash@{1}"}, "", nil)
-	instance := buildStashCommands(commonDeps{runner: runner})
-
-	assert.NoError(t, instance.Apply(1))
-	runner.CheckForMissingCalls()
-}
-
-func TestStashPop(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectGitArgs([]string{"stash", "pop", "stash@{1}"}, "", nil)
-	instance := buildStashCommands(commonDeps{runner: runner})
-
-	assert.NoError(t, instance.Pop(1))
-	runner.CheckForMissingCalls()
-}
-
-func TestStashSave(t *testing.T) {
-	runner := oscommands.NewFakeRunner(t).
-		ExpectGitArgs([]string{"stash", "save", "A stash message"}, "", nil)
-	instance := buildStashCommands(commonDeps{runner: runner})
-
-	assert.NoError(t, instance.Save("A stash message"))
-	runner.CheckForMissingCalls()
-}
-
-func TestStashStashEntryCmdObj(t *testing.T) {
-	type scenario struct {
-		testName    string
-		index       int
-		contextSize int
-		expected    string
-	}
-
-	scenarios := []scenario{
-		{
-			testName:    "Default case",
-			index:       5,
-			contextSize: 3,
-			expected:    "git stash show -p --stat --color=always --unified=3 stash@{5}",
-		},
-		{
-			testName:    "Show diff with custom context size",
-			index:       5,
-			contextSize: 77,
-			expected:    "git stash show -p --stat --color=always --unified=77 stash@{5}",
-		},
-	}
-
-	for _, s := range scenarios {
-		s := s
-		t.Run(s.testName, func(t *testing.T) {
-			userConfig := config.GetDefaultConfig()
-			userConfig.Git.DiffContextSize = s.contextSize
-			instance := buildStashCommands(commonDeps{userConfig: userConfig})
-
-			cmdStr := instance.ShowStashEntryCmdObj(s.index).ToString()
-			assert.Equal(t, s.expected, cmdStr)
-		})
-	}
-}

pkg/commands/git_commands/sync.go

@@ -1,122 +0,0 @@
-package git_commands
-
-import (
-	"fmt"
-
-	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-)
-
-type SyncCommands struct {
-	*GitCommon
-}
-
-func NewSyncCommands(gitCommon *GitCommon) *SyncCommands {
-	return &SyncCommands{
-		GitCommon: gitCommon,
-	}
-}
-
-// Push pushes to a branch
-type PushOpts struct {
-	Force          bool
-	UpstreamRemote string
-	UpstreamBranch string
-	SetUpstream    bool
-}
-
-func (self *SyncCommands) PushCmdObj(opts PushOpts) (oscommands.ICmdObj, error) {
-	cmdStr := "git push"
-
-	if opts.Force {
-		cmdStr += " --force-with-lease"
-	}
-
-	if opts.SetUpstream {
-		cmdStr += " --set-upstream"
-	}
-
-	if opts.UpstreamRemote != "" {
-		cmdStr += " " + self.cmd.Quote(opts.UpstreamRemote)
-	}
-
-	if opts.UpstreamBranch != "" {
-		if opts.UpstreamRemote == "" {
-			return nil, errors.New(self.Tr.MustSpecifyOriginError)
-		}
-		cmdStr += " " + self.cmd.Quote(opts.UpstreamBranch)
-	}
-
-	cmdObj := self.cmd.New(cmdStr).PromptOnCredentialRequest()
-	return cmdObj, nil
-}
-
-func (self *SyncCommands) Push(opts PushOpts) error {
-	cmdObj, err := self.PushCmdObj(opts)
-	if err != nil {
-		return err
-	}
-
-	return cmdObj.Run()
-}
-
-type FetchOptions struct {
-	Background bool
-	RemoteName string
-	BranchName string
-}
-
-// Fetch fetch git repo
-func (self *SyncCommands) Fetch(opts FetchOptions) error {
-	cmdStr := "git fetch"
-
-	if opts.RemoteName != "" {
-		cmdStr = fmt.Sprintf("%s %s", cmdStr, self.cmd.Quote(opts.RemoteName))
-	}
-	if opts.BranchName != "" {
-		cmdStr = fmt.Sprintf("%s %s", cmdStr, self.cmd.Quote(opts.BranchName))
-	}
-
-	cmdObj := self.cmd.New(cmdStr)
-	if opts.Background {
-		cmdObj.DontLog().FailOnCredentialRequest()
-	} else {
-		cmdObj.PromptOnCredentialRequest()
-	}
-	return cmdObj.Run()
-}
-
-type PullOptions struct {
-	RemoteName      string
-	BranchName      string
-	FastForwardOnly bool
-}
-
-func (self *SyncCommands) Pull(opts PullOptions) error {
-	cmdStr := "git pull --no-edit"
-
-	if opts.FastForwardOnly {
-		cmdStr += " --ff-only"
-	}
-
-	if opts.RemoteName != "" {
-		cmdStr = fmt.Sprintf("%s %s", cmdStr, self.cmd.Quote(opts.RemoteName))
-	}
-	if opts.BranchName != "" {
-		cmdStr = fmt.Sprintf("%s %s", cmdStr, self.cmd.Quote(opts.BranchName))
-	}
-
-	// setting GIT_SEQUENCE_EDITOR to ':' as a way of skipping it, in case the user
-	// has 'pull.rebase = interactive' configured.
-	return self.cmd.New(cmdStr).AddEnvVars("GIT_SEQUENCE_EDITOR=:").PromptOnCredentialRequest().Run()
-}
-
-func (self *SyncCommands) FastForward(branchName string, remoteName string, remoteBranchName string) error {
-	cmdStr := fmt.Sprintf("git fetch %s %s:%s", self.cmd.Quote(remoteName), self.cmd.Quote(remoteBranchName), self.cmd.Quote(branchName))
-	return self.cmd.New(cmdStr).PromptOnCredentialRequest().Run()
-}
-
-func (self *SyncCommands) FetchRemote(remoteName string) error {
-	cmdStr := fmt.Sprintf("git fetch %s", self.cmd.Quote(remoteName))
-	return self.cmd.New(cmdStr).PromptOnCredentialRequest().Run()
-}

pkg/commands/git_commands/tag.go

@@ -1,31 +0,0 @@
-package git_commands
-
-import (
-	"fmt"
-)
-
-type TagCommands struct {
-	*GitCommon
-}
-
-func NewTagCommands(gitCommon *GitCommon) *TagCommands {
-	return &TagCommands{
-		GitCommon: gitCommon,
-	}
-}
-
-func (self *TagCommands) CreateLightweight(tagName string, commitSha string) error {
-	return self.cmd.New(fmt.Sprintf("git tag -- %s %s", self.cmd.Quote(tagName), commitSha)).Run()
-}
-
-func (self *TagCommands) CreateAnnotated(tagName, commitSha, msg string) error {
-	return self.cmd.New(fmt.Sprintf("git tag %s %s -m %s", tagName, commitSha, self.cmd.Quote(msg))).Run()
-}
-
-func (self *TagCommands) Delete(tagName string) error {
-	return self.cmd.New(fmt.Sprintf("git tag -d %s", self.cmd.Quote(tagName))).Run()
-}
-
-func (self *TagCommands) Push(remoteName string, tagName string) error {
-	return self.cmd.New(fmt.Sprintf("git push %s %s", self.cmd.Quote(remoteName), self.cmd.Quote(tagName))).PromptOnCredentialRequest().Run()
-}

pkg/commands/git_commands/working_tree.go

@@ -1,356 +0,0 @@
-package git_commands
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"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/utils"
-)
-
-type WorkingTreeCommands struct {
-	*GitCommon
-	submodule  *SubmoduleCommands
-	fileLoader *loaders.FileLoader
-}
-
-func NewWorkingTreeCommands(
-	gitCommon *GitCommon,
-	submodule *SubmoduleCommands,
-	fileLoader *loaders.FileLoader,
-) *WorkingTreeCommands {
-	return &WorkingTreeCommands{
-		GitCommon:  gitCommon,
-		submodule:  submodule,
-		fileLoader: fileLoader,
-	}
-}
-
-func (self *WorkingTreeCommands) OpenMergeToolCmdObj() oscommands.ICmdObj {
-	return self.cmd.New("git mergetool")
-}
-
-func (self *WorkingTreeCommands) OpenMergeTool() error {
-	return self.OpenMergeToolCmdObj().Run()
-}
-
-// StageFile stages a file
-func (self *WorkingTreeCommands) StageFile(path string) error {
-	return self.StageFiles([]string{path})
-}
-
-func (self *WorkingTreeCommands) StageFiles(paths []string) error {
-	quotedPaths := make([]string, len(paths))
-	for i, path := range paths {
-		quotedPaths[i] = self.cmd.Quote(path)
-	}
-	return self.cmd.New(fmt.Sprintf("git add -- %s", strings.Join(quotedPaths, " "))).Run()
-}
-
-// StageAll stages all files
-func (self *WorkingTreeCommands) StageAll() error {
-	return self.cmd.New("git add -A").Run()
-}
-
-// UnstageAll unstages all files
-func (self *WorkingTreeCommands) UnstageAll() error {
-	return self.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 (self *WorkingTreeCommands) UnStageFile(fileNames []string, reset bool) error {
-	command := "git rm --cached --force -- %s"
-	if reset {
-		command = "git reset HEAD -- %s"
-	}
-
-	for _, name := range fileNames {
-		err := self.cmd.New(fmt.Sprintf(command, self.cmd.Quote(name))).Run()
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (self *WorkingTreeCommands) 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 := self.fileLoader.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 (self *WorkingTreeCommands) DiscardAllFileChanges(file *models.File) error {
-	if file.IsRename() {
-		beforeFile, afterFile, err := self.BeforeAndAfterFileForRename(file)
-		if err != nil {
-			return err
-		}
-
-		if err := self.DiscardAllFileChanges(beforeFile); err != nil {
-			return err
-		}
-
-		if err := self.DiscardAllFileChanges(afterFile); err != nil {
-			return err
-		}
-
-		return nil
-	}
-
-	quotedFileName := self.cmd.Quote(file.Name)
-
-	if file.ShortStatus == "AA" {
-		if err := self.cmd.New("git checkout --ours --  " + quotedFileName).Run(); err != nil {
-			return err
-		}
-		if err := self.cmd.New("git add -- " + quotedFileName).Run(); err != nil {
-			return err
-		}
-		return nil
-	}
-
-	if file.ShortStatus == "DU" {
-		return self.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 := self.cmd.New("git reset -- " + quotedFileName).Run(); err != nil {
-			return err
-		}
-	}
-
-	if file.ShortStatus == "DD" || file.ShortStatus == "AU" {
-		return nil
-	}
-
-	if file.Added {
-		return self.os.RemoveFile(file.Name)
-	}
-	return self.DiscardUnstagedFileChanges(file)
-}
-
-type IFileNode interface {
-	ForEachFile(cb func(*models.File) error) error
-	GetFilePathsMatching(test func(*models.File) bool) []string
-	GetPath() string
-}
-
-func (self *WorkingTreeCommands) DiscardAllDirChanges(node IFileNode) error {
-	// this could be more efficient but we would need to handle all the edge cases
-	return node.ForEachFile(self.DiscardAllFileChanges)
-}
-
-func (self *WorkingTreeCommands) DiscardUnstagedDirChanges(node IFileNode) error {
-	if err := self.RemoveUntrackedDirFiles(node); err != nil {
-		return err
-	}
-
-	quotedPath := self.cmd.Quote(node.GetPath())
-	if err := self.cmd.New("git checkout -- " + quotedPath).Run(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (self *WorkingTreeCommands) RemoveUntrackedDirFiles(node IFileNode) error {
-	untrackedFilePaths := node.GetFilePathsMatching(
-		func(file *models.File) bool { return !file.GetIsTracked() },
-	)
-
-	for _, path := range untrackedFilePaths {
-		err := os.Remove(path)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// DiscardUnstagedFileChanges directly
-func (self *WorkingTreeCommands) DiscardUnstagedFileChanges(file *models.File) error {
-	quotedFileName := self.cmd.Quote(file.Name)
-	return self.cmd.New("git checkout -- " + quotedFileName).Run()
-}
-
-// Ignore adds a file to the gitignore for the repo
-func (self *WorkingTreeCommands) Ignore(filename string) error {
-	return self.os.AppendLineToFile(".gitignore", filename)
-}
-
-// WorktreeFileDiff returns the diff of a file
-func (self *WorkingTreeCommands) WorktreeFileDiff(file *models.File, plain bool, cached bool, ignoreWhitespace bool) string {
-	// for now we assume an error means the file was deleted
-	s, _ := self.WorktreeFileDiffCmdObj(file, plain, cached, ignoreWhitespace).RunWithOutput()
-	return s
-}
-
-func (self *WorkingTreeCommands) WorktreeFileDiffCmdObj(node models.IFile, plain bool, cached bool, ignoreWhitespace bool) oscommands.ICmdObj {
-	cachedArg := ""
-	trackedArg := "--"
-	colorArg := self.UserConfig.Git.Paging.ColorArg
-	quotedPath := self.cmd.Quote(node.GetPath())
-	ignoreWhitespaceArg := ""
-	contextSize := self.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 self.cmd.New(cmdStr).DontLog()
-}
-
-func (self *WorkingTreeCommands) ApplyPatch(patch string, flags ...string) error {
-	filepath := filepath.Join(oscommands.GetTempDir(), utils.GetCurrentRepoName(), time.Now().Format("Jan _2 15.04.05.000000000")+".patch")
-	self.Log.Infof("saving temporary patch to %s", filepath)
-	if err := self.os.CreateFileWithContent(filepath, patch); err != nil {
-		return err
-	}
-
-	flagStr := ""
-	for _, flag := range flags {
-		flagStr += " --" + flag
-	}
-
-	return self.cmd.New(fmt.Sprintf("git apply%s %s", flagStr, self.cmd.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 (self *WorkingTreeCommands) ShowFileDiff(from string, to string, reverse bool, fileName string, plain bool) (string, error) {
-	return self.ShowFileDiffCmdObj(from, to, reverse, fileName, plain).RunWithOutput()
-}
-
-func (self *WorkingTreeCommands) ShowFileDiffCmdObj(from string, to string, reverse bool, fileName string, plain bool) oscommands.ICmdObj {
-	colorArg := self.UserConfig.Git.Paging.ColorArg
-	contextSize := self.UserConfig.Git.DiffContextSize
-	if plain {
-		colorArg = "never"
-	}
-
-	reverseFlag := ""
-	if reverse {
-		reverseFlag = " -R"
-	}
-
-	return self.cmd.
-		New(
-			fmt.Sprintf(
-				"git diff --submodule --no-ext-diff --unified=%d --no-renames --color=%s%s%s%s -- %s",
-				contextSize, colorArg, pad(from), pad(to), reverseFlag, self.cmd.Quote(fileName)),
-		).
-		DontLog()
-}
-
-// CheckoutFile checks out the file for the given commit
-func (self *WorkingTreeCommands) CheckoutFile(commitSha, fileName string) error {
-	return self.cmd.New(fmt.Sprintf("git checkout %s -- %s", commitSha, self.cmd.Quote(fileName))).Run()
-}
-
-// DiscardAnyUnstagedFileChanges discards any unstages file changes via `git checkout -- .`
-func (self *WorkingTreeCommands) DiscardAnyUnstagedFileChanges() error {
-	return self.cmd.New("git checkout -- .").Run()
-}
-
-// RemoveTrackedFiles will delete the given file(s) even if they are currently tracked
-func (self *WorkingTreeCommands) RemoveTrackedFiles(name string) error {
-	return self.cmd.New("git rm -r --cached -- " + self.cmd.Quote(name)).Run()
-}
-
-// RemoveUntrackedFiles runs `git clean -fd`
-func (self *WorkingTreeCommands) RemoveUntrackedFiles() error {
-	return self.cmd.New("git clean -fd").Run()
-}
-
-// ResetAndClean removes all unstaged changes and removes all untracked files
-func (self *WorkingTreeCommands) ResetAndClean() error {
-	submoduleConfigs, err := self.submodule.GetConfigs()
-	if err != nil {
-		return err
-	}
-
-	if len(submoduleConfigs) > 0 {
-		if err := self.submodule.ResetSubmodules(submoduleConfigs); err != nil {
-			return err
-		}
-	}
-
-	if err := self.ResetHard("HEAD"); err != nil {
-		return err
-	}
-
-	return self.RemoveUntrackedFiles()
-}
-
-// ResetHardHead runs `git reset --hard`
-func (self *WorkingTreeCommands) ResetHard(ref string) error {
-	return self.cmd.New("git reset --hard " + self.cmd.Quote(ref)).Run()
-}
-
-// ResetSoft runs `git reset --soft HEAD`
-func (self *WorkingTreeCommands) ResetSoft(ref string) error {
-	return self.cmd.New("git reset --soft " + self.cmd.Quote(ref)).Run()
-}
-
-func (self *WorkingTreeCommands) ResetMixed(ref string) error {
-	return self.cmd.New("git reset --mixed " + self.cmd.Quote(ref)).Run()
-}
-
-// so that we don't have unnecessary space in our commands we use this helper function to prepend spaces to args so that in the format string we can go '%s%s%s' and if any args are missing we won't have gaps.
-func pad(str string) string {
-	if str == "" {
-		return ""
-	}
-
-	return " " + str
-}

pkg/commands/git_config/cached_git_config.go

@@ -1,36 +1,31 @@
 package git_config
 
 import (
-	"os/exec"
 	"strings"
 
 	"github.com/sirupsen/logrus"
 )
 
 type IGitConfig interface {
-	// this is for when you want to pass 'mykey' (it calls `git config --get --null mykey` under the hood)
 	Get(string) string
-	// this is for when you want to pass '--local --get-regexp mykey'
-	GetGeneral(string) string
-	// this is for when you want to pass 'mykey' and check if the result is truthy
 	GetBool(string) bool
 }
 
 type CachedGitConfig struct {
-	cache           map[string]string
-	runGitConfigCmd func(*exec.Cmd) (string, error)
-	log             *logrus.Entry
+	cache  map[string]string
+	getKey func(string) (string, error)
+	log    *logrus.Entry
 }
 
 func NewStdCachedGitConfig(log *logrus.Entry) *CachedGitConfig {
-	return NewCachedGitConfig(runGitConfigCmd, log)
+	return NewCachedGitConfig(getGitConfigValue, log)
 }
 
-func NewCachedGitConfig(runGitConfigCmd func(*exec.Cmd) (string, error), log *logrus.Entry) *CachedGitConfig {
+func NewCachedGitConfig(getKey func(string) (string, error), log *logrus.Entry) *CachedGitConfig {
 	return &CachedGitConfig{
-		cache:           make(map[string]string),
-		runGitConfigCmd: runGitConfigCmd,
-		log:             log,
+		cache:  make(map[string]string),
+		getKey: getKey,
+		log:    log,
 	}
 }
 
@@ -45,30 +40,8 @@ func (self *CachedGitConfig) Get(key string) string {
 	return value
 }
 
-func (self *CachedGitConfig) GetGeneral(args string) string {
-	if value, ok := self.cache[args]; ok {
-		self.log.Debugf("using cache for args " + args)
-		return value
-	}
-
-	value := self.getGeneralAux(args)
-	self.cache[args] = value
-	return value
-}
-
-func (self *CachedGitConfig) getGeneralAux(args string) string {
-	cmd := getGitConfigGeneralCmd(args)
-	value, err := self.runGitConfigCmd(cmd)
-	if err != nil {
-		self.log.Debugf("Error getting git config value for args: " + args + ". Error: " + err.Error())
-		return ""
-	}
-	return strings.TrimSpace(value)
-}
-
 func (self *CachedGitConfig) getAux(key string) string {
-	cmd := getGitConfigCmd(key)
-	value, err := self.runGitConfigCmd(cmd)
+	value, err := self.getKey(key)
 	if err != nil {
 		self.log.Debugf("Error getting git config value for key: " + key + ". Error: " + err.Error())
 		return ""

pkg/commands/git_config/cached_git_config_test.go

@@ -1,8 +1,6 @@
 package git_config
 
 import (
-	"os/exec"
-	"strings"
 	"testing"
 
 	"github.com/jesseduffield/lazygit/pkg/utils"
@@ -54,9 +52,8 @@ func TestGetBool(t *testing.T) {
 		t.Run(s.testName, func(t *testing.T) {
 			fake := NewFakeGitConfig(s.mockResponses)
 			real := NewCachedGitConfig(
-				func(cmd *exec.Cmd) (string, error) {
-					assert.Equal(t, "config --get --null commit.gpgsign", strings.Join(cmd.Args[1:], " "))
-					return fake.Get("commit.gpgsign"), nil
+				func(key string) (string, error) {
+					return fake.Get(key), nil
 				},
 				utils.NewDummyLog(),
 			)
@@ -91,9 +88,8 @@ func TestGet(t *testing.T) {
 		t.Run(s.testName, func(t *testing.T) {
 			fake := NewFakeGitConfig(s.mockResponses)
 			real := NewCachedGitConfig(
-				func(cmd *exec.Cmd) (string, error) {
-					assert.Equal(t, "config --get --null commit.gpgsign", strings.Join(cmd.Args[1:], " "))
-					return fake.Get("commit.gpgsign"), nil
+				func(key string) (string, error) {
+					return fake.Get(key), nil
 				},
 				utils.NewDummyLog(),
 			)
@@ -105,9 +101,9 @@ func TestGet(t *testing.T) {
 	// verifying that the cache is used
 	count := 0
 	real := NewCachedGitConfig(
-		func(cmd *exec.Cmd) (string, error) {
+		func(key string) (string, error) {
 			count++
-			assert.Equal(t, "config --get --null commit.gpgsign", strings.Join(cmd.Args[1:], " "))
+			assert.Equal(t, "commit.gpgsign", key)
 			return "blah", nil
 		},
 		utils.NewDummyLog(),

pkg/commands/git_config/fake_git_config.go

@@ -17,13 +17,6 @@ func (self *FakeGitConfig) Get(key string) string {
 	return self.mockResponses[key]
 }
 
-func (self *FakeGitConfig) GetGeneral(args string) string {
-	if self.mockResponses == nil {
-		return ""
-	}
-	return self.mockResponses[args]
-}
-
 func (self *FakeGitConfig) GetBool(key string) bool {
 	return isTruthy(self.Get(key))
 }

pkg/commands/git_config/get_key.go

@@ -35,8 +35,10 @@ import (
 // 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 runGitConfigCmd(cmd *exec.Cmd) (string, error) {
+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
 
@@ -44,7 +46,7 @@ func runGitConfigCmd(cmd *exec.Cmd) (string, error) {
 	if exitError, ok := err.(*exec.ExitError); ok {
 		if waitStatus, ok := exitError.Sys().(syscall.WaitStatus); ok {
 			if waitStatus.ExitStatus() == 1 {
-				return "", fmt.Errorf("the key is not found for %s", cmd.Args)
+				return "", fmt.Errorf("the key `%s` is not found", key)
 			}
 		}
 		return "", err
@@ -52,13 +54,3 @@ func runGitConfigCmd(cmd *exec.Cmd) (string, error) {
 
 	return strings.TrimRight(stdout.String(), "\000"), nil
 }
-
-func getGitConfigCmd(key string) *exec.Cmd {
-	gitArgs := []string{"config", "--get", "--null", key}
-	return secureexec.Command("git", gitArgs...)
-}
-
-func getGitConfigGeneralCmd(args string) *exec.Cmd {
-	gitArgs := append([]string{"config"}, strings.Split(args, " ")...)
-	return secureexec.Command("git", gitArgs...)
-}

pkg/commands/git_test.go

@@ -104,7 +104,6 @@ func TestNavigateToRepoRootDirectory(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			s.test(navigateToRepoRootDirectory(s.stat, s.chdir))
 		})
@@ -160,7 +159,6 @@ func TestSetupRepository(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			s.test(setupRepository(s.openGitRepository, s.errorStr))
 		})
@@ -208,7 +206,6 @@ func TestNewGitCommand(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			s.setup()
 			s.test(NewGitCommand(utils.NewDummyCommon(), oscommands.NewDummyOSCommand(), git_config.NewFakeGitConfig(nil)))
@@ -285,7 +282,6 @@ func TestFindDotGitDir(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			s.test(findDotGitDir(s.stat, s.readFile))
 		})

pkg/commands/hosting_service/hosting_service.go

@@ -2,7 +2,6 @@ package hosting_service
 
 import (
 	"fmt"
-	"net/url"
 	"regexp"
 	"strings"
 
@@ -43,9 +42,9 @@ func (self *HostingServiceMgr) GetPullRequestURL(from string, to string) (string
 	}
 
 	if to == "" {
-		return gitService.getPullRequestURLIntoDefaultBranch(url.QueryEscape(from)), nil
+		return gitService.getPullRequestURLIntoDefaultBranch(from), nil
 	} else {
-		return gitService.getPullRequestURLIntoTargetBranch(url.QueryEscape(from), url.QueryEscape(to)), nil
+		return gitService.getPullRequestURLIntoTargetBranch(from, to), nil
 	}
 }
 
@@ -81,7 +80,9 @@ func (self *HostingServiceMgr) getServiceDomain(repoURL string) (*ServiceDomain,
 	candidateServiceDomains := self.getCandidateServiceDomains()
 
 	for _, serviceDomain := range candidateServiceDomains {
-		if strings.Contains(repoURL, serviceDomain.gitDomain) {
+		// 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
 		}
 	}

pkg/commands/hosting_service/hosting_service_test.go

@@ -56,7 +56,6 @@ func TestGetRepoInfoFromURL(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			result, err := s.serviceDefinition.getRepoInfoFromURL(s.repoURL)
 			assert.NoError(t, err)
@@ -83,7 +82,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			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%2Fprofile-page&t=1", url)
+				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page&t=1", url)
 			},
 		},
 		{
@@ -92,7 +91,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			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%2Fevents&t=1", url)
+				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/events&t=1", url)
 			},
 		},
 		{
@@ -101,7 +100,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			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%2Fsum-operation?expand=1", url)
+				assert.Equal(t, "https://github.com/peter/calculator/compare/feature/sum-operation?expand=1", url)
 			},
 		},
 		{
@@ -111,7 +110,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			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%2Fprofile-page%2Favatar&dest=feature%2Fprofile-page&t=1", url)
+				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page/avatar&dest=feature/profile-page&t=1", url)
 			},
 		},
 		{
@@ -121,7 +120,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			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%2Fremote-events&dest=feature%2Fevents&t=1", url)
+				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/remote-events&dest=feature/events&t=1", url)
 			},
 		},
 		{
@@ -131,7 +130,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			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%2Foperations...feature%2Fsum-operation?expand=1", url)
+				assert.Equal(t, "https://github.com/peter/calculator/compare/feature/operations...feature/sum-operation?expand=1", url)
 			},
 		},
 		{
@@ -140,7 +139,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			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%2Fui", url)
+				assert.Equal(t, "https://gitlab.com/peter/calculator/merge_requests/new?merge_request[source_branch]=feature/ui", url)
 			},
 		},
 		{
@@ -149,7 +148,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			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%2Fui", url)
+				assert.Equal(t, "https://gitlab.com/peter/public/calculator/merge_requests/new?merge_request[source_branch]=feature/ui", url)
 			},
 		},
 		{
@@ -159,7 +158,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			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%2Fcommit-ui&merge_request[target_branch]=epic%2Fui", url)
+				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)
 			},
 		},
 		{
@@ -169,7 +168,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			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%2Fcommit-ui&merge_request[target_branch]=epic%2Fui", url)
+				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)
 			},
 		},
 		{
@@ -190,7 +189,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			},
 			test: func(url string, err error) {
 				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature%2Fprofile-page&t=1", url)
+				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature/profile-page&t=1", url)
 			},
 			expectedLoggedErrors: nil,
 		},
@@ -203,7 +202,7 @@ func TestGetPullRequestURL(t *testing.T) {
 			},
 			test: func(url string, err error) {
 				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature%2Fprofile-page&t=1", url)
+				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'"},
 		},
@@ -216,34 +215,13 @@ func TestGetPullRequestURL(t *testing.T) {
 			},
 			test: func(url string, err error) {
 				assert.NoError(t, err)
-				assert.Equal(t, "https://bitbucket.org/johndoe/social_network/pull-requests/new?source=feature%2Fprofile-page&t=1", url)
+				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"},
 		},
-		{
-			testName:  "Escapes reserved URL characters in from branch name",
-			from:      "feature/someIssue#123",
-			to:        "master",
-			remoteUrl: "git@gitlab.com:me/public/repo-with-issues.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/me/public/repo-with-issues/merge_requests/new?merge_request[source_branch]=feature%2FsomeIssue%23123&merge_request[target_branch]=master", url)
-			},
-		},
-		{
-			testName:  "Escapes reserved URL characters in to branch name",
-			from:      "yolo",
-			to:        "archive/never-ending-feature#666",
-			remoteUrl: "git@gitlab.com:me/public/repo-with-issues.git",
-			test: func(url string, err error) {
-				assert.NoError(t, err)
-				assert.Equal(t, "https://gitlab.com/me/public/repo-with-issues/merge_requests/new?merge_request[source_branch]=yolo&merge_request[target_branch]=archive%2Fnever-ending-feature%23666", url)
-			},
-		},
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			tr := i18n.EnglishTranslationSet()
 			log := &test.FakeFieldLogger{}

pkg/commands/loaders/branches.go

@@ -4,7 +4,6 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/jesseduffield/go-git/v5/config"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
 	"github.com/jesseduffield/lazygit/pkg/common"
 	"github.com/jesseduffield/lazygit/pkg/utils"
@@ -21,34 +20,31 @@ import (
 // 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
 
-type BranchLoaderConfigCommands interface {
-	Branches() (map[string]*config.Branch, error)
-}
-
 // 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)
-	config               BranchLoaderConfigCommands
+}
+
+type BranchLoaderGitCommand interface {
+	GetRawBranches() (string, error)
+	CurrentBranchName() (string, string, error)
 }
 
 func NewBranchLoader(
 	cmn *common.Common,
-	getRawBranches func() (string, error),
-	getCurrentBranchName func() (string, string, error),
-	config BranchLoaderConfigCommands,
+	gitCommand BranchLoaderGitCommand,
 ) *BranchLoader {
 	return &BranchLoader{
 		Common:               cmn,
-		getRawBranches:       getRawBranches,
-		getCurrentBranchName: getCurrentBranchName,
-		config:               config,
+		getRawBranches:       gitCommand.GetRawBranches,
+		getCurrentBranchName: gitCommand.CurrentBranchName,
 	}
 }
 
 // Load the list of branches for the current repo
-func (self *BranchLoader) Load(reflogCommits []*models.Commit) ([]*models.Branch, error) {
+func (self *BranchLoader) Load(reflogCommits []*models.Commit) []*models.Branch {
 	branches := self.obtainBranches()
 
 	reflogBranches := self.obtainReflogBranches(reflogCommits)
@@ -85,25 +81,11 @@ outer:
 	if !foundHead {
 		currentBranchName, currentBranchDisplayName, err := self.getCurrentBranchName()
 		if err != nil {
-			return nil, err
+			panic(err)
 		}
 		branches = append([]*models.Branch{{Name: currentBranchName, DisplayName: currentBranchDisplayName, Head: true, Recency: "  *"}}, branches...)
 	}
-
-	configBranches, err := self.config.Branches()
-	if err != nil {
-		return nil, err
-	}
-
-	for _, branch := range branches {
-		match := configBranches[branch.Name]
-		if match != nil {
-			branch.UpstreamRemote = match.Remote
-			branch.UpstreamBranch = match.Merge.Short()
-		}
-	}
-
-	return branches, nil
+	return branches
 }
 
 func (self *BranchLoader) obtainBranches() []*models.Branch {
@@ -138,13 +120,12 @@ func (self *BranchLoader) obtainBranches() []*models.Branch {
 
 		upstreamName := split[2]
 		if upstreamName == "" {
-			// if we're here then it means we do not have a local version of the remote.
-			// The branch might still be tracking a remote though, we just don't know
-			// how many commits ahead/behind it is
 			branches = append(branches, branch)
 			continue
 		}
 
+		branch.UpstreamName = upstreamName
+
 		track := split[3]
 		re := regexp.MustCompile(`ahead (\d+)`)
 		match := re.FindStringSubmatch(track)

pkg/commands/loaders/commit_files.go

@@ -28,7 +28,7 @@ func (self *CommitFileLoader) GetFilesInDiff(from string, to string, reverse boo
 		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)).DontLog().RunWithOutput()
+	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
 	}

pkg/commands/loaders/commits.go

@@ -36,22 +36,26 @@ type CommitLoader struct {
 	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,
-	cmd oscommands.ICmdObjBuilder,
-	dotGitDir string,
-	getCurrentBranchName func() (string, string, error),
-	getRebaseMode func() (enums.RebaseMode, error),
+	gitCommand CommitLoaderGitCommand,
 ) *CommitLoader {
 	return &CommitLoader{
 		Common:               cmn,
-		cmd:                  cmd,
-		getCurrentBranchName: getCurrentBranchName,
-		getRebaseMode:        getRebaseMode,
+		cmd:                  gitCommand.GetCmd(),
+		getCurrentBranchName: gitCommand.CurrentBranchName,
+		getRebaseMode:        gitCommand.RebaseMode,
 		readFile:             ioutil.ReadFile,
 		walkFiles:            filepath.Walk,
-		dotGitDir:            dotGitDir,
+		dotGitDir:            gitCommand.GetDotGitDir(),
 	}
 }
 
@@ -214,7 +218,7 @@ func (self *CommitLoader) getHydratedRebasingCommits(rebaseMode enums.RebaseMode
 			prettyFormat,
 			20,
 		),
-	).DontLog()
+	)
 
 	hydratedCommits := make([]*models.Commit, 0, len(commits))
 	i := 0
@@ -274,7 +278,10 @@ func (self *CommitLoader) getNormalRebasingCommits() ([]*models.Commit, error) {
 			return err
 		}
 		content := string(bytesContent)
-		commit := self.commitFromPatch(content)
+		commit, err := self.commitFromPatch(content)
+		if err != nil {
+			return err
+		}
 		commits = append([]*models.Commit{commit}, commits...)
 		return nil
 	})
@@ -331,7 +338,7 @@ func (self *CommitLoader) getInteractiveRebasingCommits() ([]*models.Commit, err
 // 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 {
+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: ")
@@ -339,7 +346,7 @@ func (self *CommitLoader) commitFromPatch(content string) *models.Commit {
 		Sha:    sha,
 		Name:   name,
 		Status: "rebasing",
-	}
+	}, nil
 }
 
 func (self *CommitLoader) setCommitMergedStatuses(refName string, commits []*models.Commit) ([]*models.Commit, error) {
@@ -377,7 +384,7 @@ func (self *CommitLoader) getMergeBase(refName string) (string, error) {
 	}
 
 	// 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))).DontLog().RunWithOutput()
+	output, _ := self.cmd.New(fmt.Sprintf("git merge-base %s %s", self.cmd.Quote(refName), self.cmd.Quote(baseBranch))).RunWithOutput()
 	return ignoringWarnings(output), nil
 }
 
@@ -398,7 +405,6 @@ func (self *CommitLoader) getFirstPushedCommit(refName string) (string, error) {
 		New(
 			fmt.Sprintf("git merge-base %s %s@{u}", self.cmd.Quote(refName), self.cmd.Quote(refName)),
 		).
-		DontLog().
 		RunWithOutput()
 	if err != nil {
 		return "", err
@@ -438,7 +444,7 @@ func (self *CommitLoader) getLogCmd(opts GetCommitsOptions) oscommands.ICmdObj {
 			20,
 			filterFlag,
 		),
-	).DontLog()
+	)
 }
 
 var prettyFormat = fmt.Sprintf(

pkg/commands/loaders/commits_test.go

@@ -41,7 +41,7 @@ d8084cd558925eb7c9c38afeed5725c21653ab90|1640821426|Jesse Duffield||65f910ebd852
 func TestGetCommits(t *testing.T) {
 	type scenario struct {
 		testName          string
-		runner            *oscommands.FakeCmdObjRunner
+		runner            oscommands.ICmdObjRunner
 		expectedCommits   []*models.Commit
 		expectedError     error
 		rebaseMode        enums.RebaseMode
@@ -186,7 +186,6 @@ func TestGetCommits(t *testing.T) {
 	}
 
 	for _, scenario := range scenarios {
-		scenario := scenario
 		t.Run(scenario.testName, func(t *testing.T) {
 			builder := &CommitLoader{
 				Common: utils.NewDummyCommon(),
@@ -208,8 +207,6 @@ func TestGetCommits(t *testing.T) {
 
 			assert.Equal(t, scenario.expectedCommits, commits)
 			assert.Equal(t, scenario.expectedError, err)
-
-			scenario.runner.CheckForMissingCalls()
 		})
 	}
 }

pkg/commands/loaders/files.go

@@ -4,29 +4,26 @@ 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 FileLoaderConfig interface {
-	GetShowUntrackedFiles() string
-}
-
 type FileLoader struct {
 	*common.Common
 	cmd         oscommands.ICmdObjBuilder
-	config      FileLoaderConfig
+	gitConfig   git_config.IGitConfig
 	getFileType func(string) string
 }
 
-func NewFileLoader(cmn *common.Common, cmd oscommands.ICmdObjBuilder, config FileLoaderConfig) *FileLoader {
+func NewFileLoader(cmn *common.Common, cmd oscommands.ICmdObjBuilder, gitConfig git_config.IGitConfig) *FileLoader {
 	return &FileLoader{
 		Common:      cmn,
 		cmd:         cmd,
+		gitConfig:   gitConfig,
 		getFileType: oscommands.FileType,
-		config:      config,
 	}
 }
 
@@ -36,7 +33,7 @@ type GetStatusFileOptions struct {
 
 func (self *FileLoader) GetStatusFiles(opts GetStatusFileOptions) []*models.File {
 	// check if config wants us ignoring untracked files
-	untrackedFilesSetting := self.config.GetShowUntrackedFiles()
+	untrackedFilesSetting := self.gitConfig.Get("status.showUntrackedFiles")
 
 	if untrackedFilesSetting == "" {
 		untrackedFilesSetting = "all"
@@ -59,8 +56,8 @@ func (self *FileLoader) GetStatusFiles(opts GetStatusFileOptions) []*models.File
 		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)
-		hasMergeConflicts := hasInlineMergeConflicts || utils.IncludesString([]string{"DD", "AU", "UA", "UD", "DU"}, change)
 
 		file := &models.File{
 			Name:                    status.Name,
@@ -101,7 +98,7 @@ func (c *FileLoader) GitStatus(opts GitStatusOptions) ([]FileStatus, error) {
 		noRenamesFlag = " --no-renames"
 	}
 
-	statusLines, err := c.cmd.New(fmt.Sprintf("git status %s --porcelain -z%s", opts.UntrackedFilesArg, noRenamesFlag)).DontLog().RunWithOutput()
+	statusLines, err := c.cmd.New(fmt.Sprintf("git status %s --porcelain -z%s", opts.UntrackedFilesArg, noRenamesFlag)).RunWithOutput()
 	if err != nil {
 		return []FileStatus{}, err
 	}

pkg/commands/loaders/files_test.go

@@ -3,13 +3,14 @@ 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 TestFileGetStatusFiles(t *testing.T) {
+func TestGitCommandGetStatusFiles(t *testing.T) {
 	type scenario struct {
 		testName      string
 		runner        oscommands.ICmdObjRunner
@@ -185,14 +186,14 @@ func TestFileGetStatusFiles(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		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,
-				config:      &FakeFileLoaderConfig{showUntrackedFiles: "yes"},
+				gitConfig:   gitConfig,
 				getFileType: func(string) string { return "file" },
 			}
 
@@ -200,11 +201,3 @@ func TestFileGetStatusFiles(t *testing.T) {
 		})
 	}
 }
-
-type FakeFileLoaderConfig struct {
-	showUntrackedFiles string
-}
-
-func (self *FakeFileLoaderConfig) GetShowUntrackedFiles() string {
-	return self.showUntrackedFiles
-}

pkg/commands/loaders/reflog_commits.go

@@ -32,7 +32,7 @@ func (self *ReflogCommitLoader) GetReflogCommits(lastReflogCommit *models.Commit
 		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)).DontLog()
+	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)
@@ -49,11 +49,7 @@ func (self *ReflogCommitLoader) GetReflogCommits(lastReflogCommit *models.Commit
 			Status:        "reflog",
 		}
 
-		// note that the unix timestamp here is the timestamp of the COMMIT, not the reflog entry itself,
-		// so two consequetive reflog entries may have both the same SHA and therefore same timestamp.
-		// We use the reflog message to disambiguate, and fingers crossed that we never see the same of those
-		// twice in a row. Reason being that it would mean we'd be erroneously exiting early.
-		if lastReflogCommit != nil && commit.Sha == lastReflogCommit.Sha && commit.UnixTimestamp == lastReflogCommit.UnixTimestamp && commit.Name == lastReflogCommit.Name {
+		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

pkg/commands/loaders/reflog_commits_test.go

@@ -1,159 +0,0 @@
-package loaders
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/jesseduffield/lazygit/pkg/commands/models"
-	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-	"github.com/sanity-io/litter"
-	"github.com/stretchr/testify/assert"
-)
-
-const reflogOutput = `c3c4b66b64c97ffeecde 1643150483 checkout: moving from A to B
-c3c4b66b64c97ffeecde 1643150483 checkout: moving from B to A
-c3c4b66b64c97ffeecde 1643150483 checkout: moving from A to B
-c3c4b66b64c97ffeecde 1643150483 checkout: moving from master to A
-f4ddf2f0d4be4ccc7efa 1643149435 checkout: moving from A to master
-`
-
-func TestGetReflogCommits(t *testing.T) {
-	type scenario struct {
-		testName                string
-		runner                  *oscommands.FakeCmdObjRunner
-		lastReflogCommit        *models.Commit
-		filterPath              string
-		expectedCommits         []*models.Commit
-		expectedOnlyObtainedNew bool
-		expectedError           error
-	}
-
-	scenarios := []scenario{
-		{
-			testName: "no reflog entries",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git log -g --abbrev=20 --format="%h %ct %gs"`, "", nil),
-
-			lastReflogCommit:        nil,
-			expectedCommits:         []*models.Commit{},
-			expectedOnlyObtainedNew: false,
-			expectedError:           nil,
-		},
-		{
-			testName: "some reflog entries",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git log -g --abbrev=20 --format="%h %ct %gs"`, reflogOutput, nil),
-
-			lastReflogCommit: nil,
-			expectedCommits: []*models.Commit{
-				{
-					Sha:           "c3c4b66b64c97ffeecde",
-					Name:          "checkout: moving from A to B",
-					Status:        "reflog",
-					UnixTimestamp: 1643150483,
-				},
-				{
-					Sha:           "c3c4b66b64c97ffeecde",
-					Name:          "checkout: moving from B to A",
-					Status:        "reflog",
-					UnixTimestamp: 1643150483,
-				},
-				{
-					Sha:           "c3c4b66b64c97ffeecde",
-					Name:          "checkout: moving from A to B",
-					Status:        "reflog",
-					UnixTimestamp: 1643150483,
-				},
-				{
-					Sha:           "c3c4b66b64c97ffeecde",
-					Name:          "checkout: moving from master to A",
-					Status:        "reflog",
-					UnixTimestamp: 1643150483,
-				},
-				{
-					Sha:           "f4ddf2f0d4be4ccc7efa",
-					Name:          "checkout: moving from A to master",
-					Status:        "reflog",
-					UnixTimestamp: 1643149435,
-				},
-			},
-			expectedOnlyObtainedNew: false,
-			expectedError:           nil,
-		},
-		{
-			testName: "some reflog entries where last commit is given",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git log -g --abbrev=20 --format="%h %ct %gs"`, reflogOutput, nil),
-
-			lastReflogCommit: &models.Commit{
-				Sha:           "c3c4b66b64c97ffeecde",
-				Name:          "checkout: moving from B to A",
-				Status:        "reflog",
-				UnixTimestamp: 1643150483,
-			},
-			expectedCommits: []*models.Commit{
-				{
-					Sha:           "c3c4b66b64c97ffeecde",
-					Name:          "checkout: moving from A to B",
-					Status:        "reflog",
-					UnixTimestamp: 1643150483,
-				},
-			},
-			expectedOnlyObtainedNew: true,
-			expectedError:           nil,
-		},
-		{
-			testName: "when passing filterPath",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git log -g --abbrev=20 --format="%h %ct %gs" --follow -- "path"`, reflogOutput, nil),
-
-			lastReflogCommit: &models.Commit{
-				Sha:           "c3c4b66b64c97ffeecde",
-				Name:          "checkout: moving from B to A",
-				Status:        "reflog",
-				UnixTimestamp: 1643150483,
-			},
-			filterPath: "path",
-			expectedCommits: []*models.Commit{
-				{
-					Sha:           "c3c4b66b64c97ffeecde",
-					Name:          "checkout: moving from A to B",
-					Status:        "reflog",
-					UnixTimestamp: 1643150483,
-				},
-			},
-			expectedOnlyObtainedNew: true,
-			expectedError:           nil,
-		},
-		{
-			testName: "when command returns error",
-			runner: oscommands.NewFakeRunner(t).
-				Expect(`git log -g --abbrev=20 --format="%h %ct %gs"`, "", errors.New("haha")),
-
-			lastReflogCommit:        nil,
-			filterPath:              "",
-			expectedCommits:         nil,
-			expectedOnlyObtainedNew: false,
-			expectedError:           errors.New("haha"),
-		},
-	}
-
-	for _, scenario := range scenarios {
-		scenario := scenario
-		t.Run(scenario.testName, func(t *testing.T) {
-			builder := &ReflogCommitLoader{
-				Common: utils.NewDummyCommon(),
-				cmd:    oscommands.NewDummyCmdObjBuilder(scenario.runner),
-			}
-
-			commits, onlyObtainednew, err := builder.GetReflogCommits(scenario.lastReflogCommit, scenario.filterPath)
-			assert.Equal(t, scenario.expectedOnlyObtainedNew, onlyObtainednew)
-			assert.Equal(t, scenario.expectedError, err)
-			t.Logf("actual commits: \n%s", litter.Sdump(commits))
-			assert.Equal(t, scenario.expectedCommits, commits)
-
-			scenario.runner.CheckForMissingCalls()
-		})
-	}
-}

pkg/commands/loaders/remotes.go

@@ -31,7 +31,7 @@ func NewRemoteLoader(
 }
 
 func (self *RemoteLoader) GetRemotes() ([]*models.Remote, error) {
-	remoteBranchesStr, err := self.cmd.New("git branch -r").DontLog().RunWithOutput()
+	remoteBranchesStr, err := self.cmd.New("git branch -r").RunWithOutput()
 	if err != nil {
 		return nil, err
 	}

pkg/commands/loaders/stash.go

@@ -31,7 +31,7 @@ func (self *StashLoader) GetStashEntries(filterPath string) []*models.StashEntry
 		return self.getUnfilteredStashEntries()
 	}
 
-	rawString, err := self.cmd.New("git stash list --name-only").DontLog().RunWithOutput()
+	rawString, err := self.cmd.New("git stash list --name-only").RunWithOutput()
 	if err != nil {
 		return self.getUnfilteredStashEntries()
 	}
@@ -64,7 +64,7 @@ outer:
 }
 
 func (self *StashLoader) getUnfilteredStashEntries() []*models.StashEntry {
-	rawString, _ := self.cmd.New("git stash list --pretty='%gs'").DontLog().RunWithOutput()
+	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))

pkg/commands/loaders/stash_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func TestGetStashEntries(t *testing.T) {
+func TestGitCommandGetStashEntries(t *testing.T) {
 	type scenario struct {
 		testName             string
 		filterPath           string
@@ -48,13 +48,12 @@ func TestGetStashEntries(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		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(s.filterPath))
+			assert.EqualValues(t, s.expectedStashEntries, loader.GetStashEntries(""))
 		})
 	}
 }

pkg/commands/loaders/tags.go

@@ -27,7 +27,7 @@ func NewTagLoader(
 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`).DontLog().RunWithOutput()
+	remoteBranchesStr, err := self.cmd.New(`git tag --list --sort=-creatordate`).RunWithOutput()
 	if err != nil {
 		return nil, err
 	}

pkg/commands/models/branch.go

@@ -5,16 +5,12 @@ package models
 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
-	Head        bool
-	// if we have a named remote locally this will be the name of that remote e.g.
-	// 'origin' or 'tiwood'. If we don't have the remote locally it'll look like
-	// 'git@github.com:tiwood/lazygit.git'
-	UpstreamRemote string
-	UpstreamBranch string
+	DisplayName  string
+	Recency      string
+	Pushables    string
+	Pullables    string
+	UpstreamName string
+	Head         bool
 }
 
 func (b *Branch) RefName() string {
@@ -29,26 +25,22 @@ 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.UpstreamRemote != ""
-}
-
-// we know that the remote branch is not stored locally based on our pushable/pullable
-// count being question marks.
-func (b *Branch) RemoteBranchStoredLocally() bool {
-	return b.IsTrackingRemote() && b.Pushables != "?" && b.Pullables != "?"
+	return b.IsRealBranch() && b.Pullables != "?"
 }
 
 func (b *Branch) MatchesUpstream() bool {
-	return b.RemoteBranchStoredLocally() && b.Pushables == "0" && b.Pullables == "0"
+	return b.IsRealBranch() && b.Pushables == "0" && b.Pullables == "0"
 }
 
 func (b *Branch) HasCommitsToPush() bool {
-	return b.RemoteBranchStoredLocally() && b.Pushables != "0"
+	return b.IsRealBranch() && b.Pushables != "0"
 }
 
 func (b *Branch) HasCommitsToPull() bool {
-	return b.RemoteBranchStoredLocally() && b.Pullables != "0"
+	return b.IsRealBranch() && b.Pullables != "0"
 }
 
 // for when we're in a detached head state

pkg/commands/models/commit.go

@@ -1,10 +1,6 @@
 package models
 
-import (
-	"fmt"
-
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
+import "fmt"
 
 // Commit : A git commit
 type Commit struct {
@@ -22,7 +18,10 @@ type Commit struct {
 }
 
 func (c *Commit) ShortSha() string {
-	return utils.ShortSha(c.Sha)
+	if len(c.Sha) < 8 {
+		return c.Sha
+	}
+	return c.Sha[:8]
 }
 
 func (c *Commit) RefName() string {
@@ -40,9 +39,3 @@ func (c *Commit) Description() string {
 func (c *Commit) IsMerge() bool {
 	return len(c.Parents) > 1
 }
-
-// returns true if this commit is not actually in the git log but instead
-// is from a TODO file for an interactive rebase.
-func (c *Commit) IsTODO() bool {
-	return c.Action != ""
-}

pkg/commands/oscommands/cmd_obj.go

@@ -12,7 +12,6 @@ type ICmdObj interface {
 	// 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
 
@@ -23,72 +22,18 @@ type ICmdObj interface {
 	// 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
 
-	// Be calling DontLog(), we're saying that once we call Run(), we don't want to
-	// log the command in the UI (it'll still be logged in the log file). The general rule
-	// is that if a command doesn't change the git state (e.g. read commands like `git diff`)
-	// then we don't want to log it. If we are changing something (e.g. `git add .`) then
-	// we do. The only exception is if we're running a command in the background periodically
-	// like `git fetch`, which technically does mutate stuff but isn't something we need
-	// to notify the user about.
-	DontLog() ICmdObj
-
-	// This returns false if DontLog() was called
-	ShouldLog() bool
-
-	// when you call this, then call Run(), we'll stream the output to the cmdWriter (i.e. the command log panel)
-	StreamOutput() ICmdObj
-	// returns true if StreamOutput() was called
-	ShouldStreamOutput() bool
-
-	// if you call this before ShouldStreamOutput we'll consider an error with no
-	// stderr content as a non-error. Not yet supported for Run or RunWithOutput (
-	// but adding support is trivial)
-	IgnoreEmptyError() ICmdObj
-	// returns true if IgnoreEmptyError() was called
-	ShouldIgnoreEmptyError() bool
-
-	PromptOnCredentialRequest() ICmdObj
-	FailOnCredentialRequest() ICmdObj
-
-	GetCredentialStrategy() CredentialStrategy
+	// logs command
+	Log() ICmdObj
 }
 
 type CmdObj struct {
 	cmdStr string
 	cmd    *exec.Cmd
 
-	runner ICmdObjRunner
-
-	// see DontLog()
-	dontLog bool
-
-	// see StreamOutput()
-	streamOutput bool
-
-	// see IgnoreEmptyError()
-	ignoreEmptyError bool
-
-	// if set to true, it means we might be asked to enter a username/password by this command.
-	credentialStrategy CredentialStrategy
+	runner     ICmdObjRunner
+	logCommand func(ICmdObj)
 }
 
-type CredentialStrategy int
-
-const (
-	// do not expect a credential request. If we end up getting one
-	// we'll be in trouble because the command will hang indefinitely
-	NONE CredentialStrategy = iota
-	// expect a credential request and if we get one, prompt the user to enter their username/password
-	PROMPT
-	// in this case we will check for a credential request (i.e. the command pauses to ask for
-	// username/password) and if we get one, we just submit a newline, forcing the
-	// command to fail. We use this e.g. for a background `git fetch` to prevent it
-	// from hanging indefinitely.
-	FAIL
-)
-
-var _ ICmdObj = &CmdObj{}
-
 func (self *CmdObj) GetCmd() *exec.Cmd {
 	return self.cmd
 }
@@ -107,35 +52,12 @@ func (self *CmdObj) GetEnvVars() []string {
 	return self.cmd.Env
 }
 
-func (self *CmdObj) DontLog() ICmdObj {
-	self.dontLog = true
-	return self
-}
-
-func (self *CmdObj) ShouldLog() bool {
-	return !self.dontLog
-}
-
-func (self *CmdObj) StreamOutput() ICmdObj {
-	self.streamOutput = true
+func (self *CmdObj) Log() ICmdObj {
+	self.logCommand(self)
 
 	return self
 }
 
-func (self *CmdObj) ShouldStreamOutput() bool {
-	return self.streamOutput
-}
-
-func (self *CmdObj) IgnoreEmptyError() ICmdObj {
-	self.ignoreEmptyError = true
-
-	return self
-}
-
-func (self *CmdObj) ShouldIgnoreEmptyError() bool {
-	return self.ignoreEmptyError
-}
-
 func (self *CmdObj) Run() error {
 	return self.runner.Run(self)
 }
@@ -147,19 +69,3 @@ func (self *CmdObj) RunWithOutput() (string, error) {
 func (self *CmdObj) RunAndProcessLines(onLine func(line string) (bool, error)) error {
 	return self.runner.RunAndProcessLines(self, onLine)
 }
-
-func (self *CmdObj) PromptOnCredentialRequest() ICmdObj {
-	self.credentialStrategy = PROMPT
-
-	return self
-}
-
-func (self *CmdObj) FailOnCredentialRequest() ICmdObj {
-	self.credentialStrategy = FAIL
-
-	return self
-}
-
-func (self *CmdObj) GetCredentialStrategy() CredentialStrategy {
-	return self.credentialStrategy
-}

pkg/commands/oscommands/cmd_obj_builder.go

@@ -1,7 +1,6 @@
 package oscommands
 
 import (
-	"fmt"
 	"os"
 	"strings"
 
@@ -21,8 +20,9 @@ type ICmdObjBuilder interface {
 }
 
 type CmdObjBuilder struct {
-	runner   ICmdObjRunner
-	platform *Platform
+	runner    ICmdObjRunner
+	logCmdObj func(ICmdObj)
+	platform  *Platform
 }
 
 // poor man's version of explicitly saying that struct X implements interface Y
@@ -34,9 +34,10 @@ func (self *CmdObjBuilder) New(cmdStr string) ICmdObj {
 	cmd.Env = os.Environ()
 
 	return &CmdObj{
-		cmdStr: cmdStr,
-		cmd:    cmd,
-		runner: self.runner,
+		cmdStr:     cmdStr,
+		cmd:        cmd,
+		runner:     self.runner,
+		logCommand: self.logCmdObj,
 	}
 }
 
@@ -45,57 +46,23 @@ func (self *CmdObjBuilder) NewFromArgs(args []string) ICmdObj {
 	cmd.Env = os.Environ()
 
 	return &CmdObj{
-		cmdStr: strings.Join(args, " "),
-		cmd:    cmd,
-		runner: self.runner,
+		cmdStr:     strings.Join(args, " "),
+		cmd:        cmd,
+		runner:     self.runner,
+		logCommand: self.logCmdObj,
 	}
 }
 
 func (self *CmdObjBuilder) NewShell(commandStr string) ICmdObj {
-	quotedCommand := ""
-	// Windows does not seem to like quotes around the command
-	if self.platform.OS == "windows" {
-		quotedCommand = strings.NewReplacer(
-			"^", "^^",
-			"&", "^&",
-			"|", "^|",
-			"<", "^<",
-			">", "^>",
-			"%", "^%",
-		).Replace(commandStr)
-	} else {
-		quotedCommand = self.Quote(commandStr)
-	}
-
-	shellCommand := fmt.Sprintf("%s %s %s", self.platform.Shell, self.platform.ShellArg, quotedCommand)
-	return self.New(shellCommand)
+	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,
-		platform: self.platform,
+		runner:    decoratedRunner,
+		logCmdObj: self.logCmdObj,
+		platform:  self.platform,
 	}
 }
-
-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
-}

pkg/commands/oscommands/cmd_obj_runner.go

@@ -2,10 +2,6 @@ package oscommands
 
 import (
 	"bufio"
-	"bytes"
-	"io"
-	"regexp"
-	"strings"
 
 	"github.com/go-errors/errors"
 	"github.com/jesseduffield/lazygit/pkg/utils"
@@ -18,57 +14,20 @@ type ICmdObjRunner interface {
 	RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error
 }
 
-type CredentialType int
-
-const (
-	Password CredentialType = iota
-	Username
-	Passphrase
-)
-
 type cmdObjRunner struct {
-	log   *logrus.Entry
-	guiIO *guiIO
+	log       *logrus.Entry
+	logCmdObj func(ICmdObj)
 }
 
 var _ ICmdObjRunner = &cmdObjRunner{}
 
 func (self *cmdObjRunner) Run(cmdObj ICmdObj) error {
-	if cmdObj.GetCredentialStrategy() != NONE {
-		return self.runWithCredentialHandling(cmdObj)
-	}
-
-	if cmdObj.ShouldStreamOutput() {
-		return self.runAndStream(cmdObj)
-	}
-
 	_, err := self.RunWithOutput(cmdObj)
 	return err
 }
 
 func (self *cmdObjRunner) RunWithOutput(cmdObj ICmdObj) (string, error) {
-	if cmdObj.ShouldStreamOutput() {
-		err := self.runAndStream(cmdObj)
-		// for now we're not capturing output, just because it would take a little more
-		// effort and there's currently no use case for it. Some commands call RunWithOutput
-		// but ignore the output, hence why we've got this check here.
-		return "", err
-	}
-
-	if cmdObj.GetCredentialStrategy() != NONE {
-		err := self.runWithCredentialHandling(cmdObj)
-		// for now we're not capturing output, just because it would take a little more
-		// effort and there's currently no use case for it. Some commands call RunWithOutput
-		// but ignore the output, hence why we've got this check here.
-		return "", err
-	}
-
-	self.log.WithField("command", cmdObj.ToString()).Debug("RunCommand")
-
-	if cmdObj.ShouldLog() {
-		self.logCmdObj(cmdObj)
-	}
-
+	self.logCmdObj(cmdObj)
 	output, err := sanitisedCommandOutput(cmdObj.GetCmd().CombinedOutput())
 	if err != nil {
 		self.log.WithField("command", cmdObj.ToString()).Error(output)
@@ -77,14 +36,6 @@ func (self *cmdObjRunner) RunWithOutput(cmdObj ICmdObj) (string, error) {
 }
 
 func (self *cmdObjRunner) RunAndProcessLines(cmdObj ICmdObj, onLine func(line string) (bool, error)) error {
-	if cmdObj.GetCredentialStrategy() != NONE {
-		return errors.New("cannot call RunAndProcessLines with credential strategy. If you're seeing this then a contributor to Lazygit has accidentally called this method! Please raise an issue")
-	}
-
-	if cmdObj.ShouldLog() {
-		self.logCmdObj(cmdObj)
-	}
-
 	cmd := cmdObj.GetCmd()
 	stdoutPipe, err := cmd.StdoutPipe()
 	if err != nil {
@@ -114,30 +65,6 @@ func (self *cmdObjRunner) RunAndProcessLines(cmdObj ICmdObj, onLine func(line st
 	return nil
 }
 
-// Whenever we're asked for a password we just enter a newline, which will
-// eventually cause the command to fail.
-var failPromptFn = func(CredentialType) string { return "\n" }
-
-func (self *cmdObjRunner) runWithCredentialHandling(cmdObj ICmdObj) error {
-	var promptFn func(CredentialType) string
-
-	switch cmdObj.GetCredentialStrategy() {
-	case PROMPT:
-		promptFn = self.guiIO.promptForCredentialFn
-	case FAIL:
-		promptFn = failPromptFn
-	case NONE:
-		// we should never land here
-		return errors.New("runWithCredentialHandling called but cmdObj does not have a a credential strategy")
-	}
-
-	return self.runAndDetectCredentialRequest(cmdObj, promptFn)
-}
-
-func (self *cmdObjRunner) logCmdObj(cmdObj ICmdObj) {
-	self.guiIO.logCommandFn(cmdObj.ToString(), true)
-}
-
 func sanitisedCommandOutput(output []byte, err error) (string, error) {
 	outputString := string(output)
 	if err != nil {
@@ -150,123 +77,3 @@ func sanitisedCommandOutput(output []byte, err error) (string, error) {
 	}
 	return outputString, nil
 }
-
-type cmdHandler struct {
-	stdoutPipe io.Reader
-	stdinPipe  io.Writer
-	close      func() error
-}
-
-func (self *cmdObjRunner) runAndStream(cmdObj ICmdObj) error {
-	return self.runAndStreamAux(cmdObj, func(handler *cmdHandler, cmdWriter io.Writer) {
-		go func() {
-			_, _ = io.Copy(cmdWriter, handler.stdoutPipe)
-		}()
-	})
-}
-
-// runAndDetectCredentialRequest 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 (self *cmdObjRunner) runAndDetectCredentialRequest(
-	cmdObj ICmdObj,
-	promptUserForCredential func(CredentialType) string,
-) error {
-	// setting the output to english so we can parse it for a username/password request
-	cmdObj.AddEnvVars("LANG=en_US.UTF-8", "LC_ALL=en_US.UTF-8")
-
-	return self.runAndStreamAux(cmdObj, func(handler *cmdHandler, cmdWriter io.Writer) {
-		tr := io.TeeReader(handler.stdoutPipe, cmdWriter)
-
-		go utils.Safe(func() {
-			self.processOutput(tr, handler.stdinPipe, promptUserForCredential)
-		})
-	})
-}
-
-func (self *cmdObjRunner) runAndStreamAux(
-	cmdObj ICmdObj,
-	onRun func(*cmdHandler, io.Writer),
-) error {
-	cmdWriter := self.guiIO.newCmdWriterFn()
-
-	if cmdObj.ShouldLog() {
-		self.logCmdObj(cmdObj)
-	}
-	self.log.WithField("command", cmdObj.ToString()).Info("RunCommand")
-	cmd := cmdObj.GetCmd()
-
-	var stderr bytes.Buffer
-	cmd.Stderr = io.MultiWriter(cmdWriter, &stderr)
-
-	handler, err := self.getCmdHandler(cmd)
-	if err != nil {
-		return err
-	}
-
-	defer func() {
-		if closeErr := handler.close(); closeErr != nil {
-			self.log.Error(closeErr)
-		}
-	}()
-
-	onRun(handler, cmdWriter)
-
-	err = cmd.Wait()
-	if err != nil {
-		errStr := stderr.String()
-		if cmdObj.ShouldIgnoreEmptyError() && errStr == "" {
-			return nil
-		}
-		return errors.New(stderr.String())
-	}
-
-	return nil
-}
-
-func (self *cmdObjRunner) processOutput(reader io.Reader, writer io.Writer, promptUserForCredential func(CredentialType) string) {
-	checkForCredentialRequest := self.getCheckForCredentialRequestFunc()
-
-	scanner := bufio.NewScanner(reader)
-	scanner.Split(bufio.ScanBytes)
-	for scanner.Scan() {
-		newBytes := scanner.Bytes()
-		askFor, ok := checkForCredentialRequest(newBytes)
-		if ok {
-			toInput := promptUserForCredential(askFor)
-			// If the return data is empty we don't write anything to stdin
-			if toInput != "" {
-				_, _ = writer.Write([]byte(toInput))
-			}
-		}
-	}
-}
-
-// having a function that returns a function because we need to maintain some state inbetween calls hence the closure
-func (self *cmdObjRunner) getCheckForCredentialRequestFunc() func([]byte) (CredentialType, bool) {
-	var ttyText strings.Builder
-	// this function takes each word of output from the command and builds up a string to see if we're being asked for a password
-	return func(newBytes []byte) (CredentialType, bool) {
-		_, err := ttyText.Write(newBytes)
-		if err != nil {
-			self.log.Error(err)
-		}
-
-		prompts := map[string]CredentialType{
-			`Password:`:                              Password,
-			`.+'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.String()); match {
-				ttyText.Reset()
-				return askFor, true
-			}
-		}
-
-		return 0, false
-	}
-}

pkg/commands/oscommands/cmd_obj_runner_default.go

@@ -1,25 +0,0 @@
-//go:build !windows
-// +build !windows
-
-package oscommands
-
-import (
-	"os/exec"
-
-	"github.com/creack/pty"
-)
-
-// we define this separately for windows and non-windows given that windows does
-// not have great PTY support and we need a PTY to handle a credential request
-func (self *cmdObjRunner) getCmdHandler(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/cmd_obj_runner_win.go

@@ -1,49 +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)
-}
-
-// 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 (self *cmdObjRunner) getCmdHandler(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/dummies.go

@@ -1,62 +1,30 @@
 package oscommands
 
 import (
-	"github.com/jesseduffield/lazygit/pkg/common"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
 
 // NewDummyOSCommand creates a new dummy OSCommand for testing
 func NewDummyOSCommand() *OSCommand {
-	osCmd := NewOSCommand(utils.NewDummyCommon(), dummyPlatform, NewNullGuiIO(utils.NewDummyLog()))
-
-	return osCmd
-}
-
-type OSCommandDeps struct {
-	Common       *common.Common
-	Platform     *Platform
-	GetenvFn     func(string) string
-	RemoveFileFn func(string) error
-	Cmd          *CmdObjBuilder
-}
-
-func NewDummyOSCommandWithDeps(deps OSCommandDeps) *OSCommand {
-	common := deps.Common
-	if common == nil {
-		common = utils.NewDummyCommon()
-	}
-
-	platform := deps.Platform
-	if platform == nil {
-		platform = dummyPlatform
-	}
-
-	return &OSCommand{
-		Common:       common,
-		Platform:     platform,
-		getenvFn:     deps.GetenvFn,
-		removeFileFn: deps.RemoveFileFn,
-		guiIO:        NewNullGuiIO(utils.NewDummyLog()),
-	}
+	return NewOSCommand(utils.NewDummyCommon())
 }
 
 func NewDummyCmdObjBuilder(runner ICmdObjRunner) *CmdObjBuilder {
 	return &CmdObjBuilder{
-		runner:   runner,
-		platform: dummyPlatform,
+		runner:    runner,
+		logCmdObj: func(ICmdObj) {},
+		platform: &Platform{
+			OS:              "darwin",
+			Shell:           "bash",
+			ShellArg:        "-c",
+			OpenCommand:     "open {{filename}}",
+			OpenLinkCommand: "open {{link}}",
+		},
 	}
 }
 
-var dummyPlatform = &Platform{
-	OS:              "darwin",
-	Shell:           "bash",
-	ShellArg:        "-c",
-	OpenCommand:     "open {{filename}}",
-	OpenLinkCommand: "open {{link}}",
-}
-
 func NewDummyOSCommandWithRunner(runner *FakeCmdObjRunner) *OSCommand {
-	osCommand := NewOSCommand(utils.NewDummyCommon(), dummyPlatform, NewNullGuiIO(utils.NewDummyLog()))
+	osCommand := NewOSCommand(utils.NewDummyCommon())
 	osCommand.Cmd = NewDummyCmdObjBuilder(runner)
 
 	return osCommand

pkg/commands/oscommands/exec_live.go

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

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

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

@@ -3,7 +3,6 @@ package oscommands
 import (
 	"bufio"
 	"fmt"
-	"regexp"
 	"strings"
 	"testing"
 
@@ -94,24 +93,10 @@ func (self *FakeCmdObjRunner) ExpectArgs(expectedArgs []string, output string, e
 	return self
 }
 
-func (self *FakeCmdObjRunner) ExpectGitArgs(expectedArgs []string, output string, err error) *FakeCmdObjRunner {
-	self.ExpectFunc(func(cmdObj ICmdObj) (string, error) {
-		// first arg is 'git' on unix and something like '"C:\\Program Files\\Git\\mingw64\\bin\\git.exe" on windows so we'll just ensure it ends in either 'git' or 'git.exe'
-		re := regexp.MustCompile(`git(\.exe)?$`)
-		args := cmdObj.GetCmd().Args
-		if !re.MatchString(args[0]) {
-			self.t.Errorf("expected first arg to end in .git or .git.exe but was %s", args[0])
-		}
-		assert.EqualValues(self.t, expectedArgs, args[1:], 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/gui_io.go

@@ -1,51 +0,0 @@
-package oscommands
-
-import (
-	"io"
-	"io/ioutil"
-
-	"github.com/sirupsen/logrus"
-)
-
-// this struct captures some IO stuff
-type guiIO struct {
-	// this is for logging anything we want. It'll be written to a log file for the sake
-	// of debugging.
-	log *logrus.Entry
-
-	// this is for us to log the command we're about to run e.g. 'git push'. The GUI
-	// will write this to a log panel so that the user can see which commands are being
-	// run.
-	// The isCommandLineCommand arg is there so that we can style the log differently
-	// depending on whether we're directly outputting a command we're about to run that
-	// will be run on the command line, or if we're using something from Go's standard lib.
-	logCommandFn func(str string, isCommandLineCommand bool)
-	// this is for us to directly write the output of a command. We will do this for
-	// certain commands like 'git push'. The GUI will write this to a command output panel.
-	// We need a new cmd writer per command, hence it being a function.
-	newCmdWriterFn func() io.Writer
-	// this allows us to request info from the user like username/password, in the event
-	// that a command requests it.
-	// the 'credential' arg is something like 'username' or 'password'
-	promptForCredentialFn func(credential CredentialType) string
-}
-
-func NewGuiIO(log *logrus.Entry, logCommandFn func(string, bool), newCmdWriterFn func() io.Writer, promptForCredentialFn func(CredentialType) string) *guiIO {
-	return &guiIO{
-		log:                   log,
-		logCommandFn:          logCommandFn,
-		newCmdWriterFn:        newCmdWriterFn,
-		promptForCredentialFn: promptForCredentialFn,
-	}
-}
-
-// we use this function when we want to access the functionality of our OS struct but we
-// don't have anywhere to log things, or request input from the user.
-func NewNullGuiIO(log *logrus.Entry) *guiIO {
-	return &guiIO{
-		log:                   log,
-		logCommandFn:          func(string, bool) {},
-		newCmdWriterFn:        func() io.Writer { return ioutil.Discard },
-		promptForCredentialFn: failPromptFn,
-	}
-}

pkg/commands/oscommands/os.go

@@ -20,10 +20,15 @@ import (
 type OSCommand struct {
 	*common.Common
 	Platform *Platform
-	getenvFn func(string) string
-	guiIO    *guiIO
+	Getenv   func(string) string
 
-	removeFileFn func(string) error
+	// 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
 }
@@ -37,26 +42,88 @@ type Platform struct {
 	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, platform *Platform, guiIO *guiIO) *OSCommand {
+func NewOSCommand(common *common.Common) *OSCommand {
+	platform := getPlatform()
+
 	c := &OSCommand{
-		Common:       common,
-		Platform:     platform,
-		getenvFn:     os.Getenv,
-		removeFileFn: os.RemoveAll,
-		guiIO:        guiIO,
+		Common:     common,
+		Platform:   platform,
+		Getenv:     os.Getenv,
+		removeFile: os.RemoveAll,
 	}
 
-	runner := &cmdObjRunner{log: common.Log, guiIO: guiIO}
-	c.Cmd = &CmdObjBuilder{runner: runner, platform: platform}
+	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")
 
-	c.guiIO.logCommandFn(cmdStr, commandLine)
+	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
@@ -71,6 +138,7 @@ func FileType(path string) string {
 	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{
@@ -80,7 +148,9 @@ func (c *OSCommand) OpenFile(filename string) error {
 	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),
@@ -95,6 +165,26 @@ 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)
@@ -166,6 +256,15 @@ func (c *OSCommand) FileExists(path string) (bool, error) {
 	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))
@@ -248,34 +347,9 @@ func (c *OSCommand) CopyToClipboard(str string) error {
 func (c *OSCommand) RemoveFile(path string) error {
 	c.LogCommand(fmt.Sprintf("Deleting path '%s'", path), false)
 
-	return c.removeFileFn(path)
-}
-
-func (c *OSCommand) Getenv(key string) string {
-	return c.getenvFn(key)
+	return c.removeFile(path)
 }
 
 func GetTempDir() string {
 	return filepath.Join(os.TempDir(), "lazygit")
 }
-
-// GetLazygitPath returns the path of the currently executed file
-func 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) + `"`
-}
-
-func (c *OSCommand) UpdateWindowTitle() error {
-	if c.Platform.OS != "windows" {
-		return nil
-	}
-	path, getWdErr := os.Getwd()
-	if getWdErr != nil {
-		return getWdErr
-	}
-	argString := fmt.Sprint("title ", filepath.Base(path), " - Lazygit")
-	return c.Cmd.NewShell(argString).Run()
-}

pkg/commands/oscommands/os_default_platform.go

@@ -7,7 +7,7 @@ import (
 	"runtime"
 )
 
-func GetPlatform() *Platform {
+func getPlatform() *Platform {
 	return &Platform{
 		OS:              runtime.GOOS,
 		Shell:           "bash",

pkg/commands/oscommands/os_default_test.go

@@ -4,6 +4,7 @@
 package oscommands
 
 import (
+	"os/exec"
 	"testing"
 
 	"github.com/go-errors/errors"
@@ -58,6 +59,7 @@ func TestOSCommandOpenFileLinux(t *testing.T) {
 	type scenario struct {
 		filename string
 		runner   *FakeCmdObjRunner
+		command  func(string, ...string) *exec.Cmd
 		test     func(error)
 	}
 
@@ -112,3 +114,69 @@ func TestOSCommandOpenFileLinux(t *testing.T) {
 		s.test(oSCmd.OpenFile(s.filename))
 	}
 }
+
+func TestOSCommandOpenFileWindows(t *testing.T) {
+	type scenario struct {
+		filename string
+		runner   *FakeCmdObjRunner
+		command  func(string, ...string) *exec.Cmd
+		test     func(error)
+	}
+
+	scenarios := []scenario{
+		{
+			filename: "test",
+			runner: NewFakeRunner(t).
+				ExpectArgs([]string{"cmd", "/c", "start", "", "test"}, "", errors.New("error")),
+			test: func(err error) {
+				assert.Error(t, err)
+			},
+		},
+		{
+			filename: "test",
+			runner: NewFakeRunner(t).
+				ExpectArgs([]string{"cmd", "/c", "start", "", "test"}, "", nil),
+			test: func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			filename: "filename with spaces",
+			runner: NewFakeRunner(t).
+				ExpectArgs([]string{"cmd", "/c", "start", "", "filename with spaces"}, "", nil),
+			test: func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			filename: "let's_test_with_single_quote",
+			runner: NewFakeRunner(t).
+				ExpectArgs([]string{"cmd", "/c", "start", "", "let's_test_with_single_quote"}, "", nil),
+			test: func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			filename: "$USER.txt",
+			runner: NewFakeRunner(t).
+				ExpectArgs([]string{"cmd", "/c", "start", "", "$USER.txt"}, "", nil),
+			test: func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		oSCmd := NewDummyOSCommandWithRunner(s.runner)
+		platform := &Platform{
+			OS:       "windows",
+			Shell:    "cmd",
+			ShellArg: "/c",
+		}
+		oSCmd.Platform = platform
+		oSCmd.Cmd.platform = platform
+		oSCmd.UserConfig.OS.OpenCommand = `start "" {{filename}}`
+
+		s.test(oSCmd.OpenFile(s.filename))
+	}
+}

pkg/commands/oscommands/os_test.go

@@ -190,7 +190,6 @@ func TestOSCommandCreateTempFile(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			s.test(NewDummyOSCommand().CreateTempFile(s.filename, s.content))
 		})

pkg/commands/oscommands/os_windows.go

@@ -1,6 +1,6 @@
 package oscommands
 
-func GetPlatform() *Platform {
+func getPlatform() *Platform {
 	return &Platform{
 		OS:       "windows",
 		Shell:    "cmd",

pkg/commands/oscommands/os_windows_test.go

@@ -4,18 +4,18 @@
 package oscommands
 
 import (
+	"os/exec"
 	"testing"
 
-	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/secureexec"
 	"github.com/stretchr/testify/assert"
 )
 
-// handling this in a separate file because str.ToArgv has different behaviour if we're on windows
-
 func TestOSCommandOpenFileWindows(t *testing.T) {
 	type scenario struct {
 		filename string
 		runner   *FakeCmdObjRunner
+		command  func(string, ...string) *exec.Cmd
 		test     func(error)
 	}
 

pkg/commands/patch/patch_manager.go

@@ -34,7 +34,7 @@ type PatchManager struct {
 	// To is the commit sha if we're dealing with files of a commit, or a stash ref for a stash
 	To      string
 	From    string
-	reverse bool
+	Reverse bool
 
 	// CanRebase tells us whether we're allowed to modify our commits. CanRebase should be true for commits of the currently checked out branch and false for everything else
 	// TODO: move this out into a proper mode struct in the gui package: it doesn't really belong here
@@ -43,18 +43,18 @@ type PatchManager struct {
 	// fileInfoMap starts empty but you add files to it as you go along
 	fileInfoMap map[string]*fileInfo
 	Log         *logrus.Entry
-	applyPatch  applyPatchFunc
+	ApplyPatch  applyPatchFunc
 
-	// loadFileDiff loads the diff of a file, for a given to (typically a commit SHA)
-	loadFileDiff loadFileDiffFunc
+	// LoadFileDiff loads the diff of a file, for a given to (typically a commit SHA)
+	LoadFileDiff loadFileDiffFunc
 }
 
 // NewPatchManager returns a new PatchManager
 func NewPatchManager(log *logrus.Entry, applyPatch applyPatchFunc, loadFileDiff loadFileDiffFunc) *PatchManager {
 	return &PatchManager{
 		Log:          log,
-		applyPatch:   applyPatch,
-		loadFileDiff: loadFileDiff,
+		ApplyPatch:   applyPatch,
+		LoadFileDiff: loadFileDiff,
 	}
 }
 
@@ -62,7 +62,7 @@ func NewPatchManager(log *logrus.Entry, applyPatch applyPatchFunc, loadFileDiff
 func (p *PatchManager) Start(from, to string, reverse bool, canRebase bool) {
 	p.To = to
 	p.From = from
-	p.reverse = reverse
+	p.Reverse = reverse
 	p.CanRebase = canRebase
 	p.fileInfoMap = map[string]*fileInfo{}
 }
@@ -118,7 +118,7 @@ func (p *PatchManager) getFileInfo(filename string) (*fileInfo, error) {
 		return info, nil
 	}
 
-	diff, err := p.loadFileDiff(p.From, p.To, p.reverse, filename, true)
+	diff, err := p.LoadFileDiff(p.From, p.To, p.Reverse, filename, true)
 	if err != nil {
 		return nil, err
 	}
@@ -265,7 +265,7 @@ func (p *PatchManager) ApplyPatches(reverse bool) error {
 			if patch == "" {
 				continue
 			}
-			if err = p.applyPatch(patch, applyFlags...); err != nil {
+			if err = p.ApplyPatch(patch, applyFlags...); err != nil {
 				continue
 			}
 			break
@@ -301,5 +301,5 @@ func (p *PatchManager) IsEmpty() bool {
 
 // if any of these things change we'll need to reset and start a new patch
 func (p *PatchManager) NewPatchRequired(from string, to string, reverse bool) bool {
-	return from != p.From || to != p.To || reverse != p.reverse
+	return from != p.From || to != p.To || reverse != p.Reverse
 }

pkg/commands/patch/patch_modifier.go

@@ -22,7 +22,7 @@ func GetHeaderFromDiff(diff string) string {
 func GetHunksFromDiff(diff string) []*PatchHunk {
 	hunks := []*PatchHunk{}
 	firstLineIdx := -1
-	var hunkLines []string //nolint:prealloc
+	var hunkLines []string
 	pastDiffHeader := false
 
 	for lineIdx, line := range strings.SplitAfter(diff, "\n") {

pkg/commands/patch/patch_modifier_test.go

@@ -511,7 +511,6 @@ func TestModifyPatchForRange(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			result := ModifiedPatchForRange(nil, s.filename, s.diffText, s.firstLineIndex, s.lastLineIndex, s.reverse, false)
 			if !assert.Equal(t, s.expected, result) {
@@ -539,7 +538,6 @@ func TestLineNumberOfLine(t *testing.T) {
 	}
 
 	for _, s := range scenarios {
-		s := s
 		t.Run(s.testName, func(t *testing.T) {
 			result := s.hunk.LineNumberOfLine(s.idx)
 			if !assert.Equal(t, s.expected, result) {

pkg/commands/patch/patch_parser.go

@@ -98,7 +98,7 @@ func (l *PatchLine) render(selected bool, included bool) string {
 		return coloredString(style.FgCyan, match[1], selected, included) + coloredString(theme.DefaultTextColor, match[2], selected, false)
 	}
 
-	var textStyle style.TextStyle
+	textStyle := theme.DefaultTextColor
 	switch l.Kind {
 	case PATCH_HEADER:
 		textStyle = textStyle.SetBold()
@@ -108,8 +108,6 @@ func (l *PatchLine) render(selected bool, included bool) string {
 		textStyle = style.FgRed
 	case COMMIT_SHA:
 		textStyle = style.FgYellow
-	default:
-		textStyle = theme.DefaultTextColor
 	}
 
 	return coloredString(textStyle, content, selected, included)

pkg/commands/patch_rebases.go

@@ -0,0 +1,232 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/models"
+	"github.com/jesseduffield/lazygit/pkg/commands/patch"
+	"github.com/jesseduffield/lazygit/pkg/commands/types/enums"
+)
+
+// DeletePatchesFromCommit applies a patch in reverse for a commit
+func (c *GitCommand) DeletePatchesFromCommit(commits []*models.Commit, commitIndex int, p *patch.PatchManager) error {
+	if err := c.BeginInteractiveRebaseForCommit(commits, commitIndex); err != nil {
+		return err
+	}
+
+	// apply each patch in reverse
+	if err := p.ApplyPatches(true); err != nil {
+		if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
+			return err
+		}
+		return err
+	}
+
+	// time to amend the selected commit
+	if err := c.AmendHead(); err != nil {
+		return err
+	}
+
+	c.onSuccessfulContinue = func() error {
+		c.PatchManager.Reset()
+		return nil
+	}
+
+	// continue
+	return c.GenericMergeOrRebaseAction("rebase", "continue")
+}
+
+func (c *GitCommand) MovePatchToSelectedCommit(commits []*models.Commit, sourceCommitIdx int, destinationCommitIdx int, p *patch.PatchManager) error {
+	if sourceCommitIdx < destinationCommitIdx {
+		if err := c.BeginInteractiveRebaseForCommit(commits, destinationCommitIdx); err != nil {
+			return err
+		}
+
+		// apply each patch forward
+		if err := p.ApplyPatches(false); err != nil {
+			if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
+				return err
+			}
+			return err
+		}
+
+		// amend the destination commit
+		if err := c.AmendHead(); err != nil {
+			return err
+		}
+
+		c.onSuccessfulContinue = func() error {
+			c.PatchManager.Reset()
+			return nil
+		}
+
+		// continue
+		return c.GenericMergeOrRebaseAction("rebase", "continue")
+	}
+
+	if len(commits)-1 < sourceCommitIdx {
+		return errors.New("index outside of range of commits")
+	}
+
+	// we can make this GPG thing possible it just means we need to do this in two parts:
+	// one where we handle the possibility of a credential request, and the other
+	// where we continue the rebase
+	if c.UsingGpg() {
+		return errors.New(c.Tr.DisabledForGPG)
+	}
+
+	baseIndex := sourceCommitIdx + 1
+	todo := ""
+	for i, commit := range commits[0:baseIndex] {
+		a := "pick"
+		if i == sourceCommitIdx || i == destinationCommitIdx {
+			a = "edit"
+		}
+		todo = a + " " + commit.Sha + " " + commit.Name + "\n" + todo
+	}
+
+	cmdObj, err := c.PrepareInteractiveRebaseCommand(commits[baseIndex].Sha, todo, true)
+	if err != nil {
+		return err
+	}
+
+	if err := cmdObj.Run(); err != nil {
+		return err
+	}
+
+	// apply each patch in reverse
+	if err := p.ApplyPatches(true); err != nil {
+		if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
+			return err
+		}
+		return err
+	}
+
+	// amend the source commit
+	if err := c.AmendHead(); err != nil {
+		return err
+	}
+
+	if c.onSuccessfulContinue != nil {
+		return errors.New("You are midway through another rebase operation. Please abort to start again")
+	}
+
+	c.onSuccessfulContinue = func() error {
+		// now we should be up to the destination, so let's apply forward these patches to that.
+		// ideally we would ensure we're on the right commit but I'm not sure if that check is necessary
+		if err := p.ApplyPatches(false); err != nil {
+			if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
+				return err
+			}
+			return err
+		}
+
+		// amend the destination commit
+		if err := c.AmendHead(); err != nil {
+			return err
+		}
+
+		c.onSuccessfulContinue = func() error {
+			c.PatchManager.Reset()
+			return nil
+		}
+
+		return c.GenericMergeOrRebaseAction("rebase", "continue")
+	}
+
+	return c.GenericMergeOrRebaseAction("rebase", "continue")
+}
+
+func (c *GitCommand) MovePatchIntoIndex(commits []*models.Commit, commitIdx int, p *patch.PatchManager, stash bool) error {
+	if stash {
+		if err := c.StashSave(c.Tr.StashPrefix + commits[commitIdx].Sha); err != nil {
+			return err
+		}
+	}
+
+	if err := c.BeginInteractiveRebaseForCommit(commits, commitIdx); err != nil {
+		return err
+	}
+
+	if err := p.ApplyPatches(true); err != nil {
+		if c.WorkingTreeState() == enums.REBASE_MODE_REBASING {
+			if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
+				return err
+			}
+		}
+		return err
+	}
+
+	// amend the commit
+	if err := c.AmendHead(); err != nil {
+		return err
+	}
+
+	if c.onSuccessfulContinue != nil {
+		return errors.New("You are midway through another rebase operation. Please abort to start again")
+	}
+
+	c.onSuccessfulContinue = func() error {
+		// add patches to index
+		if err := p.ApplyPatches(false); err != nil {
+			if c.WorkingTreeState() == enums.REBASE_MODE_REBASING {
+				if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
+					return err
+				}
+			}
+			return err
+		}
+
+		if stash {
+			if err := c.StashDo(0, "apply"); err != nil {
+				return err
+			}
+		}
+
+		c.PatchManager.Reset()
+		return nil
+	}
+
+	return c.GenericMergeOrRebaseAction("rebase", "continue")
+}
+
+func (c *GitCommand) PullPatchIntoNewCommit(commits []*models.Commit, commitIdx int, p *patch.PatchManager) error {
+	if err := c.BeginInteractiveRebaseForCommit(commits, commitIdx); err != nil {
+		return err
+	}
+
+	if err := p.ApplyPatches(true); err != nil {
+		if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
+			return err
+		}
+		return err
+	}
+
+	// amend the commit
+	if err := c.AmendHead(); err != nil {
+		return err
+	}
+
+	// add patches to index
+	if err := p.ApplyPatches(false); err != nil {
+		if err := c.GenericMergeOrRebaseAction("rebase", "abort"); err != nil {
+			return err
+		}
+		return err
+	}
+
+	head_message, _ := c.GetHeadCommitMessage()
+	new_message := fmt.Sprintf("Split from \"%s\"", head_message)
+	err := c.CommitCmdObj(new_message, "").Run()
+	if err != nil {
+		return err
+	}
+
+	if c.onSuccessfulContinue != nil {
+		return errors.New("You are midway through another rebase operation. Please abort to start again")
+	}
+
+	c.PatchManager.Reset()
+	return c.GenericMergeOrRebaseAction("rebase", "continue")
+}

pkg/commands/rebasing.go

@@ -0,0 +1,280 @@
+package commands
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/models"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+)
+
+func (c *GitCommand) RewordCommit(commits []*models.Commit, index int) (oscommands.ICmdObj, error) {
+	todo, sha, err := c.GenerateGenericRebaseTodo(commits, index, "reword")
+	if err != nil {
+		return nil, err
+	}
+
+	return c.PrepareInteractiveRebaseCommand(sha, todo, false)
+}
+
+func (c *GitCommand) MoveCommitDown(commits []*models.Commit, index int) error {
+	// we must ensure that we have at least two commits after the selected one
+	if len(commits) <= index+2 {
+		// assuming they aren't picking the bottom commit
+		return errors.New(c.Tr.NoRoom)
+	}
+
+	todo := ""
+	orderedCommits := append(commits[0:index], commits[index+1], commits[index])
+	for _, commit := range orderedCommits {
+		todo = "pick " + commit.Sha + " " + commit.Name + "\n" + todo
+	}
+
+	cmdObj, err := c.PrepareInteractiveRebaseCommand(commits[index+2].Sha, todo, true)
+	if err != nil {
+		return err
+	}
+
+	return cmdObj.Run()
+}
+
+func (c *GitCommand) InteractiveRebase(commits []*models.Commit, index int, action string) error {
+	todo, sha, err := c.GenerateGenericRebaseTodo(commits, index, action)
+	if err != nil {
+		return err
+	}
+
+	cmdObj, err := c.PrepareInteractiveRebaseCommand(sha, todo, true)
+	if err != nil {
+		return err
+	}
+
+	return cmdObj.Run()
+}
+
+// PrepareInteractiveRebaseCommand returns the cmd for an interactive rebase
+// we tell git to run lazygit to edit the todo list, and we pass the client
+// lazygit a todo string to write to the todo file
+func (c *GitCommand) PrepareInteractiveRebaseCommand(baseSha string, todo string, overrideEditor bool) (oscommands.ICmdObj, error) {
+	ex := c.OSCommand.GetLazygitPath()
+
+	debug := "FALSE"
+	if c.Debug {
+		debug = "TRUE"
+	}
+
+	cmdStr := fmt.Sprintf("git rebase --interactive --autostash --keep-empty %s", baseSha)
+	c.Log.WithField("command", cmdStr).Info("RunCommand")
+
+	cmdObj := c.Cmd.New(cmdStr)
+
+	gitSequenceEditor := ex
+	if todo == "" {
+		gitSequenceEditor = "true"
+	} else {
+		c.OSCommand.LogCommand(fmt.Sprintf("Creating TODO file for interactive rebase: \n\n%s", todo), false)
+	}
+
+	cmdObj.AddEnvVars(
+		"LAZYGIT_CLIENT_COMMAND=INTERACTIVE_REBASE",
+		"LAZYGIT_REBASE_TODO="+todo,
+		"DEBUG="+debug,
+		"LANG=en_US.UTF-8",   // Force using EN as language
+		"LC_ALL=en_US.UTF-8", // Force using EN as language
+		"GIT_SEQUENCE_EDITOR="+gitSequenceEditor,
+	)
+
+	if overrideEditor {
+		cmdObj.AddEnvVars("GIT_EDITOR=" + ex)
+	}
+
+	return cmdObj, nil
+}
+
+func (c *GitCommand) GenerateGenericRebaseTodo(commits []*models.Commit, actionIndex int, action string) (string, string, error) {
+	baseIndex := actionIndex + 1
+
+	if len(commits) <= baseIndex {
+		return "", "", errors.New(c.Tr.CannotRebaseOntoFirstCommit)
+	}
+
+	if action == "squash" || action == "fixup" {
+		baseIndex++
+
+		if len(commits) <= baseIndex {
+			return "", "", errors.New(c.Tr.CannotSquashOntoSecondCommit)
+		}
+	}
+
+	todo := ""
+	for i, commit := range commits[0:baseIndex] {
+		var commitAction string
+		if i == actionIndex {
+			commitAction = action
+		} else if commit.IsMerge() {
+			// your typical interactive rebase will actually drop merge commits by default. Damn git CLI, you scary!
+			// doing this means we don't need to worry about rebasing over merges which always causes problems.
+			// you typically shouldn't be doing rebases that pass over merge commits anyway.
+			commitAction = "drop"
+		} else {
+			commitAction = "pick"
+		}
+		todo = commitAction + " " + commit.Sha + " " + commit.Name + "\n" + todo
+	}
+
+	return todo, commits[baseIndex].Sha, nil
+}
+
+// AmendTo amends the given commit with whatever files are staged
+func (c *GitCommand) AmendTo(sha string) error {
+	if err := c.CreateFixupCommit(sha); err != nil {
+		return err
+	}
+
+	return c.SquashAllAboveFixupCommits(sha)
+}
+
+// EditRebaseTodo sets the action at a given index in the git-rebase-todo file
+func (c *GitCommand) EditRebaseTodo(index int, action string) error {
+	fileName := filepath.Join(c.DotGitDir, "rebase-merge/git-rebase-todo")
+	bytes, err := ioutil.ReadFile(fileName)
+	if err != nil {
+		return err
+	}
+
+	content := strings.Split(string(bytes), "\n")
+	commitCount := c.getTodoCommitCount(content)
+
+	// we have the most recent commit at the bottom whereas the todo file has
+	// it at the bottom, so we need to subtract our index from the commit count
+	contentIndex := commitCount - 1 - index
+	splitLine := strings.Split(content[contentIndex], " ")
+	content[contentIndex] = action + " " + strings.Join(splitLine[1:], " ")
+	result := strings.Join(content, "\n")
+
+	return ioutil.WriteFile(fileName, []byte(result), 0644)
+}
+
+func (c *GitCommand) getTodoCommitCount(content []string) int {
+	// count lines that are not blank and are not comments
+	commitCount := 0
+	for _, line := range content {
+		if line != "" && !strings.HasPrefix(line, "#") {
+			commitCount++
+		}
+	}
+	return commitCount
+}
+
+// MoveTodoDown moves a rebase todo item down by one position
+func (c *GitCommand) MoveTodoDown(index int) error {
+	fileName := filepath.Join(c.DotGitDir, "rebase-merge/git-rebase-todo")
+	bytes, err := ioutil.ReadFile(fileName)
+	if err != nil {
+		return err
+	}
+
+	content := strings.Split(string(bytes), "\n")
+	commitCount := c.getTodoCommitCount(content)
+	contentIndex := commitCount - 1 - index
+
+	rearrangedContent := append(content[0:contentIndex-1], content[contentIndex], content[contentIndex-1])
+	rearrangedContent = append(rearrangedContent, content[contentIndex+1:]...)
+	result := strings.Join(rearrangedContent, "\n")
+
+	return ioutil.WriteFile(fileName, []byte(result), 0644)
+}
+
+// SquashAllAboveFixupCommits squashes all fixup! commits above the given one
+func (c *GitCommand) SquashAllAboveFixupCommits(sha string) error {
+	return c.runSkipEditorCommand(
+		fmt.Sprintf(
+			"git rebase --interactive --autostash --autosquash %s^",
+			sha,
+		),
+	)
+}
+
+// BeginInteractiveRebaseForCommit starts an interactive rebase to edit the current
+// commit and pick all others. After this you'll want to call `c.GenericMergeOrRebaseAction("rebase", "continue")`
+func (c *GitCommand) BeginInteractiveRebaseForCommit(commits []*models.Commit, commitIndex int) error {
+	if len(commits)-1 < commitIndex {
+		return errors.New("index outside of range of commits")
+	}
+
+	// we can make this GPG thing possible it just means we need to do this in two parts:
+	// one where we handle the possibility of a credential request, and the other
+	// where we continue the rebase
+	if c.UsingGpg() {
+		return errors.New(c.Tr.DisabledForGPG)
+	}
+
+	todo, sha, err := c.GenerateGenericRebaseTodo(commits, commitIndex, "edit")
+	if err != nil {
+		return err
+	}
+
+	cmdObj, err := c.PrepareInteractiveRebaseCommand(sha, todo, true)
+	if err != nil {
+		return err
+	}
+
+	return cmdObj.Run()
+}
+
+// RebaseBranch interactive rebases onto a branch
+func (c *GitCommand) RebaseBranch(branchName string) error {
+	cmdObj, err := c.PrepareInteractiveRebaseCommand(branchName, "", false)
+	if err != nil {
+		return err
+	}
+
+	return cmdObj.Run()
+}
+
+// GenericMerge takes a commandType of "merge" or "rebase" and a command of "abort", "skip" or "continue"
+// By default we skip the editor in the case where a commit will be made
+func (c *GitCommand) GenericMergeOrRebaseAction(commandType string, command string) error {
+	err := c.runSkipEditorCommand(
+		fmt.Sprintf(
+			"git %s --%s",
+			commandType,
+			command,
+		),
+	)
+	if err != nil {
+		if !strings.Contains(err.Error(), "no rebase in progress") {
+			return err
+		}
+		c.Log.Warn(err)
+	}
+
+	// sometimes we need to do a sequence of things in a rebase but the user needs to
+	// fix merge conflicts along the way. When this happens we queue up the next step
+	// so that after the next successful rebase continue we can continue from where we left off
+	if commandType == "rebase" && command == "continue" && c.onSuccessfulContinue != nil {
+		f := c.onSuccessfulContinue
+		c.onSuccessfulContinue = nil
+		return f()
+	}
+	if command == "abort" {
+		c.onSuccessfulContinue = nil
+	}
+	return nil
+}
+
+func (c *GitCommand) runSkipEditorCommand(command string) error {
+	cmdObj := c.OSCommand.Cmd.New(command)
+	lazyGitPath := c.OSCommand.GetLazygitPath()
+	return cmdObj.
+		AddEnvVars(
+			"LAZYGIT_CLIENT_COMMAND=EXIT_IMMEDIATELY",
+			"GIT_EDITOR="+lazyGitPath,
+			"EDITOR="+lazyGitPath,
+			"VISUAL="+lazyGitPath,
+		).
+		Run()
+}

pkg/commands/rebasing_test.go

@@ -0,0 +1,76 @@
+package commands
+
+import (
+	"regexp"
+	"testing"
+
+	"github.com/go-errors/errors"
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGitCommandRebaseBranch(t *testing.T) {
+	type scenario struct {
+		testName string
+		arg      string
+		runner   *oscommands.FakeCmdObjRunner
+		test     func(error)
+	}
+
+	scenarios := []scenario{
+		{
+			testName: "successful rebase",
+			arg:      "master",
+			runner: oscommands.NewFakeRunner(t).
+				Expect(`git rebase --interactive --autostash --keep-empty master`, "", nil),
+			test: func(err error) {
+				assert.NoError(t, err)
+			},
+		},
+		{
+			testName: "unsuccessful rebase",
+			arg:      "master",
+			runner: oscommands.NewFakeRunner(t).
+				Expect(`git rebase --interactive --autostash --keep-empty master`, "", 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.RebaseBranch(s.arg))
+		})
+	}
+}
+
+// TestGitCommandSkipEditorCommand confirms that SkipEditorCommand injects
+// environment variables that suppress an interactive editor
+func TestGitCommandSkipEditorCommand(t *testing.T) {
+	commandStr := "git blah"
+	runner := oscommands.NewFakeRunner(t).ExpectFunc(func(cmdObj oscommands.ICmdObj) (string, error) {
+		assert.Equal(t, commandStr, cmdObj.ToString())
+		envVars := cmdObj.GetEnvVars()
+		for _, regexStr := range []string{
+			`^VISUAL=.*$`,
+			`^EDITOR=.*$`,
+			`^GIT_EDITOR=.*$`,
+			"^LAZYGIT_CLIENT_COMMAND=EXIT_IMMEDIATELY$",
+		} {
+			foundMatch := utils.IncludesStringFunc(envVars, func(envVar string) bool {
+				return regexp.MustCompile(regexStr).MatchString(envVar)
+			})
+			if !foundMatch {
+				t.Errorf("expected environment variable %s to be set", regexStr)
+			}
+		}
+		return "", nil
+	})
+	gitCmd := NewDummyGitCommandWithRunner(runner)
+	err := gitCmd.runSkipEditorCommand(commandStr)
+	assert.NoError(t, err)
+	runner.CheckForMissingCalls()
+}

pkg/commands/remotes.go

@@ -0,0 +1,59 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/jesseduffield/lazygit/pkg/commands/oscommands"
+)
+
+func (c *GitCommand) AddRemote(name string, url string) error {
+	return c.Cmd.
+		New(fmt.Sprintf("git remote add %s %s", c.Cmd.Quote(name), c.Cmd.Quote(url))).
+		Run()
+}
+
+func (c *GitCommand) RemoveRemote(name string) error {
+	return c.Cmd.
+		New(fmt.Sprintf("git remote remove %s", c.Cmd.Quote(name))).
+		Run()
+}
+
+func (c *GitCommand) RenameRemote(oldRemoteName string, newRemoteName string) error {
+	return c.Cmd.
+		New(fmt.Sprintf("git remote rename %s %s", c.Cmd.Quote(oldRemoteName), c.Cmd.Quote(newRemoteName))).
+		Run()
+}
+
+func (c *GitCommand) UpdateRemoteUrl(remoteName string, updatedUrl string) error {
+	return c.Cmd.
+		New(fmt.Sprintf("git remote set-url %s %s", c.Cmd.Quote(remoteName), c.Cmd.Quote(updatedUrl))).
+		Run()
+}
+
+func (c *GitCommand) DeleteRemoteBranch(remoteName string, branchName string, promptUserForCredential func(string) string) error {
+	command := fmt.Sprintf("git push %s --delete %s", c.Cmd.Quote(remoteName), c.Cmd.Quote(branchName))
+	cmdObj := c.Cmd.
+		New(command)
+	return c.DetectUnamePass(cmdObj, promptUserForCredential)
+}
+
+func (c *GitCommand) DetectUnamePass(cmdObj oscommands.ICmdObj, promptUserForCredential func(string) string) error {
+	return c.OSCommand.DetectUnamePass(cmdObj, c.GetCmdWriter(), promptUserForCredential)
+}
+
+// CheckRemoteBranchExists Returns remote branch
+func (c *GitCommand) CheckRemoteBranchExists(branchName string) bool {
+	_, err := c.Cmd.
+		New(
+			fmt.Sprintf("git show-ref --verify -- refs/remotes/origin/%s",
+				c.Cmd.Quote(branchName),
+			)).
+		RunWithOutput()
+
+	return err == nil
+}
+
+// GetRemoteURL returns current repo remote url
+func (c *GitCommand) GetRemoteURL() string {
+	return c.GitConfig.Get("remote.origin.url")
+}

pkg/commands/stash_entries.go

@@ -0,0 +1,65 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/jesseduffield/lazygit/pkg/commands/loaders"
+)
+
+// StashDo modify stash
+func (c *GitCommand) StashDo(index int, method string) error {
+	return c.Cmd.New(fmt.Sprintf("git stash %s stash@{%d}", method, index)).Run()
+}
+
+// StashSave save stash
+// TODO: before calling this, check if there is anything to save
+func (c *GitCommand) StashSave(message string) error {
+	return c.Cmd.New("git stash save " + c.OSCommand.Quote(message)).Run()
+}
+
+// GetStashEntryDiff stash diff
+func (c *GitCommand) ShowStashEntryCmdStr(index int) string {
+	return fmt.Sprintf("git stash show -p --stat --color=%s --unified=%d stash@{%d}", c.colorArg(), c.UserConfig.Git.DiffContextSize, index)
+}
+
+// StashSaveStagedChanges stashes only the currently staged changes. This takes a few steps
+// shoutouts to Joe on https://stackoverflow.com/questions/14759748/stashing-only-staged-changes-in-git-is-it-possible
+func (c *GitCommand) StashSaveStagedChanges(message string) error {
+	// wrap in 'writing', which uses a mutex
+	if err := c.Cmd.New("git stash --keep-index").Run(); err != nil {
+		return err
+	}
+
+	if err := c.StashSave(message); err != nil {
+		return err
+	}
+
+	if err := c.Cmd.New("git stash apply stash@{1}").Run(); err != nil {
+		return err
+	}
+
+	if err := c.OSCommand.PipeCommands("git stash show -p", "git apply -R"); err != nil {
+		return err
+	}
+
+	if err := c.Cmd.New("git stash drop stash@{1}").Run(); err != nil {
+		return err
+	}
+
+	// if you had staged an untracked file, that will now appear as 'AD' in git status
+	// meaning it's deleted in your working tree but added in your index. Given that it's
+	// now safely stashed, we need to remove it.
+	files := loaders.
+		NewFileLoader(c.Common, c.Cmd, c.GitConfig).
+		GetStatusFiles(loaders.GetStatusFileOptions{})
+
+	for _, file := range files {
+		if file.ShortStatus == "AD" {
+			if err := c.UnStageFile(file.Names(), false); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}