all repos

gopher.nvim @ a995af3415d80e4d8ece4074b132a811a81aa54b

Minimalistic plugin for Go development

gopher.nvim/lua/gopher/dap.lua(view raw) 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
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