Built-in Sources

This is an automatically generated list of all null-ls built-in sources.

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

Code Actions
Completion
Diagnostics
Formatting
Hover

Code Actions

cspell

Injects actions to fix typos found by cspell.

This source is not actively developed in this repository.

An up-to-date version exists as a companion plugin in cspell.nvim

Usage

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

Defaults

Filetypes: {}
Method: code_action

Config

`find_json` (function)

Customizing the location of cspell config

local cspell = null_ls.builtins.code_actions.cspell.with({
    config = {
        find_json = function(cwd)
            return vim.fn.expand(cwd .. "/cspell.json")
        end
    },
})

`on_success` (function)

Callback after successful execution of code action.

local cspell = null_ls.builtins.code_actions.cspell.with({
    config = {
        on_success = function(cspell_config_file, params)
            -- format the cspell config file
            os.execute(
                string.format(
                    "cat %s | jq -S '.words |= sort' | tee %s > /dev/null",
                    cspell_config_file,
                    cspell_config_file
                )
            )
        end
    },
})

Notes

This source depends on the cspell built-in diagnostics source, so make sure to register it, too.

eslint

Injects actions to fix ESLint issues or ignore broken rules.

Usage

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.

Usage

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" }

Notes

Once spawned, the server will continue to run in the background. This is normal and not related to null-ls. You can stop it by running eslint_d stop from the command line.

gitrebase

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

Usage

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.).

Usage

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

Defaults

Filetypes: {}
Method: code_action

Config

`filter_actions` (function)

Callback to filter out unwanted actions.

local gitsigns = null_ls.builtins.code_actions.gitsigns.with({
    config = {
        filter_actions = function(title)
            return title:lower():match("blame") == nil -- filter out blame actions
        end,
    },
})

gomodifytags

Go tool to modify struct field tags

Usage

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

Defaults

Filetypes: { "go" }
Method: code_action

Notes

Requires installing the Go tree-sitter parser.

impl

impl generates method stubs for implementing an interface.

Usage

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

Defaults

Filetypes: { "go" }
Method: code_action

Notes

Requires installing the Go tree-sitter parser.

ltrs

LanguageTool-Rust (LTRS) is both an executable and a Rust library that aims to provide correct and safe bindings for the LanguageTool API.

Usage

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

Defaults

Filetypes: { "text", "markdown" }
Method: code_action
Command: ltrs
Args: { "check", "-m", "-r", "--text", "$TEXT" }

proselint

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

Usage

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.

Usage

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.

Usage

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.

Usage

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

Usage

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.

Usage

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.

Usage

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

Defaults

Filetypes: {}
Method: completion

vsnip

Snippets managed by vim-vsnip.

Usage

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.

Usage

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

Defaults

Filetypes: { "yaml" }
Method: diagnostics
Command: actionlint
Args: dynamically resolved (see source)

alex

Catch insensitive, inconsiderate writing.

Usage

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.

Usage

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

Defaults

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

bslint

A brighterscript CLI tool to lint your code without compiling your project.

Usage

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

Defaults

Filetypes: { "brs" }
Method: diagnostics
Command: bslint
Args: { "--files", "$FILENAME" }

buf

A new way of working with Protocol Buffers.

Usage

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

Defaults

Filetypes: { "proto" }
Method: diagnostics_on_save
Command: buf
Args: { "lint", "$FILENAME#include_package_files=true" }

buildifier

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

Usage

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

Defaults

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

cfn_lint

Validate AWS CloudFormation yaml/json templates against the AWS CloudFormation Resource Specification

Usage

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

Defaults

Filetypes: { "yaml", "json" }
Method: diagnostics
Command: cfn-lint
Args: { "--format", "parseable", "-" }

Notes

Once a supported file type is opened null-ls will try and determine if the file looks like an AWS Cloudformation template.
A file will be considered an AWS Cloudformation template if it contains a "Resources" or "AWSTemplateFormatVersion" key.
To prevent cfn-lint running on all YAML and JSON files that contain a "Resources" key.
The file must contain at least one AWS Cloudformation Resource Type, e.g "Type": "AWS::S3::Bucket"
This check will run only once when entering the buffer.
This means if "Resources" or "AWSTemplateFormatVersion" is added to a file after this check is run, the cfn-lint diagnostics will not be generated.
To fix this you must restart Neovim.

checkmake

make linter.

Usage

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

Defaults

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

checkstyle

Checkstyle is a tool for checking Java source code for adherence to a Code Standard or set of validation rules (best practices).

Usage

local sources = {
    null_ls.builtins.diagnostics.checkstyle.with({
        extra_args = { "-c", "/google_checks.xml" }, -- or "/sun_checks.xml" or path to self written rules
    }),
}

Defaults

Filetypes: { "java" }
Method: diagnostics_on_save
Command: checkstyle
Args: { "-f", "sarif", "$ROOT" }

Notes

Checkstyle only offers a jar file as download. It is recommended to put an executable wrapper script in your path. Example wrapper script:

#!/usr/bin/env bash
java -jar path/to/checkstyle.jar "$@"

Checkstyle needs a mandatory -c argument. Use extra_args to add yours. extra_args can also be a function to build more sophisticated logic.

chktex

latex semantic linter.

Usage

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

Defaults

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

clang_check

ClangCheck combines the LibTooling framework for running a Clang tool with the basic Clang diagnostics by syntax checking specific files in a fast, command line interface.

Usage

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

Defaults

Filetypes: { "c", "cpp" }
Method: diagnostics_on_save
Command: clang-check
Args: { "--analyze", "--extra-arg=-Xclang", "--extra-arg=-analyzer-output=text", "--extra-arg=-fno-color-diagnostics", "-p", "build", "$FILENAME" }

Notes

clang-check will be run only when files are saved to disk, so that compile_commands.json files can be used. It is recommended to use this linter in combination with compile_commands.json files.

clazy

Qt-oriented static code analyzer based on the Clang framework

Usage

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

Defaults

Filetypes: { "cpp" }
Method: diagnostics_on_save
Command: clazy-standalone
Args: { "--ignore-included-files", "--header-filter=$ROOT/.*", "$FILENAME" }

Notes

clazy needs a compilation database (compile_commands.json) to work. By default clazy will search for a compilation database in all parent folders of the input file.
If the compilation database is not in a parent folder, the -p option can be used to point to the corresponding folder (e.g. the projects build directory):

local sources = {
    null_ls.builtins.diagnostics.clazy.with({
        extra_args = { "-p=$ROOT/build" },
    }),
}

Alternatively, compile_commands.json can be linked into the project's root directory. For more information see https://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
clazy will be run only when files are saved to disk, so that compile_commands.json can be used.

clj_kondo

A linter for clojure code that sparks joy

Usage

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

Defaults

Filetypes: { "clojure" }
Method: diagnostics
Command: clj-kondo
Args: { "--cache", "--lint", "-", "--filename", "$FILENAME" }

cmake_lint

Check cmake listfiles for style violations, common mistakes, and anti-patterns.

Usage

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

Defaults

Filetypes: { "cmake" }
Method: diagnostics_on_save
Command: cmake-lint
Args: { "$FILENAME" }

codespell

Codespell finds common misspellings in text files.

Usage

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

Defaults

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

commitlint

commitlint checks if your commit messages meet the conventional commit format.

Usage

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

Defaults

Filetypes: { "gitcommit" }
Method: diagnostics
Command: commitlint
Args: { "--format", "commitlint-format-json" }

Notes

Needs npm packages commitlint and a json formatter: @commitlint/{config-conventional,cli} and commitlint-format-json.
It works with the packages installed globally but watch out for some common issues.

cppcheck

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

Usage

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

Defaults

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

cpplint

Cpplint is a command-line tool to check C/C++ files for style issues following Google's C++ style guide

Usage

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

Defaults

Filetypes: { "cpp", "c" }
Method: diagnostics
Command: cpplint
Args: { "$FILENAME" }

credo

Static analysis of elixir files for enforcing code consistency.

Usage

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.

This source is not actively developed in this repository.

An up-to-date version exists as a companion plugin in cspell.nvim

Usage

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.

Usage

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

Defaults

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

curlylint

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

Usage

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.

Usage

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

Defaults

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

deno_lint

Blazing fast linter for JavaScript and TypeScript written in Rust

Usage

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

Defaults

Filetypes: { "javascript", "typescript", "typescriptreact", "javascriptreact" }
Method: diagnostics
Command: deno
Args: { "lint", "--json", "$FILENAME" }

djlint

✨ 📜 🪄 ✨ HTML Template Linter and Formatter.

Usage

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

Defaults

Filetypes: { "django", "jinja.html", "htmldjango" }
Method: diagnostics
Command: djlint
Args: { "--quiet", "-" }

dotenv_linter

Lightning-fast linter for .env files.

Usage

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

Defaults

Filetypes: { "sh" }
Method: diagnostics
Command: dotenv-linter
Args: { "$FILENAME" }

editorconfig_checker

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

Usage

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

Defaults

Filetypes: {}
Method: diagnostics
Command: editorconfig-checker
Args: { "-no-color", "$FILENAME" }

erb_lint

Lint your ERB or HTML files

Usage

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

Defaults

Filetypes: { "eruby" }
Method: diagnostics
Command: erblint
Args: { "--format", "json", "--stdin", "$FILENAME" }

eslint

A linter for the JavaScript ecosystem.

Usage

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.

Usage

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" }

Notes

Once spawned, the server will continue to run in the background. This is normal and not related to null-ls. You can stop it by running eslint_d stop from the command line.

fish

Basic linting is available for fish scripts using fish --no-execute.

Usage

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

Defaults

Filetypes: { "fish" }
Method: diagnostics
Command: fish
Args: { "--no-execute", "$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.

Usage

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

Defaults

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

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.

Usage

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" }

gdlint

A linter that performs a static analysis on gdscript code according to some predefined configuration.

Usage

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

Defaults

Filetypes: { "gdscript" }
Method: diagnostics
Command: gdlint
Args: { "$FILENAME" }

gitlint

Linter for Git commit messages.

Usage

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

Defaults

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

glslc

Shader to SPIR-V compiler.

Usage

local sources = {
    null_ls.builtins.diagnostics.glslc.with({
        extra_args = { "--target-env=opengl" }, -- use opengl instead of vulkan1.0
    }),
}

Defaults

Filetypes: { "glsl" }
Method: diagnostics
Command: glslc
Args: { "-o", "-", "$FILENAME" }

Notes

The shader stage can be extracted from the file extension (.vert, .geom, .frag, etc.), but note that these file extensions are at the time of writing not natively recognized to be glsl files (only .glsl is). The shader stage can also be extracted from the file contents by adding a #pragma shader_stage(<stage>). For more information see man glslc.
the --target-env can be specified in extra_args. Defaults to vulkan1.0. Check man glslc for more possible targets environments.

golangci_lint

A Go linter aggregator.

Usage

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

Defaults

Filetypes: { "go" }
Method: diagnostics_on_save
Command: golangci-lint
Args: { "run", "--fix=false", "--out-format=json" }

gospel

misspelled word linter for Go comments, string literals and embedded files

Usage

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

Defaults

Filetypes: { "go" }
Method: diagnostics
Command: gospel
Args: { "$DIRNAME" }

hadolint

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

Usage

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

Defaults

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

haml_lint

Tool for writing clean and consistent HAML.

Usage

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

Defaults

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

jshint

JSHint is a tool that helps to detect errors and potential problems in your JavaScript code.

Usage

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

Defaults

Filetypes: { "javascript" }
Method: diagnostics
Command: jshint
Args: { "--reporter", "unix", "--extract", "auto", "--filename", "$FILENAME", "-" }

jsonlint

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

Usage

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.

Usage

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

Defaults

Filetypes: { "kotlin" }
Method: diagnostics_on_save
Command: ktlint
Args: { "--relative", "--reporter=json", "**/*.kt", "**/*.kts" }

ltrs

LanguageTool-Rust (LTRS) is both an executable and a Rust library that aims to provide correct and safe bindings for the LanguageTool API.

Usage

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

Defaults

Filetypes: { "text", "markdown", "markdown" }
Method: diagnostics
Command: ltrs
Args: { "check", "-m", "-r", "--text", "$TEXT" }

luacheck

A tool for linting and static analysis of Lua code.

Usage

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.

Usage

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

Defaults

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

markdownlint_cli2

A fast, flexible, configuration-based command-line interface for linting Markdown/CommonMark files with the markdownlint library

Usage

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

Defaults

Filetypes: { "markdown" }
Method: diagnostics_on_save
Command: markdownlint-cli2

Notes

Must be configured using a configuration file.
See the documentation to understand the differences between markdownlint-cli2 and markdownlint-cli.

markuplint

A linter for all markup developers.

Usage

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

Defaults

Filetypes: { "html" }
Method: diagnostics
Command: markuplint
Args: { "--format", "JSON", "$FILENAME" }

mdl

A tool to check Markdown files and flag style issues.

Usage

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.

Usage

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

Defaults

Filetypes: {}
Method: diagnostics
Command: misspell

mlint

Linter for MATLAB files

Usage

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

Defaults

Filetypes: { "matlab", "octave" }
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.

Usage

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

Defaults

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

npm_groovy_lint

Lint, format and auto-fix Groovy, Jenkinsfile, and Gradle files.

Usage

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

Defaults

Filetypes: { "groovy", "java", "Jenkinsfile" }
Method: diagnostics
Command: npm-groovy-lint
Args: { "-o", "json", "-" }

opacheck

Check Rego source files for parse and compilation errors.

Usage

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

Defaults

Filetypes: { "rego" }
Method: diagnostics_on_save
Command: opa
Args: { "check", "-f", "json", "--strict", "$ROOT", "--ignore=*.yaml", "--ignore=*.yml", "--ignore=*.json", "--ignore=.git/**/*" }

perlimports

A command line utility for cleaning up imports in your Perl code

Usage

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

Defaults

Filetypes: { "perl" }
Method: diagnostics
Command: perlimports
Args: { "--lint", "--read-stdin", "--filename", "$FILENAME" }

php

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

Usage

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.

Usage

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", "--stdin-path=$FILENAME", "--basepath=" }

phpmd

Runs PHP Mess Detector against PHP files.

Usage

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

Defaults

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

phpstan

PHP static analysis tool.

Usage

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.
If in place validation is required set method to diagnostics_on_save and to_temp_file to false

pmd

An extensible cross-language static code analyzer.

Usage

local sources = {
    null_ls.builtins.diagnostics.pmd.with({
        extra_args = {
            "--rulesets",
            "category/java/bestpractices.xml,category/jsp/bestpractices.xml" -- or path to self-written ruleset
        },
    }),
}

Defaults

Filetypes: { "java", "jsp" }
Method: diagnostics_on_save
Command: pmd
Args: { "--format", "json", "--dir", "$ROOT" }

Notes

PMD only offers parameterized wrapper scripts as download. It is recommended to put an executable wrapper script in your path. Example wrapper script:

#!/usr/bin/env bash
path/to/pmd/bin/run.sh pmd "$@"

PMD needs a mandatory --rulesets/-rulesets/-R argument. Use extra_args to add yours. extra_args can also be a function to build more sophisticated logic.

proselint

An English prose linter.

Usage

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.

Usage

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.

Usage

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.

Usage

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.

Usage

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.

Usage

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

Defaults

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

pycodestyle

pycodestyle is a tool to check your Python code against some of the style conventions in PEP 8.

Usage

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

Defaults

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

pydocstyle

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

Usage

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.

Usage

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.

If you prefer to use the older "message-id" names for these errors (i.e. "W0612" instead of "unused-variable"), you can customize pylint's resulting diagnostics like so:

null_ls = require("null-ls")
null_ls.setup({
  sources = {
    null_ls.builtins.diagnostics.pylint.with({
      diagnostics_postprocess = function(diagnostic)
        diagnostic.code = diagnostic.message_id
      end,
    }),
    null_ls.builtins.formatting.isort,
    null_ls.builtins.formatting.black,
    ...,
  },
})

Usage

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.

Usage

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.

Usage

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

Defaults

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

reek

Code smell detector for Ruby

Usage

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

Defaults

Filetypes: { "ruby" }
Method: diagnostics
Command: reek
Args: { "--format", "json", "--stdin-filename", "$FILENAME" }

revive

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

Usage

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

Defaults

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

Notes

extra_args does not work with this linter, since it does not support additional non-file arguments after the first file or ./... is specified. Overwrite args instead.

rpmspec

Command line tool to parse RPM spec files.

Usage

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.

Usage

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.

Usage

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

Defaults

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

ruff

An extremely fast Python linter, written in Rust.

Usage

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

Defaults

Filetypes: { "python" }
Method: diagnostics
Command: ruff
Args: { "-n", "-e", "--stdin-filename", "$FILENAME", "-" }

saltlint

A command-line utility that checks for best practices in SaltStack.

Usage

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

Defaults

Filetypes: { "sls" }
Method: diagnostics_on_save
Command: salt-lint
Args: { "--nocolor", "--json", "$FILENAME" }

selene

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

Usage

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

Defaults

Filetypes: { "lua", "luau" }
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.

Usage

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

Defaults

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

semistandardjs

JavaScript style guide, linter, and formatter.

Usage

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

Defaults

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

shellcheck

A shell script static analysis tool.

Usage

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

Defaults

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

solhint

An open source project for linting Solidity code. It provides both security and style guide validations.

Usage

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

Defaults

Filetypes: { "solidity" }
Method: diagnostics
Command: solhint
Args: { "$FILENAME", "--formatter", "unix" }

spectral

A flexible JSON/YAML linter for creating automated style guides, with baked in support for OpenAPI v3.1, v3.0, and v2.0.

Usage

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

Defaults

Filetypes: { "yaml", "json" }
Method: diagnostics
Command: spectral
Args: { "lint", "--stdin-filepath", "$FILENAME", "-f", "json" }

sqlfluff

A SQL linter and auto-formatter for Humans

Usage

local sources = {
    null_ls.builtins.diagnostics.sqlfluff.with({
        extra_args = { "--dialect", "postgres" }, -- change to your dialect
    }),
}

Defaults

Filetypes: { "sql" }
Method: diagnostics
Command: sqlfluff
Args: { "lint", "--disable-progress-bar", "-f", "github-annotation", "-n", "$FILENAME" }

Notes

SQLFluff needs a mandatory --dialect argument. Use extra_args to add yours, or create a .sqlfluff file in the same directory as the SQL file to specify the dialect (see the sqlfluff docs for details). extra_args can also be a function to build more sophisticated logic.

standardjs

JavaScript style guide, linter, and formatter.

Usage

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

Defaults

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

standardrb

Ruby style guide, linter, and formatter.

Usage

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.

Usage

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

Defaults

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

Notes

extra_args does not work with this linter, since it does not support additional non-file arguments after the first file or ./... is specified. Overwrite args instead.

statix

Lints and suggestions for the Nix programming language.

Usage

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.

Usage

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.

Usage

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

Defaults

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

swiftlint

A tool to enforce Swift style and conventions.

Usage

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

Defaults

Filetypes: { "swift" }
Method: diagnostics
Command: swiftlint
Args: { "--reporter", "json", "--use-stdin", "--quiet" }

teal

The compiler for Teal, a typed dialect of Lua.

Usage

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

Defaults

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

terraform_validate

Terraform validate is is a subcommand of terraform to validate configuration files in a directory

Usage

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

Defaults

Filetypes: { "terraform", "tf", "terraform-vars" }
Method: diagnostics_on_save
Command: terraform
Args: { "validate", "-json" }

textidote

Spelling, grammar and style checking on LaTeX documents.

Usage

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

Defaults

Filetypes: { "markdown", "tex" }
Methods: diagnostics_on_open, diagnostics_on_save
Command: textidote
Args: { "--read-all", "--output", "singleline", "--no-color", "--check", "en", "--quiet", "$FILENAME" }

textlint

The pluggable linting tool for text and Markdown.

Usage

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

Defaults

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

tfsec

Security scanner for Terraform code

Usage

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

Defaults

Filetypes: { "terraform", "tf", "terraform-vars" }
Method: diagnostics_on_save
Command: tfsec
Args: { "-s", "-f", "json", "$DIRNAME" }

tidy

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

Usage

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

Defaults

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

todo_comments

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

Usage

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

Defaults

Filetypes: {}
Method: diagnostics

trail_space

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

Usage

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

Defaults

Filetypes: {}
Method: diagnostics

tsc

Parses diagnostics from the TypeScript compiler.

Usage

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.

Usage

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

Defaults

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

typos

Source code spell checker written in rust

Usage

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

Defaults

Filetypes: {}
Method: diagnostics
Command: typos
Args: { "--format", "json", "-" }

vacuum

The world’s fastest and most scalable OpenAPI linter.

Usage

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

Defaults

Filetypes: { "yaml", "json" }
Method: diagnostics
Command: vacuum
Args: { "report", "--stdin", "--stdout" }

vale

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

Usage

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.

verilator

Verilog and SystemVerilog linter power by Verilator

Usage

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

Defaults

Filetypes: { "verilog", "systemverilog" }
Method: diagnostics
Command: verilator
Args: { "-lint-only", "-Wno-fatal", "$FILENAME" }

vint

Linter for Vimscript.

Usage

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.

Usage

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

Defaults

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

write_good

English prose linter.

Usage

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.

Usage

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.

Usage

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.

Usage

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

Defaults

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

Formatting

alejandra

The Uncompromising Nix Code Formatter

Usage

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

Defaults

Filetypes: { "nix" }
Method: formatting
Command: alejandra
Args: { "--quiet" }

asmfmt

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

Usage

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.

Usage

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

Defaults

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

autoflake

Removes unused imports and unused variables as reported by pyflakes

Usage

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

Defaults

Filetypes: { "python" }
Method: formatting
Command: autoflake
Args: { "--stdin-display-name", "$FILENAME", "-" }

autopep8

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

Usage

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.

Usage

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.

beautysh

A Bash beautifier for the masses.

Usage

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

Defaults

Filetypes: { "bash", "csh", "ksh", "sh", "zsh" }
Method: formatting
Command: beautysh
Args: { "$FILENAME" }

Notes

In addition to Bash, Beautysh can format csh, ksh, sh and zsh.

bibclean

A portable program (written in C) that will pretty-print, syntax check, and generally sort out a BibTeX database file.

Usage

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

Defaults

Filetypes: { "bib" }
Method: formatting
Command: bibclean
Args: { "-align-equals", "-delete-empty-values" }

Notes

See bibclean: prettyprint and syntax check BibTeX and Scribe bibliography data base files for latest version.

black

The uncompromising Python code formatter

Usage

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

Defaults

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

blackd

blackd is a small HTTP server that exposes Black’s functionality over a simple protocol. The main benefit of using it is to avoid the cost of starting up a new Black process every time you want to blacken a file. The only way to configure the formatter is by using the provided config options, it will not pick up on config files.

Usage

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

Defaults

Filetypes: { "python" }
Method: formatting

Config

`hostname` (string)

Address to bind the server to. Defaults to localhost.

`port` (string)

Port to listen on. Defaults to 45484.

`line_length` (number)

Set how many characters per line to allow. Defaults to 88.

`skip_source_first_line` (boolean)

If set to true, the first line of the source code will be ignored. Defaults to false.

`skip_string_normalization` (boolean)

If set to true, no string normalization will be performed. Defaults to false.

`skip_magic_trailing_comma` (boolean)

If set to true, trailing commas will not be used as a reason to split lines. Defaults to false.

`preview` (boolean)

If set to true, experimental and potentially disruptive style changes will be used. Defaults to false.

`fast` (boolean)

If set to true, Black will not perform an AST safety check after formatting. Defaults to false.

`python_variant` (string)

If set to pyi, Black will format all input files like typing stubs regardless of the file extension. Otherwise, its value must correspond to a Python version or a set of comma-separated Python versions, optionally prefixed with py. (e.g. py3.5,py3.6). Defaults to empty string.

blade_formatter

An opinionated blade template formatter for Laravel that respects readability

Usage

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

Defaults

Filetypes: { "blade" }
Method: formatting
Command: blade-formatter
Args: { "--write", "$FILENAME" }

blue

Blue -- Some folks like black but I prefer blue.

Usage

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

Defaults

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

brittany

haskell source code formatter

Usage

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

Defaults

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

bsfmt

A code formatter for BrightScript and BrighterScript.

Usage

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

Defaults

Filetypes: { "brs" }
Method: formatting
Command: bsfmt
Args: { "$FILENAME" }

buf

A new way of working with Protocol Buffers.

Usage

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

Defaults

Filetypes: { "proto" }
Method: formatting
Command: buf
Args: { "format", "-w", "$FILENAME" }

buildifier

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

Usage

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.

Usage

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

Defaults

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

cbfmt

A tool to format codeblocks inside markdown and org documents.

Usage

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

Defaults

Filetypes: { "markdown", "org" }
Method: formatting
Command: cbfmt
Args: { "--stdin-filepath", "$FILENAME", "--best-effort" }

clang_format

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

Usage

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

Defaults

Filetypes: { "c", "cpp", "cs", "java", "cuda", "proto" }
Methods: formatting, range_formatting
Command: clang-format
Args: dynamically resolved (see source)

cljstyle

Formatter for Clojure code.

Usage

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.

Usage

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

Defaults

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

codespell

Fix common misspellings in text files.

Usage

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

Defaults

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

crystal_format

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

Usage

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

Defaults

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

csharpier

CSharpier is an opinionated code formatter for c#

Usage

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

Defaults

Filetypes: { "cs" }
Method: formatting
Command: dotnet-csharpier
Args: { "--write-stdout" }

cueimports

CUE tool that updates your import lines, adding missing ones and removing unused ones.

Usage

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

Defaults

Filetypes: { "cue" }
Method: formatting
Command: cueimports

cue_fmt

A CUE language formatter.

Usage

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.

Usage

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

Defaults

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

deno_fmt

Use Deno to format TypeScript, JavaScript/JSON and markdown.

Usage

local sources = {
    null_ls.builtins.formatting.deno_fmt, -- will use the source for all supported file types
    null_ls.builtins.formatting.deno_fmt.with({
		filetypes = { "markdown" }, -- only runs `deno fmt` for markdown
    }),
}

Defaults

Filetypes: { "javascript", "javascriptreact", "json", "jsonc", "markdown", "typescript", "typescriptreact" }
Method: formatting
Command: deno
Args: dynamically resolved (see source)

Notes

deno fmt supports formatting JS/X, TS/X, JSON and markdown. If you only want deno to format a subset of these filetypes you can overwrite these with .with({filetypes={}})

dfmt

Formatter for D source code.

Usage

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

Defaults

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

djhtml

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

Usage

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

Defaults

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

djlint

✨ 📜 🪄 ✨ HTML Template Linter and Formatter.

Usage

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

Defaults

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

dprint

A pluggable and configurable code formatting platform written in Rust.

Usage

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

Defaults

Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "json", "markdown", "toml", "rust", "roslyn" }
Method: formatting
Command: dprint
Args: { "fmt", "--stdin", "$FILENAME" }

Notes

you need to install dprint to use this builtin and then run dprint init to initialize it in your project directory.

elm_format

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

Usage

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

Defaults

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

emacs_scheme_mode

An extensible, customizable, free/libre text editor — and more. Basically, using emacs in batch mode to format scheme files.

Usage

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

Defaults

Filetypes: { "scheme", "scheme.guile" }
Method: formatting
Command: emacs
Args: dynamically resolved (see source)

Notes

Adjust the expression evaluated with the --eval flag to change settings within emacs.

emacs_vhdl_mode

VHDL Mode is an Emacs major mode for editing VHDL code. Basically, using emacs in batch mode to format VHDL files.

Usage

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

Defaults

Filetypes: { "vhdl" }
Method: formatting
Command: emacs
Args: dynamically resolved (see source)

Notes

Adjust the expression evaluated with the --eval flag to change settings within emacs.

erb_format

Format ERB files with speed and precision.

Usage

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

Defaults

Filetypes: { "eruby" }
Method: formatting
Command: erb-format
Args: { "--stdin" }

erb_lint

Lint your ERB or HTML files

Usage

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

Defaults

Filetypes: { "eruby" }
Method: formatting
Command: erblint
Args: { "--autocorrect", "--stdin", "$FILENAME" }

erlfmt

An opinionated Erlang code formatter.

Usage

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

Defaults

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

eslint

Find and fix problems in your JavaScript code.

Usage

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

Like ESLint, but faster.

Usage

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" }

Notes

Once spawned, the server will continue to run in the background. This is normal and not related to null-ls. You can stop it by running eslint_d stop from the command line.

fantomas

FSharp source code formatter.

Usage

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

Defaults

Filetypes: { "fsharp" }
Method: formatting
Command: fantomas
Args: { "$FILENAME" }

fish_indent

Indent or otherwise prettify a piece of fish code.

Usage

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.

Usage

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.

Usage

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

Defaults

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

forge_fmt

Formats Solidity source files.

Usage

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

Defaults

Filetypes: { "solidity" }
Method: formatting
Command: forge
Args: { "fmt", "$FILENAME" }

format_r

Format R code automatically.

Usage

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.

Usage

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

Defaults

Filetypes: { "haskell" }
Method: formatting
Command: fourmolu
Args: { "--stdin-input-file", "$FILENAME" }

fprettify

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

Usage

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

Defaults

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

gdformat

A formatter for Godot's gdscript

Usage

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

Defaults

Filetypes: { "gd", "gdscript", "gdscript3" }
Method: formatting
Command: gdformat
Args: { "-" }

gersemi

A formatter to make your CMake code the real treasure

Usage

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

Defaults

Filetypes: { "cmake" }
Method: formatting
Command: gersemi
Args: { "-" }

gn_format

Format your GN code!

Usage

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

Defaults

Filetypes: { "gn" }
Method: formatting
Command: gn
Args: { "format", "--stdin" }

Notes

Install google depot_tools to use gn

gofmt

Formats go programs.

Usage

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.

Usage

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.

Usage

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

Defaults

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

goimports_reviser

Tool for Golang to sort goimports by 3 groups: std, general and project dependencies.

Usage

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

Defaults

Filetypes: { "go" }
Method: formatting
Command: goimports-reviser
Args: { "$FILENAME" }

golines

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

Usage

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.

Usage

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

Defaults

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

haxe_formatter

Haxe code formatter based on tokentree

Usage

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

Defaults

Filetypes: { "haxe" }
Method: formatting
Command: haxelib
Args: { "run", "formatter", "--stdin", "--source", "$FILENAME" }

hclfmt

Formatter for HCL configuration files

Usage

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

Defaults

Filetypes: { "hcl" }
Method: formatting
Command: hclfmt

htmlbeautifier

A normaliser/beautifier for HTML that also understands embedded Ruby. Ideal for tidying up Rails templates.

Usage

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

Defaults

Filetypes: { "eruby" }
Method: formatting
Command: htmlbeautifier
Args: {}

isort

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

Usage

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.

Usage

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

Defaults

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

jq

Command-line JSON processor

Usage

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

Defaults

Filetypes: { "json" }
Method: formatting
Command: jq

jsonnetfmt

Formats jsonnet files.

Usage

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

Defaults

Filetypes: { "jsonnet" }
Method: formatting
Command: jsonnetfmt
Args: { "-" }

json_tool

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

Usage

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

Defaults

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

just

Format your Justfile

Usage

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

Defaults

Filetypes: { "just" }
Method: formatting
Command: just
Args: { "--fmt", "--unstable", "-f", "$FILENAME" }

ktlint

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

Usage

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

Defaults

Filetypes: { "kotlin" }
Method: formatting
Command: ktlint
Args: { "--format", "--stdin", "**/*.kt", "**/*.kts" }

latexindent

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

Usage

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

Defaults

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

lua_format

Reformats your Lua source code.

Usage

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.

Usage

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.

markdown_toc

API and CLI for generating a markdown TOC (table of contents) for a README or any markdown files.

Usage

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

Defaults

Filetypes: { "markdown" }
Method: formatting
Command: markdown-toc
Args: { "-i", "$FILENAME" }

Notes

To generate a TOC, add  before headers in your markdown file.

mdformat

An opinionated Markdown formatter that can be used to enforce a consistent style in Markdown files

Usage

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

Defaults

Filetypes: { "markdown" }
Method: formatting
Command: mdformat
Args: { "$FILENAME" }

Notes

Mdformat offers an extensible plugin system for both code fence content formatting and Markdown parser extensions (like GFM tables). A comprehensive list of plugins is documented here

mix

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

Usage

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

Defaults

Filetypes: { "elixir" }
Method: formatting
Command: mix
Args: { "format", "--stdin-filename", "$FILENAME", "-" }

nginx_beautifier

Beautifies and formats nginx configuration files.

Usage

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.

Usage

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.

Usage

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.

Usage

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

Defaults

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

npm_groovy_lint

Lint, format and auto-fix Groovy, Jenkinsfile, and Gradle files.

Usage

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

Defaults

Filetypes: { "groovy", "java", "Jenkinsfile" }
Method: formatting
Command: npm-groovy-lint
Args: { "--format", "-" }

ocamlformat

Auto-formatter for OCaml code

Usage

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

Defaults

Filetypes: { "ocaml" }
Method: formatting
Command: ocamlformat
Args: { "--enable-outside-detected-project", "--name", "$FILENAME", "-" }

ocdc

A changelog formatter

Usage

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

Defaults

Filetypes: { "markdown" }
Method: formatting
Command: ocdc
Args: { "--path", "-" }

packer

The packer fmt Packer command is used to format HCL2 configuration files to a canonical format and style.

Usage

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

Defaults

Filetypes: { "hcl" }
Method: formatting
Command: packer
Args: { "fmt", "-" }

perlimports

A command line utility for cleaning up imports in your Perl code

Usage

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

Defaults

Filetypes: { "perl" }
Method: formatting
Command: perlimports
Args: { "--read-stdin", "--filename", "$FILENAME" }

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.

Usage

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

Defaults

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

pg_format

PostgreSQL SQL syntax beautifier

Usage

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.

Usage

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

Defaults

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

phpcsfixer

Formatter for php files.

Usage

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

Defaults

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

pint

An opinionated PHP code style fixer for minimalists.

Usage

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

Defaults

Filetypes: { "php" }
Method: formatting
Command: ./vendor/bin/pint
Args: { "--no-interaction", "--quiet", "$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.

Usage

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

Defaults

Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue", "css", "scss", "less", "html", "json", "jsonc", "yaml", "markdown", "markdown.mdx", "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.

Usage

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

Defaults

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

prettier_d_slim

Makes prettier fast.

Usage

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

Defaults

Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue", "css", "scss", "less", "html", "json", "jsonc", "yaml", "markdown", "markdown.mdx", "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_eslint

CLI for prettier-eslint

Usage

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

Defaults

Filetypes: { "javascript", "javascriptreact", "typescript", "typescriptreact", "vue", "css", "scss", "less", "html", "json", "jsonc", "yaml", "markdown", "markdown.mdx", "graphql", "handlebars" }
Method: formatting
Command: prettier-eslint
Args: { "--stdin", "--stdin-filepath", "$FILENAME" }

Notes

Known Issues: idahogurl/vs-code-prettier-eslint#72 (comment)

prettier_standard

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

Usage

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.

Usage

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

Defaults

Filetypes: { "prisma" }
Method: formatting
Command: prisma
Args: { "format", "$FILENAME" }

protolint

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

Usage

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'.

Usage

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

Usage

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

Defaults

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

purs_tidy

A syntax tidy-upper (formatter) for PureScript.

Usage

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

Defaults

Filetypes: { "purescript" }
Method: formatting
Command: purs-tidy
Args: { "format" }

Notes

For installation, use npm: npm install -g purs-tidy

pyflyby

Pyflyby is a set of Python programming productivity tools, useful for auto-import libraries

Usage

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

Defaults

Filetypes: { "python" }
Method: formatting
Command: tidy-imports
Args: { "-n" }

pyink

The Google Python code formatter

Usage

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

Defaults

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

qmlformat

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

Usage

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

Defaults

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

racket_fixw

A Racket formatter that add/remove some whitespaces but respects newline.

Usage

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

Defaults

Filetypes: { "racket" }
Method: formatting
Command: raco
Args: { "fixw" }

Notes

Install with raco pkg install fixw

raco_fmt

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

Usage

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

rego

Rego (opa fmt) Formatter

Usage

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

Defaults

Filetypes: { "rego" }
Method: formatting
Command: opa
Args: { "fmt" }

remark

remark is an extensive and complex Markdown formatter/prettifier.

Usage

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

Defaults

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

Notes

Depends on remark-cli.

reorder_python_imports

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

Usage

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.

Usage

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

Defaults

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

rome

Formatter, linter, bundler, and more for JavaScript, TypeScript, JSON, HTML, Markdown, and CSS.

Usage

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

Defaults

Filetypes: { "javascript", "typescript", "javascriptreact", "typescriptreact", "json" }
Method: formatting
Command: rome
Args: { "format", "--write", "$FILENAME" }

Notes

Currently support only JavaScript, TypeScript and JSON. See status here

rubocop

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

Usage

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

Defaults

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

rubyfmt

Format your Ruby code!

Usage

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

Defaults

Filetypes: { "ruby" }
Method: formatting
Command: rubyfmt
Args: {}

Notes

Install to your PATH with brew install rubyfmt. Ensure you have the latest version.

ruff

An extremely fast Python linter, written in Rust.

Usage

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

Defaults

Filetypes: { "python" }
Method: formatting
Command: ruff
Args: { "--fix", "-e", "-n", "--stdin-filename", "$FILENAME", "-" }

rufo

Opinionated ruby formatter.

Usage

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.

Usage

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.

Usage

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

Usage

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

Defaults

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

semistandardjs

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

Usage

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

Defaults

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

shellharden

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

Usage

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.

Usage

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

Defaults

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

smlfmt

A custom parser/auto-formatter for Standard ML

Usage

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

Defaults

Filetypes: { "sml" }
Method: formatting
Command: smlfmt
Args: { "--force", "$FILENAME" }

sqlfluff

A SQL linter and auto-formatter for Humans

Usage

local sources = {
    null_ls.builtins.formatting.sqlfluff.with({
        extra_args = { "--dialect", "postgres" }, -- change to your dialect
    }),
}

Defaults

Filetypes: { "sql" }
Method: formatting
Command: sqlfluff
Args: { "fix", "--disable-progress-bar", "-f", "-n", "-" }

Notes

SQLFluff needs a mandatory --dialect argument. Use extra_args to add yours. extra_args can also be a function to build more sophisticated logic.

sqlfmt

Formats your dbt SQL files so you don't have to

Usage

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

Defaults

Filetypes: { "sql", "jinja" }
Method: formatting
Command: sqlfmt
Args: { "-" }

Notes

Install sqlfmt with pip install shandy-sqlfmt[jinjafmt]

sqlformat

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

Usage

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

Defaults

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

sql_formatter

A whitespace formatter for different query languages

Usage

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

Defaults

Filetypes: { "sql" }
Method: formatting
Command: sql-formatter

standardjs

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

Usage

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.

Usage

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

Defaults

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

standardts

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

Usage

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

Defaults

Filetypes: { "typescript", "typescriptreact" }
Method: formatting
Command: ts-standard
Args: { "--stdin", "--fix" }

stylelint

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

Usage

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.

Usage

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

Defaults

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

stylish_haskell

Format Haskell code

Usage

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

Defaults

Filetypes: { "haskell" }
Method: formatting
Command: stylish-haskell
Args: {}

stylua

An opinionated code formatter for Lua.

Usage

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

Defaults

Filetypes: { "lua", "luau" }
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.

Usage

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.

Usage

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

Defaults

Filetypes: { "swift" }
Method: formatting
Command: swiftformat
Args: { "--stdinpath", "$FILENAME" }

swiftlint

A tool to enforce Swift style and conventions.

Usage

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

Defaults

Filetypes: { "swift" }
Method: formatting
Command: swiftlint
Args: { "lint", "--use-stdin", "--fix" }

swift_format

Swift formatter from apple. Requires building from source with swift build

Usage

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

Defaults

Filetypes: { "swift" }
Method: formatting
Command: swift-format
Args: {}

taplo

A versatile, feature-rich TOML toolkit.

Usage

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.

Usage

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.

Usage

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

Defaults

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

textlint

The pluggable linting tool for text and Markdown.

Usage

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

Defaults

Filetypes: { "txt", "markdown" }
Method: formatting
Command: textlint
Args: { "--fix", "$FILENAME" }

tidy

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

Usage

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

Defaults

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

topiary

A uniform formatter for simple languages

Usage

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

Defaults

Filetypes: { "ncl", "nickel" }
Method: formatting
Command: topiary
Args: { "-i", "-f", "$FILENAME" }

treefmt

One CLI to format your repo

Usage

local sources = {
    null_ls.builtins.formatting.treefmt.with({
        -- treefmt requires a config file
        condition = function(utils)
            return utils.root_has_file("treefmt.toml")
        end,
    }),
}

Defaults

Filetypes: {}
Method: formatting
Command: treefmt
Args: { "--allow-missing-formatter", "--stdin", "$FILENAME" }

trim_newlines

A simple wrapper around awk to remove trailing newlines.

Usage

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.

Usage

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.

Usage

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

Defaults

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

usort

Safe, minimal import sorting for Python projects.

Usage

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

Defaults

Filetypes: { "python" }
Method: formatting
Command: usort
Args: { "format", "-" }

verible_verilog_format

The verible-verilog-format formatter manages whitespace in accordance with a particular style. The main goal is to relieve humans of having to manually manage whitespace, wrapping, and indentation, and to provide a tool that can be integrated into any editor to enable editor-independent consistency.

Usage

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

Defaults

Filetypes: { "verilog", "systemverilog" }
Method: formatting
Command: verible-verilog-format
Args: { "--stdin_name", "$FILENAME", "-" }

xmlformat

xmlformatter is an Open Source Python package, which provides formatting of XML documents.

Usage

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

Defaults

Filetypes: { "xml" }
Method: formatting
Command: xmlformat
Args: { "-" }

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.

Usage

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

Defaults

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

xq

Command-line XML and HTML beautifier and content extractor

Usage

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

Defaults

Filetypes: { "xml" }
Method: formatting
Command: xq
Args: { ".", "$FILENAME" }

yamlfix

A configurable YAML formatter that keeps comments.

Usage

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

Defaults

Filetypes: { "yaml" }
Method: formatting
Command: yamlfix
Args: { "-" }

yamlfmt

yamlfmt is an extensible command line tool or library to format yaml files.

Usage

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

Defaults

Filetypes: { "yaml" }
Method: formatting
Command: yamlfmt
Args: { "-" }

yapf

Formatter for Python.

Usage

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

Defaults

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

yq

yq is a portable command-line YAML, JSON, XML, CSV and properties processor.

Usage

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

Defaults

Filetypes: { "yml", "yaml" }
Method: formatting
Command: yq
Args: { ".", "$FILENAME" }

zigfmt

Reformat Zig source into canonical form.

Usage

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

Defaults

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

zprint

Beautifully format Clojure and Clojurescript source code and s-expressions.

Usage

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

Defaults

Filetypes: { "clojure" }
Method: formatting
Command: zprint

Notes

Requires that zprint is executable and on $PATH.

Hover

dictionary

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

Usage

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

Defaults

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

Notes

Depends on Plenary's curl module, which itself depends on having curl installed and available on your $PATH.

printenv

Shows the value for the current environment variable under the cursor.

Usage

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

Defaults

Filetypes: { "sh", "dosbatch", "ps1" }
Method: hover

Notes

This source is similar in function to printenv where it shows value of environment variable, however this source uses vim.loop.os_getenv instead of printenv thus making it cross-platform.

티스토리 수익 글 보기

티스토리 수익 글 보기

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!