BUILTINS.md

<!-- THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT IT MANUALLY -->

# Built-in Sources

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

See [BUILTIN_CONFIG](BUILTIN_CONFIG.md) to learn how to set up and configure these sources.

- [Code Actions](#code-actions)
- [Completion](#completion)
- [Diagnostics](#diagnostics)
- [Formatting](#formatting)
- [Hover](#hover)

## Code Actions

### [cspell](https://github.com/streetsidesoftware/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](https://github.com/davidmh/cspell.nvim)

#### Usage

```lua
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

```lua
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.

```lua
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](https://github.com/eslint/eslint)

Injects actions to fix ESLint issues or ignore broken rules.

#### Usage

```lua
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](https://github.com/mantoni/eslint_d.js)

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

#### Usage

```lua
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

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

#### Defaults

- Filetypes: `{ "gitrebase" }`
- Method: `code_action`

### [gitsigns](https://github.com/lewis6991/gitsigns.nvim)

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

#### Usage

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

#### Defaults

- Filetypes: `{}`
- Method: `code_action`

#### Config

##### `filter_actions` (function)

Callback to filter out unwanted actions.

```lua
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](https://github.com/fatih/gomodifytags)

Go tool to modify struct field tags

#### Usage

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

#### Defaults

- Filetypes: `{ "go" }`
- Method: `code_action`

#### Notes

- Requires installing the Go tree-sitter parser.

### [impl](https://github.com/josharian/impl)

impl generates method stubs for implementing an interface.

#### Usage

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

#### Defaults

- Filetypes: `{ "go" }`
- Method: `code_action`

#### Notes

- Requires installing the Go tree-sitter parser.

### [ltrs](https://github.com/jeertmans/languagetool-rust)

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

#### Usage

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

#### Defaults

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

### [proselint](https://github.com/amperser/proselint)

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

#### Usage

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

#### Defaults

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

### [refactoring](https://github.com/ThePrimeagen/refactoring.nvim)

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

#### Usage

```lua
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](https://www.shellcheck.net/)

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

#### Usage

```lua
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](https://github.com/koalaman/shellcheck/issues/1877).

### [statix](https://github.com/nerdypepper/statix)

Lints and suggestions for the nix programming language.

#### Usage

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

#### Defaults

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

### [ts_node_action](https://github.com/CKolkey/ts-node-action)

A framework for running functions on Tree-sitter nodes, and updating the buffer with the result.

#### Usage

```lua
local sources = { null_ls.builtins.code_actions.ts_node_action }
```

#### Defaults

- Filetypes: `{}`
- Method: `code_action`

### [xo](https://github.com/xojs/xo)

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

#### Usage

```lua
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](https://github.com/L3MON4D3/LuaSnip)

Snippet engine for Neovim, written in Lua.

#### Usage

```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](https://github.com/L3MON4D3/LuaSnip#keymaps) to set up keymaps for expansion and jumping.

### spell

Spell suggestions completion source.

#### Usage

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

#### Defaults

- Filetypes: `{}`
- Method: `completion`

### tags

Tags completion source.

#### Usage

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

#### Defaults

- Filetypes: `{}`
- Method: `completion`

### [vsnip](https://github.com/hrsh7th/vim-vsnip)

Snippets managed by vim-vsnip.

#### Usage

```lua
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](https://github.com/hrsh7th/vim-vsnip#2-setting) for setup instructions.

## Diagnostics

### [actionlint](https://github.com/rhysd/actionlint)

Actionlint is a static checker for GitHub Actions workflow files.

#### Usage

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

#### Defaults

- Filetypes: `{ "yaml" }`
- Method: `diagnostics`
- Command: `actionlint`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/diagnostics/actionlint.lua))

### [alex](https://github.com/get-alex/alex)

Catch insensitive, inconsiderate writing.

#### Usage

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

#### Defaults

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

### [ansiblelint](https://github.com/ansible-community/ansible-lint)

Linter for Ansible playbooks, roles and collections.

#### Usage

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

#### Defaults

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

### [bslint](https://github.com/rokucommunity/bslint)

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

#### Usage

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

#### Defaults

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

### [buf](https://github.com/bufbuild/buf)

A new way of working with Protocol Buffers.

#### Usage

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

#### Defaults

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

### [buildifier](https://github.com/bazelbuild/buildtools/tree/master/buildifier)

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

#### Usage

```lua
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](https://github.com/aws-cloudformation/cfn-lint)

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

#### Usage

```lua
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](https://github.com/mrtazz/checkmake)

`make` linter.

#### Usage

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

#### Defaults

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

### [checkstyle](https://checkstyle.org)

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

#### Usage

```lua
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:
```bash
#!/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](https://www.nongnu.org/chktex/)

`latex` semantic linter.

#### Usage

```lua
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](https://releases.llvm.org/14.0.0/tools/clang/docs/ClangTools.html)

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

```lua
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](https://github.com/KDE/clazy)

Qt-oriented static code analyzer based on the Clang framework

#### Usage

```lua
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):
```lua
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](https://github.com/clj-kondo/clj-kondo)

A linter for clojure code that sparks joy

#### Usage

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

#### Defaults

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

### [cmake_lint](https://github.com/cheshirekow/cmake_format)

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

#### Usage

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

#### Defaults

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

### [codespell](https://github.com/codespell-project/codespell)

Codespell finds common misspellings in text files.

#### Usage

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

#### Defaults

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

### [commitlint](https://commitlint.js.org)

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

#### Usage

```lua
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](https://github.com/conventional-changelog/commitlint/issues/613).

### [cppcheck](https://github.com/danmar/cppcheck)

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

#### Usage

```lua
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](https://github.com/cpplint/cpplint)

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

#### Usage

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

#### Defaults

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

### [credo](https://hexdocs.pm/credo)

Static analysis of `elixir` files for enforcing code consistency.

#### Usage

```lua
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](https://github.com/streetsidesoftware/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](https://github.com/davidmh/cspell.nvim)

#### Usage

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

#### Defaults

- Filetypes: `{}`
- Method: `diagnostics`
- Command: `cspell`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/diagnostics/cspell.lua))

### [cue_fmt](https://github.com/cue-lang/cue)

Reports on formatting errors in .cue language files.

#### Usage

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

#### Defaults

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

### [curlylint](https://www.curlylint.org/)

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

#### Usage

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

#### Defaults

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

### [deadnix](https://github.com/astro/deadnix)

Scan Nix files for dead code.

#### Usage

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

#### Defaults

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

### [deno_lint](https://github.com/denoland/deno_lint)

Blazing fast linter for JavaScript and TypeScript written in Rust

#### Usage

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

#### Defaults

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

### [djlint](https://github.com/Riverside-Healthcare/djLint)

✨ 📜 🪄 ✨ HTML Template Linter and Formatter.

#### Usage

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

#### Defaults

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

### [dotenv_linter](https://github.com/dotenv-linter/dotenv-linter)

Lightning-fast linter for .env files.

#### Usage

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

#### Defaults

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

### [editorconfig_checker](https://github.com/editorconfig-checker/editorconfig-checker)

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

#### Usage

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

#### Defaults

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

### [erb_lint](https://github.com/Shopify/erb-lint)

Lint your ERB or HTML files

#### Usage

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

#### Defaults

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

### [eslint](https://github.com/eslint/eslint)

A linter for the JavaScript ecosystem.

#### Usage

```lua
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](https://github.com/mantoni/eslint_d.js/)

Like ESLint, but faster.

#### Usage

```lua
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](https://github.com/fish-shell/fish-shell)

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

#### Usage

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

#### Defaults

- Filetypes: `{ "fish" }`
- Method: `diagnostics`
- Command: `fish`
- Args: `{ "--no-execute", "$FILENAME" }`

### [flake8](https://github.com/PyCQA/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

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

#### Defaults

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

### [gccdiag](https://gitlab.com/andrejr/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.

#### Usage

```lua
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](https://github.com/Scony/godot-gdscript-toolkit)

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

#### Usage

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

#### Defaults

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

### [gitlint](https://jorisroovers.com/gitlint/)

Linter for Git commit messages.

#### Usage

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

#### Defaults

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

### [glslc](https://github.com/google/shaderc)

Shader to SPIR-V compiler.

#### Usage

```lua
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](https://golangci-lint.run/)

A Go linter aggregator.

#### Usage

```lua
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](https://github.com/kortschak/gospel)

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

#### Usage

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

#### Defaults

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

### [hadolint](https://github.com/hadolint/hadolint)

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

#### Usage

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

#### Defaults

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

### [haml_lint](https://github.com/sds/haml-lint)

Tool for writing clean and consistent HAML.

#### Usage

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

#### Defaults

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

### [jshint](https://github.com/jshint/jshint)

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

#### Usage

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

#### Defaults

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

### [jsonlint](https://github.com/zaach/jsonlint)

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

#### Usage

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

#### Defaults

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

### [ktlint](https://ktlint.github.io/)

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

#### Usage

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

#### Defaults

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

### [ltrs](https://github.com/jeertmans/languagetool-rust)

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

#### Usage

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

#### Defaults

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

### [luacheck](https://github.com/lunarmodules/luacheck)

A tool for linting and static analysis of Lua code.

#### Usage

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

#### Defaults

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

### [markdownlint](https://github.com/DavidAnson/markdownlint)

Markdown style and syntax checker.

#### Usage

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

#### Defaults

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

### [markdownlint_cli2](https://github.com/DavidAnson/markdownlint-cli2)

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

#### Usage

```lua
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](https://github.com/DavidAnson/markdownlint-cli2#configuration).
- See [the documentation](https://github.com/DavidAnson/markdownlint-cli2#overview) to understand the differences between markdownlint-cli2 and markdownlint-cli.

### [markuplint](https://github.com/markuplint/markuplint)

A linter for all markup developers.

#### Usage

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

#### Defaults

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

### [mdl](https://github.com/markdownlint/markdownlint)

A tool to check Markdown files and flag style issues.

#### Usage

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

#### Defaults

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

### [misspell](https://github.com/client9/misspell)

Checks commonly misspelled English words in source files.

#### Usage

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

#### Defaults

- Filetypes: `{}`
- Method: `diagnostics`
- Command: `misspell`

### [mlint](https://www.mathworks.com/help/matlab/ref/mlint.html)

Linter for MATLAB files

#### Usage

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

#### Defaults

- Filetypes: `{ "matlab", "octave" }`
- Method: `diagnostics_on_save`
- Command: `mlint`
- Args: `{ "$FILENAME" }`

### [mypy](https://github.com/python/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

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

#### Defaults

- Filetypes: `{ "python" }`
- Method: `diagnostics`
- Command: `mypy`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/diagnostics/mypy.lua))

### [npm_groovy_lint](https://github.com/nvuillam/npm-groovy-lint)

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

#### Usage

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

#### Defaults

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

### [opacheck](https://www.openpolicyagent.org/docs/latest/cli/#opa-check)

Check Rego source files for parse and compilation errors.

#### Usage

```lua
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](https://metacpan.org/dist/App-perlimports/view/script/perlimports)

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

#### Usage

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

#### Defaults

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

### [php](https://www.php.net/)

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

#### Usage

```lua
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](https://github.com/squizlabs/PHP_CodeSniffer)

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

#### Usage

```lua
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](https://github.com/phpmd/phpmd/)

Runs PHP Mess Detector against PHP files.

#### Usage

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

#### Defaults

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

### [phpstan](https://github.com/phpstan/phpstan)

PHP static analysis tool.

#### Usage

```lua
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](https://pmd.github.io)

An extensible cross-language static code analyzer.

#### Usage

```lua
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:
```bash
#!/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](https://github.com/amperser/proselint)

An English prose linter.

#### Usage

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

#### Defaults

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

### [protoc_gen_lint](https://github.com/ckaznocha/protoc-gen-lint)

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

#### Usage

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

#### Defaults

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

### [protolint](https://github.com/yoheimuta/protolint)

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

#### Usage

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

#### Defaults

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

### [psalm](https://psalm.dev/)

A static analysis tool for finding errors in PHP applications.

#### Usage

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

#### Defaults

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

### [puglint](https://github.com/pugjs/pug-lint)

An unopinionated and configurable linter and style checker for Pug.

#### Usage

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

#### Defaults

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

### [puppet_lint](http://puppet-lint.com/)

Check that your Puppet manifest conforms to the style guide.

#### Usage

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

#### Defaults

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

### [pycodestyle](https://github.com/PyCQA/pycodestyle)

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

#### Usage

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

#### Defaults

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

### [pydocstyle](https://www.pydocstyle.org/)

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

#### Usage

```lua
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](https://github.com/jose-elias-alvarez/null-ls.nvim/wiki/Source-specific-Configuration#pydocstyle) for workarounds.

### [pylama](https://github.com/klen/pylama)

Code audit tool for Python.

#### Usage

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

#### Defaults

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

### [pylint](https://github.com/PyCQA/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:

```lua
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

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

#### Defaults

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

### [pyproject_flake8](https://github.com/csachs/pyproject-flake8)

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

#### Usage

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

#### Defaults

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

### [qmllint](https://doc-snapshots.qt.io/qt6-dev/qtquick-tools-and-utilities.html#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

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

#### Defaults

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

### [reek](https://github.com/troessner/reek)

Code smell detector for Ruby

#### Usage

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

#### Defaults

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

### [revive](https://revive.run/)

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

#### Usage

```lua
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](https://rpm.org/)

Command line tool to parse RPM spec files.

#### Usage

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

#### Defaults

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

### [rstcheck](https://github.com/myint/rstcheck)

Checks syntax of reStructuredText and code blocks nested within it.

#### Usage

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

#### Defaults

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

### [rubocop](https://rubocop.org/)

The Ruby Linter/Formatter that Serves and Protects.

#### Usage

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

#### Defaults

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

### [ruff](https://github.com/charliermarsh/ruff/)

An extremely fast Python linter, written in Rust.

#### Usage

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

#### Defaults

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

### [saltlint](https://github.com/warpnet/salt-lint)

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

#### Usage

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

#### Defaults

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

### [selene](https://kampfkarren.github.io/selene/)

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

#### Usage

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

#### Defaults

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

### [semgrep](https://semgrep.dev/)

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

#### Usage

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

#### Defaults

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

### [semistandardjs](https://github.com/standard/semistandard)

JavaScript style guide, linter, and formatter.

#### Usage

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

#### Defaults

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

### [shellcheck](https://www.shellcheck.net/)

A shell script static analysis tool.

#### Usage

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

#### Defaults

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

### [solhint](https://protofire.github.io/solhint/)

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

#### Usage

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

#### Defaults

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

### [spectral](https://github.com/stoplightio/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

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

#### Defaults

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

### [sqlfluff](https://github.com/sqlfluff/sqlfluff)

A SQL linter and auto-formatter for Humans

#### Usage

```lua
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](https://standardjs.com/)

JavaScript style guide, linter, and formatter.

#### Usage

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

#### Defaults

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

### [standardrb](https://github.com/testdouble/standard)

Ruby style guide, linter, and formatter.

#### Usage

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

#### Defaults

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

### [staticcheck](https://staticcheck.io/)

Advanced Go linter.

#### Usage

```lua
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](https://github.com/nerdypepper/statix)

Lints and suggestions for the Nix programming language.

#### Usage

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

#### Defaults

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

### [stylelint](https://github.com/stylelint/stylelint)

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

#### Usage

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

#### Defaults

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

### [stylint](https://github.com/SimenB/stylint)

A linter for the Stylus CSS preprocessor.

#### Usage

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

#### Defaults

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

### [swiftlint](https://github.com/realm/SwiftLint)

A tool to enforce Swift style and conventions.

#### Usage

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

#### Defaults

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

### [teal](https://github.com/teal-language/tl)

The compiler for Teal, a typed dialect of Lua.

#### Usage

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

#### Defaults

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

### [terraform_validate](https://github.com/hashicorp/terraform)

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

#### Usage

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

#### Defaults

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

### [textidote](https://github.com/sylvainhalle/textidote)

Spelling, grammar and style checking on LaTeX documents.

#### Usage

```lua
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](https://github.com/textlint/textlint)

The pluggable linting tool for text and Markdown.

#### Usage

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

#### Defaults

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

### [tfsec](https://github.com/aquasecurity/tfsec)

Security scanner for Terraform code

#### Usage

```lua
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](https://www.html-tidy.org/)

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

#### Usage

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

#### Defaults

- Filetypes: `{ "html", "xml" }`
- Method: `diagnostics`
- Command: `tidy`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/diagnostics/tidy.lua))

### 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

```lua
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

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

#### Defaults

- Filetypes: `{}`
- Method: `diagnostics`

### [tsc](https://www.typescriptlang.org/docs/handbook/compiler-options.html)

Parses diagnostics from the TypeScript compiler.

#### Usage

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

#### Defaults

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

### [twigcs](https://github.com/friendsoftwig/twigcs)

Runs Twigcs against Twig files.

#### Usage

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

#### Defaults

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

### [typos](https://github.com/crate-ci/typos)

Source code spell checker written in rust

#### Usage

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

#### Defaults

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

### [vacuum](https://quobix.com/vacuum)

The world’s fastest and most scalable OpenAPI linter.

#### Usage

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

#### Defaults

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

### [vale](https://docs.errata.ai/vale/about)

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

#### Usage

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

#### Defaults

- Filetypes: `{ "markdown", "tex", "asciidoc" }`
- Method: `diagnostics`
- Command: `vale`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/diagnostics/vale.lua))

#### 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](https://docs.errata.ai/vale/about#open-source-configurations).

### [verilator](https://www.veripool.org/verilator/)

Verilog and SystemVerilog linter power by Verilator

#### Usage

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

#### Defaults

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

### [vint](https://github.com/Vimjas/vint)

Linter for Vimscript.

#### Usage

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

#### Defaults

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

### [vulture](https://github.com/jendrikseipp/vulture)

Vulture finds unused code in Python programs.

#### Usage

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

#### Defaults

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

### [write_good](https://github.com/btford/write-good)

English prose linter.

#### Usage

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

#### Defaults

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

### [xo](https://github.com/xojs/xo)

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

#### Usage

```lua
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](https://github.com/adrienverge/yamllint)

A linter for YAML files.

#### Usage

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

#### Defaults

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

### [zsh](https://www.zsh.org/)

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

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

#### Defaults

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

## Formatting

### [alejandra](https://github.com/kamadorueda/alejandra)

The Uncompromising Nix Code Formatter

#### Usage

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

#### Defaults

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

### [asmfmt](https://github.com/klauspost/asmfmt)

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

#### Usage

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

#### Defaults

- Filetypes: `{ "asm" }`
- Method: `formatting`
- Command: `asmfmt`

### [astyle](http://astyle.sourceforge.net/)

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](https://www.arduino.cc/) project files and is the same formatter used in the Arduino IDE.

#### Usage

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

#### Defaults

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

### [autoflake](https://github.com/PyCQA/autoflake)

Removes unused imports and unused variables as reported by pyflakes

#### Usage

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

#### Defaults

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

### [autopep8](https://github.com/hhatto/autopep8)

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

#### Usage

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

#### Defaults

- Filetypes: `{ "python" }`
- Methods: `formatting, range_formatting`
- Command: `autopep8`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/autopep8.lua))

### [bean_format](https://beancount.github.io/docs/running_beancount_and_generating_reports.html#bean-format)

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

#### Usage

```lua
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](https://github.com/lovesegfault/beautysh)

A Bash beautifier for the masses.

#### Usage

```lua
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](https://www.ctan.org/pkg/bibclean)

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

#### Usage

```lua
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](https://ftp.math.utah.edu/pub/bibclean/) for latest version.

### [black](https://github.com/psf/black)

The uncompromising Python code formatter

#### Usage

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

#### Defaults

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

### [blackd](https://github.com/psf/black)

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

```lua
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](https://github.com/shufo/blade-formatter)

An opinionated blade template formatter for Laravel that respects readability

#### Usage

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

#### Defaults

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

### [blue](https://github.com/grantjenks/blue)

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

#### Usage

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

#### Defaults

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

### [brittany](https://github.com/lspitzner/brittany)

haskell source code formatter

#### Usage

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

#### Defaults

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

### [bsfmt](https://github.com/rokucommunity/brighterscript-formatter)

A code formatter for BrightScript and BrighterScript.

#### Usage

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

#### Defaults

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

### [buf](https://github.com/bufbuild/buf)

A new way of working with Protocol Buffers.

#### Usage

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

#### Defaults

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

### [buildifier](https://github.com/bazelbuild/buildtools/tree/master/buildifier)

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

#### Usage

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

#### Defaults

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

### [cabal_fmt](https://hackage.haskell.org/package/cabal-fmt)

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

#### Usage

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

#### Defaults

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

### [cbfmt](https://github.com/lukas-reineke/cbfmt)

A tool to format codeblocks inside markdown and org documents.

#### Usage

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

#### Defaults

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

### [clang_format](https://www.kernel.org/doc/html/latest/process/clang-format.html)

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

#### Usage

```lua
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](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/clang_format.lua))

### [cljstyle](https://github.com/greglook/cljstyle)

Formatter for Clojure code.

#### Usage

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

#### Defaults

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

### [cmake_format](https://github.com/cheshirekow/cmake_format)

Parse cmake listfiles and format them nicely.

#### Usage

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

#### Defaults

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

### [codespell](https://github.com/codespell-project/codespell)

Fix common misspellings in text files.

#### Usage

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

#### Defaults

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

### [crystal_format](https://github.com/crystal-lang/crystal)

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

#### Usage

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

#### Defaults

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

### [csharpier](https://csharpier.com/)

CSharpier is an opinionated code formatter for c#

#### Usage

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

#### Defaults

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

### [cueimports](https://pkg.go.dev/github.com/asdine/cueimports)

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

#### Usage

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

#### Defaults

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

### [cue_fmt](https://cuelang.org/)

A CUE language formatter.

#### Usage

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

#### Defaults

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

### [dart_format](https://dart.dev/tools/dart-format)

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

#### Usage

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

#### Defaults

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

### [deno_fmt](https://deno.land/manual/tools/formatter)

Use [Deno](https://deno.land/) to format TypeScript, JavaScript/JSON and markdown.

#### Usage

```lua
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](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/deno_fmt.lua))

#### 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](https://github.com/dlang-community/dfmt)

Formatter for D source code.

#### Usage

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

#### Defaults

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

### [djhtml](https://github.com/rtts/djhtml)

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

#### Usage

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

#### Defaults

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

### [djlint](https://github.com/Riverside-Healthcare/djLint)

✨ 📜 🪄 ✨ HTML Template Linter and Formatter.

#### Usage

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

#### Defaults

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

### [dprint](https://dprint.dev/)

A pluggable and configurable code formatting platform written in Rust.

#### Usage

```lua
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](https://github.com/avh4/elm-format)

elm-format formats Elm source code according to a standard set of rules based on the official [Elm Style Guide](https://elm-lang.org/docs/style-guide).

#### Usage

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

#### Defaults

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

### [emacs_scheme_mode](https://www.gnu.org/savannah-checkouts/gnu/emacs/emacs.html)

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

#### Usage

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

#### Defaults

- Filetypes: `{ "scheme", "scheme.guile" }`
- Method: `formatting`
- Command: `emacs`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/emacs_scheme_mode.lua))

#### Notes

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

### [emacs_vhdl_mode](https://guest.iis.ee.ethz.ch/~zimmi/emacs/vhdl-mode.html)

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

#### Usage

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

#### Defaults

- Filetypes: `{ "vhdl" }`
- Method: `formatting`
- Command: `emacs`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/emacs_vhdl_mode.lua))

#### Notes

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

### [erb_format](https://github.com/nebulab/erb-formatter)

Format ERB files with speed and precision.

#### Usage

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

#### Defaults

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

### [erb_lint](https://github.com/Shopify/erb-lint)

Lint your ERB or HTML files

#### Usage

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

#### Defaults

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

### [erlfmt](https://github.com/WhatsApp/erlfmt)

An opinionated Erlang code formatter.

#### Usage

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

#### Defaults

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

### [eslint](https://github.com/eslint/eslint)

Find and fix problems in your JavaScript code.

#### Usage

```lua
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](https://github.com/mantoni/eslint_d.js/).

### [eslint_d](https://github.com/mantoni/eslint_d.js/)

Like ESLint, but faster.

#### Usage

```lua
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](https://github.com/fsprojects/fantomas)

FSharp source code formatter.

#### Usage

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

#### Defaults

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

### [fish_indent](https://fishshell.com/docs/current/cmds/fish_indent.html)

Indent or otherwise prettify a piece of fish code.

#### Usage

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

#### Defaults

- Filetypes: `{ "fish" }`
- Method: `formatting`
- Command: `fish_indent`

### [fixjson](https://github.com/rhysd/fixjson)

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

#### Usage

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

#### Defaults

- Filetypes: `{ "json" }`
- Method: `formatting`
- Command: `fixjson`

### [fnlfmt](https://git.sr.ht/~technomancy/fnlfmt)

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

#### Usage

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

#### Defaults

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

### [forge_fmt](https://book.getfoundry.sh/reference/config/formatter)

Formats Solidity source files.

#### Usage

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

#### Defaults

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

### [format_r](https://github.com/yihui/formatR)

Format R code automatically.

#### Usage

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

#### Defaults

- Filetypes: `{ "r", "rmd" }`
- Method: `formatting`
- Command: `R`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/format_r.lua))

### [fourmolu](https://hackage.haskell.org/package/fourmolu)

Fourmolu is a formatter for Haskell source code.

#### Usage

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

#### Defaults

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

### [fprettify](https://github.com/pseewald/fprettify)

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

#### Usage

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

#### Defaults

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

### [gdformat](https://github.com/Scony/godot-gdscript-toolkit)

A formatter for Godot's gdscript

#### Usage

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

#### Defaults

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

### [gersemi](https://github.com/BlankSpruce/gersemi)

A formatter to make your CMake code the real treasure

#### Usage

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

#### Defaults

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

### [gn_format](http://gn.googlesource.com/gn)

Format your GN code!

#### Usage

```lua
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](https://pkg.go.dev/cmd/gofmt)

Formats go programs.

#### Usage

```lua
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](https://github.com/mvdan/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

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

#### Defaults

- Filetypes: `{ "go" }`
- Method: `formatting`
- Command: `gofumpt`

### [goimports](https://pkg.go.dev/golang.org/x/tools/cmd/goimports)

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

#### Usage

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

#### Defaults

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

### [goimports_reviser](https://pkg.go.dev/github.com/incu6us/goimports-reviser)

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

#### Usage

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

#### Defaults

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

### [golines](https://pkg.go.dev/github.com/segmentio/golines)

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

#### Usage

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

#### Defaults

- Filetypes: `{ "go" }`
- Method: `formatting`
- Command: `golines`

### [google_java_format](https://github.com/google/google-java-format)

Reformats Java source code according to Google Java Style.

#### Usage

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

#### Defaults

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

### [haxe_formatter](https://github.com/HaxeCheckstyle/haxe-formatter)

Haxe code formatter based on tokentree

#### Usage

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

#### Defaults

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

### [hclfmt](https://github.com/fatih/hclfmt)

Formatter for HCL configuration files

#### Usage

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

#### Defaults

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

### [htmlbeautifier](https://github.com/threedaymonk/htmlbeautifier)

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

#### Usage

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

#### Defaults

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

### [isort](https://github.com/PyCQA/isort)

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

#### Usage

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

#### Defaults

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

### [joker](https://github.com/candid82/joker)

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

#### Usage

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

#### Defaults

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

### [jq](https://github.com/stedolan/jq)

Command-line JSON processor

#### Usage

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

#### Defaults

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

### [jsonnetfmt](https://github.com/google/jsonnet)

Formats jsonnet files.

#### Usage

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

#### Defaults

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

### [json_tool](https://docs.python.org/3/library/json.html#module-json.tool)

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

#### Usage

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

#### Defaults

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

### [just](https://just.systems/)

Format your Justfile

#### Usage

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

#### Defaults

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

### [ktlint](https://ktlint.github.io/)

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

#### Usage

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

#### Defaults

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

### [latexindent](https://github.com/cmhughes/latexindent.pl)

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

#### Usage

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

#### Defaults

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

### [lua_format](https://github.com/Koihik/LuaFormatter)

Reformats your Lua source code.

#### Usage

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

#### Defaults

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

### [markdownlint](https://github.com/igorshubovych/markdownlint-cli)

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

#### Usage

```lua
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](https://github.com/prettier/prettier), which can also fix Markdown files.

### [markdown_toc](https://github.com/jonschlinkert/markdown-toc)

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

#### Usage

```lua
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 `<!-- toc -->` before headers in your markdown file.

### [mdformat](https://github.com/executablebooks/mdformat)

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

#### Usage

```lua
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](https://mdformat.readthedocs.io/en/stable/users/plugins.html)

### [mix](https://hexdocs.pm/mix/1.12/Mix.html)

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

#### Usage

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

#### Defaults

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

### [nginx_beautifier](https://github.com/vasilevich/nginxbeautifier)

Beautifies and formats nginx configuration files.

#### Usage

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

#### Defaults

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

### [nimpretty](https://nim-lang.org/docs/tools.html)

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

#### Usage

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

#### Defaults

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

### [nixfmt](https://github.com/serokell/nixfmt)

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

#### Usage

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

#### Defaults

- Filetypes: `{ "nix" }`
- Method: `formatting`
- Command: `nixfmt`

### [nixpkgs_fmt](https://github.com/nix-community/nixpkgs-fmt)

nixpkgs-fmt is a Nix code formatter for nixpkgs.

#### Usage

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

#### Defaults

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

### [npm_groovy_lint](https://github.com/nvuillam/npm-groovy-lint)

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

#### Usage

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

#### Defaults

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

### [ocamlformat](https://github.com/ocaml-ppx/ocamlformat)

Auto-formatter for OCaml code

#### Usage

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

#### Defaults

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

### [ocdc](https://github.com/mdwint/ocdc)

A changelog formatter

#### Usage

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

#### Defaults

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

### [packer](https://www.packer.io/docs/commands/fmt)

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

#### Usage

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

#### Defaults

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

### [perlimports](https://metacpan.org/dist/App-perlimports/view/script/perlimports)

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

#### Usage

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

#### Defaults

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

### [perltidy](http://perltidy.sourceforge.net/)

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

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

#### Defaults

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

### [pg_format](https://github.com/darold/pgFormatter)

PostgreSQL SQL syntax beautifier

#### Usage

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

#### Defaults

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

### [phpcbf](https://github.com/squizlabs/PHP_CodeSniffer)

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

#### Usage

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

#### Defaults

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

### [phpcsfixer](https://github.com/PHP-CS-Fixer/PHP-CS-Fixer)

Formatter for php files.

#### Usage

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

#### Defaults

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

### [pint](https://github.com/laravel/pint)

An opinionated PHP code style fixer for minimalists.

#### Usage

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

#### Defaults

- Filetypes: `{ "php" }`
- Method: `formatting`
- Command: `./vendor/bin/pint`
- Args: `{ "--no-interaction", "--quiet", "$FILENAME" }`

### [prettier](https://github.com/prettier/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

```lua
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](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/prettier.lua))

#### Notes

- Supports more filetypes such as [Svelte](https://github.com/sveltejs/prettier-plugin-svelte) and [TOML](https://github.com/bd82/toml-tools/tree/master/packages/prettier-plugin-toml) via plugins. These filetypes are not enabled by default, but you can follow the instructions [here](BUILTIN_CONFIG.md#filetypes) to define your own list of filetypes.
- To increase speed, you may want to try [prettierd](https://github.com/fsouza/prettierd). You can also set up [eslint-plugin-prettier](https://github.com/prettier/eslint-plugin-prettier) and format via [eslint_d](https://github.com/mantoni/eslint_d.js/).

### [prettierd](https://github.com/fsouza/prettierd)

prettier, as a daemon, for ludicrous formatting speed.

#### Usage

```lua
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](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/prettierd.lua))

### [prettier_d_slim](https://github.com/mikew/prettier_d_slim)

Makes prettier fast.

#### Usage

```lua
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](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/prettier_d_slim.lua))

#### Notes

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

### [prettier_eslint](https://github.com/prettier/prettier-eslint-cli)

CLI for [prettier-eslint](https://github.com/prettier/prettier-eslint)

#### Usage

```lua
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: https://github.com/idahogurl/vs-code-prettier-eslint/issues/72#issuecomment-1247516987

### [prettier_standard](https://github.com/sheerun/prettier-standard)

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

#### Usage

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

#### Defaults

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

### [prismaFmt](https://github.com/prisma/prisma-engines)

Formatter for the prisma filetype.

#### Usage

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

#### Defaults

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

### [protolint](https://github.com/yoheimuta/protolint)

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

#### Usage

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

#### Defaults

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

### [ptop](https://www.freepascal.org/tools/ptop.html)

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

#### Usage

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

#### Defaults

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

### [puppet_lint](http://puppet-lint.com/)

Check that your Puppet manifest conforms to the style guide

#### Usage

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

#### Defaults

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

### [purs_tidy](https://github.com/natefaubion/purescript-tidy)

A syntax tidy-upper (formatter) for PureScript.

#### Usage

```lua
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](https://github.com/deshaw/pyflyby)

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

#### Usage

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

#### Defaults

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

### [pyink](https://github.com/google/pyink)

The Google Python code formatter

#### Usage

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

#### Defaults

- Filetypes: `{ "python" }`
- Methods: `formatting, range_formatting`
- Command: `pyink`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/pyink.lua))

### [qmlformat](https://doc-snapshots.qt.io/qt6-dev/qtquick-tools-and-utilities.html#qmlformat)

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

#### Usage

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

#### Defaults

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

### [racket_fixw](https://github.com/6cdh/racket-fixw)

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

#### Usage

```lua
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](https://docs.racket-lang.org/fmt/)

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

#### Usage

```lua
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](https://www.openpolicyagent.org/docs/latest/policy-language)

Rego (opa fmt) Formatter

#### Usage

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

#### Defaults

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

### [remark](https://github.com/remarkjs/remark)

remark is an extensive and complex Markdown formatter/prettifier.

#### Usage

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

#### Defaults

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

#### Notes

- Depends on [remark-cli](https://github.com/remarkjs/remark/tree/main/packages/remark-cli).

### [reorder_python_imports](https://github.com/asottile/reorder_python_imports)

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

#### Usage

```lua
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](https://rescript-lang.org/)

The ReScript format builtin.

#### Usage

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

#### Defaults

- Filetypes: `{ "rescript" }`
- Method: `formatting`
- Command: `rescript`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/rescript.lua))

### [rome](https://rome.tools)

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

#### Usage

```lua
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](https://rome.tools/#language-support)

### [rubocop](https://github.com/rubocop/rubocop)

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

#### Usage

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

#### Defaults

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

### [rubyfmt](https://github.com/fables-tales/rubyfmt)

Format your Ruby code!

#### Usage

```lua
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](https://github.com/charliermarsh/ruff/)

An extremely fast Python linter, written in Rust.

#### Usage

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

#### Defaults

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

### [rufo](https://github.com/ruby-formatter/rufo)

Opinionated ruby formatter.

#### Usage

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

#### Defaults

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

### [rustfmt](https://github.com/rust-lang/rustfmt)

A tool for formatting rust code according to style guidelines.

#### Usage

```lua
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](https://github.com/jose-elias-alvarez/null-ls.nvim/wiki/Source-specific-Configuration#rustfmt) for other workarounds.

### [rustywind](https://github.com/avencera/rustywind)

CLI for organizing Tailwind CSS classes.

#### Usage

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

#### Defaults

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

### [scalafmt](https://github.com/scalameta/scalafmt)

Code formatter for Scala

#### Usage

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

#### Defaults

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

### [semistandardjs](https://standardjs.com/)

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

#### Usage

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

#### Defaults

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

### [shellharden](https://github.com/anordal/shellharden)

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

#### Usage

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

#### Defaults

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

### [shfmt](https://github.com/mvdan/sh)

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

#### Usage

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

#### Defaults

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

### [smlfmt](https://github.com/shwestrick/smlfmt)

A custom parser/auto-formatter for Standard ML

#### Usage

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

#### Defaults

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

### [sqlfluff](https://github.com/sqlfluff/sqlfluff)

A SQL linter and auto-formatter for Humans

#### Usage

```lua
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](https://sqlfmt.com/)

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

#### Usage

```lua
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](https://manpages.ubuntu.com/manpages/xenial/man1/sqlformat.1.html)

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

#### Usage

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

#### Defaults

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

### [sql_formatter](https://github.com/sql-formatter-org/sql-formatter)

A whitespace formatter for different query languages

#### Usage

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

#### Defaults

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

### [standardjs](https://standardjs.com/)

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

#### Usage

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

#### Defaults

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

### [standardrb](https://github.com/testdouble/standard)

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

#### Usage

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

#### Defaults

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

### [standardts](https://standardjs.com/#typescript)

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

#### Usage

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

#### Defaults

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

### [stylelint](https://github.com/stylelint/stylelint)

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

#### Usage

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

#### Defaults

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

### [styler](https://github.com/r-lib/styler)

Non-invasive pretty printing of R code.

#### Usage

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

#### Defaults

- Filetypes: `{ "r", "rmd" }`
- Method: `formatting`
- Command: `R`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/styler.lua))

### [stylish_haskell](https://github.com/haskell/stylish-haskell)

Format Haskell code

#### Usage

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

#### Defaults

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

### [stylua](https://github.com/JohnnyMorganz/StyLua)

An opinionated code formatter for Lua.

#### Usage

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

#### Defaults

- Filetypes: `{ "lua", "luau" }`
- Methods: `formatting, range_formatting`
- Command: `stylua`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/stylua.lua))

### [surface](https://hexdocs.pm/surface_formatter/readme.html)

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

#### Usage

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

#### Defaults

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

### [swiftformat](https://github.com/nicklockwood/SwiftFormat)

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

#### Usage

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

#### Defaults

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

### [swiftlint](https://github.com/realm/SwiftLint)

A tool to enforce Swift style and conventions.

#### Usage

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

#### Defaults

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

### [swift_format](https://github.com/apple/swift-format)

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

#### Usage

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

#### Defaults

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

### [taplo](https://taplo.tamasfe.dev/)

A versatile, feature-rich TOML toolkit.

#### Usage

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

#### Defaults

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

### [terrafmt](https://github.com/katbyte/terrafmt)

The terrafmt command formats `terraform` blocks embedded in Markdown files.

#### Usage

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

#### Defaults

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

### [terraform_fmt](https://www.terraform.io/docs/cli/commands/fmt.html)

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

#### Usage

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

#### Defaults

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

### [textlint](https://github.com/textlint/textlint)

The pluggable linting tool for text and Markdown.

#### Usage

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

#### Defaults

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

### [tidy](https://www.html-tidy.org/)

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

#### Usage

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

#### Defaults

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

### [topiary](https://github.com/tweag/topiary)

A uniform formatter for simple languages

#### Usage

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

#### Defaults

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

### [treefmt](https://github.com/numtide/treefmt)

One CLI to format your repo

#### Usage

```lua
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

```lua
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

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

#### Defaults

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

### [uncrustify](https://github.com/uncrustify/uncrustify)

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

#### Usage

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

#### Defaults

- Filetypes: `{ "c", "cpp", "cs", "java" }`
- Method: `formatting`
- Command: `uncrustify`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/uncrustify.lua))

### [usort](https://github.com/facebookexperimental/usort)

Safe, minimal import sorting for Python projects.

#### Usage

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

#### Defaults

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

### [verible_verilog_format](https://github.com/chipsalliance/verible)

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

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

#### Defaults

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

### [xmlformat](https://github.com/pamoller/xmlformatter)

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

#### Usage

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

#### Defaults

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

### [xmllint](http://xmlsoft.org/xmllint.html)

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

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

#### Defaults

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

### [xq](https://github.com/sibprogrammer/xq)

Command-line XML and HTML beautifier and content extractor

#### Usage

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

#### Defaults

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

### [yamlfix](https://github.com/lyz-code/yamlfix)

A configurable YAML formatter that keeps comments.

#### Usage

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

#### Defaults

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

### [yamlfmt](https://github.com/google/yamlfmt)

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

#### Usage

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

#### Defaults

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

### [yapf](https://github.com/google/yapf)

Formatter for Python.

#### Usage

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

#### Defaults

- Filetypes: `{ "python" }`
- Methods: `formatting, range_formatting`
- Command: `yapf`
- Args: dynamically resolved (see [source](https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/lua/null-ls/builtins/formatting/yapf.lua))

### [yq](https://github.com/mikefarah/yq)

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

#### Usage

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

#### Defaults

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

### [zigfmt](https://github.com/ziglang/zig)

Reformat Zig source into canonical form.

#### Usage

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

#### Defaults

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

### [zprint](https://github.com/kkinnear/zprint)

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

#### Usage

```lua
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](https://dictionaryapi.dev/)

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

#### Usage

```lua
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

```lua
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.