feat: support registers - closes #148

Author: andrewferrier

README.md

@@ -172,3 +172,23 @@ add({
     depends = { 'echasnovski/mini.nvim' }, -- Needed for :ToggleCommentDebugPrints (not needed for NeoVim 0.10+)
 })
 ```
+
+## Register Usage
+
+Each of the standard keymappings (except the ones for insert mode) can be [prefixed with a register](https://neovim.io/doc/user/change.html#registers) in the same way as the standard 'y' (yank), 'd' (delete) keys, etc. When doing this, the content that would normally be inserted into the buffer is instead set into the register (lowercase register names) or appended to the register (uppercase register name). This means you can 'capture' several debugprint lines into a register, than insert them elsewhere in the buffer. This is particularly useful for 'variable' debugprint lines.
+
+For example, given this buffer:
+
+```lua
+foo = 123
+bar = 456
+```
+
+You can put your cursor on `foo`, and type `"ag?v`. Then put your cursor on `bar`, and type `"Ag?v`. Then you can move to the end of the buffer and type `"ap`. The end result will look like this:
+
+```lua
+foo = 123
+bar = 456
+print('DEBUGPRINT[1]: filename.lua:1: foo=' .. vim.inspect(foo))
+print('DEBUGPRINT[2]: filename.lua:2: bar=' .. vim.inspect(bar))
+```

SHOWCASE.md

@@ -4,6 +4,7 @@ local utils = require("debugprint.utils")
 local utils_buffer = require("debugprint.utils.buffer")
 local utils_errors = require("debugprint.utils.errors")
 local utils_operator = require("debugprint.utils.operator")
+local utils_register = require("debugprint.utils.register")
 
 local global_opts
 
@@ -190,37 +191,61 @@ local get_debugprint_line = function(opts)
     return line_to_insert
 end
 
+---@param opts DebugprintFunctionOptionsInternal
+---@param keys string
+local add_to_register = function(opts, keys)
+    utils_register.set_register(keys)
+
+    local content
+
+    if opts.variable_name then
+        content = "variable debug line (" .. opts.variable_name .. ")"
+    else
+        content = "plain debug line"
+    end
+
+    if utils_register.register_append() then
+        vim.notify("Appended " .. content .. " to register " .. opts.register)
+    else
+        vim.notify("Written " .. content .. " to register " .. opts.register)
+    end
+end
+
 ---@param opts DebugprintFunctionOptionsInternal
 ---@return nil
 local insert_debugprint_line = function(opts)
-    local line_to_insert = get_debugprint_line(opts)
-
     -- Inserting the leading space from the current line effectively acts as a
     -- 'default' indent for languages like Python, where the NeoVim or Treesitter
     -- indenter doesn't know how to indent them.
     local leading_space = vim.api.nvim_get_current_line():match("^(%s+)") or ""
 
-    local current_line_nr = vim.api.nvim_win_get_cursor(0)[1]
-    local line_to_insert_linenr
+    local line_to_insert = leading_space .. get_debugprint_line(opts)
 
-    if opts.above then
-        line_to_insert_linenr = current_line_nr - 1
+    if opts.register then
+        add_to_register(opts, line_to_insert)
     else
-        line_to_insert_linenr = current_line_nr
-    end
+        local current_line_nr = vim.api.nvim_win_get_cursor(0)[1]
+        local line_to_insert_linenr
 
-    vim.api.nvim_buf_set_lines(
-        0,
-        line_to_insert_linenr,
-        line_to_insert_linenr,
-        true,
-        { leading_space .. line_to_insert }
-    )
+        if opts.above then
+            line_to_insert_linenr = current_line_nr - 1
+        else
+            line_to_insert_linenr = current_line_nr
+        end
 
-    utils_buffer.indent_line(
-        line_to_insert_linenr,
-        global_opts.move_to_debugline
-    )
+        vim.api.nvim_buf_set_lines(
+            0,
+            line_to_insert_linenr,
+            line_to_insert_linenr,
+            true,
+            { line_to_insert }
+        )
+
+        utils_buffer.indent_line(
+            line_to_insert_linenr,
+            global_opts.move_to_debugline
+        )
+    end
 end
 
 local cache_request = {}
@@ -239,50 +264,64 @@ M.debugprint_operatorfunc_motion = function()
     M.debugprint_operatorfunc_regular()
 end
 
+---@param keys string
+---@param insert boolean
+local debugprint_insertkeys = function(keys, insert)
+    if keys ~= nil and keys ~= "" then
+        if insert then
+            vim.api.nvim_put({ keys }, "c", true, true)
+        else
+            vim.api.nvim_feedkeys(keys, "xt", true)
+        end
+    end
+end
+
 ---@param opts? DebugprintFunctionOptions
----@return string?
+---@return nil
 M.debugprint = function(opts)
-    local func_opts =
-        require("debugprint.options").get_and_validate_function_opts(opts)
+    opts = require("debugprint.options").get_and_validate_function_opts(opts)
+    ---@cast opts DebugprintFunctionOptionsInternal
+
+    opts.register = require("debugprint.utils.register").register_named()
 
-    ---@cast func_opts DebugprintFunctionOptionsInternal
+    assert(not (opts.insert and opts.register))
 
     if not utils_buffer.is_modifiable() then
         return
     end
 
-    if func_opts.variable == true then
+    if opts.variable == true then
         local filetype_config = get_filetype_config()
 
         if filetype_config then
-            func_opts.variable_name = utils.get_variable_name(
-                global_opts.ignore_treesitter
-                    or func_opts.ignore_treesitter
-                    or false,
+            opts.variable_name = utils.get_variable_name(
+                global_opts.ignore_treesitter or opts.ignore_treesitter or false,
                 filetype_config
             )
 
-            if not func_opts.variable_name then
+            if not opts.variable_name then
                 return
             end
         end
     end
 
-    if func_opts.insert == true then
-        cache_request = {}
-        return get_debugprint_line(func_opts)
-    elseif func_opts.motion == true then
-        cache_request = func_opts
+    if opts.motion == true then
+        cache_request = opts
         utils_operator.set_operatorfunc(
             "v:lua.require'debugprint'.debugprint_operatorfunc_motion"
         )
         return "g@"
+    end
+
+    if opts.insert == true then
+        cache_request = {}
+        debugprint_insertkeys(get_debugprint_line(opts), opts.insert)
     else
-        cache_request = func_opts
+        cache_request = opts
         utils_operator.set_operatorfunc(
             "v:lua.require'debugprint'.debugprint_operatorfunc_regular"
         )
-        return "g@l"
+        debugprint_insertkeys("g@l", opts.insert)
     end
 end
 

lua/debugprint/init.lua

@@ -22,79 +22,57 @@ local create_command = function(name, command, opts)
     end
 end
 
----@param keys string?
----@param insert_mode boolean
----@return nil
-local feedkeys = function(keys, insert_mode)
-    if keys ~= nil and keys ~= "" then
-        if insert_mode then
-            vim.api.nvim_put({ keys }, "c", true, true)
-        else
-            vim.api.nvim_feedkeys(keys, "xt", true)
-        end
-    end
-end
-
 ---@param global_opts DebugprintGlobalOptions
 ---@return nil
 M.map_keys_and_commands = function(global_opts)
     map_key("n", global_opts.keymaps.normal.plain_below, {
         callback = function()
-            feedkeys(debugprint.debugprint({}), false)
+            debugprint.debugprint({})
         end,
         desc = "Plain debug below current line",
     })
 
     map_key("n", global_opts.keymaps.normal.plain_above, {
         callback = function()
-            feedkeys(debugprint.debugprint({ above = true }), false)
+            debugprint.debugprint({ above = true })
         end,
         desc = "Plain debug above current line",
     })
 
     map_key("n", global_opts.keymaps.normal.variable_below, {
         callback = function()
-            feedkeys(debugprint.debugprint({ variable = true }), false)
+            debugprint.debugprint({ variable = true })
         end,
         desc = "Variable debug below current line",
     })
 
     map_key("n", global_opts.keymaps.normal.variable_above, {
         callback = function()
-            feedkeys(
-                debugprint.debugprint({
-                    above = true,
-                    variable = true,
-                }),
-                false
-            )
+            debugprint.debugprint({
+                above = true,
+                variable = true,
+            })
         end,
         desc = "Variable debug above current line",
     })
 
     map_key("n", global_opts.keymaps.normal.variable_below_alwaysprompt, {
         callback = function()
-            feedkeys(
-                debugprint.debugprint({
-                    variable = true,
-                    ignore_treesitter = true,
-                }),
-                false
-            )
+            debugprint.debugprint({
+                variable = true,
+                ignore_treesitter = true,
+            })
         end,
         desc = "Variable debug below current line (always prompt)",
     })
 
     map_key("n", global_opts.keymaps.normal.variable_above_alwaysprompt, {
         callback = function()
-            feedkeys(
-                debugprint.debugprint({
-                    above = true,
-                    variable = true,
-                    ignore_treesitter = true,
-                }),
-                false
-            )
+            debugprint.debugprint({
+                above = true,
+                variable = true,
+                ignore_treesitter = true,
+            })
         end,
         desc = "Variable debug above current line (always prompt)",
     })
@@ -120,41 +98,35 @@ M.map_keys_and_commands = function(global_opts)
 
     map_key("i", global_opts.keymaps.insert.plain, {
         callback = function()
-            feedkeys(debugprint.debugprint({ insert = true }), true)
+            debugprint.debugprint({ insert = true })
         end,
         desc = "Plain debug in-place",
     })
 
     map_key("i", global_opts.keymaps.insert.variable, {
         callback = function()
-            feedkeys(
-                debugprint.debugprint({
-                    insert = true,
-                    variable = true,
-                    ignore_treesitter = true,
-                }),
-                true
-            )
+            debugprint.debugprint({
+                insert = true,
+                variable = true,
+                ignore_treesitter = true,
+            })
         end,
         desc = "Variable debug in-place (always prompt)",
     })
 
     map_key("x", global_opts.keymaps.visual.variable_below, {
         callback = function()
-            feedkeys(debugprint.debugprint({ variable = true }), false)
+            debugprint.debugprint({ variable = true })
         end,
         desc = "Variable debug below current line",
     })
 
     map_key("x", global_opts.keymaps.visual.variable_above, {
         callback = function()
-            feedkeys(
-                debugprint.debugprint({
-                    above = true,
-                    variable = true,
-                }),
-                false
-            )
+            debugprint.debugprint({
+                above = true,
+                variable = true,
+            })
         end,
         desc = "Variable debug above current line",
     })

lua/debugprint/setup.lua

@@ -65,6 +65,7 @@
 
 ---@class DebugprintFunctionOptionsInternal: DebugprintFunctionOptions
 ---@field variable_name? string
+---@field register? string
 
 ---@class DebugprintCommandOpts
 ---@field line1 integer

lua/debugprint/types.lua

@@ -0,0 +1,36 @@
+local M = {}
+
+---@return string|nil
+M.register_named = function()
+    if
+        vim.v.register
+        and string.find(
+            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+            vim.v.register
+        )
+    then
+        return vim.v.register
+    else
+        return nil
+    end
+end
+
+---@return string|nil
+M.register_append = function()
+    if
+        vim.v.register
+        and string.find("ABCDEFGHIJKLMNOPQRSTUVWXYZ", vim.v.register)
+    then
+        return vim.v.register
+    else
+        return nil
+    end
+end
+
+---@param value string
+M.set_register = function(value)
+    assert(M.register_named ~= nil)
+    vim.fn.setreg(vim.v.register, value, "l")
+end
+
+return M