Instructions or plugin for using vim/neovim

[David-Else]

It could be quite easy to add support to vim/neovim without a complex plugin. Prettier can be used in neovim by simply adding the following to the config file and having the prettier command available (press gp to run in normal mode):

   "run global prettier install on current buffer
   func! Prettier_format()
       let save_cursor = getcurpos()
       exe '%!pnpx prettier --stdin-filepath % --single-quote'
       call setpos('.', save_cursor)
   endfunc

   nnoremap gp :call Prettier_format()<CR>

Adding some instructions, or even a plugin for dprint would be awesome!

[dsherret]

It might be possible right now by using the hidden sub-command dprint stdin-fmt --file-name <filenamegoeshere> (which really should be named fmt-stdin—opened #302).

The problem is that it might be slow for some languages that have slow startup times like C#, which is why I introduced the dprint editor-service (using that is much more complicated though).

[David-Else]

Next year neovim 0.5 will be released that will have full language server capabilities built in, but until then I think a simple solution to paste in the config file would be fantastic.

https://nathansmith.io/posts/neovim-lsp

[David-Else]

I found Vim and Neovim have a built-in way to use external formatters, formatprg:

https://neovim.io/doc/user/options.html#%27formatprg%27

and here is a 'wrapper' plugin that demonstrates how to use it with different file types:

https://github.com/joereynolds/gq.vim

[dsherret]

Interesting. Seems like that's only for a selection of text? (I'm not sure what the "|gq|" operator is) Unfortunately dprint only works on entire files. That said, the gq.vim thing you linked to seems to work on entire files if I'm reading it correctly so maybe I'm just misunderstanding what formatprg does or they're passing the entire file text to it or something (I don't have much experience with vim's scripting language though I always use vim in text editors).

By the way, sorry for my delay, but I was debating with myself about how the stdin command should work then got distracted by something 😅

[David-Else]

I found this article that explains things: https://www.vimfromscratch.com/articles/setting-up-vim-for-typescript

Formatting

I use prettier which is an opinionated (still configurable to some extent) formatter for many languages, including HTML, CSS and JavaScript. It can also format TypeScript files just fine.

Add this to your file.

autocmd FileType typescript setlocal formatprg=prettier\ --parser\ typescript

And now you can format your entire files with formatting motions, for example gggqG. If you don’t know how formatting motions work in Vim you can use :help gq.

So you can format just bits of the code with the motions, or the entire file with gg go to top, gq format, G go to the bottom.

I am using VS Code at the moment with Deno for formatting, only missing markdown formatting with ts code blocks then I can delete prettier :) Were you adding markdown formatting to Deno? denoland/deno#7352

[emosenkis]

For vim-autoformat users, you can configure it to use dprint like this:

let g:formatdef_dprint = '"dprint stdin-fmt --file-name ".@%'
let g:formatters_javascript = ['dprint']
let g:formatters_typescript = ['dprint']
let g:formatters_json = ['dprint']
let g:formatters_markdown = ['dprint']

[dsherret]

Note that dprint stdin-fmt --file-name <file-name> is now dprint fmt --stdin <file-path/file-name> in dprint 0.10.0. If you provide a full file path then it will properly include or exclude files from being formatted based on .dprintrc.json, but if you don't want that behaviour then provide only a file name.

[kevgo]

I was able to make format-on-save using dprint work in neovim using https://github.com/mhartington/formatter.nvim and this section in my init.vim:

lua << EOF
require('formatter').setup({
  filetype = {
    markdown = {
      function()
        return {
          exe = "dprint",
          args = {"fmt", "--stdin", vim.fn.fnameescape(vim.api.nvim_buf_get_name(0))},
          stdin = true
        }
      end
    },
  }
})
EOF

This is the configuration for Markdown files. Examples for other languages can be found in the formatter documentation. It seems pretty performant.

[martin-braun]

With the help of @kevgo's snippet, I was able to get this to work using equalprg / formatprg instead, because why would I want to introduce yet another plugin when NeoVim can already do this for me?

Simply inside my ftplugin for the filetype I want to format I can do:

vim.opt_local.equalprg = "dprint fmt --stdin ' .. vim.fn.fnameescape(vim.api.nvim_buf_get_name(0))
vim.opt_local.formatprg = "dprint fmt --stdin ' .. vim.fn.fnameescape(vim.api.nvim_buf_get_name(0))

and I can use my already existing keymap to fix intending, but it properly formats the file, however there are key issues about this:

1. "Compiling..." messages are also sent to stdout, resulting in a very "nice" first experience:

These should simply be printed to STDERR (when --stdin is specified), so the buffer remains clean. Luckily this is only a first time issue. Can simply undo and reformat.

2. I want this to work when no local dprint configuration is available. I'm aware of -c, but what if I only want to -c only as a fallback, that makes things more complicated for no good reason. dprint check will nicely error when no local configuration is around, but it is to slow to have it part of my nvim launch routine.

Here is a nice helper function that will always use the global configuration:

M.get_dprint_prgcall = function()
    return "dprint fmt" ..
    ' --stdin ' .. vim.fn.fnameescape(vim.api.nvim_buf_get_name(0)) ..
    ' -c ' .. vim.fn.stdpath('config') .. package.config:sub(1, 1) ..
    "dprint.json"
end

I really wish there was a way to tell it to fallback to this configuration when a local one isn't found.

[martin-braun]

Ok I went through the headache to tackle issue two. My goal was to support dprint and prettier and being able to specify the formatters in the ftplugin, but have it always prefer the formatter that has a local configuration, otherwise just try each in the correct order.

Here are some bits out of my code base to illustrate the idea.

First let me be able to resolve commands to see if they are available using this util/cmd.lua helper:

local M = {}

M.get_resolved_invoker_of = function(command)
    local p = vim.loop.os_uname().sysname == "Windows_NT"
        and io.popen("where " .. command .. " 2>/dev/null || echo ''")
        or io.popen("command -v " .. command .. " 2>/dev/null || echo ''")
    if p ~= nil then
        local result = p:read()
        p:close()
        if #result > 0 then
            return result
        end
    end
    return nil
end

return M

Not tested on Windows, but I hope it's portable as of now.

And then I can do some logic when starting to figure out what I have and what I deal with:

local cmd = require("util/cmd")

minvim = {}

minvim.prgs = {
    dprint = cmd.get_resolved_invoker_of("dprint"),
    prettier = cmd.get_resolved_invoker_of("prettier"),
}

-- find a formatter configuration to determine the preferred local formatter:
minvim.preferred_formatter = (function()
    -- local dir = vim.fn.fnamemodify(vim.api.nvim_buf_get_name(0), ":h")
    local dir = vim.fn.getcwd()
    -- NOTE(martin-braun): It would be right to execute this for each buffer,
    -- but it would be slow. We compromise by using the cwd, so always
    -- `cd` in your project when attempting to format files there.
    local sep = package.config:sub(1, 1)
    while dir ~= sep do
        local files = vim.fn.readdir(dir)
        for _, file in ipairs(files) do
            if vim.fn.filereadable(dir .. sep .. file) == 1 then
                if file == "dprint.json" or file == ".dprint.json" then
                    return "dprint"
                elseif file == ".prettierrc"
                    or file == "prettierrc.json"
                    or file == "prettierrc.yml"
                    or file == "prettierrc.yaml"
                    or file == "prettierrc.json5"
                    or file == "prettierrc.js"
                    or file == "prettier.config.js"
                    or file == "prettierrc.ts"
                    or file == "prettier.config.ts"
                    or file == "prettierrc.mjs"
                    or file == "prettier.config.mjs"
                    or file == "prettierrc.mts"
                    or file == "prettier.config.mts"
                    or file == "prettierrc.cjs"
                    or file == "prettier.config.cjs"
                    or file == "prettierrc.cts"
                    or file == "prettier.config.cts"
                    or file == "prettierrc.toml" then
                    return "prettier"
                end
            end
        end
        dir = vim.fn.fnamemodify(dir, ":h")
    end
    return nil
end)()

A bit heavy, but it does what it needs to do. Compromise is I need to be in my project cwd to prefer the right formatter, but I cannot have this thing let run for every buffer, there is no way. Nasty prettier has way too many configuration files and the tree might be too deep as well.

Now I know what formatters I have and what formatter my project (cwd) wants to use. Next I want to abstract the actual logic to format for in the ftplugin. The file is util/fmt.lua:

local M = {}

local get_dprint_prgcall = function()
    if minvim.preferred_formatter == "dprint" then
        return minvim.prgs.dprint .. ' fmt' ..
        ' --stdin ' .. vim.fn.fnameescape(vim.api.nvim_buf_get_name(0))
    end
    return minvim.prgs.dprint .. ' fmt' ..
    ' --stdin ' .. vim.fn.fnameescape(vim.api.nvim_buf_get_name(0)) ..
    ' -c ' .. vim.fn.stdpath('config') .. package.config:sub(1, 1) ..
    "dprint.json"
end

local get_prettier_prgcall = function()
    if minvim.preferred_formatter == "prettier" then
        return minvim.prgs.prettier ..
        ' --stdin-filepath ' .. vim.fn.fnameescape(vim.api.nvim_buf_get_name(0))
    end
    return minvim.prgs.prettier ..
    ' --stdin-filepath ' .. vim.fn.fnameescape(vim.api.nvim_buf_get_name(0)) ..
    ' --config ' .. vim.fn.stdpath('config') .. package.config:sub(1, 1) ..
    "prettier.config.js"
end

M.buf_try_use = function(formatters)
    if minvim.preferred_formatter then -- there is a local configuration
        for _, formatter in ipairs(formatters) do
            if formatter == minvim.preferred_formatter then
                formatters = { formatter } -- only use preferred formatter
                break
            end
        end
    end
    for _, formatter in ipairs(formatters) do
        if formatter == "dprint" and minvim.prgs.dprint then
            print("SET")
            vim.opt_local.equalprg = get_dprint_prgcall()
            vim.opt_local.formatprg = get_dprint_prgcall()
            return true
        elseif formatter == "prettier" and minvim.prgs.prettier then
            print("SET")
            vim.opt_local.equalprg = get_prettier_prgcall()
            vim.opt_local.formatprg = get_prettier_prgcall()
            return true
        end
    end
    return false
end

M.buf_disable = function()
    -- unbind format keymaps
    vim.cmd("noremap <buffer> = <nop>")
    vim.cmd("noremap <buffer> <leader>ff <nop>")
end

return M

Now in my ftplugin/markdown.lua for example, I can simply do:

local fmt = require("util.fmt")
vim.opt_local.colorcolumn = ""
if not fmt.buf_try_use({ "dprint", "prettier" }) then
    vim.opt_local.wrap = true
    fmt.buf_disable()
end

As soon as buf_try_use is given any preferred formatter, it will be used instead (and error if the tool is missing), otherwise it will just go through each given formatter, so I can add a range of formatters as fallbacks if the first one is missing.

I haven't tested the thing in all kind of scenarios and filetypes yet, and I bet there is room for much improvement, but I want to share it here so others can benefit from this work, too.