use super::*;
pub const BUILTINS: &[Builtin<'_>] = &[
Builtin::Attribute {
name: "android",
kind: AttributeKind::Nullary,
description: indoc! {
"
Enable the recipe on Android.
Part of the platform-gating family of attributes
(`[android]`, `[linux]`, `[macos]`, `[unix]`, `[windows]`, and
the BSDs). When any platform attribute is present, the recipe is
only enabled when one of the active platforms matches.
```just
[android]
install:
adb install app.apk
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "arg",
kind: AttributeKind::UnaryPlus,
description: indoc! {
"
Configure a recipe parameter.
Accepts a parameter name followed by one or more keyword
arguments that customize how the parameter is surfaced on the
command line:
- `help=\"HELP\"` sets the usage-message help string.
- `long=\"LONG\"` requires the value to be passed with `--LONG`.
- `short=\"S\"` requires the value to be passed with `-S`.
- `value=\"VALUE\"` makes the option a flag that substitutes
`VALUE` when present. Combine with `long` and/or `short`.
- `pattern=\"PATTERN\"` requires the value to match a regular
expression. Patterns are full-match; `just` rejects the
invocation if the supplied value does not match.
Multiple keys may be combined in a single `[arg(...)]`.
```just
[arg(NAME, long=\"name\", short=\"n\", help=\"greeting target\")]
greet NAME:
@echo Hello, {{NAME}}
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "confirm",
kind: AttributeKind::Optional,
description: indoc! {
"
Require confirmation in the terminal prior to executing the recipe.
With no argument, uses the default prompt. Pass a single string
to override with a custom prompt.
Can be overridden by passing `--yes` to `just`, which
auto-confirms any recipe marked with this attribute.
Recipes that depend on a recipe requiring confirmation will not
run if the confirmation is denied. Recipes listed on the command
line after a confirmation-required recipe are also skipped if
the confirmation is denied.
```just
[confirm]
delete-all:
rm -rf *
[confirm(\"Are you sure you want to delete everything?\")]
delete-everything:
rm -rf *
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "default",
kind: AttributeKind::Nullary,
description: indoc! {
"
Use this recipe as the module's default recipe.
Running `just` with no recipe name in a module that contains a
`[default]`-marked recipe will run that recipe, overriding the
usual behavior of running the first recipe defined.
```just
[default]
build:
cargo build
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "doc",
kind: AttributeKind::Optional,
description: indoc! {
"
Set or suppress the recipe's or module's documentation comment.
With no argument, any `#`-prefixed comment immediately above the
recipe or `mod` statement is omitted from `just --list` and
other doc surfaces. With a string argument, that string is used
as the documentation instead of any comment above.
```just
# This comment will not appear in --list output.
[doc]
internal:
@echo internal
[doc(\"Build the project in release mode\")]
build:
cargo build --release
```
"
},
targets: &[AttributeTarget::Module, AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "dragonfly",
kind: AttributeKind::Nullary,
description: indoc! {
"
Enable the recipe on DragonFly BSD.
Part of the platform-gating family of attributes
(`[android]`, `[linux]`, `[macos]`, `[unix]`, `[windows]`,
`[freebsd]`, `[openbsd]`, `[netbsd]`, `[dragonfly]`). When any
platform attribute is present, the recipe is only enabled when
one of the active platforms matches.
```just
[dragonfly]
install:
pkg install myapp
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "env",
kind: AttributeKind::Binary,
description: indoc! {
"
Set environment variable `ENV_VAR` to `VALUE` for the recipe.
The variable is exported to the recipe's shell and to any commands
run from backticks within it. Does not affect variables outside
the recipe.
```just
[env(\"RUST_LOG\", \"debug\")]
test:
cargo test
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "exit-message",
kind: AttributeKind::Nullary,
description: indoc! {
"
Print an error message if the recipe fails.
The inverse of `[no-exit-message]`: forces `just` to emit its
standard failure message even if `set no-exit-message` is active
globally.
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "extension",
kind: AttributeKind::Unary,
description: indoc! {
"
Set the file extension used when writing a shebang recipe's script
to a temporary file.
`EXT` should include the leading period if one is desired (for
example `\".py\"`). This affects only how the temp file is named,
which can matter for interpreters that dispatch on extension.
```just
[extension(\".py\")]
hello:
#!/usr/bin/env python3
print(\"hello\")
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "freebsd",
kind: AttributeKind::Nullary,
description: indoc! {
"
Enable the recipe on FreeBSD.
Part of the platform-gating family of attributes. When any
platform attribute is present, the recipe is only enabled when
one of the active platforms matches.
```just
[freebsd]
install:
pkg install myapp
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "group",
kind: AttributeKind::Unary,
description: indoc! {
"
Place the recipe or module in the named group `NAME`.
Groups are used by `just --list` to visually cluster related
recipes. `[group(...)]` may be repeated on the same recipe or
module to place it in multiple groups.
```just
[group(\"build\")]
compile:
cargo build
[group(\"build\")]
[group(\"release\")]
package:
cargo build --release
```
"
},
targets: &[AttributeTarget::Module, AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "linux",
kind: AttributeKind::Nullary,
description: indoc! {
"
Enable the recipe on Linux.
Part of the platform-gating family of attributes
(`[android]`, `[linux]`, `[macos]`, `[unix]`, `[windows]`, and
the BSDs). When any platform attribute is present, the recipe is
only enabled when one of the active platforms matches. Useful for writing
cross-platform justfiles that dispatch on the host OS.
```just
[linux]
run:
cc main.c && ./a.out
[windows]
run:
cl main.c && main.exe
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "macos",
kind: AttributeKind::Nullary,
description: indoc! {
"
Enable the recipe on macOS.
Part of the platform-gating family of attributes. When any
platform attribute is present, the recipe is only enabled when
one of the active platforms matches.
Note that `[unix]` also enables the recipe on macOS.
```just
[macos]
open target:
open {{target}}
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "metadata",
kind: AttributeKind::UnaryPlus,
description: indoc! {
"
Attach arbitrary metadata `METADATA` to the recipe.
The attribute accepts any number of arguments. `just` does not
interpret them; they are surfaced via `just --dump --dump-format
json` and intended for consumption by external tooling.
```just
[metadata(\"key1=value1\", \"key2=value2\")]
build:
cargo build
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "netbsd",
kind: AttributeKind::Nullary,
description: indoc! {
"
Enable the recipe on NetBSD.
Part of the platform-gating family of attributes. When any
platform attribute is present, the recipe is only enabled when
one of the active platforms matches.
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "no-cd",
kind: AttributeKind::Nullary,
description: indoc! {
"
Don't change directory before executing the recipe.
Normally `just` runs recipes with the current directory set to
the directory containing the `justfile`. With `[no-cd]`, the
recipe runs with the current directory unchanged, so it can use
paths relative to the invocation directory or operate on the
user's current directory.
```just
[no-cd]
commit file:
git add {{file}}
git commit
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "no-exit-message",
kind: AttributeKind::Nullary,
description: indoc! {
"
Don't print an error message if the recipe fails.
`just` normally prints a line like `error: Recipe \\\"foo\\\" failed
with exit code 1` when a recipe exits non-zero. This attribute
suppresses that message for the annotated recipe, which is useful
when the recipe already prints its own, more specific error
output.
```just
[no-exit-message]
test:
./run-tests.sh
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "no-quiet",
kind: AttributeKind::Nullary,
description: indoc! {
"
Override globally quiet recipes and always echo the recipe lines.
Cancels the effect of `set quiet := true` or a leading `@` on the
recipe itself. Useful when the global default is to suppress echo
but you want this particular recipe to be visible.
```just
set quiet := true
[no-quiet]
build:
cargo build
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "openbsd",
kind: AttributeKind::Nullary,
description: indoc! {
"
Enable the recipe on OpenBSD.
Part of the platform-gating family of attributes. When any
platform attribute is present, the recipe is only enabled when
one of the active platforms matches.
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "parallel",
kind: AttributeKind::Nullary,
description: indoc! {
"
Run this recipe's dependencies in parallel.
By default, a recipe's dependencies are executed serially in the
order they appear. `[parallel]` fans them out so they run
concurrently. The recipe body itself runs only after all
dependencies complete.
```just
[parallel]
check: check-formatting check-lints check-tests
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "positional-arguments",
kind: AttributeKind::Nullary,
description: indoc! {
"
Turn on positional arguments for this recipe.
Recipe arguments are passed to the shell as positional parameters
(`$0`, `$1`, `$@`, ...) instead of being interpolated as
`{{ name }}`. The recipe name is available as `$0` for linewise
recipes.
Note that PowerShell does not handle positional arguments the
same way as POSIX shells; enabling this with PowerShell as the
configured shell will likely break the recipe.
```just
[positional-arguments]
@foo bar:
echo $0
echo $1
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "private",
kind: AttributeKind::Nullary,
description: indoc! {
"
Make a recipe, alias, variable, or module private.
Private items are hidden from `just --list` and `just
--summary`, but are still callable by name and usable as
dependencies of other recipes. A leading underscore on the name
has the same effect.
```just
[private]
_helper:
@echo internal
```
"
},
targets: &[
AttributeTarget::Alias,
AttributeTarget::Assignment,
AttributeTarget::Module,
AttributeTarget::Recipe,
],
},
Builtin::Attribute {
name: "script",
kind: AttributeKind::Variadic,
description: indoc! {
"
Execute the recipe as a script.
With no argument, uses the interpreter configured by
`set script-interpreter := [...]` (default: `['sh', '-eu']`).
With an argument, uses the supplied `COMMAND` as the
interpreter, bypassing the `script-interpreter` setting.
Instead of running each line separately through the shell, the
entire recipe body is written to a temporary file and passed to
the interpreter as a single script. This makes multi-line
control flow, here-docs, and shell-specific features work as
written.
```just
set script-interpreter := ['bash', '-eu']
[script]
hello:
for i in 1 2 3; do
echo $i
done
[script(\"python3\")]
hello-py:
print(\"hello from python\")
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "unix",
kind: AttributeKind::Nullary,
description: indoc! {
"
Enable the recipe on Unix-like platforms, including macOS.
Part of the platform-gating family of attributes. When any
platform attribute is present, the recipe is only enabled when
one of the active platforms matches. `[unix]` matches Android,
Linux, macOS, and the BSDs.
```just
[unix]
run:
cc main.c && ./a.out
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "windows",
kind: AttributeKind::Nullary,
description: indoc! {
"
Enable the recipe on Windows.
Part of the platform-gating family of attributes. When any
platform attribute is present, the recipe is only enabled when
one of the active platforms matches.
```just
[windows]
run:
cl main.c && main.exe
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Attribute {
name: "working-directory",
kind: AttributeKind::Unary,
description: indoc! {
"
Set the recipe's working directory to `PATH`.
`PATH` may be relative or absolute. If relative, it is
interpreted relative to the default working directory (the
directory containing the `justfile`, unless overridden).
```just
[working-directory(\"./subproject\")]
build:
cargo build
```
"
},
targets: &[AttributeTarget::Recipe],
},
Builtin::Constant {
name: "BG_BLACK",
description: indoc! {
"
ANSI escape sequence for black background: `\\e[40m`.
"
},
},
Builtin::Constant {
name: "BG_BLUE",
description: indoc! {
"
ANSI escape sequence for blue background: `\\e[44m`.
"
},
},
Builtin::Constant {
name: "BG_CYAN",
description: indoc! {
"
ANSI escape sequence for cyan background: `\\e[46m`.
"
},
},
Builtin::Constant {
name: "BG_GREEN",
description: indoc! {
"
ANSI escape sequence for green background: `\\e[42m`.
"
},
},
Builtin::Constant {
name: "BG_MAGENTA",
description: indoc! {
"
ANSI escape sequence for magenta background: `\\e[45m`.
"
},
},
Builtin::Constant {
name: "BG_RED",
description: indoc! {
"
ANSI escape sequence for red background: `\\e[41m`.
"
},
},
Builtin::Constant {
name: "BG_WHITE",
description: indoc! {
"
ANSI escape sequence for white background: `\\e[47m`.
"
},
},
Builtin::Constant {
name: "BG_YELLOW",
description: indoc! {
"
ANSI escape sequence for yellow background: `\\e[43m`.
"
},
},
Builtin::Constant {
name: "BLACK",
description: indoc! {
"
ANSI escape sequence for black foreground text: `\\e[30m`.
Terminate styled output with `NORMAL` to reset.
"
},
},
Builtin::Constant {
name: "BLUE",
description: indoc! {
"
ANSI escape sequence for blue foreground text: `\\e[34m`.
Terminate styled output with `NORMAL` to reset.
"
},
},
Builtin::Constant {
name: "BOLD",
description: indoc! {
"
ANSI escape sequence for bold text: `\\e[1m`.
Combine with color constants and terminate with `NORMAL`.
"
},
},
Builtin::Constant {
name: "CLEAR",
description: indoc! {
"
ANSI escape sequence that clears the terminal screen, similar to
the `clear` command: `\\ec`.
"
},
},
Builtin::Constant {
name: "CYAN",
description: indoc! {
"
ANSI escape sequence for cyan foreground text: `\\e[36m`.
Terminate styled output with `NORMAL` to reset.
"
},
},
Builtin::Constant {
name: "GREEN",
description: indoc! {
"
ANSI escape sequence for green foreground text: `\\e[32m`.
Terminate styled output with `NORMAL` to reset.
"
},
},
Builtin::Constant {
name: "HEX",
description: indoc! {
"
Lowercase hexadecimal digit string: `\"0123456789abcdef\"`.
Useful as the alphabet argument to `choose()` for generating
random hex strings.
```just
token := choose('32', HEX)
```
"
},
},
Builtin::Constant {
name: "HEXLOWER",
description: indoc! {
"
Explicitly lowercase hexadecimal digit string:
`\"0123456789abcdef\"`.
Identical to `HEX`. Prefer this name when paired with `HEXUPPER`
to make the case intent obvious at the call site.
"
},
},
Builtin::Constant {
name: "HEXUPPER",
description: indoc! {
"
Uppercase hexadecimal digit string: `\"0123456789ABCDEF\"`.
Useful as the alphabet argument to `choose()` for generating
uppercase-hex strings.
"
},
},
Builtin::Constant {
name: "HIDE",
description: indoc! {
"
ANSI escape sequence for hidden (concealed) text: `\\e[8m`.
Useful for sensitive output like passwords, though not a
substitute for proper secret handling.
"
},
},
Builtin::Constant {
name: "INVERT",
description: indoc! {
"
ANSI escape sequence that swaps foreground and background colors:
`\\e[7m`.
"
},
},
Builtin::Constant {
name: "ITALIC",
description: indoc! {
"
ANSI escape sequence for italic text: `\\e[3m`.
Support for italic rendering varies by terminal.
"
},
},
Builtin::Constant {
name: "MAGENTA",
description: indoc! {
"
ANSI escape sequence for magenta foreground text: `\\e[35m`.
Terminate styled output with `NORMAL` to reset.
"
},
},
Builtin::Constant {
name: "NORMAL",
description: indoc! {
"
ANSI escape sequence that resets all terminal display attributes:
`\\e[0m`.
Use at the end of a styled segment to return the terminal to its
default colors and weights.
```just
@greet:
echo '{{BOLD}}{{RED}}danger{{NORMAL}}'
```
"
},
},
Builtin::Constant {
name: "PATH_SEP",
description: indoc! {
"
Native path separator: `/` on Unix, `\\` on Windows.
Use when constructing paths that must use the host's conventional
separator.
"
},
},
Builtin::Constant {
name: "PATH_VAR_SEP",
description: indoc! {
"
Native `PATH`-variable list separator: `:` on Unix, `;` on
Windows.
Use when building colon- or semicolon-delimited path lists for
environment variables like `$PATH`.
"
},
},
Builtin::Constant {
name: "RED",
description: indoc! {
"
ANSI escape sequence for red foreground text: `\\e[31m`.
Terminate styled output with `NORMAL` to reset.
"
},
},
Builtin::Constant {
name: "STRIKETHROUGH",
description: indoc! {
"
ANSI escape sequence for strikethrough text: `\\e[9m`.
"
},
},
Builtin::Constant {
name: "UNDERLINE",
description: indoc! {
"
ANSI escape sequence for underlined text: `\\e[4m`.
"
},
},
Builtin::Constant {
name: "WHITE",
description: indoc! {
"
ANSI escape sequence for white foreground text: `\\e[37m`.
Terminate styled output with `NORMAL` to reset.
"
},
},
Builtin::Constant {
name: "YELLOW",
description: indoc! {
"
ANSI escape sequence for yellow foreground text: `\\e[33m`.
Terminate styled output with `NORMAL` to reset.
"
},
},
Builtin::Function {
name: "absolute_path",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the absolute form of `path`, resolved against the current
working directory. Does not follow symlinks or canonicalize. For
that, use `canonicalize()`.
```just
absolute_path(\"./bar.txt\") # in /foo -> \"/foo/bar.txt\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "append",
aliases: &[],
kind: FunctionKind::Binary,
description: indoc! {
"
Append `suffix` to each whitespace-separated token in `s`.
```just
append(\"/src\", \"foo bar baz\") # => \"foo/src bar/src baz/src\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "arch",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
Instruction set architecture of the host machine.
Returns one of: `aarch64`, `arm`, `asmjs`, `hexagon`, `mips`,
`msp430`, `powerpc`, `powerpc64`, `s390x`, `sparc`, `wasm32`,
`x86`, `x86_64`, or `xcore`.
```just
system-info:
@echo This is an {{arch()}} machine.
```
"
},
deprecated: None,
},
Builtin::Function {
name: "blake3",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the BLAKE3 hash of `string` as a lowercase hex string.
```just
blake3(\"hello\") # => \"ea8f163db38682925e4491c5e58d4bb...\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "blake3_file",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the BLAKE3 hash of the file at `path` as a lowercase hex
string. Aborts if the file cannot be read.
"
},
deprecated: None,
},
Builtin::Function {
name: "cache_directory",
aliases: &["cache_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
User-specific cache directory.
On Unix, follows the XDG Base Directory Specification
(`$XDG_CACHE_HOME` or `$HOME/.cache`). On macOS, returns
`~/Library/Caches`. On Windows, returns
`{FOLDERID_LocalAppData}`.
"
},
deprecated: None,
},
Builtin::Function {
name: "canonicalize",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Canonicalize `path` by resolving symlinks and removing `.`,
`..`, and redundant path separators where possible. Aborts if
the path does not exist.
```just
canonicalize(\"../foo/./bar\") # => \"/absolute/path/to/bar\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "capitalize",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return `s` with the first character uppercased and the rest
lowercased.
```just
capitalize(\"hello WORLD\") # => \"Hello world\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "choose",
aliases: &[],
kind: FunctionKind::Binary,
description: indoc! {
"
Return a string of `n` randomly selected characters from
`alphabet`. `alphabet` may not contain repeated characters.
```just
choose('64', HEX) # 64-character random lowercase hex string
```
"
},
deprecated: None,
},
Builtin::Function {
name: "clean",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Simplify `path` by removing extra path separators, intermediate
`.` components, and `..` where possible. Purely lexical; does not
touch the filesystem.
```just
clean(\"foo//bar/../baz\") # => \"foo/baz\"
clean(\"foo/./bar\") # => \"foo/bar\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "config_directory",
aliases: &["config_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
User-specific configuration directory.
On Unix, follows the XDG Base Directory Specification
(`$XDG_CONFIG_HOME` or `$HOME/.config`). On macOS, returns
`~/Library/Application Support`. On Windows, returns
`{FOLDERID_RoamingAppData}`.
"
},
deprecated: None,
},
Builtin::Function {
name: "config_local_directory",
aliases: &["config_local_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
Local user-specific configuration directory, for configuration
that should not roam or sync between machines.
On Unix, follows XDG conventions. On Windows, returns
`{FOLDERID_LocalAppData}`.
"
},
deprecated: None,
},
Builtin::Function {
name: "data_directory",
aliases: &["data_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
User-specific data directory.
On Unix, follows the XDG Base Directory Specification
(`$XDG_DATA_HOME` or `$HOME/.local/share`). On macOS, returns
`~/Library/Application Support`. On Windows, returns
`{FOLDERID_RoamingAppData}`.
"
},
deprecated: None,
},
Builtin::Function {
name: "data_local_directory",
aliases: &["data_local_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
Local user-specific data directory, for data that should not
roam or sync between machines.
On Unix, follows XDG conventions. On Windows, returns
`{FOLDERID_LocalAppData}`.
"
},
deprecated: None,
},
Builtin::Function {
name: "datetime",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the current local time formatted with `format`.
`format` is a `strftime`-style string. See the
[`chrono` docs](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
for the full set of specifiers.
```just
datetime(\"%Y-%m-%d\") # => \"2026-04-23\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "datetime_utc",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the current UTC time formatted with `format`.
`format` is a `strftime`-style string. See the
[`chrono` docs](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
for the full set of specifiers.
"
},
deprecated: None,
},
Builtin::Function {
name: "encode_uri_component",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Percent-encode every character in `s` except
`[A-Za-z0-9_.!~*'()-]`. Matches the behavior of JavaScript's
`encodeURIComponent`.
```just
encode_uri_component(\"hello world!\") # => \"hello%20world!\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "env",
aliases: &[],
kind: FunctionKind::UnaryOpt,
description: indoc! {
"
Retrieve the environment variable named `key`.
Called with one argument, aborts execution if the variable is
unset. Called with two arguments, returns `default` when the
variable is unset.
A default can be substituted for an *empty* value (not just an
unset one) with the `||` operator, currently unstable:
```just
set unstable
foo := env('FOO', '') || 'DEFAULT_VALUE'
```
"
},
deprecated: None,
},
Builtin::Function {
name: "env_var",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
**Deprecated**: use `env(key)` instead.
Retrieve the environment variable named `key`. Aborts if the
variable is unset.
"
},
deprecated: Some("env"),
},
Builtin::Function {
name: "env_var_or_default",
aliases: &[],
kind: FunctionKind::Binary,
description: indoc! {
"
**Deprecated**: use `env(key, default)` instead.
Retrieve the environment variable named `key`, returning
`default` when the variable is unset.
"
},
deprecated: Some("env"),
},
Builtin::Function {
name: "error",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Abort execution and report `message` to the user. Diverges and
never returns a value.
```just
check-flag:
@echo {{ if flag == \"\" { error(\"flag must be set\") } else { flag } }}
```
"
},
deprecated: None,
},
Builtin::Function {
name: "executable_directory",
aliases: &["executable_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
User-specific executable directory.
On Unix, follows the XDG Base Directory Specification
(`$XDG_BIN_HOME` or `$HOME/.local/bin`). On Windows, returns no
well-defined value, so use with care on that platform.
"
},
deprecated: None,
},
Builtin::Function {
name: "extension",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the file extension of `path`, not including the leading
period. Aborts if `path` has no extension.
```just
extension(\"/foo/bar.txt\") # => \"txt\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "file_name",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the file name of `path` with any leading directory
components removed.
```just
file_name(\"/foo/bar.txt\") # => \"bar.txt\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "file_stem",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the file name of `path` without its extension or any
leading directory components.
```just
file_stem(\"/foo/bar.txt\") # => \"bar\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "home_directory",
aliases: &["home_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
The user's home directory.
On Unix, returns `$HOME`. On macOS, returns `$HOME`. On Windows,
returns `{FOLDERID_Profile}`.
"
},
deprecated: None,
},
Builtin::Function {
name: "invocation_directory",
aliases: &["invocation_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
The absolute path of the directory in which `just` was invoked,
before it `chdir`'d to the justfile directory.
On Windows, paths are converted to Cygwin-style forward-slash
form via `cygpath`. Use `invocation_directory_native()` to keep
the native path on all platforms.
Useful when a recipe needs to operate on files relative to where
the user ran `just` rather than where the justfile lives.
```just
rustfmt:
find {{invocation_directory()}} -name '*.rs' -exec rustfmt {} \\\\;
```
"
},
deprecated: None,
},
Builtin::Function {
name: "invocation_directory_native",
aliases: &["invocation_dir_native"],
kind: FunctionKind::Nullary,
description: indoc! {
"
The absolute path of the directory in which `just` was invoked,
in the host's native path format.
Unlike `invocation_directory()`, this does not convert paths to
Cygwin style on Windows.
"
},
deprecated: None,
},
Builtin::Function {
name: "is_dependency",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
Return the string `\"true\"` if the current recipe is being run
as a dependency of another recipe, and `\"false\"` if it was
invoked directly from the command line.
"
},
deprecated: None,
},
Builtin::Function {
name: "join",
aliases: &[],
kind: FunctionKind::BinaryPlus,
description: indoc! {
"
Join two or more path components.
Uses `/` on Unix and `\\` on Windows, which can lead to surprises
in cross-platform justfiles. Prefer the `/` operator (`a / b`),
which always uses `/`, unless Windows backslashes are
specifically desired.
```just
join(\"foo/bar\", \"baz\") # => \"foo/bar/baz\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "just_executable",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
Absolute path to the `just` executable that is currently running.
```just
executable:
@echo just is at {{just_executable()}}
```
"
},
deprecated: None,
},
Builtin::Function {
name: "just_pid",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
Process ID of the running `just` executable, as a decimal string.
"
},
deprecated: None,
},
Builtin::Function {
name: "justfile",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
Absolute path to the current `justfile`.
In submodules and imports, still refers to the *root* justfile.
Use `source_file()` to get the path of the file currently being
evaluated.
"
},
deprecated: None,
},
Builtin::Function {
name: "justfile_directory",
aliases: &["justfile_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
Absolute path to the parent directory of the current `justfile`.
```just
script:
{{justfile_directory()}}/scripts/deploy
```
"
},
deprecated: None,
},
Builtin::Function {
name: "kebabcase",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Convert `s` to `kebab-case`.
```just
kebabcase(\"helloWorld\") # => \"hello-world\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "lowercamelcase",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Convert `s` to `lowerCamelCase`.
```just
lowercamelcase(\"hello_world\") # => \"helloWorld\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "lowercase",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Convert `s` to lowercase.
```just
lowercase(\"Hello\") # => \"hello\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "module_directory",
aliases: &["module_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
Directory of the current module file. Behaves like
`justfile_directory()` in the root justfile, but resolves to the
directory of the current `mod` source file inside submodules.
"
},
deprecated: None,
},
Builtin::Function {
name: "module_file",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
Path of the current module file. Behaves like `justfile()` in
the root justfile, but resolves to the current `mod` source
file inside submodules.
"
},
deprecated: None,
},
Builtin::Function {
name: "module_path",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
`::`-separated path to the current module.
In the root justfile this returns the empty string. Inside a
submodule, it returns the module path used to address recipes in
that module.
"
},
deprecated: None,
},
Builtin::Function {
name: "num_cpus",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
Number of logical CPUs available on the host machine.
```just
build:
make -j{{num_cpus()}}
```
"
},
deprecated: None,
},
Builtin::Function {
name: "os",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
Host operating system.
Returns one of: `android`, `bitrig`, `dragonfly`, `emscripten`,
`freebsd`, `haiku`, `ios`, `linux`, `macos`, `netbsd`, `openbsd`,
`solaris`, or `windows`.
"
},
deprecated: None,
},
Builtin::Function {
name: "os_family",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
Host operating system family. Returns `unix` or `windows`.
Useful for gating logic in cross-platform justfiles.
```just
run:
{{if os_family() == \"windows\" { \"main.exe\" } else { \"./main\" }}}
```
"
},
deprecated: None,
},
Builtin::Function {
name: "parent_directory",
aliases: &["parent_dir"],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the parent directory of `path`. Aborts if `path` has no
parent (e.g. the filesystem root).
```just
parent_directory(\"/foo/bar.txt\") # => \"/foo\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "path_exists",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return `\"true\"` if `path` points at an existing filesystem
entity, `\"false\"` otherwise.
Symbolic links are traversed. Returns `\"false\"` for broken
symlinks or when the path is inaccessible.
"
},
deprecated: None,
},
Builtin::Function {
name: "prepend",
aliases: &[],
kind: FunctionKind::Binary,
description: indoc! {
"
Prepend `prefix` to each whitespace-separated token in `s`.
```just
prepend(\"src/\", \"foo bar baz\") # => \"src/foo src/bar src/baz\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "quote",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Quote `s` for safe use as a single argument in a POSIX shell.
Replaces every single quote with `'\\''` and surrounds the
result in single quotes. Sufficient for `sh` and most
descendants (`bash`, `zsh`, `dash`, ...).
```just
quote(\"hello 'world'\") # => \"'hello '\\\\''world'\\\\'''\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "read",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the contents of the file at `path` as a string. Aborts if
the file cannot be read.
"
},
deprecated: None,
},
Builtin::Function {
name: "replace",
aliases: &[],
kind: FunctionKind::Ternary,
description: indoc! {
"
Replace every occurrence of `from` in `s` with `to`.
```just
replace(\"hello\", \"l\", \"x\") # => \"hexxo\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "replace_regex",
aliases: &[],
kind: FunctionKind::Ternary,
description: indoc! {
"
Replace every match of `regex` in `s` with `replacement`.
Regex syntax and replacement syntax are provided by the Rust
[`regex`](https://docs.rs/regex) crate. Capture groups are
supported; see the crate's
[replacement syntax](https://docs.rs/regex/latest/regex/struct.Regex.html#replacement-string-syntax)
docs for details.
```just
replace_regex(\"hello\", \"[aeiou]\", \"X\") # => \"hXllX\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "require",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Search the directories in `$PATH` for an executable called
`name` and return its full path. Aborts with an error if no
such executable is found.
```just
bash := require(\"bash\")
@test:
echo using {{bash}}
```
"
},
deprecated: None,
},
Builtin::Function {
name: "runtime_directory",
aliases: &["runtime_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
The user-specific runtime directory.
Follows the XDG Base Directory Specification on Unix; returns
the platform-specified runtime directory on other systems. May
be unset on some platforms, in which case the function aborts.
"
},
deprecated: None,
},
Builtin::Function {
name: "semver_matches",
aliases: &[],
kind: FunctionKind::Binary,
description: indoc! {
"
Check whether a semantic version `version` satisfies a
`requirement`, returning `\"true\"` or `\"false\"`.
```just
semver_matches(\"1.2.3\", \">=1.0.0\") # => \"true\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "sha256",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the SHA-256 hash of `string` as a lowercase hex string.
"
},
deprecated: None,
},
Builtin::Function {
name: "sha256_file",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the SHA-256 hash of the file at `path` as a lowercase hex
string. Aborts if the file cannot be read.
"
},
deprecated: None,
},
Builtin::Function {
name: "shell",
aliases: &[],
kind: FunctionKind::UnaryPlus,
description: indoc! {
"
Return the standard output of shell script `command`, with zero
or more positional arguments `args`.
The shell used to interpret `command` is the same shell used to
evaluate recipe lines, configurable with `set shell := [...]`.
`command` is also passed as the first positional argument, so
that `$@` works as expected and `$1` refers to the first
user-supplied argument. With the default `sh -cu` shell and args
`'foo'` and `'bar'`, the full invocation is:
```
'sh' '-cu' 'echo $@' 'echo $@' 'foo' 'bar'
```
"
},
deprecated: None,
},
Builtin::Function {
name: "shoutykebabcase",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Convert `s` to `SHOUTY-KEBAB-CASE`.
```just
shoutykebabcase(\"hello_world\") # => \"HELLO-WORLD\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "shoutysnakecase",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Convert `s` to `SHOUTY_SNAKE_CASE`.
```just
shoutysnakecase(\"hello-world\") # => \"HELLO_WORLD\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "snakecase",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Convert `s` to `snake_case`.
```just
snakecase(\"helloWorld\") # => \"hello_world\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "source_directory",
aliases: &["source_dir"],
kind: FunctionKind::Nullary,
description: indoc! {
"
Directory of the current source file. Behaves like
`justfile_directory()` in the root justfile, but resolves to the
directory of the current `import` or `mod` source file when
called from within an imported or submodule file.
"
},
deprecated: None,
},
Builtin::Function {
name: "source_file",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
Path of the current source file. Behaves like `justfile()` in
the root justfile, but resolves to the current `import` or `mod`
source file when called from within an imported or submodule
file.
"
},
deprecated: None,
},
Builtin::Function {
name: "style",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return the terminal display attribute escape sequence used by
`just` itself for styled output.
Unlike the plain color constants, `style(name)` produces the
exact sequence `just` uses, so recipe output can match
`just`'s own styling.
Recognized values of `name`: `'command'` (echoed recipe lines),
`'error'`, and `'warning'`.
```just
scary:
@echo '{{ style(\"error\") }}OH NO{{ NORMAL }}'
```
"
},
deprecated: None,
},
Builtin::Function {
name: "titlecase",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Convert `s` to `Title Case`.
```just
titlecase(\"hello world\") # => \"Hello World\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "trim",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Remove leading and trailing whitespace from `s`.
```just
trim(\" hello \") # => \"hello\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "trim_end",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Remove trailing whitespace from `s`.
```just
trim_end(\"hello \") # => \"hello\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "trim_end_match",
aliases: &[],
kind: FunctionKind::Binary,
description: indoc! {
"
Remove a single trailing occurrence of `substring` from `s` if
present. Leaves `s` unchanged if `substring` does not match at
the end.
```just
trim_end_match(\"hello.txt\", \".txt\") # => \"hello\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "trim_end_matches",
aliases: &[],
kind: FunctionKind::Binary,
description: indoc! {
"
Repeatedly remove trailing occurrences of `substring` from `s`
until none remain.
```just
trim_end_matches(\"aaaab\", \"a\") # => \"aaaab\"
trim_end_matches(\"baaaa\", \"a\") # => \"b\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "trim_start",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Remove leading whitespace from `s`.
```just
trim_start(\" hello\") # => \"hello\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "trim_start_match",
aliases: &[],
kind: FunctionKind::Binary,
description: indoc! {
"
Remove a single leading occurrence of `substring` from `s` if
present. Leaves `s` unchanged if `substring` does not match at
the start.
```just
trim_start_match(\"hello-world\", \"hello-\") # => \"world\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "trim_start_matches",
aliases: &[],
kind: FunctionKind::Binary,
description: indoc! {
"
Repeatedly remove leading occurrences of `substring` from `s`
until none remain.
```just
trim_start_matches(\"aaaab\", \"a\") # => \"b\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "uppercamelcase",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Convert `s` to `UpperCamelCase` (also known as PascalCase).
```just
uppercamelcase(\"hello_world\") # => \"HelloWorld\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "uppercase",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Convert `s` to uppercase.
```just
uppercase(\"hello\") # => \"HELLO\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "uuid",
aliases: &[],
kind: FunctionKind::Nullary,
description: indoc! {
"
Generate a random version 4 UUID.
```just
uuid() # => \"f81d4fae-7dec-11d0-a765-00a0c91e6bf6\"
```
"
},
deprecated: None,
},
Builtin::Function {
name: "which",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Search the directories in `$PATH` for an executable called
`name` and return its full path, or the empty string if no such
executable is found.
Unlike `require()`, does not abort on missing executables, so
this is useful for optional tooling. Currently unstable; requires
`set unstable`.
```just
set unstable
bosh := which(\"bosh\")
```
"
},
deprecated: None,
},
Builtin::Function {
name: "without_extension",
aliases: &[],
kind: FunctionKind::Unary,
description: indoc! {
"
Return `path` with its extension removed. Aborts if `path` has
no extension.
```just
without_extension(\"/foo/bar.txt\") # => \"/foo/bar\"
```
"
},
deprecated: None,
},
Builtin::Setting {
name: "allow-duplicate-recipes",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Allow recipes appearing later in a `justfile` to override
earlier recipes with the same name, instead of producing a
duplicate-definition error.
```just
set allow-duplicate-recipes
@foo:
echo foo
@foo:
echo bar
```
`just foo` in the above justfile prints `bar`.
"
},
deprecated: None,
},
Builtin::Setting {
name: "allow-duplicate-variables",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Allow variables appearing later in a `justfile` to override
earlier variables with the same name, instead of producing a
duplicate-definition error.
```just
set allow-duplicate-variables
a := \"foo\"
a := \"bar\"
```
"
},
deprecated: None,
},
Builtin::Setting {
name: "dotenv-filename",
kind: SettingKind::String,
description: indoc! {
"
Load a `.env` file with a custom name.
When set, `just` looks for a file with the given name relative
to the working directory and each of its ancestors. It is not
an error if no file is found unless `dotenv-required` is also
set.
```just
set dotenv-filename := \".env.local\"
```
Compare with `dotenv-path`, which is only checked relative to
the working directory.
"
},
deprecated: None,
},
Builtin::Setting {
name: "dotenv-load",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Load a `.env` file, if present.
When enabled, `just` looks for a file named `.env` relative to
the working directory and each of its ancestors. It is not an
error if no file is found unless `dotenv-required` is also set.
Loaded values become **environment variables**, not `just`
variables, so they must be accessed as `$VARIABLE_NAME` in
recipes and backticks.
"
},
deprecated: None,
},
Builtin::Setting {
name: "dotenv-override",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Override existing environment variables with values from the
`.env` file.
By default, variables already set in the ambient environment
win over those loaded from `.env`. With this setting enabled,
the dotenv values take precedence.
"
},
deprecated: None,
},
Builtin::Setting {
name: "dotenv-path",
kind: SettingKind::String,
description: indoc! {
"
Load a `.env` file from a specific path. Errors if the file is
not found. Overrides `dotenv-filename`.
Unlike `dotenv-filename`, which is searched for relative to the
working directory and each ancestor, `dotenv-path` is checked
only relative to the working directory (or is absolute).
Can also be overridden at runtime via the `--dotenv-path` /
`-E` command-line option.
"
},
deprecated: None,
},
Builtin::Setting {
name: "dotenv-required",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Error if a `.env` file isn't found.
By default, dotenv-related settings silently skip loading when
the target file does not exist. With this enabled, the absence
of the file is a hard error.
"
},
deprecated: None,
},
Builtin::Setting {
name: "export",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Export every top-level `just` variable as an environment
variable.
Equivalent to prefixing each assignment with `export`, so
recipes and backticks see the variables as `$NAME` rather than
needing `{{ name }}` interpolation.
```just
set export
a := \"hello\"
@foo b:
echo $a
echo $b
```
"
},
deprecated: None,
},
Builtin::Setting {
name: "fallback",
kind: SettingKind::Boolean(false),
description: indoc! {
"
If the first recipe on the command line is not found in the
current justfile, search for a justfile in the parent directory
and try there.
Useful in nested project layouts where a subdirectory justfile
should transparently defer to the root one for unknown
recipes.
"
},
deprecated: None,
},
Builtin::Setting {
name: "guards",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Enable `?` sigils on recipe lines to conditionally stop recipe
execution without reporting an error.
"
},
deprecated: None,
},
Builtin::Setting {
name: "ignore-comments",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Ignore recipe lines beginning with `#`.
With this enabled, comment lines inside recipe bodies are
stripped before being passed to the shell, rather than being
echoed and executed as comments.
"
},
deprecated: None,
},
Builtin::Setting {
name: "lazy",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Don't evaluate unused variables.
Normally `just` evaluates every assignment when the justfile is
loaded. Lazy mode defers evaluation until a variable is actually
referenced by the recipe being run. Useful when some assignments
involve expensive backticks or `shell()` calls that only a subset
of recipes need.
"
},
deprecated: None,
},
Builtin::Setting {
name: "no-cd",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Don't change directory before executing recipes in the current
module.
By default, `just` executes recipes with the current directory set
to the directory containing the justfile. This setting leaves the
current directory unchanged for every recipe in the module.
Individual recipes can also opt in with `[no-cd]`, and
`[working-directory(PATH)]` can override the working directory for a
specific recipe.
"
},
deprecated: None,
},
Builtin::Setting {
name: "no-exit-message",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Suppress the trailing `error: Recipe \\\"foo\\\" failed with exit
code N` message for failed recipes, globally. Individual
recipes can still opt back in with the `[exit-message]`
attribute.
"
},
deprecated: None,
},
Builtin::Setting {
name: "positional-arguments",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Pass recipe arguments as shell positional parameters (`$0`,
`$1`, `$@`, ...) for all recipes in the justfile.
Equivalent to annotating every recipe with
`[positional-arguments]`. PowerShell does not handle positional
arguments the same way as POSIX shells, so enabling this with a
PowerShell-configured `shell` will likely break.
"
},
deprecated: None,
},
Builtin::Setting {
name: "quiet",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Disable echoing recipe lines before executing them.
Equivalent to prefixing every recipe line with `@`. Individual
recipes can opt out with the `[no-quiet]` attribute.
"
},
deprecated: None,
},
Builtin::Setting {
name: "script-interpreter",
kind: SettingKind::Array,
description: indoc! {
"
Set the command used to invoke recipes annotated with a bare
`[script]` attribute (no interpreter argument). Defaults to
`['sh', '-eu']`.
```just
set script-interpreter := ['bash', '-eu']
[script]
hello:
for i in 1 2 3; do echo $i; done
```
"
},
deprecated: None,
},
Builtin::Setting {
name: "shell",
kind: SettingKind::Array,
description: indoc! {
"
Set the command used to invoke recipe lines and evaluate
backticks. Shebang recipes are unaffected. Defaults to `sh -cu`
on Unix; on Windows, use `windows-shell` to override.
`just` appends the line-to-run as an additional argument, so
most shells need a `-c`-style flag to make them evaluate the
first argument as a command.
```just
set shell := [\"zsh\", \"-cu\"]
foo:
ls **/*.txt # will run via zsh
```
"
},
deprecated: None,
},
Builtin::Setting {
name: "tempdir",
kind: SettingKind::String,
description: indoc! {
"
Create temporary directories used by shebang and script recipes
in `tempdir` instead of the system default (`$TMPDIR` /
`/tmp`).
Useful when the system temp directory is mounted `noexec` and
cannot run the temporary script files `just` generates.
"
},
deprecated: None,
},
Builtin::Setting {
name: "unstable",
kind: SettingKind::Boolean(false),
description: indoc! {
"
Enable unstable features, such as the `||` operator for
fallback defaults and the `which()` function.
Unstable features may change or be removed without notice.
"
},
deprecated: None,
},
Builtin::Setting {
name: "windows-powershell",
kind: SettingKind::Boolean(false),
description: indoc! {
"
**Deprecated**: use `windows-shell` instead.
Use the legacy `powershell.exe` binary on Windows as the
default shell for recipes and backticks. Prefer `windows-shell`
for a more flexible, version-agnostic alternative.
"
},
deprecated: Some("windows-shell"),
},
Builtin::Setting {
name: "windows-shell",
kind: SettingKind::Array,
description: indoc! {
"
Set the command used to invoke recipes and evaluate backticks
on Windows.
By default, `just` uses `sh` on Windows. Set this to use
PowerShell, `cmd.exe`, Nushell, or any other shell.
```just
set windows-shell := [\"powershell.exe\", \"-NoLogo\", \"-Command\"]
hello:
Write-Host 'Hello, world!'
```
"
},
deprecated: None,
},
Builtin::Setting {
name: "working-directory",
kind: SettingKind::String,
description: indoc! {
"
Set the working directory for recipes and backticks, relative
to the default working directory.
If relative, interpreted relative to the directory containing
the justfile. If absolute, used as-is.
Individual recipes can override this with the
`[working-directory(PATH)]` attribute or disable directory
change entirely with `[no-cd]`.
"
},
deprecated: None,
},
];
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn no_duplicate_names() {
#[track_caller]
fn case(kind: &str, names: impl IntoIterator<Item = &'static str>) {
let mut seen = HashSet::new();
for name in names {
assert!(
seen.insert(name),
"duplicate {kind} name in BUILTINS: {name}",
);
}
}
case(
"attribute",
BUILTINS.iter().filter_map(|builtin| match builtin {
Builtin::Attribute { name, .. } => Some(*name),
_ => None,
}),
);
case(
"constant",
BUILTINS.iter().filter_map(|builtin| match builtin {
Builtin::Constant { name, .. } => Some(*name),
_ => None,
}),
);
case(
"function",
BUILTINS.iter().flat_map(|builtin| match builtin {
Builtin::Function { name, aliases, .. } => once(*name)
.chain(aliases.iter().copied())
.collect::<Vec<_>>(),
_ => Vec::new(),
}),
);
case(
"setting",
BUILTINS.iter().filter_map(|builtin| match builtin {
Builtin::Setting { name, .. } => Some(*name),
_ => None,
}),
);
}
#[test]
fn alphabetical_by_kind() {
#[track_caller]
fn case(kind: &str, names: impl IntoIterator<Item = &'static str>) {
let names = names.into_iter().collect::<Vec<_>>();
for window in names.windows(2) {
assert!(
window[0] < window[1],
"{kind} names out of order in BUILTINS: {:?} before {:?}",
window[0],
window[1],
);
}
}
case(
"attribute",
BUILTINS.iter().filter_map(|builtin| match builtin {
Builtin::Attribute { name, .. } => Some(*name),
_ => None,
}),
);
case(
"constant",
BUILTINS.iter().filter_map(|builtin| match builtin {
Builtin::Constant { name, .. } => Some(*name),
_ => None,
}),
);
case(
"function",
BUILTINS.iter().filter_map(|builtin| match builtin {
Builtin::Function { name, .. } => Some(*name),
_ => None,
}),
);
case(
"setting",
BUILTINS.iter().filter_map(|builtin| match builtin {
Builtin::Setting { name, .. } => Some(*name),
_ => None,
}),
);
}
}