*gopher.nvim*

==============================================================================

gopher.nvim is a minimalistic plugin for Go development in Neovim written in Lua.
It's not an LSP tool, the main goal of this plugin is add go tooling support in Neovim.

------------------------------------------------------------------------------
                                                 *gopher.nvim-table-of-contents*
Table of Contents
  Setup....................................................|gopher.nvim-setup|
  Install dependencies..............................|gopher.nvim-install-deps|
  Configuration...........................................|gopher.nvim-config|
  Auto implementation of interface methods..................|gopher.nvim-impl|
  Setup `nvim-dap` for Go......................................|gopher.nvim-dap|

------------------------------------------------------------------------------
                                                             *gopher.nvim-setup*
                                 `gopher.setup`
Setup function. This method simply merges default configs with opts table.
You can read more about configuration at |gopher.nvim-config|
Calling this function is optional, if you ok with default settings. Look |gopher.nvim.config-defaults|

Usage ~
`require("gopher").setup {}` (replace `{}` with your `config` table)

------------------------------------------------------------------------------
                                                      *gopher.nvim-install-deps*
                             `gopher.install_deps`
Gopher.nvim implements most of its features using third-party tools.
To  install these tools, you can run `:GoInstallDeps` command
or call `require("gopher").install_deps()` if you want ues lua api.


==============================================================================
------------------------------------------------------------------------------
                                                            *gopher.nvim-config*
config it is the place where you can configure the plugin.
also this is optional is you're ok with default settings.
You can look at default options |gopher.nvim-config-defaults|

------------------------------------------------------------------------------
                                                   *gopher.nvim-config-defaults*
                                `default_config`
>lua
  local default_config = {
    --minidoc_replace_end

    -- user specified paths to binaries
    ---@class gopher.ConfigCommand
    commands = {
      go = "go",
      gomodifytags = "gomodifytags",
      gotests = "gotests",
      impl = "impl",
      iferr = "iferr",
      dlv = "dlv",
    },
    ---@class gopher.ConfigGotests
    gotests = {
      -- gotests doesn't have template named "default" so this plugin uses "default" to set the default template
      template = "default",
      -- path to a directory containing custom test code templates
      ---@type string|nil
      template_dir = nil,
      -- switch table tests from using slice to map (with test name for the key)
      -- works only with gotests installed from develop branch
      named = false,
    },
    ---@class gopher.ConfigGoTag
    gotag = {
      ---@type gopher.ConfigGoTagTransform
      transform = "snakecase",
    },
  }
<
Class ~
{gopher.Config}

------------------------------------------------------------------------------
                                                                *config.setup()*
                         `config.setup`({user_config})
Parameters ~
{user_config} `(optional)` gopher.Config


==============================================================================
------------------------------------------------------------------------------
                                                              *gopher.nvim-impl*
impl is utilizing the `impl` tool to generate method stubs for interfaces.
Usage ~

1. put your coursor on the struct on which you want implement the interface
   and run `:GoImpl io.Reader`
   which will automatically choose the reciver for the methods and
   implement the `io.Reader` interface
2. same as previous but with custom receiver, so put your coursor on the struct
   run `:GoImpl w io.Writer`
   where `w` is the receiver and `io.Writer` is the interface
3. specift receiver, struct, and interface
   there's no need to put your coursor on the struct if you specify all arguments
   `:GoImpl r RequestReader io.Reader`
   where `r` is the receiver, `RequestReader` is the struct and `io.Reader` is the interface

simple example:
>go
   type BytesReader struct{}
   //    ^ put your cursor here
   // run `:GoImpl b io.Reader`

   // this is what you will get
   func (b *BytesReader) Read(p []byte) (n int, err error) {
   	panic("not implemented") // TODO: Implement
   }
<


==============================================================================
------------------------------------------------------------------------------
                                                               *gopher.nvim-dap*
This module sets up `nvim-dap` for Go.
Usage ~
just call `require("gopher.dap").setup()`, adn you're good to go.


 vim:tw=78:ts=8:noet:ft=help:norl: