Wrapper for bzl_library.

Decode a base64 encoded string.

Base64 encode a string.

Copies a directory to another location.

This rule uses a precompiled binary to perform the copy, so no shell is required.

If using this rule with source directories, it is recommended that you use the
--host_jvm_args=-DBAZEL_TRACK_SOURCE_DIRECTORIES=1 startup option so that changes
to files within source directories are detected. See
https://github.com/bazelbuild/bazel/commit/c64421bc35214f0414e4f4226cc953e8c55fa0d2
for more context.

Factory function that creates an action to copy a directory from src to dst using a tool binary.

The tool binary will typically be the @bazel_lib//tools/copy_directory go_binary
either built from source or provided by a toolchain.

This helper is used by the copy_directory rule. It is exposed as a public API so it can be used
within other rule implementations.

Copies a file or directory to another location.

native.genrule() is sometimes used to copy files (often wishing to rename them). The 'copy_file' rule does this with a simpler interface than genrule.

This rule uses a hermetic uutils/coreutils cp binary, no shell is required.

If using this rule with source directories, it is recommended that you use the
--host_jvm_args=-DBAZEL_TRACK_SOURCE_DIRECTORIES=1 startup option so that changes
to files within source directories are detected. See
https://github.com/bazelbuild/bazel/commit/c64421bc35214f0414e4f4226cc953e8c55fa0d2
for more context.

Factory function that creates an action to copy a file from src to dst.

If src is a TreeArtifact, dir_path must be specified as the path within
the TreeArtifact to the file to copy.

This helper is used by copy_file. It is exposed as a public API so it can be used within
other rule implementations.

To use copy_file_action in your own rules, you need to include the toolchains it uses
in your rule definition. For example:

load("@bazel_lib//lib:copy_file.bzl", "COPY_FILE_TOOLCHAINS")

my_rule = rule(
    ...,
    toolchains = COPY_FILE_TOOLCHAINS,
)

Additionally, you must ensure that the coreutils toolchain is has been registered in your
WORKSPACE if you are not using bzlmod:

load("@bazel_lib//lib:repositories.bzl", "register_coreutils_toolchains")

register_coreutils_toolchains()

Factory function that creates an action to copy a file to the output tree.

File are copied to the same workspace-relative path. The resulting files is
returned.

If the file passed in is already in the output tree is then it is returned
without a copy action.

To use copy_file_to_bin_action in your own rules, you need to include the toolchains it uses
in your rule definition. For example:

load("@bazel_lib//lib:copy_to_bin.bzl", "COPY_FILE_TO_BIN_TOOLCHAINS")

my_rule = rule(
    ...,
    toolchains = COPY_FILE_TO_BIN_TOOLCHAINS,
)

Additionally, you must ensure that the coreutils toolchain is has been registered in your
WORKSPACE if you are not using bzlmod:

load("@bazel_lib//lib:repositories.bzl", "register_coreutils_toolchains")

register_coreutils_toolchains()

Factory function that creates actions to copy files to the output tree.

Files are copied to the same workspace-relative path. The resulting list of
files is returned.

If a file passed in is already in the output tree is then it is added
directly to the result without a copy action.

Copies a source file to output tree at the same workspace-relative path.

e.g. <execroot>/path/to/file -> <execroot>/bazel-out/<platform>/bin/path/to/file

If a file passed in is already in the output tree is then it is added directly to the
DefaultInfo provided by the rule without a copy.

This is useful to populate the output folder with all files needed at runtime, even
those which aren't outputs of a Bazel rule.

This way you can run a binary in the output folder (execroot or runfiles_root)
without that program needing to rely on a runfiles helper library or be aware that
files are divided between the source tree and the output tree.

Factory function to copy files to a directory using a tool binary.

The tool binary will typically be the @bazel_lib//tools/copy_to_directory go_binary
either built from source or provided by a toolchain.

This helper is used by copy_to_directory. It is exposed as a public API so it can be used within
other rule implementations where additional_files can also be passed in.

A test that compares two files.

The test succeeds if the files' contents match.

Helper function to generate a directory_path target and return its label.

Helper function to convert a dict of directory to path mappings to directory_path targets and labels.

For example,

make_directory_paths("my_name", {
    "//directory/artifact:target_1": "file/path",
    "//directory/artifact:target_2": ["file/path1", "file/path2"],
})

generates the targets,

directory_path(
    name = "my_name_0",
    directory = "//directory/artifact:target_1",
    path = "file/path"
)

directory_path(
    name = "my_name_1",
    directory = "//directory/artifact:target_2",
    path = "file/path1"
)

directory_path(
    name = "my_name_2",
    directory = "//directory/artifact:target_2",
    path = "file/path2"
)

and the list of targets is returned,

[
    "my_name_0",
    "my_name_1",
    "my_name_2",
]

Expand location templates.

Expands all $(execpath ...), $(rootpath ...) and deprecated $(location ...) templates in the
given string by replacing with the expanded path. Expansion only works for labels that point to direct dependencies
of this rule or that are explicitly listed in the optional argument targets.

See https://docs.bazel.build/versions/main/be/make-variables.html#predefined_label_variables.

Use $(rootpath) and $(rootpaths) to expand labels to the runfiles path that a built binary can use
to find its dependencies. This path is of the format:

• ./file
• path/to/file
• ../external_repo/path/to/file

Use $(execpath) and $(execpaths) to expand labels to the execroot (where Bazel runs build actions).
This is of the format:

• ./file
• path/to/file
• external/external_repo/path/to/file
• <bin_dir>/path/to/file
• <bin_dir>/external/external_repo/path/to/file

The deprecated $(location) and $(locations) expansions returns either the execpath or rootpath depending on the context.

Expand make variables and substitute like genrule does.

Bazel pre-defined variables
are expanded however only $@, $(@D) and $(RULEDIR) of
pre-defined genrule variables
are supported.

This function is the same as ctx.expand_make_variables with the additional
genrule-like substitutions of:

• $<: The input file if it is a single file. Else triggers a build error.

• $@: The output file if it is a single file. Else triggers a build error.

• $(@D): The output directory.

  If there is only one file name in outs, this expands to the directory containing that file.

  If there is only one directory in outs, this expands to the single output directory.

  If there are multiple files, this instead expands to the package's root directory in the bin tree,
  even if all generated files belong to the same subdirectory!

• $(RULEDIR): The output directory of the rule, that is, the directory
  corresponding to the name of the package containing the rule under the bin tree.

• $(BUILD_FILE_PATH): ctx.build_file_path

• $(VERSION_FILE): ctx.version_file.path

• $(INFO_FILE): ctx.info_file.path

• $(TARGET): ctx.label

• $(WORKSPACE): ctx.workspace_name

See https://docs.bazel.build/versions/main/be/general.html#genrule.cmd and
https://docs.bazel.build/versions/main/be/make-variables.html#predefined_genrule_variables
for more information of how these special variables are expanded.

Wrapper macro for expand_template_rule.

Test if the passed path matches the glob expression.

* A single asterisk stands for zero or more arbitrary characters except for the the path separator / if match_path_separator is False

? The question mark stands for exactly one character except for the the path separator / if match_path_separator is False

** A double asterisk stands for an arbitrary sequence of 0 or more characters. It is only allowed when preceded by either the beginning of the string or a slash. Likewise it must be followed by a slash or the end of the pattern.

Determine if the passed string is a global expression

Check if every item of arr passes function f.

Example:
every(lambda i: i.endswith(".js"), ["app.js", "lib.js"]) // True

Filter a list arr by applying a function f to each item.

Example:
filter(lambda i: i.endswith(".js"), ["app.ts", "app.js", "lib.ts", "lib.js"]) // ["app.js", "lib.js"]

Find a particular item from list arr by a given function f.

Unlike pick, the find method returns a tuple of the index and the value of first item passing by f.
Furthermore find does not fail if no item passes f.
In this case (-1, None) is returned.

Apply a function f with each item of arr and return a new list.

Example:
map(lambda i: i*2, [1, 2, 3]) // [2, 4, 6]

Check if exactly one item in list arr passes the given function f.

Pick a particular item in list arr by a given function f.

Unlike filter, the pick method returns the first item found by f.
If no item has passed f, the function will fail.

Check if at least one item of arr passes function f.

Example:
some(lambda i: i.endswith(".js"), ["app.js", "lib.ts"]) // True

Return a new list with unique items in it.

Example:
unique(["foo", "bar", "foo", "baz"]) // ["foo", "bar", "baz"]

Helper function to generate a output_files target and return its label.

Generates a UTF-8 encoded params file from a list of arguments.

Handles variable substitutions for args.

Resolves a relative path between two files, "to_file" and "frm_file".

If neither of the paths begin with ../ it is assumed that they share the same root. When finding the relative path,
the incoming files are treated as actual files (not folders) so the resulting relative path may differ when compared
to passing the same arguments to python's "os.path.relpath()" or NodeJs's "path.relative()".

For example, 'relative_file("../foo/foo.txt", "bar/bar.txt")' will return '../../foo/foo.txt'

The relative path from bazel-out/[arch]/bin to the given File object

The repository relative path for a File

This is the full runfiles path of a File excluding its workspace name.

This differs from root path (a.k.a. short_path) and
rlocation path as it does not include the repository name if the File is from an external repository.

The rlocation path for a File

This produces the same value as the rlocationpath predefined source/output path variable.

From https://bazel.build/reference/be/make-variables#predefined_genrule_variables:

rlocationpath: The path a built binary can pass to the Rlocation function of a runfiles
library to find a dependency at runtime, either in the runfiles directory (if available)
or using the runfiles manifest.

This is similar to root path (a.k.a. short_path)
in that it does not contain configuration prefixes, but differs in that it always starts with the
name of the repository.

The rlocation path of a File in an external repository repo will start with repo/, followed by the
repository-relative path.

Passing this path to a binary and resolving it to a file system path using the runfiles libraries
is the preferred approach to find dependencies at runtime. Compared to root path, it has the
advantage that it works on all platforms and even if the runfiles directory is not available.

Find an environment variable in system. Doesn't %-escape the value!

Returns true if the host operating system is Darwin

Returns true if the host operating system is Linux

Returns true if the host operating system is Windows

Returns the name of the host operating system

Returns a normalized name of the host os and CPU architecture.

Alias archictures names are normalized:

x86_64 => amd64
aarch64 => arm64

The result can be used to generate repository names for host toolchain
repositories for toolchains that use these normalized names.

Common os & architecture pairs that are returned are,

• darwin_amd64
• darwin_arm64
• linux_amd64
• linux_arm64
• linux_s390x
• linux_ppc64le
• windows_amd64

Implementation of patching an already extracted repository.

This rule is intended to be used in the implementation function of
a repository rule. If the parameters patches, patch_tool,
patch_args, patch_cmds and patch_cmds_win are not specified
then they are taken from ctx.attr.

Load dependencies

Registers zstd toolchain and repositories

Registers bats toolchain and repositories

Registers coreutils toolchain and repositories

Registers copy_directory toolchain and repositories

Registers copy_to_directory toolchain and repositories

Registers expand_template toolchain and repositories

Register all bazel-lib toolchains at their default versions.

To be more selective about which toolchains and versions to register,
call the individual toolchain registration macros.

Runs a binary as a build action.

This rule does not require Bash (unlike native.genrule).

Provide the bazel-out/stable_status.txt and bazel-out/volatile_status.txt files.

returns a string encoding a codepoint

chr returns a string that encodes the single Unicode code
point whose value is specified by the integer i

returns the codepoint of a character

ord(c) returns the integer value of the sole Unicode code point
encoded by the string c.

If c does not encode exactly one Unicode code point, ord fails.
Each invalid code within the string is treated as if it encodes the
Unicode replacement character, U+FFFD.

Format integer to hexadecimal representation

Split a string into a list space separated arguments

Unlike the naive .split(" "), this function takes quoted strings
and escapes into account.

Generates a test target which fails if the file doesn't contain the string.

Depends on bash, as it creates an sh_test target.

Assert that the default outputs of a target are the expected ones.

Assert that an archive file contains at least the given file entries.

Assert that a directory contains at least the given file entries.

Generate a consistent label string for all Bazel versions.

Starting in Bazel 6, the workspace name is empty for the local workspace and there's no other
way to determine it. This behavior differs from Bazel 5 where the local workspace name was fully
qualified in str(label).

This utility function is meant for use in rules and requires the rule context to determine the
user's workspace name (ctx.workspace_name).

Provide a sane default for *_test timeout attribute.

The test-encyclopedia says:

Tests may return arbitrarily fast regardless of timeout.
A test is not penalized for an overgenerous timeout, although a warning may be issued:
you should generally set your timeout as tight as you can without incurring any flakiness.

However Bazel's default for timeout is medium, which is dumb given this guidance.

It also says:

Tests which do not explicitly specify a timeout have one implied based on the test's size as follows

Therefore if size is specified, we should allow timeout to take its implied default.
If neither is set, then we can fix Bazel's wrong default here to avoid warnings under
--test_verbose_timeout_warnings.

This function can be used in a macro which wraps a testing rule.

Check whether a file exists.

Useful in macros to set defaults for a configuration file if it is present.
This can only be called during the loading phase, not from a rule implementation.

Detects if the Bazel version being used is greater than or equal to 6 (including Bazel 6 pre-releases and RCs).

Detecting Bazel 6 or greater is particularly useful in rules as slightly different code paths may be needed to
support bzlmod which was added in Bazel 6.

Unlike the undocumented native.bazel_version, which only works in WORKSPACE and repository rules, this function can
be used in rules and BUILD files.

An alternate approach to make the Bazel version available in BUILD files and rules would be to
use the host_repo repository rule
which contains the bazel_version in the exported host struct:

WORKSPACE:

load("@bazel_lib//lib:host_repo.bzl", "host_repo")
host_repo(name = "bazel_lib_host")

BUILD.bazel:

load("@bazel_lib_host//:defs.bzl", "host")
print(host.bazel_version)

That approach, however, incurs a cost in the user's WORKSPACE.

Detects if the Bazel version being used is greater than or equal to 7 (including Bazel 7 pre-releases and RCs).

Unlike the undocumented native.bazel_version, which only works in WORKSPACE and repository rules, this function can
be used in rules and BUILD files.

An alternate approach to make the Bazel version available in BUILD files and rules would be to
use the host_repo repository rule
which contains the bazel_version in the exported host struct:

WORKSPACE:

load("@bazel_lib//lib:host_repo.bzl", "host_repo")
host_repo(name = "bazel_lib_host")

BUILD.bazel:

load("@bazel_lib_host//:defs.bzl", "host")
print(host.bazel_version)

That approach, however, incurs a cost in the user's WORKSPACE.

Detect the value of the --enable_bzlmod flag

Returns True if the given Label (or stringy version of a label) represents a target outside of the workspace

Adapts a maybe(http_archive, ...) to look like an http_archive.

This makes WORKSPACE dependencies easier to read and update.

Typical usage looks like,

load("//lib:utils.bzl", http_archive = "maybe_http_archive")

http_archive(
    name = "aspect_rules_js",
    sha256 = "5bb643d9e119832a383e67f946dc752b6d719d66d1df9b46d840509ceb53e1f1",
    strip_prefix = "rules_js-1.6.2",
    url = "https://github.com/aspect-build/rules_js/archive/refs/tags/v1.6.2.tar.gz",
)

instead of the classic maybe pattern of,

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")

maybe(
    http_archive,
    name = "aspect_rules_js",
    sha256 = "5bb643d9e119832a383e67f946dc752b6d719d66d1df9b46d840509ceb53e1f1",
    strip_prefix = "rules_js-1.6.2",
    url = "https://github.com/aspect-build/rules_js/archive/refs/tags/v1.6.2.tar.gz",
)

Returns the path to the workspace root under bazel

Returns a dict of rule parameters filtered from the input dict that only contains the ones that are common to all binary rules

These are listed in Bazel's documentation:
https://bazel.build/reference/be/common-definitions#common-attributes
https://bazel.build/reference/be/common-definitions#common-attributes-binary

Returns a dict of rule parameters filtered from the input dict that only contains the ones that are common to all rules

These are listed in Bazel's documentation:
https://bazel.build/reference/be/common-definitions#common-attributes

Returns a dict of rule parameters filtered from the input dict that only contains the ones that are common to all test rules

These are listed in Bazel's documentation:
https://bazel.build/reference/be/common-definitions#common-attributes
https://bazel.build/reference/be/common-definitions#common-attributes-tests

Returns a list of tags filtered from the input set that only contains the ones that are considered "well known"

These are listed in Bazel's documentation:
https://docs.bazel.build/versions/main/test-encyclopedia.html#tag-conventions
https://docs.bazel.build/versions/main/be/common-definitions.html#common-attributes

Converts a string to a Label. If Label is supplied, the same label is returned.

Provide a sane default for *_test timeout attribute.

The test-encyclopedia says:

Tests may return arbitrarily fast regardless of timeout.
A test is not penalized for an overgenerous timeout, although a warning may be issued:
you should generally set your timeout as tight as you can without incurring any flakiness.

However Bazel's default for timeout is medium, which is dumb given this guidance.

It also says:

Tests which do not explicitly specify a timeout have one implied based on the test's size as follows

Therefore if size is specified, we should allow timeout to take its implied default.
If neither is set, then we can fix Bazel's wrong default here to avoid warnings under
--test_verbose_timeout_warnings.

This function can be used in a macro which wraps a testing rule.

Check whether a file exists.

Useful in macros to set defaults for a configuration file if it is present.
This can only be called during the loading phase, not from a rule implementation.

Detects if the Bazel version being used is greater than or equal to 6 (including Bazel 6 pre-releases and RCs).

Detecting Bazel 6 or greater is particularly useful in rules as slightly different code paths may be needed to
support bzlmod which was added in Bazel 6.

Unlike the undocumented native.bazel_version, which only works in WORKSPACE and repository rules, this function can
be used in rules and BUILD files.

An alternate approach to make the Bazel version available in BUILD files and rules would be to
use the host_repo repository rule
which contains the bazel_version in the exported host struct:

WORKSPACE:

load("@bazel_lib//lib:host_repo.bzl", "host_repo")
host_repo(name = "bazel_lib_host")

BUILD.bazel:

load("@bazel_lib_host//:defs.bzl", "host")
print(host.bazel_version)

That approach, however, incurs a cost in the user's WORKSPACE.

Detects if the Bazel version being used is greater than or equal to 7 (including Bazel 7 pre-releases and RCs).

Unlike the undocumented native.bazel_version, which only works in WORKSPACE and repository rules, this function can
be used in rules and BUILD files.

An alternate approach to make the Bazel version available in BUILD files and rules would be to
use the host_repo repository rule
which contains the bazel_version in the exported host struct:

WORKSPACE:

load("@bazel_lib//lib:host_repo.bzl", "host_repo")
host_repo(name = "bazel_lib_host")

BUILD.bazel:

load("@bazel_lib_host//:defs.bzl", "host")
print(host.bazel_version)

That approach, however, incurs a cost in the user's WORKSPACE.

Detect the value of the --enable_bzlmod flag

Returns True if the given Label (or stringy version of a label) represents a target outside of the workspace

Adapts a maybe(http_archive, ...) to look like an http_archive.

This makes WORKSPACE dependencies easier to read and update.

Typical usage looks like,

load("//lib:utils.bzl", http_archive = "maybe_http_archive")

http_archive(
    name = "aspect_rules_js",
    sha256 = "5bb643d9e119832a383e67f946dc752b6d719d66d1df9b46d840509ceb53e1f1",
    strip_prefix = "rules_js-1.6.2",
    url = "https://github.com/aspect-build/rules_js/archive/refs/tags/v1.6.2.tar.gz",
)

instead of the classic maybe pattern of,

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")

maybe(
    http_archive,
    name = "aspect_rules_js",
    sha256 = "5bb643d9e119832a383e67f946dc752b6d719d66d1df9b46d840509ceb53e1f1",
    strip_prefix = "rules_js-1.6.2",
    url = "https://github.com/aspect-build/rules_js/archive/refs/tags/v1.6.2.tar.gz",
)

Returns the path to the workspace root under bazel

Returns a list of tags filtered from the input set that only contains the ones that are considered "well known"

These are listed in Bazel's documentation:
https://docs.bazel.build/versions/main/test-encyclopedia.html#tag-conventions
https://docs.bazel.build/versions/main/be/common-definitions.html#common-attributes

Returns a dict of rule parameters filtered from the input dict that only contains the ones that are common to all rules

These are listed in Bazel's documentation:
https://bazel.build/reference/be/common-definitions#common-attributes

Returns a dict of rule parameters filtered from the input dict that only contains the ones that are common to all test rules

These are listed in Bazel's documentation:
https://bazel.build/reference/be/common-definitions#common-attributes
https://bazel.build/reference/be/common-definitions#common-attributes-tests

Returns a dict of rule parameters filtered from the input dict that only contains the ones that are common to all binary rules

These are listed in Bazel's documentation:
https://bazel.build/reference/be/common-definitions#common-attributes
https://bazel.build/reference/be/common-definitions#common-attributes-binary

Converts a string to a Label. If Label is supplied, the same label is returned.

Generate a consistent label string for all Bazel versions.

Starting in Bazel 6, the workspace name is empty for the local workspace and there's no other
way to determine it. This behavior differs from Bazel 5 where the local workspace name was fully
qualified in str(label).

This utility function is meant for use in rules and requires the rule context to determine the
user's workspace name (ctx.workspace_name).

Create a Windows Batch file to launch the given shell script.

The rule should specify @bazel_tools//tools/sh:toolchain_type as a required toolchain.

Write one or more files and/or directories to the source tree.

By default, diff_test targets are generated that ensure the source tree files and/or directories to be written to
are up to date and the rule also checks that all source tree files and/or directories to be written to exist.
To disable the exists check and up-to-date tests set diff_test to False.

Write a file or directory to the source tree.

By default, a diff_test target ("{name}_test") is generated that ensure the source tree file or directory to be written to
is up to date and the rule also checks that the source tree file or directory to be written to exists.
To disable the exists check and up-to-date test set diff_test to False.