Feature Request: "envFile" dap configuration attribute

[niklod]

Problem Statement

Request

Implement "envFile" attribute in "launch.json" dap configuration.

Possible profits

A more convenient way to manage dotenvs while debugging complex projects.

Description

According to VSCode debugger config https://code.visualstudio.com/docs/editor/debugging#_launchjson-attributes there is a very useful attribute "envFile" that helps manage big Dotenv files while debugging complex projects. Without this attribute, there is only one way to use .env files – "env" attribute.
Now it works properly, but after editing variables, we should constantly reload nvim-dap. A workflow like this is painful in my point of view

Ideas or possible solutions

No response

[mfussenegger]

I could be mistaken, but the linked documentation sounds as if envFile is a property that some of the debug adapters already support, not as if it's something that vscode handles in a special way?

Currently nvim-dap passes all properties 1:1 to the debug adapter, so if a debug adapter supports such a property it should already work

[ray-x]

FYI, the go extension from vs-code.

https://github.com/golang/vscode-go/blob/29bdea3492aa44c25d8f316505a6822856fa792f/src/utils/envUtils.ts#L22-L44

envFile seems to be a property defined by vscode extension (not only go, but also nodejs, python etc) instead of a standard dap property.

[niklod]

@mfussenegger @ray-x thanks for the research. Are there some workarounds to working with .env files in nvim-dap?

[ray-x]

seems you have to write lua code to load .env file line by line into env

[niklod]

Alright, got it. Thanks for helping guys!

[mfussenegger]

It would be possible to support envFile in a nvim-dap extension by using the enrich_config hook supported for adapters. See :h dap-adapter
It would need to check if there is a envFile property on the config, if so replace it with env with the content from the file and then call on_config with the modified configuration.

[benortiz]

@niklod or @ray-x would you mind sketching out what this code might look like? I'm using the adapter defined here and I'm having difficulty figuring out how I should modify it using the template from the dap-adapter help.

-- :h dap-adapter
local adapter = {
  type = 'server';
  host = '127.0.0.1';
  port = 8080;
  enrich_config = function(config, on_config)
    local final_config = vim.deepcopy(config)
    final_config.extra_property = 'This got injected by the adapter'
    on_config(final_config)
  end;
}

[ray-x]

If you read your .env into a lua list with you function env_read e.g.

envFileElem = env_read('.env')
vim.tbl_extend(final_config.env, envFileElem)

[niklod]

@benortiz honestly I have the same problem. I tried configure it like this:

  dap.adapters.go = function(callback, config)
    local adapter = {
      type = 'server';
      host = '127.0.0.1';
      port = 38697;
      enrich_config = function(config, on_config)
        local final_config = vim.deepcopy(config)

        local t = {}
        t["test_env"] = "test_value"

        vim.tbl_extend(final_config.env, t)

        on_config(final_config)
      end;
    }
    callback({type = "server", host = "127.0.0.1", port = 38697})
  end

But it doesn't work

[thanhdatvo]

@niklod did you figure it out yet?

[mfussenegger]

Turning this into a discussion because this is a debug adapter/extension issue.

[badloop]

Any movement on this? I'm at a point that this would be super helpful and would be willing to contribute if needed

[badloop]

So at the very least it appears that if you expose var_placeholders, a simple function could be written client side to expand the envFile to env vars in the configuration in memory like so:

dap = require('dap')
-- Parse out envFiles
for type, _ in pairs(dap.configurations) do
	for _, config in pairs(dap.configurations[type]) do
		if config.envFile then
			local filePath = config.envFile
			for key, fn in pairs(dap.get_placeholders()) do
				filePath = filePath:gsub(key, fn)
			end
			for line in io.lines(filePath) do
				local words = {}
				for word in string.gmatch(line, "[a-zA-Z0-9_]+") do
					table.insert(words, word)
				end
				if not config.env then
					config.env = {}
				end
				config.env[words[1]] = words[2]
			end
		end
	end
end

A more ideal situation would be to have this function within dap.lua in this plugin and have it execute and expand the env file when launching the individual configuration.

Thoughts?

[mfussenegger]

A more ideal situation would be to have this function within dap.lua in this plugin and have it execute and expand the env file when launching the individual configuration.

Given that envFile is not even supported by vscode, but instead added by specific extensions this won't happen.

Adding a more specific extension point for variables is tracked in #720

[badloop]

Ah I wasn't aware of that. Thanks for the info!

[AlexBieg]

I wasn't able to get the provided code working without a few tweaks. So for anyone else like me who is just looking to load the files this might be a solution. Two things to note:

1. I changed the regex from [a-zA-Z0-9_]+ to [^=]+ to avoid needing to figure out exactly all of the characters of the my env files.
2. The get_placeholders function just did not work for me at all. Maybe I was on an older version? Either way, I just used the full path for my env files and that worked fine

Code:

for type, _ in pairs(dap.configurations) do
	for _, config in pairs(dap.configurations[type]) do
		if config.envFile then
			local filePath = config.envFile
			for line in io.lines(filePath) do
				local words = {}
				for word in string.gmatch(line, "[^=]+") do
					table.insert(words, word)
				end
				if not config.env then
					config.env = {}
				end
				config.env[words[1]] = words[2]
			end
		end
	end
end

[niklod]

Also my final working solution:

enrich_config = function(finalConfig, on_config)
  local final_config = vim.deepcopy(finalConfig)

  -- Placeholder expansion for launch directives
  local placeholders = {
    ["${file}"] = function(_)
      return vim.fn.expand("%:p")
    end,
    ["${fileBasename}"] = function(_)
      return vim.fn.expand("%:t")
    end,
    ["${fileBasenameNoExtension}"] = function(_)
      return vim.fn.fnamemodify(vim.fn.expand("%:t"), ":r")
    end,
    ["${fileDirname}"] = function(_)
      return vim.fn.expand("%:p:h")
    end,
    ["${fileExtname}"] = function(_)
      return vim.fn.expand("%:e")
    end,
    ["${relativeFile}"] = function(_)
      return vim.fn.expand("%:.")
    end,
    ["${relativeFileDirname}"] = function(_)
      return vim.fn.fnamemodify(vim.fn.expand("%:.:h"), ":r")
    end,
    ["${workspaceFolder}"] = function(_)
      return vim.fn.getcwd()
    end,
    ["${workspaceFolderBasename}"] = function(_)
      return vim.fn.fnamemodify(vim.fn.getcwd(), ":t")
    end,
    ["${env:([%w_]+)}"] = function(match)
      return os.getenv(match) or ""
    end,
  }

  if final_config.envFile then
    local filePath = final_config.envFile
    for key, fn in pairs(placeholders) do
      filePath = filePath:gsub(key, fn)
    end

    for line in io.lines(filePath) do
      local words = {}
      for word in string.gmatch(line, "[^=]+") do
        table.insert(words, word)
      end
      if not final_config.env then
        final_config.env = {}
      end
      final_config.env[words[1]] = words[2]
    end
  end

  on_config(final_config)
end,

adapter initialization example:

dap.adapters.go = {
  type = "server",
  port = 38697,
  executable = {
    command = "dlv",
    args = { "dap", "-l", "127.0.0.1:38697" },
  },
  enrich_config = function(finalConfig, on_config)
    local final_config = vim.deepcopy(finalConfig)

    -- Placeholder expansion for launch directives
    local placeholders = {
      ["${file}"] = function(_)
        return vim.fn.expand("%:p")
      end,
      ["${fileBasename}"] = function(_)
        return vim.fn.expand("%:t")
      end,
      ["${fileBasenameNoExtension}"] = function(_)
        return vim.fn.fnamemodify(vim.fn.expand("%:t"), ":r")
      end,
      ["${fileDirname}"] = function(_)
        return vim.fn.expand("%:p:h")
      end,
      ["${fileExtname}"] = function(_)
        return vim.fn.expand("%:e")
      end,
      ["${relativeFile}"] = function(_)
        return vim.fn.expand("%:.")
      end,
      ["${relativeFileDirname}"] = function(_)
        return vim.fn.fnamemodify(vim.fn.expand("%:.:h"), ":r")
      end,
      ["${workspaceFolder}"] = function(_)
        return vim.fn.getcwd()
      end,
      ["${workspaceFolderBasename}"] = function(_)
        return vim.fn.fnamemodify(vim.fn.getcwd(), ":t")
      end,
      ["${env:([%w_]+)}"] = function(match)
        return os.getenv(match) or ""
      end,
    }

    if final_config.envFile then
      local filePath = final_config.envFile
      for key, fn in pairs(placeholders) do
        filePath = filePath:gsub(key, fn)
      end

      for line in io.lines(filePath) do
        local words = {}
        for word in string.gmatch(line, "[^=]+") do
          table.insert(words, word)
        end
        if not final_config.env then
          final_config.env = {}
        end
        final_config.env[words[1]] = words[2]
      end
    end

    on_config(final_config)
  end,
}

[plamen-kutinchev]

I have pasted your solution because I need it also but I don't know how to input the file. How to configure the file for the env which to look for ?

[niklod]

If i understand your question correctly, you have to create .vscode directory in the root of the project and then create file launch.json inside this directory.
Example launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "service",
      "type": "go",
      "request": "launch",
      "program": "${workspaceFolder}/cmd/service/",
      "envFile": "${workspaceFolder}/.env"
    }
  ]
}

I use it primarily with golang

[niklod]

you can see more examples here and here