Awesome

debugprint.nvim

Overview

debugprint is a NeoVim plugin that simplifies debugging for those who prefer a low-tech approach. Instead of using a sophisticated debugger like nvim-dap, some people prefer using a 'print' statement to trace the output during execution. With debugprint, you can insert 'print' statements, with debug information pre-populated, relevant to the language you're editing. These statements include reference information for quick output navigation and the ability to output variable values.

debugprint supports 30 filetypes/programming languages out-of-the-box, including Python, JavaScript/TypeScript, Java, C/C++ and more. See the comparison table for the full list. It can also be extended to support other languages.

Features

debugprint is inspired by vim-debugstring, but is updated and refreshed for the NeoVim generation. It has these features:

• It includes reference information in each 'print line' such as file names, line numbers, a monotonic counter (which can be customized), and snippets of other lines to make it easier to cross-reference them in output.

• It can output the value of variables (or in some cases, expressions).

• It dot-repeats.

• It can detect a variable name under the cursor if it's a supported Treesitter-based language, or will prompt for the variable name with a sensible default if not.

• It knows which filetype you are working with when embedded inside another filetype, e.g. JavaScript-in-HTML, using Treesitter magic.

• It provides keymappings for visual and operator-pending modes, so you can select variables visually and using motions respectively.

• It provides commands to delete all debugging lines added to the current buffer as well as comment/uncomment those lines.

• It can optionally move to the inserted line (or not).

• You can add support for languages it doesn't support out of the box.

• It's MIT Licensed.

Demo

Installation

Requires NeoVim 0.9+.

Example for lazy.nvim:

return {
    "andrewferrier/debugprint.nvim",
    opts = { … },
    dependencies = {
        "echasnovski/mini.nvim" -- Needed for :ToggleCommentDebugPrints (not needed for NeoVim 0.10+)
    },
    -- The 'keys' and 'cmds' sections of this configuration are optional and only needed if
    -- you want to take advantage of `lazy.nvim` lazy-loading. If you decide to
    -- customize the keys/commands (see below), you'll need to change these too.
    keys = {
        { "g?", mode = 'n' },
        { "g?", mode = 'x' },
    },
    cmd = {
        "ToggleCommentDebugPrints",
        "DeleteDebugPrints",
    },
}

Example for packer.nvim:

packer.startup(function(use)
    …
    use({
        "andrewferrier/debugprint.nvim",
        config = function()
            opts = { … }
            require("debugprint").setup(opts)
        end,
        requires = {
            "echasnovski/mini.nvim" -- Needed for :ToggleCommentDebugPrints (not needed for NeoVim 0.10+)
        }
    })
    …
end)

The sections below detail the allowed options that can appear in the opts object.

Please subscribe to this GitHub issue to be notified of any breaking changes to debugprint.

Keymappings and Commands

By default, the plugin will create some keymappings and commands for use 'out of the box'. There are also some function invocations which are not mapped to any keymappings or commands by default, but could be. This is all shown in the following table.

The keys and commands outlined above can be specifically overridden using the keymaps and commands objects inside the opts object used above during configuration of debugprint. For example, if configuring via lazy.nvim, it might look like this:

return {
    "andrewferrier/debugprint.nvim",
    opts = {
        keymaps = {
            normal = {
                plain_below = "g?p",
                plain_above = "g?P",
                variable_below = "g?v",
                variable_above = "g?V",
                variable_below_alwaysprompt = nil,
                variable_above_alwaysprompt = nil,
                textobj_below = "g?o",
                textobj_above = "g?O",
                toggle_comment_debug_prints = nil,
                delete_debug_prints = nil,
            },
            visual = {
                variable_below = "g?v",
                variable_above = "g?V",
            },
        },
        commands = {
            toggle_comment_debug_prints = "ToggleCommentDebugPrints",
            delete_debug_prints = "DeleteDebugPrints",
        },
    },
}

You only need to include the keys / commands which you wish to override, others will default as shown above. Setting any key or command to nil will skip it.

The default keymappings are chosen specifically because ordinarily in NeoVim they are used to convert sections to ROT-13, which most folks don't use.

Mapping Deprecation

Note: as of version 2.0.0, the old mechanism of configuring keymaps/commands which specifically allowed for mapping directly to require('debugprint').debugprint(...) is no longer officially supported or documented. This is primarily because of confusion which arose over how to do this mapping. Existing mappings performed this way are likely to continue to work for some time. You should, however, migrate over to the new method outlined above. If this doesn't give you the flexibility to map how you wish for some reason, please open an issue.

Other Options

debugprint supports the following options in its global opts object:

Customizing Counter Logic

display_counter can also be set to a custom callback function to implement custom counter logic. In this case you are responsible for implementing your own counter. For example, this logic will implement essentially the same as the default counter:

local counter = 0

local counter_func = function()
    counter = counter + 1
    return '[' .. tostring(counter) .. ']'
end

debugprint.setup({display_counter = counter_func})

Add Custom Filetypes

Note: If you work out a configuration for a filetype not supported out-of-the-box, it would be appreciated if you can open an issue to have it supported out-of-the-box in debugprint so others can benefit. Similarly, if you spot any issues with, or improvements to, the language configurations out-of-the-box, please open an issue also.

If debugprint doesn't support your filetype, you can add it as a custom filetype in one of two ways:

• In the opts.filetypes object in setup().

• Using the require('debugprint').add_custom_filetypes() method (designed for use from ftplugin/ directories, etc.

In either case, the format is the same. For example, if adding via setup():

local my_fileformat = {
    left = 'print "',
    left_var = 'print "', -- `left_var` is optional, for 'variable' lines only; `left` will be used if it's not present
    right = '"',
    mid_var = "${",
    right_var = '}"',
}

require('debugprint').setup({ filetypes = { ["filetype"] = my_fileformat, ["another_filetype"] = another_of_my_fileformats, ... }})

or add_custom_filetypes():

require('debugprint').add_custom_filetypes({ my_fileformat, ... })

Your new file format will be merged in with those that already exist. If you pass in one that already exists, your configuration will override the built-in configuration.

The keys in the configuration are used like this:

If it helps to understand these, you can look at the built-in configurations in filetypes.lua.

Feature Comparison with Similar Plugins

(This table is quite wide, you may need to scroll horizontally)

Other unmaintained plugins (last updated more than 3 years ago):

• vim-debugstring
• vim-printf