Merge pull request #129 (v0.4.0)

.github/workflows/tests.yml

···
           - v0.11.1
           - v0.11.2
           - v0.11.3
+          - v0.11.4
     runs-on: ${{ matrix.os }}
     steps:
       - name: Install Task

README.md

···
 
 > All development of new and maybe undocumented, and unstable features is happening on [develop](https://github.com/olexsmir/gopher.nvim/tree/develop) branch.
 
+## Table of content
+* [How to install](#install-using-lazynvim)
+* [Features](#features)
+* [Configuration](#configuration)
+* [Troubleshooting](#troubleshooting)
+* [Contributing](#contributing)
+
 ## Install (using [lazy.nvim](https://github.com/folke/lazy.nvim))
 
 Requirements:
···
 - Treesitter parser for `go`(`:TSInstall go` if you use [nvim-treesitter](https://github.com/nvim-treesitter/nvim-treesitter))
 - [Go](https://github.com/golang/go) installed
 
+> [!IMPORTANT]
+> If you prefer using other forges, this repository is also mirrored at:
+> - [tangled.org](https://tangled.org): [`https://tangled.org/olexsmir.xyz/gopher.nvim`](https://tangled.org/olexsmir.xyz/gopher.nvim)
+> - [codeberg.org](https://codeberg.org): [`https://codeberg.org/olexsmir/gopher.nvim`](https://codeberg.org/olexsmir/gopher.nvim)
+
 ```lua
--- NOTE: this plugin is already lazy-loaded, it adds only about 1ms of load
--- time to your config
+-- NOTE: this plugin is already lazy-loaded and adds only about 1ms
+-- of load time to your config
 {
   "olexsmir/gopher.nvim",
   ft = "go",
   -- branch = "develop"
-  -- (optional) will update plugin's deps on every update
+  -- (optional) updates the plugin's dependencies on each update
   build = function()
     vim.cmd.GoInstallDeps()
   end,
···
   ```vim
   " add json tag
   :GoTagAdd json
+
+  " add json tag with omitempty option
+  :GoTagAdd json=omitempty
 
   " remove yaml tag
   :GoTagRm yaml
···
   -- timeout for running internal commands
   timeout = 2000,
 
+  -- timeout for running installer commands(e.g :GoDepsInstall, :GoDepsInstallSync)
+  installer_timeout = 999999,
+
+  -- user specified paths to binaries
   commands = {
     go = "go",
     gomodifytags = "gomodifytags",
···
     iferr = "iferr",
   },
   gotests = {
-    -- gotests doesn't have template named "default" so this plugin uses "default" to set the default template
+    -- a default template that gotess will use.
+    -- gotets doesn't have template named `default`, we use it to represent absence of the provided template.
     template = "default",
+
     -- path to a directory containing custom test code templates
     template_dir = nil,
-    -- switch table tests from using slice to map (with test name for the key)
+
+    -- use named tests(map with test name as key) in table tests(slice of structs by default)
     named = false,
   },
   gotag = {
     transform = "snakecase",
+
     -- default tags to add to struct fields
     default_tag = "json",
+
+    -- default tag option added struct fields, set to nil to disable
+    -- e.g: `option = "json=omitempty,xml=omitempty`
+    option = nil,
   },
   iferr = {
-    -- choose a custom error message
+    -- choose a custom error message, nil to use default
+    -- e.g: `message = 'fmt.Errorf("failed to %w", err)'`
     message = nil,
   },
 }
 ```
+
+## Troubleshooting
+The most common issue with the plugin is missing dependencies.
+Run `:checkhealth gopher` to verify that the plugin is installed correctly.
+If any binaries are missing, install them using `:GoInstallDeps`.
+
+If the issue persists, feel free to [open a new issue](https://github.com/olexsmir/gopher.nvim/issues/new).
 
 ## Contributing
 

Taskfile.yml

···
              -u ./scripts/minimal_init.lua \
              -c "lua MiniTest.run()" \
              -c ":qa!"
+  nvim:
+    cmd: nvim --clean -u "./scripts/minimal_init.lua" {{ .CLI_ARGS }}
 
   docgen:
     desc: generate vimhelp

doc/gopher.nvim.txt

···
 ------------------------------------------------------------------------------
                                                       *gopher.nvim-dependencies*
                              `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 to use lua api.
-By default dependencies will be installed asynchronously,
-to install them synchronously pass `{sync = true}` as an argument.
+
+Gopher.nvim implements most of its features using third-party tools. To
+install plugin's dependencies, you can run:
+`:GoInstallDeps` or `:GoInstallDepsSync`
+or use `require("gopher").install_deps()` if you prefer lua api.
 
 
 ==============================================================================
···
     ---@type number
     timeout = 2000,
 
-    --- timeout for running installer commands(e.g :GoDepsInstall, :GoDepsInstallSync)
+    -- timeout for running installer commands(e.g :GoDepsInstall, :GoDepsInstallSync)
+    ---@type number
     installer_timeout = 999999,
 
     -- user specified paths to binaries
···
     },
     ---@class gopher.ConfigGotests
     gotests = {
-      -- gotests doesn't have template named "default" so this plugin uses "default" to set the default template
+      -- a default template that gotess will use.
+      -- gotets doesn't have template named `default`, we use it to represent absence of the provided 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)
+
+      -- use named tests(map with test name as key) in table tests(slice of structs by default)
       named = false,
     },
     ---@class gopher.ConfigGoTag
···
 
       -- default tags to add to struct fields
       default_tag = "json",
+
+      -- default tag option added struct fields, set to nil to disable
+      -- e.g: `option = "json=omitempty,xml=omitempty`
+      ---@type string|nil
+      option = nil,
     },
     iferr = {
-      -- choose a custom error message
+      -- choose a custom error message, nil to use default
+      -- e.g: `message = 'fmt.Errorf("failed to %w", err)'`
       ---@type string|nil
       message = nil,
     },
···
 <
 Class ~
 {gopher.Config}
+Fields ~
+{setup} `(fun(user_config?: gopher.Config))`
 
 
 ==============================================================================
···
 ------------------------------------------------------------------------------
                                                        *gopher.nvim-struct-tags*
 
-`struct_tags` is utilizing the `gomodifytags` tool to add or remove tags to struct fields.
+`struct_tags` is utilizing the `gomodifytags` tool to add or remove tags to
+struct fields.
 
 Usage ~
 
-How to add/remove tags to struct fields:
+How to add/remove/clear tags to struct fields:
 1. Place cursor on the struct
 2. Run `:GoTagAdd json` to add json tags to struct fields
 3. Run `:GoTagRm json` to remove json tags to struct fields
+4. Run `:GoTagClear` to clear all tags from struct fields
 
-To clear all tags from struct run: `:GoTagClear`
+If you want to add/remove tag with options, you can use `json=omitempty`
+(where json is tag, and omitempty is its option).
+Example: `:GoTagAdd xml json=omitempty`
+
 
 NOTE: if you dont specify the tag it will use `json` as default
 
···
 Integration of `impl` tool to generate method stubs for interfaces.
 
 Usage ~
+
 1. Automatically implement an interface for a struct:
-   - Place your cursor on the struct where you want to implement the interface.
-   - Run `:GoImpl io.Reader`
-   - This will automatically determine the receiver and implement the `io.Reader` interface.
+ - Place your cursor on the struct where you want to implement the interface.
+ - Run `:GoImpl io.Reader`
+ - This will automatically determine the receiver and implement the `io.Reader` interface.
 
 2. Specify a custom receiver:
-   - Place your cursor on the struct
-   - Run `:GoImpl w io.Writer`, where:
-     - `w` is the receiver.
-     - `io.Writer` is the interface to implement.
+ - Place your cursor on the struct
+ - Run `:GoImpl w io.Writer`, where:
+  - `w` is the receiver.
+  - `io.Writer` is the interface to implement.
 
 3. Explicitly specify the receiver, struct, and interface:
-   - No need to place the cursor on the struct if all arguments are provided.
-   - Run `:GoImpl r RequestReader io.Reader`, where:
-     - `r` is the receiver.
-     - `RequestReader` is the struct.
-     - `io.Reader` is the interface to implement.
+ - No need to place the cursor on the struct if all arguments are provided.
+ - Run `:GoImpl r RequestReader io.Reader`, where:
+  - `r` is the receiver.
+  - `RequestReader` is the struct.
+  - `io.Reader` is the interface to implement.
 
 Example:
 >go
···
 Usage ~
 
 - Generate unit test for specific function/method:
-  1. Place your cursor on the desired function/method.
-  2. Run `:GoTestAdd`
+ 1. Place your cursor on the desired function/method.
+ 2. Run `:GoTestAdd`
 
 - Generate unit tests for *all* functions/methods in current file:
-  - run `:GoTestsAll`
+ - run `:GoTestsAll`
 
 - Generate unit tests *only* for *exported(public)* functions/methods:
-  - run `:GoTestsExp`
+ - run `:GoTestsExp`
 
-You can also specify the template to use for generating the tests. See |gopher.nvim-config|
-More details about templates can be found at: https://github.com/cweill/gotests
+You can also specify the template to use for generating the tests.
+See |gopher.nvim-config|.
+More details about templates: https://github.com/cweill/gotests
 
 If you prefer named tests, you can enable them in |gopher.nvim-config|.
 
···
 This module provides a way to generate comments for Go code.
 
 Usage ~
-Set cursor on line with function/method/struct/etc and run `:GoCmt` to generate a comment.
+
+Set cursor on line with function/method/struct/etc and
+run `:GoCmt` to generate a comment.
 
 
  vim:tw=78:ts=8:noet:ft=help:norl:

lua/gopher/_utils/gocmd.lua

···
-local r = require "gopher._utils.runner"
-local c = require("gopher.config").commands
-local u = require "gopher._utils"
-local gocmd = {}
-
----@param args string[]
----@return string[]
-local function if_get(args)
-  for i, arg in ipairs(args) do
-    local m = string.match(arg, "^https://(.*)$") or string.match(arg, "^http://(.*)$") or arg
-    table.remove(args, i)
-    table.insert(args, i, m)
-  end
-  return args
-end
-
----@param args unknown[]
----@return string[]
-local function if_generate(args)
-  if #args == 1 and args[1] == "%" then
-    args[1] = vim.fn.expand "%"
-  end
-  return args
-end
-
----@param subcmd string
----@param args string[]
----@return string
-function gocmd.run(subcmd, args)
-  if #args == 0 and subcmd ~= "generate" then
-    error "please provide any arguments"
-  end
-
-  if subcmd == "get" then
-    args = if_get(args)
-  end
-
-  if subcmd == "generate" then
-    args = if_generate(args)
-  end
-
-  local rs = r.sync { c.go, subcmd, unpack(args) }
-  if rs.code ~= 0 then
-    error("go " .. subcmd .. " failed: " .. rs.stderr)
-  end
-
-  u.notify(c.go .. " " .. subcmd .. " ran successful")
-  return rs.stdout
-end
-
-return gocmd

lua/gopher/_utils/init.lua

···
 local utils = {}
 
 ---@param msg string
----@param lvl? number by default `vim.log.levels.INFO`
+---@param lvl? integer by default `vim.log.levels.INFO`
 function utils.notify(msg, lvl)
   lvl = lvl or vim.log.levels.INFO
   vim.notify(msg, lvl, {
···
 function utils.trimend(s)
   local r, _ = string.gsub(s, "%s+$", "")
   return r
+end
+
+-- Since indentation can be spaces or tabs, that's my hack around it
+---@param line string
+---@param indent integer
+---@return string
+function utils.indent(line, indent)
+  local char = string.sub(line, 1, 1)
+  if char ~= " " and char ~= "\t" then
+    char = " "
+  end
+  return string.rep(char, indent)
+end
+
+---@generic T
+---@param tbl T[]
+---@return T[]
+function utils.list_unique(tbl)
+  if vim.fn.has "nvim-0.12" == 1 then
+    return vim.list.unique(tbl)
+  end
+
+  for i = #tbl, 1, -1 do
+    for j = 1, i - 1 do
+      if tbl[i] == tbl[j] then
+        table.remove(tbl, i)
+        break
+      end
+    end
+  end
+  return tbl
 end
 
 return utils

lua/gopher/_utils/log.lua

···
 -- for the code i have stolen(or have inspected by idk)
 local c = require "gopher.config"
 
----@class Gopher.Logger
+---@class gopher.Logger
 ---@field get_outfile fun():string
 ---@field trace fun(...)
 ---@field fmt_trace fun(...)
···
   float_precision = 0.01,
 }
 
----@type Gopher.Logger
+---@type gopher.Logger
 ---@diagnostic disable-next-line: missing-fields
 local log = {}
 

lua/gopher/_utils/ts.lua

···
        right: (expression_list (composite_literal
                                  type: (struct_type))))]
   ]],
+  struct_field = [[
+    (field_declaration name: (field_identifier) @_name)
+  ]],
   func = [[
     [(function_declaration name: (identifier)       @_name)
-     (method_declaration   name: (field_identifier) @_name)]
+     (method_declaration   name: (field_identifier) @_name)
+     (method_elem          name: (field_identifier) @_name)]
   ]],
   package = [[
     (package_identifier) @_name
···
       name: (type_identifier) @_name
       type: (interface_type))
   ]],
+  var = [[
+    [(var_declaration (var_spec name: (identifier) @_name))
+     (short_var_declaration
+       left: (expression_list (identifier) @_name @_var))]
+  ]],
 }
 
 ---@param parent_type string[]
 ---@param node TSNode
 ---@return TSNode?
-local function get_parrent_node(parent_type, node)
+local function get_parent_node(parent_type, node)
   ---@type TSNode?
   local current = node
   while current do
···
 end
 
 ---@class gopher.TsResult
----@field name string
----@field start integer
----@field end_ integer
----@field is_varstruct boolean
+---@field name string Name of the struct, function, etc
+---@field start integer Line number where the declaration starts
+---@field end_ integer Line number where the declaration ends
+---@field indent integer Number of spaces/tabs in the current cursor line
+---@field is_varstruct boolean Is struct declared as `var S struct{}` or `s := struct{}{}`
 
 ---@param bufnr integer
 ---@param parent_type string[]
···
     error "No treesitter parser found for go"
   end
 
-  local node = vim.treesitter.get_node {
-    bufnr = bufnr,
-  }
+  local node = vim.treesitter.get_node { bufnr = bufnr }
   if not node then
-    error "No nodes found under cursor"
+    error "No nodes found under the cursor"
   end
 
-  local parent_node = get_parrent_node(parent_type, node)
+  local parent_node = get_parent_node(parent_type, node)
   if not parent_node then
-    error "No parent node found under cursor"
+    error "No parent node found under the cursor"
   end
 
   local q = vim.treesitter.query.parse("go", query)
   local res = get_captures(q, parent_node, bufnr)
   assert(res.name ~= nil, "No capture name found")
 
-  local start_row, _, end_row, _ = parent_node:range()
+  local start_row, start_col, end_row, _ = parent_node:range()
+  res["indent"] = start_col
   res["start"] = start_row + 1
   res["end_"] = end_row + 1
 
···
 ---@param bufnr integer
 function ts.get_struct_under_cursor(bufnr)
   --- should be both type_spec and type_declaration
-  --- because in cases like `type ( T struct{}, U strict{} )`
-  --- i will be choosing always last struct in the list
+  --- because in cases like `type ( T struct{}, U struct{} )`
   ---
   --- var_declaration is for cases like `var x struct{}`
   --- short_var_declaration is for cases like `x := struct{}{}`
+  ---
+  --- it always chooses last struct type in the list
   return do_stuff(bufnr, {
     "type_spec",
     "type_declaration",
···
 end
 
 ---@param bufnr integer
+function ts.get_struct_field_under_cursor(bufnr)
+  return do_stuff(bufnr, { "field_declaration" }, queries.struct_field)
+end
+
+---@param bufnr integer
 function ts.get_func_under_cursor(bufnr)
   --- since this handles both and funcs and methods we should check for both parent nodes
-  return do_stuff(bufnr, { "function_declaration", "method_declaration" }, queries.func)
+  return do_stuff(bufnr, {
+    "method_elem",
+    "function_declaration",
+    "method_declaration",
+  }, queries.func)
 end
 
 ---@param bufnr integer
···
 ---@param bufnr integer
 function ts.get_interface_under_cursor(bufnr)
   return do_stuff(bufnr, { "type_declaration" }, queries.interface)
+end
+
+---@param bufnr integer
+function ts.get_variable_under_cursor(bufnr)
+  return do_stuff(bufnr, { "var_declaration", "short_var_declaration" }, queries.var)
 end
 
 return ts

lua/gopher/comment.lua

···
 ---@text
 --- This module provides a way to generate comments for Go code.
 ---
----@usage Set cursor on line with function/method/struct/etc and run `:GoCmt` to generate a comment.
+---@usage
+--- Set cursor on line with function/method/struct/etc and
+--- run `:GoCmt` to generate a comment.
 
 local ts = require "gopher._utils.ts"
 local log = require "gopher._utils.log"
+local u = require "gopher._utils"
 local comment = {}
 
----@param name string
----@return string
----@dochide
-local function template(name)
-  return "// " .. name .. " "
-end
-
+--- NOTE: The order of functions executed inside this function is IMPORTANT.
+--- This function is extremely fragile; run tests after making any changes.
+---
 ---@param bufnr integer
+---@param line string
 ---@return string
 ---@dochide
-local function generate(bufnr)
+local function generate(bufnr, line)
+  local sf_ok, sf_res = pcall(ts.get_struct_field_under_cursor, bufnr)
+  if sf_ok then
+    return u.indent(line, sf_res.indent) .. "// " .. sf_res.name .. " "
+  end
+
   local s_ok, s_res = pcall(ts.get_struct_under_cursor, bufnr)
   if s_ok then
-    return template(s_res.name)
+    return u.indent(line, s_res.indent) .. "// " .. s_res.name .. " "
+  end
+
+  local v_ok, v_res = pcall(ts.get_variable_under_cursor, bufnr)
+  if v_ok then
+    return u.indent(line, v_res.indent) .. "// " .. v_res.name .. " "
   end
 
   local f_ok, f_res = pcall(ts.get_func_under_cursor, bufnr)
   if f_ok then
-    return template(f_res.name)
+    return u.indent(line, f_res.indent) .. "// " .. f_res.name .. " "
   end
 
   local i_ok, i_res = pcall(ts.get_interface_under_cursor, bufnr)
   if i_ok then
-    return template(i_res.name)
+    return u.indent(line, i_res.indent) .. "// " .. i_res.name .. " "
   end
 
   local p_ok, p_res = pcall(ts.get_package_under_cursor, bufnr)
···
 
 function comment.comment()
   local bufnr = vim.api.nvim_get_current_buf()
-  local cmt = generate(bufnr)
-  log.debug("generated comment: " .. cmt)
+  local lnum = vim.fn.getcurpos()[2]
+  local line = vim.fn.getline(lnum)
+  local cmt = generate(bufnr, line)
+  log.debug("generated comment:", {
+    comment = cmt,
+    line = line,
+  })
 
-  local pos = vim.fn.getcurpos()[2]
-  vim.fn.append(pos - 1, cmt)
-  vim.fn.setpos(".", { 0, pos, #cmt })
+  vim.fn.append(lnum - 1, cmt)
+  vim.fn.setpos(".", { bufnr, lnum, #cmt })
   vim.cmd "startinsert!"
 end
 

lua/gopher/config.lua

···
+---@type gopher.Config
+---@dochide
+---@diagnostic disable-next-line: missing-fields .setup() gets injected later
 local config = {}
 
 ---@tag gopher.nvim-config.ConfigGoTagTransform
···
 ---@tag gopher.nvim-config
 ---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section)
 ---@class gopher.Config
+---@field setup fun(user_config?: gopher.Config)
 local default_config = {
   -- log level, you might consider using DEBUG or TRACE for debugging the plugin
   ---@type number
···
   ---@type number
   timeout = 2000,
 
-  --- timeout for running installer commands(e.g :GoDepsInstall, :GoDepsInstallSync)
+  -- timeout for running installer commands(e.g :GoDepsInstall, :GoDepsInstallSync)
+  ---@type number
   installer_timeout = 999999,
 
   -- user specified paths to binaries
···
   },
   ---@class gopher.ConfigGotests
   gotests = {
-    -- gotests doesn't have template named "default" so this plugin uses "default" to set the default template
+    -- a default template that gotess will use.
+    -- gotets doesn't have template named `default`, we use it to represent absence of the provided 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)
+
+    -- use named tests(map with test name as key) in table tests(slice of structs by default)
     named = false,
   },
   ---@class gopher.ConfigGoTag
···
 
     -- default tags to add to struct fields
     default_tag = "json",
+
+    -- default tag option added struct fields, set to nil to disable
+    -- e.g: `option = "json=omitempty,xml=omitempty`
+    ---@type string|nil
+    option = nil,
   },
   iferr = {
-    -- choose a custom error message
+    -- choose a custom error message, nil to use default
+    -- e.g: `message = 'fmt.Errorf("failed to %w", err)'`
     ---@type string|nil
     message = nil,
   },
···
   vim.validate("commands.iferr", _config.commands.iferr, "string")
   vim.validate("gotests", _config.gotests, "table")
   vim.validate("gotests.template", _config.gotests.template, "string")
-  vim.validate("gotests.template_dir", _config.gotests.template_dir, "string", true)
+  vim.validate("gotests.template_dir", _config.gotests.template_dir, { "string", "nil" })
   vim.validate("gotests.named", _config.gotests.named, "boolean")
   vim.validate("gotag", _config.gotag, "table")
   vim.validate("gotag.transform", _config.gotag.transform, "string")
   vim.validate("gotag.default_tag", _config.gotag.default_tag, "string")
+  vim.validate("gotag.option", _config.gotag.option, { "string", "nil" })
   vim.validate("iferr", _config.iferr, "table")
-  vim.validate("iferr.message", _config.iferr.message, "string", true)
+  vim.validate("iferr.message", _config.iferr.message, { "string", "nil" })
 end
 
 setmetatable(config, {
···
 })
 
 ---@dochide
----@return gopher.Config
-return config --[[ @as gopher.Config ]]
+return config

lua/gopher/go.lua

···
+local c = require "gopher.config"
+local u = require "gopher._utils"
+local r = require "gopher._utils.runner"
+local go = {}
+
+local function run(subcmd, args)
+  local rs = r.sync { c.commands.go, subcmd, unpack(args) }
+  if rs.code ~= 0 then
+    error("go " .. subcmd .. " failed: " .. rs.stderr)
+  end
+
+  u.notify(c.commands.go .. " " .. subcmd .. " ran successful")
+  return rs.stdout
+end
+
+---@param args string[]
+function go.get(args)
+  for i, arg in ipairs(args) do
+    local m = string.match(arg, "^https://(.*)$") or string.match(arg, "^http://(.*)$") or arg
+    table.remove(args, i)
+    table.insert(args, i, m)
+  end
+
+  run("get", args)
+end
+
+---@param args string[]
+function go.mod(args)
+  run("mod", args)
+end
+
+---@param args string[]
+function go.work(args)
+  -- TODO: use `gopls.tidy`
+
+  run("work", args)
+end
+
+---Executes `go generate`
+---If only argument is `%` it's going to be equivalent to `go generate <path to current file>`
+---@param args string[]
+function go.generate(args)
+  -- TODO: use `gopls.generate`
+
+  if #args == 0 then
+    error "please provide arguments"
+  end
+
+  if #args == 1 and args[1] == "%" then
+    args[1] = vim.fn.expand "%"
+  end
+
+  run("generate", args)
+end
+
+return go

lua/gopher/gotests.lua

···
 ---@text gotests is utilizing the `gotests` tool to generate unit tests boilerplate.
 ---@usage
 --- - Generate unit test for specific function/method:
----   1. Place your cursor on the desired function/method.
----   2. Run `:GoTestAdd`
+---  1. Place your cursor on the desired function/method.
+---  2. Run `:GoTestAdd`
 ---
 --- - Generate unit tests for *all* functions/methods in current file:
----   - run `:GoTestsAll`
+---  - run `:GoTestsAll`
 ---
 --- - Generate unit tests *only* for *exported(public)* functions/methods:
----   - run `:GoTestsExp`
+---  - run `:GoTestsExp`
 ---
---- You can also specify the template to use for generating the tests. See |gopher.nvim-config|
---- More details about templates can be found at: https://github.com/cweill/gotests
+--- You can also specify the template to use for generating the tests.
+--- See |gopher.nvim-config|.
+--- More details about templates: https://github.com/cweill/gotests
 ---
 --- If you prefer named tests, you can enable them in |gopher.nvim-config|.
 

lua/gopher/health.lua

···
+local c = require("gopher.config").commands
 local health = {}
-local cmd = require("gopher.config").commands
 
 local deps = {
+  vim_version = "nvim-0.10",
   bin = {
     {
-      bin = cmd.go,
+      bin = c.go,
       msg = "required for `:GoGet`, `:GoMod`, `:GoGenerate`, `:GoWork`, `:GoInstallDeps`, `:GoInstallDepsSync`",
-      optional = false,
     },
-    { bin = cmd.gomodifytags, msg = "required for `:GoTagAdd`, `:GoTagRm`", optional = true },
-    { bin = cmd.impl, msg = "required for `:GoImpl`", optional = true },
-    { bin = cmd.iferr, msg = "required for `:GoIfErr`", optional = true },
-    {
-      bin = cmd.gotests,
-      msg = "required for `:GoTestAdd`, `:GoTestsAll`, `:GoTestsExp`",
-      optional = true,
-    },
+    { bin = c.gomodifytags, msg = "required for `:GoTagAdd`, `:GoTagRm`" },
+    { bin = c.impl, msg = "required for `:GoImpl`" },
+    { bin = c.iferr, msg = "required for `:GoIfErr`" },
+    { bin = c.gotests, msg = "required for `:GoTestAdd`, `:GoTestsAll`, `:GoTestsExp`" },
   },
   treesitter = {
     { parser = "go", msg = "required for most of the parts of `gopher.nvim`" },
   },
 }
 
----@param bin string
----@return boolean
-local function is_binary_found(bin)
-  return vim.fn.executable(bin) == 1
+---@param bin {bin:string, msg:string, optional:boolean}
+local function check_binary(bin)
+  if vim.fn.executable(bin.bin) == 1 then
+    vim.health.ok(bin.bin .. " is found oh PATH: `" .. vim.fn.exepath(bin.bin) .. "`")
+  else
+    vim.health.error(bin.bin .. " not found on PATH, " .. bin.msg)
+  end
 end
 
----@param ft string
----@return boolean
-local function is_treesitter_parser_available(ft)
-  local ok, parser = pcall(vim.treesitter.get_parser, 0, ft)
-  return ok and parser ~= nil
+---@param ts {parser:string, msg:string}
+local function check_treesitter(ts)
+  local ok, parser = pcall(vim.treesitter.get_parser, 0, ts.parser)
+  if ok and parser ~= nil then
+    vim.health.ok("`" .. ts.parser .. "` parser is installed")
+  else
+    vim.health.error("`" .. ts.parser .. "` parser not found")
+  end
 end
 
 function health.check()
-  vim.health.start "required binaries"
-  vim.health.info "all those binaries can be installed by `:GoInstallDeps`"
+  vim.health.start "Neovim version"
+  if vim.fn.has(deps.vim_version) == 1 then
+    vim.health.ok "Neovim version is compatible"
+  else
+    vim.health.error(deps.vim_version .. " or newer is required")
+  end
+
+  vim.health.start "Required binaries (those can be installed with `:GoInstallDeps`)"
   for _, bin in ipairs(deps.bin) do
-    if is_binary_found(bin.bin) then
-      vim.health.ok(bin.bin .. " installed")
-    else
-      if bin.optional then
-        vim.health.warn(bin.bin .. " not found, " .. bin.msg)
-      else
-        vim.health.error(bin.bin .. " not found, " .. bin.msg)
-      end
-    end
+    check_binary(bin)
   end
 
-  vim.health.start "required treesitter parsers"
+  vim.health.start "Treesitter"
   for _, parser in ipairs(deps.treesitter) do
-    if is_treesitter_parser_available(parser.parser) then
-      vim.health.ok(parser.parser .. " parser installed")
-    else
-      vim.health.error(parser.parser .. " parser not found, " .. parser.msg)
-    end
+    check_treesitter(parser)
   end
 end
 

lua/gopher/iferr.lua

···
 
   vim.fn.append(pos, u.remove_empty_lines(vim.split(rs.stdout, "\n")))
   vim.cmd [[silent normal! j=2j]]
-  vim.fn.setpos(".", pos)
+  vim.fn.setpos(".", pos --[[@as integer[] ]])
 end
 
 return iferr

lua/gopher/impl.lua

···
 ---@text
 --- Integration of `impl` tool to generate method stubs for interfaces.
 ---
----@usage 1. Automatically implement an interface for a struct:
----    - Place your cursor on the struct where you want to implement the interface.
----    - Run `:GoImpl io.Reader`
----    - This will automatically determine the receiver and implement the `io.Reader` interface.
+---@usage
+--- 1. Automatically implement an interface for a struct:
+---  - Place your cursor on the struct where you want to implement the interface.
+---  - Run `:GoImpl io.Reader`
+---  - This will automatically determine the receiver and implement the `io.Reader` interface.
 ---
 --- 2. Specify a custom receiver:
----    - Place your cursor on the struct
----    - Run `:GoImpl w io.Writer`, where:
----      - `w` is the receiver.
----      - `io.Writer` is the interface to implement.
+---  - Place your cursor on the struct
+---  - Run `:GoImpl w io.Writer`, where:
+---   - `w` is the receiver.
+---   - `io.Writer` is the interface to implement.
 ---
 --- 3. Explicitly specify the receiver, struct, and interface:
----    - No need to place the cursor on the struct if all arguments are provided.
----    - Run `:GoImpl r RequestReader io.Reader`, where:
----      - `r` is the receiver.
----      - `RequestReader` is the struct.
----      - `io.Reader` is the interface to implement.
+---  - No need to place the cursor on the struct if all arguments are provided.
+---  - Run `:GoImpl r RequestReader io.Reader`, where:
+---   - `r` is the receiver.
+---   - `RequestReader` is the struct.
+---   - `io.Reader` is the interface to implement.
 ---
 --- Example:
 --- >go

lua/gopher/init.lua

···
 local log = require "gopher._utils.log"
 local tags = require "gopher.struct_tags"
 local tests = require "gopher.gotests"
-local gocmd = require("gopher._utils.gocmd").run
+local go = require "gopher.go"
 local gopher = {}
 
 ---@toc_entry Setup
···
 
 ---@toc_entry Install dependencies
 ---@tag gopher.nvim-dependencies
----@text 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 to use lua api.
---- By default dependencies will be installed asynchronously,
---- to install them synchronously pass `{sync = true}` as an argument.
+---@text
+--- Gopher.nvim implements most of its features using third-party tools. To
+--- install plugin's dependencies, you can run:
+--- `:GoInstallDeps` or `:GoInstallDepsSync`
+--- or use `require("gopher").install_deps()` if you prefer lua api.
 gopher.install_deps = require("gopher.installer").install_deps
 
 gopher.impl = require("gopher.impl").impl
···
   all = tests.all_tests,
 }
 
-gopher.get = function(...)
-  gocmd("get", ...)
-end
-
-gopher.mod = function(...)
-  gocmd("mod", ...)
-end
-
-gopher.generate = function(...)
-  gocmd("generate", ...)
-end
-
-gopher.work = function(...)
-  gocmd("work", ...)
-end
+gopher.get = go.get
+gopher.mod = go.mod
+gopher.work = go.work
+gopher.generate = go.generate
 
 return gopher

lua/gopher/struct_tags.lua

···
 ---@toc_entry Modify struct tags
 ---@tag gopher.nvim-struct-tags
 ---@text
---- `struct_tags` is utilizing the `gomodifytags` tool to add or remove tags to struct fields.
+--- `struct_tags` is utilizing the `gomodifytags` tool to add or remove tags to
+--- struct fields.
 ---
 ---@usage
---- How to add/remove tags to struct fields:
+--- How to add/remove/clear tags to struct fields:
 --- 1. Place cursor on the struct
 --- 2. Run `:GoTagAdd json` to add json tags to struct fields
 --- 3. Run `:GoTagRm json` to remove json tags to struct fields
+--- 4. Run `:GoTagClear` to clear all tags from struct fields
 ---
---- To clear all tags from struct run: `:GoTagClear`
+--- If you want to add/remove tag with options, you can use `json=omitempty`
+--- (where json is tag, and omitempty is its option).
+--- Example: `:GoTagAdd xml json=omitempty`
+---
 ---
 --- NOTE: if you dont specify the tag it will use `json` as default
 ---
···
 
 ---@dochide
 ---@class gopher.StructTagInput
----@field tags string[] User provided tags
+---@field input string[] User provided tags
 ---@field range? gopher.StructTagRange  (optional)
 
 ---@dochide
···
   )
 end
 
+---@dochide
+---@param option string
+local function option_to_tag(option)
+  return option:match "^(.-)="
+end
+
+---@dochide
 ---@param args string[]
----@return string
+local function unwrap_if_needed(args)
+  local out = {}
+  for _, v in pairs(args) do
+    for _, p in pairs(vim.split(v, ",")) do
+      table.insert(out, p)
+    end
+  end
+  return out
+end
+
+---@dochide
+---@class gopher.StructTagsArgs
+---@field tags string
+---@field options string
+
 ---@dochide
-local function handler_user_tags(args)
-  if #args == 0 then
-    return c.gotag.default_tag
+---@param args string[]
+---@return gopher.StructTagsArgs
+function struct_tags.parse_args(args)
+  args = unwrap_if_needed(args)
+
+  local tags, options = {}, {}
+  for _, v in pairs(args) do
+    if string.find(v, "=") then
+      table.insert(options, v)
+      table.insert(tags, option_to_tag(v))
+    else
+      table.insert(tags, v)
+    end
   end
-  return table.concat(args, ",")
+
+  return {
+    tags = table.concat(u.list_unique(tags), ","),
+    options = table.concat(u.list_unique(options), ","),
+  }
 end
 
--- Adds tags to a struct under the cursor
--- See |gopher.nvim-struct-tags|
+-- Adds tags to a struct under the cursor. See `:h gopher.nvim-struct-tags`.
 ---@param opts gopher.StructTagInput
 ---@dochide
 function struct_tags.add(opts)
···
   local fpath = vim.fn.expand "%"
   local bufnr = vim.api.nvim_get_current_buf()
 
-  local user_tags = handler_user_tags(opts.tags)
-  handle_tags(fpath, bufnr, opts.range, { "-add-tags", user_tags })
+  local user_args = struct_tags.parse_args(opts.input)
+  handle_tags(fpath, bufnr, opts.range, {
+    "-add-tags",
+    (user_args.tags ~= "") and user_args.tags or c.gotag.default_tag,
+    (user_args.options ~= "" or c.gotag.option) and "-add-options" or nil,
+    (user_args.options ~= "") and user_args.options or c.gotag.option,
+  })
 end
 
--- Removes tags from a struct under the cursor
--- See `:h gopher.nvim-struct-tags`
+-- Removes tags from a struct under the cursor. See `:h gopher.nvim-struct-tags`.
 ---@dochide
 ---@param opts gopher.StructTagInput
 function struct_tags.remove(opts)
···
   local fpath = vim.fn.expand "%"
   local bufnr = vim.api.nvim_get_current_buf()
 
-  local user_tags = handler_user_tags(opts.tags)
-  handle_tags(fpath, bufnr, opts.range, { "-remove-tags", user_tags })
+  local user_args = struct_tags.parse_args(opts.input)
+  handle_tags(fpath, bufnr, opts.range, {
+    "-remove-tags",
+    (user_args.tags ~= "") and user_args.tags or c.gotag.default_tag,
+    (user_args.options ~= "" or c.gotag.option ~= nil) and "-remove-options" or nil,
+    (user_args.options ~= "") and user_args.options or c.gotag.option,
+  })
 end
 
--- Removes all tags from a struct under the cursor
--- See `:h gopher.nvim-struct-tags`
+-- Removes all tags from a struct under the cursor.
+-- See `:h gopher.nvim-struct-tags`.
 ---@dochide
 function struct_tags.clear()
   local fpath = vim.fn.expand "%"

plugin/gopher.lua

···
 -- :GoTag
 cmd("GoTagAdd", function(opts)
   require("gopher").tags.add {
-    tags = opts.fargs,
+    input = opts.fargs,
     range = (opts.count ~= -1) and {
       start = opts.line1,
       end_ = opts.line2,
···
 
 cmd("GoTagRm", function(opts)
   require("gopher").tags.rm {
-    tags = opts.fargs,
+    input = opts.fargs,
     range = (opts.count ~= -1) and {
       start = opts.line1,
       end_ = opts.line2,
···
 end, "*")
 
 cmd("GoGenerate", function(opts)
-  require("gopher").generate(opts.fargs or "")
+  require("gopher").generate(opts.fargs or { "" })
 end, "?")

scripts/minimal_init.lua

···
   end
 end
 
-install_plug "nvim-lua/plenary.nvim"
 install_plug "nvim-treesitter/nvim-treesitter"
 install_plug "echasnovski/mini.doc" -- used for docs generation
 install_plug "folke/tokyonight.nvim" -- theme for generating demos

spec/fixtures/comment/interface_many_method_input.go

···
+package main
+
+type Testinger interface {
+	Get(id string) int
+	Set(id string, val int)
+}

spec/fixtures/comment/interface_many_method_output.go

···
+package main
+
+type Testinger interface {
+	Get(id string) int
+	// Set 
+	Set(id string, val int)
+}

spec/fixtures/comment/interface_method_input.go

···
+package main
+
+type Testinger interface {
+	Method(input string) error
+}

spec/fixtures/comment/interface_method_output.go

···
+package main
+
+type Testinger interface {
+	// Method 
+	Method(input string) error
+}

spec/fixtures/comment/many_structs_fields_input.go

···
+package main
+
+type (
+	TestOne struct {
+		Asdf string
+		ID   int
+	}
+
+	TestTwo struct {
+		Fesa int
+		A    bool
+	}
+
+	TestThree struct {
+		Asufj int
+		Fs    string
+	}
+)

spec/fixtures/comment/many_structs_fields_output.go

···
+package main
+
+type (
+	TestOne struct {
+		Asdf string
+		ID   int
+	}
+
+	TestTwo struct {
+		// Fesa 
+		Fesa int
+		A    bool
+	}
+
+	TestThree struct {
+		Asufj int
+		Fs    string
+	}
+)

spec/fixtures/comment/struct_fields_input.go

···
+package main
+
+type CommentStruct struct {
+	Name    string
+	Address string
+	Aliases []string
+}

spec/fixtures/comment/struct_fields_output.go

···
+package main
+
+type CommentStruct struct {
+	Name    string
+	// Address 
+	Address string
+	Aliases []string
+}

spec/fixtures/comment/svar_input.go

···
+package main
+
+func varTest() {
+	s := "something"
+}

spec/fixtures/comment/svar_output.go

···
+package main
+
+func varTest() {
+	// s 
+	s := "something"
+}

spec/fixtures/comment/var_input.go

···
+package main
+
+func test() {
+	var imAVar string
+}

spec/fixtures/comment/var_output.go

···
+package main
+
+func test() {
+	// imAVar 
+	var imAVar string
+}

spec/fixtures/comment/var_struct_fields_input.go

···
+package main
+
+func main() {
+	var s struct {
+		API string
+		Key string
+	}
+}

spec/fixtures/comment/var_struct_fields_output.go

···
+package main
+
+func main() {
+	var s struct {
+		API string
+		// Key 
+		Key string
+	}
+}

spec/fixtures/tags/overwrite_default_option_input.go

···
+package main
+
+type Test struct {
+	ID      int
+	Another struct {
+		Second string
+	}
+}

spec/fixtures/tags/overwrite_default_option_output.go

···
+package main
+
+type Test struct {
+	ID      int `xml:"id,otheroption"`
+	Another struct {
+		Second string `xml:"second,otheroption"`
+	} `xml:"another,otheroption"`
+}

spec/fixtures/tags/remove_with_option_input.go

···
+package main
+
+type Test struct {
+	ID      int    `json:"id,omitempty" xml:"id,someoption"`
+	Name    string `json:"name,omitempty" xml:"name,someoption"`
+	Num     int64  `json:"num,omitempty" xml:"num,someoption"`
+	Another struct {
+		First  int    `json:"first,omitempty" xml:"first,someoption"`
+		Second string `json:"second,omitempty" xml:"second,someoption"`
+	} `json:"another,omitempty" xml:"another,someoption"`
+}

spec/fixtures/tags/remove_with_option_output.go

···
+package main
+
+type Test struct {
+	ID      int    `xml:"id,someoption"`
+	Name    string `xml:"name,someoption"`
+	Num     int64  `xml:"num,someoption"`
+	Another struct {
+		First  int    `xml:"first,someoption"`
+		Second string `xml:"second,someoption"`
+	} `xml:"another,someoption"`
+}

spec/fixtures/tags/with_default_option_input.go

···
+package main
+
+type Test struct {
+	ID      int
+	Another struct {
+		Second string
+	}
+}

spec/fixtures/tags/with_default_option_output.go

···
+package main
+
+type Test struct {
+	ID      int `xml:"id,theoption"`
+	Another struct {
+		Second string `xml:"second,theoption"`
+	} `xml:"another,theoption"`
+}

spec/fixtures/tags/with_option_input.go

···
+package main
+
+type Test struct {
+	ID      int
+	Name    string
+	Num     int64
+	Another struct {
+		First  int
+		Second string
+	}
+}

spec/fixtures/tags/with_option_output.go

···
+package main
+
+type Test struct {
+	ID      int    `json:"id,omitempty"`
+	Name    string `json:"name,omitempty"`
+	Num     int64  `json:"num,omitempty"`
+	Another struct {
+		First  int    `json:"first,omitempty"`
+		Second string `json:"second,omitempty"`
+	} `json:"another,omitempty"`
+}

spec/integration/comment_test.lua

···
   do_the_test("struct", { 4, 1 })
 end
 
+comment["should add a comment on struct field"] = function()
+  do_the_test("struct_fields", { 5, 8 })
+end
+
+comment["should add a comment on var struct field"] = function()
+  do_the_test("var_struct_fields", { 6, 4 })
+end
+
+comment["should add a comment on one field of many structs"] = function()
+  do_the_test("many_structs_fields", { 10, 4 })
+end
+
 comment["should add comment to function"] = function()
   do_the_test("func", { 3, 1 })
 end
···
 
 comment["should add comment to interface"] = function()
   do_the_test("interface", { 3, 6 })
+end
+
+comment["should add comment on interface method"] = function()
+  do_the_test("interface_method", { 4, 2 })
+end
+
+comment["should add a comment on interface with many method"] = function()
+  do_the_test("interface_many_method", { 5, 2 })
+end
+
+comment["should add a comment on a var"] = function()
+  do_the_test("var", { 4, 2 })
+end
+
+comment["should add a comment on a short declared var"] = function()
+  do_the_test("svar", { 4, 8 })
 end
 
 comment["otherwise should add // above cursor"] = function()

spec/integration/iferr_test.lua

···
   child.lua [[
     require("gopher").setup {
       iferr = { message = 'fmt.Errorf("failed to %w", err)' }
-  } ]]
+    }
+  ]]
 
   local rs = t.setup_test("iferr/message", child, { 6, 2 })
   child.cmd "GoIfErr"

spec/integration/struct_tags_test.lua

···
   t.cleanup(rs)
 end
 
+struct_tags["should add tags with option"] = function()
+  local rs = t.setup_test("tags/with_option", child, { 3, 6 })
+  child.cmd "GoTagAdd json=omitempty"
+  child.cmd "write"
+
+  t.eq(t.readfile(rs.tmp), rs.fixtures.output)
+  t.cleanup(rs)
+end
+
+struct_tags["should add tags with default option"] = function()
+  child.lua [[
+    require("gopher").setup {
+      gotag = { option = "xml=theoption" },
+    }
+  ]]
+
+  local rs = t.setup_test("tags/with_default_option", child, { 3, 6 })
+  child.cmd "GoTagAdd xml"
+  child.cmd "write"
+
+  t.eq(t.readfile(rs.tmp), rs.fixtures.output)
+  t.cleanup(rs)
+end
+
+struct_tags["should add tags and overwrite default option"] = function()
+  child.lua [[
+    require("gopher").setup {
+      gotag = { option = "xml=theoption" },
+    }
+  ]]
+
+  local rs = t.setup_test("tags/overwrite_default_option", child, { 3, 6 })
+  child.cmd "GoTagAdd xml=otheroption"
+  child.cmd "write"
+
+  t.eq(t.readfile(rs.tmp), rs.fixtures.output)
+  t.cleanup(rs)
+end
+
+struct_tags["should remove tag with specified option"] = function()
+  local rs = t.setup_test("tags/remove_with_option", child, { 3, 6 })
+  child.cmd "GoTagRm json=omitempty"
+  child.cmd "write"
+
+  t.eq(t.readfile(rs.tmp), rs.fixtures.output)
+  t.cleanup(rs)
+end
+
 return T

spec/unit/config_test.lua

···
 end
 
 config["can be called with empty table"] = function()
+  ---@diagnostic disable-next-line: missing-fields
   require("gopher").setup {}
 end
 
 config["should change option"] = function()
   local log_level = 1234567890
+
+  ---@diagnostic disable-next-line: missing-fields
   require("gopher").setup {
     log_level = log_level,
   }

spec/unit/struct_tag_test.lua

···
+local t = require "spec.testutils"
+local _, T, st = t.setup "struct_tags"
+
+st["should parse tags"] = function()
+  local out = require("gopher.struct_tags").parse_args { "json", "yaml", "etc" }
+
+  t.eq(out.tags, "json,yaml,etc")
+  t.eq(out.options, "")
+end
+
+st["should parse tags separated by commas"] = function()
+  local out = require("gopher.struct_tags").parse_args { "json,yaml,etc" }
+
+  t.eq(out.tags, "json,yaml,etc")
+  t.eq(out.options, "")
+end
+
+st["should parse tags separated by command and spaces"] = function()
+  local out = require("gopher.struct_tags").parse_args {
+    "json,yaml",
+    "json=omitempty",
+    "xml=something",
+  }
+
+  t.eq(out.tags, "json,yaml,xml")
+  t.eq(out.options, "json=omitempty,xml=something")
+end
+
+st["should parse tag with an option"] = function()
+  local out = require("gopher.struct_tags").parse_args {
+    "json=omitempty",
+    "xml",
+    "xml=theoption",
+  }
+
+  t.eq(out.tags, "json,xml")
+  t.eq(out.options, "json=omitempty,xml=theoption")
+end
+
+st["should parse tags with an option"] = function()
+  local out = require("gopher.struct_tags").parse_args { "json=omitempty", "yaml" }
+
+  t.eq(out.tags, "json,yaml")
+  t.eq(out.options, "json=omitempty")
+end
+
+st["should parse tags with an option separated with comma"] = function()
+  local out = require("gopher.struct_tags").parse_args { "json=omitempty,yaml" }
+
+  t.eq(out.tags, "json,yaml")
+  t.eq(out.options, "json=omitempty")
+end
+
+st["should parse tags with options specified separately"] = function()
+  local out = require("gopher.struct_tags").parse_args { "json", "yaml", "json=omitempty" }
+
+  t.eq(out.tags, "json,yaml")
+  t.eq(out.options, "json=omitempty")
+end
+
+st["should parse tags with options specified separately and separated by comma"] = function()
+  local out = require("gopher.struct_tags").parse_args { "json,yaml,json=omitempty" }
+
+  t.eq(out.tags, "json,yaml")
+  t.eq(out.options, "json=omitempty")
+end
+
+return T

spec/unit/utils_test.lua

···
   t.eq(u.trimend "  hi   ", "  hi")
 end
 
+utils["should add .indent() spaces"] = function()
+  local u = require "gopher._utils"
+  local line = "    func Test() error {"
+  local indent = 4
+
+  t.eq("    ", u.indent(line, indent))
+end
+
+utils["should add .indent() a tab"] = function()
+  local u = require "gopher._utils"
+  local line = "\tfunc Test() error {"
+  local indent = 1
+
+  t.eq("\t", u.indent(line, indent))
+end
+
+utils["should add .indent() 2 tabs"] = function()
+  local u = require "gopher._utils"
+  local line = "\t\tfunc Test() error {"
+  local indent = 2
+
+  t.eq("\t\t", u.indent(line, indent))
+end
+
+utils["should .list_unique on list with duplicates"] = function()
+  local u = require "gopher._utils"
+  t.eq({ "json", "xml" }, u.list_unique { "json", "xml", "json" })
+end
+
+utils["should .list_unique on list with no duplicates"] = function()
+  local u = require "gopher._utils"
+  t.eq({ "json", "xml" }, u.list_unique { "json", "xml" })
+end
+
 return T

vhs/iferr.go

···
 package demos
 
-func ifErr() {
+func ifErr() error {
 	out, err := doSomething()
 
 	_ = out

vhs/tags.tape

···
 Sleep 1s
 
 Type@400ms "jVjj"
-Type ":GoTagAdd xml" Sleep 500ms Enter
+Type ":GoTagAdd json=omitempty" Sleep 500ms Enter
 
 Sleep 5s