Skip to content

Built-in LSP Sources¤

[2022-03-21 17;13] gk: I've put this here w/o sub headers, in order to have a better overview and search.

This is an automatically generated list of all null-ls built-in sources (source: https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/doc/BUILTINS.md) I've

See BUILTIN_CONFIG to learn how to set up and configure these sources.

Code Actions¤

eslint¤

Injects actions to fix ESLint issues or ignore broken rules.

local sources = { null_ls.builtins.code_actions.eslint }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue" }
  • Method: code_action
  • Command: eslint
  • Args: { "-f", "json", "--stdin", "--stdin-filename", "$FILENAME" }

eslint_d¤

Injects actions to fix ESLint issues or ignore broken rules. Like ESLint, but faster.

local sources = { null_ls.builtins.code_actions.eslint_d }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue" }
  • Method: code_action
  • Command: eslint_d
  • Args: { "-f", "json", "--stdin", "--stdin-filename", "$FILENAME" }

gitrebase¤

Injects actions to change gitrebase command (e.g. using squash instead of pick).

local sources = { null_ls.builtins.code_actions.gitrebase }

Defaults

  • Filetypes: { "gitrebase" }
  • Method: code_action

gitsigns¤

Injects code actions for Git operations at the current cursor position (stage / preview / reset hunks, blame, etc.).

local sources = { null_ls.builtins.code_actions.gitsigns }

Defaults

  • Filetypes: {}
  • Method: code_action

proselint¤

An English prose linter. Can fix some issues via code actions.

local sources = { null_ls.builtins.code_actions.proselint }

Defaults

  • Filetypes: { "markdown", "tex" }
  • Method: code_action
  • Command: proselint
  • Args: { "--json" }

refactoring¤

The Refactoring library based off the Refactoring book by Martin Fowler.

local sources = { null_ls.builtins.code_actions.refactoring }

Defaults

  • Filetypes: { "go", "javascript", "lua", "python", "typescript" }
  • Method: code_action

Notes

  • Requires visually selecting the code you want to refactor and calling :'<,'>lua vim.lsp.buf.range_code_action() (for the default handler) or :'<,'>Telescope lsp_range_code_actions (for Telescope).

shellcheck¤

Provides actions to disable ShellCheck errors/warnings, either for the current line or for the entire file.

local sources = { null_ls.builtins.code_actions.shellcheck }

Defaults

  • Filetypes: { "sh" }
  • Method: code_action
  • Command: shellcheck
  • Args: { "--format", "json1", "--source-path=$DIRNAME", "--external-sources", "-" }

Notes

  • Running the action to disable a rule for the current line adds a disable directive above the line or appends the rule to an existing disable directive for that line.
  • Running the action to disable a rule for the current file adds a disable directive at the top of the file or appends the rule to an existing file disable directive.
  • The first non-comment line in a script is not eligible for a line-level disable directive. See shellcheck#1877.

statix¤

Lints and suggestions for the nix programming language.

local sources = { null_ls.builtins.code_actions.statix }

Defaults

  • Filetypes: { "nix" }
  • Method: code_action
  • Command: statix
  • Args: { "check", "--stdin", "--format=json" }

xo¤

❤️ JavaScript/TypeScript linter (ESLint wrapper) with great defaults

local sources = { null_ls.builtins.code_actions.xo }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact" }
  • Method: code_action
  • Command: xo
  • Args: { "--reporter", "json", "--stdin", "--stdin-filename", "$FILENAME" }

Completion¤

luasnip¤

Snippet engine for Neovim, written in Lua.

local sources = { null_ls.builtins.completion.luasnip }

Defaults

  • Filetypes: {}
  • Method: completion

Notes

  • Registering this source will show available snippets in the completion list, but luasnip is in charge of expanding them. Consult luasnip's documentation to set up keymaps for expansion and jumping.

spell¤

Spell suggestions completion source.

local sources = { null_ls.builtins.completion.spell }

Defaults

  • Filetypes: {}
  • Method: completion

tags¤

Tags completion source.

local sources = { null_ls.builtins.completion.tags }

Defaults

  • Filetypes: {}
  • Method: completion

vsnip¤

Snippets managed by vim-vsnip.

local sources = { null_ls.builtins.completion.vsnip }

Defaults

  • Filetypes: {}
  • Method: completion

Notes

  • Registering this source will show available snippets in the completion list, but vim-vsnip is in charge of expanding them. See vim-vsnip's documentation for setup instructions.

Diagnostics¤

actionlint¤

Actionlint is a static checker for GitHub Actions workflow files.

local sources = { null_ls.builtins.diagnostics.actionlint }

Defaults

  • Filetypes: { "yaml" }
  • Method: diagnostics
  • Command: actionlint
  • Args: { "-no-color", "-format", "{{json .}}", "-" }

alex¤

Catch insensitive, inconsiderate writing.

local sources = { null_ls.builtins.diagnostics.alex }

Defaults

  • Filetypes: { "markdown" }
  • Method: diagnostics
  • Command: alex
  • Args: { "--stdin", "--quiet" }

ansiblelint¤

Linter for Ansible playbooks, roles and collections.

local sources = { null_ls.builtins.diagnostics.ansiblelint }

Defaults

  • Filetypes: { "yaml.ansible" }
  • Method: diagnostics
  • Command: ansible-lint
  • Args: { "-f", "codeclimate", "-q", "--nocolor", "$FILENAME" }

buildifier¤

buildifier is a tool for formatting and linting bazel BUILD, WORKSPACE, and .bzl files.

local sources = { null_ls.builtins.diagnostics.buildifier }

Defaults

  • Filetypes: { "bzl" }
  • Method: diagnostics
  • Command: buildifier
  • Args: { "-mode=check", "-lint=warn", "-format=json", "-path=$FILENAME" }

checkmake¤

make linter.

local sources = { null_ls.builtins.diagnostics.checkmake }

Defaults

  • Filetypes: { "make" }
  • Method: diagnostics
  • Command: checkmake
  • Args: { "--format='{{.LineNumber}}:{{.Rule}}:{{.Violation}}'", "$FILENAME" }

chktex¤

latex semantic linter.

local sources = { null_ls.builtins.diagnostics.chktex }

Defaults

  • Filetypes: { "tex" }
  • Method: diagnostics
  • Command: chktex
  • Args: { "-q", "-f%l:%c:%d:%k:%n:%m\n" }

codespell¤

Codespell finds common misspellings in text files.

local sources = { null_ls.builtins.diagnostics.codespell }

Defaults

  • Filetypes: {}
  • Method: diagnostics
  • Command: codespell
  • Args: { "-" }

cppcheck¤

A tool for fast static analysis of C/C++ code.

local sources = { null_ls.builtins.diagnostics.cppcheck }

Defaults

  • Filetypes: { "cpp", "c" }
  • Method: diagnostics
  • Command: cppcheck
  • Args: { "--enable=warning,style,performance,portability", "--template=gcc", "$FILENAME" }

credo¤

Static analysis of elixir files for enforcing code consistency.

local sources = { null_ls.builtins.diagnostics.credo }

Defaults

  • Filetypes: { "elixir" }
  • Method: diagnostics
  • Command: mix
  • Args: { "credo", "suggest", "--format", "json", "--read-from-stdin", "$FILENAME" }

Notes

  • Searches upwards from the buffer to the project root and tries to find the first .credo.exs file in case the project has nested credo configs.

cspell¤

cspell is a spell checker for code.

local sources = { null_ls.builtins.diagnostics.cspell }

Defaults

  • Filetypes: {}
  • Method: diagnostics
  • Command: cspell
  • Args: dynamically resolved (see source)

cue_fmt¤

Reports on formatting errors in .cue language files.

local sources = { null_ls.builtins.diagnostics.cue_fmt }

Defaults

  • Filetypes: { "cue" }
  • Method: diagnostics
  • Command: cue
  • Args: { "fmt", "$FILENAME" }

curlylint¤

Experimental HTML templates linting for Jinja, Nunjucks, Django templates, Twig, and Liquid.

local sources = { null_ls.builtins.diagnostics.curlylint }

Defaults

  • Filetypes: { "jinja.html", "htmldjango" }
  • Method: diagnostics
  • Command: curlylint
  • Args: { "--quiet", "-", "--format", "json", "--stdin-filepath", "$FILENAME" }

deadnix¤

Scan Nix files for dead code.

local sources = { null_ls.builtins.diagnostics.deadnix }

Defaults

  • Filetypes: { "nix" }
  • Method: diagnostics
  • Command: deadnix
  • Args: { "--output-format=json", "$FILENAME" }

djlint¤

✨ 📜 🪄 ✨ HTML Template Linter and Formatter.

local sources = { null_ls.builtins.diagnostics.djlint }

Defaults

  • Filetypes: { "django", "jinja.html", "htmldjango" }
  • Method: diagnostics
  • Command: djlint
  • Args: { "$FILENAME" }

editorconfig_checker¤

A tool to verify that your files are in harmony with your .editorconfig.

local sources = { null_ls.builtins.diagnostics.editorconfig_checker }

Defaults

  • Filetypes: {}
  • Method: diagnostics
  • Command: ec
  • Args: { "-no-color", "$FILENAME" }

eslint¤

A linter for the JavaScript ecosystem.

local sources = { null_ls.builtins.diagnostics.eslint }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue" }
  • Method: diagnostics
  • Command: eslint
  • Args: { "-f", "json", "--stdin", "--stdin-filename", "$FILENAME" }

eslint_d¤

Like ESLint, but faster.

local sources = { null_ls.builtins.diagnostics.eslint_d }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue" }
  • Method: diagnostics
  • Command: eslint_d
  • Args: { "-f", "json", "--stdin", "--stdin-filename", "$FILENAME" }

flake8¤

flake8 is a python tool that glues together pycodestyle, pyflakes, mccabe, and third-party plugins to check the style and quality of Python code.

local sources = { null_ls.builtins.diagnostics.flake8 }

Defaults

  • Filetypes: { "python" }
  • Method: diagnostics
  • Command: flake8
  • Args: { "--format", "default", "--stdin-display-name", "$FILENAME", "-" }

gccdiag¤

gccdiag is a wrapper for any C/C++ compiler (gcc, avr-gcc, arm-none-eabi-gcc, etc) that automatically uses the correct compiler arguments for a file in your project by parsing the compile_commands.json file at the root of your project.

local sources = { null_ls.builtins.diagnostics.gccdiag }

Defaults

  • Filetypes: { "c", "cpp" }
  • Method: diagnostics_on_save
  • Command: gccdiag
  • Args: { "--default-args", "-S -x $FILEEXT", "-i", "-fdiagnostics-color", "--", "$FILENAME" }

gitlint¤

Linter for Git commit messages.

local sources = { null_ls.builtins.diagnostics.gitlint }

Defaults

  • Filetypes: { "gitcommit" }
  • Method: diagnostics
  • Command: gitlint
  • Args: { "--msg-filename", "$FILENAME" }

golangci_lint¤

A Go linter aggregator.

local sources = { null_ls.builtins.diagnostics.golangci_lint }

Defaults

  • Filetypes: { "go" }
  • Method: diagnostics_on_save
  • Command: golangci-lint
  • Args: { "run", "--fix=false", "--fast", "--out-format=json", "$DIRNAME", "--path-prefix", "$ROOT" }

hadolint¤

A smarter Dockerfile linter that helps you build best practice Docker images.

local sources = { null_ls.builtins.diagnostics.hadolint }

Defaults

  • Filetypes: { "dockerfile" }
  • Method: diagnostics
  • Command: hadolint
  • Args: { "--no-fail", "--format=json", "$FILENAME" }

haml_lint¤

Tool for writing clean and consistent HAML.

local sources = { null_ls.builtins.diagnostics.haml_lint }

Defaults

  • Filetypes: { "haml" }
  • Method: diagnostics
  • Command: haml-lint
  • Args: { "--reporter", "json", "$FILENAME" }

jsonlint¤

A pure JavaScript version of the service provided at jsonlint.com.

local sources = { null_ls.builtins.diagnostics.jsonlint }

Defaults

  • Filetypes: { "json" }
  • Method: diagnostics
  • Command: jsonlint
  • Args: { "--compact" }

ktlint¤

An anti-bikeshedding Kotlin linter with built-in formatter.

local sources = { null_ls.builtins.diagnostics.ktlint }

Defaults

  • Filetypes: { "kotlin" }
  • Method: diagnostics_on_save
  • Command: ktlint
  • Args: { "--relative", "--reporter=json" }

luacheck¤

A tool for linting and static analysis of Lua code.

local sources = { null_ls.builtins.diagnostics.luacheck }

Defaults

  • Filetypes: { "lua" }
  • Method: diagnostics
  • Command: luacheck
  • Args: { "--formatter", "plain", "--codes", "--ranges", "--filename", "$FILENAME", "-" }

markdownlint¤

Markdown style and syntax checker.

local sources = { null_ls.builtins.diagnostics.markdownlint }

Defaults

  • Filetypes: { "markdown" }
  • Method: diagnostics
  • Command: markdownlint
  • Args: { "--stdin" }

mdl¤

A tool to check Markdown files and flag style issues.

local sources = { null_ls.builtins.diagnostics.mdl }

Defaults

  • Filetypes: { "markdown" }
  • Method: diagnostics
  • Command: mdl
  • Args: { "--json" }

misspell¤

Checks commonly misspelled English words in source files.

local sources = { null_ls.builtins.diagnostics.misspell }

Defaults

  • Filetypes: {}
  • Method: diagnostics
  • Command: misspell

mlint¤

Linter for MATLAB files

local sources = { null_ls.builtins.diagnostics.mlint }

Defaults

  • Filetypes: { "matlab" }
  • Method: diagnostics_on_save
  • Command: mlint
  • Args: { "$FILENAME" }

mypy¤

Mypy is an optional static type checker for Python that aims to combine the benefits of dynamic (or "duck") typing and static typing.

local sources = { null_ls.builtins.diagnostics.mypy }

Defaults

  • Filetypes: { "python" }
  • Method: diagnostics
  • Command: mypy
  • Args: dynamically resolved (see source)

php¤

Uses the php command-line tool's built in -l flag to check for syntax errors.

local sources = { null_ls.builtins.diagnostics.php }

Defaults

  • Filetypes: { "php" }
  • Method: diagnostics
  • Command: php
  • Args: { "-l", "-d", "display_errors=STDERR", "-d", " log_errors=Off" }

phpcs¤

PHP_CodeSniffer is a script that tokenizes PHP, JavaScript and CSS files to detect violations of a defined coding standard.

local sources = { null_ls.builtins.diagnostics.phpcs }

Defaults

  • Filetypes: { "php" }
  • Method: diagnostics
  • Command: phpcs
  • Args: { "--report=json", "-q", "-s", "--runtime-set", "ignore_warnings_on_exit", "1", "--runtime-set", "ignore_errors_on_exit", "1", "-" }

phpmd¤

Runs PHP Mess Detector against PHP files.

local sources = { null_ls.builtins.diagnostics.phpmd }

Defaults

  • Filetypes: { "php" }
  • Method: diagnostics
  • Command: phpmd
  • Args: { "$FILENAME", "json" }

phpstan¤

PHP static analysis tool.

local sources = { null_ls.builtins.diagnostics.phpstan }

Defaults

  • Filetypes: { "php" }
  • Method: diagnostics
  • Command: phpstan
  • Args: { "analyze", "--error-format", "json", "--no-progress", "$FILENAME" }

Notes

  • Requires a valid phpstan.neon at root.

proselint¤

An English prose linter.

local sources = { null_ls.builtins.diagnostics.proselint }

Defaults

  • Filetypes: { "markdown", "tex" }
  • Method: diagnostics
  • Command: proselint
  • Args: { "--json" }

protoc_gen_lint¤

A plug-in for Google's Protocol Buffers (protobufs) compiler to lint .proto files for style violations.

local sources = { null_ls.builtins.diagnostics.protoc_gen_lint }

Defaults

  • Filetypes: { "proto" }
  • Method: diagnostics
  • Command: protoc
  • Args: { "--lint_out", "$FILENAME", "-I", "/tmp", "$FILENAME" }

protolint¤

A pluggable linter and fixer to enforce Protocol Buffer style and conventions.

local sources = { null_ls.builtins.diagnostics.protolint }

Defaults

  • Filetypes: { "proto" }
  • Method: diagnostics
  • Command: protolint
  • Args: { "--reporter", "json", "$FILENAME" }

psalm¤

A static analysis tool for finding errors in PHP applications.

local sources = { null_ls.builtins.diagnostics.psalm }

Defaults

  • Filetypes: { "php" }
  • Method: diagnostics
  • Command: psalm
  • Args: { "--output-format=json", "--no-progress", "$FILENAME" }

puglint¤

An unopinionated and configurable linter and style checker for Pug.

local sources = { null_ls.builtins.diagnostics.puglint }

Defaults

  • Filetypes: { "pug" }
  • Method: diagnostics
  • Command: pug-lint
  • Args: { "--reporter=inline", "$FILENAME" }

puppet_lint¤

Check that your Puppet manifest conforms to the style guide.

local sources = { null_ls.builtins.diagnostics.puppet_lint }

Defaults

  • Filetypes: { "puppet", "epuppet" }
  • Method: diagnostics
  • Command: puppet-lint
  • Args: { "--json", "$FILENAME" }

pydocstyle¤

pydocstyle is a static analysis tool for checking compliance with Python docstring conventions.

local sources = { null_ls.builtins.diagnostics.pydocstyle }

Defaults

  • Filetypes: { "python" }
  • Method: diagnostics
  • Command: pydocstyle
  • Args: { "$FILENAME" }

Notes

  • May fail to resolve config files. See the wiki for workarounds.

pylama¤

Code audit tool for Python.

local sources = { null_ls.builtins.diagnostics.pylama }

Defaults

  • Filetypes: { "python" }
  • Method: diagnostics
  • Command: pylama
  • Args: { "--from-stdin", "$FILENAME", "-f", "json" }

pylint¤

Pylint is a Python static code analysis tool which looks for programming errors, helps enforcing a coding standard, sniffs for code smells and offers simple refactoring suggestions.

local sources = { null_ls.builtins.diagnostics.pylint }

Defaults

  • Filetypes: { "python" }
  • Method: diagnostics
  • Command: pylint
  • Args: { "--from-stdin", "$FILENAME", "-f", "json" }

pyproject_flake8¤

pyproject-flake8 is a flake8 wrapper to use with pyproject.toml configuration.

local sources = { null_ls.builtins.diagnostics.pyproject_flake8 }

Defaults

  • Filetypes: { "python" }
  • Method: diagnostics
  • Command: pflake8
  • Args: { "--format", "default", "--stdin-display-name", "$FILENAME", "-" }

qmllint¤

qmllint is a tool shipped with Qt that verifies the syntatic validity of QML files. It also warns about some QML anti-patterns.

local sources = { null_ls.builtins.diagnostics.qmllint }

Defaults

  • Filetypes: { "qml" }
  • Method: diagnostics
  • Command: qmllint
  • Args: { "$FILENAME" }

revive¤

Fast, configurable, extensible, flexible, and beautiful linter for Go.

local sources = { null_ls.builtins.diagnostics.revive }

Defaults

  • Filetypes: { "go" }
  • Method: diagnostics_on_save
  • Command: revive
  • Args: { "-formatter", "json", "./..." }

rpmspec¤

Command line tool to parse RPM spec files.

local sources = { null_ls.builtins.diagnostics.rpmspec }

Defaults

  • Filetypes: { "spec" }
  • Method: diagnostics
  • Command: rpmspec
  • Args: { "-P", "$FILENAME" }

rstcheck¤

Checks syntax of reStructuredText and code blocks nested within it.

local sources = { null_ls.builtins.diagnostics.rstcheck }

Defaults

  • Filetypes: { "rst" }
  • Method: diagnostics_on_save
  • Command: rstcheck
  • Args: { "-r", "$DIRNAME" }

rubocop¤

The Ruby Linter/Formatter that Serves and Protects.

local sources = { null_ls.builtins.diagnostics.rubocop }

Defaults

  • Filetypes: { "ruby" }
  • Method: diagnostics
  • Command: rubocop
  • Args: { "-f", "json", "--stdin", "$FILENAME" }

selene¤

Command line tool designed to help write correct and idiomatic Lua code.

local sources = { null_ls.builtins.diagnostics.selene }

Defaults

  • Filetypes: { "lua" }
  • Method: diagnostics
  • Command: selene
  • Args: { "--display-style", "quiet", "-" }

semgrep¤

Semgrep is a fast, open-source, static analysis tool for finding bugs and enforcing code standards at editor, commit, and CI time.

local sources = { null_ls.builtins.diagnostics.semgrep }

Defaults

  • Filetypes: { "typescript", "typescriptreact", "ruby", "python", "java", "go" }
  • Method: diagnostics
  • Command: semgrep
  • Args: { "-q", "--json", "$FILENAME" }

shellcheck¤

A shell script static analysis tool.

local sources = { null_ls.builtins.diagnostics.shellcheck }

Defaults

  • Filetypes: { "sh" }
  • Method: diagnostics
  • Command: shellcheck
  • Args: { "--format", "json1", "--source-path=$DIRNAME", "--external-sources", "-" }

standardjs¤

JavaScript style guide, linter, and formatter.

local sources = { null_ls.builtins.diagnostics.standardjs }

Defaults

  • Filetypes: { "javascript", "javascriptreact" }
  • Method: diagnostics
  • Command: standard
  • Args: { "--stdin" }

standardrb¤

Ruby style guide, linter, and formatter.

local sources = { null_ls.builtins.diagnostics.standardrb }

Defaults

  • Filetypes: { "ruby" }
  • Method: diagnostics
  • Command: standardrb
  • Args: { "--no-fix", "-f", "json", "--stdin", "$FILENAME" }

staticcheck¤

Advanced Go linter.

local sources = { null_ls.builtins.diagnostics.staticcheck }

Defaults

  • Filetypes: { "go" }
  • Method: diagnostics_on_save
  • Command: staticcheck
  • Args: { "-f", "json", "./..." }

statix¤

Lints and suggestions for the Nix programming language.

local sources = { null_ls.builtins.diagnostics.statix }

Defaults

  • Filetypes: { "nix" }
  • Method: diagnostics
  • Command: statix
  • Args: { "check", "--stdin", "--format=errfmt" }

stylelint¤

A mighty, modern linter that helps you avoid errors and enforce conventions in your styles.

local sources = { null_ls.builtins.diagnostics.stylelint }

Defaults

  • Filetypes: { "scss", "less", "css", "sass" }
  • Method: diagnostics
  • Command: stylelint
  • Args: { "--formatter", "json", "--stdin-filename", "$FILENAME" }

stylint¤

A linter for the Stylus CSS preprocessor.

local sources = { null_ls.builtins.diagnostics.stylint }

Defaults

  • Filetypes: { "stylus" }
  • Method: diagnostics
  • Command: stylint
  • Args: { "$FILENAME" }

teal¤

The compiler for Teal, a typed dialect of Lua.

local sources = { null_ls.builtins.diagnostics.teal }

Defaults

  • Filetypes: { "teal" }
  • Method: diagnostics
  • Command: tl
  • Args: { "check", "$FILENAME" }

textlint¤

The pluggable linting tool for text and Markdown.

local sources = { null_ls.builtins.diagnostics.textlint }

Defaults

  • Filetypes: {}
  • Method: diagnostics
  • Command: textlint
  • Args: { "-f", "json", "--stdin", "--stdin-filename", "$FILENAME" }

tidy¤

Tidy corrects and cleans up HTML and XML documents by fixing markup errors and upgrading legacy code to modern standards.

local sources = { null_ls.builtins.diagnostics.tidy }

Defaults

  • Filetypes: { "html", "xml" }
  • Method: diagnostics
  • Command: tidy
  • Args: dynamically resolved (see source)

trail_space¤

Uses inbuilt Lua code to detect lines with trailing whitespace and show a diagnostic warning on each line where it's present.

local sources = { null_ls.builtins.diagnostics.trail_space }

Defaults

  • Filetypes: {}
  • Method: diagnostics

tsc¤

Parses diagnostics from the TypeScript compiler.

local sources = { null_ls.builtins.diagnostics.tsc }

Defaults

  • Filetypes: { "typescript", "typescriptreact" }
  • Method: diagnostics_on_save
  • Command: tsc
  • Args: { "--pretty", "false", "--noEmit" }

twigcs¤

Runs Twigcs against Twig files.

local sources = { null_ls.builtins.diagnostics.twigcs }

Defaults

  • Filetypes: { "twig" }
  • Method: diagnostics
  • Command: twigcs
  • Args: { "--reporter", "json", "$FILENAME" }

vale¤

Syntax-aware linter for prose built with speed and extensibility in mind.

local sources = { null_ls.builtins.diagnostics.vale }

Defaults

  • Filetypes: { "markdown", "tex", "asciidoc" }
  • Method: diagnostics
  • Command: vale
  • Args: dynamically resolved (see source)

Notes

  • vale does not include a syntax by itself, so you probably need to grab a vale.ini (at ~/.vale.ini) and a StylesPath (somewhere, pointed from vale.ini) from the list of configurations.

vint¤

Linter for Vimscript.

local sources = { null_ls.builtins.diagnostics.vint }

Defaults

  • Filetypes: { "vim" }
  • Method: diagnostics
  • Command: vint
  • Args: { "--style-problem", "--json", "$FILENAME" }

vulture¤

Vulture finds unused code in Python programs.

local sources = { null_ls.builtins.diagnostics.vulture }

Defaults

  • Filetypes: { "python" }
  • Method: diagnostics
  • Command: vulture
  • Args: { "$FILENAME" }

write_good¤

English prose linter.

local sources = { null_ls.builtins.diagnostics.write_good }

Defaults

  • Filetypes: { "markdown" }
  • Method: diagnostics
  • Command: write-good
  • Args: { "--text=$TEXT", "--parse" }

xo¤

❤️ JavaScript/TypeScript linter (ESLint wrapper) with great defaults.

local sources = { null_ls.builtins.diagnostics.xo }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact" }
  • Method: diagnostics
  • Command: xo
  • Args: { "--reporter", "json", "--stdin", "--stdin-filename", "$FILENAME" }

yamllint¤

A linter for YAML files.

local sources = { null_ls.builtins.diagnostics.yamllint }

Defaults

  • Filetypes: { "yaml" }
  • Method: diagnostics
  • Command: yamllint
  • Args: { "--format", "parsable", "-" }

zsh¤

Uses zsh's own -n option to evaluate, but not execute, zsh scripts. Effectively, this acts somewhat like a linter, although it only really checks for serious errors - and will likely only show the first error.

local sources = { null_ls.builtins.diagnostics.zsh }

Defaults

  • Filetypes: { "zsh" }
  • Method: diagnostics
  • Command: zsh
  • Args: { "-n", "$FILENAME" }

Formatting¤

asmfmt¤

Format your assembler code in a similar way that gofmt formats your go code.

local sources = { null_ls.builtins.formatting.asmfmt }

Defaults

  • Filetypes: { "asm" }
  • Method: formatting
  • Command: asmfmt

astyle¤

Artistic Style is a source code indenter, formatter, and beautifier for the C, C++, C++/CLI, Objective‑C, C# and Java programming languages. This formatter works well for Arduino project files and is the same formatter used in the Arduino IDE.

local sources = { null_ls.builtins.formatting.astyle }

Defaults

  • Filetypes: { "arduino", "c", "cpp", "cs", "java" }
  • Method: formatting
  • Command: astyle
  • Args: { "--quiet" }

autopep8¤

A tool that automatically formats Python code to conform to the PEP 8 style guide.

local sources = { null_ls.builtins.formatting.autopep8 }

Defaults

  • Filetypes: { "python" }
  • Methods: formatting, range_formatting
  • Command: autopep8
  • Args: dynamically resolved (see source)

bean_format¤

This pure text processing tool will reformat beancount input to right-align all the numbers at the same, minimal column.

local sources = { null_ls.builtins.formatting.bean_format }

Defaults

  • Filetypes: { "beancount" }
  • Method: formatting
  • Command: bean-format

Notes

  • It left-aligns all the currencies.
  • It only modifies whitespace.

black¤

The uncompromising Python code formatter

local sources = { null_ls.builtins.formatting.black }

Defaults

  • Filetypes: { "python" }
  • Method: formatting
  • Command: black
  • Args: { "--stdin-filename", "$FILENAME", "--quiet", "-" }

brittany¤

haskell source code formatter

local sources = { null_ls.builtins.formatting.brittany }

Defaults

  • Filetypes: { "haskell" }
  • Method: formatting
  • Command: brittany

buildifier¤

buildifier is a tool for formatting and linting bazel BUILD, WORKSPACE, and .bzl files.

local sources = { null_ls.builtins.formatting.buildifier }

Defaults

  • Filetypes: { "bzl" }
  • Method: formatting
  • Command: buildifier
  • Args: { "-path=$FILENAME" }

cabal_fmt¤

Format .cabal files preserving the original field ordering, and comments.

local sources = { null_ls.builtins.formatting.cabal_fmt }

Defaults

  • Filetypes: { "cabal" }
  • Method: formatting
  • Command: cabal-fmt

clang_format¤

Tool to format C/C++/… code according to a set of rules and heuristics.

local sources = { null_ls.builtins.formatting.clang_format }

Defaults

  • Filetypes: { "c", "cpp", "cs", "java" }
  • Method: formatting
  • Command: clang-format
  • Args: { "-assume-filename", "$FILENAME" }

cljstyle¤

Formatter for Clojure code.

local sources = { null_ls.builtins.formatting.cljstyle }

Defaults

  • Filetypes: { "clojure" }
  • Method: formatting
  • Command: cljstyle
  • Args: { "pipe" }

cmake_format¤

Parse cmake listfiles and format them nicely.

local sources = { null_ls.builtins.formatting.cmake_format }

Defaults

  • Filetypes: { "cmake" }
  • Method: formatting
  • Command: cmake-format
  • Args: { "-" }

codespell¤

Fix common misspellings in text files.

local sources = { null_ls.builtins.formatting.codespell }

Defaults

  • Filetypes: {}
  • Method: formatting
  • Command: codespell
  • Args: { "--write-changes", "$FILENAME" }

crystal_format¤

A tool for automatically checking and correcting the style of code in a project.

local sources = { null_ls.builtins.formatting.crystal_format }

Defaults

  • Filetypes: { "crystal" }
  • Method: formatting
  • Command: crystal
  • Args: { "tool", "format" }

cue_fmt¤

A CUE language formatter.

local sources = { null_ls.builtins.formatting.cue_fmt }

Defaults

  • Filetypes: { "cue" }
  • Method: formatting
  • Command: cue
  • Args: { "fmt", "$FILENAME" }

dart_format¤

Replace the whitespace in your program with formatting that follows Dart guidelines.

local sources = { null_ls.builtins.formatting.dart_format }

Defaults

  • Filetypes: { "dart" }
  • Method: formatting
  • Command: dart
  • Args: { "format" }

deno_fmt¤

Use Deno to format TypeScript and JavaScript code.

local sources = { null_ls.builtins.formatting.deno_fmt }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact" }
  • Method: formatting
  • Command: deno
  • Args: { "fmt", "-" }

dfmt¤

Formatter for D source code.

local sources = { null_ls.builtins.formatting.dfmt }

Defaults

  • Filetypes: { "d" }
  • Method: formatting
  • Command: dfmt

djhtml¤

A pure-Python Django/Jinja template indenter without dependencies.

local sources = { null_ls.builtins.formatting.djhtml }

Defaults

  • Filetypes: { "django", "jinja.html", "htmldjango" }
  • Method: formatting
  • Command: djhtml

djlint¤

✨ 📜 🪄 ✨ HTML Template Linter and Formatter.

local sources = { null_ls.builtins.formatting.djlint }

Defaults

  • Filetypes: { "django", "jinja.html", "htmldjango" }
  • Method: formatting
  • Command: djlint
  • Args: { "--reformat", "-" }

elm_format¤

elm-format formats Elm source code according to a standard set of rules based on the official Elm Style Guide.

local sources = { null_ls.builtins.formatting.elm_format }

Defaults

  • Filetypes: { "elm" }
  • Method: formatting
  • Command: elm-format
  • Args: { "--stdin" }

erlfmt¤

An opinionated Erlang code formatter.

local sources = { null_ls.builtins.formatting.erlfmt }

Defaults

  • Filetypes: { "erlang" }
  • Method: formatting
  • Command: erlfmt
  • Args: { "-" }

eslint¤

Find and fix problems in your JavaScript code.

local sources = { null_ls.builtins.formatting.eslint }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue" }
  • Method: formatting
  • Command: eslint
  • Args: { "--fix-dry-run", "--format", "json", "--stdin", "--stdin-filename", "$FILENAME" }

Notes

  • Slow and not suitable for formatting on save. If at all possible, use eslint_d.

eslint_d¤

Makes eslint the fastest linter on the planet.

local sources = { null_ls.builtins.formatting.eslint_d }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue" }
  • Method: formatting
  • Command: eslint_d
  • Args: { "--fix-to-stdout", "--stdin", "--stdin-filename", "$FILENAME" }

fish_indent¤

Indent or otherwise prettify a piece of fish code.

local sources = { null_ls.builtins.formatting.fish_indent }

Defaults

  • Filetypes: { "fish" }
  • Method: formatting
  • Command: fish_indent

fixjson¤

A JSON file fixer/formatter for humans using (relaxed) JSON5.

local sources = { null_ls.builtins.formatting.fixjson }

Defaults

  • Filetypes: { "json" }
  • Method: formatting
  • Command: fixjson

fnlfmt¤

fnlfmt is a Fennel code formatter which follows established Lisp conventions when determining how to format a given piece of code.

local sources = { null_ls.builtins.formatting.fnlfmt }

Defaults

  • Filetypes: { "fennel", "fnl" }
  • Method: formatting
  • Command: fnlfmt
  • Args: { "-" }

format_r¤

Format R code automatically.

local sources = { null_ls.builtins.formatting.format_r }

Defaults

  • Filetypes: { "r", "rmd" }
  • Method: formatting
  • Command: R
  • Args: dynamically resolved (see source)

fourmolu¤

Fourmolu is a formatter for Haskell source code.

local sources = { null_ls.builtins.formatting.fourmolu }

Defaults

  • Filetypes: { "haskell" }
  • Method: formatting
  • Command: fourmolu

fprettify¤

fprettify is an auto-formatter for modern Fortran code that imposes strict whitespace formatting, written in Python.

local sources = { null_ls.builtins.formatting.fprettify }

Defaults

  • Filetypes: { "fortran" }
  • Method: formatting
  • Command: fprettify
  • Args: { "--silent" }

gofmt¤

Formats go programs.

local sources = { null_ls.builtins.formatting.gofmt }

Defaults

  • Filetypes: { "go" }
  • Method: formatting
  • Command: gofmt

Notes

  • It uses tabs for indentation and blanks for alignment.
  • Aligntment assumes that the editor is using a fixed-width font.

gofumpt¤

Enforce a stricter format than gofmt, while being backwards compatible. That is, gofumpt is happy with a subset of the formats that gofmt is happy with.

local sources = { null_ls.builtins.formatting.gofumpt }

Defaults

  • Filetypes: { "go" }
  • Method: formatting
  • Command: gofumpt

goimports¤

Updates your Go import lines, adding missing ones and removing unreferenced ones.

local sources = { null_ls.builtins.formatting.goimports }

Defaults

  • Filetypes: { "go" }
  • Method: formatting
  • Command: goimports
  • Args: { "-srcdir", "$DIRNAME" }

golines¤

Applies a base formatter (eg. goimports or gofmt), then shortens long lines of code.

local sources = { null_ls.builtins.formatting.golines }

Defaults

  • Filetypes: { "go" }
  • Method: formatting
  • Command: golines

google_java_format¤

Reformats Java source code according to Google Java Style.

local sources = { null_ls.builtins.formatting.google_java_format }

Defaults

  • Filetypes: { "java" }
  • Method: formatting
  • Command: google-java-format
  • Args: { "-" }

isort¤

Python utility / library to sort imports alphabetically and automatically separate them into sections and by type.

local sources = { null_ls.builtins.formatting.isort }

Defaults

  • Filetypes: { "python" }
  • Method: formatting
  • Command: isort
  • Args: { "--stdout", "--filename", "$FILENAME", "-" }

joker¤

joker is a small Clojure interpreter, linter and formatter written in Go.

local sources = { null_ls.builtins.formatting.joker }

Defaults

  • Filetypes: { "clj" }
  • Method: formatting
  • Command: joker
  • Args: { "--format", "-" }

json_tool¤

Provides a simple command line interface to validate and pretty-print JSON objects.

local sources = { null_ls.builtins.formatting.json_tool }

Defaults

  • Filetypes: { "json" }
  • Method: formatting
  • Command: python
  • Args: { "-m", "json.tool" }

ktlint¤

An anti-bikeshedding Kotlin linter with built-in formatter.

local sources = { null_ls.builtins.formatting.ktlint }

Defaults

  • Filetypes: { "kotlin" }
  • Method: formatting
  • Command: ktlint
  • Args: { "--format", "--stdin" }

latexindent¤

A perl script for formatting LaTeX files that is generally included in major TeX distributions.

local sources = { null_ls.builtins.formatting.latexindent }

Defaults

  • Filetypes: { "tex" }
  • Method: formatting
  • Command: latexindent
  • Args: { "-" }

lua_format¤

Reformats your Lua source code.

local sources = { null_ls.builtins.formatting.lua_format }

Defaults

  • Filetypes: { "lua" }
  • Method: formatting
  • Command: lua-format
  • Args: { "-i" }

markdownlint¤

A Node.js style checker and lint tool for Markdown/CommonMark files.

local sources = { null_ls.builtins.formatting.markdownlint }

Defaults

  • Filetypes: { "markdown" }
  • Method: formatting
  • Command: markdownlint
  • Args: { "--fix", "$FILENAME" }

Notes

  • Can fix some (but not all!) markdownlint issues. If possible, use Prettier, which can also fix Markdown files.

mix¤

Build tool that provides tasks for creating, compiling, and testing elixir projects, managing its dependencies, and more.

local sources = { null_ls.builtins.formatting.mix }

Defaults

  • Filetypes: { "elixir" }
  • Method: formatting
  • Command: mix
  • Args: { "format", "-" }

nginx_beautifier¤

Beautifies and formats nginx configuration files.

local sources = { null_ls.builtins.formatting.nginx_beautifier }

Defaults

  • Filetypes: { "nginx" }
  • Method: formatting
  • Command: nginxbeautifier
  • Args: { "-i", "-o", "$FILENAME" }

nimpretty¤

nimpretty is a Nim source code beautifier, to format code according to the official style guide.

local sources = { null_ls.builtins.formatting.nimpretty }

Defaults

  • Filetypes: { "nim" }
  • Method: formatting
  • Command: nimpretty
  • Args: { "$FILENAME" }

nixfmt¤

nixfmt is a formatter for Nix code, intended to apply a uniform style.

local sources = { null_ls.builtins.formatting.nixfmt }

Defaults

  • Filetypes: { "nix" }
  • Method: formatting
  • Command: nixfmt

nixpkgs_fmt¤

nixpkgs-fmt is a Nix code formatter for nixpkgs.

local sources = { null_ls.builtins.formatting.nixpkgs_fmt }

Defaults

  • Filetypes: { "nix" }
  • Method: formatting
  • Command: nixpkgs-fmt

perltidy¤

perl script which indents and reformats perl scripts to make them easier to read. If you write perl scripts, or spend much time reading them, you will probably find it useful.

local sources = { null_ls.builtins.formatting.perltidy }

Defaults

  • Filetypes: { "perl" }
  • Method: formatting
  • Command: perltidy
  • Args: { "-q" }

pg_format¤

PostgreSQL SQL syntax beautifier

local sources = { null_ls.builtins.formatting.pg_format }

Defaults

  • Filetypes: { "sql", "pgsql" }
  • Method: formatting
  • Command: pg_format

phpcbf¤

Tokenizes PHP files and detects violations of a defined set of coding standards.

local sources = { null_ls.builtins.formatting.phpcbf }

Defaults

  • Filetypes: { "php" }
  • Method: formatting
  • Command: phpcbf
  • Args: { "-q", "--stdin-path=$FILENAME", "-" }

phpcsfixer¤

Formatter for php files.

local sources = { null_ls.builtins.formatting.phpcsfixer }

Defaults

  • Filetypes: { "php" }
  • Method: formatting
  • Command: php-cs-fixer
  • Args: { "--no-interaction", "--quiet", "fix", "$FILENAME" }

prettier¤

Prettier is an opinionated code formatter. It enforces a consistent style by parsing your code and re-printing it with its own rules that take the maximum line length into account, wrapping code when necessary.

local sources = { null_ls.builtins.formatting.prettier }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue", "css", "scss", "less", "html", "json", "jsonc", "yaml", "markdown", "graphql", "handlebars" }
  • Methods: formatting, range_formatting
  • Command: prettier
  • Args: dynamically resolved (see source)

Notes

  • Supports more filetypes such as Svelte and TOML via plugins. These filetypes are not enabled by default, but you can follow the instructions here to define your own list of filetypes.
  • To increase speed, you may want to try prettierd. You can also set up eslint-plugin-prettier and format via eslint_d.

prettierd¤

prettier, as a daemon, for ludicrous formatting speed.

local sources = { null_ls.builtins.formatting.prettierd }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue", "css", "scss", "less", "html", "json", "jsonc", "yaml", "markdown", "graphql", "handlebars" }
  • Method: formatting
  • Command: prettierd
  • Args: { "$FILENAME" }

prettier_d_slim¤

Makes prettier fast.

local sources = { null_ls.builtins.formatting.prettier_d_slim }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue", "css", "scss", "less", "html", "json", "jsonc", "yaml", "markdown", "graphql", "handlebars" }
  • Methods: formatting, range_formatting
  • Command: prettier_d_slim
  • Args: dynamically resolved (see source)

Notes

  • May not work on some filetypes.
  • prettierd is more stable and recommended.

prettier_standard¤

Formats with Prettier and lints with ESLint+Standard! (✿◠‿◠)

local sources = { null_ls.builtins.formatting.prettier_standard }

Defaults

  • Filetypes: { "javascript", "javascriptreact" }
  • Method: formatting
  • Command: prettier-standard
  • Args: { "--stdin" }

prismaFmt¤

Formatter for the prisma filetype.

local sources = { null_ls.builtins.formatting.prismaFmt }

Defaults

  • Filetypes: { "prisma" }
  • Method: formatting
  • Command: prisma-fmt
  • Args: { "format", "-i", "$FILENAME" }

protolint¤

A pluggable linter and fixer to enforce Protocol Buffer style and conventions.

local sources = { null_ls.builtins.formatting.protolint }

Defaults

  • Filetypes: { "proto" }
  • Method: formatting
  • Command: protolint
  • Args: { "--fix", "$FILENAME" }

ptop¤

The FPC Pascal configurable source beautifier. Name means 'Pascal-TO-Pascal'.

local sources = { null_ls.builtins.formatting.ptop }

Defaults

  • Filetypes: { "pascal", "delphi" }
  • Method: formatting
  • Command: ptop
  • Args: { "$FILENAME", "$FILENAME" }

puppet_lint¤

Check that your Puppet manifest conforms to the style guide

local sources = { null_ls.builtins.formatting.puppet_lint }

Defaults

  • Filetypes: { "puppet", "epuppet" }
  • Method: formatting
  • Command: puppet-lint
  • Args: { "--fix", "$FILENAME" }

qmlformat¤

qmlformat is a tool that automatically formats QML files according to the QML Coding Conventions.

local sources = { null_ls.builtins.formatting.qmlformat }

Defaults

  • Filetypes: { "qml" }
  • Method: formatting
  • Command: qmlformat
  • Args: { "-i", "$FILENAME" }

raco_fmt¤

The fmt package provides an extensible tool to format Racket code, using an expressive pretty printer library to compute the optimal layout.

local sources = { null_ls.builtins.formatting.raco_fmt }

Defaults

  • Filetypes: { "racket" }
  • Method: formatting
  • Command: raco
  • Args: { "fmt" }

Notes

  • Requires Racket 8.0 or later
  • Install with raco pkg install fmt

remark¤

remark is an extensive and complex Markdown formatter/prettifier.

local sources = { null_ls.builtins.formatting.remark }

Defaults

  • Filetypes: { "markdown" }
  • Method: formatting
  • Command: remark
  • Args: { "--no-color", "--silent" }

Notes

reorder_python_imports¤

Tool for automatically reordering python imports. Similar to isort but uses static analysis more.

local sources = { null_ls.builtins.formatting.reorder_python_imports }

Defaults

  • Filetypes: { "python" }
  • Method: formatting
  • Command: reorder-python-imports
  • Args: { "-", "--exit-zero-even-if-changed" }

rescript¤

The ReScript format builtin.

local sources = { null_ls.builtins.formatting.rescript }

Defaults

  • Filetypes: { "rescript" }
  • Method: formatting
  • Command: rescript
  • Args: dynamically resolved (see source)

rubocop¤

Ruby static code analyzer and formatter, based on the community Ruby style guide.

local sources = { null_ls.builtins.formatting.rubocop }

Defaults

  • Filetypes: { "ruby" }
  • Method: formatting
  • Command: rubocop
  • Args: { "--auto-correct", "-f", "quiet", "--stderr", "--stdin", "$FILENAME" }

rufo¤

Opinionated ruby formatter.

local sources = { null_ls.builtins.formatting.rufo }

Defaults

  • Filetypes: { "ruby" }
  • Method: formatting
  • Command: rufo
  • Args: { "-x" }

rustfmt¤

A tool for formatting rust code according to style guidelines.

local sources = { null_ls.builtins.formatting.rustfmt }

Defaults

  • Filetypes: { "rust" }
  • Method: formatting
  • Command: rustfmt
  • Args: { "--emit=stdout" }

Notes

  • --edition defaults to 2015. To set a different edition, use extra_args.
  • See the wiki for other workarounds.

rustywind¤

CLI for organizing Tailwind CSS classes.

local sources = { null_ls.builtins.formatting.rustywind }

Defaults

  • Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue", "svelte", "html" }
  • Method: formatting
  • Command: rustywind
  • Args: { "--stdin" }

scalafmt¤

Code formatter for Scala

local sources = { null_ls.builtins.formatting.scalafmt }

Defaults

  • Filetypes: { "scala" }
  • Method: formatting
  • Command: scalafmt
  • Args: { "--stdin" }

shellharden¤

Hardens shell scripts by quoting variables, replacing function_call with $(function_call), and more.

local sources = { null_ls.builtins.formatting.shellharden }

Defaults

  • Filetypes: { "sh" }
  • Method: formatting
  • Command: shellharden
  • Args: { "--transform", "" }

shfmt¤

A shell parser, formatter, and interpreter with bash support.

local sources = { null_ls.builtins.formatting.shfmt }

Defaults

  • Filetypes: { "sh" }
  • Method: formatting
  • Command: shfmt
  • Args: { "-filename", "$FILENAME" }

sqlformat¤

The sqlformat command-line tool can reformat SQL files according to specified options.

local sources = { null_ls.builtins.formatting.sqlformat }

Defaults

  • Filetypes: { "sql" }
  • Method: formatting
  • Command: sqlformat
  • Args: { "-" }

standardjs¤

JavaScript Standard Style, a no-configuration automatic code formatter that just works.

local sources = { null_ls.builtins.formatting.standardjs }

Defaults

  • Filetypes: { "javascript", "javascriptreact" }
  • Method: formatting
  • Command: standard
  • Args: { "--stdin", "--fix" }

standardrb¤

Ruby Style Guide, with linter & automatic code fixer. Based on Rubocop.

local sources = { null_ls.builtins.formatting.standardrb }

Defaults

  • Filetypes: { "ruby" }
  • Method: formatting
  • Command: standardrb
  • Args: { "--fix", "--format", "quiet", "--stderr", "--stdin", "$FILENAME" }

stylelint¤

A mighty, modern linter that helps you avoid errors and enforce conventions in your styles.

local sources = { null_ls.builtins.formatting.stylelint }

Defaults

  • Filetypes: { "scss", "less", "css", "sass" }
  • Method: formatting
  • Command: stylelint
  • Args: { "--fix", "--stdin", "--stdin-filename", "$FILENAME" }

styler¤

Non-invasive pretty printing of R code.

local sources = { null_ls.builtins.formatting.styler }

Defaults

  • Filetypes: { "r", "rmd" }
  • Method: formatting
  • Command: R
  • Args: dynamically resolved (see source)

stylua¤

An opinionated code formatter for Lua.

local sources = { null_ls.builtins.formatting.stylua }

Defaults

  • Filetypes: { "lua" }
  • Methods: formatting, range_formatting
  • Command: stylua
  • Args: dynamically resolved (see source)

surface¤

A code formatter for Surface, the server-side rendering component library for Phoenix.

local sources = { null_ls.builtins.formatting.surface }

Defaults

  • Filetypes: { "elixir", "surface" }
  • Method: formatting
  • Command: mix
  • Args: { "surface.format", "-" }

swiftformat¤

SwiftFormat is a code library and command-line tool for reformatting swift code on macOS or Linux.

local sources = { null_ls.builtins.formatting.swiftformat }

Defaults

  • Filetypes: { "swift" }
  • Method: formatting
  • Command: swiftformat

taplo¤

A versatile, feature-rich TOML toolkit.

local sources = { null_ls.builtins.formatting.taplo }

Defaults

  • Filetypes: { "toml" }
  • Method: formatting
  • Command: taplo
  • Args: { "format", "-" }

terrafmt¤

The terrafmt command formats terraform blocks embedded in Markdown files.

local sources = { null_ls.builtins.formatting.terrafmt }

Defaults

  • Filetypes: { "markdown" }
  • Method: formatting
  • Command: terrafmt
  • Args: { "fmt", "$FILENAME" }

terraform_fmt¤

The terraform-fmt command rewrites terraform configuration files to a canonical format and style.

local sources = { null_ls.builtins.formatting.terraform_fmt }

Defaults

  • Filetypes: { "terraform", "tf" }
  • Method: formatting
  • Command: terraform
  • Args: { "fmt", "-" }

tidy¤

Tidy corrects and cleans up HTML and XML documents by fixing markup errors and upgrading legacy code to modern standards.

local sources = { null_ls.builtins.formatting.tidy }

Defaults

  • Filetypes: { "html", "xml" }
  • Method: formatting
  • Command: tidy
  • Args: { "--tidy-mark", "no", "-quiet", "-indent", "-wrap", "-" }

trim_newlines¤

A simple wrapper around awk to remove trailing newlines.

local sources = { null_ls.builtins.formatting.trim_newlines }

Defaults

  • Filetypes: {}
  • Method: formatting
  • Command: awk
  • Args: { 'NF{print s $0; s=""; next} {s=s ORS}' }

trim_whitespace¤

A simple wrapper around awk to remove trailing whitespace.

local sources = { null_ls.builtins.formatting.trim_whitespace }

Defaults

  • Filetypes: {}
  • Method: formatting
  • Command: awk
  • Args: { '{ sub(/[ \t]+$/, ""); print }' }

uncrustify¤

A source code beautifier for C, C++, C#, ObjectiveC, D, Java, Pawn and Vala.

local sources = { null_ls.builtins.formatting.uncrustify }

Defaults

  • Filetypes: { "c", "cpp", "cs", "java" }
  • Method: formatting
  • Command: uncrustify
  • Args: dynamically resolved (see source)

xmllint¤

Despite the name, xmllint can be used to format XML files as well as lint them, and that's the mode this builtin is using.

local sources = { null_ls.builtins.formatting.xmllint }

Defaults

  • Filetypes: { "xml" }
  • Method: formatting
  • Command: xmllint
  • Args: { "--format", "-" }

yapf¤

Formatter for Python.

local sources = { null_ls.builtins.formatting.yapf }

Defaults

  • Filetypes: { "python" }
  • Methods: formatting, range_formatting
  • Command: yapf
  • Args: dynamically resolved (see source)

zigfmt¤

Reformat Zig source into canonical form.

local sources = { null_ls.builtins.formatting.zigfmt }

Defaults

  • Filetypes: { "zig" }
  • Method: formatting
  • Command: zig
  • Args: { "fmt", "--stdin" }

Hover¤

dictionary¤

Shows the first available definition for the current word under the cursor.

local sources = { null_ls.builtins.hover.dictionary }

Defaults

  • Filetypes: { "text", "markdown" }
  • Method: hover

Notes

  • Depends on Plenary's curl module, which itself depends on having curl installed and available on your $PATH.
Back to top
Copyright © Gunther Klessinger
Made with Material for MkDocs