feat: Support dynamic filetype config evaluation - closes #21

Author: andrewferrier

SHOWCASE.md

@@ -43,6 +43,29 @@ The keys in the configuration are used like this:
 
 To see some examples, you can look at the [built-in configurations](lua/debugprint/filetypes.lua).
 
+### Dynamically creating filetype configurations
+
+It is also possible to dynamically create filetype configurations by specifying filetype configurations as callback functions that pass back the contents of the table above, rather than the contents of the table directly. For example:
+
+```lua
+local my_fileformat = function(opts)
+    -- Do some dynamic stuff to calculate my_left, my_right, my_mid_var etc...
+
+    return {
+        left = my_left,
+        right = my_right,
+        mid_var = my_mid_var,
+        right_var = my_right
+    }
+end
+
+require('debugprint').setup({ filetypes = { ["filetype"] = my_fileformat }})
+```
+
+The function you specify is invoked each time that a debug line is inserted. In the example above, `opts` is of type `DebugprintFileTypeFunctionParams`. This can be found documented in `lua/debugprint/types.lua`. This type is not stable and the contents are not guaranteed to stay the same between versions, although we'll try not to remove fields from it.
+
+Further documentation on this technique is not provided as this is an advanced approach and is left for the user.
+
 ## Use `console.info()` rather than `console.warn()` for JavaScript/TypeScript
 
 `debugprint` uses `console.warn()` by default for these languages ([explanation here](https://github.com/andrewferrier/debugprint.nvim/issues/72#issuecomment-1902469694)). However, some folks don't like this. You can change it to use `console.info()` instead like this:

lua/debugprint/filetype_config.lua

@@ -0,0 +1,61 @@
+local M = {}
+
+local utils = require("debugprint.utils")
+
+---@param fn function(DebugprintFileTypeConfigParams):DebugprintFileTypeConfig
+---@return DebugprintFileTypeConfig
+local get_function_wrapped_config = function(fn)
+    local bufnr = vim.fn.bufnr()
+
+    local result = fn({
+        effective_filetypes = utils.get_effective_filetypes(),
+        bufnr = bufnr,
+        file_path = vim.api.nvim_buf_get_name(bufnr),
+    })
+
+    return result
+end
+
+---@param filetypes DebugprintFileTypeConfigOrDynamic[]
+---@return DebugprintFileTypeConfig?
+M.get = function(filetypes)
+    local effective_filetypes = utils.get_effective_filetypes()
+    local config = {}
+    local found_config = false
+
+    for _, effective_filetype in ipairs(effective_filetypes) do
+        ---@type DebugprintFileTypeConfigOrDynamic
+        local entry = filetypes[effective_filetype]
+
+        if entry ~= nil then
+            found_config = true
+
+            local filetype_contents
+
+            if type(entry) == "function" then
+                filetype_contents = get_function_wrapped_config(entry)
+            else
+                filetype_contents = entry
+            end
+            ---@cast filetype_contents DebugprintFileTypeConfig
+
+            -- Combine all valid configs into the same object. This seems to
+            -- make sense as an approach; the only case where I've found where
+            -- this applies so far is ["bash", "sh"]. If this causes problems we
+            -- may need to come up with something more sophisticated.
+            config = vim.tbl_deep_extend(
+                "keep",
+                vim.deepcopy(filetype_contents),
+                config
+            )
+        end
+    end
+
+    if not found_config then
+        return nil
+    else
+        return config
+    end
+end
+
+return M

lua/debugprint/init.lua

@@ -112,34 +112,6 @@ local get_debugline_textcontent = function(opts, fileconfig)
     return line
 end
 
----@return DebugprintFileTypeConfig?
-local get_filetype_config = function()
-    local effective_filetypes = utils.get_effective_filetypes()
-    local config = {}
-    local found_config = false
-
-    for _, effective_filetype in ipairs(effective_filetypes) do
-        if global_opts.filetypes[effective_filetype] ~= nil then
-            found_config = true
-            -- Combine all valid configs into the same object. This seems to
-            -- make sense as an approach; the only case where I've found where
-            -- this applies so far is ["bash", "sh"]. If this causes problems we
-            -- may need to come up with something more sophisticated.
-            config = vim.tbl_deep_extend(
-                "keep",
-                vim.deepcopy(global_opts.filetypes[effective_filetype]),
-                config
-            )
-        end
-    end
-
-    if not found_config then
-        return nil
-    else
-        return config
-    end
-end
-
 ---@param opts DebugprintFunctionOptionsInternal
 ---@param fileconfig DebugprintFileTypeConfig
 ---@return string
@@ -175,10 +147,11 @@ end
 local get_debugprint_line = function(opts)
     local line_to_insert
 
-    local fileconfig = get_filetype_config()
+    local filetype_config =
+        require("debugprint.filetype_config").get(global_opts.filetypes)
 
-    if fileconfig ~= nil then
-        line_to_insert = construct_debugprint_line(opts, fileconfig)
+    if filetype_config ~= nil then
+        line_to_insert = construct_debugprint_line(opts, filetype_config)
     else
         line_to_insert = utils_errors.construct_error_line(
             "No debugprint configuration for filetype "
@@ -286,7 +259,8 @@ M.debugprint = function(opts)
     end
 
     if opts.variable == true then
-        local filetype_config = get_filetype_config()
+        local filetype_config =
+            require("debugprint.filetype_config").get(global_opts.filetypes)
 
         if filetype_config then
             opts.variable_name = utils.get_variable_name(
@@ -438,7 +412,7 @@ M._get_global_opts = function()
     return global_opts
 end
 
----@param filetypes DebugprintFileTypeConfig[]
+---@param filetypes DebugprintFileTypeConfigOrDynamic[]
 ---@return nil
 M.add_custom_filetypes = function(filetypes)
     vim.validate({

lua/debugprint/types.lua

@@ -12,6 +12,14 @@
 ---@field display_location? boolean
 ---@field display_snippet? boolean
 
+---@class DebugprintFileTypeConfigParams
+---@field effective_filetypes string[]
+---@field file_path string
+---@field bufnr integer
+
+---@alias DebugprintFileTypeConfigOrDynamic DebugprintFileTypeConfig |
+---                                         function(DebugprintFileTypeConfigParams):DebugprintFileTypeConfig)
+
 ---@class DebugprintGlobalOptions
 ---@field keymaps? DebugprintKeymapOptions
 ---@field commands? DebugprintCommandOptions
@@ -21,7 +29,7 @@
 ---@field move_to_debugline? boolean
 ---@field notify_for_registers? boolean
 ---@field highlight_lines? boolean
----@field filetypes? DebugprintFileTypeConfig[]
+---@field filetypes? DebugprintFileTypeConfigOrDynamic[]
 ---@field print_tag? string
 ---Deprecated
 ---@field create_keymaps? boolean

tests/debugprint.lua

@@ -3073,3 +3073,78 @@ describe("register support", function()
         })
     end)
 end)
+
+describe("dynamic filetype configuration", function()
+    before_each(function()
+        teardown()
+    end)
+
+    after_each(function()
+        teardown()
+    end)
+
+    it("can capture one plain statement", function()
+        debugprint.setup({
+            filetypes = {
+                ["lua"] = function(opts)
+                    assert.equals(type(opts.bufnr), "number")
+                    assert.equals(type(opts.file_path), "string")
+                    assert.are.same(opts.effective_filetypes, { "lua" })
+
+                    return {
+                        left = "blah('",
+                        right = "')",
+                    }
+                end,
+            },
+        })
+
+        local filename = init_file({
+            "foo",
+            "bar",
+        }, "lua", 1, 0)
+
+        feedkeys("g?p")
+
+        check_lines({
+            "foo",
+            "blah('DEBUGPRINT[1]: " .. filename .. ":1 (after foo)')",
+            "bar",
+        })
+    end)
+
+    it("can capture one variable statement", function()
+        debugprint.setup({
+            filetypes = {
+                ["lua"] = function(opts)
+                    assert.equals(type(opts.bufnr), "number")
+                    assert.equals(type(opts.file_path), "string")
+                    assert.are.same(opts.effective_filetypes, { "lua" })
+
+                    return {
+                        left = "blah('",
+                        right = "')",
+                        mid_var = opts.effective_filetypes[1]
+                            .. "' .. vim.inspect(",
+                        right_var = "))",
+                    }
+                end,
+            },
+        })
+
+        local filename = init_file({
+            "foo = 123",
+            "bar = 456",
+        }, "lua", 1, 0)
+
+        feedkeys("g?v")
+
+        check_lines({
+            "foo = 123",
+            "blah('DEBUGPRINT[1]: "
+                .. filename
+                .. ":1: foo=lua' .. vim.inspect(foo))",
+            "bar = 456",
+        })
+    end)
+end)