olexsmir/gopher.nvim
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

sync develop and main (#68)

Browse source 
* healthcheck: refactoring, remove deprecation wanings (#35)

* refactor(checkhealth): remove deprecation warnings, complete rewrite

* refactor(checkhealth): rename util file

* style(healthchecker): reformat lua in vim file

* refactor(health): move all report function into table

* add editorconfig (#36)

* refactor of public plugin's api (#37)

* refactor: move all plugin functionality to init.lua

* fix(commands): now it uses correct module paths

* refactor(config): change way how it handles options

* refactor(gotests): use correct config, change way how deps required, fix some typos

* fix(healthchecker): use correct config

* refactor(iferr): change api

* refactor(impl): change api

* refactor(installer): change api

* refactor(struct_tags): change way of importting deps

* refactor(struct_tags): rename M to struct_tags

* run stylua

* refactor(dap): make it all in one file, and make some refactoring

* refactor(_utils): change way how it organizes

* fix: use new _utils api

* refactor(_utils.health): reorganize module

* refactor(_utils.ts): some renameing, moving requires lines

* run stylua

* update tooling (#38)

* chore: delete pre-commit

* chore: switch from makefile to taskfile

* chore(ci): update and add one more linter

* chore(editorconfig): add config for Go

* chore(editorconfig): remove max_line_length

* fix: editorconfig-check on README.md

* feat: run tests independent from user's nvim config

* remove editorconfig-checker

* fix(config): now it not removes .setup() from itself after calling
.setup()

* fix(config): now it works correctly

* chore: update taskfile, and linter config

* feat(config): make it optional to call .setup()

* run tests independent of user nvim setup (#39)

* chore(lua_ls): now lua_ls knows about testing functions

* spec: change way how tests srtuctured

* test(config): refactor tests

* test: utils

* refactor(utils): remove not used function

* chore(ci): add test runner

* chore(ci): remove taskfile from deps

* fix: now it works

* fix(dap): now dlv uses cmd to run from config

* chore(ci): run tests on many versions of nvim

* refactor: commands runner (#42)

* feat(utils): first impl of own commands runner

* refactor(gotests): uses own runner instead of vendored

* refactor(utils): back to plenary.job

* refactor(gotests): use new runner, clean code

* fix(runner): now it returns output correctly

* refactor(iferr): use vim.system

i have tried to use _utils.runner, but i can't figure out how to make `< file.go` for the command

* refactor(impl): use new runner

* refactor(installer): use new runner

* refactor(struct_tags): use new runner

* refactor: commands such as :GoGet runs with new runner

* refactor: throw errors in more lua way, i think

* refactor(utils): notify now has title

* refactor: use more correct way of notifying

* refactor(runner): write error message on error

* add ability for setting custom tools options (#44)

* feat(gotests): add custom templates support

* feat(struct_tags): add support for custom `transform` option

* fix(health): check if bin is installed, and added message about treesitter parser

* fix: fix iferr config (#56)

* Add support for named tests (#50)

* fix(typo): README.md (#47)

* feat: add support for named tests

* test

* tags in table

* debug installer msg

* test

* hardcoded @develop

* get gotests tag from setup()

* update readme

* store install tag in urls table

* removed gotests tag

* update README.md

* remove urls installer index reference

* remove named arg from add_test()

* .

* update README.md

* update README.md

---------

Co-authored-by: Steve M <gearcog@users.noreply.github.com>

* reformat .editorconfig config

* refactor(api)!: mave tags and gotests api into their sub tables

* add help file, and docs (#59)

* idk how good this idea is

* this could be working but i still cant figure out how to run it

* ignore tags that mini.doc gens, but why?

* chore(taskfile): force exiting after tests

because i got infinit ci

* chore(ci): add more nvim versions to run on

* chore: update taskfile

* feat: add docs generator

* docs: its only begining

* refactor: update docgen script

* docs: write some more

* docs(config): update

* docs: update readme

* language

* hope it would work

* what about that?

* maybe this would work?

* update md

* upd

* WHY DOESNT IT WORKING

* idk by but 0.9.3 just fails the ci, so i deleted it from suite

* again update, why does markdown not work in embeded html

* maybe it can help?

* upd

* again update

* kinda fix

* fix: formatting

* again some updating

* some readme updating

* fix, this shouldnt be in repo

* i finnaly undertood how to fix this fking skill issue

* fix(struct_tags): typo

* refactor(docs): change the order in generated file

* docs: install deps

* refactor(scripts): rename doc-gen script

* docs(impl): write docs

* docs(dap): add doc

* stylua .

* docs(struct_tags): add doc

* docs(gotests): add docs

* docs(iferr): add docs

* docs(comment): add doc

* update CONTRIBUTING.md

* docs(README): talk about `develop` branch

* docs: update README.md

* refactor(health): keep in mind new way of health check (#63)

* feat: add logger (#64)

* refactor(health): keep in mind new way of health check (#63)

* feat(log): add logger module

* refactor(utils): remove unused code

* refactor(log, utils): get plugin name from config

* refactor(logger): add some type annotations

* refactor(utils): log notifications

* feat: LOGGER™

* feat(config): TYPES

* refactor(log): dont give a thing about var that is not even declared

* feat(log): add easy way to open log

* refactor(log): some types

* update types

* docs: regen

* fix(log): make setting log level by config work

* feat(iferr): write error to log file if occur

* feat(gotests): add logger

* add deprecation message (#67)

---------

Co-authored-by: Arne Van Maele <93863978+arnevm123@users.noreply.github.com>
Co-authored-by: Alex <49870662+ysomad@users.noreply.github.com>
Co-authored-by: Steve M <gearcog@users.noreply.github.com>
This commit is contained in:
Smirnov Oleksandr 2024-06-15 12:43:06 +03:00 • committed by GitHub
parent ac27f4b679
commit a995af3415
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
47 changed files with 1594 additions and 737 deletions
Download patch file Download diff file Expand all files Collapse all files

17
lua/gopher/_utils/_health.lua
View file

@ -1,17 +0,0 @@
return {
---@param lib string
---@return boolean
lualib_is_found = function(lib)
local is_found, _ = pcall(require, lib)
return is_found
end,
---@param bin string
---@return boolean
binary_is_found = function(bin)
if vim.fn.executable(bin) == 1 then
return true
end
return false
end,
}

40
lua/gopher/_utils/commands.lua
View file

@ -1,40 +0,0 @@
---Run any go commands like `go generate`, `go get`, `go mod`
---@param cmd string
---@param ... string|string[]
return function(cmd, ...)
local Job = require "plenary.job"
local c = require("gopher.config").config.commands
local u = require "gopher._utils"
local args = { ... }
if #args == 0 then
u.notify("please provice any arguments", "error")
return
end
if cmd == "generate" and #args == 1 and args[1] == "%" then
args[1] = vim.fn.expand "%" ---@diagnostic disable-line: missing-parameter
elseif cmd == "get" then
for i, arg in ipairs(args) do
---@diagnostic disable-next-line: param-type-mismatch
local m = string.match(arg, "^https://(.*)$") or string.match(arg, "^http://(.*)$") or arg
table.remove(args, i)
table.insert(args, i, m)
end
end
local cmd_args = vim.list_extend({ cmd }, args) ---@diagnostic disable-line: missing-parameter
Job:new({
command = c.go,
args = cmd_args,
on_exit = function(_, retval)
if retval ~= 0 then
u.notify("command 'go " .. unpack(cmd_args) .. "' exited with code " .. retval, "error")
u.notify(cmd .. " " .. unpack(cmd_args), "debug")
return
end
u.notify("go " .. cmd .. " was success runned", "info")
end,
}):start()
end

33
lua/gopher/_utils/health_util.lua Normal file
View file

@ -0,0 +1,33 @@
local h = vim.health or require "health"
local health = {}
health.start = h.start or h.report_start
health.ok = h.ok or h.report_ok
health.warn = h.warn or h.report_warn
health.error = h.error or h.report_error
health.info = h.info or h.report_info
---@param module string
---@return boolean
function health.is_lualib_found(module)
local is_found, _ = pcall(require, module)
return is_found
end
---@param bin string
---@return boolean
function health.is_binary_found(bin)
if vim.fn.executable(bin) == 1 then
return true
end
return false
end
---@param ft string
---@return boolean
function health.is_treesitter_parser_available(ft)
local ok, parser = pcall(vim.treesitter.get_parser, 0, ft)
return ok and parser ~= nil
end
return health

74
lua/gopher/_utils/init.lua
View file

@ -1,48 +1,34 @@
---@diagnostic disable: param-type-mismatch
return {
---@param t table
---@return boolean
empty = function(t)
if t == nil then
return true
end
local c = require "gopher.config"
local log = require "gopher._utils.log"
local utils = {}
return next(t) == nil
end,
---@param msg string
---@param lvl number
function utils.deferred_notify(msg, lvl)
vim.defer_fn(function()
vim.notify(msg, lvl, {
title = c.___plugin_name,
})
log.debug(msg)
end, 0)
end
---@param s string
---@return string
rtrim = function(s)
local n = #s
while n > 0 and s:find("^%s", n) do
n = n - 1
end
---@param msg string
---@param lvl? number
function utils.notify(msg, lvl)
lvl = lvl or vim.log.levels.INFO
vim.notify(msg, lvl, {
title = c.___plugin_name,
})
log.debug(msg)
end
return s:sub(1, n)
end,
-- safe require
---@param module string module name
function utils.sreq(module)
local ok, m = pcall(require, module)
assert(ok, string.format("gopher.nvim dependency error: %s not installed", module))
return m
end
---@param msg string
---@param lvl string|integer
notify = function(msg, lvl)
local l
if lvl == "error" or lvl == 4 then
l = vim.log.levels.ERROR
elseif lvl == "info" or lvl == 2 then
l = vim.log.levels.INFO
elseif lvl == "debug" or lvl == 1 then
l = vim.log.levels.DEBUG
end
vim.defer_fn(function()
vim.notify(msg, l)
end, 0)
end,
---safe require
---@param name string module name
sreq = function(name)
local ok, m = pcall(require, name)
assert(ok, string.format("gopher.nvim dependency error: %s not installed", name))
return m
end,
}
return utils

170
lua/gopher/_utils/log.lua Normal file
View file

@ -0,0 +1,170 @@
-- thanks https://github.com/tjdevries/vlog.nvim
-- and https://github.com/williamboman/mason.nvim
-- for the code i have stolen(or have inspected by idk)
local c = require "gopher.config"
---@class Gopher.Logger
---@field get_outfile fun():string
---@field trace fun(...)
---@field fmt_trace fun(...)
---@field debug fun(...)
---@field fmt_debug fun(...)
---@field info fun(...)
---@field fmt_info fun(...)
---@field warn fun(...)
---@field fmt_warn fun(...)
---@field error fun(...)
---@field fmt_error fun(...)
local config = {
-- Name of the plugin. Prepended to log messages
name = c.___plugin_name,
-- Should print the output to neovim while running
-- values: 'sync','async',false
use_console = vim.env.GOPHER_VERBOSE_LOGS == "1",
-- Should highlighting be used in console (using echohl)
highlights = true,
-- Should write to a file
use_file = true,
-- Level configuration
modes = {
{ name = "trace", hl = "Comment", level = vim.log.levels.TRACE },
{ name = "debug", hl = "Comment", level = vim.log.levels.DEBUG },
{ name = "info", hl = "None", level = vim.log.levels.INFO },
{ name = "warn", hl = "WarningMsg", level = vim.log.levels.WARN },
{ name = "error", hl = "ErrorMsg", level = vim.log.levels.ERROR },
},
-- Can limit the number of decimals displayed for floats
float_precision = 0.01,
}
---@type Gopher.Logger
---@diagnostic disable-next-line: missing-fields
local log = {}
---@return string
function log.get_outfile()
return table.concat {
(vim.fn.has "nvim-0.8.0" == 1) and vim.fn.stdpath "log" or vim.fn.stdpath "cache",
("/%s.log"):format(config.name),
}
end
-- selene: allow(incorrect_standard_library_use)
local unpack = unpack or table.unpack
do
local round = function(x, increment)
increment = increment or 1
x = x / increment
return (x > 0 and math.floor(x + 0.5) or math.ceil(x - 0.5)) * increment
end
local tbl_has_tostring = function(tbl)
local mt = getmetatable(tbl)
return mt and mt.__tostring ~= nil
end
local make_string = function(...)
local t = {}
for i = 1, select("#", ...) do
local x = select(i, ...)
if type(x) == "number" and config.float_precision then
x = tostring(round(x, config.float_precision))
elseif type(x) == "table" and not tbl_has_tostring(x) then
x = vim.inspect(x)
else
x = tostring(x)
end
t[#t + 1] = x
end
return table.concat(t, " ")
end
local log_at_level = function(level_config, message_maker, ...)
-- Return early if we're below the current_log_level
--
-- the log level source get from config directly because otherwise it doesnt work
if level_config.level < c.log_level then
return
end
local nameupper = level_config.name:upper()
local msg = message_maker(...)
local info = debug.getinfo(2, "Sl")
local lineinfo = info.short_src .. ":" .. info.currentline
-- Output to console
if config.use_console then
local log_to_console = function()
local console_string =
string.format("[%-6s%s] %s: %s", nameupper, os.date "%H:%M:%S", lineinfo, msg)
if config.highlights and level_config.hl then
vim.cmd(string.format("echohl %s", level_config.hl))
end
local split_console = vim.split(console_string, "\n")
for _, v in ipairs(split_console) do
local formatted_msg = string.format("[%s] %s", config.name, vim.fn.escape(v, [["\]]))
---@diagnostic disable-next-line: param-type-mismatch
local ok = pcall(vim.cmd, string.format([[echom "%s"]], formatted_msg))
if not ok then
vim.api.nvim_out_write(msg .. "\n")
end
end
if config.highlights and level_config.hl then
vim.cmd "echohl NONE"
end
end
if config.use_console == "sync" and not vim.in_fast_event() then
log_to_console()
else
vim.schedule(log_to_console)
end
end
-- Output to log file
if config.use_file then
local fp = assert(io.open(log.get_outfile(), "a"))
local str = string.format("[%-6s%s] %s: %s\n", nameupper, os.date(), lineinfo, msg)
fp:write(str)
fp:close()
end
end
for _, x in ipairs(config.modes) do
-- log.info("these", "are", "separated")
log[x.name] = function(...) ---@diagnostic disable-line: assign-type-mismatch
return log_at_level(x, make_string, ...)
end
-- log.fmt_info("These are %s strings", "formatted")
log[("fmt_%s"):format(x.name)] = function(...) ---@diagnostic disable-line: assign-type-mismatch
return log_at_level(x, function(...)
local passed = { ... }
local fmt = table.remove(passed, 1)
local inspected = {}
for _, v in ipairs(passed) do
if type(v) == "table" and tbl_has_tostring(v) then
table.insert(inspected, v)
else
table.insert(inspected, vim.inspect(v))
end
end
return string.format(fmt, unpack(inspected))
end, ...)
end
end
end
return log

53
lua/gopher/_utils/runner/gocmd.lua Normal file
View file

@ -0,0 +1,53 @@
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[]|nil
function gocmd.run(subcmd, args)
if #args == 0 then
error "please provice any arguments"
end
if subcmd == "get" then
args = if_get(args)
end
if subcmd == "generate" then
args = if_generate(args)
end
return r.sync(c.go, {
args = { subcmd, unpack(args) },
on_exit = function(data, status)
if status ~= 0 then
error("gocmd failed: " .. data)
end
u.notify(c.go .. " " .. subcmd .. " successful runned")
end,
})
end
return gocmd

33
lua/gopher/_utils/runner/init.lua Normal file
View file

@ -0,0 +1,33 @@
local Job = require "plenary.job"
local runner = {}
---@class gopher.RunnerOpts
---@field args? string[]
---@field cwd? string?
---@field on_exit? fun(data:string, status:number)
---@param cmd string
---@param opts gopher.RunnerOpts
---@return string[]|nil
function runner.sync(cmd, opts)
local output
Job:new({
command = cmd,
args = opts.args,
cwd = opts.cwd,
on_stderr = function(_, data)
vim.print(data)
end,
on_exit = function(data, status)
output = data:result()
vim.schedule(function()
if opts.on_exit then
opts.on_exit(output, status)
end
end)
end,
}):sync(60000 --[[1 min]])
return output
end
return runner

28
lua/gopher/_utils/ts/init.lua
View file

@ -1,7 +1,7 @@
---@diagnostic disable: param-type-mismatch
local nodes = require "gopher._utils.ts.nodes"
local u = require "gopher._utils"
local M = {
local ts = {
querys = {
struct_block = [[((type_declaration (type_spec name:(type_identifier) @struct.name type: (struct_type)))@struct.declaration)]],
em_struct_block = [[(field_declaration name:(field_identifier)@struct.name type: (struct_type)) @struct.declaration]],
@ -27,14 +27,14 @@ end
---@param bufnr string|nil
---@param do_notify boolean|nil
---@return table|nil
function M.get_struct_node_at_pos(row, col, bufnr, do_notify)
function ts.get_struct_node_at_pos(row, col, bufnr, do_notify)
local notify = do_notify or true
local query = M.querys.struct_block .. " " .. M.querys.em_struct_block
local query = ts.querys.struct_block .. " " .. ts.querys.em_struct_block
local bufn = bufnr or vim.api.nvim_get_current_buf()
local ns = nodes.nodes_at_cursor(query, get_name_defaults(), bufn, row, col)
if ns == nil then
if notify then
u.notify("struct not found", "warn")
u.deferred_notify("struct not found", vim.log.levels.WARN)
end
else
return ns[#ns]
@ -46,14 +46,14 @@ end
---@param bufnr string|nil
---@param do_notify boolean|nil
---@return table|nil
function M.get_func_method_node_at_pos(row, col, bufnr, do_notify)
function ts.get_func_method_node_at_pos(row, col, bufnr, do_notify)
local notify = do_notify or true
local query = M.querys.func .. " " .. M.querys.method_name
local query = ts.querys.func .. " " .. ts.querys.method_name
local bufn = bufnr or vim.api.nvim_get_current_buf()
local ns = nodes.nodes_at_cursor(query, get_name_defaults(), bufn, row, col)
if ns == nil then
if notify then
u.notify("function not found", "warn")
u.deferred_notify("function not found", vim.log.levels.WARN)
end
else
return ns[#ns]
@ -65,16 +65,16 @@ end
---@param bufnr string|nil
---@param do_notify boolean|nil
---@return table|nil
function M.get_package_node_at_pos(row, col, bufnr, do_notify)
function ts.get_package_node_at_pos(row, col, bufnr, do_notify)
local notify = do_notify or true
-- stylua: ignore
if row > 10 then return end
local query = M.querys.package
local query = ts.querys.package
local bufn = bufnr or vim.api.nvim_get_current_buf()
local ns = nodes.nodes_at_cursor(query, get_name_defaults(), bufn, row, col)
if ns == nil then
if notify then
u.notify("package not found", "warn")
u.deferred_notify("package not found", vim.log.levels.WARN)
return nil
end
else
@ -87,18 +87,18 @@ end
---@param bufnr string|nil
---@param do_notify boolean|nil
---@return table|nil
function M.get_interface_node_at_pos(row, col, bufnr, do_notify)
function ts.get_interface_node_at_pos(row, col, bufnr, do_notify)
local notify = do_notify or true
local query = M.querys.interface
local query = ts.querys.interface
local bufn = bufnr or vim.api.nvim_get_current_buf()
local ns = nodes.nodes_at_cursor(query, get_name_defaults(), bufn, row, col)
if ns == nil then
if notify then
u.notify("interface not found", "warn")
u.deferred_notify("interface not found", vim.log.levels.WARN)
end
else
return ns[#ns]
end
end
return M
return ts

20
lua/gopher/_utils/ts/nodes.lua
View file

@ -1,3 +1,7 @@
local ts_query = require "nvim-treesitter.query"
local parsers = require "nvim-treesitter.parsers"
local locals = require "nvim-treesitter.locals"
local u = require "gopher._utils"
local M = {}
local function intersects(row, col, sRow, sCol, eRow, eCol)
@ -53,10 +57,6 @@ end
---@param pos_row string
---@return string
function M.get_all_nodes(query, lang, _, bufnr, pos_row, _)
local ts_query = require "nvim-treesitter.query"
local parsers = require "nvim-treesitter.parsers"
local locals = require "nvim-treesitter.locals"
bufnr = bufnr or 0
pos_row = pos_row or 30000
@ -113,8 +113,6 @@ end
---@param col string
---@return table
function M.nodes_at_cursor(query, default, bufnr, row, col)
local u = require "gopher._utils"
bufnr = bufnr or vim.api.nvim_get_current_buf()
local ft = vim.api.nvim_buf_get_option(bufnr, "ft")
if row == nil or col == nil then
@ -123,13 +121,19 @@ function M.nodes_at_cursor(query, default, bufnr, row, col)
local nodes = M.get_all_nodes(query, ft, default, bufnr, row, col)
if nodes == nil then
u.notify("Unable to find any nodes. Place your cursor on a go symbol and try again", "debug")
u.deferred_notify(
"Unable to find any nodes. Place your cursor on a go symbol and try again",
vim.log.levels.DEBUG
)
return nil
end
nodes = M.sort_nodes(M.intersect_nodes(nodes, row, col))
if nodes == nil or #nodes == 0 then
u.notify("Unable to find any nodes at pos. " .. tostring(row) .. ":" .. tostring(col), "debug")
u.deferred_notify(
"Unable to find any nodes at pos. " .. tostring(row) .. ":" .. tostring(col),
vim.log.levels.DEBUG
)
return nil
end

29
lua/gopher/api.lua
View file

@ -1,29 +0,0 @@
local API = {}
local tags = require "gopher.struct_tags"
local tests = require "gopher.gotests"
local cmd = require "gopher._utils.commands"
API.install_deps = require "gopher.installer"
API.tags_add = tags.add
API.tags_rm = tags.remove
API.impl = require "gopher.impl"
API.iferr = require "gopher.iferr"
API.comment = require "gopher.comment"
API.test_add = tests.func_test
API.test_exported = tests.all_exported_tests
API.tests_all = tests.all_tests
API.get = function(...)
cmd("get", ...)
end
API.mod = function(...)
cmd("mod", ...)
end
API.generate = function(...)
cmd("generate", ...)
end
API.work = function(...)
cmd("work", ...)
end
return API

9
lua/gopher/comment.lua
View file

@ -1,3 +1,10 @@
---@toc_entry Generate comments
---@tag gopher.nvim-comments
---@usage Execute `:GoCmt` to generate a comment for the current function/method/struct/etc on this line.
---@text This module provides a way to generate comments for Go code.
local log = require "gopher._utils.log"
local function generate(row, col)
local ts_utils = require "gopher._utils.ts"
local comment, ns = nil, nil
@ -33,6 +40,8 @@ return function()
local row, col = unpack(vim.api.nvim_win_get_cursor(0))
local comment, ns = generate(row + 1, col + 1)
log.debug("generated comment: " .. comment)
vim.api.nvim_win_set_cursor(0, {
ns.dim.s.r,
ns.dim.s.c,

108
lua/gopher/config.lua
View file

@ -1,33 +1,89 @@
---@class Config
---@field commands ConfigCommands
---@toc_entry Configuration
---@tag gopher.nvim-config
---@text 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|
---@class ConfigCommands
---@field go string
---@field gomodifytags string
---@field gotests string
---@field impl string
---@field iferr string
---@field dlv string
---@type gopher.Config
---@private
local config = {}
local M = {
---@type Config
config = {
---set custom commands for tools
commands = {
go = "go",
gomodifytags = "gomodifytags",
gotests = "gotests",
impl = "impl",
iferr = "iferr",
dlv = "dlv",
},
---@tag gopher.nvim-config.ConfigGoTagTransform
---@text Possible values for |gopher.Config|.gotag.transform:
---
---@private
---@alias gopher.ConfigGoTagTransform
---| "snakecase" "GopherUser" -> "gopher_user"
---| "camelcase" "GopherUser" -> "gopherUser"
---| "lispcase" "GopherUser" -> "gopher-user"
---| "pascalcase" "GopherUser" -> "GopherUser"
---| "titlecase" "GopherUser" -> "Gopher User"
---| "keep" keeps the original field name
--minidoc_replace_start {
---@tag gopher.nvim-config-defaults
---@eval return MiniDoc.afterlines_to_code(MiniDoc.current.eval_section):gsub(">", ">lua")
---
---@class gopher.Config
local default_config = {
--minidoc_replace_end
-- log level, you might consider using DEBUG or TRACE for degugging the plugin
---@type number
log_level = vim.log.levels.INFO,
-- 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",
},
}
--minidoc_afterlines_end
---Plugin setup function
---@param opts Config user config
function M.setup(opts)
M.config = vim.tbl_deep_extend("force", M.config, opts or {})
---@type gopher.Config
---@private
local _config = default_config
-- I am kinda secret so don't tell anyone about me
-- even dont use me
--
-- if you don't belive me that i am secret see
-- the line below it says @private
---@private
_config.___plugin_name = "gopher.nvim" ---@diagnostic disable-line: inject-field
---@param user_config? gopher.Config
---@private
function config.setup(user_config)
_config = vim.tbl_deep_extend("force", default_config, user_config or {})
end
return M
setmetatable(config, {
__index = function(_, key)
return _config[key]
end,
})
return config

129
lua/gopher/dap.lua Normal file
View file

@ -0,0 +1,129 @@
---@toc_entry Setup `nvim-dap` for Go
---@tag gopher.nvim-dap
---@text This module sets up `nvim-dap` for Go.
---@usage just call `require("gopher.dap").setup()`, and you're good to go.
local c = require "gopher.config"
local dap = {}
dap.adapter = function(callback, config)
local host = config.host or "127.0.0.1"
local port = config.port or "38697"
local addr = string.format("%s:%s", host, port)
local handle, pid_or_err
local stdout = assert(vim.loop.new_pipe(false))
local opts = {
stdio = { nil, stdout },
args = { "dap", "-l", addr },
detached = true,
}
handle, pid_or_err = vim.loop.spawn(c.commands.dlv, opts, function(status)
if not stdout or not handle then
return
end
stdout:close()
handle:close()
if status ~= 0 then
print("dlv exited with code", status)
end
end)
assert(handle, "Error running dlv: " .. tostring(pid_or_err))
if stdout then
stdout:read_start(function(err, chunk)
assert(not err, err)
if chunk then
vim.schedule(function()
require("dap.repl").append(chunk)
end)
end
end)
end
-- wait for delve to start
vim.defer_fn(function()
callback { type = "server", host = "127.0.0.1", port = port }
end, 100)
end
local function args_input()
vim.ui.input({ prompt = "Args: " }, function(input)
return vim.split(input or "", " ")
end)
end
local function get_arguments()
local co = coroutine.running()
if co then
return coroutine.create(function()
local args = args_input()
coroutine.resume(co, args)
end)
else
return args_input()
end
end
dap.configuration = {
{
type = "go",
name = "Debug",
request = "launch",
program = "${file}",
},
{
type = "go",
name = "Debug (Arguments)",
request = "launch",
program = "${file}",
args = get_arguments,
},
{
type = "go",
name = "Debug Package",
request = "launch",
program = "${fileDirname}",
},
{
type = "go",
name = "Attach",
mode = "local",
request = "attach",
processId = require("dap.utils").pick_process,
},
{
type = "go",
name = "Debug test",
request = "launch",
mode = "test",
program = "${file}",
},
{
type = "go",
name = "Debug test (go.mod)",
request = "launch",
mode = "test",
program = "./${relativeFileDirname}",
},
}
-- sets ups nvim-dap for Go in one function call.
function dap.setup()
vim.deprecate(
"gopher.dap",
"you might consider setting up `nvim-dap` manually, or using another plugin(https://github.com/leoluz/nvim-dap-go)",
"v0.1.6",
"gopher"
)
local ok, d = pcall(require, "dap")
assert(ok, "gopher.nvim dependency error: dap not installed")
d.adapters.go = dap.adapter
d.configurations.go = dap.configuration
end
return dap

98
lua/gopher/dap/config.lua
View file

@ -1,98 +0,0 @@
---@diagnostic disable: param-type-mismatch
local function get_arguments()
local function get()
vim.ui.input({ prompt = "Args: " }, function(input)
return vim.split(input or "", " ") ---@diagnostic disable-line: missing-parameter
end)
end
local co = coroutine.running()
if co then
return coroutine.create(function()
local args = get()
coroutine.resume(co, args)
end)
else
return get()
end
end
return {
adapter = function(callback, config)
local handle, pid_or_err
local stdout = vim.loop.new_pipe(false)
local host = config.host or "127.0.0.1"
local port = config.port or "38697"
local addr = string.format("%s:%s", host, port)
local opts = {
stdio = { nil, stdout },
args = { "dap", "-l", addr },
detached = true,
}
handle, pid_or_err = vim.loop.spawn("dlv", opts, function(code)
stdout:close()
handle:close()
if code ~= 0 then
print("dlv exited with code", code)
end
end)
assert(handle, "Error running dlv: " .. tostring(pid_or_err))
stdout:read_start(function(err, chunk)
assert(not err, err)
if chunk then
vim.schedule(function()
require("dap.repl").append(chunk)
end)
end
end)
-- Wait for delve to start
vim.defer_fn(function()
callback { type = "server", host = "127.0.0.1", port = port }
end, 100)
end,
configuration = {
{
type = "go",
name = "Debug",
request = "launch",
program = "${file}",
},
{
type = "go",
name = "Debug (Arguments)",
request = "launch",
program = "${file}",
args = get_arguments,
},
{
type = "go",
name = "Debug Package",
request = "launch",
program = "${fileDirname}",
},
{
type = "go",
name = "Attach",
mode = "local",
request = "attach",
processId = require("dap.utils").pick_process,
},
{
type = "go",
name = "Debug test",
request = "launch",
mode = "test",
program = "${file}",
},
{
type = "go",
name = "Debug test (go.mod)",
request = "launch",
mode = "test",
program = "./${relativeFileDirname}",
},
},
}

13
lua/gopher/dap/init.lua
View file

@ -1,13 +0,0 @@
local M = {}
---setup nvim-dap for golang using
function M.setup()
local cfg = require "gopher.dap.config"
local u = require "gopher._utils"
local dap = u.sreq "dap"
dap.adapters.go = cfg.adapter
dap.configurations.go = cfg.configuration
end
return M

141
lua/gopher/gotests.lua
View file

@ -1,73 +1,104 @@
---@toc_entry Generating unit tests boilerplate
---@tag gopher.nvim-gotests
---@text gotests is utilizing the `gotests` tool to generate unit tests boilerplate.
---@usage
--- - generate unit test for spesisfic function/method
--- - to specift the function/method put your cursor on it
--- - run `:GoTestAdd`
---
--- - generate unit tests for all functions/methods in current file
--- - run `:GoTestsAll`
---
--- - generate unit tests only for exported(public) functions/methods
--- - 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
---
---@tag gopher.nvim-gotests-named
---@text
--- if you prefare using named tests, you can enable it in the config.
--- but you would need to install `gotests@develop` because stable version doesn't support this feature.
--- you can do it with:
--- >lua
--- -- simply run go get in your shell:
--- go install github.com/cweill/gotests/...@develop
---
--- -- if you want to install it within neovim, you can use one of this:
---
--- vim.fn.jobstart("go install github.com/cweill/gotests/...@develop")
---
--- -- or if you want to use mason:
--- require("mason-tool-installer").setup {
--- ensure_installed = {
--- { "gotests", version = "develop" },
--- }
--- }
--- <
---
--- if you choose to install `gotests` within neovim, i recommend adding it to your `build` section in your |lazy.nvim|
local c = require "gopher.config"
local ts_utils = require "gopher._utils.ts"
local r = require "gopher._utils.runner"
local u = require "gopher._utils"
local M = {}
---@param cmd_args table
local function run(cmd_args)
local Job = require "plenary.job"
local c = require("gopher.config").config.commands
Job:new({
command = c.gotests,
args = cmd_args,
on_exit = function(_, retval)
if retval ~= 0 then
u.notify("command 'go " .. unpack(cmd_args) .. "' exited with code " .. retval, "error")
return
end
u.notify("unit test(s) generated", "info")
end,
}):start()
end
local log = require "gopher._utils.log"
local gotests = {}
---@param args table
---@private
local function add_test(args)
local fpath = vim.fn.expand "%" ---@diagnostic disable-line: missing-parameter
if c.gotests.named then
table.insert(args, "-named")
end
if c.gotests.template_dir then
table.insert(args, "-template_dir")
table.insert(args, c.gotests.template_dir)
end
if c.gotests.template ~= "default" then
table.insert(args, "-template")
table.insert(args, c.gotests.template)
end
table.insert(args, "-w")
table.insert(args, fpath)
run(args)
table.insert(args, vim.fn.expand "%")
log.debug("generating tests with args: ", args)
return r.sync(c.commands.gotests, {
args = args,
on_exit = function(data, status)
if not status == 0 then
error("gotests failed: " .. data)
end
u.notify "unit test(s) generated"
end,
})
end
---generate unit test for one function
---@param parallel boolean
function M.func_test(parallel)
local ts_utils = require "gopher._utils.ts"
-- generate unit test for one function
function gotests.func_test()
local ns = ts_utils.get_func_method_node_at_pos(unpack(vim.api.nvim_win_get_cursor(0)))
if ns == nil or ns.name == nil then
u.notify("cursor on func/method and execute the command again", "info")
u.notify("cursor on func/method and execute the command again", vim.log.levels.WARN)
return
end
local cmd_args = { "-only", ns.name }
if parallel then
table.insert(cmd_args, "-parallel")
end
add_test(cmd_args)
add_test { "-only", ns.name }
end
---generate unit tests for all functions in current file
---@param parallel boolean
function M.all_tests(parallel)
local cmd_args = { "-all" }
if parallel then
table.insert(cmd_args, "-parallel")
end
add_test(cmd_args)
-- generate unit tests for all functions in current file
function gotests.all_tests()
add_test { "-all" }
end
---generate unit tests for all exported functions
---@param parallel boolean
function M.all_exported_tests(parallel)
local cmd_args = {}
if parallel then
table.insert(cmd_args, "-parallel")
end
table.insert(cmd_args, "-exported")
add_test(cmd_args)
-- generate unit tests for all exported functions
function gotests.all_exported_tests()
add_test { "-exported" }
end
return M
return gotests

84
lua/gopher/health.lua
View file

@ -1,44 +1,70 @@
local c = require("gopher.config").config.commands
local health = {}
local cmd = require("gopher.config").commands
local u = require "gopher._utils.health_util"
local requried_for_work_msg = "Gopher.nvim will not work without it!"
local M = {
_required = {
plugins = {
{ lib = "plenary", help = requried_for_work_msg },
{ lib = "nvim-treesitter", help = requried_for_work_msg },
{ lib = "dap", help = "Required for set upping debugger" },
local deps = {
plugin = {
{ lib = "dap", msg = "required for `gopher.dap`", optional = true },
{ lib = "plenary", msg = "required for everyting in gopher.nvim", optional = false },
{ lib = "nvim-treesitter", msg = "required for everyting in gopher.nvim", optional = false },
},
bin = {
{
bin = cmd.go,
msg = "required for `:GoGet`, `:GoMod`, `:GoGenerate`, `:GoWork`, `:GoInstallDeps`",
optional = false,
},
binarys = {
{ bin = c.go, help = "required for GoMod, GoGet, GoGenerate command" },
{ bin = c.gomodifytags, help = "required for modify struct tags" },
{ bin = c.impl, help = "required for interface implementing" },
{ bin = c.gotests, help = "required for test(s) generation" },
{ bin = c.dlv, help = "required for debugger(nvim-dap)" },
{ bin = cmd.gomodifytags, msg = "required for `:GoTagAdd`, `:GoTagRm`", optional = false },
{ bin = cmd.impl, msg = "required for `:GoImpl`", optional = false },
{ bin = cmd.iferr, msg = "required for `:GoIfErr`", optional = false },
{
bin = cmd.gotests,
msg = "required for `:GoTestAdd`, `:GoTestsAll`, `:GoTestsExp`",
optional = false,
},
{ bin = cmd.dlv, msg = "required for debugging, (`nvim-dap`, `gopher.dap`)", optional = true },
},
treesitter = {
{ parser = "go", msg = "required for `gopher.nvim`", optional = false },
},
}
function M.check()
local health = vim.health or require "health"
local u = require "gopher._utils._health"
health.report_start "Required plugins"
for _, plugin in ipairs(M._required.plugins) do
if u.lualib_is_found(plugin.lib) then
health.report_ok(plugin.lib .. " installed.")
function health.check()
u.start "required plugins"
for _, plugin in ipairs(deps.plugin) do
if u.is_lualib_found(plugin.lib) then
u.ok(plugin.lib .. " installed")
else
health.report_error(plugin.lib .. " not found. " .. plugin.help)
if plugin.optional then
u.warn(plugin.lib .. " not found, " .. plugin.msg)
else
u.error(plugin.lib .. " not found, " .. plugin.msg)
end
end
end
health.report_start "Required go tools"
for _, binary in ipairs(M._required.binarys) do
if u.binary_is_found(binary.bin) then
health.report_ok(binary.bin .. " installed")
u.start "required binaries"
u.info "all those binaries can be installed by `:GoInstallDeps`"
for _, bin in ipairs(deps.bin) do
if u.is_binary_found(bin.bin) then
u.ok(bin.bin .. " installed")
else
health.report_warn(binary.bin .. " is not installed but " .. binary.help)
if bin.optional then
u.warn(bin.bin .. " not found, " .. bin.msg)
else
u.error(bin.bin .. " not found, " .. bin.msg)
end
end
end
u.start "required treesitter parsers"
for _, parser in ipairs(deps.treesitter) do
if u.is_treesitter_parser_available(parser.parser) then
u.ok(parser.parser .. " parser installed")
else
u.error(parser.parser .. " parser not found, " .. parser.msg)
end
end
end
return M
return health

27
lua/gopher/iferr.lua
View file

@ -1,21 +1,26 @@
---Add iferr declaration
---That's Lua of vimscript implementation of:
---github.com/koron/iferr
return function()
local c = require("gopher.config").config.commands
local u = require "gopher._utils"
---@toc_entry Iferr
---@tag gopher.nvim-iferr
---@text if you're using `iferr` tool, this module provides a way to automatically insert `if err != nil` check.
---@usage execute `:GoIfErr` near any err variable to insert the check
local c = require "gopher.config"
local log = require "gopher._utils.log"
local iferr = {}
-- That's Lua implementation: github.com/koron/iferr
function iferr.iferr()
local boff = vim.fn.wordcount().cursor_bytes
local cmd = (c.iferr .. " -pos " .. boff)
local data = vim.fn.systemlist(cmd, vim.fn.bufnr "%")
local pos = vim.fn.getcurpos()[2]
local data = vim.fn.systemlist((c.commands.iferr .. " -pos " .. boff), vim.fn.bufnr "%")
if vim.v.shell_error ~= 0 then
u.notify("command " .. cmd .. " exited with code " .. vim.v.shell_error, "error")
return
error("iferr failed: " .. data)
log.error("failed. output: " .. data)
end
local pos = vim.fn.getcurpos()[2]
vim.fn.append(pos, data)
vim.cmd [[silent normal! j=2j]]
vim.fn.setpos(".", pos)
end
return iferr

79
lua/gopher/impl.lua
View file

@ -1,12 +1,43 @@
---@toc_entry Auto implementation of interface methods
---@tag gopher.nvim-impl
---@text 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
--- }
--- <
local c = require("gopher.config").commands
local r = require "gopher._utils.runner"
local ts_utils = require "gopher._utils.ts"
local u = require "gopher._utils"
local impl = {}
---@return string
---@private
local function get_struct()
local ts_utils = require "gopher._utils.ts"
local ns = ts_utils.get_struct_node_at_pos(unpack(vim.api.nvim_win_get_cursor(0)))
if ns == nil then
u.notify("put cursor on a struct or specify a receiver", "info")
u.deferred_notify("put cursor on a struct or specify a receiver", vim.log.levels.INFO)
return ""
end
@ -18,10 +49,7 @@ local function get_struct()
return ns.name
end
return function(...)
local c = require("gopher.config").config.commands
local Job = require "plenary.job"
function impl.impl(...)
local args = { ... }
local iface, recv_name = "", ""
local recv = get_struct()
@ -30,7 +58,7 @@ return function(...)
iface = vim.fn.input "impl: generating method stubs for interface: "
vim.cmd "redraw!"
if iface == "" then
u.notify("usage: GoImpl f *File io.Reader", "info")
u.deferred_notify("usage: GoImpl f *File io.Reader", vim.log.levels.INFO)
return
end
elseif #args == 1 then -- :GoImpl io.Reader
@ -48,28 +76,23 @@ return function(...)
recv = string.format("%s %s", recv_name, recv)
end
-- stylua: ignore
local cmd_args = {
"-dir", vim.fn.fnameescape(vim.fn.expand "%:p:h"), ---@diagnostic disable-line: missing-parameter
recv,
iface
}
local res_data
Job:new({
command = c.impl,
args = cmd_args,
on_exit = function(data, retval)
if retval ~= 0 then
u.notify("command 'impl " .. unpack(cmd_args) .. "' exited with code " .. retval, "error")
return
local output = r.sync(c.impl, {
args = {
"-dir",
vim.fn.fnameescape(vim.fn.expand "%:p:h" --[[@as string]]),
recv,
iface,
},
on_exit = function(data, status)
if not status == 0 then
error("impl failed: " .. data)
end
res_data = data:result()
end,
}):sync()
})
local pos = vim.fn.getcurpos()[2]
table.insert(res_data, 1, "")
vim.fn.append(pos, res_data)
table.insert(output, 1, "")
vim.fn.append(pos, output)
end
return impl

71
lua/gopher/init.lua
View file

@ -1,5 +1,70 @@
local GOPHER = {}
--- *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.setup = require("gopher.config").setup
--- Table of Contents
---@tag gopher.nvim-table-of-contents
---@toc
return GOPHER
local log = require "gopher._utils.log"
local tags = require "gopher.struct_tags"
local tests = require "gopher.gotests"
local gocmd = require("gopher._utils.runner.gocmd").run
local gopher = {}
---@toc_entry Setup
---@tag gopher.nvim-setup
---@text 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)
---@param user_config gopher.Config
gopher.setup = function(user_config)
log.debug "setting up config"
require("gopher.config").setup(user_config)
log.debug(vim.inspect(user_config))
end
---@toc_entry Install dependencies
---@tag gopher.nvim-install-deps
---@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 ues lua api.
gopher.install_deps = require("gopher.installer").install_deps
gopher.impl = require("gopher.impl").impl
gopher.iferr = require("gopher.iferr").iferr
gopher.comment = require "gopher.comment"
gopher.tags = {
add = tags.add,
rm = tags.remove,
}
gopher.test = {
add = tests.func_test,
exported = tests.all_exported_tests,
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
return gopher

27
lua/gopher/installer.lua
View file

@ -1,3 +1,8 @@
local c = require("gopher.config").commands
local r = require "gopher._utils.runner"
local u = require "gopher._utils"
local installer = {}
local urls = {
gomodifytags = "github.com/fatih/gomodifytags",
impl = "github.com/josharian/impl",
@ -8,28 +13,24 @@ local urls = {
---@param pkg string
local function install(pkg)
local Job = require "plenary.job"
local u = require "gopher._utils"
local url = urls[pkg] .. "@latest"
Job:new({
command = "go",
r.sync(c.go, {
args = { "install", url },
on_exit = function(_, retval)
if retval ~= 0 then
u.notify("command 'go install " .. url .. "' exited with code " .. retval, "error")
on_exit = function(data, status)
if not status == 0 then
error("go install failed: " .. data)
return
end
u.notify("install " .. url .. " finished", "info ")
u.notify("installed: " .. url)
end,
}):start()
})
end
---Install required go deps
return function()
function installer.install_deps()
for pkg, _ in pairs(urls) do
install(pkg)
end
end
return installer

77
lua/gopher/struct_tags.lua
View file

@ -1,11 +1,35 @@
local M = {}
---@toc_entry Modifty struct tags
---@tag gopher.nvim-struct-tags
---@text struct-tags is utilizing the `gomodifytags` tool to add or remove tags to struct fields.
---@usage - put your coursor on the struct
--- - run `:GoTagAdd json` to add json tags to struct fields
--- - run `:GoTagRm json` to remove json tags to struct fields
---
--- note: if you dont spesify the tag it will use `json` as default
---
--- simple example:
--- >go
--- // before
--- type User struct {
--- // ^ put your cursor here
--- // run `:GoTagAdd yaml`
--- ID int
--- Name string
--- }
---
--- // after
--- type User struct {
--- ID int `yaml:id`
--- Name string `yaml:name`
--- }
--- <
local ts_utils = require "gopher._utils.ts"
local r = require "gopher._utils.runner"
local c = require "gopher.config"
local struct_tags = {}
local function modify(...)
local ts_utils = require "gopher._utils.ts"
local Job = require "plenary.job"
local c = require("gopher.config").config.commands
local u = require "gopher._utils"
local fpath = vim.fn.expand "%" ---@diagnostic disable-line: missing-parameter
local ns = ts_utils.get_struct_node_at_pos(unpack(vim.api.nvim_win_get_cursor(0)))
if ns == nil then
@ -14,6 +38,7 @@ local function modify(...)
-- stylua: ignore
local cmd_args = {
"-transform", c.gotag.transform,
"-format", "json",
"-file", fpath,
"-w"
@ -40,40 +65,26 @@ local function modify(...)
table.insert(cmd_args, "json")
end
-- get result of "gomodifytags" works
local res_data
Job:new({
command = c.gomodifytags,
local output = r.sync(c.commands.gomodifytags, {
args = cmd_args,
on_exit = function(data, retval)
if retval ~= 0 then
u.notify(
"command 'gomodifytags " .. unpack(cmd_args) .. "' exited with code " .. retval,
"error"
)
return
on_exit = function(data, status)
if not status == 0 then
error("gotag failed: " .. data)
end
res_data = data:result()
end,
}):sync()
})
-- decode goted value
local tagged = vim.json.decode(table.concat(res_data))
local tagged = vim.json.decode(table.concat(output))
if
tagged.errors ~= nil
or tagged.lines == nil
or tagged["start"] == nil
or tagged["start"] == 0
then
u.notify("failed to set tags " .. vim.inspect(tagged), "error")
error("failed to set tags " .. vim.inspect(tagged))
end
for i, v in ipairs(tagged.lines) do
tagged.lines[i] = u.rtrim(v)
end
-- write goted tags
vim.api.nvim_buf_set_lines(
0,
tagged.start - 1,
@ -84,9 +95,8 @@ local function modify(...)
vim.cmd "write"
end
---add tags to struct under cursor
---@param ... unknown
function M.add(...)
-- add tags to struct under cursor
function struct_tags.add(...)
local arg = { ... }
if #arg == nil or arg == "" then
arg = { "json" }
@ -100,9 +110,8 @@ function M.add(...)
modify(unpack(cmd_args))
end
---remove tags to struct under cursor
---@param ... unknown
function M.remove(...)
-- remove tags to struct under cursor
function struct_tags.remove(...)
local arg = { ... }
if #arg == nil or arg == "" then
arg = { "json" }
@ -116,4 +125,4 @@ function M.remove(...)
modify(unpack(cmd_args))
end
return M
return struct_tags