Runs a command in an acme win on file changes

Watch
=====

Usage: ``Watch [-v] [-t]  [-p <path>] [-x <regexp>] <command>``

Watches for changes in a directory tree, and runs a command when
something changed. By default, the output goes to an acme win.

-t sends the output to the terminal instead of acme

-v enables verbose debugging output

-p <path> specifies the path to watch (if it is a directory then it watches recursively)

-x <regexp> specifies a regexp used to exclude files and directories from the watcher.


Watch

This plugin adds [gopls](https://github.com/golang/tools/blob/master/gopls/README.md) features to Vim/Neovim

coc-go language server extension for Vim/Neovim

A wrapper to turn the VSCode go extension into a language server supporting the language-server-protocol.

# A Go Language Server based on the Go Extension for Visual Studio Code

Wraps the VSCode Go extension from Microsoft into a language server, such that
its functionality can be reused with other LSP-aware clients.

In the first iteration we will mock VSCode APIs or simulate their behavior
backed by an LSP. We will maintain this as a fork of the original repository
such that we can easily pick up incoming improvements of that by just rebasing.
Once we got more confidence, we'd probably refactor the VSCode specific parts
away.

[Original README.md](README_old.MD).

## Mismatches and Challenges

- There is no such thing as the `activeTextEditor` in LSP. For services that
  have a `TextDocumentItem`, we set it before calling the service impl, but for
  other services, e.g. `executeCommand` we cannot make sure that they are
  performed on the correct document.
- We have to use/mock/adapt a lot of global variables

## Prerequisites

Make sure the `go` command is available from your path and that the GOPATH
environment variable points to where your go packages are installed.  Some go
packages are necessary:

```shell
go get -u -v github.com/nsf/gocode
go get -u -v github.com/uudashr/gopkgs/cmd/gopkgs
go get -u -v github.com/ramya-rao-a/go-outline
go get -u -v github.com/acroca/go-symbols
go get -u -v golang.org/x/tools/cmd/guru
go get -u -v golang.org/x/tools/cmd/gorename
go get -u -v github.com/fatih/gomodifytags
go get -u -v github.com/haya14busa/goplay/cmd/goplay
go get -u -v github.com/josharian/impl
go get -u -v github.com/tylerb/gotype-live
go get -u -v github.com/rogpeppe/godef
go get -u -v golang.org/x/tools/cmd/godoc
go get -u -v github.com/zmb3/gogetdoc
go get -u -v golang.org/x/tools/cmd/goimports
go get -u -v sourcegraph.com/sqs/goreturns
go get -u -v github.com/golang/lint/golint
go get -u -v github.com/cweill/gotests/...
go get -u -v github.com/alecthomas/gometalinter
go get -u -v honnef.co/go/tools/...
go get -u -v github.com/sourcegraph/go-langserver
go get -u -v github.com/derekparker/delve/cmd/dlv
go get -u -v github.com/davidrjenni/reftools/cmd/fillstruc
```

Note: this list comes from
[here](https://github.com/theia-ide/go-language-server/blob/master/src/goInstallTools.ts#L20-L42).

## Build and usage

1. Run `npm install` to install the package dependencies.
2. Run `npm run compile` to compile the Typescript to Javascript.
3. Run the server with `node ./out/src-vscode-mock/cli.js --stdio`.


go-language-server

A Visual Studio Code extension for showing definition in output and generating go doc

# Visual Studio Code Go Doc

A Visual Studio Code extension for showing definition in Output and generating go doc.

## Configuration

The extension requires `Go` insalled in path. It installs `gogetdoc` in `GOPATH` if gogetdoc is missing.

* [gogetdoc](https://github.com/zmb3/gogetdoc)

### Commands

* Go Doc: Get Definition - Prints the definition in output


Go Doc

Go (Golang) Package For Atom That Adds Autocomplete, Formatting, Syntax Checking, Linting and Vetting.

# [go-plus](https://atom.io/packages/go-plus) [![Build Status](https://travis-ci.org/joefitzgerald/go-plus.svg?branch=master)](https://travis-ci.org/joefitzgerald/go-plus) [![Build status](https://ci.appveyor.com/api/projects/status/d0cekvaprt9wo1et/branch/master?svg=true)](https://ci.appveyor.com/project/joefitzgerald/go-plus/branch/master) [![Slack](https://img.shields.io/badge/atom_slack-%23go--plus-blue.svg?style=flat)](https://atom-slack.herokuapp.com) [![Slack](https://img.shields.io/badge/gophers_slack-%23go--plus-blue.svg?style=flat)](https://gophersinvite.herokuapp.com)

[![Greenkeeper badge](https://badges.greenkeeper.io/joefitzgerald/go-plus.svg)](https://greenkeeper.io/)

> An Improved [Go](https://www.golang.org) Experience For The [Atom Editor](https://atom.io)

![image](https://user-images.githubusercontent.com/7527103/48982584-cd537600-f0a1-11e8-9101-e43dc2064223.png)

- Github: https://github.com/joefitzgerald/go-plus
- Atom: https://atom.io/packages/go-plus

## Overview

This package includes the following functionality:

- Display information about your current go installation, by running `go version` and `go env`
- Autocomplete using `gocode`
- Format your code with `gofmt`, `goimports`, or `goreturns`;
  optionally run one of these tools on save of any `.go` file
- Run `go install .` and `go test -c -o {tempdir} .` to verify your code compiles
  and to keep `gocode` suggestions up to date
- Run a variety of linters (e.g. `golint`, `vet`, etc.) against your code using [`gometalinter`](https://github.com/alecthomas/gometalinter), [`revive`](https://github.com/mgechev/revive) or [`golangci-lint`](https://github.com/golangci/golangci-lint)
- Run tests, display test output, and display test coverage using `go test -coverprofile`
- Display documentation for identifiers in source code using
  [`gogetdoc`](https://github.com/zmb3/gogetdoc)
- Rename the symbol under your cursor using `gorename`
- Go to definition using `guru` or `godef`
- Highlight occurrences of an identifier using `guru`
- Find usages of an identifier using `guru`

You can add debug functionality to Atom by installing the following package:

- [go-debug](https://atom.io/packages/go-debug): Debug your package / tests using [`delve`](https://github.com/derekparker/delve)

## Builds

### How Are The Builds Performed?

The following commands are run for the directory of the current file:

- `go install .` (for normal `.go` files)
- `go test -o {tmpdir} -c .` (for `_test.go` files)

### Why Are You Running `go install` Instead Of `go build`?

`gocode` (and a few other tools, like `gotype`) work on `.a` files (i.e. the package object archive), and the way to keep these up to date is to run `go install` periodically. This ensures your autocomplete suggestions are kept up to date.

## Platforms

The package has CI for OS X, Windows and Ubuntu.

## Installing Missing Tools

If you are missing any required tools, you may be prompted to install them. You can also manually install the required tools in your terminal:

```
go get -u golang.org/x/tools/cmd/goimports
go get -u golang.org/x/tools/cmd/gorename
go get -u github.com/sqs/goreturns
go get -u github.com/mdempsky/gocode
go get -u github.com/alecthomas/gometalinter
go get -u github.com/mgechev/revive
go get -u github.com/golangci/golangci-lint/cmd/golangci-lint
go get -u github.com/zmb3/gogetdoc
go get -u github.com/zmb3/goaddimport
go get -u github.com/rogpeppe/godef
go get -u golang.org/x/tools/cmd/guru
go get -u github.com/fatih/gomodifytags
go get -u github.com/tpng/gopkgs
go get -u github.com/ramya-rao-a/go-outline
```

## Having Issues?

Please consult the [FAQ](https://github.com/joefitzgerald/go-plus/wiki/FAQ) prior to [opening an issue](https://github.com/joefitzgerald/go-plus/issues/new): https://github.com/joefitzgerald/go-plus/wiki/FAQ

If you have an issue with debugging, file an issue with [`go-debug`](https://github.com/lloiser/go-debug) [here](https://github.com/lloiser/go-debug/issues/new).

## Maintainers

- Joe Fitzgerald ([@joefitzgerald](https://github.com/joefitzgerald))
- Zac Bergquist ([@zmb3](https://github.com/zmb3))
- Lukas Beranek ([@lloiser](https://github.com/lloiser))

## Contributors

A list of contributors can be found at https://github.com/joefitzgerald/go-plus/graphs/contributors. Thank you so much to everyone has contributed to the package :heart:. You are awesome!

## Contributing

Contributions are greatly appreciated. Please fork this repository, make your
changes, and open a pull request. See [Contributing](https://github.com/joefitzgerald/go-plus/wiki/Contributing) for detailed instructions.


go-plus

This is go-mode, the Emacs mode for editing Go code.

It is a complete rewrite of the go-mode that shipped with Go 1.0.3 and
before, and was part of Go 1.1 until Go 1.3. Beginning with Go 1.4,
editor integration will not be part of the Go distribution anymore,
making this repository the canonical place for go-mode.


# Features

In addition to normal features, such as fontification and indentation,
and close integration with familiar Emacs functionality (for example
syntax-based navigation like `beginning-of-defun`), go-mode comes with
the following extra features to provide an improved experience:

- Integration with `gofmt` by providing a command of the same name,
  and `gofmt-before-save`, which can be used in a hook to format Go
  buffers before saving them.
  - Setting the `gofmt-command` variable also allows using
    `goimports`.
  - Setting the `gofmt-args` variable with a list of arguments allows
    using e.g. `gofmt -s`.
- Integration with `godoc` via the functions `godoc` and
  `godoc-at-point`.
- Integration with the Playground
  - `go-play-buffer` and `go-play-region` to send code to the
    Playground
  - `go-download-play` to download a Playground entry into a new
    buffer
- Managing imports
  - A function for jumping to the file's imports (`go-goto-imports` -
    `C-c C-f i`)
  - A function for adding imports, including tab completion
    (`go-import-add`, bound to `C-c C-a`)
  - It is recommended that you use `goimports` or the
    `organize-imports` feature of `gopls` to manage
    adding/removing/organizing imports automatically.
- Integration with godef
  - `godef-describe` (`C-c C-d`) to describe expressions
  - `godef-jump` (`C-c C-j`) and `godef-jump-other-window` (`C-x 4 C-c
    C-j`) to jump to declarations
  - This requires you to install godef via `go install
  github.com/rogpeppe/godef@latest`.
- Basic support for imenu (functions and variables)
- Built-in support for displaying code coverage as calculated by `go
  test` (`go-coverage`)
- Several functions for jumping to and manipulating the individual
  parts of function signatures. These functions support anonymous
  functions, but are smart enough to skip them when required (e.g.
  when jumping to a method receiver or docstring.)
  - Jump to the argument list (`go-goto-arguments` - `C-c C-f a`)
  - Jump to the docstring, create it if it does not exist yet
    (`go-goto-docstring` - `C-c C-f d`).
  - Jump to the function keyword (`go-goto-function` - `C-c C-f f`)
  - Jump to the function name (`go-goto-function-name` - `C-c C-f n`)
  - Jump to the return values (`go-goto-return-values` - `C-c C-f r`)
  - Jump to the method receiver, adding a pair of parentheses if no
    method receiver exists (`go-goto-method-receiver` - `C-c C-f m`).

  All of these functions accept a prefix argument (`C-u`), causing
  them to skip anonymous functions.

# Installation

## MELPA

The recommended way of installing go-mode is via
[ELPA](http://www.emacswiki.org/emacs/ELPA), the Emacs package
manager, and the
[MELPA Stable repository](http://emacsredux.com/blog/2014/05/16/melpa-stable/), which provides
an up-to-date version of go-mode.

If you're not familiar with ELPA yet, consider reading
[this guide](http://xahlee.info/emacs/emacs/emacs_package_system.html).

## Manual



To install go-mode manually, check out the `go-mode.el` repository in
a directory of your choice, add it to your load path and configure
Emacs to automatically load it when opening a `.go` file:

    (add-to-list 'load-path "/place/where/you/put/it/")
    (autoload 'go-mode "go-mode" nil t)
    (add-to-list 'auto-mode-alist '("\\.go\\'" . go-mode))

Either evaluate the statements with `C-x C-e`, or restart Emacs.

# Other extensions

There are several third party extensions that can enhance the Go
experience in Emacs.

## Gopls integration

[Gopls](https://github.com/golang/tools/blob/master/gopls/README.md)
is the official language server protocol (lsp) implementation provided
by the Go team. It is intended to replace the existing third party
tools for code formatting (gofmt), automatic imports (goimports), code
navigation (godef/guru), type and function descriptions (godoc/godef),
error checking, auto completion (gocode), variable and type renaming
(rename), and more. Once gopls is stable the older tools will no
longer be supported.

Gopls is a supported backend for
[lsp-mode](https://github.com/emacs-lsp/lsp-mode). It will be used
automatically by lsp-mode if `gopls` is found in your PATH. You can
install gopls via: `go install golang.org/x/tools/gopls@latest`. To enable
lsp-mode for go buffers:

    (add-hook 'go-mode-hook 'lsp-deferred)


## Syntax/error checking

There are two ways of using flymake with Go:

1. [goflymake](https://github.com/dougm/goflymake), which internally
uses `go build` to capture all errors that a regular compilation would
also produce
2. [flymake-go](http://marmalade-repo.org/packages/flymake-go) for a
more lightweight solution that only uses `gofmt` and as such is only
able to catch syntax errors. Unlike goflymake, however, it does not
require an additional executable.

Additionally, there is
[flycheck](https://github.com/flycheck/flycheck), a modern replacement
for flymake, which comes with built-in support for Go. In addition to
using `go build` or `gofmt`, it also has support for `go vet`,
`golint` and `errcheck`.

## Auto completion

For auto completion, take a look at
[gocode](https://github.com/nsf/gocode).

## eldoc

https://github.com/syohex/emacs-go-eldoc provides eldoc functionality
for go-mode.

## Snippets

I maintain a set of YASnippet snippets for go-mode at
https://github.com/dominikh/yasnippet-go

## Integration with errcheck

https://github.com/dominikh/go-errcheck.el provides integration with
[errcheck](https://github.com/kisielk/errcheck).

# Stability

go-mode.el has regular, tagged releases and is part of the MELPA
Stable repository. These tagged releases are intended to provide a
stable experience. APIs added in tagged releases will usually not be
removed or changed in future releases.

Changes made on the master branch, which is tracked by the normal
MELPA repository, however, are under active development. New APIs are
experimental and may be changed or removed before the next release.
Furthermore, there is a higher chance for bugs.

If you want a stable experience, use MELPA Stable. If you want cutting
edge features, or "beta-test" future releases, use MELPA or the master
branch.


go-mode

Autocompletion daemon for the Go programming language

## An autocompletion daemon for the Go programming language

**IMPORTANT: This project is not maintained anymore, consider using https://pkg.go.dev/golang.org/x/tools/gopls, a tool which provides similar functionality and more, created and maintained by Go team.**

Gocode is a helper tool which is intended to be integrated with your source code editor, like vim, neovim and emacs. It provides several advanced capabilities, which currently includes:

 - Context-sensitive autocompletion

It is called *daemon*, because it uses client/server architecture for caching purposes. In particular, it makes autocompletions very fast. Typical autocompletion time with warm cache is 30ms, which is barely noticeable.

Also watch the [demo screencast](https://nsf.github.io/images/gocode-demo.swf).

![Gocode in vim](https://nsf.github.io/images/gocode-screenshot.png)

![Gocode in emacs](https://nsf.github.io/images/emacs-gocode.png)

### Setup

 1. You should have a correctly installed Go compiler environment and your personal workspace ($GOPATH). If you have no idea what **$GOPATH** is, take a look [here](http://golang.org/doc/code.html). Please make sure that your **$GOPATH/bin** is available in your **$PATH**. This is important, because most editors assume that **gocode** binary is available in one of the directories, specified by your **$PATH** environment variable. Otherwise manually copy the **gocode** binary from **$GOPATH/bin** to a location which is part of your **$PATH** after getting it in step 2.

    Do these steps only if you understand why you need to do them:

    `export GOPATH=$HOME/goprojects`

    `export PATH=$PATH:$GOPATH/bin`

 2. Then you need to get the appropriate version of the gocode, for 6g/8g/5g compiler you can do this:

    `go get -u github.com/nsf/gocode` (-u flag for "update")

    Windows users should consider doing this instead:

    `go get -u -ldflags -H=windowsgui github.com/nsf/gocode`

    That way on the Windows OS gocode will be built as a GUI application and doing so solves hanging window issues with some of the editors.

 3. Next steps are editor specific. See below.

### Vim setup

#### Vim manual installation

Note: As of go 1.5 there is no $GOROOT/misc/vim script. Suggested installation is via [vim-go plugin](https://github.com/fatih/vim-go).

In order to install vim scripts, you need to fulfill the following steps:

 1. Install official Go vim scripts from **$GOROOT/misc/vim**. If you did that already, proceed to the step 2.

 2. Install gocode vim scripts. Usually it's enough to do the following:

    2.1. `vim/update.sh`

    **update.sh** script does the following:

		#!/bin/sh
		mkdir -p "$HOME/.vim/autoload"
		mkdir -p "$HOME/.vim/ftplugin/go"
		cp "${0%/*}/autoload/gocomplete.vim" "$HOME/.vim/autoload"
		cp "${0%/*}/ftplugin/go/gocomplete.vim" "$HOME/.vim/ftplugin/go"

    2.2. Alternatively, you can create symlinks using symlink.sh script in order to avoid running update.sh after every gocode update.

    **symlink.sh** script does the following:

		#!/bin/sh
		cd "${0%/*}"
		ROOTDIR=`pwd`
		mkdir -p "$HOME/.vim/autoload"
		mkdir -p "$HOME/.vim/ftplugin/go"
		ln -s "$ROOTDIR/autoload/gocomplete.vim" "$HOME/.vim/autoload/"
		ln -s "$ROOTDIR/ftplugin/go/gocomplete.vim" "$HOME/.vim/ftplugin/go/"

 3. Make sure vim has filetype plugin enabled. Simply add that to your **.vimrc**:

    `filetype plugin on`

 4. Autocompletion should work now. Use `<C-x><C-o>` for autocompletion (omnifunc autocompletion).

#### Using Vundle in Vim

Add the following line to your **.vimrc**:

`Plugin 'nsf/gocode', {'rtp': 'vim/'}`

And then update your packages by running `:PluginInstall`.

#### Using vim-plug in Vim

Add the following line to your **.vimrc**:

`Plug 'nsf/gocode', { 'rtp': 'vim', 'do': '~/.vim/plugged/gocode/vim/symlink.sh' }`

And then update your packages by running `:PlugInstall`.

#### Other

Alternatively take a look at the vundle/pathogen friendly repo: https://github.com/Blackrush/vim-gocode.

### Neovim setup
#### Neovim manual installation

 Neovim users should also follow `Vim manual installation`, except that you should goto `gocode/nvim` in step 2, and remember that, the Neovim configuration file is `~/.config/nvim/init.vim`.

#### Using Vundle in Neovim

Add the following line to your **init.vim**:

`Plugin 'nsf/gocode', {'rtp': 'nvim/'}`

And then update your packages by running `:PluginInstall`.

#### Using vim-plug in Neovim

Add the following line to your **init.vim**:

`Plug 'nsf/gocode', { 'rtp': 'nvim', 'do': '~/.config/nvim/plugged/gocode/nvim/symlink.sh' }`

And then update your packages by running `:PlugInstall`.

### Emacs setup

In order to install emacs script, you need to fulfill the following steps:

 1. Install [auto-complete-mode](http://www.emacswiki.org/emacs/AutoComplete)

 2. Copy **emacs/go-autocomplete.el** file from the gocode source distribution to a directory which is in your 'load-path' in emacs.

 3. Add these lines to your **.emacs**:

 		(require 'go-autocomplete)
		(require 'auto-complete-config)
		(ac-config-default)

Also, there is an alternative plugin for emacs using company-mode. See `emacs-company/README` for installation instructions.

If you're a MacOSX user, you may find that script useful: https://github.com/purcell/exec-path-from-shell. It helps you with setting up the right environment variables as Go and gocode require it. By default it pulls the PATH, but don't forget to add the GOPATH as well, e.g.:

```
(when (memq window-system '(mac ns))
  (exec-path-from-shell-initialize)
  (exec-path-from-shell-copy-env "GOPATH"))
```

### Options

You can change all available options using `gocode set` command. The config file uses json format and is usually stored somewhere in **~/.config/gocode** directory. On windows it's stored in the appropriate AppData folder. It's suggested to avoid modifying config file manually, do that using the `gocode set` command.

`gocode set` lists all options and their values.

`gocode set <option>` shows the value of that *option*.

`gocode set <option> <value>` sets the new *value* for that *option*.

 - *propose-builtins*

   A boolean option. If **true**, gocode will add built-in types, functions and constants to autocompletion proposals. Default: **false**.

 - *lib-path*

   A string option. Allows you to add search paths for packages. By default, gocode only searches **$GOPATH/pkg/$GOOS_$GOARCH** and **$GOROOT/pkg/$GOOS_$GOARCH** in terms of previously existed environment variables. Also you can specify multiple paths using ':' (colon) as a separator (on Windows use semicolon ';'). The paths specified by *lib-path* are prepended to the default ones.

 - *autobuild*

   A boolean option. If **true**, gocode will try to automatically build out-of-date packages when their source files are modified, in order to obtain the freshest autocomplete results for them. This feature is experimental. Default: **false**.

 - *force-debug-output*

   A string option. If is not empty, gocode will forcefully redirect the logging into that file. Also forces enabling of the debug mode on the server side. Default: "" (empty).

 - *package-lookup-mode*

   A string option. If **go**, use standard Go package lookup rules. If **gb**, use gb-specific lookup rules. See https://github.com/constabulary/gb for details. Default: **go**.

 - *close-timeout*

   An integer option. If there have been no completion requests after this number of seconds, the gocode process will terminate. Defaults to 1800 (30 minutes).

 - *unimported-packages*

   A boolean option. If set to true, gocode will try to import certain known packages automatically for identifiers which cannot be resolved otherwise. Currently only a limited set of standard library packages are supported. Default: **false**.

 - *partials*

   A boolean option. If set to false, gocode will not filter autocompletion results based on entered prefix before the cursor. Instead it will return all available autocompletion results viable for a given context. Whether this option is set to true or false, gocode will return a valid prefix length for output formats which support it. Setting this option to a non-default value may result in editor misbehaviour. Default: **true**.

 - *ignore-case*

   A boolean option. If set to true, gocode will perform case-insensitive matching when doing prefix-based filtering. Default: **false**.

 - *class-filtering*

   A boolean option. Enables or disables gocode's feature where it performs class-based filtering if partial input matches corresponding class keyword: const, var, type, func, package. Default: **true**.

### Debugging

If something went wrong, the first thing you may want to do is manually start the gocode daemon with a debug mode enabled and in a separate terminal window. It will show you all the stack traces, panics if any and additional info about autocompletion requests. Shutdown the daemon if it was already started and run a new one explicitly with a debug mode enabled:

`gocode close`

`gocode -s -debug`

Please, report bugs, feature suggestions and other rants to the [github issue tracker](http://github.com/nsf/gocode/issues) of this project.

### Developing

There is [Guide for IDE/editor plugin developers](docs/IDE_integration.md).

If you have troubles, please, contact me and I will try to do my best answering your questions. You can contact me via <a href="mailto:no.smile.face@gmail.com">email</a>. Or for short question find me on IRC: #go-nuts @ freenode.

### Misc

 - It's a good idea to use the latest git version always. I'm trying to keep it in a working state.
 - Use `go install` (not `go build`) for building a local source tree. The objects in `pkg/` are needed for Gocode to work.


gocode

<br/>
<div align="center">
  <a href="https://vshymanskyy.github.io/StandWithUkraine">
    <img src="images/dove.png" class="this" alt="Stand With Ukraine" style="width: 60%;">
  </a>
  <h3 align="center"><a href="https://vshymanskyy.github.io/StandWithUkraine">🇺🇦 #StandWithUkraine 🇺🇦</a></h3>
</div>

---

# goimports-reviser [![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social)](https://twitter.com/intent/tweet?text=Right%20golang%20imports%20sorting%20and%20code%20formatting%20tool%20(goimports%20alternative)&url=https://github.com/incu6us/goimports-reviser&hashtags=golang,code,goimports-reviser,goimports,gofmt,developers)
[![#StandWithUkraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/badges/StandWithUkraine.svg)](https://vshymanskyy.github.io/StandWithUkraine)
!['Status Badge'](https://github.com/incu6us/goimports-reviser/workflows/build/badge.svg)
!['Release Badge'](https://github.com/incu6us/goimports-reviser/workflows/release/badge.svg)
!['Quality Badge'](https://goreportcard.com/badge/github.com/incu6us/goimports-reviser)
[![codecov](https://codecov.io/gh/incu6us/goimports-reviser/branch/master/graph/badge.svg)](https://codecov.io/gh/incu6us/goimports-reviser)
![GitHub All Releases](https://img.shields.io/github/downloads/incu6us/goimports-reviser/total?color=green)
![GitHub release (latest by date)](https://img.shields.io/github/v/release/incu6us/goimports-reviser?color=green)
[![goimports-reviser](https://snapcraft.io//goimports-reviser/badge.svg)](https://snapcraft.io/goimports-reviser)
![license](https://img.shields.io/github/license/incu6us/goimports-reviser)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go) 

<a href="https://www.buymeacoffee.com/slavka" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 60px !important;width: 217px !important;"></a>

!['logo'](./images/reviser-muscot_200.png)


Tool for Golang to sort goimports by 3-4 groups(with own [linter](linter/README.md)): std, general, company(which is optional) and project dependencies.
Also, formatting for your code will be prepared(so, you don't need to use `gofmt` or `goimports` separately). 
Use additional options `-rm-unused` to remove unused imports and `-set-alias` to rewrite import aliases for versioned packages or for packages with additional prefix/suffix(example: `opentracing "github.com/opentracing/opentracing-go"`).
`-company-prefixes` - will create group for company imports(libs inside your organization). Values should be comma-separated.


## Configuration:
### Cmd
```bash
goimports-reviser -rm-unused -set-alias -format ./reviser/reviser.go
```

You can also apply rules to a dir or recursively apply using ./... as a target:
```bash
goimports-reviser -rm-unused -set-alias -format -recursive reviser
```

```bash
goimports-reviser -rm-unused -set-alias -format ./...
```

You can also apply rules to multiple targets:
```bash
goimports-reviser -rm-unused -set-alias -format ./reviser/reviser.go ./pkg/...
```

### Example, to configure it with JetBrains IDEs (via file watcher plugin):
![example](./images/image.png)


### Options:
```text
Usage of goimports-reviser:
  -apply-to-generated-files
    	Apply imports sorting and formatting(if the option is set) to generated files. Generated file is a file with first comment which starts with comment '// Code generated'. Optional parameter.
  -company-prefixes string
    	Company package prefixes which will be placed after 3rd-party group by default(if defined). Values should be comma-separated. Optional parameters.
  -excludes string
    	Exclude files or dirs, example: '.git/,proto/*.go'.
  -file-path string
    	Deprecated. Put file name as an argument(last item) of command line.
  -format
    	Option will perform additional formatting. Optional parameter.
  -imports-order string
    	Your imports groups can be sorted in your way.
    	std - std import group;
    	general - libs for general purpose;
    	company - inter-org or your company libs(if you set '-company-prefixes'-option, then 4th group will be split separately. In other case, it will be the part of general purpose libs);
    	project - your local project dependencies;
    	blanked - imports with "_" alias;
    	dotted - imports with "." alias.
    	Optional parameter. (default "std,general,company,project")
  -list-diff
    	Option will list files whose formatting differs from goimports-reviser. Optional parameter.
  -local string
    	Deprecated
  -output string
    	Can be "file", "write" or "stdout". Whether to write the formatted content back to the file or to stdout. When "write" together with "-list-diff" will list the file name and write back to the file. Optional parameter. (default "file")
  -project-name string
    	Your project name(ex.: github.com/incu6us/goimports-reviser). Optional parameter.
  -recursive
    	Apply rules recursively if target is a directory. In case of ./... execution will be recursively applied by default. Optional parameter.
  -rm-unused
    	Remove unused imports. Optional parameter.
  -separate-named
        Separate named imports from their group with a new line. Optional parameter.
  -set-alias
    	Set alias for versioned package names, like 'github.com/go-pg/pg/v9'. In this case import will be set as 'pg "github.com/go-pg/pg/v9"'. Optional parameter.
  -set-exit-status
    	set the exit status to 1 if a change is needed/made. Optional parameter.
  -use-cache
    	Use cache to improve performance. Optional parameter.
  -version
    	Show version.
```

## Install
### With Go
```bash
go install -v github.com/incu6us/goimports-reviser/v3@latest
```

### With Brew
```bash
brew tap incu6us/homebrew-tap
brew install incu6us/homebrew-tap/goimports-reviser
```

### With Snap
```bash
snap install goimports-reviser
```

## Examples
Before usage:
```go
package testdata

import (
	"log"

	"github.com/incu6us/goimports-reviser/testdata/innderpkg"

	"bytes"

	"golang.org/x/exp/slices"
)
``` 

After usage:
```go
package testdata

import (
	"bytes"
	"log"

	"golang.org/x/exp/slices"

	"github.com/incu6us/goimports-reviser/testdata/innderpkg"
)
```

Comments(not Docs) for imports is acceptable. Example:
```go
package testdata

import (
    "fmt" // comments to the package here
)
```  

### Example with `-company-prefixes`-option

Before usage:

```go
package testdata // goimports-reviser/testdata

import (
	"fmt" //fmt package
	"golang.org/x/exp/slices" //custom package
	"github.com/incu6us/goimports-reviser/pkg" // this is a company package which is not a part of the project, but is a part of your organization
	"goimports-reviser/pkg"
)
```

After usage:
```go
package testdata // goimports-reviser/testdata

import (
	"fmt" // fmt package

	"golang.org/x/exp/slices" // custom package

	"github.com/incu6us/goimports-reviser/pkg" // this is a company package which is not a part of the project, but is a part of your organization

	"goimports-reviser/pkg"
)
```

### Example with `-imports-order std,general,company,project,blanked,dotted`-option

Before usage:

```go
package testdata // goimports-reviser/testdata

import (
	_ "github.com/pkg1"
	. "github.com/pkg2"
	"fmt" //fmt package
	"golang.org/x/exp/slices" //custom package
	"github.com/incu6us/goimports-reviser/pkg" // this is a company package which is not a part of the project, but is a part of your organization
	"goimports-reviser/pkg"
)
```

After usage:
```go
package testdata // goimports-reviser/testdata

import (
	"fmt" // fmt package

	"golang.org/x/exp/slices" // custom package

	"github.com/incu6us/goimports-reviser/pkg" // this is a company package which is not a part of the project, but is a part of your organization

	"goimports-reviser/pkg"

	_ "github.com/pkg1"

	. "github.com/pkg2"
)
```

### Example with `-format`-option

Before usage:
```go
package main
func test(){
}
func additionalTest(){
}
```

After usage:
```go
package main

func test(){
}

func additionalTest(){
}
```

### Example with `-separate-named`-option

Before usage:

```go
package testdata // goimports-reviser/testdata

import (
	"fmt"
	"github.com/incu6us/goimports-reviser/pkg"
	extpkg "google.com/golang/pkg"
	"golang.org/x/exp/slices"
	extslice "github.com/PeterRK/slices"
)
```

After usage:
```go
package testdata // goimports-reviser/testdata

import (
	"fmt"

	"github.com/incu6us/goimports-reviser/pkg"
	"golang.org/x/exp/slices"

	extpkg "google.com/golang/pkg"
	extslice "github.com/PeterRK/slices"
)
```
---
## Contributors

A big thank you to all the amazing people who contributed!

<a href="https://github.com/incu6us/goimports-reviser/graphs/contributors">
  <img src="https://contrib.rocks/image?repo=incu6us/goimports-reviser" />
</a>

## Give a Star! ⭐
If you like or are using this project, please give it a **star**.


### Stargazers

[![Stargazers over time](https://starchart.cc/incu6us/goimports-reviser.svg)](https://starchart.cc/incu6us/goimports-reviser)



goimports-reviser

# vim-go [![GitHub Actions Status](https://github.com/fatih/vim-go/workflows/test/badge.svg)](https://github.com/fatih/vim-go/actions)



<p align="center">
  <img style="float: right;" src="assets/vim-go.png" alt="Vim-go logo"/>
</p>

## Features

This plugin adds Go language support for Vim, with the following main features:

* Compile your package with `:GoBuild`, install it with `:GoInstall` or test it
  with `:GoTest`. Run a single test with `:GoTestFunc`).
* Quickly execute your current file(s) with `:GoRun`.
* Improved syntax highlighting and folding.
* Debug programs with integrated [`delve`](https://github.com/go-delve/delve) support with `:GoDebugStart`.
* Completion and many other features support via `gopls`.
* formatting on save keeps the cursor position and undo history.
* Go to symbol/declaration with `:GoDef`.
* Look up documentation with `:GoDoc` or `:GoDocBrowser`.
* Easily import packages via `:GoImport`, remove them via `:GoDrop`.
* Precise type-safe renaming of identifiers with `:GoRename`.
* See which code is covered by tests with `:GoCoverage`.
* Add or remove tags on struct fields with `:GoAddTags` and `:GoRemoveTags`.
* Lint your code with `:GoLint` or `:GoMetaLinter`, run your code through `:GoVet` to catch static errors, or make sure errors are checked with `:GoErrCheck`.
* Advanced source analysis utilizing `gopls`, such as `:GoImplements`, `:GoCallees`, and `:GoReferrers`.
* ... and many more! Please see [doc/vim-go.txt](doc/vim-go.txt) for more information.
* Integration with [`gopls`](https://github.com/golang/tools/blob/master/gopls/README.md).
* The `gopls` instance can be shared with other Vim plugins.
* Vim-go's use of `gopls` can be disabled and alternative tools can be used when desired.
* Integration with [`Tagbar`](https://github.com/preservim/tagbar) via [`gotags`](https://github.com/jstemmer/gotags).
* Integration with [`Ultisnips`](https://github.com/SirVer/ultisnips) and other snippet engines.

## Install

vim-go requires at least Vim 8.2.5072 or Neovim 0.4.0.

The [**latest stable release**](https://github.com/fatih/vim-go/releases/latest) is the
recommended version to use. If you choose to use the master branch instead,
please do so with caution; it is a _development_ branch.


vim-go follows the standard runtime path structure. Below are some helper lines
for popular package managers:

* [Vim 8 packages](http://vimhelp.appspot.com/repeat.txt.html#packages)
  * `git clone https://github.com/fatih/vim-go.git ~/.vim/pack/plugins/start/vim-go`
* [Neovim packages](https://neovim.io/doc/user/repeat.html#packages)
  * `git clone https://github.com/fatih/vim-go.git ~/.local/share/nvim/site/pack/plugins/start/vim-go`
* [Pathogen](https://github.com/tpope/vim-pathogen)
  * `git clone https://github.com/fatih/vim-go.git ~/.vim/bundle/vim-go`
* [vim-plug](https://github.com/junegunn/vim-plug)
  * `Plug 'fatih/vim-go', { 'do': ':GoUpdateBinaries' }`
* [Vundle](https://github.com/VundleVim/Vundle.vim)
  * `Plugin 'fatih/vim-go'`

You will also need to install all the necessary binaries. vim-go makes it easy
to install all of them by providing a command, `:GoInstallBinaries`, which will
`go install` all the required binaries.

Check out the Install section in [the documentation](doc/vim-go.txt) for more
detailed instructions (`:help go-install`).

## Usage

The full documentation can be found at [doc/vim-go.txt](doc/vim-go.txt). You can
display it from within Vim with `:help vim-go`.

Depending on your installation method, you may have to generate the plugin's
[`help tags`](http://vimhelp.appspot.com/helphelp.txt.html#%3Ahelptags)
manually (e.g. `:helptags ALL`).

We also have a [tutorial](https://github.com/fatih/vim-go/wiki/Tutorial) in the [official vim-go wiki](https://github.com/fatih/vim-go/wiki).

## FAQ and troubleshooting

The FAQ and troubleshooting tips are in the documentation and can be quickly
accessed using `:help go-troubleshooting`. If you believe you've found a bug or
shortcoming in vim-go that is neither addressed by help nor in [existing
issues](https://github.com/fatih/vim-go/issues), please open an issue with
clear reproduction steps. `:GoReportGitHubIssue` can be used pre-populate a lot
of the information needed when creating a new issue.

## Contributing

All PRs are welcome. If you are planning to contribute a large patch or to
integrate a new tool, please create an issue first to get any upfront questions
or design decisions out of the way first.

You can run the tests locally by running `make`. It will lint the VimL for you,
lint the documentation, and run the tests against the minimum required version
of Vim, other versions of Vim that may be critical to support, and Neovim.

## License

The BSD 3-Clause License - see [`LICENSE`](LICENSE) for more details



vim-go

Extension for Visual Studio Code (VS Code) which provides support for the Go language

# Go for Visual Studio Code

[![Slack](https://img.shields.io/badge/slack-gophers-green.svg?style=flat)](https://gophers.slack.com/messages/vscode/)



[The VS Code Go extension](https://marketplace.visualstudio.com/items?itemName=golang.go)
provides rich language support for the
[Go programming language](https://go.dev/).

## Requirements

* Visual Studio Code 1.90 or newer (or editors compatible with VS Code 1.90+ APIs)
* Go 1.21 or newer.

## Quick Start

Welcome! 👋🏻<br/>
Whether you are new to Go or an experienced Go developer, we hope this
extension fits your needs and enhances your development experience.

1.  Install [Go](https://go.dev) 1.21 or newer if you haven't already.

1.  Install the [VS Code Go extension].

1.  Open any Go file or go.mod file to automatically activate the extension. The
    [Go status bar](https://github.com/golang/vscode-go/wiki/ui) appears in the
    bottom right corner of the window and displays your Go version.

1.  The extension depends on `go`, `gopls` (the Go language server), and optional
    tools depending on your settings. If `gopls` is missing, the extension will
    try to install it. The :zap: sign next to the Go version indicates
    the language server is running, and you are ready to go.

<p align="center">
<img src="docs/images/gettingstarted.gif" width=75%>
<br/>
<em>(Install Missing Tools)</em>
</p>

You are ready to Go :-) &nbsp;&nbsp; 🎉🎉🎉

## What's next

* Explore more [features][full feature breakdown] of the VS Code Go extension.
* View the
  [settings documentation](https://github.com/golang/vscode-go/wiki/settings)
	and [advanced topics](https://github.com/golang/vscode-go/wiki/advanced) to
	customize the extension.
* View the [tools documentation](https://github.com/golang/vscode-go/wiki/tools)
  for a complete list of tools the VS Code Go extension depends on. You can
  install additional tools and update them by using "Go: Install/Update Tools".
* Solve issues with the
  [general troubleshooting](https://github.com/golang/vscode-go/wiki/troubleshooting)
	and [debugging troubleshooting](https://github.com/golang/vscode-go/wiki/debugging#troubleshooting)
	guides.
* [file an issue](https://github.com/golang/vscode-go/issues/new/choose) for
  problems with the extension.
* Start a [GitHub discussion](https://github.com/golang/vscode-go/discussions)
  or get help on [Stack Overflow].
* Explore Go language resources on [go.dev/learn](https://go.dev/learn) and
  [golang.org/help](https://golang.org/help).

If you are new to Go, [this article](https://golang.org/doc/code.html) provides
the overview on Go code organization and basic `go` commands. Watch ["Getting
started with VS Code Go"] for an explanation of how to build your first Go
application using VS Code Go.

## Feature highlights

* [IntelliSense] - Results appear for symbols as you type.
* [Code navigation] - Jump to or peek at a symbol's declaration.
* [Code editing] - Support for saved snippets, formatting and code organization,
  and automatic organization of imports.
* [Diagnostics] -  Build, vet, and lint errors shown as you type or on save.
* Enhanced support for [testing] and [debugging]

See the [full feature breakdown] for more details.

<p align=center>
<img src="docs/images/completion-signature-help.gif" width=75%>
<br/>
<em>(Code completion and Signature Help)</em>
</p>

In addition to integrated editing features, the extension provides several
commands for working with Go files. You can access any of these by opening the
Command Palette (`Ctrl+Shift+P` on Linux/Windows and `Cmd+Shift+P` on Mac), and
then typing in the command name. See the
[full list of commands](https://github.com/golang/vscode-go/wiki/commands#detailed-list) provided by this
extension.

<p align=center>
<img src="docs/images/toggletestfile.gif" width=75%>
<br/><em>(Toggle Test File)</em></p>

**⚠️ Note**: the default syntax highlighting for Go files is provided by a
[TextMate rule](https://github.com/worlpaker/go-syntax) embedded in VS
Code, not by this extension.

For better syntax highlighting, we recommend enabling
[semantic highlighting](https://code.visualstudio.com/api/language-extensions/semantic-highlight-guide)
by turning on [Gopls' `ui.semanticTokens` setting](https://github.com/golang/vscode-go/wiki/settings#uisemantictokens).
    ```
    "gopls": { "ui.semanticTokens": true }
    ```

## Setting up your workspace

The VS Code Go extension supports both `GOPATH` and Go modules modes.

[Go modules](https://golang.org/ref/mod) are used to manage dependencies in
recent versions of Go. Modules replace the `GOPATH`-based approach to specifying
which source files are used in a given build, and they are the default build
mode in go1.16+. We highly recommend Go development in module mode. If you are
working on existing projects, please consider migrating to modules.

Unlike the traditional `GOPATH` mode, module mode does not require the workspace
to be located under `GOPATH` nor to use a specific structure. A module is
defined by a directory tree of Go source files with a `go.mod` file in the
tree's root directory.

Your project may involve one or more modules. If you are working with multiple
modules or uncommon project layouts, you will need to configure your workspace
by using [Workspace Folders]. See the
[Supported workspace layouts documentation] for more information.

## Pre-release version

If you'd like to get early access to new features and bug fixes, you can use the
pre-release extension. Following the vscode's [convention](https://code.visualstudio.com/api/working-with-extensions/publishing-extension#prerelease-extensions),
we use the minor version of the extension version number to distinguish stable
and pre-release versions (`0.ODD_NUMBER.patch` for pre-release, `0.EVEN_NUMBER.patch`
for stable release).

To install the pre-release version, use the drop-down list
to select "Install Pre-Release Version", or if already installed the Go extension,
use the "Switch to Pre-Release Version" option in the Visual Studio Code
extension management page. For more details about this mechanism, see the
[Visual Studio Code's documentation](https://code.visualstudio.com/updates/v1_63#_pre-release-extensions).

## Telemetry

VS Code Go extension relies on the [Go Telemetry](https://go.dev/doc/telemetry) to
learn insights about the performance and stability of the extension and the
language server (`gopls`).
**Go Telemetry data uploading is disabled by default** and can be enabled
with the following command:

```
go run golang.org/x/telemetry/cmd/gotelemetry@latest on
```

After telemetry is enabled, the language server will upload metrics and stack
traces to [telemetry.go.dev](https://telemetry.go.dev). You can inspect what
data is collected and can be uploaded by running:

```
go run golang.org/x/telemetry/cmd/gotelemetry@latest view
```

If we get enough adoption, this data can significantly advance the pace of
the Go extension development, and help us meet a higher standard
of reliability. For example:

- Even with [semi-automated crash
  reports](https://github.com/golang/vscode-go/issues?q=is%3Aissue+is%3Aopen+label%3AautomatedReport)
  in VS Code, we've seen several crashers go unreported for weeks or months.
- Even with [a suite of
  benchmarks](https://perf.golang.org/dashboard/?benchmark=all&repository=tools&branch=release-branch.go1.20),
  some performance regressions don't show up in our benchmark environment (such
  as the [completion bug](https://go.dev/issue/62665) mentioned below!).
- Even with [lots of great
  ideas](https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3Agopls+label%3Afeaturerequest)
  for how to improve gopls, we have limited resources. Telemetry can help us
  identify which new features are most important, and which existing features
  aren't being used or aren't working well.

These are just a few ways that telemetry can improve gopls. The [telemetry blog
post series](https://research.swtch.com/telemetry-uses) contains many more.

Go telemetry is designed to be transparent and privacy-preserving. Learn more at
[https://go.dev/doc/telemetry](https://go.dev/doc/telemetry).

## Support Policy

The Go extension is maintained by engineers on the
[Go tools team](https://github.com/orgs/golang/teams/tools-team/members),
who actively monitor the [VS Code Go](https://github.com/golang/vscode-go/issues)
and the [Go](https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3Agopls)
issue trackers.

We support only the latest stable and pre-release versions of the extension.

### Supported Go and tools

The Go extension follows the [Go Release Policy](https://go.dev/doc/devel/release.html#policy),
meaning that it _officially_ supports the two most recent major Go releases.
The Go team maintains _best-effort_ support for the last three major Go versions.

The Go extension relies on [tools](https://github.com/golang/vscode-go/wiki/tools)
like `gopls` and `dlv` for its core functionalities and they have their own release
policy and schedule. We test only against the latest versions of these tools.

In case you need to work with an older version of Go, please check
the [Compatibility] page and manually install the compatible version of
the extension and tools.

## Contributing

We welcome your contributions and thank you for working to improve the Go
development experience in VS Code. If you would like to help work on the VS Code
Go extension, see our
[contribution guide](https://github.com/golang/vscode-go/wiki/contributing) to
learn how to build and run the VS Code Go extension locally and contribute to
the project.

## Code of Conduct

This project follows the
[Go Community Code of Conduct](https://golang.org/conduct). If you encounter a
conduct-related issue, please mail conduct@golang.org.

## License

[MIT](LICENSE)

[Stack Overflow]: https://stackoverflow.com/questions/tagged/go+visual-studio-code
[`gopls`]: https://golang.org/s/gopls
[`go`]: https://golang.org/cmd/go
[Managing extensions in VS Code]: https://code.visualstudio.com/docs/editor/extension-gallery
[VS Code Go extension]: https://marketplace.visualstudio.com/items?itemName=golang.go
[Go installation guide]: https://golang.org/doc/install
["Getting started with VS Code Go"]: https://youtu.be/1MXIGYrMk80
[IntelliSense]: https://github.com/golang/vscode-go/wiki/features#intellisense
[Code navigation]: https://github.com/golang/vscode-go/wiki/features#code-navigation
[Code editing]: https://github.com/golang/vscode-go/wiki/features#code-editing
[Compatibility]: https://github.com/golang/vscode-go/wiki/compatibility
[diagnostics]: https://github.com/golang/vscode-go/wiki/features#diagnostics
[testing]: https://github.com/golang/vscode-go/wiki/features#run-and-test-in-the-editor
[debugging]: https://github.com/golang/vscode-go/wiki/debugging#features
[full feature breakdown]: https://github.com/golang/vscode-go/wiki/features
[workspace documentation]: https://github.com/golang/tools/blob/master/gopls/doc/workspace.md
[`Go: Install/Update Tools` command]: https://github.com/golang/vscode-go/wiki/commands#go-installupdate-tools
[Supported workspace layouts documentation]: https://github.com/golang/tools/blob/master/gopls/doc/workspace.md
[Workspace Folders]: https://code.visualstudio.com/docs/editor/multi-root-workspaces

vscode-go

Golang plugin collection for the text editor SublimeText 3 providing code completion and other IDE-like features

# GoSublime [![Backers on Open Collective](https://opencollective.com/gosublime/backers/badge.svg)](#backers) [![Sponsors on Open Collective](https://opencollective.com/gosublime/sponsors/badge.svg)](#sponsors) [![Build Status](https://travis-ci.org/DisposaBoy/GoSublime.svg?branch=master)](https://travis-ci.org/DisposaBoy/GoSublime)

## Intro

GoSublime is an IDE-like plugin for [Sublime Text 3](http://www.sublimetext.com/) mainly, but not limited to, providing integration for most of your Go/Golang development tools.

See https://margo.sh/b/hello-margo/ for a brief introduction to margo, the engine behind GoSublime.

## Installation & Support

See https://margo.sh/b/migrate/ for instructions on how to install GoSublime.

See [SUPPORT.md](SUPPORT.md) for details about what level of support you can expect while using GoSublime.

## Features

- code completion from Gocode (fork);
- context aware snippets via the code-completion popup;
- sublime build system(ctrl+b) integrating with GoSublime 9o command prompt with live command output;
- lint/syntax check as you type or on save;
- quickly jump to any linter error reported in any open file or package;
- quickly fmt your source or automatically on save to conform with your coding standards;
- easily create a new go file and run it without needing to save it first (9o `replay`);
- share your snippets (anything in the loaded file) on play.golang.org;
- list declarations in the current file or package;
- automatically add/remove package imports;
- quickly jump your import section(automatically goes to the last import) where you can easily edit the pkg alias and return to where you were before;
- go to definition of a package function or constant, etc.;
- create your own margo extensions in Go to e.g. add context-aware commands to the command palette.

## Demo

- Old demo http://vimeo.com/disposaboy/gosublime-demo2

## Copyright, License & Contributors

margo and GoSublime are released under the MIT license. See [LICENSE.md](LICENSE.md)

Thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
<a href="graphs/contributors"><img src="https://opencollective.com/gosublime/contributors.svg?width=890" /></a>

### Supporters

GoSublime has received support from many kind individuals and as a thank you I've added most to [THANKS.md](THANKS.md) file as a way of saying _Thank You_. Some donors donated anonymously and so are not listed, however. If you have donated and would like to add an entry to this file, feel free to open a pull request.

### Donations

See https://margo.sh/funding/ for ways in which you can help support future development of margo and GoSublime.

<hr/>

Become a backer or a sponsor on OpenCollective

### Backers

Thank you to all our backers! 🙏 [[Become a backer](https://opencollective.com/gosublime#backer)]

<a href="https://opencollective.com/gosublime#backers" target="_blank"><img src="https://opencollective.com/gosublime/backers.svg?width=890"></a>

### Sponsors

Support this project by becoming a sponsor. Your logo will show up here with a link to your website. [[Become a sponsor](https://opencollective.com/gosublime#sponsor)]

<a href="https://opencollective.com/gosublime/sponsor/0/website" target="_blank"><img src="https://opencollective.com/gosublime/sponsor/0/avatar.svg"></a>
<a href="https://opencollective.com/gosublime/sponsor/1/website" target="_blank"><img src="https://opencollective.com/gosublime/sponsor/1/avatar.svg"></a>
<a href="https://opencollective.com/gosublime/sponsor/2/website" target="_blank"><img src="https://opencollective.com/gosublime/sponsor/2/avatar.svg"></a>
<a href="https://opencollective.com/gosublime/sponsor/3/website" target="_blank"><img src="https://opencollective.com/gosublime/sponsor/3/avatar.svg"></a>
<a href="https://opencollective.com/gosublime/sponsor/4/website" target="_blank"><img src="https://opencollective.com/gosublime/sponsor/4/avatar.svg"></a>
<a href="https://opencollective.com/gosublime/sponsor/5/website" target="_blank"><img src="https://opencollective.com/gosublime/sponsor/5/avatar.svg"></a>
<a href="https://opencollective.com/gosublime/sponsor/6/website" target="_blank"><img src="https://opencollective.com/gosublime/sponsor/6/avatar.svg"></a>
<a href="https://opencollective.com/gosublime/sponsor/7/website" target="_blank"><img src="https://opencollective.com/gosublime/sponsor/7/avatar.svg"></a>
<a href="https://opencollective.com/gosublime/sponsor/8/website" target="_blank"><img src="https://opencollective.com/gosublime/sponsor/8/avatar.svg"></a>
<a href="https://opencollective.com/gosublime/sponsor/9/website" target="_blank"><img src="https://opencollective.com/gosublime/sponsor/9/avatar.svg"></a>

<br>

<a href="https://margo.sh/sponsors/0" target="_blank"><img src="https://margo.sh/sponsors/0.svg?2"></a>


GoSublime

Vim plugin for generating Go tests based on the function's or method's signature

# gounit-vim

Vim plugin for [gounit](https://github.com/hexdigest/gounit) tool that allows you to generate Go tests easily.

## Demo

![demo](https://github.com/hexdigest/gounit-vim/blob/master/demo.gif)

## Installation
gounit-vim requires **gounit** to be available in your `$PATH`. Alternatively you can provide path to **gounit** using `g:gounit_bin` setting.

Plugin installation:
* [Pathogen](https://github.com/tpope/vim-pathogen)
    ```
    git clone https://github.com/hexdigest/gounit-vim.git ~/.vim/bundle/gounit-vim
    ```
*  [vim-plug](https://github.com/junegunn/vim-plug)
    ```
    Plug 'hexdigest/gounit-vim'
    ```
*  [NeoBundle](https://github.com/Shougo/neobundle.vim)
    ```
    NeoBundle 'hexdigest/gounit-vim'
    ```
*  [Vundle](https://github.com/gmarik/vundle)
    ```
    Plugin 'hexdigest/gounit-vim'
    ```
*  [Vim packages](http://vimhelp.appspot.com/repeat.txt.html#packages) (since Vim 7.4.1528)
    ```
    git clone https://github.com/hexdigest/gounit-vim.git ~/.vim/pack/plugins/start/gounit-vim
    ```  
You will also need to install all the necessary GoUnit binaries. 
It is easy to install by providing a command `:GoUnitInstallBinaries`, which will `go get` all the required binaries.

## Usage
Call `:GoUnit` to generate test for the function declaration in the current line or all functions selected in visual mode.
`GoUnit` also understands "range" parameters:
```vim
:5,10GoUnit     " genereate tests for functions from line 5 to line 10
:.,$GoUnit      " from the current line till the end of the file
:0,.GoUnit      " from the first line to the current line
:%GoUnit        " generate tests for the whole file
```

These commands generate tests using template that you set as a preferred with the `:GoUnitTemplateUse <template>` command.
If you don't want to change your preferred template you can use all of the above commands followed by the name of the template, i.e. `:GoUnit minimock`
If you have `wildmenu` option enabled you can pick desired template from the list of all registered templates with `:GoUnit <TAB>`.

## Managing templates

There are few commands to manage your test templates:
```vim
:GoUnitTemplateAdd             " register contents of the current buffer as a new templates
:GoUnitTemplateAdd /file/name  " register /file/name as new template
:GoUnitTemplateDel template    " remove template
:GoUnitTemplateList            " display all registered test templates
:GoUnitTemplateUse template    " set template as preferred
```

Also you can create useful maps to use it with [vim-go](https://github.com/fatih/vim-go) plugin for fast test generation.
```vim
" maps your leader key + gt to generate tests for the function under your cursor
nnoremap <leader>gt :normal vaf<cr>:GoUnit<cr>
```

## Settings
If you want you can set path to your **gounit** binary if it's not in your path, for example:

    let g:gounit_bin = '/home/user/go/bin/gounit'


gounit-vim

Vim plugin to highlight syntax errors on save

Vim compiler file for Go (golang)
=================================

Compiles Go files in the background and usefully underlines and reports
errors to the QuickFix window:

![](demo.png?raw=true)

Installation:
-------------

### Pathogen

Just clone this repo into your bundles directory:

    git clone https://github.com/rjohnsondev/vim-compiler-go.git ~/.vim/bundle/vim-compiler-go

Either ensure the $GOROOT environment variable is set, or otherwise set the
g:golang_goroot variable in .vimrc to where your go installation can be found.
This must be an absolute path:

    let g:golang_goroot = "/home/richard/go"

### Manual installation

Drop golang.vim in ~/.vim/compiler directory.

Add the following line to the autocmd section of .vimrc

    autocmd FileType go compiler golang

Set the g:golang_goroot variable to where your go installation can be
found.  This must be an absolute path

    let g:golang_goroot = "/home/richard/go"

The plugin assumes a standard project layout with the files stored in a
src directory.  The GOPATH is set to one directory below the src folder.

Usage:
------

Golang is called after a buffer with Go code is saved. The QuickFix
window is opened to show errors, warnings and hints provided by Golang.

To disable calling Golang every time a buffer is saved, put into .vimrc file:

    let g:golang_onwrite = 0

The QuickFix window can be disabled with:

    let g:golang_cwindow = 0

Setting highlights for the lines can be disabled with:

    let g:golang_inline_highlight = 0

Of course, standard :make command can be used as is the case with every
other compiler.


The Best Go Libraries For Editor Plugins (13)