Oleksandr Smirnov
6a3924cee5
* feat(json2go): implement * feat(json2go): support manual input * chore(readme): add json2go * chore(docs): add docs
137 lines
4 KiB
Lua
137 lines
4 KiB
Lua
---@toc_entry json2go
|
|
---@tag gopher.nvim-json2go
|
|
---@text
|
|
--- Convert json to go type annotations.
|
|
---
|
|
---@usage
|
|
--- `:GoJson` opens a temporary buffer where you can paste or write JSON.
|
|
--- Saving the buffer (`:w` or `:wq`) automatically closes it and inserts the
|
|
--- generated Go struct into the original buffer at the cursor position.
|
|
---
|
|
--- Alternatively, you can pass JSON directly as an argument:
|
|
--- >vim
|
|
--- :GoJson {"name": "Alice", "age": 30}
|
|
--- <
|
|
|
|
local c = require "gopher.config"
|
|
local log = require "gopher._utils.log"
|
|
local u = require "gopher._utils"
|
|
local r = require "gopher._utils.runner"
|
|
local json2go = {}
|
|
|
|
---@dochide
|
|
---@param bufnr integer
|
|
---@param cpos integer
|
|
---@param type_ string
|
|
local function apply(bufnr, cpos, type_)
|
|
local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
|
|
local input_lines = u.remove_empty_lines(vim.split(type_, "\n"))
|
|
for i, line in pairs(input_lines) do
|
|
table.insert(lines, cpos + i, line)
|
|
end
|
|
vim.api.nvim_buf_set_lines(bufnr, 0, -1, true, lines)
|
|
end
|
|
|
|
-- Convert json string to go type.
|
|
---
|
|
---@param json_str string Json string that is going to be converted to go type.
|
|
---@return string? Go type, or nil if failed.
|
|
function json2go.transform(json_str)
|
|
local cmd = { c.commands.json2go }
|
|
if c.json2go.type_name then
|
|
table.insert(cmd, "-type", c.json2go.type_name)
|
|
end
|
|
|
|
local rs = r.sync(cmd, { stdin = json_str })
|
|
if rs.code ~= 0 then
|
|
u.notify("json2go: got this error: " .. rs.stdout, vim.log.levels.ERROR)
|
|
log.error("json2go: got this error: " .. rs.stdout)
|
|
return
|
|
end
|
|
return rs.stdout
|
|
end
|
|
|
|
---@dochide
|
|
---@param ocpos integer
|
|
local function interactive(ocpos)
|
|
local obuf = vim.api.nvim_get_current_buf()
|
|
local owin = vim.api.nvim_get_current_win()
|
|
|
|
-- setup the input window
|
|
local buf = vim.api.nvim_create_buf(false, true)
|
|
vim.cmd(c.json2go.interactive_cmd)
|
|
|
|
local win = vim.api.nvim_get_current_win()
|
|
vim.api.nvim_win_set_buf(win, buf)
|
|
vim.api.nvim_buf_set_name(buf, "[GoJson input]")
|
|
vim.api.nvim_set_option_value("filetype", "jsonc", { buf = buf })
|
|
vim.api.nvim_set_option_value("buftype", "acwrite", { buf = buf })
|
|
vim.api.nvim_set_option_value("swapfile", false, { buf = buf })
|
|
vim.api.nvim_set_option_value("bufhidden", "delete", { buf = buf })
|
|
vim.api.nvim_buf_set_lines(buf, 0, -1, false, {
|
|
"// Write your json here.",
|
|
"// Writing and quitting (:wq), will generate go struct under the cursor.",
|
|
"",
|
|
"",
|
|
})
|
|
|
|
vim.api.nvim_create_autocmd("BufLeave", { buffer = buf, command = "stopinsert" })
|
|
vim.api.nvim_create_autocmd("BufWriteCmd", {
|
|
buffer = buf,
|
|
once = true,
|
|
callback = function()
|
|
local input = vim.api.nvim_buf_get_lines(buf, 0, -1, true)
|
|
local inp = table.concat(
|
|
vim
|
|
.iter(input)
|
|
:filter(function(line)
|
|
local found = string.find(line, "^//.*")
|
|
return (not found) or (line == "")
|
|
end)
|
|
:totable(),
|
|
"\n"
|
|
)
|
|
|
|
local go_type = json2go.transform(inp)
|
|
if not go_type then
|
|
error "cound't convert json to go type"
|
|
end
|
|
|
|
vim.api.nvim_set_option_value("modified", false, { buf = buf })
|
|
apply(obuf, ocpos, go_type)
|
|
|
|
vim.api.nvim_set_current_win(owin)
|
|
vim.api.nvim_win_set_cursor(owin, { ocpos + 1, 0 })
|
|
|
|
vim.schedule(function()
|
|
pcall(vim.api.nvim_win_close, win, true)
|
|
pcall(vim.api.nvim_buf_delete, buf, {})
|
|
end)
|
|
end,
|
|
})
|
|
|
|
vim.cmd "normal! G"
|
|
vim.cmd "startinsert"
|
|
end
|
|
|
|
--- Converts json string to go type, and puts result under the cursor. If
|
|
--- [json_str] is nil, will open an interactive prompt (with cmd set in
|
|
--- config).
|
|
---
|
|
---@param json_str? string
|
|
function json2go.json2go(json_str)
|
|
local cur_line = vim.api.nvim_win_get_cursor(0)[1]
|
|
if not json_str then
|
|
interactive(cur_line)
|
|
return
|
|
end
|
|
|
|
local go_type = json2go.transform(json_str)
|
|
if not go_type then
|
|
error "cound't convert json to go type"
|
|
end
|
|
|
|
apply(0, cur_line, go_type)
|
|
end
|
|
|
|
return json2go
|