Produce a multi-formatter that aggregates formatter tools.

Some formatter tools are built-in to rules_lint and may be installed by multitool.
These are noted in the attributes for each language in 'languages' below.

Note: Under --enable_bzlmod, rules_lint installs multitool automatically.
WORKSPACE users must install it manually; see the snippet on the releases page.

Other formatter binaries may be declared in your repository, typically in tools/format/BUILD.bazel.
You can test that they work by running them directly, with bazel run -- //tools/format:some-tool.
Then use the label //tools/format:some-tool as the value of whatever language attribute in format_multirun.
See the example/tools/format/BUILD file in this repo for full examples of declaring formatters.

Support repos that aren't on bazel central registry.

Needed until Bazel 7 allows MODULE.bazel to directly call repository rules.

API for calling declaring a buf lint aspect.

Typical usage:

load("@aspect_rules_lint//lint:buf.bzl", "lint_buf_aspect")

buf = lint_buf_aspect(
    config = Label("//path/to:buf.yaml"),
)

Important: while using buf's allow_comment_ignores functionality, the bazel flag --experimental_proto_descriptor_sets_include_source_info is required.

API for declaring a checkstyle lint aspect that visits java_library rules.

Typical usage:

First, call the fetch_checkstyle helper in WORKSPACE to download the jar file.
Alternatively you could use whatever you prefer for managing Java dependencies, such as a Maven integration rule.

Next, declare a binary target for it, typically in tools/lint/BUILD.bazel:

java_binary(
    name = "checkstyle",
    main_class = "com.puppycrawl.tools.checkstyle.Main",
    runtime_deps = ["@com_puppycrawl_tools_checkstyle//jar"],
)

Finally, declare an aspect for it, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:checkstyle.bzl", "lint_checkstyle_aspect")

checkstyle = lint_checkstyle_aspect(
    binary = Label("//tools/lint:checkstyle"),
    config = Label("//:checkstyle.xml"),
)

API for calling declaring a clang-tidy lint aspect.

Typical usage:

First, install clang-tidy with llvm_toolchain or as a native binary (llvm_toolchain
does not support Windows as of 06/2024, but providing a native clang-tidy.exe works)

Next, declare a binary target for it, typically in tools/lint/BUILD.bazel:

e.g. using llvm_toolchain:

native_binary(
    name = "clang_tidy",
    src = "@llvm_toolchain_llvm//:bin/clang-tidy"
    out = "clang_tidy",
)

e.g as native binary:

native_binary(
    name = "clang_tidy",
    src = "clang-tidy.exe"
    out = "clang_tidy",
)

Finally, create the linter aspect, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:clang_tidy.bzl", "lint_clang_tidy_aspect")

clang_tidy = lint_clang_tidy_aspect(
    binary = Label("//path/to:clang-tidy"),
    configs = [Label("//path/to:.clang-tidy")],
)

API for calling declaring an ESLint lint aspect.

Typical usage:

First, install eslint using your typical npm package.json and rules_js rules.

Next, declare a binary target for it, typically in tools/lint/BUILD.bazel:

load("@npm//:eslint/package_json.bzl", eslint_bin = "bin")
eslint_bin.eslint_binary(name = "eslint")

Finally, create the linter aspect, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:eslint.bzl", "lint_eslint_aspect")

eslint = lint_eslint_aspect(
    binary = Label("//tools/lint:eslint"),
    # We trust that eslint will locate the correct configuration file for a given source file.
    # See https://eslint.org/docs/latest/use/configure/configuration-files#cascading-and-hierarchy
    configs = [
        Label("//:eslintrc"),
        ...
    ],
)

With ts_project <=3.2.0

Prior to [commit 5e25e91]https://github.com/aspect-build/rules_ts/commit/5e25e91420947e3a81938d8eb076803e5cf51fe2)
the rule produced by the ts_project macro and a custom transpiler expanded the macro to
multiple targets, including changing the default target to js_library.

Since you want to lint the original TypeScript source files, the ts_project rule produced
by the macro is the one you want to lint, so when used with an eslint_test you should use
the [name]_typings label:

ts_project(
    name = "my_ts",
    transpiler = swc,
    ...
)

eslint_test(
    name = "lint_my_ts",
    srcs = [":my_ts_typings"],
)

See the react example

API for declaring a flake8 lint aspect that visits py_library rules.

Typical usage:

First, fetch the flake8 package via your standard requirements file and pip calls.

Then, declare a binary target for it, typically in tools/lint/BUILD.bazel:

load("@rules_python//python/entry_points:py_console_script_binary.bzl", "py_console_script_binary")
py_console_script_binary(
    name = "flake8",
    pkg = "@pip//flake8:pkg",
)

Finally, create the linter aspect, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:flake8.bzl", "lint_flake8_aspect")

flake8 = lint_flake8_aspect(
    binary = Label("//tools/lint:flake8"),
    config = Label("//:.flake8"),
)

API for declaring a keep-sorted lint aspect that visits all source files.

Typical usage:

First, fetch the keep-sorted dependency via gazelle. We provide a convenient go.mod file.
To keep it isolated from your other go dependencies, we recommend adding to .bazelrc:

common --experimental_isolated_extension_usages

Next add to MODULE.bazel:

keep_sorted_deps = use_extension("@gazelle//:extensions.bzl", "go_deps", isolate = True)
keep_sorted_deps.from_file(go_mod = "@aspect_rules_lint//lint/keep-sorted:go.mod")
use_repo(keep_sorted_deps, "com_github_google_keep_sorted")

Finally, create the linter aspect, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:keep_sorted.bzl", "lint_keep_sorted_aspect")

keep_sorted = lint_keep_sorted_aspect(
    binary = Label("@com_github_google_keep_sorted//:keep-sorted"),
)

Now you can add // keep-sorted start / // keep-sorted end lines to your library sources,
following the documentation at https://github.com/google/keep-sorted#usage.

API for calling declaring an ktlint lint aspect.

Typical usage:
Make sure you have ktlint pulled as a dependency into your WORKSPACE/module by pulling a version of it from here
https://github.com/pinterest/ktlint/releases and using a http_file declaration for it like.

http_file(
    name = "com_github_pinterest_ktlint",
    sha256 = "2e28cf46c27d38076bf63beeba0bdef6a845688d6c5dccd26505ce876094eb92",
    url = "https://github.com/pinterest/ktlint/releases/download/1.2.1/ktlint",
    executable = True,
)

Then, create the linter aspect, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:ktlint.bzl", "lint_ktlint_aspect")

ktlint = lint_ktlint_aspect(
    binary = Label("@com_github_pinterest_ktlint//file"),
    # rules can be enabled/disabled from with this file
    editorconfig = Label("//:.editorconfig"),
    # a baseline file with exceptions for violations
    baseline_file = Label("//:.ktlint-baseline.xml"),
)

If you plan on using Ktlint custom rulesets, you can also declare
an additional ruleset_jar attribute pointing to your custom ruleset jar like this

java_binary(
    name = "my_ktlint_custom_ruleset",
    ...
)

ktlint = lint_ktlint_aspect(
    binary = Label("@com_github_pinterest_ktlint//file"),
    # rules can be enabled/disabled from with this file
    editorconfig = Label("//:.editorconfig"),
    # a baseline file with exceptions for violations
    baseline_file = Label("//:.ktlint-baseline.xml"),
    # Run your custom ktlint ruleset on top of standard rules
    ruleset_jar = Label("//:my_ktlint_custom_ruleset_deploy.jar"),
)

If your custom ruleset is a third-party dependency and not a first-party dependency, you can also fetch it using http_file and use it instead.

Factory function to make lint test rules.

When the linter exits non-zero, the test will print the output of the linter and then fail.

To use this, in your linters.bzl where you define the aspect, just create a test that references it.

For example, with flake8:

load("@aspect_rules_lint//lint:lint_test.bzl", "lint_test")
load("@aspect_rules_lint//lint:flake8.bzl", "lint_flake8_aspect")

flake8 = lint_flake8_aspect(
    binary = Label("//:flake8"),
    config = Label("//:.flake8"),
)

flake8_test = lint_test(aspect = flake8)

Now in your BUILD files you can add a test:

load("//tools/lint:linters.bzl", "flake8_test")

py_library(
    name = "unused_import",
    srcs = ["unused_import.py"],
)

flake8_test(
    name = "flake8",
    srcs = [":unused_import"],
)

API for declaring a PMD lint aspect that visits java_library rules.

Typical usage:

First, call the fetch_pmd helper in WORKSPACE to download the zip file.
Alternatively you could use whatever you prefer for managing Java dependencies, such as a Maven integration rule.

Next, declare a binary target for it, typically in tools/lint/BUILD.bazel:

java_binary(
    name = "pmd",
    main_class = "net.sourceforge.pmd.PMD",
    runtime_deps = ["@net_sourceforge_pmd"],
)

Finally, declare an aspect for it, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:pmd.bzl", "lint_pmd_aspect")

pmd = lint_pmd_aspect(
    binary = Label("//tools/lint:pmd"),
    rulesets = [Label("//:pmd.xml")],
)

API for declaring a pylint lint aspect that visits Python rules.

Typical usage:

First, fetch the pylint package via your standard requirements file and pip calls.

Then, declare a binary target for it, typically in tools/lint/BUILD.bazel:

load("@rules_python//python/entry_points:py_console_script_binary.bzl", "py_console_script_binary")

py_console_script_binary(
    name = "pylint",
    pkg = "@pip//pylint:pkg",
)

Finally, create the linter aspect, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:pylint.bzl", "lint_pylint_aspect")

pylint = lint_pylint_aspect(
    binary = Label("//tools/lint:pylint"),
    config = Label("//:.pylintrc"),
)

This file is automatically updated by mirror_ruff.sh

API for declaring a Ruff lint aspect that visits py_{binary|library|test} rules.

Typical usage:

Ruff is provided as a built-in tool by rules_lint. To use the built-in version,
create the linter aspect, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:ruff.bzl", "lint_ruff_aspect")

ruff = lint_ruff_aspect(
    binary = Label("@aspect_rules_lint//lint:ruff_bin",
    configs = [Label("//:.ruff.toml")],
)

Using a specific ruff version

In WORKSPACE, fetch the desired version from https://github.com/astral-sh/ruff/releases

load("@aspect_rules_lint//lint:ruff.bzl", "fetch_ruff")

# Specify a tag from the ruff repository
fetch_ruff("v0.4.10")

In tools/lint/BUILD.bazel, select the tool for the host platform:

# Note: this won't interact properly with the --platform flag, see
# https://github.com/aspect-build/rules_lint/issues/389
alias(
    name = "ruff",
    actual = select({
        "@bazel_tools//src/conditions:linux_x86_64": "@ruff_x86_64-unknown-linux-gnu//:ruff",
        "@bazel_tools//src/conditions:linux_aarch64": "@ruff_aarch64-unknown-linux-gnu//:ruff",
        "@bazel_tools//src/conditions:darwin_arm64": "@ruff_aarch64-apple-darwin//:ruff",
        "@bazel_tools//src/conditions:darwin_x86_64": "@ruff_x86_64-apple-darwin//:ruff",
        "@bazel_tools//src/conditions:windows_x64": "@ruff_x86_64-pc-windows-msvc//:ruff.exe",
    }),
)

Finally, reference this tool alias rather than the one from @multitool:

ruff = lint_ruff_aspect(
    binary = "@@//tools/lint:ruff",
    ...
)

API for declaring a shellcheck lint aspect that visits sh_{binary|library|test} rules.

Typical usage:

Shellcheck is provided as a built-in tool by rules_lint. To use the built-in version,
create the linter aspect, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:shellcheck.bzl", "lint_shellcheck_aspect")

shellcheck = lint_shellcheck_aspect(
    binary = Label("@aspect_rules_lint//lint:shellcheck_bin",
    config = Label("//:.shellcheckrc"),
)

API for declaring a spotbugs lint aspect that visits java_library and java_binary rules.

Typical usage:

First, call the fetch_spotbugs helper in WORKSPACE to download the jar file.
Alternatively you could use whatever you prefer for managing Java dependencies, such as a Maven integration rule.

Next, declare a binary target for it, typically in tools/lint/BUILD.bazel:

java_binary(
    name = "spotbugs",
    main_class = "edu.umd.cs.findbugs.LaunchAppropriateUI",
    runtime_deps = [
        "@spotbugs//:jar",
    ],
)

Finally, declare an aspect for it, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:spotbugs.bzl", "lint_spotbugs_aspect")

spotbugs = lint_spotbugs_aspect(
    binary = Label("//tools/lint:spotbugs"),
    exclude_filter = Label("//:spotbugs-exclude.xml"),
)

Configures Stylelint to run as a Bazel aspect

First, all CSS sources must be the srcs of some Bazel rule.
You can use a filegroup with lint-with-stylelint in the tags:

filegroup(
    name = "css",
    srcs = glob(["*.css"]),
    tags = ["lint-with-stylelint"],
)

See the filegroup_tags and rule_kinds attributes below to customize this behavior.

Usage

Add stylelint as a devDependency in your package.json, and declare a binary target for Bazel to execute it.

For example in tools/lint/BUILD.bazel:

load("@npm//:stylelint/package_json.bzl", stylelint_bin = "bin")
stylelint_bin.stylelint_binary(name = "stylelint")

Then declare the linter aspect, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:stylelint.bzl", "lint_stylelint_aspect")
stylelint = lint_stylelint_aspect(
    binary = Label("//tools/lint:stylelint"),
    config = Label("//:stylelintrc"),
)

Finally, register the aspect with your linting workflow, such as in .aspect/cli/config.yaml for aspect lint.

Vale styles library

Vendored from https://raw.githubusercontent.com/errata-ai/styles/master/library.json
Then the url fields are converted from latest to a format string, and sha256sums added.

This file is automatically updated by mirror_vale.sh

API for declaring a Vale lint aspect that visits markdown files.

First, all markdown sources must be the srcs of some Bazel rule.
Either use a filegroup with markdown in the tags:

filegroup(
    name = "md",
    srcs = glob(["*.md"]),
    tags = ["markdown"],
)

or use a markdown_library rule such as the one in https://github.com/dwtj/dwtj_rules_markdown.
Aspect plans to provide support for Markdown in configure so these rules can be automatically
maintained rather than requiring developers to write them by hand.

Note that any Markdown files in the repo which aren't in the srcs of one of these rules will not
be linted by Vale.

Styles

Vale is powered by Styles.
There is a built-in style and if this is
sufficient then it's not necessary to follow the rest of this section.

The styles from https://vale.sh/hub/ are already fetched by fetch_vale() which has a Bazel-based
mirror of https://github.com/errata-ai/packages/blob/master/library.json.
It's possible to fetch more styles using a typical http_archive() call.

At runtime, Vale requires the styles are "installed" into a folder together.
Use the copy_to_directory
rule to accomplish this, for example,

copy_to_directory(
    name = "vale_styles",
    srcs = ["@vale_write-good//:write-good"],
    include_external_repositories = ["vale_*"],
)

Note that the .vale.ini file may have a StylesPath entry.
Under Bazel, we set VALE_STYLES_PATH in the environment, so the StylesPath is used
only when running Vale outside Bazel, such as in an editor extension.

See the example in rules_lint for a fully-working vale setup.

Usage

load("@aspect_rules_lint//lint:vale.bzl", "lint_vale_aspect")

vale = lint_vale_aspect(
    binary = Label("//tools/lint:vale"),
    # A copy_to_bin rule that places the .vale.ini file into bazel-bin
    config = Label("//:.vale_ini"),
    # Optional.
    # A copy_to_directory rule that "installs" custom styles together into a single folder
    styles = Label("//tools/lint:vale_styles"),
)

Configures yamllint to run as a Bazel aspect.

Typical usage:

Create an executable target for yamllint, for example in tools/lint/BUILD.bazel:

load("@rules_python//python/entry_points:py_console_script_binary.bzl", "py_console_script_binary")

py_console_script_binary(
    name = "yamllint",
    pkg = "@pip//yamllint:pkg",
)

Then declare the linter aspect, typically in tools/lint/linters.bzl:

load("@aspect_rules_lint//lint:yamllint.bzl", "lint_yamllint_aspect")

yamllint = lint_yamllint_aspect(
    binary = Label("//tools/lint:yamllint"),
    config = Label("//:.yamllint"),
)

Finally, opt YAML sources into linting by tagging a filegroup with lint-with-yamllint, or by
providing a custom rule_kinds list that matches your YAML rules.