Add subble image

- **PR Description**

Fixes https://github.com/jesseduffield/lazygit/issues/4464.

I checked, and the README already has a width specified on the `img`
tag, so I don't think the increased size of this will matter at all. I
just grabbed this directly from discord's site
https://discord.com/branding


https://github.com/jesseduffield/lazygit/blob/f7787fc8190504a9461b37da4c3240d3488b6813/README.md#L510

I personally use github dark mode all the time, and can vouch that it
looks totally fine. Light mode users won't see a difference, since we
just removed some white


![Image](https://github.com/user-attachments/assets/f682a58b-eaff-44ed-89aa-69f19d797557)

.gitignore

@@ -1,6 +0,0 @@
-development.log
-commands.log
-extra/lgit.rb
-notes/go.notes
-TODO.notes
-TODO.md

.travis.yml

@@ -1,51 +0,0 @@
-language: go
-sudo: false
-env:
-  - DEP_VERSION="0.5.0"
-matrix:
-  include:
-  - go: 1.x
-    env: LATEST=true
-  - go: 1.7
-  - go: tip
-  allow_failures:
-  - go: tip
-before_install:
-  # Download the binary to bin folder in $GOPATH
-  # - curl -L -s https://github.com/golang/dep/releases/download/v${DEP_VERSION}/dep-linux-386 -o $GOPATH/bin/dep
-  - curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
-  - ls
-  - ls */*
-  # Make the binary executable
-  - chmod +x $GOPATH/bin/dep
-  - ls $GOPATH/bin/
-  - dep ensure
-  - go get github.com/mitchellh/gox
-install:
-  -
-script:
-# - go get -v ./...
-# - diff -u <(echo -n) <(gofmt -d .) # can't make gofmt ignore vendor directory
-# - go vet $(go list ./... | grep -v /vendor/)
-  - gox -os="linux darwin windows" -arch="amd64" -ldflags "-X main.Rev=`git rev-parse --short HEAD`" -verbose ./...
-  - mv lazygit_windows_amd64.exe lazygit_windows_amd64_${TRAVIS_TAG}.exe
-  - mv lazygit_darwin_amd64 lazygit_darwin_amd64_${TRAVIS_TAG}
-  - mv lazygit_linux_amd64 lazygit_linux_amd64_${TRAVIS_TAG}
-  - chmod +x ./lazygit_windows_amd64_${TRAVIS_TAG}.exe
-  - chmod +x ./lazygit_darwin_amd64_${TRAVIS_TAG}
-  - chmod +x ./lazygit_linux_amd64_${TRAVIS_TAG}
-  - ls
-  - ls */*
-deploy:
-  provider: releases
-  skip_cleanup: true
-  api_key:
-    secure: TnB8I+swjicHuGTXk3ncm1Aaa12eIJqWV/Lhcnbb01i39p6+fyn3vDMdWPcejt3R8gcJqv4wyP8UQVO9G1qkLppt6V/qAuY5x6nX0MgEa3t+8JLJnGYHZYsuIgan/ecAmeu5+6dgUhr9Oq6zQOEv/O88NsALzMlqnEQNXI8XSoScfhkiVDIp3zWov0vBizCdThnNgTx9zRpJVoqxmhWvgt+me2+fOhSx1Y+3ZA2gE7zq8IFAbxp36d0rsR5lKqmTuF+YsF9iQ7Ar+xCjbRunLsZx+VwGqGfpS/qS7EwsEqBI0vEO76eFJkwEsIzOvJiFNhBDUu3upquBFMT4uzxRxH3eV+J4mZtu29UDLdvKI5Q730Lk9AgmH4now+RmP08M0SEXJa+AnHeuBv2u1iU5bu+sI6CORVQzKQwOph9AABDjSZ54wrXIpYEeIW2sz8nx+hiG6QL1mqfM/l+55BR69u3vxKYMryQBxPuzhZCTOqqI4uahlb6GIUNZJ9vGZeIA9HFJq3ymW8cdrpYzhKf3Nx9jK+Yb81h5/AHq9iChXEC63VPCDXXGRllh2UYWNYCaAdtk+ekpLR8299e4CaEregy6g5U2S3/xrBKl87miu1uJ/fquXoxGdSU+JcmsmXZ26sGIU2TCYdNjSfIgpOyfMmB4JNtKHqWRHA9Fe42CRpA=
-  file:
-  - lazygit_windows_amd64_${TRAVIS_TAG}.exe
-  - lazygit_darwin_amd64_${TRAVIS_TAG}
-  - lazygit_linux_amd64_${TRAVIS_TAG}
-  on:
-    repo: jesseduffield/lazygit
-    tags: true
-    condition: $LATEST = true

CODE-OF-CONDUCT.md

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

CONTRIBUTING.md

@@ -1,34 +0,0 @@
-# Contributing
-
-
-♥ We love pull requests from everyone !
-
-
-When contributing to this repository, please first discuss the change you wish
-to make via issue, email, or any other method with the owners of this repository
-before making a change. 
-
-## So all code changes happen through Pull Requests
-Pull requests are the best way to propose changes to the codebase. We actively
-welcome your pull requests:
-
-1. Fork the repo and create your branch from `master`.
-2. If you've added code that should be tested, add tests.
-3. If you've added code that need documentation, update the documentation.
-4. Be sure to test your modifications.
-5. Write a [good commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
-6. Issue that pull request!
-
-## Code of conduct
-Please note by participating in this project, you agree to abide by the [code of conduct].
-
-[code of conduct]: https://github.com/jesseduffield/lazygit/blob/master/CODE-OF-CONDUCT.md
-
-## Any contributions you make will be under the MIT Software License
-In short, when you submit code changes, your submissions are understood to be
-under the same [MIT License](http://choosealicense.com/licenses/mit/) that
-covers the project. Feel free to contact the maintainers if that's a concern.
-
-## Report bugs using Github's [issues](https://github.com/jesseduffield/lazygit/issues)
-We use GitHub issues to track public bugs. Report a bug by [opening a new
-issue](https://github.com/jesseduffield/lazygit/issues/new); it's that easy!

Gopkg.lock

@@ -1,77 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  digest = "1:865079840386857c809b72ce300be7580cb50d3d3129ce11bf9aa6ca2bc1934a"
-  name = "github.com/fatih/color"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "5b77d2a35fb0ede96d138fc9a99f5c9b6aef11b4"
-  version = "v1.7.0"
-
-[[projects]]
-  branch = "master"
-  digest = "1:4a8ed9b8cf22bd03bee5d74179fa06a282e4a73b6de949f7a865ff56cd2537e0"
-  name = "github.com/golang-collections/collections"
-  packages = ["stack"]
-  pruneopts = "UT"
-  revision = "604e922904d35e97f98a774db7881f049cd8d970"
-
-[[projects]]
-  branch = "master"
-  digest = "1:f086cf183e423bf1926f4de05f47bf57132fe5db9c99e464f733ce925280fc81"
-  name = "github.com/jesseduffield/gocui"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "3c923f53ac9952af649af04a067405843558d56f"
-
-[[projects]]
-  digest = "1:c658e84ad3916da105a761660dcaeb01e63416c8ec7bc62256a9b411a05fcd67"
-  name = "github.com/mattn/go-colorable"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "167de6bfdfba052fa6b2d3664c8f5272e23c9072"
-  version = "v0.0.9"
-
-[[projects]]
-  digest = "1:d4d17353dbd05cb52a2a52b7fe1771883b682806f68db442b436294926bbfafb"
-  name = "github.com/mattn/go-isatty"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "0360b2af4f38e8d38c7fce2a9f4e702702d73a39"
-  version = "v0.0.3"
-
-[[projects]]
-  digest = "1:e2d1d410fb367567c2b53ed9e2d719d3c1f0891397bb2fa49afd747cfbf1e8e4"
-  name = "github.com/mattn/go-runewidth"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "9e777a8366cce605130a531d2cd6363d07ad7317"
-  version = "v0.0.2"
-
-[[projects]]
-  branch = "master"
-  digest = "1:c9b6e36dbd23f8403a04493376916ca5dad8c01b2da5ae0a05e6a468eb0b6f24"
-  name = "github.com/nsf/termbox-go"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "5c94acc5e6eb520f1bcd183974e01171cc4c23b3"
-
-[[projects]]
-  branch = "master"
-  digest = "1:9ec6ad2659635ba0974dd7e55bf84233523eb4e7535c9a2fddaefc4cc62a3eac"
-  name = "golang.org/x/sys"
-  packages = ["unix"]
-  pruneopts = "UT"
-  revision = "0ffbfd41fbef8ffcf9b62b0b0aa3a5873ed7a4fe"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  input-imports = [
-    "github.com/fatih/color",
-    "github.com/golang-collections/collections/stack",
-    "github.com/jesseduffield/gocui",
-  ]
-  solver-name = "gps-cdcl"
-  solver-version = 1

Gopkg.toml

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

LICENSE

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

README.md

@@ -1,63 +0,0 @@
-# lazygit [![Go Report Card](https://goreportcard.com/badge/github.com/jesseduffield/lazygit)](https://goreportcard.com/report/github.com/jesseduffield/lazygit)
-
-A simple terminal UI for git commands, written in Go with the [gocui](https://github.com/jroimartin/gocui "gocui") library.
-
-Are YOU tired of typing every git command directly into the terminal, but you're too stubborn to use Sourcetree because you'll never forgive Atlassian for making Jira? This is the app for you!
-
-[Tutorial](https://www.youtube.com/watch?v=VDXvbHZYeKY)
-
-![Gif](https://image.ibb.co/mmeXho/optimisedgif.gif)
-
-## Installation
-In a terminal call this command:
-`go get github.com/jesseduffield/lazygit`
-(if you don't have Go installed, you can follow the installation guide [here](https://golang.org/doc/install).
-
-Then just call `lazygit` in your terminal inside a git repository.
-
-If you want, you can also add an alias for this with `echo "alias lg='lazygit'" >> ~/.zshrc` (or whichever rc file you're using).
-
-Please note:
-If you get an error claiming that lazygit cannot be found or is not defined, you may need to add `~/go/bin` to your $PATH (MacOS/Linux), or `%HOME%\go\bin` (Windows)
-
-### Ubuntu
-Packages for Ubuntu 16.04 and up are available via Launchpad PPA.
-
-They are built daily, straight from master branch.
-
-```sh
-sudo add-apt-repository ppa:lazygit-team/daily
-sudo apt-get update
-sudo apt-get install lazygit
-```
-
-## Cool features
-- Adding files easily
-- Resolving merge conflicts
-- Easily check out recent branches
-- Scroll through logs/diffs of branches/commits/stash
-- Quick pushing/pulling
-- Squash down and rename commits
-
-### Resolving merge conflicts
-![Gif](https://image.ibb.co/iyxUTT/shortermerging.gif)
-
-### Viewing commit diffs
-![Viewing Commit Diffs](https://image.ibb.co/gPD02o/capture.png)
-
-## Docs
-[Keybindings](https://github.com/jesseduffield/lazygit/blob/master/docs/Keybindings.md)
-
-## Milestones
-- [ ] Easy Installation (homebrew, release binaries)
-- [ ] Configurable Keybindings
-- [ ] Configurable Color Themes
-- [ ] Spawning Subprocesses (help needed - have a look at https://github.com/jesseduffield/lazygit/pull/18)
-- [ ] Performance
-- [ ] i18n
-
-## Contributing
-We love your input! Please check out the [contributing guide](CONTRIBUTING.md).
-
-## Work in progress
-This is still a work in progress so there's still bugs to iron out and as this is my first project in Go the code could no doubt use an increase in quality, but I'll be improving on it whenever I find the time. If you have any feedback feel free to [raise an issue](https://github.com/jesseduffield/lazygit/issues)/[submit a PR](https://github.com/jesseduffield/lazygit/pulls).

branches_panel.go

@@ -1,120 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/jesseduffield/gocui"
-)
-
-func handleBranchPress(g *gocui.Gui, v *gocui.View) error {
-	index := getItemPosition(v)
-	if index == 0 {
-		return createErrorPanel(g, "You have already checked out this branch")
-	}
-	branch := getSelectedBranch(v)
-	if output, err := gitCheckout(branch.Name, false); err != nil {
-		createErrorPanel(g, output)
-	}
-	return refreshSidePanels(g)
-}
-
-func handleForceCheckout(g *gocui.Gui, v *gocui.View) error {
-	branch := getSelectedBranch(v)
-	return createConfirmationPanel(g, v, "Force Checkout Branch", "Are you sure you want force checkout? You will lose all local changes", func(g *gocui.Gui, v *gocui.View) error {
-		if output, err := gitCheckout(branch.Name, true); err != nil {
-			createErrorPanel(g, output)
-		}
-		return refreshSidePanels(g)
-	}, nil)
-}
-
-func handleCheckoutByName(g *gocui.Gui, v *gocui.View) error {
-	createPromptPanel(g, v, "Branch Name:", func(g *gocui.Gui, v *gocui.View) error {
-		if output, err := gitCheckout(trimmedContent(v), false); err != nil {
-			return createErrorPanel(g, output)
-		}
-		return refreshSidePanels(g)
-	})
-	return nil
-}
-
-func handleNewBranch(g *gocui.Gui, v *gocui.View) error {
-	branch := state.Branches[0]
-	createPromptPanel(g, v, "New Branch Name (Branch is off of "+branch.Name+")", func(g *gocui.Gui, v *gocui.View) error {
-		if output, err := gitNewBranch(trimmedContent(v)); err != nil {
-			return createErrorPanel(g, output)
-		}
-		refreshSidePanels(g)
-		return handleBranchSelect(g, v)
-	})
-	return nil
-}
-
-func handleMerge(g *gocui.Gui, v *gocui.View) error {
-	checkedOutBranch := state.Branches[0]
-	selectedBranch := getSelectedBranch(v)
-	defer refreshSidePanels(g)
-	if checkedOutBranch.Name == selectedBranch.Name {
-		return createErrorPanel(g, "You cannot merge a branch into itself")
-	}
-	if output, err := gitMerge(selectedBranch.Name); err != nil {
-		return createErrorPanel(g, output)
-	}
-	return nil
-}
-
-func getSelectedBranch(v *gocui.View) Branch {
-	lineNumber := getItemPosition(v)
-	return state.Branches[lineNumber]
-}
-
-func renderBranchesOptions(g *gocui.Gui) error {
-	return renderOptionsMap(g, map[string]string{
-		"space":   "checkout",
-		"f":       "force checkout",
-		"m":       "merge",
-		"c":       "checkout by name",
-		"n":       "new branch",
-		"← → ↑ ↓": "navigate",
-	})
-}
-
-// may want to standardise how these select methods work
-func handleBranchSelect(g *gocui.Gui, v *gocui.View) error {
-	if err := renderBranchesOptions(g); err != nil {
-		return err
-	}
-	// This really shouldn't happen: there should always be a master branch
-	if len(state.Branches) == 0 {
-		return renderString(g, "main", "No branches for this repo")
-	}
-	go func() {
-		branch := getSelectedBranch(v)
-		diff, err := getBranchGraph(branch.Name, branch.BaseBranch)
-		if err != nil && strings.HasPrefix(diff, "fatal: ambiguous argument") {
-			diff = "There is no tracking for this branch"
-		}
-		renderString(g, "main", diff)
-	}()
-	return nil
-}
-
-// refreshStatus is called at the end of this because that's when we can
-// be sure there is a state.Branches array to pick the current branch from
-func refreshBranches(g *gocui.Gui) error {
-	g.Update(func(g *gocui.Gui) error {
-		v, err := g.View("branches")
-		if err != nil {
-			panic(err)
-		}
-		state.Branches = getGitBranches()
-		v.Clear()
-		for _, branch := range state.Branches {
-			fmt.Fprintln(v, branch.DisplayString)
-		}
-		resetOrigin(v)
-		return refreshStatus(g)
-	})
-	return nil
-}

commits_panel.go

@@ -1,138 +0,0 @@
-package main
-
-import (
-	"errors"
-
-	"github.com/fatih/color"
-	"github.com/jesseduffield/gocui"
-)
-
-var (
-	// ErrNoCommits : When no commits are found for the branch
-	ErrNoCommits = errors.New("No commits for this branch")
-)
-
-func refreshCommits(g *gocui.Gui) error {
-	g.Update(func(*gocui.Gui) error {
-		state.Commits = getCommits()
-		v, err := g.View("commits")
-		if err != nil {
-			panic(err)
-		}
-		v.Clear()
-		red := color.New(color.FgRed)
-		yellow := color.New(color.FgYellow)
-		white := color.New(color.FgWhite)
-		shaColor := white
-		for _, commit := range state.Commits {
-			if commit.Pushed {
-				shaColor = red
-			} else {
-				shaColor = yellow
-			}
-			shaColor.Fprint(v, commit.Sha+" ")
-			white.Fprintln(v, commit.Name)
-		}
-		refreshStatus(g)
-		return nil
-	})
-	return nil
-}
-
-func handleResetToCommit(g *gocui.Gui, commitView *gocui.View) error {
-	return createConfirmationPanel(g, commitView, "Reset To Commit", "Are you sure you want to reset to this commit?", func(g *gocui.Gui, v *gocui.View) error {
-		commit, err := getSelectedCommit(g)
-		devLog(commit)
-		if err != nil {
-			panic(err)
-		}
-		if output, err := gitResetToCommit(commit.Sha); err != nil {
-			return createErrorPanel(g, output)
-		}
-		if err := refreshCommits(g); err != nil {
-			panic(err)
-		}
-		if err := refreshFiles(g); err != nil {
-			panic(err)
-		}
-		resetOrigin(commitView)
-		return handleCommitSelect(g, nil)
-	}, nil)
-}
-
-func renderCommitsOptions(g *gocui.Gui) error {
-	return renderOptionsMap(g, map[string]string{
-		"s":       "squash down",
-		"r":       "rename",
-		"g":       "reset to this commit",
-		"← → ↑ ↓": "navigate",
-	})
-}
-
-func handleCommitSelect(g *gocui.Gui, v *gocui.View) error {
-	if err := renderCommitsOptions(g); err != nil {
-		return err
-	}
-	commit, err := getSelectedCommit(g)
-	if err != nil {
-		if err != ErrNoCommits {
-			return err
-		}
-		return renderString(g, "main", "No commits for this branch")
-	}
-	commitText := gitShow(commit.Sha)
-	return renderString(g, "main", commitText)
-}
-
-func handleCommitSquashDown(g *gocui.Gui, v *gocui.View) error {
-	if getItemPosition(v) != 0 {
-		return createErrorPanel(g, "Can only squash topmost commit")
-	}
-	if len(state.Commits) == 1 {
-		return createErrorPanel(g, "You have no commits to squash with")
-	}
-	commit, err := getSelectedCommit(g)
-	if err != nil {
-		return err
-	}
-	if output, err := gitSquashPreviousTwoCommits(commit.Name); err != nil {
-		return createErrorPanel(g, output)
-	}
-	if err := refreshCommits(g); err != nil {
-		panic(err)
-	}
-	refreshStatus(g)
-	return handleCommitSelect(g, v)
-}
-
-func handleRenameCommit(g *gocui.Gui, v *gocui.View) error {
-	if getItemPosition(v) != 0 {
-		return createErrorPanel(g, "Can only rename topmost commit")
-	}
-	createPromptPanel(g, v, "Rename Commit", func(g *gocui.Gui, v *gocui.View) error {
-		if output, err := gitRenameCommit(v.Buffer()); err != nil {
-			return createErrorPanel(g, output)
-		}
-		if err := refreshCommits(g); err != nil {
-			panic(err)
-		}
-		return handleCommitSelect(g, v)
-	})
-	return nil
-}
-
-func getSelectedCommit(g *gocui.Gui) (Commit, error) {
-	v, err := g.View("commits")
-	if err != nil {
-		panic(err)
-	}
-	if len(state.Commits) == 0 {
-		return Commit{}, ErrNoCommits
-	}
-	lineNumber := getItemPosition(v)
-	if lineNumber > len(state.Commits)-1 {
-		colorLog(color.FgRed, "potential error in getSelected Commit (mismatched ui and state)", state.Commits, lineNumber)
-		return state.Commits[len(state.Commits)-1], nil
-	}
-	return state.Commits[lineNumber], nil
-}

confirmation_panel.go

@@ -1,119 +0,0 @@
-// lots of this has been directly ported from one of the example files, will brush up later
-
-// Copyright 2014 The gocui Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/jesseduffield/gocui"
-)
-
-func wrappedConfirmationFunction(function func(*gocui.Gui, *gocui.View) error) func(*gocui.Gui, *gocui.View) error {
-	return func(g *gocui.Gui, v *gocui.View) error {
-		if function != nil {
-			if err := function(g, v); err != nil {
-				panic(err)
-			}
-		}
-		return closeConfirmationPrompt(g)
-	}
-}
-
-func closeConfirmationPrompt(g *gocui.Gui) error {
-	view, err := g.View("confirmation")
-	if err != nil {
-		panic(err)
-	}
-	if err := returnFocus(g, view); err != nil {
-		panic(err)
-	}
-	g.DeleteKeybindings("confirmation")
-	return g.DeleteView("confirmation")
-}
-
-func getMessageHeight(message string, width int) int {
-	lines := strings.Split(message, "\n")
-	lineCount := 0
-	for _, line := range lines {
-		lineCount += len(line)/width + 1
-	}
-	return lineCount
-}
-
-func getConfirmationPanelDimensions(g *gocui.Gui, prompt string) (int, int, int, int) {
-	width, height := g.Size()
-	panelWidth := 60
-	panelHeight := getMessageHeight(prompt, panelWidth)
-	return width/2 - panelWidth/2,
-		height/2 - panelHeight/2 - panelHeight%2 - 1,
-		width/2 + panelWidth/2,
-		height/2 + panelHeight/2
-}
-
-func createPromptPanel(g *gocui.Gui, currentView *gocui.View, title string, handleYes func(*gocui.Gui, *gocui.View) error) error {
-	// only need to fit one line
-	x0, y0, x1, y1 := getConfirmationPanelDimensions(g, "")
-	if confirmationView, err := g.SetView("confirmation", x0, y0, x1, y1, 0); err != nil {
-		if err != gocui.ErrUnknownView {
-			return err
-		}
-
-		g.Cursor = true
-
-		confirmationView.Editable = true
-		confirmationView.Title = title
-		confirmationView.FgColor = gocui.ColorWhite
-		switchFocus(g, currentView, confirmationView)
-		return setKeyBindings(g, handleYes, nil)
-	}
-	return nil
-}
-
-func createConfirmationPanel(g *gocui.Gui, currentView *gocui.View, title, prompt string, handleYes, handleNo func(*gocui.Gui, *gocui.View) error) error {
-	g.Update(func(g *gocui.Gui) error {
-		// delete the existing confirmation panel if it exists
-		if view, _ := g.View("confirmation"); view != nil {
-			if err := closeConfirmationPrompt(g); err != nil {
-				panic(err)
-			}
-		}
-		x0, y0, x1, y1 := getConfirmationPanelDimensions(g, prompt)
-		if confirmationView, err := g.SetView("confirmation", x0, y0, x1, y1, 0); err != nil {
-			if err != gocui.ErrUnknownView {
-				return err
-			}
-			confirmationView.Title = title
-			confirmationView.FgColor = gocui.ColorWhite
-			renderString(g, "confirmation", prompt)
-			switchFocus(g, currentView, confirmationView)
-			return setKeyBindings(g, handleYes, handleNo)
-		}
-		return nil
-	})
-	return nil
-}
-
-func setKeyBindings(g *gocui.Gui, handleYes, handleNo func(*gocui.Gui, *gocui.View) error) error {
-	renderString(g, "options", "esc: close, enter: confirm")
-	if err := g.SetKeybinding("confirmation", gocui.KeyEnter, gocui.ModNone, wrappedConfirmationFunction(handleYes)); err != nil {
-		return err
-	}
-
-	return g.SetKeybinding("confirmation", gocui.KeyEsc, gocui.ModNone, wrappedConfirmationFunction(handleNo))
-}
-
-func createMessagePanel(g *gocui.Gui, currentView *gocui.View, title, prompt string) error {
-	return createConfirmationPanel(g, currentView, title, prompt, nil, nil)
-}
-
-func createErrorPanel(g *gocui.Gui, message string) error {
-	currentView := g.CurrentView()
-	colorFunction := color.New(color.FgRed).SprintFunc()
-	coloredMessage := colorFunction(strings.TrimSpace(message))
-	return createConfirmationPanel(g, currentView, "Error", coloredMessage, nil, nil)
-}

docs/Keybindings.md

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

files_panel.go

@@ -1,329 +0,0 @@
-package main
-
-import (
-
-	// "io"
-	// "io/ioutil"
-
-	// "strings"
-
-	"errors"
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/jesseduffield/gocui"
-)
-
-var (
-	// ErrNoFiles : when there are no modified files in the repo
-	ErrNoFiles = errors.New("No changed files")
-)
-
-func stagedFiles(files []GitFile) []GitFile {
-	result := make([]GitFile, 0)
-	for _, file := range files {
-		if file.HasStagedChanges {
-			result = append(result, file)
-		}
-	}
-	return result
-}
-
-func stageSelectedFile(g *gocui.Gui) error {
-	file, err := getSelectedFile(g)
-	if err != nil {
-		return err
-	}
-	return stageFile(file.Name)
-}
-
-func handleFilePress(g *gocui.Gui, v *gocui.View) error {
-	file, err := getSelectedFile(g)
-	if err != nil {
-		if err == ErrNoFiles {
-			return nil
-		}
-		return err
-	}
-
-	if file.HasMergeConflicts {
-		return handleSwitchToMerge(g, v)
-	}
-
-	if file.HasUnstagedChanges {
-		stageFile(file.Name)
-	} else {
-		unStageFile(file.Name, file.Tracked)
-	}
-
-	if err := refreshFiles(g); err != nil {
-		return err
-	}
-
-	return handleFileSelect(g, v)
-}
-
-func getSelectedFile(g *gocui.Gui) (GitFile, error) {
-	if len(state.GitFiles) == 0 {
-		return GitFile{}, ErrNoFiles
-	}
-	filesView, err := g.View("files")
-	if err != nil {
-		panic(err)
-	}
-	lineNumber := getItemPosition(filesView)
-	return state.GitFiles[lineNumber], nil
-}
-
-func handleFileRemove(g *gocui.Gui, v *gocui.View) error {
-	file, err := getSelectedFile(g)
-	if err != nil {
-		if err == ErrNoFiles {
-			return nil
-		}
-		return err
-	}
-	var deleteVerb string
-	if file.Tracked {
-		deleteVerb = "checkout"
-	} else {
-		deleteVerb = "delete"
-	}
-	return createConfirmationPanel(g, v, strings.Title(deleteVerb)+" file", "Are you sure you want to "+deleteVerb+" "+file.Name+" (you will lose your changes)?", func(g *gocui.Gui, v *gocui.View) error {
-		if err := removeFile(file); err != nil {
-			panic(err)
-		}
-		return refreshFiles(g)
-	}, nil)
-}
-
-func handleIgnoreFile(g *gocui.Gui, v *gocui.View) error {
-	file, err := getSelectedFile(g)
-	if err != nil {
-		return createErrorPanel(g, err.Error())
-	}
-	if file.Tracked {
-		return createErrorPanel(g, "Cannot ignore tracked files")
-	}
-	gitIgnore(file.Name)
-	return refreshFiles(g)
-}
-
-func renderfilesOptions(g *gocui.Gui, gitFile *GitFile) error {
-	optionsMap := map[string]string{
-		"← → ↑ ↓": "navigate",
-		"S":       "stash files",
-		"c":       "commit changes",
-		"o":       "open",
-		"s":       "sublime",
-		"v":       "vscode",
-		"i":       "ignore",
-		"d":       "delete",
-		"space":   "toggle staged",
-		"R":       "refresh",
-	}
-	if state.HasMergeConflicts {
-		optionsMap["a"] = "abort merge"
-		optionsMap["m"] = "resolve merge conflicts"
-	}
-	if gitFile == nil {
-		return renderOptionsMap(g, optionsMap)
-	}
-	if gitFile.Tracked {
-		optionsMap["d"] = "checkout"
-	}
-	return renderOptionsMap(g, optionsMap)
-}
-
-func handleFileSelect(g *gocui.Gui, v *gocui.View) error {
-	gitFile, err := getSelectedFile(g)
-	if err != nil {
-		if err != ErrNoFiles {
-			return err
-		}
-		renderString(g, "main", "No changed files")
-		return renderfilesOptions(g, nil)
-	}
-	renderfilesOptions(g, &gitFile)
-	var content string
-	if gitFile.HasMergeConflicts {
-		return refreshMergePanel(g)
-	}
-
-	content = getDiff(gitFile)
-	return renderString(g, "main", content)
-}
-
-func handleCommitPress(g *gocui.Gui, filesView *gocui.View) error {
-	if len(stagedFiles(state.GitFiles)) == 0 && !state.HasMergeConflicts {
-		return createErrorPanel(g, "There are no staged files to commit")
-	}
-	createPromptPanel(g, filesView, "Commit message", func(g *gocui.Gui, v *gocui.View) error {
-		message := trimmedContent(v)
-		if message == "" {
-			return createErrorPanel(g, "You cannot commit without a commit message")
-		}
-		if output, err := gitCommit(message); err != nil {
-			return createErrorPanel(g, output)
-		}
-		refreshFiles(g)
-		return refreshCommits(g)
-	})
-	return nil
-}
-
-func genericFileOpen(g *gocui.Gui, v *gocui.View, open func(string) (string, error)) error {
-	file, err := getSelectedFile(g)
-	if err != nil {
-		if err != ErrNoFiles {
-			return err
-		}
-		return nil
-	}
-	if output, err := open(file.Name); err != nil {
-		return createErrorPanel(g, output)
-	}
-	return nil
-}
-
-func handleFileOpen(g *gocui.Gui, v *gocui.View) error {
-	return genericFileOpen(g, v, openFile)
-}
-func handleSublimeFileOpen(g *gocui.Gui, v *gocui.View) error {
-	return genericFileOpen(g, v, sublimeOpenFile)
-}
-func handleVsCodeFileOpen(g *gocui.Gui, v *gocui.View) error {
-	return genericFileOpen(g, v, vsCodeOpenFile)
-}
-
-func handleRefreshFiles(g *gocui.Gui, v *gocui.View) error {
-	return refreshFiles(g)
-}
-
-func refreshStateGitFiles() {
-	// get files to stage
-	gitFiles := getGitStatusFiles()
-	state.GitFiles = mergeGitStatusFiles(state.GitFiles, gitFiles)
-	updateHasMergeConflictStatus()
-}
-
-func updateHasMergeConflictStatus() error {
-	merging, err := isInMergeState()
-	if err != nil {
-		return err
-	}
-	state.HasMergeConflicts = merging
-	return nil
-}
-
-func renderGitFile(gitFile GitFile, filesView *gocui.View) {
-	// potentially inefficient to be instantiating these color
-	// objects with each render
-	red := color.New(color.FgRed)
-	green := color.New(color.FgGreen)
-	if !gitFile.Tracked && !gitFile.HasStagedChanges {
-		red.Fprintln(filesView, gitFile.DisplayString)
-		return
-	}
-	green.Fprint(filesView, gitFile.DisplayString[0:1])
-	red.Fprint(filesView, gitFile.DisplayString[1:3])
-	if gitFile.HasUnstagedChanges {
-		red.Fprintln(filesView, gitFile.Name)
-	} else {
-		green.Fprintln(filesView, gitFile.Name)
-	}
-}
-
-func catSelectedFile(g *gocui.Gui) (string, error) {
-	item, err := getSelectedFile(g)
-	if err != nil {
-		if err != ErrNoFiles {
-			return "", err
-		}
-		return "", renderString(g, "main", "No file to display")
-	}
-	cat, err := catFile(item.Name)
-	if err != nil {
-		panic(err)
-	}
-	return cat, nil
-}
-
-func refreshFiles(g *gocui.Gui) error {
-	filesView, err := g.View("files")
-	if err != nil {
-		return err
-	}
-	refreshStateGitFiles()
-	filesView.Clear()
-	for _, gitFile := range state.GitFiles {
-		renderGitFile(gitFile, filesView)
-	}
-	correctCursor(filesView)
-	if filesView == g.CurrentView() {
-		handleFileSelect(g, filesView)
-	}
-	return nil
-}
-
-func pullFiles(g *gocui.Gui, v *gocui.View) error {
-	devLog("pulling...")
-	createMessagePanel(g, v, "", "Pulling...")
-	go func() {
-		if output, err := gitPull(); err != nil {
-			createErrorPanel(g, output)
-		} else {
-			closeConfirmationPrompt(g)
-			refreshCommits(g)
-			refreshStatus(g)
-			devLog("pulled.")
-		}
-		refreshFiles(g)
-	}()
-	return nil
-}
-
-func pushFiles(g *gocui.Gui, v *gocui.View) error {
-	devLog("pushing...")
-	createMessagePanel(g, v, "", "Pushing...")
-	go func() {
-		if output, err := gitPush(); err != nil {
-			createErrorPanel(g, output)
-		} else {
-			closeConfirmationPrompt(g)
-			refreshCommits(g)
-			refreshStatus(g)
-			devLog("pushed.")
-		}
-	}()
-	return nil
-}
-
-func handleSwitchToMerge(g *gocui.Gui, v *gocui.View) error {
-	mergeView, err := g.View("main")
-	if err != nil {
-		return err
-	}
-	file, err := getSelectedFile(g)
-	if err != nil {
-		if err != ErrNoFiles {
-			return err
-		}
-		return nil
-	}
-	if !file.HasMergeConflicts {
-		return createErrorPanel(g, "This file has no merge conflicts")
-	}
-	switchFocus(g, v, mergeView)
-	return refreshMergePanel(g)
-}
-
-func handleAbortMerge(g *gocui.Gui, v *gocui.View) error {
-	output, err := gitAbortMerge()
-	if err != nil {
-		return createErrorPanel(g, output)
-	}
-	createMessagePanel(g, v, "", "Merge aborted")
-	refreshStatus(g)
-	return refreshFiles(g)
-}

gitcommands.go

@@ -1,586 +0,0 @@
-package main
-
-import (
-
-	// "log"
-	"errors"
-	"fmt"
-	"os"
-	"os/exec"
-	"regexp"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/fatih/color"
-)
-
-var (
-	// ErrNoCheckedOutBranch : When we have no checked out branch
-	ErrNoCheckedOutBranch = errors.New("No currently checked out branch")
-)
-
-// GitFile : A staged/unstaged file
-// TODO: decide whether to give all of these the Git prefix
-type GitFile struct {
-	Name               string
-	HasStagedChanges   bool
-	HasUnstagedChanges bool
-	Tracked            bool
-	Deleted            bool
-	HasMergeConflicts  bool
-	DisplayString      string
-}
-
-// Branch : A git branch
-type Branch struct {
-	Name          string
-	Type          string
-	BaseBranch    string
-	DisplayString string
-}
-
-// Commit : A git commit
-type Commit struct {
-	Sha           string
-	Name          string
-	Pushed        bool
-	DisplayString string
-}
-
-// StashEntry : A git stash entry
-type StashEntry struct {
-	Index         int
-	Name          string
-	DisplayString string
-}
-
-// Map (from https://gobyexample.com/collection-functions)
-func Map(vs []string, f func(string) string) []string {
-	vsm := make([]string, len(vs))
-	for i, v := range vs {
-		vsm[i] = f(v)
-	}
-	return vsm
-}
-
-func includesString(list []string, a string) bool {
-	for _, b := range list {
-		if b == a {
-			return true
-		}
-	}
-	return false
-}
-
-// not sure how to genericise this because []interface{} doesn't accept e.g.
-// []int arguments
-func includesInt(list []int, a int) bool {
-	for _, b := range list {
-		if b == a {
-			return true
-		}
-	}
-	return false
-}
-
-func mergeGitStatusFiles(oldGitFiles, newGitFiles []GitFile) []GitFile {
-	if len(oldGitFiles) == 0 {
-		return newGitFiles
-	}
-
-	appendedIndexes := make([]int, 0)
-
-	// retain position of files we already could see
-	result := make([]GitFile, 0)
-	for _, oldGitFile := range oldGitFiles {
-		for newIndex, newGitFile := range newGitFiles {
-			if oldGitFile.Name == newGitFile.Name {
-				result = append(result, newGitFile)
-				appendedIndexes = append(appendedIndexes, newIndex)
-				break
-			}
-		}
-	}
-
-	// append any new files to the end
-	for index, newGitFile := range newGitFiles {
-		if !includesInt(appendedIndexes, index) {
-			result = append(result, newGitFile)
-		}
-	}
-
-	return result
-}
-
-func platformShell() (string, string) {
-	if runtime.GOOS == "windows" {
-		return "cmd", "/c"
-	}
-	return "bash", "-c"
-}
-
-func runDirectCommand(command string) (string, error) {
-	timeStart := time.Now()
-	commandLog(command)
-
-	shell, shellArg := platformShell()
-	cmdOut, err := exec.
-		Command(shell, shellArg, command).
-		CombinedOutput()
-	devLog("run direct command time for command: ", command, time.Now().Sub(timeStart))
-	return sanitisedCommandOutput(cmdOut, err)
-}
-
-func branchStringParts(branchString string) (string, string) {
-	// expect string to be something like '4w    master`
-	splitBranchName := strings.Split(branchString, "\t")
-	// if we have no \t then we have no recency, so just output that as blank
-	if len(splitBranchName) == 1 {
-		return "", branchString
-	}
-	return splitBranchName[0], splitBranchName[1]
-}
-
-// branchPropertiesFromName : returns branch type, base, and color
-func branchPropertiesFromName(name string) (string, string, color.Attribute) {
-	if strings.Contains(name, "feature/") {
-		return "feature", "develop", color.FgGreen
-	} else if strings.Contains(name, "bugfix/") {
-		return "bugfix", "develop", color.FgYellow
-	} else if strings.Contains(name, "hotfix/") {
-		return "hotfix", "master", color.FgRed
-	}
-	return "other", name, color.FgWhite
-}
-
-func coloredString(str string, colour *color.Color) string {
-	return colour.SprintFunc()(fmt.Sprint(str))
-}
-
-func withPadding(str string, padding int) string {
-	if padding-len(str) < 0 {
-		return str
-	}
-	return str + strings.Repeat(" ", padding-len(str))
-}
-
-// TODO: DRY up this function and getGitBranches
-func getGitStashEntries() []StashEntry {
-	stashEntries := make([]StashEntry, 0)
-	rawString, _ := runDirectCommand("git stash list --pretty='%gs'")
-	for i, line := range splitLines(rawString) {
-		stashEntries = append(stashEntries, stashEntryFromLine(line, i))
-	}
-	return stashEntries
-}
-
-func stashEntryFromLine(line string, index int) StashEntry {
-	return StashEntry{
-		Name:          line,
-		Index:         index,
-		DisplayString: line,
-	}
-}
-
-func getStashEntryDiff(index int) (string, error) {
-	return runCommand("git stash show -p --color stash@{" + fmt.Sprint(index) + "}")
-}
-
-func includes(array []string, str string) bool {
-	for _, arrayStr := range array {
-		if arrayStr == str {
-			return true
-		}
-	}
-	return false
-}
-
-func getGitStatusFiles() []GitFile {
-	statusOutput, _ := getGitStatus()
-	statusStrings := splitLines(statusOutput)
-	gitFiles := make([]GitFile, 0)
-
-	for _, statusString := range statusStrings {
-		change := statusString[0:2]
-		stagedChange := change[0:1]
-		unstagedChange := statusString[1:2]
-		filename := statusString[3:]
-		tracked := !includes([]string{"??", "A "}, change)
-		gitFile := GitFile{
-			Name:               filename,
-			DisplayString:      statusString,
-			HasStagedChanges:   !includes([]string{" ", "U", "?"}, stagedChange),
-			HasUnstagedChanges: unstagedChange != " ",
-			Tracked:            tracked,
-			Deleted:            unstagedChange == "D" || stagedChange == "D",
-			HasMergeConflicts:  change == "UU",
-		}
-		devLog("tracked", gitFile.Tracked)
-		devLog("hasUnstagedChanges", gitFile.HasUnstagedChanges)
-		devLog("HasStagedChanges", gitFile.HasStagedChanges)
-		devLog("DisplayString", gitFile.DisplayString)
-		gitFiles = append(gitFiles, gitFile)
-	}
-	devLog(gitFiles)
-	return gitFiles
-}
-
-func gitStashDo(index int, method string) (string, error) {
-	return runCommand("git stash " + method + " stash@{" + fmt.Sprint(index) + "}")
-}
-
-func gitStashSave(message string) (string, error) {
-	output, err := runCommand("git stash save \"" + message + "\"")
-	if err != nil {
-		return output, err
-	}
-	// if there are no local changes to save, the exit code is 0, but we want
-	// to raise an error
-	if output == "No local changes to save\n" {
-		return output, errors.New(output)
-	}
-	return output, nil
-}
-
-func gitCheckout(branch string, force bool) (string, error) {
-	forceArg := ""
-	if force {
-		forceArg = "--force "
-	}
-	return runCommand("git checkout " + forceArg + branch)
-}
-
-func sanitisedCommandOutput(output []byte, err error) (string, error) {
-	outputString := string(output)
-	if outputString == "" && err != nil {
-		return err.Error(), err
-	}
-	return outputString, err
-}
-
-func runCommand(command string) (string, error) {
-	commandStartTime := time.Now()
-	commandLog(command)
-	splitCmd := strings.Split(command, " ")
-	cmdOut, err := exec.Command(splitCmd[0], splitCmd[1:]...).CombinedOutput()
-	devLog("run command time: ", time.Now().Sub(commandStartTime))
-	return sanitisedCommandOutput(cmdOut, err)
-}
-
-func openFile(filename string) (string, error) {
-	return runCommand("open " + filename)
-}
-
-func vsCodeOpenFile(filename string) (string, error) {
-	return runCommand("code -r " + filename)
-}
-
-func sublimeOpenFile(filename string) (string, error) {
-	return runCommand("subl " + filename)
-}
-
-func getBranchGraph(branch string, baseBranch string) (string, error) {
-	return runCommand("git log --graph --color --abbrev-commit --decorate --date=relative --pretty=medium -100 " + branch)
-
-	// Leaving this guy commented out in case there's backlash from the design
-	// change and I want to make this configurable
-	// return runCommand("git log -p -30 --color --no-merges " + branch)
-}
-
-func verifyInGitRepo() {
-	if output, err := runCommand("git status"); err != nil {
-		fmt.Println(output)
-		os.Exit(1)
-	}
-}
-
-func getCommits() []Commit {
-	pushables := gitCommitsToPush()
-	log := getLog()
-	commits := make([]Commit, 0)
-	// now we can split it up and turn it into commits
-	lines := splitLines(log)
-	for _, line := range lines {
-		splitLine := strings.Split(line, " ")
-		sha := splitLine[0]
-		pushed := includesString(pushables, sha)
-		commits = append(commits, Commit{
-			Sha:           sha,
-			Name:          strings.Join(splitLine[1:], " "),
-			Pushed:        pushed,
-			DisplayString: strings.Join(splitLine, " "),
-		})
-	}
-	return commits
-}
-
-func getLog() string {
-	// currently limiting to 30 for performance reasons
-	// TODO: add lazyloading when you scroll down
-	result, err := runDirectCommand("git log --oneline -30")
-	if err != nil {
-		// assume if there is an error there are no commits yet for this branch
-		return ""
-	}
-	return result
-}
-
-func gitIgnore(filename string) {
-	if _, err := runDirectCommand("echo '" + filename + "' >> .gitignore"); err != nil {
-		panic(err)
-	}
-}
-
-func gitShow(sha string) string {
-	result, err := runDirectCommand("git show --color " + sha)
-	if err != nil {
-		panic(err)
-	}
-	return result
-}
-
-func getDiff(file GitFile) string {
-	cachedArg := ""
-	if file.HasStagedChanges && !file.HasUnstagedChanges {
-		cachedArg = "--cached "
-	}
-	deletedArg := ""
-	if file.Deleted {
-		deletedArg = "-- "
-	}
-	trackedArg := ""
-	if !file.Tracked && !file.HasStagedChanges {
-		trackedArg = "--no-index /dev/null "
-	}
-	command := "git diff --color " + cachedArg + deletedArg + trackedArg + file.Name
-	// for now we assume an error means the file was deleted
-	s, _ := runCommand(command)
-	return s
-}
-
-func catFile(file string) (string, error) {
-	return runDirectCommand("cat " + file)
-}
-
-func stageFile(file string) error {
-	_, err := runCommand("git add " + file)
-	return err
-}
-
-func unStageFile(file string, tracked bool) error {
-	var command string
-	if tracked {
-		command = "git reset HEAD "
-	} else {
-		command = "git rm --cached "
-	}
-	devLog(command)
-	_, err := runCommand(command + file)
-	return err
-}
-
-func getGitStatus() (string, error) {
-	return runCommand("git status --untracked-files=all --short")
-}
-
-func isInMergeState() (bool, error) {
-	output, err := runCommand("git status --untracked-files=all")
-	if err != nil {
-		return false, err
-	}
-	return strings.Contains(output, "conclude merge") || strings.Contains(output, "unmerged paths"), nil
-}
-
-func removeFile(file GitFile) error {
-	// if the file isn't tracked, we assume you want to delete it
-	if !file.Tracked {
-		_, err := runCommand("rm -rf ./" + file.Name)
-		return err
-	}
-	// if the file is tracked, we assume you want to just check it out
-	_, err := runCommand("git checkout " + file.Name)
-	return err
-}
-
-func gitCommit(message string) (string, error) {
-	return runDirectCommand("git commit -m \"" + message + "\"")
-}
-
-func gitPull() (string, error) {
-	return runDirectCommand("git pull --no-edit")
-}
-
-func gitPush() (string, error) {
-	branchName := gitCurrentBranchName()
-	if branchName == "" {
-		return "", ErrNoCheckedOutBranch
-	}
-	return runDirectCommand("git push -u origin " + branchName)
-}
-
-func gitSquashPreviousTwoCommits(message string) (string, error) {
-	return runDirectCommand("git reset --soft HEAD^ && git commit --amend -m \"" + message + "\"")
-}
-
-func gitRenameCommit(message string) (string, error) {
-	return runDirectCommand("git commit --allow-empty --amend -m \"" + message + "\"")
-}
-
-func gitFetch() (string, error) {
-	return runDirectCommand("git fetch")
-}
-
-func gitResetToCommit(sha string) (string, error) {
-	return runDirectCommand("git reset " + sha)
-}
-
-func gitNewBranch(name string) (string, error) {
-	return runDirectCommand("git checkout -b " + name)
-}
-
-func gitListStash() (string, error) {
-	return runDirectCommand("git stash list")
-}
-
-func gitMerge(branchName string) (string, error) {
-	return runDirectCommand("git merge --no-edit " + branchName)
-}
-
-func gitAbortMerge() (string, error) {
-	return runDirectCommand("git merge --abort")
-}
-
-func gitUpstreamDifferenceCount() (string, string) {
-	pushableCount, err := runDirectCommand("git rev-list @{u}..head --count")
-	if err != nil {
-		return "?", "?"
-	}
-	pullableCount, err := runDirectCommand("git rev-list head..@{u} --count")
-	if err != nil {
-		return "?", "?"
-	}
-	return strings.TrimSpace(pushableCount), strings.TrimSpace(pullableCount)
-}
-
-func gitCommitsToPush() []string {
-	pushables, err := runDirectCommand("git rev-list @{u}..head --abbrev-commit")
-	if err != nil {
-		return make([]string, 0)
-	}
-	return splitLines(pushables)
-}
-
-func gitCurrentBranchName() string {
-	branchName, err := runDirectCommand("git symbolic-ref --short HEAD")
-	// if there is an error, assume there are no branches yet
-	if err != nil {
-		return ""
-	}
-	return strings.TrimSpace(branchName)
-}
-
-// A line will have the form '10 days ago master' so we need to strip out the
-// useful information from that into timeNumber, timeUnit, and branchName
-func branchInfoFromLine(line string) (string, string, string) {
-	r := regexp.MustCompile("\\|.*\\s")
-	line = r.ReplaceAllString(line, " ")
-	words := strings.Split(line, " ")
-	return words[0], words[1], words[3]
-}
-
-func abbreviatedTimeUnit(timeUnit string) string {
-	r := regexp.MustCompile("s$")
-	timeUnit = r.ReplaceAllString(timeUnit, "")
-	timeUnitMap := map[string]string{
-		"hour":   "h",
-		"minute": "m",
-		"second": "s",
-		"week":   "w",
-		"year":   "y",
-		"day":    "d",
-		"month":  "m",
-	}
-	return timeUnitMap[timeUnit]
-}
-
-func getBranches() []Branch {
-	branches := make([]Branch, 0)
-	rawString, err := runDirectCommand("git reflog -n100 --pretty='%cr|%gs' --grep-reflog='checkout: moving' HEAD")
-	if err != nil {
-		return branches
-	}
-
-	branchLines := splitLines(rawString)
-	for i, line := range branchLines {
-		timeNumber, timeUnit, branchName := branchInfoFromLine(line)
-		timeUnit = abbreviatedTimeUnit(timeUnit)
-
-		if branchAlreadyStored(branchName, branches) {
-			continue
-		}
-
-		branch := constructBranch(timeNumber+timeUnit, branchName, i)
-		branches = append(branches, branch)
-	}
-	return branches
-}
-
-func constructBranch(prefix, name string, index int) Branch {
-	branchType, branchBase, colourAttr := branchPropertiesFromName(name)
-	if index == 0 {
-		prefix = "  *"
-	}
-	colour := color.New(colourAttr)
-	displayString := withPadding(prefix, 4) + coloredString(name, colour)
-	return Branch{
-		Name:          name,
-		Type:          branchType,
-		BaseBranch:    branchBase,
-		DisplayString: displayString,
-	}
-}
-
-func getGitBranches() []Branch {
-	// check if there are any branches
-	branchCheck, _ := runCommand("git branch")
-	if branchCheck == "" {
-		return []Branch{constructBranch("", gitCurrentBranchName(), 0)}
-	}
-	branches := getBranches()
-	if len(branches) == 0 {
-		branches = append(branches, constructBranch("", gitCurrentBranchName(), 0))
-	}
-	branches = getAndMergeFetchedBranches(branches)
-	return branches
-}
-
-func branchAlreadyStored(branchName string, branches []Branch) bool {
-	for _, existingBranch := range branches {
-		if existingBranch.Name == branchName {
-			return true
-		}
-	}
-	return false
-}
-
-// here branches contains all the branches that we've checked out, along with
-// the recency. In this function we append the branches that are in our heads
-// directory i.e. things we've fetched but haven't necessarily checked out.
-// Worth mentioning this has nothing to do with the 'git merge' operation
-func getAndMergeFetchedBranches(branches []Branch) []Branch {
-	rawString, err := runDirectCommand("git branch --sort=-committerdate --no-color")
-	if err != nil {
-		return branches
-	}
-	branchLines := splitLines(rawString)
-	for _, line := range branchLines {
-		line = strings.Replace(line, "* ", "", -1)
-		line = strings.TrimSpace(line)
-		if branchAlreadyStored(line, branches) {
-			continue
-		}
-		branches = append(branches, constructBranch("", line, len(branches)))
-	}
-	return branches
-}

gui.go

@@ -1,297 +0,0 @@
-package main
-
-import (
-
-	// "io"
-	// "io/ioutil"
-
-	"log"
-	"runtime"
-	"strings"
-	"time"
-
-	// "strings"
-
-	"github.com/golang-collections/collections/stack"
-	"github.com/jesseduffield/gocui"
-)
-
-// OverlappingEdges determines if panel edges overlap
-var OverlappingEdges = false
-
-type stateType struct {
-	GitFiles          []GitFile
-	Branches          []Branch
-	Commits           []Commit
-	StashEntries      []StashEntry
-	PreviousView      string
-	HasMergeConflicts bool
-	ConflictIndex     int
-	ConflictTop       bool
-	Conflicts         []conflict
-	EditHistory       *stack.Stack
-}
-
-type conflict struct {
-	start  int
-	middle int
-	end    int
-}
-
-var state = stateType{
-	GitFiles:      make([]GitFile, 0),
-	PreviousView:  "files",
-	Commits:       make([]Commit, 0),
-	StashEntries:  make([]StashEntry, 0),
-	ConflictIndex: 0,
-	ConflictTop:   true,
-	Conflicts:     make([]conflict, 0),
-	EditHistory:   stack.New(),
-}
-
-func scrollUpMain(g *gocui.Gui, v *gocui.View) error {
-	mainView, _ := g.View("main")
-	ox, oy := mainView.Origin()
-	if oy >= 1 {
-		return mainView.SetOrigin(ox, oy-1)
-	}
-	return nil
-}
-
-func scrollDownMain(g *gocui.Gui, v *gocui.View) error {
-	mainView, _ := g.View("main")
-	ox, oy := mainView.Origin()
-	if oy < len(mainView.BufferLines()) {
-		return mainView.SetOrigin(ox, oy+1)
-	}
-	return nil
-}
-
-func handleRefresh(g *gocui.Gui, v *gocui.View) error {
-	return refreshSidePanels(g)
-}
-
-// Binding - a keybinding mapping a key and modifier to a handler. The keypress
-// is only handled if the given view has focus, or handled globally if the view
-// is ""
-type Binding struct {
-	ViewName string
-	Handler  func(*gocui.Gui, *gocui.View) error
-	Key      interface{} // FIXME: find out how to get `gocui.Key | rune`
-	Modifier gocui.Modifier
-}
-
-func keybindings(g *gocui.Gui) error {
-	bindings := []Binding{
-		Binding{ViewName: "", Key: gocui.KeyArrowLeft, Modifier: gocui.ModNone, Handler: previousView},
-		Binding{ViewName: "", Key: gocui.KeyArrowRight, Modifier: gocui.ModNone, Handler: nextView},
-		Binding{ViewName: "", Key: gocui.KeyTab, Modifier: gocui.ModNone, Handler: nextView},
-		Binding{ViewName: "", Key: 'q', Modifier: gocui.ModNone, Handler: quit},
-		Binding{ViewName: "", Key: gocui.KeyCtrlC, Modifier: gocui.ModNone, Handler: quit},
-		Binding{ViewName: "", Key: gocui.KeyArrowDown, Modifier: gocui.ModNone, Handler: cursorDown},
-		Binding{ViewName: "", Key: gocui.KeyArrowUp, Modifier: gocui.ModNone, Handler: cursorUp},
-		Binding{ViewName: "", Key: gocui.KeyPgup, Modifier: gocui.ModNone, Handler: scrollUpMain},
-		Binding{ViewName: "", Key: gocui.KeyPgdn, Modifier: gocui.ModNone, Handler: scrollDownMain},
-		Binding{ViewName: "", Key: 'P', Modifier: gocui.ModNone, Handler: pushFiles},
-		Binding{ViewName: "", Key: 'p', Modifier: gocui.ModNone, Handler: pullFiles},
-		Binding{ViewName: "", Key: 'R', Modifier: gocui.ModNone, Handler: handleRefresh},
-		Binding{ViewName: "files", Key: 'c', Modifier: gocui.ModNone, Handler: handleCommitPress},
-		Binding{ViewName: "files", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: handleFilePress},
-		Binding{ViewName: "files", Key: 'd', Modifier: gocui.ModNone, Handler: handleFileRemove},
-		Binding{ViewName: "files", Key: 'm', Modifier: gocui.ModNone, Handler: handleSwitchToMerge},
-		Binding{ViewName: "files", Key: 'o', Modifier: gocui.ModNone, Handler: handleFileOpen},
-		Binding{ViewName: "files", Key: 's', Modifier: gocui.ModNone, Handler: handleSublimeFileOpen},
-		Binding{ViewName: "files", Key: 'v', Modifier: gocui.ModNone, Handler: handleVsCodeFileOpen},
-		Binding{ViewName: "files", Key: 'i', Modifier: gocui.ModNone, Handler: handleIgnoreFile},
-		Binding{ViewName: "files", Key: 'r', Modifier: gocui.ModNone, Handler: handleRefreshFiles},
-		Binding{ViewName: "files", Key: 'S', Modifier: gocui.ModNone, Handler: handleStashSave},
-		Binding{ViewName: "files", Key: 'a', Modifier: gocui.ModNone, Handler: handleAbortMerge},
-		Binding{ViewName: "main", Key: gocui.KeyArrowUp, Modifier: gocui.ModNone, Handler: handleSelectTop},
-		Binding{ViewName: "main", Key: gocui.KeyArrowDown, Modifier: gocui.ModNone, Handler: handleSelectBottom},
-		Binding{ViewName: "main", Key: gocui.KeyEsc, Modifier: gocui.ModNone, Handler: handleEscapeMerge},
-		Binding{ViewName: "main", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: handlePickHunk},
-		Binding{ViewName: "main", Key: 'b', Modifier: gocui.ModNone, Handler: handlePickBothHunks},
-		Binding{ViewName: "main", Key: gocui.KeyArrowLeft, Modifier: gocui.ModNone, Handler: handleSelectPrevConflict},
-		Binding{ViewName: "main", Key: gocui.KeyArrowRight, Modifier: gocui.ModNone, Handler: handleSelectNextConflict},
-		Binding{ViewName: "main", Key: 'z', Modifier: gocui.ModNone, Handler: handlePopFileSnapshot},
-		Binding{ViewName: "branches", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: handleBranchPress},
-		Binding{ViewName: "branches", Key: 'c', Modifier: gocui.ModNone, Handler: handleCheckoutByName},
-		Binding{ViewName: "branches", Key: 'F', Modifier: gocui.ModNone, Handler: handleForceCheckout},
-		Binding{ViewName: "branches", Key: 'n', Modifier: gocui.ModNone, Handler: handleNewBranch},
-		Binding{ViewName: "branches", Key: 'm', Modifier: gocui.ModNone, Handler: handleMerge},
-		Binding{ViewName: "commits", Key: 's', Modifier: gocui.ModNone, Handler: handleCommitSquashDown},
-		Binding{ViewName: "commits", Key: 'r', Modifier: gocui.ModNone, Handler: handleRenameCommit},
-		Binding{ViewName: "commits", Key: 'g', Modifier: gocui.ModNone, Handler: handleResetToCommit},
-		Binding{ViewName: "stash", Key: gocui.KeySpace, Modifier: gocui.ModNone, Handler: handleStashApply},
-		Binding{ViewName: "stash", Key: 'k', Modifier: gocui.ModNone, Handler: handleStashPop},
-		Binding{ViewName: "stash", Key: 'd', Modifier: gocui.ModNone, Handler: handleStashDrop},
-	}
-	for _, binding := range bindings {
-		if err := g.SetKeybinding(binding.ViewName, binding.Key, binding.Modifier, binding.Handler); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func layout(g *gocui.Gui) error {
-	g.Highlight = true
-	g.SelFgColor = gocui.ColorWhite | gocui.AttrBold
-	if runtime.GOOS != "windows" {
-		g.FgColor = gocui.ColorBlack
-	}
-	width, height := g.Size()
-	leftSideWidth := width / 3
-	statusFilesBoundary := 2
-	filesBranchesBoundary := 2 * height / 5   // height - 20
-	commitsBranchesBoundary := 3 * height / 5 // height - 10
-	commitsStashBoundary := height - 5        // height - 5
-	minimumHeight := 16
-
-	panelSpacing := 1
-	if OverlappingEdges {
-		panelSpacing = 0
-	}
-
-	if height < minimumHeight {
-		v, err := g.SetView("limit", 0, 0, width-1, height-1, 0)
-		if err != nil {
-			if err != gocui.ErrUnknownView {
-				return err
-			}
-			v.Title = "Not enough space to render panels"
-			v.Wrap = true
-		}
-		return nil
-	}
-
-	g.DeleteView("limit")
-
-	optionsTop := height - 2
-	// hiding options if there's not enough space
-	if height < 30 {
-		optionsTop = height - 1
-	}
-
-	v, err := g.SetView("main", leftSideWidth+panelSpacing, 0, width-1, optionsTop, gocui.LEFT)
-	if err != nil {
-		if err != gocui.ErrUnknownView {
-			return err
-		}
-		v.Title = "Diff"
-		v.Wrap = true
-		v.FgColor = gocui.ColorWhite
-	}
-
-	if v, err := g.SetView("status", 0, 0, leftSideWidth, statusFilesBoundary, gocui.BOTTOM|gocui.RIGHT); err != nil {
-		if err != gocui.ErrUnknownView {
-			return err
-		}
-		v.Title = "Status"
-		v.FgColor = gocui.ColorWhite
-	}
-
-	filesView, err := g.SetView("files", 0, statusFilesBoundary+panelSpacing, leftSideWidth, filesBranchesBoundary, gocui.TOP|gocui.BOTTOM)
-	if err != nil {
-		if err != gocui.ErrUnknownView {
-			return err
-		}
-		filesView.Highlight = true
-		filesView.Title = "Files"
-		v.FgColor = gocui.ColorWhite
-	}
-
-	if v, err := g.SetView("branches", 0, filesBranchesBoundary+panelSpacing, leftSideWidth, commitsBranchesBoundary, gocui.TOP|gocui.BOTTOM); err != nil {
-		if err != gocui.ErrUnknownView {
-			return err
-		}
-		v.Title = "Branches"
-		v.FgColor = gocui.ColorWhite
-	}
-
-	if v, err := g.SetView("commits", 0, commitsBranchesBoundary+panelSpacing, leftSideWidth, commitsStashBoundary, gocui.TOP|gocui.BOTTOM); err != nil {
-		if err != gocui.ErrUnknownView {
-			return err
-		}
-		v.Title = "Commits"
-		v.FgColor = gocui.ColorWhite
-	}
-
-	if v, err := g.SetView("stash", 0, commitsStashBoundary+panelSpacing, leftSideWidth, optionsTop, gocui.TOP|gocui.RIGHT); err != nil {
-		if err != gocui.ErrUnknownView {
-			return err
-		}
-		v.Title = "Stash"
-		v.FgColor = gocui.ColorWhite
-	}
-
-	if v, err := g.SetView("options", -1, optionsTop, width, optionsTop+2, 0); err != nil {
-		if err != gocui.ErrUnknownView {
-			return err
-		}
-		v.BgColor = gocui.ColorDefault
-		v.FgColor = gocui.ColorBlue
-		v.Frame = false
-		v.Title = "Options"
-
-		// these are only called once
-		handleFileSelect(g, filesView)
-		refreshFiles(g)
-		refreshBranches(g)
-		refreshCommits(g)
-		refreshStashEntries(g)
-		nextView(g, nil)
-	}
-
-	return nil
-}
-
-func fetch(g *gocui.Gui) {
-	gitFetch()
-	refreshStatus(g)
-}
-
-func updateLoader(g *gocui.Gui) {
-	if confirmationView, _ := g.View("confirmation"); confirmationView != nil {
-		content := trimmedContent(confirmationView)
-		if strings.Contains(content, "...") {
-			staticContent := strings.Split(content, "...")[0] + "..."
-			renderString(g, "confirmation", staticContent+" "+loader())
-		}
-	}
-}
-
-func run() {
-	g, err := gocui.NewGui(gocui.OutputNormal, OverlappingEdges)
-	if err != nil {
-		log.Panicln(err)
-	}
-	defer g.Close()
-
-	// periodically fetching to check for upstream differences
-	go func() {
-		for range time.Tick(time.Second * 60) {
-			fetch(g)
-		}
-	}()
-
-	go func() {
-		for range time.Tick(time.Millisecond * 10) {
-			updateLoader(g)
-		}
-	}()
-
-	g.SetManagerFunc(layout)
-
-	if err := keybindings(g); err != nil {
-		log.Panicln(err)
-	}
-
-	if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
-		log.Panicln(err)
-	}
-}
-
-func quit(g *gocui.Gui, v *gocui.View) error {
-	return gocui.ErrQuit
-}

main.go

@@ -1,69 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"os"
-	"os/user"
-	"time"
-
-	"github.com/fatih/color"
-)
-
-var (
-	startTime time.Time
-	debugging bool
-)
-
-func homeDirectory() string {
-	usr, err := user.Current()
-	if err != nil {
-		log.Fatal(err)
-	}
-	return usr.HomeDir
-}
-
-func devLog(objects ...interface{}) {
-	localLog(color.FgWhite, homeDirectory()+"/go/src/github.com/jesseduffield/lazygit/development.log", objects...)
-}
-
-func colorLog(colour color.Attribute, objects ...interface{}) {
-	localLog(colour, homeDirectory()+"/go/src/github.com/jesseduffield/lazygit/development.log", objects...)
-}
-
-func commandLog(objects ...interface{}) {
-	localLog(color.FgWhite, homeDirectory()+"/go/src/github.com/jesseduffield/lazygit/commands.log", objects...)
-}
-
-func localLog(colour color.Attribute, path string, objects ...interface{}) {
-	if !debugging {
-		return
-	}
-	f, _ := os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0644)
-	defer f.Close()
-	for _, object := range objects {
-		colorFunction := color.New(colour).SprintFunc()
-		f.WriteString(colorFunction(fmt.Sprint(object)) + "\n")
-	}
-}
-
-func navigateToRepoRootDirectory() {
-	_, err := os.Stat(".git")
-	for os.IsNotExist(err) {
-		devLog("going up a directory to find the root")
-		os.Chdir("..")
-		_, err = os.Stat(".git")
-	}
-}
-
-func main() {
-	debuggingPointer := flag.Bool("debug", false, "a boolean")
-	flag.Parse()
-	debugging = *debuggingPointer
-	devLog("\n\n\n\n\n\n\n\n\n\n")
-	startTime = time.Now()
-	verifyInGitRepo()
-	navigateToRepoRootDirectory()
-	run()
-}

merge_panel.go

@@ -1,264 +0,0 @@
-// though this panel is called the merge panel, it's really going to use the main panel. This may change in the future
-
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"io/ioutil"
-	"math"
-	"os"
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/jesseduffield/gocui"
-)
-
-func findConflicts(content string) ([]conflict, error) {
-	conflicts := make([]conflict, 0)
-	var newConflict conflict
-	for i, line := range splitLines(content) {
-		if line == "<<<<<<< HEAD" || line == "<<<<<<< MERGE_HEAD" || line == "<<<<<<< Updated upstream" {
-			newConflict = conflict{start: i}
-		} else if line == "=======" {
-			newConflict.middle = i
-		} else if strings.HasPrefix(line, ">>>>>>> ") {
-			newConflict.end = i
-			conflicts = append(conflicts, newConflict)
-		}
-	}
-	return conflicts, nil
-}
-
-func shiftConflict(conflicts []conflict) (conflict, []conflict) {
-	return conflicts[0], conflicts[1:]
-}
-
-func shouldHighlightLine(index int, conflict conflict, top bool) bool {
-	return (index >= conflict.start && index <= conflict.middle && top) || (index >= conflict.middle && index <= conflict.end && !top)
-}
-
-func coloredConflictFile(content string, conflicts []conflict, conflictIndex int, conflictTop, hasFocus bool) (string, error) {
-	if len(conflicts) == 0 {
-		return content, nil
-	}
-	conflict, remainingConflicts := shiftConflict(conflicts)
-	var outputBuffer bytes.Buffer
-	for i, line := range splitLines(content) {
-		colourAttr := color.FgWhite
-		if i == conflict.start || i == conflict.middle || i == conflict.end {
-			colourAttr = color.FgRed
-		}
-		colour := color.New(colourAttr)
-		if hasFocus && conflictIndex < len(conflicts) && conflicts[conflictIndex] == conflict && shouldHighlightLine(i, conflict, conflictTop) {
-			colour.Add(color.Bold)
-		}
-		if i == conflict.end && len(remainingConflicts) > 0 {
-			conflict, remainingConflicts = shiftConflict(remainingConflicts)
-		}
-		outputBuffer.WriteString(coloredString(line, colour) + "\n")
-	}
-	return outputBuffer.String(), nil
-}
-
-func handleSelectTop(g *gocui.Gui, v *gocui.View) error {
-	state.ConflictTop = true
-	return refreshMergePanel(g)
-}
-
-func handleSelectBottom(g *gocui.Gui, v *gocui.View) error {
-	state.ConflictTop = false
-	return refreshMergePanel(g)
-}
-
-func handleSelectNextConflict(g *gocui.Gui, v *gocui.View) error {
-	if state.ConflictIndex >= len(state.Conflicts)-1 {
-		return nil
-	}
-	state.ConflictIndex++
-	return refreshMergePanel(g)
-}
-
-func handleSelectPrevConflict(g *gocui.Gui, v *gocui.View) error {
-	if state.ConflictIndex <= 0 {
-		return nil
-	}
-	state.ConflictIndex--
-	return refreshMergePanel(g)
-}
-
-func isIndexToDelete(i int, conflict conflict, pick string) bool {
-	return i == conflict.middle ||
-		i == conflict.start ||
-		i == conflict.end ||
-		pick != "both" &&
-			(pick == "bottom" && i > conflict.start && i < conflict.middle) ||
-		(pick == "top" && i > conflict.middle && i < conflict.end)
-}
-
-func resolveConflict(g *gocui.Gui, conflict conflict, pick string) error {
-	gitFile, err := getSelectedFile(g)
-	if err != nil {
-		return err
-	}
-	file, err := os.Open(gitFile.Name)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	reader := bufio.NewReader(file)
-	output := ""
-	for i := 0; true; i++ {
-		line, err := reader.ReadString('\n')
-		if err != nil {
-			break
-		}
-		if !isIndexToDelete(i, conflict, pick) {
-			output += line
-		}
-	}
-	devLog(output)
-	return ioutil.WriteFile(gitFile.Name, []byte(output), 0644)
-}
-
-func pushFileSnapshot(g *gocui.Gui) error {
-	gitFile, err := getSelectedFile(g)
-	if err != nil {
-		return err
-	}
-	content, err := catFile(gitFile.Name)
-	if err != nil {
-		return err
-	}
-	state.EditHistory.Push(content)
-	return nil
-}
-
-func handlePopFileSnapshot(g *gocui.Gui, v *gocui.View) error {
-	colorLog(color.FgCyan, "IM HERE")
-	if state.EditHistory.Len() == 0 {
-		return nil
-	}
-	prevContent := state.EditHistory.Pop().(string)
-	gitFile, err := getSelectedFile(g)
-	if err != nil {
-		return err
-	}
-	ioutil.WriteFile(gitFile.Name, []byte(prevContent), 0644)
-	return refreshMergePanel(g)
-}
-
-func handlePickHunk(g *gocui.Gui, v *gocui.View) error {
-	conflict := state.Conflicts[state.ConflictIndex]
-	pushFileSnapshot(g)
-	pick := "bottom"
-	if state.ConflictTop {
-		pick = "top"
-	}
-	err := resolveConflict(g, conflict, pick)
-	if err != nil {
-		panic(err)
-	}
-	refreshMergePanel(g)
-	return nil
-}
-
-func handlePickBothHunks(g *gocui.Gui, v *gocui.View) error {
-	conflict := state.Conflicts[state.ConflictIndex]
-	pushFileSnapshot(g)
-	err := resolveConflict(g, conflict, "both")
-	if err != nil {
-		panic(err)
-	}
-	return refreshMergePanel(g)
-}
-
-func currentViewName(g *gocui.Gui) string {
-	currentView := g.CurrentView()
-	return currentView.Name()
-}
-
-func refreshMergePanel(g *gocui.Gui) error {
-	cat, err := catSelectedFile(g)
-	if err != nil {
-		return err
-	}
-	state.Conflicts, err = findConflicts(cat)
-	if err != nil {
-		return err
-	}
-
-	if len(state.Conflicts) == 0 {
-		return handleCompleteMerge(g)
-	} else if state.ConflictIndex > len(state.Conflicts)-1 {
-		state.ConflictIndex = len(state.Conflicts) - 1
-	}
-	hasFocus := currentViewName(g) == "main"
-	if hasFocus {
-		renderMergeOptions(g)
-	}
-	content, err := coloredConflictFile(cat, state.Conflicts, state.ConflictIndex, state.ConflictTop, hasFocus)
-	if err != nil {
-		return err
-	}
-	if err := scrollToConflict(g); err != nil {
-		return err
-	}
-	return renderString(g, "main", content)
-}
-
-func scrollToConflict(g *gocui.Gui) error {
-	mainView, err := g.View("main")
-	if err != nil {
-		return err
-	}
-	if len(state.Conflicts) == 0 {
-		return nil
-	}
-	conflict := state.Conflicts[state.ConflictIndex]
-	ox, _ := mainView.Origin()
-	_, height := mainView.Size()
-	conflictMiddle := (conflict.end + conflict.start) / 2
-	newOriginY := int(math.Max(0, float64(conflictMiddle-(height/2))))
-	return mainView.SetOrigin(ox, newOriginY)
-}
-
-func switchToMerging(g *gocui.Gui) error {
-	state.ConflictIndex = 0
-	state.ConflictTop = true
-	_, err := g.SetCurrentView("main")
-	if err != nil {
-		return err
-	}
-	return refreshMergePanel(g)
-}
-
-func renderMergeOptions(g *gocui.Gui) error {
-	return renderOptionsMap(g, map[string]string{
-		"↑ ↓":   "select hunk",
-		"← →":   "navigate conflicts",
-		"space": "pick hunk",
-		"b":     "pick both hunks",
-		"z":     "undo",
-	})
-}
-
-func handleEscapeMerge(g *gocui.Gui, v *gocui.View) error {
-	filesView, err := g.View("files")
-	if err != nil {
-		return err
-	}
-	refreshFiles(g)
-	return switchFocus(g, v, filesView)
-}
-
-func handleCompleteMerge(g *gocui.Gui) error {
-	filesView, err := g.View("files")
-	if err != nil {
-		return err
-	}
-	stageSelectedFile(g)
-	refreshFiles(g)
-	return switchFocus(g, nil, filesView)
-}

stash_panel.go

@@ -1,93 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	"github.com/jesseduffield/gocui"
-)
-
-func refreshStashEntries(g *gocui.Gui) error {
-	g.Update(func(g *gocui.Gui) error {
-		v, err := g.View("stash")
-		if err != nil {
-			panic(err)
-		}
-		state.StashEntries = getGitStashEntries()
-		v.Clear()
-		for _, stashEntry := range state.StashEntries {
-			fmt.Fprintln(v, stashEntry.DisplayString)
-		}
-		return resetOrigin(v)
-	})
-	return nil
-}
-
-func getSelectedStashEntry(v *gocui.View) *StashEntry {
-	if len(state.StashEntries) == 0 {
-		return nil
-	}
-	lineNumber := getItemPosition(v)
-	return &state.StashEntries[lineNumber]
-}
-
-func renderStashOptions(g *gocui.Gui) error {
-	return renderOptionsMap(g, map[string]string{
-		"space":   "apply",
-		"k":       "pop",
-		"d":       "drop",
-		"← → ↑ ↓": "navigate",
-	})
-}
-
-func handleStashEntrySelect(g *gocui.Gui, v *gocui.View) error {
-	if err := renderStashOptions(g); err != nil {
-		return err
-	}
-	go func() {
-		stashEntry := getSelectedStashEntry(v)
-		if stashEntry == nil {
-			renderString(g, "main", "No stash entries")
-			return
-		}
-		diff, _ := getStashEntryDiff(stashEntry.Index)
-		renderString(g, "main", diff)
-	}()
-	return nil
-}
-
-func handleStashApply(g *gocui.Gui, v *gocui.View) error {
-	return stashDo(g, v, "apply")
-}
-
-func handleStashPop(g *gocui.Gui, v *gocui.View) error {
-	return stashDo(g, v, "pop")
-}
-
-func handleStashDrop(g *gocui.Gui, v *gocui.View) error {
-	return createConfirmationPanel(g, v, "Stash drop", "Are you sure you want to drop this stash entry?", func(g *gocui.Gui, v *gocui.View) error {
-		return stashDo(g, v, "drop")
-	}, nil)
-}
-
-func stashDo(g *gocui.Gui, v *gocui.View, method string) error {
-	stashEntry := getSelectedStashEntry(v)
-	if stashEntry == nil {
-		return createErrorPanel(g, "No stash to "+method)
-	}
-	if output, err := gitStashDo(stashEntry.Index, method); err != nil {
-		createErrorPanel(g, output)
-	}
-	refreshStashEntries(g)
-	return refreshFiles(g)
-}
-
-func handleStashSave(g *gocui.Gui, filesView *gocui.View) error {
-	createPromptPanel(g, filesView, "Stash changes", func(g *gocui.Gui, v *gocui.View) error {
-		if output, err := gitStashSave(trimmedContent(v)); err != nil {
-			createErrorPanel(g, output)
-		}
-		refreshStashEntries(g)
-		return refreshFiles(g)
-	})
-	return nil
-}

status_panel.go

@@ -1,43 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/fatih/color"
-	"github.com/jesseduffield/gocui"
-)
-
-func refreshStatus(g *gocui.Gui) error {
-	v, err := g.View("status")
-	if err != nil {
-		panic(err)
-	}
-	// for some reason if this isn't wrapped in an update the clear seems to
-	// be applied after the other things or something like that; the panel's
-	// contents end up cleared
-	g.Update(func(*gocui.Gui) error {
-		v.Clear()
-		pushables, pullables := gitUpstreamDifferenceCount()
-		fmt.Fprint(v, "↑"+pushables+"↓"+pullables)
-		branches := state.Branches
-		if err := updateHasMergeConflictStatus(); err != nil {
-			return err
-		}
-		if state.HasMergeConflicts {
-			colour := color.New(color.FgYellow)
-			fmt.Fprint(v, coloredString(" (merging)", colour))
-		}
-		if len(branches) == 0 {
-			return nil
-		}
-		branch := branches[0]
-		// utilising the fact these all have padding to only grab the name
-		// from the display string with the existing coloring applied
-		fmt.Fprint(v, " "+branch.DisplayString[4:])
-		colorLog(color.FgCyan, time.Now().Sub(startTime))
-		return nil
-	})
-
-	return nil
-}

test/generate_basic_repo.sh

@@ -1,49 +0,0 @@
-#!/bin/bash
-
-# this script will make a repo with a master and develop branch, where we end up
-# on the master branch and if we try and merge master we get a merge conflict
-
-# call this command from the test directory:
-# ./generate_basic_repo.sh; cd testrepo; gg; cd ..
-
-# -e means exit if something fails
-# -x means print out simple commands before running them
-set -ex
-
-reponame="testrepo"
-
-rm -rf ${reponame}
-mkdir ${reponame}
-cd ${reponame}
-
-git init
-
-function add_spacing {
-  for i in {1..60}
-  do
-    echo "..." >> $1
-  done
-}
-
-echo "Here is a story that has been told throuhg the ages" >> file1
-
-git add file1
-git commit -m "first commit"
-
-git checkout -b develop
-
-echo "once upon a time there was a dog" >> file1
-add_spacing file1
-echo "once upon a time there was another dog" >> file1
-git add file1
-git commit -m "first commit on develop"
-
-git checkout master
-
-echo "once upon a time there was a cat" >> file1
-add_spacing file1
-echo "once upon a time there was another cat" >> file1
-git add file1
-git commit -m "first commit on develop"
-
-git merge develop # should have a merge conflict here

vendor/github.com/fatih/color/LICENSE.md

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

vendor/github.com/fatih/color/color.go

@@ -1,603 +0,0 @@
-package color
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-	"sync"
-
-	"github.com/mattn/go-colorable"
-	"github.com/mattn/go-isatty"
-)
-
-var (
-	// NoColor defines if the output is colorized or not. It's dynamically set to
-	// false or true based on the stdout's file descriptor referring to a terminal
-	// or not. This is a global option and affects all colors. For more control
-	// over each color block use the methods DisableColor() individually.
-	NoColor = os.Getenv("TERM") == "dumb" ||
-		(!isatty.IsTerminal(os.Stdout.Fd()) && !isatty.IsCygwinTerminal(os.Stdout.Fd()))
-
-	// Output defines the standard output of the print functions. By default
-	// os.Stdout is used.
-	Output = colorable.NewColorableStdout()
-
-	// Error defines a color supporting writer for os.Stderr.
-	Error = colorable.NewColorableStderr()
-
-	// colorsCache is used to reduce the count of created Color objects and
-	// allows to reuse already created objects with required Attribute.
-	colorsCache   = make(map[Attribute]*Color)
-	colorsCacheMu sync.Mutex // protects colorsCache
-)
-
-// Color defines a custom color object which is defined by SGR parameters.
-type Color struct {
-	params  []Attribute
-	noColor *bool
-}
-
-// Attribute defines a single SGR Code
-type Attribute int
-
-const escape = "\x1b"
-
-// Base attributes
-const (
-	Reset Attribute = iota
-	Bold
-	Faint
-	Italic
-	Underline
-	BlinkSlow
-	BlinkRapid
-	ReverseVideo
-	Concealed
-	CrossedOut
-)
-
-// Foreground text colors
-const (
-	FgBlack Attribute = iota + 30
-	FgRed
-	FgGreen
-	FgYellow
-	FgBlue
-	FgMagenta
-	FgCyan
-	FgWhite
-)
-
-// Foreground Hi-Intensity text colors
-const (
-	FgHiBlack Attribute = iota + 90
-	FgHiRed
-	FgHiGreen
-	FgHiYellow
-	FgHiBlue
-	FgHiMagenta
-	FgHiCyan
-	FgHiWhite
-)
-
-// Background text colors
-const (
-	BgBlack Attribute = iota + 40
-	BgRed
-	BgGreen
-	BgYellow
-	BgBlue
-	BgMagenta
-	BgCyan
-	BgWhite
-)
-
-// Background Hi-Intensity text colors
-const (
-	BgHiBlack Attribute = iota + 100
-	BgHiRed
-	BgHiGreen
-	BgHiYellow
-	BgHiBlue
-	BgHiMagenta
-	BgHiCyan
-	BgHiWhite
-)
-
-// New returns a newly created color object.
-func New(value ...Attribute) *Color {
-	c := &Color{params: make([]Attribute, 0)}
-	c.Add(value...)
-	return c
-}
-
-// Set sets the given parameters immediately. It will change the color of
-// output with the given SGR parameters until color.Unset() is called.
-func Set(p ...Attribute) *Color {
-	c := New(p...)
-	c.Set()
-	return c
-}
-
-// Unset resets all escape attributes and clears the output. Usually should
-// be called after Set().
-func Unset() {
-	if NoColor {
-		return
-	}
-
-	fmt.Fprintf(Output, "%s[%dm", escape, Reset)
-}
-
-// Set sets the SGR sequence.
-func (c *Color) Set() *Color {
-	if c.isNoColorSet() {
-		return c
-	}
-
-	fmt.Fprintf(Output, c.format())
-	return c
-}
-
-func (c *Color) unset() {
-	if c.isNoColorSet() {
-		return
-	}
-
-	Unset()
-}
-
-func (c *Color) setWriter(w io.Writer) *Color {
-	if c.isNoColorSet() {
-		return c
-	}
-
-	fmt.Fprintf(w, c.format())
-	return c
-}
-
-func (c *Color) unsetWriter(w io.Writer) {
-	if c.isNoColorSet() {
-		return
-	}
-
-	if NoColor {
-		return
-	}
-
-	fmt.Fprintf(w, "%s[%dm", escape, Reset)
-}
-
-// Add is used to chain SGR parameters. Use as many as parameters to combine
-// and create custom color objects. Example: Add(color.FgRed, color.Underline).
-func (c *Color) Add(value ...Attribute) *Color {
-	c.params = append(c.params, value...)
-	return c
-}
-
-func (c *Color) prepend(value Attribute) {
-	c.params = append(c.params, 0)
-	copy(c.params[1:], c.params[0:])
-	c.params[0] = value
-}
-
-// Fprint formats using the default formats for its operands and writes to w.
-// Spaces are added between operands when neither is a string.
-// It returns the number of bytes written and any write error encountered.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprint(w io.Writer, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprint(w, a...)
-}
-
-// Print formats using the default formats for its operands and writes to
-// standard output. Spaces are added between operands when neither is a
-// string. It returns the number of bytes written and any write error
-// encountered. This is the standard fmt.Print() method wrapped with the given
-// color.
-func (c *Color) Print(a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprint(Output, a...)
-}
-
-// Fprintf formats according to a format specifier and writes to w.
-// It returns the number of bytes written and any write error encountered.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprintf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprintf(w, format, a...)
-}
-
-// Printf formats according to a format specifier and writes to standard output.
-// It returns the number of bytes written and any write error encountered.
-// This is the standard fmt.Printf() method wrapped with the given color.
-func (c *Color) Printf(format string, a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprintf(Output, format, a...)
-}
-
-// Fprintln formats using the default formats for its operands and writes to w.
-// Spaces are always added between operands and a newline is appended.
-// On Windows, users should wrap w with colorable.NewColorable() if w is of
-// type *os.File.
-func (c *Color) Fprintln(w io.Writer, a ...interface{}) (n int, err error) {
-	c.setWriter(w)
-	defer c.unsetWriter(w)
-
-	return fmt.Fprintln(w, a...)
-}
-
-// Println formats using the default formats for its operands and writes to
-// standard output. Spaces are always added between operands and a newline is
-// appended. It returns the number of bytes written and any write error
-// encountered. This is the standard fmt.Print() method wrapped with the given
-// color.
-func (c *Color) Println(a ...interface{}) (n int, err error) {
-	c.Set()
-	defer c.unset()
-
-	return fmt.Fprintln(Output, a...)
-}
-
-// Sprint is just like Print, but returns a string instead of printing it.
-func (c *Color) Sprint(a ...interface{}) string {
-	return c.wrap(fmt.Sprint(a...))
-}
-
-// Sprintln is just like Println, but returns a string instead of printing it.
-func (c *Color) Sprintln(a ...interface{}) string {
-	return c.wrap(fmt.Sprintln(a...))
-}
-
-// Sprintf is just like Printf, but returns a string instead of printing it.
-func (c *Color) Sprintf(format string, a ...interface{}) string {
-	return c.wrap(fmt.Sprintf(format, a...))
-}
-
-// FprintFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprint().
-func (c *Color) FprintFunc() func(w io.Writer, a ...interface{}) {
-	return func(w io.Writer, a ...interface{}) {
-		c.Fprint(w, a...)
-	}
-}
-
-// PrintFunc returns a new function that prints the passed arguments as
-// colorized with color.Print().
-func (c *Color) PrintFunc() func(a ...interface{}) {
-	return func(a ...interface{}) {
-		c.Print(a...)
-	}
-}
-
-// FprintfFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprintf().
-func (c *Color) FprintfFunc() func(w io.Writer, format string, a ...interface{}) {
-	return func(w io.Writer, format string, a ...interface{}) {
-		c.Fprintf(w, format, a...)
-	}
-}
-
-// PrintfFunc returns a new function that prints the passed arguments as
-// colorized with color.Printf().
-func (c *Color) PrintfFunc() func(format string, a ...interface{}) {
-	return func(format string, a ...interface{}) {
-		c.Printf(format, a...)
-	}
-}
-
-// FprintlnFunc returns a new function that prints the passed arguments as
-// colorized with color.Fprintln().
-func (c *Color) FprintlnFunc() func(w io.Writer, a ...interface{}) {
-	return func(w io.Writer, a ...interface{}) {
-		c.Fprintln(w, a...)
-	}
-}
-
-// PrintlnFunc returns a new function that prints the passed arguments as
-// colorized with color.Println().
-func (c *Color) PrintlnFunc() func(a ...interface{}) {
-	return func(a ...interface{}) {
-		c.Println(a...)
-	}
-}
-
-// SprintFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprint(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output, example:
-//
-//	put := New(FgYellow).SprintFunc()
-//	fmt.Fprintf(color.Output, "This is a %s", put("warning"))
-func (c *Color) SprintFunc() func(a ...interface{}) string {
-	return func(a ...interface{}) string {
-		return c.wrap(fmt.Sprint(a...))
-	}
-}
-
-// SprintfFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprintf(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output.
-func (c *Color) SprintfFunc() func(format string, a ...interface{}) string {
-	return func(format string, a ...interface{}) string {
-		return c.wrap(fmt.Sprintf(format, a...))
-	}
-}
-
-// SprintlnFunc returns a new function that returns colorized strings for the
-// given arguments with fmt.Sprintln(). Useful to put into or mix into other
-// string. Windows users should use this in conjunction with color.Output.
-func (c *Color) SprintlnFunc() func(a ...interface{}) string {
-	return func(a ...interface{}) string {
-		return c.wrap(fmt.Sprintln(a...))
-	}
-}
-
-// sequence returns a formatted SGR sequence to be plugged into a "\x1b[...m"
-// an example output might be: "1;36" -> bold cyan
-func (c *Color) sequence() string {
-	format := make([]string, len(c.params))
-	for i, v := range c.params {
-		format[i] = strconv.Itoa(int(v))
-	}
-
-	return strings.Join(format, ";")
-}
-
-// wrap wraps the s string with the colors attributes. The string is ready to
-// be printed.
-func (c *Color) wrap(s string) string {
-	if c.isNoColorSet() {
-		return s
-	}
-
-	return c.format() + s + c.unformat()
-}
-
-func (c *Color) format() string {
-	return fmt.Sprintf("%s[%sm", escape, c.sequence())
-}
-
-func (c *Color) unformat() string {
-	return fmt.Sprintf("%s[%dm", escape, Reset)
-}
-
-// DisableColor disables the color output. Useful to not change any existing
-// code and still being able to output. Can be used for flags like
-// "--no-color". To enable back use EnableColor() method.
-func (c *Color) DisableColor() {
-	c.noColor = boolPtr(true)
-}
-
-// EnableColor enables the color output. Use it in conjunction with
-// DisableColor(). Otherwise this method has no side effects.
-func (c *Color) EnableColor() {
-	c.noColor = boolPtr(false)
-}
-
-func (c *Color) isNoColorSet() bool {
-	// check first if we have user setted action
-	if c.noColor != nil {
-		return *c.noColor
-	}
-
-	// if not return the global option, which is disabled by default
-	return NoColor
-}
-
-// Equals returns a boolean value indicating whether two colors are equal.
-func (c *Color) Equals(c2 *Color) bool {
-	if len(c.params) != len(c2.params) {
-		return false
-	}
-
-	for _, attr := range c.params {
-		if !c2.attrExists(attr) {
-			return false
-		}
-	}
-
-	return true
-}
-
-func (c *Color) attrExists(a Attribute) bool {
-	for _, attr := range c.params {
-		if attr == a {
-			return true
-		}
-	}
-
-	return false
-}
-
-func boolPtr(v bool) *bool {
-	return &v
-}
-
-func getCachedColor(p Attribute) *Color {
-	colorsCacheMu.Lock()
-	defer colorsCacheMu.Unlock()
-
-	c, ok := colorsCache[p]
-	if !ok {
-		c = New(p)
-		colorsCache[p] = c
-	}
-
-	return c
-}
-
-func colorPrint(format string, p Attribute, a ...interface{}) {
-	c := getCachedColor(p)
-
-	if !strings.HasSuffix(format, "\n") {
-		format += "\n"
-	}
-
-	if len(a) == 0 {
-		c.Print(format)
-	} else {
-		c.Printf(format, a...)
-	}
-}
-
-func colorString(format string, p Attribute, a ...interface{}) string {
-	c := getCachedColor(p)
-
-	if len(a) == 0 {
-		return c.SprintFunc()(format)
-	}
-
-	return c.SprintfFunc()(format, a...)
-}
-
-// Black is a convenient helper function to print with black foreground. A
-// newline is appended to format by default.
-func Black(format string, a ...interface{}) { colorPrint(format, FgBlack, a...) }
-
-// Red is a convenient helper function to print with red foreground. A
-// newline is appended to format by default.
-func Red(format string, a ...interface{}) { colorPrint(format, FgRed, a...) }
-
-// Green is a convenient helper function to print with green foreground. A
-// newline is appended to format by default.
-func Green(format string, a ...interface{}) { colorPrint(format, FgGreen, a...) }
-
-// Yellow is a convenient helper function to print with yellow foreground.
-// A newline is appended to format by default.
-func Yellow(format string, a ...interface{}) { colorPrint(format, FgYellow, a...) }
-
-// Blue is a convenient helper function to print with blue foreground. A
-// newline is appended to format by default.
-func Blue(format string, a ...interface{}) { colorPrint(format, FgBlue, a...) }
-
-// Magenta is a convenient helper function to print with magenta foreground.
-// A newline is appended to format by default.
-func Magenta(format string, a ...interface{}) { colorPrint(format, FgMagenta, a...) }
-
-// Cyan is a convenient helper function to print with cyan foreground. A
-// newline is appended to format by default.
-func Cyan(format string, a ...interface{}) { colorPrint(format, FgCyan, a...) }
-
-// White is a convenient helper function to print with white foreground. A
-// newline is appended to format by default.
-func White(format string, a ...interface{}) { colorPrint(format, FgWhite, a...) }
-
-// BlackString is a convenient helper function to return a string with black
-// foreground.
-func BlackString(format string, a ...interface{}) string { return colorString(format, FgBlack, a...) }
-
-// RedString is a convenient helper function to return a string with red
-// foreground.
-func RedString(format string, a ...interface{}) string { return colorString(format, FgRed, a...) }
-
-// GreenString is a convenient helper function to return a string with green
-// foreground.
-func GreenString(format string, a ...interface{}) string { return colorString(format, FgGreen, a...) }
-
-// YellowString is a convenient helper function to return a string with yellow
-// foreground.
-func YellowString(format string, a ...interface{}) string { return colorString(format, FgYellow, a...) }
-
-// BlueString is a convenient helper function to return a string with blue
-// foreground.
-func BlueString(format string, a ...interface{}) string { return colorString(format, FgBlue, a...) }
-
-// MagentaString is a convenient helper function to return a string with magenta
-// foreground.
-func MagentaString(format string, a ...interface{}) string {
-	return colorString(format, FgMagenta, a...)
-}
-
-// CyanString is a convenient helper function to return a string with cyan
-// foreground.
-func CyanString(format string, a ...interface{}) string { return colorString(format, FgCyan, a...) }
-
-// WhiteString is a convenient helper function to return a string with white
-// foreground.
-func WhiteString(format string, a ...interface{}) string { return colorString(format, FgWhite, a...) }
-
-// HiBlack is a convenient helper function to print with hi-intensity black foreground. A
-// newline is appended to format by default.
-func HiBlack(format string, a ...interface{}) { colorPrint(format, FgHiBlack, a...) }
-
-// HiRed is a convenient helper function to print with hi-intensity red foreground. A
-// newline is appended to format by default.
-func HiRed(format string, a ...interface{}) { colorPrint(format, FgHiRed, a...) }
-
-// HiGreen is a convenient helper function to print with hi-intensity green foreground. A
-// newline is appended to format by default.
-func HiGreen(format string, a ...interface{}) { colorPrint(format, FgHiGreen, a...) }
-
-// HiYellow is a convenient helper function to print with hi-intensity yellow foreground.
-// A newline is appended to format by default.
-func HiYellow(format string, a ...interface{}) { colorPrint(format, FgHiYellow, a...) }
-
-// HiBlue is a convenient helper function to print with hi-intensity blue foreground. A
-// newline is appended to format by default.
-func HiBlue(format string, a ...interface{}) { colorPrint(format, FgHiBlue, a...) }
-
-// HiMagenta is a convenient helper function to print with hi-intensity magenta foreground.
-// A newline is appended to format by default.
-func HiMagenta(format string, a ...interface{}) { colorPrint(format, FgHiMagenta, a...) }
-
-// HiCyan is a convenient helper function to print with hi-intensity cyan foreground. A
-// newline is appended to format by default.
-func HiCyan(format string, a ...interface{}) { colorPrint(format, FgHiCyan, a...) }
-
-// HiWhite is a convenient helper function to print with hi-intensity white foreground. A
-// newline is appended to format by default.
-func HiWhite(format string, a ...interface{}) { colorPrint(format, FgHiWhite, a...) }
-
-// HiBlackString is a convenient helper function to return a string with hi-intensity black
-// foreground.
-func HiBlackString(format string, a ...interface{}) string {
-	return colorString(format, FgHiBlack, a...)
-}
-
-// HiRedString is a convenient helper function to return a string with hi-intensity red
-// foreground.
-func HiRedString(format string, a ...interface{}) string { return colorString(format, FgHiRed, a...) }
-
-// HiGreenString is a convenient helper function to return a string with hi-intensity green
-// foreground.
-func HiGreenString(format string, a ...interface{}) string {
-	return colorString(format, FgHiGreen, a...)
-}
-
-// HiYellowString is a convenient helper function to return a string with hi-intensity yellow
-// foreground.
-func HiYellowString(format string, a ...interface{}) string {
-	return colorString(format, FgHiYellow, a...)
-}
-
-// HiBlueString is a convenient helper function to return a string with hi-intensity blue
-// foreground.
-func HiBlueString(format string, a ...interface{}) string { return colorString(format, FgHiBlue, a...) }
-
-// HiMagentaString is a convenient helper function to return a string with hi-intensity magenta
-// foreground.
-func HiMagentaString(format string, a ...interface{}) string {
-	return colorString(format, FgHiMagenta, a...)
-}
-
-// HiCyanString is a convenient helper function to return a string with hi-intensity cyan
-// foreground.
-func HiCyanString(format string, a ...interface{}) string { return colorString(format, FgHiCyan, a...) }
-
-// HiWhiteString is a convenient helper function to return a string with hi-intensity white
-// foreground.
-func HiWhiteString(format string, a ...interface{}) string {
-	return colorString(format, FgHiWhite, a...)
-}

vendor/github.com/fatih/color/doc.go

@@ -1,133 +0,0 @@
-/*
-Package color is an ANSI color package to output colorized or SGR defined
-output to the standard output. The API can be used in several way, pick one
-that suits you.
-
-Use simple and default helper functions with predefined foreground colors:
-
-    color.Cyan("Prints text in cyan.")
-
-    // a newline will be appended automatically
-    color.Blue("Prints %s in blue.", "text")
-
-    // More default foreground colors..
-    color.Red("We have red")
-    color.Yellow("Yellow color too!")
-    color.Magenta("And many others ..")
-
-    // Hi-intensity colors
-    color.HiGreen("Bright green color.")
-    color.HiBlack("Bright black means gray..")
-    color.HiWhite("Shiny white color!")
-
-However there are times where custom color mixes are required. Below are some
-examples to create custom color objects and use the print functions of each
-separate color object.
-
-    // Create a new color object
-    c := color.New(color.FgCyan).Add(color.Underline)
-    c.Println("Prints cyan text with an underline.")
-
-    // Or just add them to New()
-    d := color.New(color.FgCyan, color.Bold)
-    d.Printf("This prints bold cyan %s\n", "too!.")
-
-
-    // Mix up foreground and background colors, create new mixes!
-    red := color.New(color.FgRed)
-
-    boldRed := red.Add(color.Bold)
-    boldRed.Println("This will print text in bold red.")
-
-    whiteBackground := red.Add(color.BgWhite)
-    whiteBackground.Println("Red text with White background.")
-
-    // Use your own io.Writer output
-    color.New(color.FgBlue).Fprintln(myWriter, "blue color!")
-
-    blue := color.New(color.FgBlue)
-    blue.Fprint(myWriter, "This will print text in blue.")
-
-You can create PrintXxx functions to simplify even more:
-
-    // Create a custom print function for convenient
-    red := color.New(color.FgRed).PrintfFunc()
-    red("warning")
-    red("error: %s", err)
-
-    // Mix up multiple attributes
-    notice := color.New(color.Bold, color.FgGreen).PrintlnFunc()
-    notice("don't forget this...")
-
-You can also FprintXxx functions to pass your own io.Writer:
-
-    blue := color.New(FgBlue).FprintfFunc()
-    blue(myWriter, "important notice: %s", stars)
-
-    // Mix up with multiple attributes
-    success := color.New(color.Bold, color.FgGreen).FprintlnFunc()
-    success(myWriter, don't forget this...")
-
-
-Or create SprintXxx functions to mix strings with other non-colorized strings:
-
-    yellow := New(FgYellow).SprintFunc()
-    red := New(FgRed).SprintFunc()
-
-    fmt.Printf("this is a %s and this is %s.\n", yellow("warning"), red("error"))
-
-    info := New(FgWhite, BgGreen).SprintFunc()
-    fmt.Printf("this %s rocks!\n", info("package"))
-
-Windows support is enabled by default. All Print functions work as intended.
-However only for color.SprintXXX functions, user should use fmt.FprintXXX and
-set the output to color.Output:
-
-    fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS"))
-
-    info := New(FgWhite, BgGreen).SprintFunc()
-    fmt.Fprintf(color.Output, "this %s rocks!\n", info("package"))
-
-Using with existing code is possible. Just use the Set() method to set the
-standard output to the given parameters. That way a rewrite of an existing
-code is not required.
-
-    // Use handy standard colors.
-    color.Set(color.FgYellow)
-
-    fmt.Println("Existing text will be now in Yellow")
-    fmt.Printf("This one %s\n", "too")
-
-    color.Unset() // don't forget to unset
-
-    // You can mix up parameters
-    color.Set(color.FgMagenta, color.Bold)
-    defer color.Unset() // use it in your function
-
-    fmt.Println("All text will be now bold magenta.")
-
-There might be a case where you want to disable color output (for example to
-pipe the standard output of your app to somewhere else). `Color` has support to
-disable colors both globally and for single color definition. For example
-suppose you have a CLI app and a `--no-color` bool flag. You can easily disable
-the color output with:
-
-    var flagNoColor = flag.Bool("no-color", false, "Disable color output")
-
-    if *flagNoColor {
-    	color.NoColor = true // disables colorized output
-    }
-
-It also has support for single color definitions (local). You can
-disable/enable color output on the fly:
-
-     c := color.New(color.FgCyan)
-     c.Println("Prints cyan text")
-
-     c.DisableColor()
-     c.Println("This is printed without any color")
-
-     c.EnableColor()
-     c.Println("This prints again cyan...")
-*/
-package color

vendor/github.com/golang-collections/collections/LICENSE

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

vendor/github.com/golang-collections/collections/stack/stack.go

@@ -1,44 +0,0 @@
-package stack
-
-type (
-	Stack struct {
-		top *node
-		length int
-	}
-	node struct {
-		value interface{}
-		prev *node
-	}	
-)
-// Create a new stack
-func New() *Stack {
-	return &Stack{nil,0}
-}
-// Return the number of items in the stack
-func (this *Stack) Len() int {
-	return this.length
-}
-// View the top item on the stack
-func (this *Stack) Peek() interface{} {
-	if this.length == 0 {
-		return nil
-	}
-	return this.top.value
-}
-// Pop the top item of the stack and return it
-func (this *Stack) Pop() interface{} {
-	if this.length == 0 {
-		return nil
-	}
-	
-	n := this.top
-	this.top = n.prev
-	this.length--
-	return n.value
-}
-// Push a value onto the top of the stack
-func (this *Stack) Push(value interface{}) {
-	n := &node{value,this.top}
-	this.top = n
-	this.length++
-}

vendor/github.com/jesseduffield/gocui/AUTHORS

@@ -1,30 +0,0 @@
-# This is the official list of gocui authors for copyright purposes.
-
-# Names should be added to this file as
-#	Name or Organization <email address> contribution
-#		Contribution
-# The email address is not required for organizations.
-
-Roi Martin <jroi.martin@gmail.com>
-	Main developer
-
-Ryan Sullivan <kayoticsully@gmail.com>
-	Toggleable view frames
-
-Matthieu Rakotojaona <matthieu.rakotojaona@gmail.com>
-	Wrapped views
-
-Harry Lawrence <hazbo@gmx.com>
-	Basic mouse support
-
-Danny Tylman <dtylman@gmail.com>
-	Masked views
-
-Frederik Deweerdt <frederik.deweerdt@gmail.com>
-	Colored fonts
-
-Henri Koski <henri.t.koski@gmail.com>
-	Custom current view color
-
-Dustin Willis Webber <dustin.webber@gmail.com>
-	256-colors output mode support

vendor/github.com/jesseduffield/gocui/LICENSE

@@ -1,23 +0,0 @@
-Copyright (c) 2014 The gocui Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of the gocui Authors nor the names of its contributors
-      may be used to endorse or promote products derived from this software
-      without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/jesseduffield/gocui/attribute.go

@@ -1,32 +0,0 @@
-// Copyright 2014 The gocui Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gocui
-
-import "github.com/nsf/termbox-go"
-
-// Attribute represents a terminal attribute, like color, font style, etc. They
-// can be combined using bitwise OR (|). Note that it is not possible to
-// combine multiple color attributes.
-type Attribute termbox.Attribute
-
-// Color attributes.
-const (
-	ColorDefault Attribute = Attribute(termbox.ColorDefault)
-	ColorBlack             = Attribute(termbox.ColorBlack)
-	ColorRed               = Attribute(termbox.ColorRed)
-	ColorGreen             = Attribute(termbox.ColorGreen)
-	ColorYellow            = Attribute(termbox.ColorYellow)
-	ColorBlue              = Attribute(termbox.ColorBlue)
-	ColorMagenta           = Attribute(termbox.ColorMagenta)
-	ColorCyan              = Attribute(termbox.ColorCyan)
-	ColorWhite             = Attribute(termbox.ColorWhite)
-)
-
-// Text style attributes.
-const (
-	AttrBold      Attribute = Attribute(termbox.AttrBold)
-	AttrUnderline           = Attribute(termbox.AttrUnderline)
-	AttrReverse             = Attribute(termbox.AttrReverse)
-)

vendor/github.com/jesseduffield/gocui/doc.go

@@ -1,118 +0,0 @@
-// Copyright 2014 The gocui Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-/*
-Package gocui allows to create console user interfaces.
-
-Create a new GUI:
-
-	g, err := gocui.NewGui(gocui.OutputNormal)
-	if err != nil {
-		// handle error
-	}
-	defer g.Close()
-
-	// Set GUI managers and key bindings
-	// ...
-
-	if err := g.MainLoop(); err != nil && err != gocui.ErrQuit {
-		// handle error
-	}
-
-Set GUI managers:
-
-	g.SetManager(mgr1, mgr2)
-
-Managers are in charge of GUI's layout and can be used to build widgets. On
-each iteration of the GUI's main loop, the Layout function of each configured
-manager is executed. Managers are used to set-up and update the application's
-main views, being possible to freely change them during execution. Also, it is
-important to mention that a main loop iteration is executed on each reported
-event (key-press, mouse event, window resize, etc).
-
-GUIs are composed by Views, you can think of it as buffers. Views implement the
-io.ReadWriter interface, so you can just write to them if you want to modify
-their content. The same is valid for reading.
-
-Create and initialize a view with absolute coordinates:
-
-	if v, err := g.SetView("viewname", 2, 2, 22, 7); err != nil {
-		if err != gocui.ErrUnknownView {
-			// handle error
-		}
-		fmt.Fprintln(v, "This is a new view")
-		// ...
-	}
-
-Views can also be created using relative coordinates:
-
-	maxX, maxY := g.Size()
-	if v, err := g.SetView("viewname", maxX/2-30, maxY/2, maxX/2+30, maxY/2+2); err != nil {
-		// ...
-	}
-
-Configure keybindings:
-
-	if err := g.SetKeybinding("viewname", gocui.KeyEnter, gocui.ModNone, fcn); err != nil {
-		// handle error
-	}
-
-gocui implements full mouse support that can be enabled with:
-
-	g.Mouse = true
-
-Mouse events are handled like any other keybinding:
-
-	if err := g.SetKeybinding("viewname", gocui.MouseLeft, gocui.ModNone, fcn); err != nil {
-		// handle error
-	}
-
-IMPORTANT: Views can only be created, destroyed or updated in three ways: from
-the Layout function within managers, from keybinding callbacks or via
-*Gui.Update(). The reason for this is that it allows gocui to be
-concurrent-safe. So, if you want to update your GUI from a goroutine, you must
-use *Gui.Update(). For example:
-
-	g.Update(func(g *gocui.Gui) error {
-		v, err := g.View("viewname")
-		if err != nil {
-			// handle error
-		}
-		v.Clear()
-		fmt.Fprintln(v, "Writing from different goroutines")
-		return nil
-	})
-
-By default, gocui provides a basic edition mode. This mode can be extended
-and customized creating a new Editor and assigning it to *View.Editor:
-
-	type Editor interface {
-		Edit(v *View, key Key, ch rune, mod Modifier)
-	}
-
-DefaultEditor can be taken as example to create your own custom Editor:
-
-	var DefaultEditor Editor = EditorFunc(simpleEditor)
-
-	func simpleEditor(v *View, key Key, ch rune, mod Modifier) {
-		switch {
-		case ch != 0 && mod == 0:
-			v.EditWrite(ch)
-		case key == KeySpace:
-			v.EditWrite(' ')
-		case key == KeyBackspace || key == KeyBackspace2:
-			v.EditDelete(true)
-		// ...
-		}
-	}
-
-Colored text:
-
-Views allow to add colored text using ANSI colors. For example:
-
-	fmt.Fprintln(v, "\x1b[0;31mHello world")
-
-For more information, see the examples in folder "_examples/".
-*/
-package gocui

vendor/github.com/jesseduffield/gocui/edit.go

@@ -1,344 +0,0 @@
-// Copyright 2014 The gocui Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gocui
-
-import "errors"
-
-const maxInt = int(^uint(0) >> 1)
-
-// Editor interface must be satisfied by gocui editors.
-type Editor interface {
-	Edit(v *View, key Key, ch rune, mod Modifier)
-}
-
-// The EditorFunc type is an adapter to allow the use of ordinary functions as
-// Editors. If f is a function with the appropriate signature, EditorFunc(f)
-// is an Editor object that calls f.
-type EditorFunc func(v *View, key Key, ch rune, mod Modifier)
-
-// Edit calls f(v, key, ch, mod)
-func (f EditorFunc) Edit(v *View, key Key, ch rune, mod Modifier) {
-	f(v, key, ch, mod)
-}
-
-// DefaultEditor is the default editor.
-var DefaultEditor Editor = EditorFunc(simpleEditor)
-
-// simpleEditor is used as the default gocui editor.
-func simpleEditor(v *View, key Key, ch rune, mod Modifier) {
-	switch {
-	case ch != 0 && mod == 0:
-		v.EditWrite(ch)
-	case key == KeySpace:
-		v.EditWrite(' ')
-	case key == KeyBackspace || key == KeyBackspace2:
-		v.EditDelete(true)
-	case key == KeyDelete:
-		v.EditDelete(false)
-	case key == KeyInsert:
-		v.Overwrite = !v.Overwrite
-	case key == KeyEnter:
-		v.EditNewLine()
-	case key == KeyArrowDown:
-		v.MoveCursor(0, 1, false)
-	case key == KeyArrowUp:
-		v.MoveCursor(0, -1, false)
-	case key == KeyArrowLeft:
-		v.MoveCursor(-1, 0, false)
-	case key == KeyArrowRight:
-		v.MoveCursor(1, 0, false)
-	}
-}
-
-// EditWrite writes a rune at the cursor position.
-func (v *View) EditWrite(ch rune) {
-	v.writeRune(v.cx, v.cy, ch)
-	v.MoveCursor(1, 0, true)
-}
-
-// EditDelete deletes a rune at the cursor position. back determines the
-// direction.
-func (v *View) EditDelete(back bool) {
-	x, y := v.ox+v.cx, v.oy+v.cy
-	if y < 0 {
-		return
-	} else if y >= len(v.viewLines) {
-		v.MoveCursor(-1, 0, true)
-		return
-	}
-
-	maxX, _ := v.Size()
-	if back {
-		if x == 0 { // start of the line
-			if y < 1 {
-				return
-			}
-
-			var maxPrevWidth int
-			if v.Wrap {
-				maxPrevWidth = maxX
-			} else {
-				maxPrevWidth = maxInt
-			}
-
-			if v.viewLines[y].linesX == 0 { // regular line
-				v.mergeLines(v.cy - 1)
-				if len(v.viewLines[y-1].line) < maxPrevWidth {
-					v.MoveCursor(-1, 0, true)
-				}
-			} else { // wrapped line
-				v.deleteRune(len(v.viewLines[y-1].line)-1, v.cy-1)
-				v.MoveCursor(-1, 0, true)
-			}
-		} else { // middle/end of the line
-			v.deleteRune(v.cx-1, v.cy)
-			v.MoveCursor(-1, 0, true)
-		}
-	} else {
-		if x == len(v.viewLines[y].line) { // end of the line
-			v.mergeLines(v.cy)
-		} else { // start/middle of the line
-			v.deleteRune(v.cx, v.cy)
-		}
-	}
-}
-
-// EditNewLine inserts a new line under the cursor.
-func (v *View) EditNewLine() {
-	v.breakLine(v.cx, v.cy)
-	v.ox = 0
-	v.cx = 0
-	v.MoveCursor(0, 1, true)
-}
-
-// MoveCursor moves the cursor taking into account the width of the line/view,
-// displacing the origin if necessary.
-func (v *View) MoveCursor(dx, dy int, writeMode bool) {
-	maxX, maxY := v.Size()
-	cx, cy := v.cx+dx, v.cy+dy
-	x, y := v.ox+cx, v.oy+cy
-
-	var curLineWidth, prevLineWidth int
-	// get the width of the current line
-	if writeMode {
-		if v.Wrap {
-			curLineWidth = maxX - 1
-		} else {
-			curLineWidth = maxInt
-		}
-	} else {
-		if y >= 0 && y < len(v.viewLines) {
-			curLineWidth = len(v.viewLines[y].line)
-			if v.Wrap && curLineWidth >= maxX {
-				curLineWidth = maxX - 1
-			}
-		} else {
-			curLineWidth = 0
-		}
-	}
-	// get the width of the previous line
-	if y-1 >= 0 && y-1 < len(v.viewLines) {
-		prevLineWidth = len(v.viewLines[y-1].line)
-	} else {
-		prevLineWidth = 0
-	}
-
-	// adjust cursor's x position and view's x origin
-	if x > curLineWidth { // move to next line
-		if dx > 0 { // horizontal movement
-			cy++
-			if writeMode || v.oy+cy < len(v.viewLines) {
-				if !v.Wrap {
-					v.ox = 0
-				}
-				v.cx = 0
-			}
-		} else { // vertical movement
-			if curLineWidth > 0 { // move cursor to the EOL
-				if v.Wrap {
-					v.cx = curLineWidth
-				} else {
-					ncx := curLineWidth - v.ox
-					if ncx < 0 {
-						v.ox += ncx
-						if v.ox < 0 {
-							v.ox = 0
-						}
-						v.cx = 0
-					} else {
-						v.cx = ncx
-					}
-				}
-			} else {
-				if writeMode || v.oy+cy < len(v.viewLines) {
-					if !v.Wrap {
-						v.ox = 0
-					}
-					v.cx = 0
-				}
-			}
-		}
-	} else if cx < 0 {
-		if !v.Wrap && v.ox > 0 { // move origin to the left
-			v.ox += cx
-			v.cx = 0
-		} else { // move to previous line
-			cy--
-			if prevLineWidth > 0 {
-				if !v.Wrap { // set origin so the EOL is visible
-					nox := prevLineWidth - maxX + 1
-					if nox < 0 {
-						v.ox = 0
-					} else {
-						v.ox = nox
-					}
-				}
-				v.cx = prevLineWidth
-			} else {
-				if !v.Wrap {
-					v.ox = 0
-				}
-				v.cx = 0
-			}
-		}
-	} else { // stay on the same line
-		if v.Wrap {
-			v.cx = cx
-		} else {
-			if cx >= maxX {
-				v.ox += cx - maxX + 1
-				v.cx = maxX
-			} else {
-				v.cx = cx
-			}
-		}
-	}
-
-	// adjust cursor's y position and view's y origin
-	if cy < 0 {
-		if v.oy > 0 {
-			v.oy--
-		}
-	} else if writeMode || v.oy+cy < len(v.viewLines) {
-		if cy >= maxY {
-			v.oy++
-		} else {
-			v.cy = cy
-		}
-	}
-}
-
-// writeRune writes a rune into the view's internal buffer, at the
-// position corresponding to the point (x, y). The length of the internal
-// buffer is increased if the point is out of bounds. Overwrite mode is
-// governed by the value of View.overwrite.
-func (v *View) writeRune(x, y int, ch rune) error {
-	v.tainted = true
-
-	x, y, err := v.realPosition(x, y)
-	if err != nil {
-		return err
-	}
-
-	if x < 0 || y < 0 {
-		return errors.New("invalid point")
-	}
-
-	if y >= len(v.lines) {
-		s := make([][]cell, y-len(v.lines)+1)
-		v.lines = append(v.lines, s...)
-	}
-
-	olen := len(v.lines[y])
-
-	var s []cell
-	if x >= len(v.lines[y]) {
-		s = make([]cell, x-len(v.lines[y])+1)
-	} else if !v.Overwrite {
-		s = make([]cell, 1)
-	}
-	v.lines[y] = append(v.lines[y], s...)
-
-	if !v.Overwrite || (v.Overwrite && x >= olen-1) {
-		copy(v.lines[y][x+1:], v.lines[y][x:])
-	}
-	v.lines[y][x] = cell{
-		fgColor: v.FgColor,
-		bgColor: v.BgColor,
-		chr:     ch,
-	}
-
-	return nil
-}
-
-// deleteRune removes a rune from the view's internal buffer, at the
-// position corresponding to the point (x, y).
-func (v *View) deleteRune(x, y int) error {
-	v.tainted = true
-
-	x, y, err := v.realPosition(x, y)
-	if err != nil {
-		return err
-	}
-
-	if x < 0 || y < 0 || y >= len(v.lines) || x >= len(v.lines[y]) {
-		return errors.New("invalid point")
-	}
-	v.lines[y] = append(v.lines[y][:x], v.lines[y][x+1:]...)
-	return nil
-}
-
-// mergeLines merges the lines "y" and "y+1" if possible.
-func (v *View) mergeLines(y int) error {
-	v.tainted = true
-
-	_, y, err := v.realPosition(0, y)
-	if err != nil {
-		return err
-	}
-
-	if y < 0 || y >= len(v.lines) {
-		return errors.New("invalid point")
-	}
-
-	if y < len(v.lines)-1 { // otherwise we don't need to merge anything
-		v.lines[y] = append(v.lines[y], v.lines[y+1]...)
-		v.lines = append(v.lines[:y+1], v.lines[y+2:]...)
-	}
-	return nil
-}
-
-// breakLine breaks a line of the internal buffer at the position corresponding
-// to the point (x, y).
-func (v *View) breakLine(x, y int) error {
-	v.tainted = true
-
-	x, y, err := v.realPosition(x, y)
-	if err != nil {
-		return err
-	}
-
-	if y < 0 || y >= len(v.lines) {
-		return errors.New("invalid point")
-	}
-
-	var left, right []cell
-	if x < len(v.lines[y]) { // break line
-		left = make([]cell, len(v.lines[y][:x]))
-		copy(left, v.lines[y][:x])
-		right = make([]cell, len(v.lines[y][x:]))
-		copy(right, v.lines[y][x:])
-	} else { // new empty line
-		left = v.lines[y]
-	}
-
-	lines := make([][]cell, len(v.lines)+1)
-	lines[y] = left
-	lines[y+1] = right
-	copy(lines, v.lines[:y])
-	copy(lines[y+2:], v.lines[y+1:])
-	v.lines = lines
-	return nil
-}

vendor/github.com/jesseduffield/gocui/escape.go

@@ -1,229 +0,0 @@
-// Copyright 2014 The gocui Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gocui
-
-import (
-	"errors"
-	"strconv"
-)
-
-type escapeInterpreter struct {
-	state                  escapeState
-	curch                  rune
-	csiParam               []string
-	curFgColor, curBgColor Attribute
-	mode                   OutputMode
-}
-
-type escapeState int
-
-const (
-	stateNone escapeState = iota
-	stateEscape
-	stateCSI
-	stateParams
-)
-
-var (
-	errNotCSI        = errors.New("Not a CSI escape sequence")
-	errCSIParseError = errors.New("CSI escape sequence parsing error")
-	errCSITooLong    = errors.New("CSI escape sequence is too long")
-)
-
-// runes in case of error will output the non-parsed runes as a string.
-func (ei *escapeInterpreter) runes() []rune {
-	switch ei.state {
-	case stateNone:
-		return []rune{0x1b}
-	case stateEscape:
-		return []rune{0x1b, ei.curch}
-	case stateCSI:
-		return []rune{0x1b, '[', ei.curch}
-	case stateParams:
-		ret := []rune{0x1b, '['}
-		for _, s := range ei.csiParam {
-			ret = append(ret, []rune(s)...)
-			ret = append(ret, ';')
-		}
-		return append(ret, ei.curch)
-	}
-	return nil
-}
-
-// newEscapeInterpreter returns an escapeInterpreter that will be able to parse
-// terminal escape sequences.
-func newEscapeInterpreter(mode OutputMode) *escapeInterpreter {
-	ei := &escapeInterpreter{
-		state:      stateNone,
-		curFgColor: ColorDefault,
-		curBgColor: ColorDefault,
-		mode:       mode,
-	}
-	return ei
-}
-
-// reset sets the escapeInterpreter in initial state.
-func (ei *escapeInterpreter) reset() {
-	ei.state = stateNone
-	ei.curFgColor = ColorDefault
-	ei.curBgColor = ColorDefault
-	ei.csiParam = nil
-}
-
-// parseOne parses a rune. If isEscape is true, it means that the rune is part
-// of an escape sequence, and as such should not be printed verbatim. Otherwise,
-// it's not an escape sequence.
-func (ei *escapeInterpreter) parseOne(ch rune) (isEscape bool, err error) {
-	// Sanity checks
-	if len(ei.csiParam) > 20 {
-		return false, errCSITooLong
-	}
-	if len(ei.csiParam) > 0 && len(ei.csiParam[len(ei.csiParam)-1]) > 255 {
-		return false, errCSITooLong
-	}
-
-	ei.curch = ch
-
-	switch ei.state {
-	case stateNone:
-		if ch == 0x1b {
-			ei.state = stateEscape
-			return true, nil
-		}
-		return false, nil
-	case stateEscape:
-		if ch == '[' {
-			ei.state = stateCSI
-			return true, nil
-		}
-		return false, errNotCSI
-	case stateCSI:
-		switch {
-		case ch >= '0' && ch <= '9':
-			ei.csiParam = append(ei.csiParam, "")
-		case ch == 'm':
-			ei.csiParam = append(ei.csiParam, "0")
-		default:
-			return false, errCSIParseError
-		}
-		ei.state = stateParams
-		fallthrough
-	case stateParams:
-		switch {
-		case ch >= '0' && ch <= '9':
-			ei.csiParam[len(ei.csiParam)-1] += string(ch)
-			return true, nil
-		case ch == ';':
-			ei.csiParam = append(ei.csiParam, "")
-			return true, nil
-		case ch == 'm':
-			var err error
-			switch ei.mode {
-			case OutputNormal:
-				err = ei.outputNormal()
-			case Output256:
-				err = ei.output256()
-			}
-			if err != nil {
-				return false, errCSIParseError
-			}
-
-			ei.state = stateNone
-			ei.csiParam = nil
-			return true, nil
-		default:
-			return false, errCSIParseError
-		}
-	}
-	return false, nil
-}
-
-// outputNormal provides 8 different colors:
-//   black, red, green, yellow, blue, magenta, cyan, white
-func (ei *escapeInterpreter) outputNormal() error {
-	for _, param := range ei.csiParam {
-		p, err := strconv.Atoi(param)
-		if err != nil {
-			return errCSIParseError
-		}
-
-		switch {
-		case p >= 30 && p <= 37:
-			ei.curFgColor = Attribute(p - 30 + 1)
-		case p == 39:
-			ei.curFgColor = ColorDefault
-		case p >= 40 && p <= 47:
-			ei.curBgColor = Attribute(p - 40 + 1)
-		case p == 49:
-			ei.curBgColor = ColorDefault
-		case p == 1:
-			ei.curFgColor |= AttrBold
-		case p == 4:
-			ei.curFgColor |= AttrUnderline
-		case p == 7:
-			ei.curFgColor |= AttrReverse
-		case p == 0:
-			ei.curFgColor = ColorDefault
-			ei.curBgColor = ColorDefault
-		}
-	}
-
-	return nil
-}
-
-// output256 allows you to leverage the 256-colors terminal mode:
-//   0x01 - 0x08: the 8 colors as in OutputNormal
-//   0x09 - 0x10: Color* | AttrBold
-//   0x11 - 0xe8: 216 different colors
-//   0xe9 - 0x1ff: 24 different shades of grey
-func (ei *escapeInterpreter) output256() error {
-	if len(ei.csiParam) < 3 {
-		return ei.outputNormal()
-	}
-
-	mode, err := strconv.Atoi(ei.csiParam[1])
-	if err != nil {
-		return errCSIParseError
-	}
-	if mode != 5 {
-		return ei.outputNormal()
-	}
-
-	fgbg, err := strconv.Atoi(ei.csiParam[0])
-	if err != nil {
-		return errCSIParseError
-	}
-	color, err := strconv.Atoi(ei.csiParam[2])
-	if err != nil {
-		return errCSIParseError
-	}
-
-	switch fgbg {
-	case 38:
-		ei.curFgColor = Attribute(color + 1)
-
-		for _, param := range ei.csiParam[3:] {
-			p, err := strconv.Atoi(param)
-			if err != nil {
-				return errCSIParseError
-			}
-
-			switch {
-			case p == 1:
-				ei.curFgColor |= AttrBold
-			case p == 4:
-				ei.curFgColor |= AttrUnderline
-			case p == 7:
-				ei.curFgColor |= AttrReverse
-			}
-		}
-	case 48:
-		ei.curBgColor = Attribute(color + 1)
-	default:
-		return errCSIParseError
-	}
-
-	return nil
-}

vendor/github.com/jesseduffield/gocui/gui.go

@@ -1,666 +0,0 @@
-// Copyright 2014 The gocui Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gocui
-
-import (
-	"errors"
-
-	"github.com/nsf/termbox-go"
-)
-
-var (
-	// ErrQuit is used to decide if the MainLoop finished successfully.
-	ErrQuit = errors.New("quit")
-
-	// ErrUnknownView allows to assert if a View must be initialized.
-	ErrUnknownView = errors.New("unknown view")
-)
-
-// OutputMode represents the terminal's output mode (8 or 256 colors).
-type OutputMode termbox.OutputMode
-
-const (
-	// OutputNormal provides 8-colors terminal mode.
-	OutputNormal = OutputMode(termbox.OutputNormal)
-
-	// Output256 provides 256-colors terminal mode.
-	Output256 = OutputMode(termbox.Output256)
-
-	// OutputGrayScale provides greyscale terminal mode.
-	OutputGrayScale = OutputMode(termbox.OutputGrayscale)
-
-	// Output216 provides greyscale terminal mode.
-	Output216 = OutputMode(termbox.Output216)
-)
-
-// Gui represents the whole User Interface, including the views, layouts
-// and keybindings.
-type Gui struct {
-	tbEvents    chan termbox.Event
-	userEvents  chan userEvent
-	views       []*View
-	currentView *View
-	managers    []Manager
-	keybindings []*keybinding
-	maxX, maxY  int
-	outputMode  OutputMode
-
-	// BgColor and FgColor allow to configure the background and foreground
-	// colors of the GUI.
-	BgColor, FgColor Attribute
-
-	// SelBgColor and SelFgColor allow to configure the background and
-	// foreground colors of the frame of the current view.
-	SelBgColor, SelFgColor Attribute
-
-	// If Highlight is true, Sel{Bg,Fg}Colors will be used to draw the
-	// frame of the current view.
-	Highlight bool
-
-	// If Cursor is true then the cursor is enabled.
-	Cursor bool
-
-	// If Mouse is true then mouse events will be enabled.
-	Mouse bool
-
-	// If InputEsc is true, when ESC sequence is in the buffer and it doesn't
-	// match any known sequence, ESC means KeyEsc.
-	InputEsc bool
-
-	// If ASCII is true then use ASCII instead of unicode to draw the
-	// interface. Using ASCII is more portable.
-	ASCII bool
-
-	// SupportOverlaps is true when we allow for view edges to overlap with other
-	// view edges
-	SupportOverlaps bool
-}
-
-// NewGui returns a new Gui object with a given output mode.
-func NewGui(mode OutputMode, supportOverlaps bool) (*Gui, error) {
-	if err := termbox.Init(); err != nil {
-		return nil, err
-	}
-
-	g := &Gui{}
-
-	g.outputMode = mode
-	termbox.SetOutputMode(termbox.OutputMode(mode))
-
-	g.tbEvents = make(chan termbox.Event, 20)
-	g.userEvents = make(chan userEvent, 20)
-
-	g.maxX, g.maxY = termbox.Size()
-
-	g.BgColor, g.FgColor = ColorDefault, ColorDefault
-	g.SelBgColor, g.SelFgColor = ColorDefault, ColorDefault
-
-	// SupportOverlaps is true when we allow for view edges to overlap with other
-	// view edges
-	g.SupportOverlaps = supportOverlaps
-
-	return g, nil
-}
-
-// Close finalizes the library. It should be called after a successful
-// initialization and when gocui is not needed anymore.
-func (g *Gui) Close() {
-	termbox.Close()
-}
-
-// Size returns the terminal's size.
-func (g *Gui) Size() (x, y int) {
-	return g.maxX, g.maxY
-}
-
-// SetRune writes a rune at the given point, relative to the top-left
-// corner of the terminal. It checks if the position is valid and applies
-// the given colors.
-func (g *Gui) SetRune(x, y int, ch rune, fgColor, bgColor Attribute) error {
-	if x < 0 || y < 0 || x >= g.maxX || y >= g.maxY {
-		return errors.New("invalid point")
-	}
-	termbox.SetCell(x, y, ch, termbox.Attribute(fgColor), termbox.Attribute(bgColor))
-	return nil
-}
-
-// Rune returns the rune contained in the cell at the given position.
-// It checks if the position is valid.
-func (g *Gui) Rune(x, y int) (rune, error) {
-	if x < 0 || y < 0 || x >= g.maxX || y >= g.maxY {
-		return ' ', errors.New("invalid point")
-	}
-	c := termbox.CellBuffer()[y*g.maxX+x]
-	return c.Ch, nil
-}
-
-// SetView creates a new view with its top-left corner at (x0, y0)
-// and the bottom-right one at (x1, y1). If a view with the same name
-// already exists, its dimensions are updated; otherwise, the error
-// ErrUnknownView is returned, which allows to assert if the View must
-// be initialized. It checks if the position is valid.
-func (g *Gui) SetView(name string, x0, y0, x1, y1 int, overlaps byte) (*View, error) {
-	if x0 >= x1 || y0 >= y1 {
-		return nil, errors.New("invalid dimensions")
-	}
-	if name == "" {
-		return nil, errors.New("invalid name")
-	}
-
-	if v, err := g.View(name); err == nil {
-		v.x0 = x0
-		v.y0 = y0
-		v.x1 = x1
-		v.y1 = y1
-		v.tainted = true
-		return v, nil
-	}
-
-	v := newView(name, x0, y0, x1, y1, g.outputMode)
-	v.BgColor, v.FgColor = g.BgColor, g.FgColor
-	v.SelBgColor, v.SelFgColor = g.SelBgColor, g.SelFgColor
-	v.Overlaps = overlaps
-	g.views = append(g.views, v)
-	return v, ErrUnknownView
-}
-
-// SetViewOnTop sets the given view on top of the existing ones.
-func (g *Gui) SetViewOnTop(name string) (*View, error) {
-	for i, v := range g.views {
-		if v.name == name {
-			s := append(g.views[:i], g.views[i+1:]...)
-			g.views = append(s, v)
-			return v, nil
-		}
-	}
-	return nil, ErrUnknownView
-}
-
-// SetViewOnBottom sets the given view on bottom of the existing ones.
-func (g *Gui) SetViewOnBottom(name string) (*View, error) {
-	for i, v := range g.views {
-		if v.name == name {
-			s := append(g.views[:i], g.views[i+1:]...)
-			g.views = append([]*View{v}, s...)
-			return v, nil
-		}
-	}
-	return nil, ErrUnknownView
-}
-
-// Views returns all the views in the GUI.
-func (g *Gui) Views() []*View {
-	return g.views
-}
-
-// View returns a pointer to the view with the given name, or error
-// ErrUnknownView if a view with that name does not exist.
-func (g *Gui) View(name string) (*View, error) {
-	for _, v := range g.views {
-		if v.name == name {
-			return v, nil
-		}
-	}
-	return nil, ErrUnknownView
-}
-
-// ViewByPosition returns a pointer to a view matching the given position, or
-// error ErrUnknownView if a view in that position does not exist.
-func (g *Gui) ViewByPosition(x, y int) (*View, error) {
-	// traverse views in reverse order checking top views first
-	for i := len(g.views); i > 0; i-- {
-		v := g.views[i-1]
-		if x > v.x0 && x < v.x1 && y > v.y0 && y < v.y1 {
-			return v, nil
-		}
-	}
-	return nil, ErrUnknownView
-}
-
-// ViewPosition returns the coordinates of the view with the given name, or
-// error ErrUnknownView if a view with that name does not exist.
-func (g *Gui) ViewPosition(name string) (x0, y0, x1, y1 int, err error) {
-	for _, v := range g.views {
-		if v.name == name {
-			return v.x0, v.y0, v.x1, v.y1, nil
-		}
-	}
-	return 0, 0, 0, 0, ErrUnknownView
-}
-
-// DeleteView deletes a view by name.
-func (g *Gui) DeleteView(name string) error {
-	for i, v := range g.views {
-		if v.name == name {
-			g.views = append(g.views[:i], g.views[i+1:]...)
-			return nil
-		}
-	}
-	return ErrUnknownView
-}
-
-// SetCurrentView gives the focus to a given view.
-func (g *Gui) SetCurrentView(name string) (*View, error) {
-	for _, v := range g.views {
-		if v.name == name {
-			g.currentView = v
-			return v, nil
-		}
-	}
-	return nil, ErrUnknownView
-}
-
-// CurrentView returns the currently focused view, or nil if no view
-// owns the focus.
-func (g *Gui) CurrentView() *View {
-	return g.currentView
-}
-
-// SetKeybinding creates a new keybinding. If viewname equals to ""
-// (empty string) then the keybinding will apply to all views. key must
-// be a rune or a Key.
-func (g *Gui) SetKeybinding(viewname string, key interface{}, mod Modifier, handler func(*Gui, *View) error) error {
-	var kb *keybinding
-
-	k, ch, err := getKey(key)
-	if err != nil {
-		return err
-	}
-	kb = newKeybinding(viewname, k, ch, mod, handler)
-	g.keybindings = append(g.keybindings, kb)
-	return nil
-}
-
-// DeleteKeybinding deletes a keybinding.
-func (g *Gui) DeleteKeybinding(viewname string, key interface{}, mod Modifier) error {
-	k, ch, err := getKey(key)
-	if err != nil {
-		return err
-	}
-
-	for i, kb := range g.keybindings {
-		if kb.viewName == viewname && kb.ch == ch && kb.key == k && kb.mod == mod {
-			g.keybindings = append(g.keybindings[:i], g.keybindings[i+1:]...)
-			return nil
-		}
-	}
-	return errors.New("keybinding not found")
-}
-
-// DeleteKeybindings deletes all keybindings of view.
-func (g *Gui) DeleteKeybindings(viewname string) {
-	var s []*keybinding
-	for _, kb := range g.keybindings {
-		if kb.viewName != viewname {
-			s = append(s, kb)
-		}
-	}
-	g.keybindings = s
-}
-
-// getKey takes an empty interface with a key and returns the corresponding
-// typed Key or rune.
-func getKey(key interface{}) (Key, rune, error) {
-	switch t := key.(type) {
-	case Key:
-		return t, 0, nil
-	case rune:
-		return 0, t, nil
-	default:
-		return 0, 0, errors.New("unknown type")
-	}
-}
-
-// userEvent represents an event triggered by the user.
-type userEvent struct {
-	f func(*Gui) error
-}
-
-// Update executes the passed function. This method can be called safely from a
-// goroutine in order to update the GUI. It is important to note that the
-// passed function won't be executed immediately, instead it will be added to
-// the user events queue. Given that Update spawns a goroutine, the order in
-// which the user events will be handled is not guaranteed.
-func (g *Gui) Update(f func(*Gui) error) {
-	go func() { g.userEvents <- userEvent{f: f} }()
-}
-
-// A Manager is in charge of GUI's layout and can be used to build widgets.
-type Manager interface {
-	// Layout is called every time the GUI is redrawn, it must contain the
-	// base views and its initializations.
-	Layout(*Gui) error
-}
-
-// The ManagerFunc type is an adapter to allow the use of ordinary functions as
-// Managers. If f is a function with the appropriate signature, ManagerFunc(f)
-// is an Manager object that calls f.
-type ManagerFunc func(*Gui) error
-
-// Layout calls f(g)
-func (f ManagerFunc) Layout(g *Gui) error {
-	return f(g)
-}
-
-// SetManager sets the given GUI managers. It deletes all views and
-// keybindings.
-func (g *Gui) SetManager(managers ...Manager) {
-	g.managers = managers
-	g.currentView = nil
-	g.views = nil
-	g.keybindings = nil
-
-	go func() { g.tbEvents <- termbox.Event{Type: termbox.EventResize} }()
-}
-
-// SetManagerFunc sets the given manager function. It deletes all views and
-// keybindings.
-func (g *Gui) SetManagerFunc(manager func(*Gui) error) {
-	g.SetManager(ManagerFunc(manager))
-}
-
-// MainLoop runs the main loop until an error is returned. A successful
-// finish should return ErrQuit.
-func (g *Gui) MainLoop() error {
-	go func() {
-		for {
-			g.tbEvents <- termbox.PollEvent()
-		}
-	}()
-
-	inputMode := termbox.InputAlt
-	if true { // previously g.InputEsc, but didn't seem to work
-		inputMode = termbox.InputEsc
-	}
-	if g.Mouse {
-		inputMode |= termbox.InputMouse
-	}
-	termbox.SetInputMode(inputMode)
-
-	if err := g.flush(); err != nil {
-		return err
-	}
-	for {
-		select {
-		case ev := <-g.tbEvents:
-			if err := g.handleEvent(&ev); err != nil {
-				return err
-			}
-		case ev := <-g.userEvents:
-			if err := ev.f(g); err != nil {
-				return err
-			}
-		}
-		if err := g.consumeevents(); err != nil {
-			return err
-		}
-		if err := g.flush(); err != nil {
-			return err
-		}
-	}
-}
-
-// consumeevents handles the remaining events in the events pool.
-func (g *Gui) consumeevents() error {
-	for {
-		select {
-		case ev := <-g.tbEvents:
-			if err := g.handleEvent(&ev); err != nil {
-				return err
-			}
-		case ev := <-g.userEvents:
-			if err := ev.f(g); err != nil {
-				return err
-			}
-		default:
-			return nil
-		}
-	}
-}
-
-// handleEvent handles an event, based on its type (key-press, error,
-// etc.)
-func (g *Gui) handleEvent(ev *termbox.Event) error {
-	switch ev.Type {
-	case termbox.EventKey, termbox.EventMouse:
-		return g.onKey(ev)
-	case termbox.EventError:
-		return ev.Err
-	default:
-		return nil
-	}
-}
-
-// flush updates the gui, re-drawing frames and buffers.
-func (g *Gui) flush() error {
-	termbox.Clear(termbox.Attribute(g.FgColor), termbox.Attribute(g.BgColor))
-
-	maxX, maxY := termbox.Size()
-	// if GUI's size has changed, we need to redraw all views
-	if maxX != g.maxX || maxY != g.maxY {
-		for _, v := range g.views {
-			v.tainted = true
-		}
-	}
-	g.maxX, g.maxY = maxX, maxY
-
-	for _, m := range g.managers {
-		if err := m.Layout(g); err != nil {
-			return err
-		}
-	}
-	for _, v := range g.views {
-		if v.Frame {
-			var fgColor, bgColor Attribute
-			if g.Highlight && v == g.currentView {
-				fgColor = g.SelFgColor
-				bgColor = g.SelBgColor
-			} else {
-				fgColor = g.FgColor
-				bgColor = g.BgColor
-			}
-
-			if err := g.drawFrameEdges(v, fgColor, bgColor); err != nil {
-				return err
-			}
-			if err := g.drawFrameCorners(v, fgColor, bgColor); err != nil {
-				return err
-			}
-			if v.Title != "" {
-				if err := g.drawTitle(v, fgColor, bgColor); err != nil {
-					return err
-				}
-			}
-		}
-		if err := g.draw(v); err != nil {
-			return err
-		}
-	}
-	termbox.Flush()
-	return nil
-}
-
-// drawFrameEdges draws the horizontal and vertical edges of a view.
-func (g *Gui) drawFrameEdges(v *View, fgColor, bgColor Attribute) error {
-	runeH, runeV := '─', '│'
-	if g.ASCII {
-		runeH, runeV = '-', '|'
-	}
-
-	for x := v.x0 + 1; x < v.x1 && x < g.maxX; x++ {
-		if x < 0 {
-			continue
-		}
-		if v.y0 > -1 && v.y0 < g.maxY {
-			if err := g.SetRune(x, v.y0, runeH, fgColor, bgColor); err != nil {
-				return err
-			}
-		}
-		if v.y1 > -1 && v.y1 < g.maxY {
-			if err := g.SetRune(x, v.y1, runeH, fgColor, bgColor); err != nil {
-				return err
-			}
-		}
-	}
-	for y := v.y0 + 1; y < v.y1 && y < g.maxY; y++ {
-		if y < 0 {
-			continue
-		}
-		if v.x0 > -1 && v.x0 < g.maxX {
-			if err := g.SetRune(v.x0, y, runeV, fgColor, bgColor); err != nil {
-				return err
-			}
-		}
-		if v.x1 > -1 && v.x1 < g.maxX {
-			if err := g.SetRune(v.x1, y, runeV, fgColor, bgColor); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func cornerRune(index byte) rune {
-	return []rune{' ', '│', '│', '│', '─', '┘', '┐', '┤', '─', '└', '┌', '├', '├', '┴', '┬', '┼'}[index]
-}
-
-func corner(v *View, directions byte) rune {
-	index := v.Overlaps | directions
-	return cornerRune(index)
-}
-
-// drawFrameCorners draws the corners of the view.
-func (g *Gui) drawFrameCorners(v *View, fgColor, bgColor Attribute) error {
-	runeTL, runeTR, runeBL, runeBR := '┌', '┐', '└', '┘'
-	if g.SupportOverlaps {
-		runeTL = corner(v, BOTTOM|RIGHT)
-		runeTR = corner(v, BOTTOM|LEFT)
-		runeBL = corner(v, TOP|RIGHT)
-		runeBR = corner(v, TOP|LEFT)
-	}
-	if g.ASCII {
-		runeTL, runeTR, runeBL, runeBR = '+', '+', '+', '+'
-	}
-
-	corners := []struct {
-		x, y int
-		ch   rune
-	}{{v.x0, v.y0, runeTL}, {v.x1, v.y0, runeTR}, {v.x0, v.y1, runeBL}, {v.x1, v.y1, runeBR}}
-
-	for _, c := range corners {
-		if c.x >= 0 && c.y >= 0 && c.x < g.maxX && c.y < g.maxY {
-			if err := g.SetRune(c.x, c.y, c.ch, fgColor, bgColor); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-// drawTitle draws the title of the view.
-func (g *Gui) drawTitle(v *View, fgColor, bgColor Attribute) error {
-	if v.y0 < 0 || v.y0 >= g.maxY {
-		return nil
-	}
-
-	for i, ch := range v.Title {
-		x := v.x0 + i + 2
-		if x < 0 {
-			continue
-		} else if x > v.x1-2 || x >= g.maxX {
-			break
-		}
-		if err := g.SetRune(x, v.y0, ch, fgColor, bgColor); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// draw manages the cursor and calls the draw function of a view.
-func (g *Gui) draw(v *View) error {
-	if g.Cursor {
-		if curview := g.currentView; curview != nil {
-			vMaxX, vMaxY := curview.Size()
-			if curview.cx < 0 {
-				curview.cx = 0
-			} else if curview.cx >= vMaxX {
-				curview.cx = vMaxX - 1
-			}
-			if curview.cy < 0 {
-				curview.cy = 0
-			} else if curview.cy >= vMaxY {
-				curview.cy = vMaxY - 1
-			}
-
-			gMaxX, gMaxY := g.Size()
-			cx, cy := curview.x0+curview.cx+1, curview.y0+curview.cy+1
-			if cx >= 0 && cx < gMaxX && cy >= 0 && cy < gMaxY {
-				termbox.SetCursor(cx, cy)
-			} else {
-				termbox.HideCursor()
-			}
-		}
-	} else {
-		termbox.HideCursor()
-	}
-
-	v.clearRunes()
-	if err := v.draw(); err != nil {
-		return err
-	}
-	return nil
-}
-
-// onKey manages key-press events. A keybinding handler is called when
-// a key-press or mouse event satisfies a configured keybinding. Furthermore,
-// currentView's internal buffer is modified if currentView.Editable is true.
-func (g *Gui) onKey(ev *termbox.Event) error {
-	switch ev.Type {
-	case termbox.EventKey:
-		matched, err := g.execKeybindings(g.currentView, ev)
-		if err != nil {
-			return err
-		}
-		if matched {
-			break
-		}
-		if g.currentView != nil && g.currentView.Editable && g.currentView.Editor != nil {
-			g.currentView.Editor.Edit(g.currentView, Key(ev.Key), ev.Ch, Modifier(ev.Mod))
-		}
-	case termbox.EventMouse:
-		mx, my := ev.MouseX, ev.MouseY
-		v, err := g.ViewByPosition(mx, my)
-		if err != nil {
-			break
-		}
-		if err := v.SetCursor(mx-v.x0-1, my-v.y0-1); err != nil {
-			return err
-		}
-		if _, err := g.execKeybindings(v, ev); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-// execKeybindings executes the keybinding handlers that match the passed view
-// and event. The value of matched is true if there is a match and no errors.
-func (g *Gui) execKeybindings(v *View, ev *termbox.Event) (matched bool, err error) {
-	matched = false
-	for _, kb := range g.keybindings {
-		if kb.handler == nil {
-			continue
-		}
-		if kb.matchKeypress(Key(ev.Key), ev.Ch, Modifier(ev.Mod)) && kb.matchView(v) {
-			if err := kb.handler(g, v); err != nil {
-				return false, err
-			}
-			matched = true
-		}
-	}
-	return matched, nil
-}

vendor/github.com/jesseduffield/gocui/keybinding.go

@@ -1,141 +0,0 @@
-// Copyright 2014 The gocui Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gocui
-
-import "github.com/nsf/termbox-go"
-
-// Keybidings are used to link a given key-press event with a handler.
-type keybinding struct {
-	viewName string
-	key      Key
-	ch       rune
-	mod      Modifier
-	handler  func(*Gui, *View) error
-}
-
-// newKeybinding returns a new Keybinding object.
-func newKeybinding(viewname string, key Key, ch rune, mod Modifier, handler func(*Gui, *View) error) (kb *keybinding) {
-	kb = &keybinding{
-		viewName: viewname,
-		key:      key,
-		ch:       ch,
-		mod:      mod,
-		handler:  handler,
-	}
-	return kb
-}
-
-// matchKeypress returns if the keybinding matches the keypress.
-func (kb *keybinding) matchKeypress(key Key, ch rune, mod Modifier) bool {
-	return kb.key == key && kb.ch == ch && kb.mod == mod
-}
-
-// matchView returns if the keybinding matches the current view.
-func (kb *keybinding) matchView(v *View) bool {
-	// if the user is typing in a field, ignore char keys
-	if v.Editable == true && kb.ch != 0 {
-		return false
-	}
-	if kb.viewName == "" {
-		return true
-	}
-	return v != nil && kb.viewName == v.name
-}
-
-// Key represents special keys or keys combinations.
-type Key termbox.Key
-
-// Special keys.
-const (
-	KeyF1         Key = Key(termbox.KeyF1)
-	KeyF2             = Key(termbox.KeyF2)
-	KeyF3             = Key(termbox.KeyF3)
-	KeyF4             = Key(termbox.KeyF4)
-	KeyF5             = Key(termbox.KeyF5)
-	KeyF6             = Key(termbox.KeyF6)
-	KeyF7             = Key(termbox.KeyF7)
-	KeyF8             = Key(termbox.KeyF8)
-	KeyF9             = Key(termbox.KeyF9)
-	KeyF10            = Key(termbox.KeyF10)
-	KeyF11            = Key(termbox.KeyF11)
-	KeyF12            = Key(termbox.KeyF12)
-	KeyInsert         = Key(termbox.KeyInsert)
-	KeyDelete         = Key(termbox.KeyDelete)
-	KeyHome           = Key(termbox.KeyHome)
-	KeyEnd            = Key(termbox.KeyEnd)
-	KeyPgup           = Key(termbox.KeyPgup)
-	KeyPgdn           = Key(termbox.KeyPgdn)
-	KeyArrowUp        = Key(termbox.KeyArrowUp)
-	KeyArrowDown      = Key(termbox.KeyArrowDown)
-	KeyArrowLeft      = Key(termbox.KeyArrowLeft)
-	KeyArrowRight     = Key(termbox.KeyArrowRight)
-
-	MouseLeft      = Key(termbox.MouseLeft)
-	MouseMiddle    = Key(termbox.MouseMiddle)
-	MouseRight     = Key(termbox.MouseRight)
-	MouseRelease   = Key(termbox.MouseRelease)
-	MouseWheelUp   = Key(termbox.MouseWheelUp)
-	MouseWheelDown = Key(termbox.MouseWheelDown)
-)
-
-// Keys combinations.
-const (
-	KeyCtrlTilde      Key = Key(termbox.KeyCtrlTilde)
-	KeyCtrl2              = Key(termbox.KeyCtrl2)
-	KeyCtrlSpace          = Key(termbox.KeyCtrlSpace)
-	KeyCtrlA              = Key(termbox.KeyCtrlA)
-	KeyCtrlB              = Key(termbox.KeyCtrlB)
-	KeyCtrlC              = Key(termbox.KeyCtrlC)
-	KeyCtrlD              = Key(termbox.KeyCtrlD)
-	KeyCtrlE              = Key(termbox.KeyCtrlE)
-	KeyCtrlF              = Key(termbox.KeyCtrlF)
-	KeyCtrlG              = Key(termbox.KeyCtrlG)
-	KeyBackspace          = Key(termbox.KeyBackspace)
-	KeyCtrlH              = Key(termbox.KeyCtrlH)
-	KeyTab                = Key(termbox.KeyTab)
-	KeyCtrlI              = Key(termbox.KeyCtrlI)
-	KeyCtrlJ              = Key(termbox.KeyCtrlJ)
-	KeyCtrlK              = Key(termbox.KeyCtrlK)
-	KeyCtrlL              = Key(termbox.KeyCtrlL)
-	KeyEnter              = Key(termbox.KeyEnter)
-	KeyCtrlM              = Key(termbox.KeyCtrlM)
-	KeyCtrlN              = Key(termbox.KeyCtrlN)
-	KeyCtrlO              = Key(termbox.KeyCtrlO)
-	KeyCtrlP              = Key(termbox.KeyCtrlP)
-	KeyCtrlQ              = Key(termbox.KeyCtrlQ)
-	KeyCtrlR              = Key(termbox.KeyCtrlR)
-	KeyCtrlS              = Key(termbox.KeyCtrlS)
-	KeyCtrlT              = Key(termbox.KeyCtrlT)
-	KeyCtrlU              = Key(termbox.KeyCtrlU)
-	KeyCtrlV              = Key(termbox.KeyCtrlV)
-	KeyCtrlW              = Key(termbox.KeyCtrlW)
-	KeyCtrlX              = Key(termbox.KeyCtrlX)
-	KeyCtrlY              = Key(termbox.KeyCtrlY)
-	KeyCtrlZ              = Key(termbox.KeyCtrlZ)
-	KeyEsc                = Key(termbox.KeyEsc)
-	KeyCtrlLsqBracket     = Key(termbox.KeyCtrlLsqBracket)
-	KeyCtrl3              = Key(termbox.KeyCtrl3)
-	KeyCtrl4              = Key(termbox.KeyCtrl4)
-	KeyCtrlBackslash      = Key(termbox.KeyCtrlBackslash)
-	KeyCtrl5              = Key(termbox.KeyCtrl5)
-	KeyCtrlRsqBracket     = Key(termbox.KeyCtrlRsqBracket)
-	KeyCtrl6              = Key(termbox.KeyCtrl6)
-	KeyCtrl7              = Key(termbox.KeyCtrl7)
-	KeyCtrlSlash          = Key(termbox.KeyCtrlSlash)
-	KeyCtrlUnderscore     = Key(termbox.KeyCtrlUnderscore)
-	KeySpace              = Key(termbox.KeySpace)
-	KeyBackspace2         = Key(termbox.KeyBackspace2)
-	KeyCtrl8              = Key(termbox.KeyCtrl8)
-)
-
-// Modifier allows to define special keys combinations. They can be used
-// in combination with Keys or Runes when a new keybinding is defined.
-type Modifier termbox.Modifier
-
-// Modifiers.
-const (
-	ModNone Modifier = Modifier(0)
-	ModAlt           = Modifier(termbox.ModAlt)
-)

vendor/github.com/jesseduffield/gocui/view.go

@@ -1,513 +0,0 @@
-// Copyright 2014 The gocui Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package gocui
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"strings"
-
-	"github.com/nsf/termbox-go"
-)
-
-// Constants for overlapping edges
-const (
-	TOP    = 1 // view is overlapping at top edge
-	BOTTOM = 2 // view is overlapping at bottom edge
-	LEFT   = 4 // view is overlapping at left edge
-	RIGHT  = 8 // view is overlapping at right edge
-)
-
-// A View is a window. It maintains its own internal buffer and cursor
-// position.
-type View struct {
-	name           string
-	x0, y0, x1, y1 int
-	ox, oy         int
-	cx, cy         int
-	lines          [][]cell
-	readOffset     int
-	readCache      string
-
-	tainted   bool       // marks if the viewBuffer must be updated
-	viewLines []viewLine // internal representation of the view's buffer
-
-	ei *escapeInterpreter // used to decode ESC sequences on Write
-
-	// BgColor and FgColor allow to configure the background and foreground
-	// colors of the View.
-	BgColor, FgColor Attribute
-
-	// SelBgColor and SelFgColor are used to configure the background and
-	// foreground colors of the selected line, when it is highlighted.
-	SelBgColor, SelFgColor Attribute
-
-	// If Editable is true, keystrokes will be added to the view's internal
-	// buffer at the cursor position.
-	Editable bool
-
-	// Editor allows to define the editor that manages the edition mode,
-	// including keybindings or cursor behaviour. DefaultEditor is used by
-	// default.
-	Editor Editor
-
-	// Overwrite enables or disables the overwrite mode of the view.
-	Overwrite bool
-
-	// If Highlight is true, Sel{Bg,Fg}Colors will be used
-	// for the line under the cursor position.
-	Highlight bool
-
-	// If Frame is true, a border will be drawn around the view.
-	Frame bool
-
-	// If Wrap is true, the content that is written to this View is
-	// automatically wrapped when it is longer than its width. If true the
-	// view's x-origin will be ignored.
-	Wrap bool
-
-	// If Autoscroll is true, the View will automatically scroll down when the
-	// text overflows. If true the view's y-origin will be ignored.
-	Autoscroll bool
-
-	// If Frame is true, Title allows to configure a title for the view.
-	Title string
-
-	// If Mask is true, the View will display the mask instead of the real
-	// content
-	Mask rune
-
-	// Overlaps describes which edges are overlapping with another view's edges
-	Overlaps byte
-}
-
-type viewLine struct {
-	linesX, linesY int // coordinates relative to v.lines
-	line           []cell
-}
-
-type cell struct {
-	chr              rune
-	bgColor, fgColor Attribute
-}
-
-type lineType []cell
-
-// String returns a string from a given cell slice.
-func (l lineType) String() string {
-	str := ""
-	for _, c := range l {
-		str += string(c.chr)
-	}
-	return str
-}
-
-// newView returns a new View object.
-func newView(name string, x0, y0, x1, y1 int, mode OutputMode) *View {
-	v := &View{
-		name:    name,
-		x0:      x0,
-		y0:      y0,
-		x1:      x1,
-		y1:      y1,
-		Frame:   true,
-		Editor:  DefaultEditor,
-		tainted: true,
-		ei:      newEscapeInterpreter(mode),
-	}
-	return v
-}
-
-// Size returns the number of visible columns and rows in the View.
-func (v *View) Size() (x, y int) {
-	return v.x1 - v.x0 - 1, v.y1 - v.y0 - 1
-}
-
-// Name returns the name of the view.
-func (v *View) Name() string {
-	return v.name
-}
-
-// setRune sets a rune at the given point relative to the view. It applies the
-// specified colors, taking into account if the cell must be highlighted. Also,
-// it checks if the position is valid.
-func (v *View) setRune(x, y int, ch rune, fgColor, bgColor Attribute) error {
-	maxX, maxY := v.Size()
-	if x < 0 || x >= maxX || y < 0 || y >= maxY {
-		return errors.New("invalid point")
-	}
-
-	var (
-		ry, rcy int
-		err     error
-	)
-	if v.Highlight {
-		_, ry, err = v.realPosition(x, y)
-		if err != nil {
-			return err
-		}
-		_, rcy, err = v.realPosition(v.cx, v.cy)
-		if err != nil {
-			return err
-		}
-	}
-
-	if v.Mask != 0 {
-		fgColor = v.FgColor
-		bgColor = v.BgColor
-		ch = v.Mask
-	} else if v.Highlight && ry == rcy {
-		fgColor = fgColor | AttrBold
-	}
-
-	termbox.SetCell(v.x0+x+1, v.y0+y+1, ch,
-		termbox.Attribute(fgColor), termbox.Attribute(bgColor))
-
-	return nil
-}
-
-// SetCursor sets the cursor position of the view at the given point,
-// relative to the view. It checks if the position is valid.
-func (v *View) SetCursor(x, y int) error {
-	maxX, maxY := v.Size()
-	if x < 0 || x >= maxX || y < 0 || y >= maxY {
-		return errors.New("invalid point")
-	}
-	v.cx = x
-	v.cy = y
-	return nil
-}
-
-// Cursor returns the cursor position of the view.
-func (v *View) Cursor() (x, y int) {
-	return v.cx, v.cy
-}
-
-// SetOrigin sets the origin position of the view's internal buffer,
-// so the buffer starts to be printed from this point, which means that
-// it is linked with the origin point of view. It can be used to
-// implement Horizontal and Vertical scrolling with just incrementing
-// or decrementing ox and oy.
-func (v *View) SetOrigin(x, y int) error {
-	if x < 0 || y < 0 {
-		return errors.New("invalid point")
-	}
-	v.ox = x
-	v.oy = y
-	return nil
-}
-
-// Origin returns the origin position of the view.
-func (v *View) Origin() (x, y int) {
-	return v.ox, v.oy
-}
-
-// Write appends a byte slice into the view's internal buffer. Because
-// View implements the io.Writer interface, it can be passed as parameter
-// of functions like fmt.Fprintf, fmt.Fprintln, io.Copy, etc. Clear must
-// be called to clear the view's buffer.
-func (v *View) Write(p []byte) (n int, err error) {
-	v.tainted = true
-
-	for _, ch := range bytes.Runes(p) {
-		switch ch {
-		case '\n':
-			v.lines = append(v.lines, nil)
-		case '\r':
-			nl := len(v.lines)
-			if nl > 0 {
-				v.lines[nl-1] = nil
-			} else {
-				v.lines = make([][]cell, 1)
-			}
-		default:
-			cells := v.parseInput(ch)
-			if cells == nil {
-				continue
-			}
-
-			nl := len(v.lines)
-			if nl > 0 {
-				v.lines[nl-1] = append(v.lines[nl-1], cells...)
-			} else {
-				v.lines = append(v.lines, cells)
-			}
-		}
-	}
-	return len(p), nil
-}
-
-// parseInput parses char by char the input written to the View. It returns nil
-// while processing ESC sequences. Otherwise, it returns a cell slice that
-// contains the processed data.
-func (v *View) parseInput(ch rune) []cell {
-	cells := []cell{}
-
-	isEscape, err := v.ei.parseOne(ch)
-	if err != nil {
-		for _, r := range v.ei.runes() {
-			c := cell{
-				fgColor: v.FgColor,
-				bgColor: v.BgColor,
-				chr:     r,
-			}
-			cells = append(cells, c)
-		}
-		v.ei.reset()
-	} else {
-		if isEscape {
-			return nil
-		}
-		c := cell{
-			fgColor: v.ei.curFgColor,
-			bgColor: v.ei.curBgColor,
-			chr:     ch,
-		}
-		cells = append(cells, c)
-	}
-
-	return cells
-}
-
-// Read reads data into p. It returns the number of bytes read into p.
-// At EOF, err will be io.EOF. Calling Read() after Rewind() makes the
-// cache to be refreshed with the contents of the view.
-func (v *View) Read(p []byte) (n int, err error) {
-	if v.readOffset == 0 {
-		v.readCache = v.Buffer()
-	}
-	if v.readOffset < len(v.readCache) {
-		n = copy(p, v.readCache[v.readOffset:])
-		v.readOffset += n
-	} else {
-		err = io.EOF
-	}
-	return
-}
-
-// Rewind sets the offset for the next Read to 0, which also refresh the
-// read cache.
-func (v *View) Rewind() {
-	v.readOffset = 0
-}
-
-// draw re-draws the view's contents.
-func (v *View) draw() error {
-	maxX, maxY := v.Size()
-
-	if v.Wrap {
-		if maxX == 0 {
-			return errors.New("X size of the view cannot be 0")
-		}
-		v.ox = 0
-	}
-	if v.tainted {
-		v.viewLines = nil
-		for i, line := range v.lines {
-			if v.Wrap {
-				if len(line) < maxX {
-					vline := viewLine{linesX: 0, linesY: i, line: line}
-					v.viewLines = append(v.viewLines, vline)
-					continue
-				} else {
-					for n := 0; n <= len(line); n += maxX {
-						if len(line[n:]) <= maxX {
-							vline := viewLine{linesX: n, linesY: i, line: line[n:]}
-							v.viewLines = append(v.viewLines, vline)
-						} else {
-							vline := viewLine{linesX: n, linesY: i, line: line[n : n+maxX]}
-							v.viewLines = append(v.viewLines, vline)
-						}
-					}
-				}
-			} else {
-				vline := viewLine{linesX: 0, linesY: i, line: line}
-				v.viewLines = append(v.viewLines, vline)
-			}
-		}
-		v.tainted = false
-	}
-
-	if v.Autoscroll && len(v.viewLines) > maxY {
-		v.oy = len(v.viewLines) - maxY
-	}
-	y := 0
-	for i, vline := range v.viewLines {
-		if i < v.oy {
-			continue
-		}
-		if y >= maxY {
-			break
-		}
-		x := 0
-		for j, c := range vline.line {
-			if j < v.ox {
-				continue
-			}
-			if x >= maxX {
-				break
-			}
-
-			fgColor := c.fgColor
-			if fgColor == ColorDefault {
-				fgColor = v.FgColor
-			}
-			bgColor := c.bgColor
-			if bgColor == ColorDefault {
-				bgColor = v.BgColor
-			}
-
-			if err := v.setRune(x, y, c.chr, fgColor, bgColor); err != nil {
-				return err
-			}
-			x++
-		}
-		y++
-	}
-	return nil
-}
-
-// realPosition returns the position in the internal buffer corresponding to the
-// point (x, y) of the view.
-func (v *View) realPosition(vx, vy int) (x, y int, err error) {
-	vx = v.ox + vx
-	vy = v.oy + vy
-
-	if vx < 0 || vy < 0 {
-		return 0, 0, errors.New("invalid point")
-	}
-
-	if len(v.viewLines) == 0 {
-		return vx, vy, nil
-	}
-
-	if vy < len(v.viewLines) {
-		vline := v.viewLines[vy]
-		x = vline.linesX + vx
-		y = vline.linesY
-	} else {
-		vline := v.viewLines[len(v.viewLines)-1]
-		x = vx
-		y = vline.linesY + vy - len(v.viewLines) + 1
-	}
-
-	return x, y, nil
-}
-
-// Clear empties the view's internal buffer.
-func (v *View) Clear() {
-	v.tainted = true
-
-	v.lines = nil
-	v.viewLines = nil
-	v.readOffset = 0
-	v.clearRunes()
-}
-
-// clearRunes erases all the cells in the view.
-func (v *View) clearRunes() {
-	maxX, maxY := v.Size()
-	for x := 0; x < maxX; x++ {
-		for y := 0; y < maxY; y++ {
-			termbox.SetCell(v.x0+x+1, v.y0+y+1, ' ',
-				termbox.Attribute(v.FgColor), termbox.Attribute(v.BgColor))
-		}
-	}
-}
-
-// BufferLines returns the lines in the view's internal
-// buffer.
-func (v *View) BufferLines() []string {
-	lines := make([]string, len(v.lines))
-	for i, l := range v.lines {
-		str := lineType(l).String()
-		str = strings.Replace(str, "\x00", " ", -1)
-		lines[i] = str
-	}
-	return lines
-}
-
-// Buffer returns a string with the contents of the view's internal
-// buffer.
-func (v *View) Buffer() string {
-	str := ""
-	for _, l := range v.lines {
-		str += lineType(l).String() + "\n"
-	}
-	return strings.Replace(str, "\x00", " ", -1)
-}
-
-// ViewBufferLines returns the lines in the view's internal
-// buffer that is shown to the user.
-func (v *View) ViewBufferLines() []string {
-	lines := make([]string, len(v.viewLines))
-	for i, l := range v.viewLines {
-		str := lineType(l.line).String()
-		str = strings.Replace(str, "\x00", " ", -1)
-		lines[i] = str
-	}
-	return lines
-}
-
-// ViewBuffer returns a string with the contents of the view's buffer that is
-// shown to the user.
-func (v *View) ViewBuffer() string {
-	str := ""
-	for _, l := range v.viewLines {
-		str += lineType(l.line).String() + "\n"
-	}
-	return strings.Replace(str, "\x00", " ", -1)
-}
-
-// Line returns a string with the line of the view's internal buffer
-// at the position corresponding to the point (x, y).
-func (v *View) Line(y int) (string, error) {
-	_, y, err := v.realPosition(0, y)
-	if err != nil {
-		return "", err
-	}
-
-	if y < 0 || y >= len(v.lines) {
-		return "", errors.New("invalid point")
-	}
-
-	return lineType(v.lines[y]).String(), nil
-}
-
-// Word returns a string with the word of the view's internal buffer
-// at the position corresponding to the point (x, y).
-func (v *View) Word(x, y int) (string, error) {
-	x, y, err := v.realPosition(x, y)
-	if err != nil {
-		return "", err
-	}
-
-	if x < 0 || y < 0 || y >= len(v.lines) || x >= len(v.lines[y]) {
-		return "", errors.New("invalid point")
-	}
-
-	str := lineType(v.lines[y]).String()
-
-	nl := strings.LastIndexFunc(str[:x], indexFunc)
-	if nl == -1 {
-		nl = 0
-	} else {
-		nl = nl + 1
-	}
-	nr := strings.IndexFunc(str[x:], indexFunc)
-	if nr == -1 {
-		nr = len(str)
-	} else {
-		nr = nr + x
-	}
-	return string(str[nl:nr]), nil
-}
-
-// indexFunc allows to split lines by words taking into account spaces
-// and 0.
-func indexFunc(r rune) bool {
-	return r == ' ' || r == 0
-}

vendor/github.com/mattn/go-colorable/LICENSE

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

vendor/github.com/mattn/go-colorable/colorable_appengine.go

@@ -1,29 +0,0 @@
-// +build appengine
-
-package colorable
-
-import (
-	"io"
-	"os"
-
-	_ "github.com/mattn/go-isatty"
-)
-
-// NewColorable return new instance of Writer which handle escape sequence.
-func NewColorable(file *os.File) io.Writer {
-	if file == nil {
-		panic("nil passed instead of *os.File to NewColorable()")
-	}
-
-	return file
-}
-
-// NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
-func NewColorableStdout() io.Writer {
-	return os.Stdout
-}
-
-// NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
-func NewColorableStderr() io.Writer {
-	return os.Stderr
-}

vendor/github.com/mattn/go-colorable/colorable_others.go

@@ -1,30 +0,0 @@
-// +build !windows
-// +build !appengine
-
-package colorable
-
-import (
-	"io"
-	"os"
-
-	_ "github.com/mattn/go-isatty"
-)
-
-// NewColorable return new instance of Writer which handle escape sequence.
-func NewColorable(file *os.File) io.Writer {
-	if file == nil {
-		panic("nil passed instead of *os.File to NewColorable()")
-	}
-
-	return file
-}
-
-// NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
-func NewColorableStdout() io.Writer {
-	return os.Stdout
-}
-
-// NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
-func NewColorableStderr() io.Writer {
-	return os.Stderr
-}

vendor/github.com/mattn/go-colorable/colorable_windows.go

@@ -1,884 +0,0 @@
-// +build windows
-// +build !appengine
-
-package colorable
-
-import (
-	"bytes"
-	"io"
-	"math"
-	"os"
-	"strconv"
-	"strings"
-	"syscall"
-	"unsafe"
-
-	"github.com/mattn/go-isatty"
-)
-
-const (
-	foregroundBlue      = 0x1
-	foregroundGreen     = 0x2
-	foregroundRed       = 0x4
-	foregroundIntensity = 0x8
-	foregroundMask      = (foregroundRed | foregroundBlue | foregroundGreen | foregroundIntensity)
-	backgroundBlue      = 0x10
-	backgroundGreen     = 0x20
-	backgroundRed       = 0x40
-	backgroundIntensity = 0x80
-	backgroundMask      = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity)
-)
-
-type wchar uint16
-type short int16
-type dword uint32
-type word uint16
-
-type coord struct {
-	x short
-	y short
-}
-
-type smallRect struct {
-	left   short
-	top    short
-	right  short
-	bottom short
-}
-
-type consoleScreenBufferInfo struct {
-	size              coord
-	cursorPosition    coord
-	attributes        word
-	window            smallRect
-	maximumWindowSize coord
-}
-
-type consoleCursorInfo struct {
-	size    dword
-	visible int32
-}
-
-var (
-	kernel32                       = syscall.NewLazyDLL("kernel32.dll")
-	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
-	procSetConsoleTextAttribute    = kernel32.NewProc("SetConsoleTextAttribute")
-	procSetConsoleCursorPosition   = kernel32.NewProc("SetConsoleCursorPosition")
-	procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW")
-	procFillConsoleOutputAttribute = kernel32.NewProc("FillConsoleOutputAttribute")
-	procGetConsoleCursorInfo       = kernel32.NewProc("GetConsoleCursorInfo")
-	procSetConsoleCursorInfo       = kernel32.NewProc("SetConsoleCursorInfo")
-	procSetConsoleTitle            = kernel32.NewProc("SetConsoleTitleW")
-)
-
-// Writer provide colorable Writer to the console
-type Writer struct {
-	out     io.Writer
-	handle  syscall.Handle
-	oldattr word
-	oldpos  coord
-}
-
-// NewColorable return new instance of Writer which handle escape sequence from File.
-func NewColorable(file *os.File) io.Writer {
-	if file == nil {
-		panic("nil passed instead of *os.File to NewColorable()")
-	}
-
-	if isatty.IsTerminal(file.Fd()) {
-		var csbi consoleScreenBufferInfo
-		handle := syscall.Handle(file.Fd())
-		procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
-		return &Writer{out: file, handle: handle, oldattr: csbi.attributes, oldpos: coord{0, 0}}
-	}
-	return file
-}
-
-// NewColorableStdout return new instance of Writer which handle escape sequence for stdout.
-func NewColorableStdout() io.Writer {
-	return NewColorable(os.Stdout)
-}
-
-// NewColorableStderr return new instance of Writer which handle escape sequence for stderr.
-func NewColorableStderr() io.Writer {
-	return NewColorable(os.Stderr)
-}
-
-var color256 = map[int]int{
-	0:   0x000000,
-	1:   0x800000,
-	2:   0x008000,
-	3:   0x808000,
-	4:   0x000080,
-	5:   0x800080,
-	6:   0x008080,
-	7:   0xc0c0c0,
-	8:   0x808080,
-	9:   0xff0000,
-	10:  0x00ff00,
-	11:  0xffff00,
-	12:  0x0000ff,
-	13:  0xff00ff,
-	14:  0x00ffff,
-	15:  0xffffff,
-	16:  0x000000,
-	17:  0x00005f,
-	18:  0x000087,
-	19:  0x0000af,
-	20:  0x0000d7,
-	21:  0x0000ff,
-	22:  0x005f00,
-	23:  0x005f5f,
-	24:  0x005f87,
-	25:  0x005faf,
-	26:  0x005fd7,
-	27:  0x005fff,
-	28:  0x008700,
-	29:  0x00875f,
-	30:  0x008787,
-	31:  0x0087af,
-	32:  0x0087d7,
-	33:  0x0087ff,
-	34:  0x00af00,
-	35:  0x00af5f,
-	36:  0x00af87,
-	37:  0x00afaf,
-	38:  0x00afd7,
-	39:  0x00afff,
-	40:  0x00d700,
-	41:  0x00d75f,
-	42:  0x00d787,
-	43:  0x00d7af,
-	44:  0x00d7d7,
-	45:  0x00d7ff,
-	46:  0x00ff00,
-	47:  0x00ff5f,
-	48:  0x00ff87,
-	49:  0x00ffaf,
-	50:  0x00ffd7,
-	51:  0x00ffff,
-	52:  0x5f0000,
-	53:  0x5f005f,
-	54:  0x5f0087,
-	55:  0x5f00af,
-	56:  0x5f00d7,
-	57:  0x5f00ff,
-	58:  0x5f5f00,
-	59:  0x5f5f5f,
-	60:  0x5f5f87,
-	61:  0x5f5faf,
-	62:  0x5f5fd7,
-	63:  0x5f5fff,
-	64:  0x5f8700,
-	65:  0x5f875f,
-	66:  0x5f8787,
-	67:  0x5f87af,
-	68:  0x5f87d7,
-	69:  0x5f87ff,
-	70:  0x5faf00,
-	71:  0x5faf5f,
-	72:  0x5faf87,
-	73:  0x5fafaf,
-	74:  0x5fafd7,
-	75:  0x5fafff,
-	76:  0x5fd700,
-	77:  0x5fd75f,
-	78:  0x5fd787,
-	79:  0x5fd7af,
-	80:  0x5fd7d7,
-	81:  0x5fd7ff,
-	82:  0x5fff00,
-	83:  0x5fff5f,
-	84:  0x5fff87,
-	85:  0x5fffaf,
-	86:  0x5fffd7,
-	87:  0x5fffff,
-	88:  0x870000,
-	89:  0x87005f,
-	90:  0x870087,
-	91:  0x8700af,
-	92:  0x8700d7,
-	93:  0x8700ff,
-	94:  0x875f00,
-	95:  0x875f5f,
-	96:  0x875f87,
-	97:  0x875faf,
-	98:  0x875fd7,
-	99:  0x875fff,
-	100: 0x878700,
-	101: 0x87875f,
-	102: 0x878787,
-	103: 0x8787af,
-	104: 0x8787d7,
-	105: 0x8787ff,
-	106: 0x87af00,
-	107: 0x87af5f,
-	108: 0x87af87,
-	109: 0x87afaf,
-	110: 0x87afd7,
-	111: 0x87afff,
-	112: 0x87d700,
-	113: 0x87d75f,
-	114: 0x87d787,
-	115: 0x87d7af,
-	116: 0x87d7d7,
-	117: 0x87d7ff,
-	118: 0x87ff00,
-	119: 0x87ff5f,
-	120: 0x87ff87,
-	121: 0x87ffaf,
-	122: 0x87ffd7,
-	123: 0x87ffff,
-	124: 0xaf0000,
-	125: 0xaf005f,
-	126: 0xaf0087,
-	127: 0xaf00af,
-	128: 0xaf00d7,
-	129: 0xaf00ff,
-	130: 0xaf5f00,
-	131: 0xaf5f5f,
-	132: 0xaf5f87,
-	133: 0xaf5faf,
-	134: 0xaf5fd7,
-	135: 0xaf5fff,
-	136: 0xaf8700,
-	137: 0xaf875f,
-	138: 0xaf8787,
-	139: 0xaf87af,
-	140: 0xaf87d7,
-	141: 0xaf87ff,
-	142: 0xafaf00,
-	143: 0xafaf5f,
-	144: 0xafaf87,
-	145: 0xafafaf,
-	146: 0xafafd7,
-	147: 0xafafff,
-	148: 0xafd700,
-	149: 0xafd75f,
-	150: 0xafd787,
-	151: 0xafd7af,
-	152: 0xafd7d7,
-	153: 0xafd7ff,
-	154: 0xafff00,
-	155: 0xafff5f,
-	156: 0xafff87,
-	157: 0xafffaf,
-	158: 0xafffd7,
-	159: 0xafffff,
-	160: 0xd70000,
-	161: 0xd7005f,
-	162: 0xd70087,
-	163: 0xd700af,
-	164: 0xd700d7,
-	165: 0xd700ff,
-	166: 0xd75f00,
-	167: 0xd75f5f,
-	168: 0xd75f87,
-	169: 0xd75faf,
-	170: 0xd75fd7,
-	171: 0xd75fff,
-	172: 0xd78700,
-	173: 0xd7875f,
-	174: 0xd78787,
-	175: 0xd787af,
-	176: 0xd787d7,
-	177: 0xd787ff,
-	178: 0xd7af00,
-	179: 0xd7af5f,
-	180: 0xd7af87,
-	181: 0xd7afaf,
-	182: 0xd7afd7,
-	183: 0xd7afff,
-	184: 0xd7d700,
-	185: 0xd7d75f,
-	186: 0xd7d787,
-	187: 0xd7d7af,
-	188: 0xd7d7d7,
-	189: 0xd7d7ff,
-	190: 0xd7ff00,
-	191: 0xd7ff5f,
-	192: 0xd7ff87,
-	193: 0xd7ffaf,
-	194: 0xd7ffd7,
-	195: 0xd7ffff,
-	196: 0xff0000,
-	197: 0xff005f,
-	198: 0xff0087,
-	199: 0xff00af,
-	200: 0xff00d7,
-	201: 0xff00ff,
-	202: 0xff5f00,
-	203: 0xff5f5f,
-	204: 0xff5f87,
-	205: 0xff5faf,
-	206: 0xff5fd7,
-	207: 0xff5fff,
-	208: 0xff8700,
-	209: 0xff875f,
-	210: 0xff8787,
-	211: 0xff87af,
-	212: 0xff87d7,
-	213: 0xff87ff,
-	214: 0xffaf00,
-	215: 0xffaf5f,
-	216: 0xffaf87,
-	217: 0xffafaf,
-	218: 0xffafd7,
-	219: 0xffafff,
-	220: 0xffd700,
-	221: 0xffd75f,
-	222: 0xffd787,
-	223: 0xffd7af,
-	224: 0xffd7d7,
-	225: 0xffd7ff,
-	226: 0xffff00,
-	227: 0xffff5f,
-	228: 0xffff87,
-	229: 0xffffaf,
-	230: 0xffffd7,
-	231: 0xffffff,
-	232: 0x080808,
-	233: 0x121212,
-	234: 0x1c1c1c,
-	235: 0x262626,
-	236: 0x303030,
-	237: 0x3a3a3a,
-	238: 0x444444,
-	239: 0x4e4e4e,
-	240: 0x585858,
-	241: 0x626262,
-	242: 0x6c6c6c,
-	243: 0x767676,
-	244: 0x808080,
-	245: 0x8a8a8a,
-	246: 0x949494,
-	247: 0x9e9e9e,
-	248: 0xa8a8a8,
-	249: 0xb2b2b2,
-	250: 0xbcbcbc,
-	251: 0xc6c6c6,
-	252: 0xd0d0d0,
-	253: 0xdadada,
-	254: 0xe4e4e4,
-	255: 0xeeeeee,
-}
-
-// `\033]0;TITLESTR\007`
-func doTitleSequence(er *bytes.Reader) error {
-	var c byte
-	var err error
-
-	c, err = er.ReadByte()
-	if err != nil {
-		return err
-	}
-	if c != '0' && c != '2' {
-		return nil
-	}
-	c, err = er.ReadByte()
-	if err != nil {
-		return err
-	}
-	if c != ';' {
-		return nil
-	}
-	title := make([]byte, 0, 80)
-	for {
-		c, err = er.ReadByte()
-		if err != nil {
-			return err
-		}
-		if c == 0x07 || c == '\n' {
-			break
-		}
-		title = append(title, c)
-	}
-	if len(title) > 0 {
-		title8, err := syscall.UTF16PtrFromString(string(title))
-		if err == nil {
-			procSetConsoleTitle.Call(uintptr(unsafe.Pointer(title8)))
-		}
-	}
-	return nil
-}
-
-// Write write data on console
-func (w *Writer) Write(data []byte) (n int, err error) {
-	var csbi consoleScreenBufferInfo
-	procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-
-	er := bytes.NewReader(data)
-	var bw [1]byte
-loop:
-	for {
-		c1, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-		if c1 != 0x1b {
-			bw[0] = c1
-			w.out.Write(bw[:])
-			continue
-		}
-		c2, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-
-		if c2 == ']' {
-			if err := doTitleSequence(er); err != nil {
-				break loop
-			}
-			continue
-		}
-		if c2 != 0x5b {
-			continue
-		}
-
-		var buf bytes.Buffer
-		var m byte
-		for {
-			c, err := er.ReadByte()
-			if err != nil {
-				break loop
-			}
-			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
-				m = c
-				break
-			}
-			buf.Write([]byte(string(c)))
-		}
-
-		switch m {
-		case 'A':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.y -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'B':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.y += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'C':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'D':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'E':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x = 0
-			csbi.cursorPosition.y += short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'F':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x = 0
-			csbi.cursorPosition.y -= short(n)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'G':
-			n, err = strconv.Atoi(buf.String())
-			if err != nil {
-				continue
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			csbi.cursorPosition.x = short(n - 1)
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'H', 'f':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			if buf.Len() > 0 {
-				token := strings.Split(buf.String(), ";")
-				switch len(token) {
-				case 1:
-					n1, err := strconv.Atoi(token[0])
-					if err != nil {
-						continue
-					}
-					csbi.cursorPosition.y = short(n1 - 1)
-				case 2:
-					n1, err := strconv.Atoi(token[0])
-					if err != nil {
-						continue
-					}
-					n2, err := strconv.Atoi(token[1])
-					if err != nil {
-						continue
-					}
-					csbi.cursorPosition.x = short(n2 - 1)
-					csbi.cursorPosition.y = short(n1 - 1)
-				}
-			} else {
-				csbi.cursorPosition.y = 0
-			}
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&csbi.cursorPosition)))
-		case 'J':
-			n := 0
-			if buf.Len() > 0 {
-				n, err = strconv.Atoi(buf.String())
-				if err != nil {
-					continue
-				}
-			}
-			var count, written dword
-			var cursor coord
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			switch n {
-			case 0:
-				cursor = coord{x: csbi.cursorPosition.x, y: csbi.cursorPosition.y}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
-			case 1:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.window.top-csbi.cursorPosition.y)*csbi.size.x)
-			case 2:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top}
-				count = dword(csbi.size.x - csbi.cursorPosition.x + (csbi.size.y-csbi.cursorPosition.y)*csbi.size.x)
-			}
-			procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-			procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-		case 'K':
-			n := 0
-			if buf.Len() > 0 {
-				n, err = strconv.Atoi(buf.String())
-				if err != nil {
-					continue
-				}
-			}
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			var cursor coord
-			var count, written dword
-			switch n {
-			case 0:
-				cursor = coord{x: csbi.cursorPosition.x + 1, y: csbi.cursorPosition.y}
-				count = dword(csbi.size.x - csbi.cursorPosition.x - 1)
-			case 1:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
-				count = dword(csbi.size.x - csbi.cursorPosition.x)
-			case 2:
-				cursor = coord{x: csbi.window.left, y: csbi.window.top + csbi.cursorPosition.y}
-				count = dword(csbi.size.x)
-			}
-			procFillConsoleOutputCharacter.Call(uintptr(w.handle), uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-			procFillConsoleOutputAttribute.Call(uintptr(w.handle), uintptr(csbi.attributes), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&written)))
-		case 'm':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			attr := csbi.attributes
-			cs := buf.String()
-			if cs == "" {
-				procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(w.oldattr))
-				continue
-			}
-			token := strings.Split(cs, ";")
-			for i := 0; i < len(token); i++ {
-				ns := token[i]
-				if n, err = strconv.Atoi(ns); err == nil {
-					switch {
-					case n == 0 || n == 100:
-						attr = w.oldattr
-					case 1 <= n && n <= 5:
-						attr |= foregroundIntensity
-					case n == 7:
-						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
-					case n == 22 || n == 25:
-						attr |= foregroundIntensity
-					case n == 27:
-						attr = ((attr & foregroundMask) << 4) | ((attr & backgroundMask) >> 4)
-					case 30 <= n && n <= 37:
-						attr &= backgroundMask
-						if (n-30)&1 != 0 {
-							attr |= foregroundRed
-						}
-						if (n-30)&2 != 0 {
-							attr |= foregroundGreen
-						}
-						if (n-30)&4 != 0 {
-							attr |= foregroundBlue
-						}
-					case n == 38: // set foreground color.
-						if i < len(token)-2 && (token[i+1] == "5" || token[i+1] == "05") {
-							if n256, err := strconv.Atoi(token[i+2]); err == nil {
-								if n256foreAttr == nil {
-									n256setup()
-								}
-								attr &= backgroundMask
-								attr |= n256foreAttr[n256]
-								i += 2
-							}
-						} else {
-							attr = attr & (w.oldattr & backgroundMask)
-						}
-					case n == 39: // reset foreground color.
-						attr &= backgroundMask
-						attr |= w.oldattr & foregroundMask
-					case 40 <= n && n <= 47:
-						attr &= foregroundMask
-						if (n-40)&1 != 0 {
-							attr |= backgroundRed
-						}
-						if (n-40)&2 != 0 {
-							attr |= backgroundGreen
-						}
-						if (n-40)&4 != 0 {
-							attr |= backgroundBlue
-						}
-					case n == 48: // set background color.
-						if i < len(token)-2 && token[i+1] == "5" {
-							if n256, err := strconv.Atoi(token[i+2]); err == nil {
-								if n256backAttr == nil {
-									n256setup()
-								}
-								attr &= foregroundMask
-								attr |= n256backAttr[n256]
-								i += 2
-							}
-						} else {
-							attr = attr & (w.oldattr & foregroundMask)
-						}
-					case n == 49: // reset foreground color.
-						attr &= foregroundMask
-						attr |= w.oldattr & backgroundMask
-					case 90 <= n && n <= 97:
-						attr = (attr & backgroundMask)
-						attr |= foregroundIntensity
-						if (n-90)&1 != 0 {
-							attr |= foregroundRed
-						}
-						if (n-90)&2 != 0 {
-							attr |= foregroundGreen
-						}
-						if (n-90)&4 != 0 {
-							attr |= foregroundBlue
-						}
-					case 100 <= n && n <= 107:
-						attr = (attr & foregroundMask)
-						attr |= backgroundIntensity
-						if (n-100)&1 != 0 {
-							attr |= backgroundRed
-						}
-						if (n-100)&2 != 0 {
-							attr |= backgroundGreen
-						}
-						if (n-100)&4 != 0 {
-							attr |= backgroundBlue
-						}
-					}
-					procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(attr))
-				}
-			}
-		case 'h':
-			var ci consoleCursorInfo
-			cs := buf.String()
-			if cs == "5>" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 0
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			} else if cs == "?25" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 1
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			}
-		case 'l':
-			var ci consoleCursorInfo
-			cs := buf.String()
-			if cs == "5>" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 1
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			} else if cs == "?25" {
-				procGetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-				ci.visible = 0
-				procSetConsoleCursorInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&ci)))
-			}
-		case 's':
-			procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
-			w.oldpos = csbi.cursorPosition
-		case 'u':
-			procSetConsoleCursorPosition.Call(uintptr(w.handle), *(*uintptr)(unsafe.Pointer(&w.oldpos)))
-		}
-	}
-
-	return len(data), nil
-}
-
-type consoleColor struct {
-	rgb       int
-	red       bool
-	green     bool
-	blue      bool
-	intensity bool
-}
-
-func (c consoleColor) foregroundAttr() (attr word) {
-	if c.red {
-		attr |= foregroundRed
-	}
-	if c.green {
-		attr |= foregroundGreen
-	}
-	if c.blue {
-		attr |= foregroundBlue
-	}
-	if c.intensity {
-		attr |= foregroundIntensity
-	}
-	return
-}
-
-func (c consoleColor) backgroundAttr() (attr word) {
-	if c.red {
-		attr |= backgroundRed
-	}
-	if c.green {
-		attr |= backgroundGreen
-	}
-	if c.blue {
-		attr |= backgroundBlue
-	}
-	if c.intensity {
-		attr |= backgroundIntensity
-	}
-	return
-}
-
-var color16 = []consoleColor{
-	{0x000000, false, false, false, false},
-	{0x000080, false, false, true, false},
-	{0x008000, false, true, false, false},
-	{0x008080, false, true, true, false},
-	{0x800000, true, false, false, false},
-	{0x800080, true, false, true, false},
-	{0x808000, true, true, false, false},
-	{0xc0c0c0, true, true, true, false},
-	{0x808080, false, false, false, true},
-	{0x0000ff, false, false, true, true},
-	{0x00ff00, false, true, false, true},
-	{0x00ffff, false, true, true, true},
-	{0xff0000, true, false, false, true},
-	{0xff00ff, true, false, true, true},
-	{0xffff00, true, true, false, true},
-	{0xffffff, true, true, true, true},
-}
-
-type hsv struct {
-	h, s, v float32
-}
-
-func (a hsv) dist(b hsv) float32 {
-	dh := a.h - b.h
-	switch {
-	case dh > 0.5:
-		dh = 1 - dh
-	case dh < -0.5:
-		dh = -1 - dh
-	}
-	ds := a.s - b.s
-	dv := a.v - b.v
-	return float32(math.Sqrt(float64(dh*dh + ds*ds + dv*dv)))
-}
-
-func toHSV(rgb int) hsv {
-	r, g, b := float32((rgb&0xFF0000)>>16)/256.0,
-		float32((rgb&0x00FF00)>>8)/256.0,
-		float32(rgb&0x0000FF)/256.0
-	min, max := minmax3f(r, g, b)
-	h := max - min
-	if h > 0 {
-		if max == r {
-			h = (g - b) / h
-			if h < 0 {
-				h += 6
-			}
-		} else if max == g {
-			h = 2 + (b-r)/h
-		} else {
-			h = 4 + (r-g)/h
-		}
-	}
-	h /= 6.0
-	s := max - min
-	if max != 0 {
-		s /= max
-	}
-	v := max
-	return hsv{h: h, s: s, v: v}
-}
-
-type hsvTable []hsv
-
-func toHSVTable(rgbTable []consoleColor) hsvTable {
-	t := make(hsvTable, len(rgbTable))
-	for i, c := range rgbTable {
-		t[i] = toHSV(c.rgb)
-	}
-	return t
-}
-
-func (t hsvTable) find(rgb int) consoleColor {
-	hsv := toHSV(rgb)
-	n := 7
-	l := float32(5.0)
-	for i, p := range t {
-		d := hsv.dist(p)
-		if d < l {
-			l, n = d, i
-		}
-	}
-	return color16[n]
-}
-
-func minmax3f(a, b, c float32) (min, max float32) {
-	if a < b {
-		if b < c {
-			return a, c
-		} else if a < c {
-			return a, b
-		} else {
-			return c, b
-		}
-	} else {
-		if a < c {
-			return b, c
-		} else if b < c {
-			return b, a
-		} else {
-			return c, a
-		}
-	}
-}
-
-var n256foreAttr []word
-var n256backAttr []word
-
-func n256setup() {
-	n256foreAttr = make([]word, 256)
-	n256backAttr = make([]word, 256)
-	t := toHSVTable(color16)
-	for i, rgb := range color256 {
-		c := t.find(rgb)
-		n256foreAttr[i] = c.foregroundAttr()
-		n256backAttr[i] = c.backgroundAttr()
-	}
-}

vendor/github.com/mattn/go-colorable/noncolorable.go

@@ -1,55 +0,0 @@
-package colorable
-
-import (
-	"bytes"
-	"io"
-)
-
-// NonColorable hold writer but remove escape sequence.
-type NonColorable struct {
-	out io.Writer
-}
-
-// NewNonColorable return new instance of Writer which remove escape sequence from Writer.
-func NewNonColorable(w io.Writer) io.Writer {
-	return &NonColorable{out: w}
-}
-
-// Write write data on console
-func (w *NonColorable) Write(data []byte) (n int, err error) {
-	er := bytes.NewReader(data)
-	var bw [1]byte
-loop:
-	for {
-		c1, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-		if c1 != 0x1b {
-			bw[0] = c1
-			w.out.Write(bw[:])
-			continue
-		}
-		c2, err := er.ReadByte()
-		if err != nil {
-			break loop
-		}
-		if c2 != 0x5b {
-			continue
-		}
-
-		var buf bytes.Buffer
-		for {
-			c, err := er.ReadByte()
-			if err != nil {
-				break loop
-			}
-			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
-				break
-			}
-			buf.Write([]byte(string(c)))
-		}
-	}
-
-	return len(data), nil
-}

vendor/github.com/mattn/go-isatty/LICENSE

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

vendor/github.com/mattn/go-isatty/doc.go

@@ -1,2 +0,0 @@
-// Package isatty implements interface to isatty
-package isatty

vendor/github.com/mattn/go-isatty/isatty_appengine.go

@@ -1,15 +0,0 @@
-// +build appengine
-
-package isatty
-
-// IsTerminal returns true if the file descriptor is terminal which
-// is always false on on appengine classic which is a sandboxed PaaS.
-func IsTerminal(fd uintptr) bool {
-	return false
-}
-
-// IsCygwinTerminal() return true if the file descriptor is a cygwin or msys2
-// terminal. This is also always false on this environment.
-func IsCygwinTerminal(fd uintptr) bool {
-	return false
-}

vendor/github.com/mattn/go-isatty/isatty_bsd.go

@@ -1,18 +0,0 @@
-// +build darwin freebsd openbsd netbsd dragonfly
-// +build !appengine
-
-package isatty
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-const ioctlReadTermios = syscall.TIOCGETA
-
-// IsTerminal return true if the file descriptor is terminal.
-func IsTerminal(fd uintptr) bool {
-	var termios syscall.Termios
-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
-	return err == 0
-}

vendor/github.com/mattn/go-isatty/isatty_linux.go

@@ -1,18 +0,0 @@
-// +build linux
-// +build !appengine,!ppc64,!ppc64le
-
-package isatty
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-const ioctlReadTermios = syscall.TCGETS
-
-// IsTerminal return true if the file descriptor is terminal.
-func IsTerminal(fd uintptr) bool {
-	var termios syscall.Termios
-	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fd, ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
-	return err == 0
-}