turbo-debug.nvim/lua/turbo-debug/adapters/init.lua

local config = require("turbo-debug.config")

local M = {}

local mason_bin = vim.fn.stdpath("data") .. "/mason/bin/"

function M.find_executable(names)
  for _, name in ipairs(names) do
    if vim.fn.executable(name) == 1 then return name end
    local mason_path = mason_bin .. name
    if vim.fn.executable(mason_path) == 1 then return mason_path end
  end
end

function M.register(dap, name, adapter, configurations, filetypes)
  if dap.adapters[name] then return end
  dap.adapters[name] = adapter
  for _, ft in ipairs(filetypes) do
    dap.configurations[ft] = dap.configurations[ft] or configurations
  end
end

-- simple executable adapters (inlined — no separate files needed)
local function register_simple_adapters(dap)
  local simple = {
    { "netcoredbg", { "netcoredbg" }, {
      type = "executable", args = { "--interpreter=vscode" },
    }, { {
      type = "netcoredbg", request = "launch", name = "Launch .NET",
      program = function() return vim.fn.input("Path to DLL: ", vim.fn.getcwd() .. "/bin/Debug/", "file") end,
    } }, { "cs" } },

    { "java", { "java-debug-adapter" }, {
      type = "executable",
    }, { {
      type = "java", request = "launch", name = "Launch class",
      mainClass = function() return vim.fn.input("Main class: ") end,
      cwd = "${workspaceFolder}",
    } }, { "java" } },

    { "kotlin", { "kotlin-debug-adapter" }, {
      type = "executable",
    }, { {
      type = "kotlin", request = "launch", name = "Launch main",
      mainClass = function() return vim.fn.input("Main class: ") end,
      projectRoot = "${workspaceFolder}",
    } }, { "kotlin" } },

    { "php", { "php-debug-adapter" }, {
      type = "executable",
    }, { {
      type = "php", request = "launch", name = "Listen for Xdebug", port = 9003,
    } }, { "php" } },

    { "rdbg", { "rdbg" }, {
      type = "server", port = "${port}",
      executable = { command = nil, args = { "-n", "--open", "--port", "${port}", "-c", "--", "ruby", "${file}" } },
    }, { {
      type = "rdbg", request = "launch", name = "Launch file", command = "ruby", script = "${file}",
    }, {
      type = "rdbg", request = "attach", name = "Attach", localfsMap = "${workspaceFolder}",
    } }, { "ruby" } },
  }

  for _, s in ipairs(simple) do
    local name, exe_names, adapter_tpl, configurations, filetypes = s[1], s[2], s[3], s[4], s[5]
    local exe = M.find_executable(exe_names)
    if exe then
      local adapter = vim.deepcopy(adapter_tpl)
      adapter.command = adapter.command or exe
      if adapter.executable then adapter.executable.command = exe end
      M.register(dap, name, adapter, configurations, filetypes)
    end
  end

  -- lua/neovim (osv) — optional, skip if not installed
  local ok, osv = pcall(require, "osv")
  if ok then
    M.register(dap, "nlua", {
      type = "server", host = "127.0.0.1",
      port = function() return osv.launch({ port = 0 }) end,
    }, { {
      type = "nlua", request = "attach", name = "Attach to running Neovim",
    } }, { "lua" })
  end
end

function M.setup()
  if not config.opts.builtin_adapters then return end

  local dap = require("dap")

  -- load adapters with non-trivial logic from separate files
  for _, name in ipairs({ "python", "go", "c", "javascript" }) do
    local ok, adapter_mod = pcall(require, "turbo-debug.adapters." .. name)
    if ok and adapter_mod.register then
      adapter_mod.register(dap)
    end
  end

  -- register simple adapters inlined above
  register_simple_adapters(dap)

  -- apply user adapter overrides (last — wins over everything)
  for name, adapter_config in pairs(config.opts.adapters) do
    if adapter_config.adapter then dap.adapters[name] = adapter_config.adapter end
    if adapter_config.configurations then dap.configurations[name] = adapter_config.configurations end
  end
end

return M