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

lua/gopher/_utils/init.lua

@@ -1,5 +1,7 @@
 local utils = {}
 
+local TITLE = "gopher.nvim"
+
 ---@param t table
 ---@return boolean
 function utils.is_tbl_empty(t)
@@ -10,13 +12,24 @@ function utils.is_tbl_empty(t)
 end
 
 ---@param msg string
----@param lvl any
+---@param lvl number
 function utils.deferred_notify(msg, lvl)
   vim.defer_fn(function()
-    vim.notify(msg, lvl)
+    vim.notify(msg, lvl, {
+      title = TITLE,
+    })
   end, 0)
 end
 
+---@param msg string
+---@param lvl? number
+function utils.notify(msg, lvl)
+  lvl = lvl or vim.log.levels.INFO
+  vim.notify(msg, lvl, {
+    title = TITLE,
+  })
+end
+
 -- safe require
 ---@param  module string module name
 function utils.sreq(module)

lua/gopher/_utils/runner/gocmd.lua

@@ -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

lua/gopher/_utils/runner/init.lua

@@ -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()
+  return output
+end
+
+return runner

lua/gopher/gotests.lua

@@ -1,74 +1,45 @@
 local c = require("gopher.config").commands
-local u = require "gopher._utils"
 local ts_utils = require "gopher._utils.ts"
-local Job = require "plenary.job"
+local r = require "gopher._utils.runner"
+local u = require "gopher._utils"
 local gotests = {}
 
----@param cmd_args table
-local function run(cmd_args)
-  Job:new({
-    command = c.gotests,
-    args = cmd_args,
-    on_exit = function(_, retval)
-      if retval ~= 0 then
-        u.deferred_notify(
-          "command '" .. c.gotests .. " " .. unpack(cmd_args) .. "' exited with code " .. retval,
-          vim.log.levels.ERROR
-        )
-        return
-      end
-
-      u.deferred_notify("unit test(s) generated", vim.log.levels.INFO)
-    end,
-  }):start()
-end
-
 ---@param args table
 local function add_test(args)
-  local fpath = vim.fn.expand "%" ---@diagnostic disable-line: missing-parameter
   table.insert(args, "-w")
-  table.insert(args, fpath)
-  run(args)
+  table.insert(args, vim.fn.expand "%")
+
+  return r.sync(c.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 gotests.func_test(parallel)
+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.deferred_notify("cursor on func/method and execute the command again", vim.log.levels.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 gotests.all_tests(parallel)
-  local cmd_args = { "-all" }
-  if parallel then
-    table.insert(cmd_args, "-parallel")
-  end
-
-  add_test(cmd_args)
+function gotests.all_tests()
+  add_test { "-all" }
 end
 
 ---generate unit tests for all exported functions
----@param parallel boolean
-function gotests.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)
+function gotests.all_exported_tests()
+  add_test { "-exported" }
 end
 
 return gotests

lua/gopher/iferr.lua

@@ -1,22 +1,16 @@
 local c = require("gopher.config").commands
-local u = require "gopher._utils"
 local iferr = {}
 
 -- That's Lua of vimscript implementation of: github.com/koron/iferr
-iferr.iferr = function()
+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.iferr .. " -pos " .. boff), vim.fn.bufnr "%")
   if vim.v.shell_error ~= 0 then
-    u.deferred_notify(
-      "command " .. cmd .. " exited with code " .. vim.v.shell_error,
-      vim.log.levels.ERROR
-    )
-    return
+    error("iferr failed: " .. data)
   end
 
-  local pos = vim.fn.getcurpos()[2]
   vim.fn.append(pos, data)
   vim.cmd [[silent normal! j=2j]]
   vim.fn.setpos(".", pos)

lua/gopher/impl.lua

@@ -1,5 +1,5 @@
 local c = require("gopher.config").commands
-local Job = require "plenary.job"
+local r = require "gopher._utils.runner"
 local ts_utils = require "gopher._utils.ts"
 local u = require "gopher._utils"
 local impl = {}
@@ -47,33 +47,23 @@ function impl.impl(...)
     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.deferred_notify(
-          "command '" .. c.impl .. " " .. unpack(cmd_args) .. "' exited with code " .. retval,
-          vim.log.levels.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

lua/gopher/init.lua

@@ -1,6 +1,6 @@
 local tags = require "gopher.struct_tags"
 local tests = require "gopher.gotests"
-local uc = require "gopher._utils.commands"
+local gocmd = require("gopher._utils.runner.gocmd").run
 local gopher = {}
 
 gopher.setup = require("gopher.config").setup
@@ -17,19 +17,19 @@ gopher.test_exported = tests.all_exported_tests
 gopher.tests_all = tests.all_tests
 
 gopher.get = function(...)
-  uc("get", ...)
+  gocmd("get", { ... })
 end
 
 gopher.mod = function(...)
-  uc("mod", ...)
+  gocmd("mod", { ... })
 end
 
 gopher.generate = function(...)
-  uc("generate", ...)
+  gocmd("generate", { ... })
 end
 
 gopher.work = function(...)
-  uc("work", ...)
+  gocmd("work", { ... })
 end
 
 return gopher