just

KO | EN

gitlite — search

#python #ai #typescript #machine-learning #deep-learning #docker #macos #java #cli #kubernetes #vue #pytorch #mcp #open-source

(★ 35,403)

🤖 Just a command runner

파일 탐색기

최종 버전 다운로드 (.zip)

- - ci.yaml
  - release.yaml
- forbid
- package
- test-bash-completions
- - book.toml
- - book.toml
- just.bash
- just.elvish
- just.fish
- just.nu
- just.powershell
- just.zsh
- just.sh
- - Cargo.toml
- - Cargo.toml
- completion-registration-script.bash
- crates-io-readme.md
- Dockerfile
- icon.png
- screenshot.png
- cross-platform.just
- keybase.just
- kitchen-sink.just
- powershell.just
- pre-commit.just
- rule124.just
- screenshot.just
- - SKILL.md
- - unix.rs
  - windows.rs
- alias.rs
- alias_style.rs
- analyzer.rs
- arg_attribute.rs
- arguments.rs
- assignment.rs
- ast.rs
- attribute.rs
- attribute_set.rs
- binding.rs
- cache.rs
- cache_entry.rs
- cache_key.rs
- cache_lock.rs
- cache_status.rs
- clean.rs
- color.rs
- color_display.rs
- command_color.rs
- command_ext.rs
- compilation.rs
- compile_error.rs
- compile_error_kind.rs
- compiler.rs
- completer.rs
- conditional_operator.rs
- config.rs
- config_error.rs
- const_error.rs
- const_eval_error.rs
- constants.rs
- count.rs
- datetime_format.rs
- datetime_format_error.rs
- delimiter.rs
- dependency.rs
- dependency_argument.rs
- disabled.rs
- dump_format.rs
- element.rs
- enclosure.rs
- environment.rs
- error.rs
- evaluate_format.rs
- evaluator.rs
- execution_context.rs
- executor.rs
- expression.rs
- expression_context.rs
- filesystem.rs
- format_string_part.rs
- fragment.rs
- function.rs
- function_definition.rs
- indentation.rs
- interpreter.rs
- invocation.rs
- invocation_parser.rs
- item.rs
- justfile.rs
- keyed.rs
- keyword.rs
- layer.rs
- lexer.rs
- lib.rs
- line.rs
- list.rs
- list_entry.rs
- list_feature.rs
- list_operator.rs
- load_dotenv.rs
- loader.rs
- main.rs
- modulepath.rs
- name.rs
- namepath.rs
- node.rs
- number.rs
- numerator.rs
- ordinal.rs
- output_error.rs
- parameter.rs
- parameter_kind.rs
- parser.rs
- pattern.rs
- platform.rs
- platform_interface.rs
- position.rs
- positional.rs
- ran.rs
- range_ext.rs
- recipe.rs
- recipe_resolver.rs
- recipe_signature.rs
- reference.rs
- references.rs
- request.rs
- resolution.rs
- run.rs
- scope.rs
- search.rs
- search_config.rs
- search_error.rs
- semaphore.rs
- set.rs
- setting.rs
- settings.rs
- shebang.rs
- shell.rs
- shell_kind.rs
- show_whitespace.rs
- sigil.rs
- signal.rs
- signal_handler.rs
- signals.rs
- source.rs
- string_context.rs
- string_delimiter.rs
- string_kind.rs
- string_literal.rs
- string_state.rs
- style.rs
- subcommand.rs
- suggestion.rs
- switch.rs
- table.rs
- tangle.rs
- testing.rs
- token.rs
- token_kind.rs
- tree.rs
- unindent.rs
- unresolved_dependency.rs
- unresolved_recipe.rs
- unstable_feature.rs
- usage.rs
- use_color.rs
- value.rs
- variable_resolver.rs
- verbosity.rs
- version.rs
- warning.rs
- which.rs
- alias.rs
- alias_style.rs
- allow_duplicate_recipes.rs
- allow_duplicate_variables.rs
- allow_missing.rs
- arg_attribute.rs
- assertions.rs
- assignment.rs
- attributes.rs
- backticks.rs
- booleans.rs
- byte_order_mark.rs
- cache.rs
- ceiling.rs
- changelog.rs
- choose.rs
- command.rs
- comparison.rs
- completions.rs
- conditional.rs
- confirm.rs
- constants.rs
- datetime.rs
- default.rs
- delimiters.rs
- dependencies.rs
- directories.rs
- dotenv.rs
- dump.rs
- edit.rs
- equals.rs
- error_messages.rs
- evaluate.rs
- examples.rs
- explain.rs
- export.rs
- fallback.rs
- format.rs
- format_string.rs
- function_definitions.rs
- functions.rs
- global.rs
- groups.rs
- guards.rs
- ignore_comments.rs
- imports.rs
- init.rs
- interpolation.rs
- invocation_directory.rs
- json.rs
- justfile_from_stdin.rs
- lazy.rs
- lib.rs
- line_prefixes.rs
- list.rs
- list_literals.rs
- lists.rs
- logical_operators.rs
- man.rs
- mapped_dependencies.rs
- markdown.rs
- minimum_version.rs
- misc.rs
- modules.rs
- multibyte_char.rs
- negation.rs
- newline_escape.rs
- no_aliases.rs
- no_cd.rs
- no_dependencies.rs
- no_exit_message.rs
- non_unicode.rs
- options.rs
- os_attributes.rs
- output.rs
- overrides.rs
- parallel.rs
- parameters.rs
- parser.rs
- positional_arguments.rs
- private.rs
- quiet.rs
- quote.rs
- readme.rs
- recursion_limit.rs
- regexes.rs
- request.rs
- resolve.rs
- run.rs
- scope.rs
- script.rs
- search.rs
- search_arguments.rs
- settings.rs
- shadowing_parameters.rs
- shebang.rs
- shell.rs
- shell_expansion.rs
- show.rs
- signals.rs
- slash_operator.rs
- string.rs
- style.rs
- subsequents.rs
- summary.rs
- tempdir.rs
- test.rs
- timestamps.rs
- undefined_variables.rs
- unexport.rs
- unstable.rs
- usage.rs
- which_function.rs
- windows.rs
- windows_shell.rs
- working_directory.rs
- - en
  - zh
- .nojekyll
- CNAME
- favicon.ico
- index.css
- index.html
- install.sh
.editorconfig
.gitattributes
.gitignore
build.rs
Cargo.lock
Cargo.toml
CHANGELOG.md
clippy.toml
CONTRIBUTING.md
flake.lock
flake.nix
GRAMMAR.md
justfile
LICENSE
README.md
README.中文.md
rustfmt.toml

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/casey/just

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd just

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Docker

쉬움 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Docker Desktop 컨테이너를 빌드하고 실행하려면 필요합니다. 설치 후 실행해서 백그라운드에 켜두세요.

docker build -f etc/Dockerfile -t just .

Dockerfile을 기반으로 실행 가능한 이미지를 빌드합니다.

docker run -p 8080:80 just

빌드된 이미지를 실제 컨테이너로 실행합니다.

✅ 터미널에 docker compose ps 를 입력해 컨테이너들이 Up 상태인지 확인하세요. README에 포트 번호가 적혀있다면 브라우저에서 http://localhost:포트번호 로 접속해보세요.

3. Rust

보통

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
Rust (rustup) rustup으로 설치하면 cargo도 함께 설치됩니다.

cargo test

이 명령어를 터미널에 그대로 입력해 실행하세요.

cargo publish

이 명령어를 터미널에 그대로 입력해 실행하세요.

cargo test {{FLAGS}}

이 명령어를 터미널에 그대로 입력해 실행하세요.

<td><a href=https://www.rust-lang.org>Cargo</a></td>

이 명령어를 터미널에 그대로 입력해 실행하세요.

<td><code>cargo install just</code></td>

이 명령어를 터미널에 그대로 입력해 실행하세요.

✅ cargo build가 에러 없이 끝나면 성공입니다. target/ 폴더에 실행 파일이 생성됩니다.

이 레포의 README에 적힌 실제 명령어를 그대로 가져왔습니다.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

목차↗️

# `just`

[![crates.io version](https://img.shields.io/crates/v/just.svg)](https://crates.io/crates/just)
[![build status](https://github.com/casey/just/actions/workflows/ci.yaml/badge.svg)](https://github.com/casey/just/actions/workflows/ci.yaml)
[![downloads](https://img.shields.io/github/downloads/casey/just/total.svg)](https://github.com/casey/just/releases)
[![chat on discord](https://img.shields.io/discord/695580069837406228?logo=discord)](https://discord.gg/ezYScXR)
[![say thanks](https://img.shields.io/badge/Say%20Thanks-!-1EAEDB.svg)](mailto:casey@rodarmor.com?subject=Thanks%20for%20Just!)

`just`는 프로젝트별 명령어를 저장하고 실행하는 유용한 도구입니다.
이 리드미는 [book](https://just.systems/man/en/) 형태로도 제공됩니다. 이 책은 가장 최신 릴리스를 반영하고 있으며, [GitHub의 리드미](https://github.com/casey/just/blob/master/README.md)는 가장 최신 master 브랜치를 반영합니다.
(中文文档在 [这里](https://github.com/casey/just/blob/master/README.中文.md),
快看过来!)
레시피(recipe)라고 불리는 명령어들은 `make`에서 영감을 받은 문법으로 `justfile`이라는 파일에 저장됩니다:
![screenshot](https://raw.githubusercontent.com/casey/just/master/etc/screenshot.png)
그런 다음 `just RECIPE`를 사용하여 실행할 수 있습니다:
```console
$ just test-all
cc \*.c -o main
./test --all
Yay, all your tests passed!
```
`just`는 수많은 유용한 기능을 가지고 있으며, `make`에 비해 많은 개선 사항이 있습니다:
- `just`는 빌드 시스템이 아닌 명령어 러너이므로 [`make`의 복잡성과 특이성](#what-are-the-idiosyncrasies-of-make-that-just-avoids)을 많이 피할 수 있습니다.
`.PHONY` 레시피가 필요 없습니다!
- 추가 종속성 없이 Linux, macOS, Windows 및 기타 합리적인 유닉스 계열 시스템을 지원합니다. (만약 시스템에 `sh`가 없다면, [다른 쉘을 선택](#shell)해야 합니다.)
- 오류가 구체적이고 유익하며, 구문 오류는 소스 컨텍스트와 함께 보고됩니다.
- 레시피는 [플래그 및 옵션](#recipe-flags-and-options)을 포함하여 [명령어 라인 인수](#recipe-parameters)를 받을 수 있습니다.
- `just`는 풍부한 [표현식 언어](#expressions)와 많은 내장 함수를 가지고 있습니다.
- 가능하면 오류는 정적으로 해결됩니다. 알 수 없는 레시피와 순환 종속성은 실행 전에 보고됩니다.
- `just`는 [`--env` 파일들을 로드](#dotenv-settings)하므로 환경 변수를 쉽게 채울 수 있습니다.
- 레시피를 [명령어 라인에서 나열](#listing-available-recipes)할 수 있습니다.
- 명령어 라인 자동 완성 스크립트는 [대부분의 인기 있는 쉘에서 사용할 수 있습니다](#shell-completion-scripts).
- 레시피는 Python이나 Node.js처럼 [임의의 언어](#shebang-recipes)로 작성할 수 있습니다.
- `just`는 `justfile`이 포함된 디렉터리뿐만 아니라 하위 디렉터리 어디서든 호출할 수 있습니다.
- `justfile`은 [모듈](#modules)과 [임포트](#imports)를 사용하여 여러 파일로 구성할 수 있습니다.
- 그리고 [훨씬 더 많은 기능](#https://just.systems/man/en/)이 있습니다!
`just`와 관련하여 도움이 필요하시면 언제든지 이슈를 열어주시거나 [Discord](https://discord.gg/ezYScXR)에서 저를 핑해 주세요. 기능 요청과 버그 신고는 언제나 환영합니다!

Installation
------------
Just는 선호하는 [패키지 관리자](#packages)를 사용하거나, [사전 빌드된 바이너리](#pre-built-binaries)를 다운로드하거나, `cargo install just`를 사용하여 소스에서 빌드할 수 있습니다.

### Prerequisites
`just`는 Linux, macOS, BSD를 포함하여 적절한 `sh`가 있는 모든 시스템에서 실행되어야 합니다.

#### Windows
Windows에서 `just`는 [Git for Windows](https://git-scm.com), [GitHub Desktop](https://desktop.github.com), 또는 [Cygwin](http://www.cygwin.com)이 제공하는 `sh`와 함께 작동합니다. 설치 후, `just`를 호출하려는 쉘의 `PATH`에 `sh`가 포함되어 있어야 합니다.
`sh`를 설치하고 싶지 않다면, `shell` 설정을 사용하여 원하는 쉘을 사용할 수 있습니다.
PowerShell처럼 말이죠:
```just
# use PowerShell instead of sh:
set shell := ["powershell.exe", "-c"]
hello:
Write-Host "Hello, world!"
```
…또는 `cmd.exe`:
```just
# use cmd.exe instead of sh:
set shell := ["cmd.exe", "/c"]
list:
dir
```
명령어 라인 인수를 사용하여 쉘을 설정할 수도 있습니다. 예를 들어, PowerShell을 사용하려면 `--shell powershell.exe --shell-arg -c`와 함께 `just`를 실행하세요.
(PowerShell은 Windows 7 SP1 및 Windows Server 2008 R2 SP1 이상에 기본적으로 설치되어 있으며, `cmd.exe`는 다루기 까다롭기 때문에 대부분의 Windows 사용자에게 PowerShell을 권장합니다.)

### Packages
#### Cross-platform

| 패키지 관리자 | 패키지 | 명령어 |
| --- | --- | --- |
| [arkade](https://github.com/alexellis/arkade) | just | `arkade get just` |
| [asdf](https://asdf-vm.com) | [just](https://github.com/olofvndrhr/asdf-just) | `asdf plugin add just`  `asdf install just <version>` |
| [Cargo](https://www.rust-lang.org) | [just](https://crates.io/crates/just) | `cargo install just` |
| [Cargo Binstall](https://github.com/cargo-bins/cargo-binstall) | [just](https://crates.io/crates/just) | `cargo binstall just` |
| [Conda](https://docs.conda.io/projects/conda/en/latest/index.html) | [just](https://anaconda.org/conda-forge/just) | `conda install -c conda-forge just` |
| [Homebrew](https://brew.sh) | [just](https://formulae.brew.sh/formula/just) | `brew install just` |
| [Nix](https://nixos.org/nix/) | [just](https://github.com/NixOS/nixpkgs/blob/master/pkgs/by-name/ju/just/package.nix) | `nix-env -iA nixpkgs.just` |
| [npm](https://www.npmjs.com/) | [rust-just](https://www.npmjs.com/package/rust-just) | `npm install -g rust-just` |
| [pipx](https://pipx.pypa.io/stable/) | [rust-just](https://pypi.org/project/rust-just/) | `pipx install rust-just` |
| [Snap](https://snapcraft.io) | [just](https://snapcraft.io/just) | `snap install --edge --classic just` |
| [Spack](https://spack.io/) | [just](https://packages.spack.io/package.html?name=just) | `spack install just` |
| [uv](https://docs.astral.sh/uv/) | [rust-just](https://pypi.org/project/rust-just/) | `uv tool install rust-just` |

#### BSD

| 운영체제 | 패키지 관리자 | 패키지 | 명령어 |
| --- | --- | --- | --- |
| [FreeBSD](https://www.freebsd.org) | [pkg](https://www.freebsd.org/doc/handbook/pkgng-intro.html) | [just](https://www.freshports.org/deskutils/just/) | `pkg install just` |
| [OpenBSD](https://www.openbsd.org) | [pkg\_\*](https://www.openbsd.org/faq/faq15.html) | [just](https://cvsweb.openbsd.org/cgi-bin/cvsweb/ports/sysutils/just) | `pkg_add just` |

#### Linux

| 운영체제 | 패키지 관리자 | 패키지 | 명령어 |
| --- | --- | --- | --- |
| [Alpine](https://alpinelinux.org) | [apk-tools](https://wiki.alpinelinux.org/wiki/Alpine_Linux_package_management) | [just](https://pkgs.alpinelinux.org/package/edge/community/x86_64/just) | `apk add just` |
| [Arch](https://www.archlinux.org) | [pacman](https://wiki.archlinux.org/title/Pacman) | [just](https://archlinux.org/packages/extra/x86_64/just/) | `pacman -S just` |
| [Debian 13](https://debian.org) 및 [Ubuntu 24.04](https://ubuntu.com) 파생 버전 | [apt](https://en.wikipedia.org/wiki/APT_(software)) | [just](https://packages.debian.org/trixie/just) | `apt install just` |
| [Fedora](https://getfedora.org) | [DNF](https://dnf.readthedocs.io/en/latest/) | [just](https://src.fedoraproject.org/rpms/rust-just) | `dnf install just` |
| [Gentoo](https://www.gentoo.org) | [Portage](https://wiki.gentoo.org/wiki/Portage) | [dev-build/just](https://packages.gentoo.org/packages/dev-build/just) | `emerge -av dev-build/just` |
| [NixOS](https://nixos.org/nixos/) | [Nix](https://nixos.org/nix/) | [just](https://github.com/NixOS/nixpkgs/blob/master/pkgs/by-name/ju/just/package.nix) | `nix-env -iA nixos.just` |
| [openSUSE](https://opensuse.org) | [Zypper](https://en.opensuse.org/Portal:Zypper) | [just](https://build.opensuse.org/package/show/Base:System/just) | `zypper in just` |
| [Solus](https://getsol.us) | [eopkg](https://getsol.us/articles/package-management/basics/en) | [just](https://dev.getsol.us/source/just/) | `eopkg install just` |
| [Void](https://voidlinux.org) | [XBPS](https://wiki.voidlinux.org/XBPS) | [just](https://github.com/void-linux/void-packages/blob/master/srcpkgs/just/template) | `xbps-install -S just` |

#### Windows

| 패키지 관리자 | 패키지 | 명령어 |
| --- | --- | --- |
| [Chocolatey](https://chocolatey.org) | [just](https://github.com/michidk/just-choco) | `choco install just` |
| [Scoop](https://scoop.sh) | [just](https://github.com/ScoopInstaller/Main/blob/master/bucket/just.json) | `scoop install just` |
| [Windows Package Manager](https://learn.microsoft.com/en-us/windows/package-manager/) | [Casey/Just](https://github.com/microsoft/winget-pkgs/tree/master/manifests/c/Casey/Just) | `winget install --id Casey.Just --exact` |

#### macOS

| 패키지 관리자 | 패키지 | 명령어 |
| --- | --- | --- |
| [MacPorts](https://www.macports.org) | [just](https://ports.macports.org/port/just/summary) | `port install just` |

![just package version table](https://repology.org/badge/vertical-allrepos/just.svg)
### 사전 빌드된 바이너리
Linux, macOS, Windows용 사전 빌드된 바이너리는 [릴리스 페이지](https://github.com/casey/just/releases)에서 확인할 수 있습니다.
Linux, macOS 또는 Windows에서 다음 명령어를 사용하여 최신 릴리스를 다운로드할 수 있습니다. `DEST`를 `just`를 배치하려는 디렉터리로 바꾸기만 하면 됩니다.
```console
curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to DEST
```
예를 들어, `just`를 `~/bin`에 설치하려면 다음과 같이 합니다.
```console
# ~/bin 생성
mkdir -p ~/bin
# just를 다운로드하여 ~/bin/just에 압축 해제
curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to ~/bin
# 셸이 실행 파일을 찾는 경로에 `~/bin` 추가
# 이 줄은 셸의 초기화 파일(예: `~/.bashrc` 또는 `~/.zshrc`)에 추가해야 합니다.
export PATH="$PATH:$HOME/bin"
# 이제 just를 실행할 수 있어야 합니다.
just --help
```
GitHub Actions나 여러 머신이 IP 주소를 공유하는 기타 환경에서는 `install.sh`가 실패할 수 있습니다. `install.sh`는 설치할 `just`의 최신 버전을 확인하기 위해 GitHub API를 호출하며, 해당 API 호출은 IP 주소별로 속도가 제한됩니다. 이러한 환경에서 `install.sh`의 안정성을 높이려면 `--tag`를 사용하여 특정 태그를 전달하면 됩니다.
속도 제한을 피하는 또 다른 방법은 `GITHUB\_TOKEN`이라는 이름의 환경 변수로 GitHub 인증 토큰을 `install.sh`에 전달하여 요청을 인증하도록 하는 것입니다.
[릴리스](https://github.com/casey/just/releases)에는 사전 빌드된 바이너리 아카이브의 무결성을 확인하는 데 사용할 수 있는 `SHA256SUM` 파일이 포함되어 있습니다.
릴리스를 확인하려면 사전 빌드된 바이너리 아카이브와 `SHA256SUM` 파일을 함께 다운로드하고 다음을 실행하세요.
```sh
shasum --algorithm 256 --ignore-missing --check SHA256SUMS
```
### GitHub Actions
`just`는 여러 방법으로 GitHub Actions에 설치할 수 있습니다.
macOS에서는 `brew install just`, Windows에서는 `choco install just`를 사용하여 GitHub Actions 러너에 사전 설치된 패키지 매니저를 사용할 수 있습니다.
[extractions/setup-just](https://github.com/extractions/setup-just)를 사용하는 방법:
```yaml
- uses: extractions/setup-just@v3
  with:
    just-version: 1.5.0 # 선택적 semver 사양, 그렇지 않으면 최신 버전
```
또는 [taiki-e/install-action](https://github.com/taiki-e/install-action)을 사용하는 방법:
```yaml
- uses: taiki-e/install-action@just
```
### Docker
`just`는 [GitHub Container Registry](https://ghcr.io/casey/just)에서 Docker 이미지로 제공됩니다.
`just`를 Docker 이미지로 복사하려면 `Dockerfile`에 다음 줄을 추가하세요.
```dockerfile
COPY --from=ghcr.io/casey/just:latest /just /usr/local/bin/
```
복사한 후 `just`를 docker 빌드의 일부로 사용할 수도 있습니다.
```dockerfile
RUN just
```
### 릴리스 RSS 피드
`just` 릴리스의 [RSS 피드](https://en.wikipedia.org/wiki/RSS)는 [여기](https://github.com/casey/just/releases.atom)에서 확인할 수 있습니다.
### Node.js 설치
Node.js 애플리케이션에서 `just` 설치를 자동화하기 위해 [just-install](https://npmjs.com/package/just-install)을 사용할 수 있습니다.
`just`는 npm 스크립트에 대한 훌륭하고 더 강력한 대안입니다. Node.js 애플리케이션의 의존성에 `just`를 포함하려면 `just-install`이 `npm install` 명령어의 일부로 로컬 플랫폼 전용 바이너리를 설치합니다. 이렇게 하면 모든 개발자가 위에서 언급한 프로세스 중 하나를 사용하여 `just`를 개별적으로 설치할 필요가 없습니다. 설치 후에는 `just` 명령어가 npm 스크립트나 npx에서 작동합니다. 프로젝트 설정 과정을 가능한 한 쉽게 만들고자 하는 팀에 매우 좋습니다.
자세한 내용은 [just-install README 파일](https://github.com/brombal/just-install#readme)을 참조하세요.
### Nix Flake
`just` 저장소에는 [nix flake](https://nix.dev/concepts/flakes.html)를 정의하는 [`flake.nix`](https://github.com/casey/just/tree/master/flake.nix)가 포함되어 있어, `just`를 다른 flake의 입력으로 사용할 수 있습니다.
```nix
{
  inputs = {
    just.url = "github:casey/just";
  }
  outputs = {self, nixpkgs, 
```

just}: {
}
}
```
하위 호환성
-----------------------
버전 1.0의 출시와 함께, `just`는 하위 호환성과 안정성에 대한 강한 의지를 보여줍니다.
향후 출시 버전에서는 기존의 `justfile`이 작동하지 않게 만들거나 명령줄 인터페이스의 정상적인 실행을 깨뜨리는 하위 호환성 위반 변경 사항을 도입하지 않을 것입니다.
하지만 그렇다고 해서 명백한 버그 수정을 배제하는 것은 아니며, 그로 인해 해당 동작에 의존하는 `justfile`이 영향을 받을지라도 버그 수정은 진행될 수 있습니다.
`just` 2.0은 결코 존재하지 않을 것입니다. 하위 호환성을 깨뜨리는 바람직한 변경 사항이 있다면 각 `justfile`별로 사용자가 선택(opt-in)할 수 있도록 제공되므로, 사용자는 편한 시점에 마이그레이션할 수 있습니다.
아직 안정화 단계에 이르지 못한 기능들은 불안정(unstable) 상태로 표시되며 언제든지 변경되거나 제거될 수 있습니다. 불안정 기능을 사용하면 기본적으로 에러가 발생하지만, `--unstable` 플래그를 전달하거나, `set unstable`을 설정하거나, 환경 변수 `JUST\_UNSTABLE`의 값을 `false`, `0`, 또는 빈 문자열이 아닌 다른 값으로 설정하여 에러를 억제할 수 있습니다.
### 최소 Just 버전 요구하기
특정 버전을 필요로 하는 `just`의 기능을 사용하는 경우, `minimum-version`1.55.0 설정을 사용하여 더 오래된 버전의 `just`를 사용할 때 에러가 발생하도록 만들 수 있습니다:
```justfile
set minimum-version := '1.55.0'
```
`just`가 자신의 버전보다 더 높은 최소 버전을 마주치면, 요구되는 버전과 함께 에러 메시지를 출력합니다. 이는 그렇지 않았을 때 발생할 혼란스러운 에러 메시지보다 훨씬 나을 것입니다.
`minimum-version` 설정은 `justfile`의 맨 위에, 해당 설정이 보호하는 새로운 기능을 사용하기 전에 배치해야 합니다.
최소 버전 검사는 파서(parser)에서 구현되며, 파서는 렉서(lexer) 다음에 실행되므로, 렉서를 전방 비호환(forward-incompatible) 방식으로 변경하는 기능은 여전히 도움이 되지 않는 에러 메시지를 발생시킬 수 있습니다.
에디터 지원
--------------
`justfile`의 문법은 `make`와 매우 유사하므로, 에디터에 `just`에 대한 `make` 문법 강조(syntax highlighting)를 사용하도록 설정하고 싶을 수 있습니다.
### Vim 및 Neovim
[pbnj](https://github.com/pbnj) 덕분에 버전 9.1.1042 이상의 Vim과 버전 0.11 이상의 Neovim은 기본적으로 Justfile 문법 강조를 지원합니다.
#### `vim-just`
[vim-just](https://github.com/NoahTheDuke/vim-just) 플러그인은 `justfile`을 위한 문법 강조를 제공합니다.
[Plug](https://github.com/junegunn/vim-plug)와 같은 선호하는 패키지 매니저로 설치하세요:
```vim
call plug#begin()
Plug 'NoahTheDuke/vim-just'
call plug#end()
```
또는 Vim의 내장 패키지 지원 기능을 사용하세요:
```console
mkdir -p ~/.vim/pack/vendor/start
cd ~/.vim/pack/vendor/start
git clone https://github.com/NoahTheDuke/vim-just.git
```
#### `tree-sitter-just`
[tree-sitter-just](https://github.com/IndianBoy42/tree-sitter-just)는 Neovim을 위한 [Nvim Treesitter](https://github.com/nvim-treesitter/nvim-treesitter) 플러그인입니다.
### Emacs
[just-mode](https://github.com/leon-barrett/just-mode.el)는 `justfile`의 문법 강조와 자동 들여쓰기를 제공합니다. 이 기능은 [MELPA](https://melpa.org/)에서 [just-mode](https://melpa.org/#/just-mode)로 제공됩니다.
[justl](https://github.com/psibi/justl.el)은 레시피를 실행하고 목록을 표시하는 명령어를 제공합니다.
개별 `justfile`에 파일 단위로 `make` 모드를 활성화하려면 다음 내용을 추가할 수 있습니다:
```text
# Local Variables:
# mode: makefile
# End:
```
### Visual Studio Code
VS Code용 확장은 [여기서 확인할 수 있습니다](https://github.com/nefrob/vscode-just).
유지보수되지 않는 VS Code 확장에는
[skellock/vscode-just](https://github.com/skellock/vscode-just) 및
[sclu1034/vscode-just](https://github.com/sclu1034/vscode-just)가 포함됩니다.
### JetBrains IDE
[linux\_china](https://github.com/linux-china)가 제작한 JetBrains IDE용 플러그인은
[여기서 확인할 수 있습니다](https://plugins.jetbrains.com/plugin/18658-just).
### Kakoune
TeddyDD 덕분에 Kakoune은 `justfile` 문법 강조를 기본으로 지원합니다.
### Helix
[Helix](https://helix-editor.com/)는 버전 23.05부터 `justfile` 문법 강조를 기본으로 지원합니다.
### Sublime Text
[nk9](https://github.com/nk9/just\_sublime)의 [Just package](https://github.com/nk9/just\_sublime)는

[nk9](https://github.com/nk9)의 `just` 구문 및 기타 도구들은 [PackageControl](https://packagecontrol.io/packages/Just)에서 사용할 수 있습니다.
### Micro
[tomodachi94](https://github.com/tomodachi94) 덕분에 [Micro](https://micro-editor.github.io/)는 Justfile 구문 강조 기능을 기본으로 지원합니다.
### Zed
[jackTabsCode](https://github.com/jackTabsCode)가 개발한 [zed-just](https://github.com/jackTabsCode/zed-just/) 확장은 [Zed extensions page](https://zed.dev/extensions?query=just)에서 사용할 수 있습니다.
### 기타 편집기
사용하는 편집기에서 구문 강조 기능이 작동하도록 만드는 데 필요한 명령어를 저에게 보내주시면 여기에 추가하겠습니다.
### Language Server Protocol
[just-lsp](https://github.com/terror/just-lsp)는 [language server protocol](https://en.wikipedia.org/wiki/Language\_Server\_Protocol) 구현을 제공하여 정의로 이동, 인라인 진단, 코드 완성 등의 기능을 활성화합니다.
### Model Context Protocol
[just-mcp](https://github.com/promptexecution/just-mcp)는 LLM이 `justfiles`의 내용을 조회하고 레시피를 실행할 수 있도록 [model context protocol](https://en.wikipedia.org/wiki/Model\_Context\_Protocol) 어댑터를 제공합니다.
빠른 시작
-----------
컴퓨터에 `just`를 설치하는 방법은 설치 섹션을 참조하세요. 제대로 설치되었는지 확인하려면 `just --version`을 실행해 보세요.
구문에 대한 개요는 [이 치트시트](https://cheatography.com/linux-china/cheat-sheets/justfile/)를 확인하세요.
`just`가 설치되어 정상적으로 작동하면, 프로젝트의 루트 디렉토리에 `justfile`이라는 이름의 파일을 만들고 다음 내용을 작성하세요:
```just
recipe-name:
echo 'This is a recipe!'
# this is a comment
another-recipe:
@echo 'This is another recipe.'
```
`just`를 실행하면 현재 디렉토리 및 상위 디렉토리에서 `justfile`이라는 이름의 파일을 찾으므로, 프로젝트의 어떤 하위 디렉토리에서든 실행할 수 있습니다.
`justfile` 검색은 대소문자를 구분하지 않으므로 `Justfile`, `JUSTFILE`, `JuStFiLe` 등 어떤 대소문자 조합이든 작동합니다. 또한 `just`는 `justfile`을 숨기고 싶은 경우를 대비해 `.justfile` 이름의 파일도 찾습니다.
기본적으로 인자 없이 `just`를 실행하면 `justfile`의 첫 번째 레시피가 실행됩니다:
```console
$ just
echo 'This is a recipe!'
This is a recipe!
```
하나 이상의 인자를 지정하여 실행할 레시피를 선택할 수 있습니다:
```console
$ just another-recipe
This is another recipe.
```
`just`는 각 명령어를 실행하기 전에 표준 에러로 출력하므로 `echo 'This is a recipe!'`가 출력된 것입니다. `@`로 시작하는 줄은 이 출력이 생략되므로 `echo 'This is another recipe.'`는 출력되지 않습니다.
명령어가 실패하면 레시피 실행이 중단됩니다. 여기서는 `cargo test`가 성공할 때만 `cargo publish`가 실행됩니다:
```just
publish:
cargo test
# tests passed, time to publish!
cargo publish
```
레시피는 다른 레시피에 의존할 수 있습니다. 여기서는 `test` 레시피가 `build` 레시피에 의존하므로 `test` 전에 `build`가 실행됩니다:
```just
build:
cc main.c foo.c bar.c -o main
test: build
./test
sloc:
@echo "`wc -l \*.c` lines of code"
```
```console
$ just test
cc main.c foo.c bar.c -o main
./test
testing… all tests passed!
```
의존성이 없는 레시피들은 명령줄에 주어진 순서대로 실행됩니다:
```console
$ just build sloc
cc main.c foo.c bar.c -o main
1337 lines of code
```
의존성은 그것에 의존하는 레시피 뒤에 전달되더라도 항상 먼저 실행됩니다:
```console
$ just test build
cc main.c foo.c bar.c -o main
./test
testing… all tests passed!
```
레시피는 서브모듈의 레시피에 의존할 수 있습니다:
```justfile
mod foo
baz: foo::bar
```
예제
--------
다양한 `justfile`은 [examples directory](https://github.com/casey/just/tree/master/examples)와 [GitHub](https://github.com/search?q=path%3A\*\*%2Fjustfile&type=code)에서 찾아볼 수 있습니다.
레시피
-------
### 기본 레시피
레시피 이름 없이 `just`를 실행하면 `[default]` 속성이 있는 레시피가 실행되며, `[default]` 속성을 가진 레시피가 없는 경우 `justfile`의 첫 번째 레시피가 실행됩니다.
이 레시피는

프로젝트에서 가장 자주 실행되는 명령어는, 예를 들어
테스트를 실행하는 다음과 같은 명령어입니다:
```just
test:
cargo test
```
또한 의존성을 사용하여 기본적으로 여러 레시피를 실행할 수도 있습니다:
```just
default: lint build test
build:
echo Building…
test:
echo Testing…
lint:
echo Linting…
```
기본 레시피로 적절한 레시피가 없는 경우, `default-list`1.52.0를 사용하여 대신 사용 가능한 레시피 목록을 출력할 수 있습니다:
```just
set default-list := true
```
### 레시피 매개변수
레시피는 매개변수를 가질 수 있습니다. 여기서 `build` 레시피에는
`target`이라는 매개변수가 있습니다:
```just
build target:
@echo 'Building {{target}}…'
cd {{target}} && make
```
명령줄에서 인수를 전달하려면, 레시피 이름 뒤에 인수를 배치하세요:
```console
$ just build my-awesome-project
Building my-awesome-project…
cd my-awesome-project && make
```
의존성에 인수를 전달하려면, 의존성 이름과 인수를 함께 괄호 안에 넣으세요:
```just
default: (build "main")
build target:
@echo 'Building {{target}}…'
cd {{target}} && make
```
변수도 의존성에 대한 인수로 전달할 수 있습니다:
```just
target := "main"
\_build version:
@echo 'Building {{version}}…'
cd {{version}} && make
build: (\_build target)
```
명령어의 인수를 의존성에 전달하려면, 의존성 이름과 인수를 함께 괄호 안에 넣으면 됩니다:
```just
build target:
@echo "Building {{target}}…"
push target: (build target)
@echo 'Pushing {{target}}…'
```
매개변수에 기본값을 지정할 수도 있습니다:
```just
default := 'all'
test target tests=default:
@echo 'Testing {{target}}:{{tests}}…'
./test --tests {{tests}} {{target}}
```
기본값이 있는 매개변수는 생략할 수 있습니다:
```console
$ just test server
Testing server:all…
./test --tests all server
```
또는 값을 지정할 수도 있습니다:
```console
$ just test server unit
Testing server:unit…
./test --tests unit server
```
기본값은 임의의 표현식이 될 수 있지만, `+`, `&&`, `||`, `/` 연산자가 포함된 표현식은 괄호로 감싸야 합니다:
```just
arch := "wasm"
test triple=(arch + "-unknown-unknown") input=(arch / "input.dat"):
./test {{triple}}
```
레시피의 마지막 매개변수는 가변 매개변수가 될 수 있으며, 인수 이름 앞에 `+` 또는 `\*`를 붙여서 나타냅니다:
```just
backup +FILES:
scp {{FILES}} me@server.com:
```
`+`가 앞에 붙은 가변 매개변수는 \_하나 이상\_의 인수를 허용하며, 공백으로 구분된 해당 인수들을 포함하는 문자열로 확장됩니다:
```console
$ just backup FAQ.md GRAMMAR.md
scp FAQ.md GRAMMAR.md me@server.com:
FAQ.md 100% 1831 1.8KB/s 00:00
GRAMMAR.md 100% 1666 1.6KB/s 00:00
```
`\*`가 앞에 붙은 가변 매개변수는 \_0개 이상\_의 인수를 허용하며, 공백으로 구분된 해당 인수들을 포함하는 문자열로 확장됩니다. 인수가 없는 경우 빈 문자열이 됩니다:
```just
commit MESSAGE \*FLAGS:
git commit {{FLAGS}} -m "{{MESSAGE}}"
```
가변 매개변수에도 기본값을 할당할 수 있습니다. 이는 명령줄에서 전달된 인수에 의해 재정의됩니다:
```just
test +FLAGS='-q':
cargo test {{FLAGS}}
```
가변 매개변수가 허용하는 인수 개수는 `[arg(ARG, min=MIN)]` 및 `[arg(ARG, max=MAX)]` 속성1.56.0을 사용하여 제한할 수 있으며, 이를 사용하려면 리스트 기능이 활성화되어 있어야 합니다:
```just
set unstable
set lists
[arg('FILES', min='2', max='4')]
backup +FILES:
scp {{FILES}} me@server.com:
```
`min`과 `max`는 기본값에도 적용됩니다.
`{{…}}` 대체 항목은 공백을 포함하는 경우 따옴표로 감싸야 할 수 있습니다. 예를 들어, 다음과 같은 레시피가 있다고 가정해 봅시다:
```just
search QUERY:
lynx https://www.google.com/?q={{QUERY}}
```
그리고 다음과 같이 입력하면:
```console
$ just search "cat toupee"
```
`just`는 `lynx https://www.google.com/?q=cat toupee` 명령어를 실행하게 되며, 이는 `sh`에 의해 `lynx`, `https://www.google.com/?q=cat`, `toupee`로 파싱되어 의도한 `lynx`와 `https://www.google.com/?q=cat toupee`가 아닌 다른 결과로 처리됩니다.
따옴표를 추가하여 이를 해결할 수 있습니다:
```just
search QUERY:
lynx 'https://www.google.com/?q={{QUERY}}'
```
`$`가 앞에 붙은 매개변수는 환경 변수로 내보내집니다:
```just
foo $bar:
echo $bar
```
매개변수는 정규 표현식 패턴과 일치하도록 제한될 수 있습니다

`[arg("name", pattern=PATTERN)]` 어트리뷰트를 사용하는 방법1.45.0:
```just
[arg('n', pattern='\d+')]
double n:
echo $(({{n}} \* 2))
```
`pattern`의 값은 const 표현식일 수 있습니다1.55.0.
패턴의 시작 부분에 `^`가, 끝 부분에 `$`가 자동으로 추가되므로, 전체 인수 값과 일치해야 합니다.
`|` 연산자를 사용하여 패턴을 여러 대안 중 하나로 제한할 수 있습니다:
```just
[arg('flag', pattern='--help|--version')]
info flag:
just {{flag}}
```
정규 표현식은 [Rust `regex` 크레이트](https://docs.rs/regex/latest/regex/)에서 제공합니다. 사용 예시는 [문법 문서](https://docs.rs/regex/latest/regex/#syntax)를 참고하세요.
레시피에 대한 사용법 정보는 `--usage` 하위 명령어를 사용하여 출력할 수 있습니다1.46.0:
```console
$ just --usage foo
Usage: just foo [OPTIONS] bar
Arguments:
bar
```
`[arg(ARG, help=HELP)]` 어트리뷰트를 사용하여 인수에 도움말 문자열을 추가할 수 있습니다:
```just
[arg("bar", help="hello")]
foo bar:
```
`help`의 값은 const 표현식일 수 있습니다1.55.0.
```console
$ just --usage foo
Usage: just foo bar
Arguments:
bar hello
```
#### 레시피 플래그 및 옵션
레시피 매개변수는 기본적으로 위치 기반입니다.
다음 `justfile`에서:
```just
@foo bar:
echo bar={{bar}}
```
매개변수 `bar`는 위치 기반입니다:
```console
$ just foo hello
bar=hello
```
`[arg(ARG, long=OPTION)]`1.46.0 어트리뷰트를 사용하면 매개변수를 긴 옵션(long option)으로 만들 수 있습니다.
다음 `justfile`에서:
```just
[arg("bar", long="bar")]
foo bar:
```
매개변수 `bar`는 `--bar` 옵션으로 전달됩니다:
```console
$ just foo --bar hello
bar=hello
```
옵션은 `--name=value` 구문으로도 전달할 수 있습니다:
```console
$ just foo --bar=hello
bar=hello
```
`long`의 값은 생략할 수 있으며, 이 경우 옵션의 이름은 기본적으로 매개변수의 이름이 됩니다. 다음 justfile에서 `bar`는 `--bar`를 통해 전달할 수 있습니다:
```just
[arg("bar", long)]
foo bar:
```
`[arg(ARG, short=OPTION)]`1.46.0 어트리뷰트를 사용하면 매개변수를 짧은 옵션(short option)으로 만들 수 있습니다.
다음 `justfile`에서:
```just
[arg("bar", short="b")]
foo bar:
```
매개변수 `bar`는 `-b` 옵션으로 전달됩니다:
```console
$ just foo -b hello
bar=hello
```
`short`의 값은 생략할 수 있으며, 이 경우 옵션의 이름은 기본적으로 매개변수 이름의 첫 글자가 됩니다. 다음 justfile에서 `bar`는 `-b`를 통해 전달할 수 있습니다:
```just
[arg("bar", short)]
foo bar:
```
매개변수에 긴 옵션과 짧은 옵션이 모두 있는 경우 둘 중 하나를 사용하여 전달할 수 있습니다.
여러 개의 짧은 옵션을 결합할 수 있습니다1.55.0. 예를 들어 `-abc`는 `-a -b -c`와 동일합니다. 값을 취하는 짧은 옵션은 가장 마지막에 올 수 있습니다. 예를 들어 `-abcd VALUE`와 같이 사용할 수 있습니다.
가변 인자 `\*` 및 `+` 매개변수는 옵션이 될 수 있으며, 이 경우 옵션을 반복해서 사용할 수 있고 각 사용마다 하나의 값이 추가됩니다:
```just
[arg('file', long)]
backup +file:
scp {{file}} me@server.com:
```
```console
$ just backup --file FAQ.md --file GRAMMAR.md
scp FAQ.md GRAMMAR.md me@server.com:
```
위치 기반 가변 인자 매개변수와 마찬가지로, `+` 옵션은 최소한 한 번 이상 전달되어야 하는 반면 `\*` 옵션은 생략할 수 있습니다.
`[arg(ARG, value=VALUE, …)]`1.46.0 어트리뷰트를 `long` 또는 `short`과 함께 사용하여 매개변수를 값을 취하지 않는 플래그로 만들 수 있습니다.
`VALUE`는 표현식일 수 있습니다1.54.0.
다음 `justfile`에서:
```just
[arg("bar", long="bar", value="hello")]
foo bar:
```
매개변수 `bar`는 `--bar` 옵션으로 전달되지만 값을 직접 받지 않고, 대신 `[arg]` 어트리뷰트에 지정된 값을 사용합니다:
```console
$ just foo --bar
bar=hello
```
이는 위험한 명령어에 `--force` 같은 플래그를 무조건 요구해야 할 때 유용합니다.
플래그의 매개변수에 기본값이 있는 경우, 해당 플래그는 선택 사항이 됩니다:
```just
[arg("bar", long="bar", value="hello")]
foo bar="goodbye":
```
호출 시 전달되지 않으면 기본값을 받게 됩니다:
```console
$ just foo
bar=goodbye
```
### 인수 분할 방지하기
다음 `justfile`이 주어졌을 때:
```just
foo argument:
touch {{argument}}
```
다음 명령어는 `some`과 `argument.txt`라는 두 개의 파일을 생성합니다:
```console
$ just foo "some argument.txt"
```
사용자의 쉘은 pa

rse `"some argument.txt"`를 단일 인수로 처리하지만,
`just`가 `touch {{argument}}`를 `touch some argument.txt`로 치환할 때
따옴표가 보존되지 않아 `touch`는 두 개의 인수를 받게 됩니다.
이를 피하는 몇 가지 방법이 있습니다: 따옴표 사용, 위치 인수(positional arguments), 그리고 내보낸 인수(exported arguments)입니다.
#### 따옴표 사용
`{{argument}}` 보간(interpolation) 주위에 따옴표를 추가할 수 있습니다:
```just
foo argument:
touch '{{argument}}'
```
이렇게 하면 실행 전에 변수 이름 오탈자를 잡아내는 `just`의 기능이 유지되지만 (예를 들어 `{{argument}}`라고 작성한 경우), `argument`의 값에 작은따옴표가 포함된 경우에는 원하는 대로 작동하지 않습니다.
#### 위치 인수 (Positional Arguments)
`positional-arguments` 설정은 모든 인수가 위치 인수로 전달되도록 하여 `$1`, `$2`, …, 그리고 `$@`를 통해 접근할 수 있게 합니다. 이들을 큰따옴표로 감싸면 셸에 의해 추가로 분리되는 것을 방지할 수 있습니다:
```just
set positional-arguments
foo argument:
touch "$1"
```
이렇게 하면 `$1` 대신 `$2`를 입력하는 등의 오탈자를 잡아내는 `just`의 기능은 사용할 수 없게 되지만, 큰따옴표가 포함된 값을 포함하여 `argument`의 가능한 모든 값에 대해 작동합니다.
#### 내보낸 인수 (Exported Arguments)
`export` 설정이 설정되면 모든 인수가 내보내집니다:
```just
set export
foo argument:
touch "$argument"
```
또는 앞에 `$`를 붙여 개별 인수를 내보낼 수도 있습니다:
```just
foo $argument:
touch "$argument"
```
이렇게 하면 `$argument`를 잘못 입력하는 등의 오탈자를 잡아내는 `just`의 기능은 사용할 수 없게 되지만, 큰따옴표가 포함된 값을 포함하여 `argument`의 가능한 모든 값에 대해 작동합니다.
### 위치 인수 (Positional Arguments)
`positional-arguments`가 `true`인 경우, 레시피 인수가 명령어에 위치 인수로 전달됩니다. 셸 레시피의 경우 `$0` 인수는 레시피의 이름이 됩니다.
예를 들어, 다음 레시피를 실행하면:
```just
set positional-arguments
@foo bar:
echo $0
echo $1
```
다음과 같은 출력을 생성합니다:
```console
$ just foo hello
foo
hello
```
`bash`나 `zsh`와 같은 `sh` 호환 셸을 사용할 때, `$@`는 1번부터 시작하여 레시피에 전달된 위치 인수로 확장됩니다. `"$@"`와 같이 큰따옴표 내에서 사용하면 공백이 포함된 인수가 마치 각각 큰따옴표로 감싸진 것처럼 전달됩니다. 즉, `"$@"`는 `"$1" "$2"`…와 동일합니다.
위치 매개변수가 없을 때 `"$@"`와 `$@`는 아무것도 아닌 것으로 확장됩니다 (즉, 제거됩니다).
이 예제 레시피는 인수들을 각각 다른 줄에 하나씩 출력합니다:
```just
set positional-arguments
@test \*args='':
bash -c 'while (( "$#" )); do echo - $1; shift; done' -- "$@"
```
_두 개의_ 인수를 주고 실행하기:
```console
$ just test foo "bar baz"
- foo
- bar baz
```
위치 인수는 `[positional-arguments]` attribute1.29.0를 사용하여 레시피별로 활성화할 수도 있습니다:
```just
[positional-arguments]
@foo bar:
echo $0
echo $1
```
PowerShell은 다른 셸과 동일한 방식으로 위치 인수를 처리하지 않으므로, 위치 인수를 활성화하면 PowerShell을 사용하는 레시피가 깨질 수 있다는 점에 유의하세요.
PowerShell 7.4 이상을 사용하는 경우, `-CommandWithArgs` 플래그를 사용하면 위치 인수가 예상대로 작동합니다:
```just
set shell := ['pwsh.exe', '-CommandWithArgs']
set positional-arguments
print-args a b c:
Write-Output @($args[1..($args.Count - 1)])
```
### 의존성 (Dependencies)
의존성은 그것에 의존하는 레시피보다 먼저 실행됩니다:
```just
a: b
@echo A
b:
@echo B
```
```
$ just a
B
A
```
`just`를 한 번 호출할 때, 명령줄 호출에 나타나는 횟수나 의존성으로 나타나는 횟수에 관계없이 동일한 인수를 가진 레시피는 한 번만 실행됩니다:
```just
a:
@echo A
b: a
@echo B
c: a
@echo C
```
```
$ just a a a a a
A
$ just b c
A
B
C
```
여러 레시피가 어떤 종류의 설정을 수행하는 레시피에 의존할 수 있으며, 이 레시피들이 실행될 때 해당 설정은 한 번만 수행됩니다:
```just
build:
cc main.c
test-foo: build
./a.out --test foo
test-bar: build
./a.out --test bar
```
```
$ just test-foo test-bar
cc main.c
./a.out --test foo
./a.out --test bar
```
주어진 실행에서 레시피는 다음을 받을 때만 건너뛰어집니다

동일한 인자:
```just
build:
cc main.c
test TEST: build
./a.out --test {{TEST}}
```
```
$ just test foo test bar
cc main.c
./a.out --test foo
./a.out --test bar
```
#### 레시피의 끝에서 레시피 실행하기
레시피의 일반적인 의존성은 항상 레시피가 시작되기 전에 실행됩니다. 즉, 피의존성이 의존성보다 항상 먼저 실행됩니다. 이러한 의존성을 "사전 의존성(prior dependencies)"이라고 합니다.
레시피에는 후행 의존성(subsequent dependencies)도 있을 수 있으며, 이는 레시피 직후에 실행되고 `&&`로 지정합니다:
```just
a:
echo 'A!'
b: a && c d
echo 'B!'
c:
echo 'C!'
d:
echo 'D!'
```
…\_b\_를 실행하면 다음이 출력됩니다:
```console
$ just b
echo 'A!'
A!
echo 'B!'
B!
echo 'C!'
C!
echo 'D!'
D!
```
#### 레시피 중간에서 레시피 실행하기
`just`는 다른 레시피의 중간에서 레시피를 실행하는 것을 지원하지 않지만, 레시피 중간에서 재귀적으로 `just`를 호출할 수 있습니다. 다음과 같은 `justfile`이 주어졌을 때:
```just
a:
echo 'A!'
b: a
echo 'B start!'
just c
echo 'B end!'
c:
echo 'C!'
```
…\_b\_를 실행하면 다음이 출력됩니다:
```console
$ just b
echo 'A!'
A!
echo 'B start!'
B start!
echo 'C!'
C!
echo 'B end!'
B end!
```
이 방식에는 한계가 있습니다. 레시피 `c`가 완전히 새로운 `just` 호출로 실행되기 때문입니다. 변수 할당이 재계산되고, 의존성이 두 번 실행될 수 있으며, 명령행 인자가 자식 `just` 프로세스로 전달되지 않습니다.
### 병렬성
`[parallel]` 속성을 사용하면 의존성을 병렬로 실행할 수 있습니다.
이 `justfile`에서 `main`이 실행될 때 `foo`, `bar`, `baz`는 병렬로 실행됩니다:
```just
[parallel]
main: foo bar baz
foo:
sleep 1
bar:
sleep 1
baz:
sleep 1
```
동시에 실행되는 레시피의 수는 `--jobs` 옵션1.56.0을 사용하여 제한할 수 있습니다. `num\_jobs()` 함수는 작업의 수를 반환하며, `--jobs`가 전달되지 않은 경우 빈 리스트로 대체됩니다.
GNU `parallel`을 사용하여 레시피 라인을 동시에 실행할 수 있습니다:
```just
parallel:
#!/usr/bin/env -S parallel --shebang --ungroup --jobs {{ num\_cpus() }}
echo task 1 start; sleep 3; echo task 1 done
echo task 2 start; sleep 3; echo task 2 done
echo task 3 start; sleep 3; echo task 3 done
echo task 4 start; sleep 3; echo task 4 done
```
### 문서 주석
레시피 바로 앞에 있는 주석은 `just --list`에 표시됩니다:
```just
# build stuff
build:
./bin/build
# test stuff
test:
./bin/test
```
```console
$ just --list
Available recipes:
build # build stuff
test # test stuff
```
`[doc]` 속성을 사용하여 레시피의 문서 주석을 설정하거나 숨길 수 있습니다:
```just
# This comment won't appear
[doc('Build stuff')]
build:
./bin/build
# This one won't either
[doc]
test:
./bin/test
```
```console
$ just --list
Available recipes:
build # Build stuff
test
```
`[doc]`의 값은 상수 표현식1.56.0일 수 있습니다.
### 그룹
레시피와 모듈에는 하나 이상의 그룹 이름을 주석으로 지정할 수 있습니다:
```just
[group('lint')]
js-lint:
echo 'Running JS linter…'
[group('rust recipes')]
[group('lint')]
rust-lint:
echo 'Running Rust linter…'
[group('lint')]
cpp-lint:
echo 'Running C++ linter…'
# not in any group
email-everyone:
echo 'Sending mass email…'
```
레시피는 그룹별로 나열됩니다:
```
$ just --list
Available recipes:
email-everyone # not in any group
[lint]
cpp-lint
js-lint
rust-lint
[rust recipes]
rust-lint
```
`just --list --unsorted`는 각 그룹 내에서 justfile에 작성된 순서대로 레시피를 출력합니다:
```
$ just --list --unsorted
Available recipes:
(no group)
email-everyone # not in any group
[lint]
js-lint
rust-lint
cpp-lint
[rust recipes]
rust-lint
```
`--groups`를 사용하여 그룹을 나열할 수 있습니다:
```
$ just --groups
Recipe groups:
lint
rust recipes
```
그룹을 justfile에 작성된 순서대로 출력하려면 `just --groups --unsorted`를 사용하세요.
### 별칭
별칭을 사용하면 명령행에서 대체 이름으로 레시피를 호출할 수 있습니다:
```just
alias b := build
build:
echo 'Building!'
```
```console
$ just b
echo 'Building!'
Building!
```
별칭의 대상은 서브모듈의 레시피일 수 있습니다:
```justfile
mod foo
alias baz := foo::bar
```
또는 모듈1.55.0일 수도 있습니다:
```justfile
mod frontend
alias f := frontend
```
```console
$ just

f build
```
### 프라이빗 레시피 (Private Recipes)
이름이 `\_`로 시작하는 레시피와 별칭은 `just --list`에서 제외됩니다:
```just
test: \_test-helper
./bin/test
\_test-helper:
./bin/super-secret-test-helper-stuff
```
```console
$ just --list
Available recipes:
test
```
또한 `just --summary`에서도 제외됩니다:
```console
$ just --summary
test
```
`[private]` 속성1.10.0을 사용하면 이름을 변경하지 않고도 레시피나 별칭을 숨길 수 있습니다:
```just
[private]
foo:
[private]
alias b := bar
bar:
```
```console
$ just --list
Available recipes:
bar
```
이는 다른 레시피의 의존성으로만 사용되는 헬퍼 레시피에 유용합니다.

### 항목 활성화 및 비활성화 (Enabling and Disabling Items)
`[android]`, `[dragonfly]`, `[freebsd]`, `[linux]`, `[macos]`, `[netbsd]`, `[openbsd]`, `[unix]`, 그리고 `[windows]` 속성은 조건부 속성입니다.
기본적으로 항목은 항상 활성화됩니다. 하나 이상의 조건부 속성을 가진 항목은 해당 조건부 속성 중 하나 이상이 활성화된 경우에만 활성화됩니다.
조건부 속성은 원래 레시피에만 적용되었지만, 이제 모든 최상위 항목에 적용될 수 있습니다1.56.0.

이를 사용하여 실행 중인 운영체제에 따라 다르게 동작하는 `justfile`을 작성할 수 있습니다. 이 `justfile`의 `run` 레시피는 운영체제에 따라 다른 C 컴파일러와 해당 컴파일러에 맞는 올바른 출력 바이너리 이름을 사용하여 `main.c`를 컴파일하고 실행합니다:
```just
[unix]
run:
cc main.c
./a.out
[windows]
run:
cl main.c
main.exe
```
마찬가지로 현재 운영체제에 따라 설정을 조건부로 지정할 수 있습니다:
```just
[unix]
set shell := ['sh', '-cu']
[windows]
set shell := ['cmd', '/c']
```

### 중복 레시피 허용 (Allow Duplicate Recipes)
`allow-duplicate-recipes`가 `true`로 설정된 경우, 이름이 같은 여러 레시피를 정의해도 오류가 발생하지 않으며 마지막 정의가 사용됩니다. 기본값은 `false`입니다.
```just
set allow-duplicate-recipes
@foo:
echo foo
@foo:
echo bar
```
```console
$ just foo
bar
```

표현식 (Expressions)
-------------------
### 변수 및 할당 (Variables and Assignments)
모듈 수준의 변수는 `:=`를 사용하여 값을 할당함으로써 생성할 수 있습니다:
```just
foo := "hello"
bar := "world"
baz:
echo {{ foo + " " + bar }}
```
모듈 내의 모든 변수를 출력할 수 있습니다:
```console
$ just --evaluate
bar := "world"
foo := "hello"
```
또는 단일 변수의 값만 출력할 수 있습니다:
```console
$ just --evaluate foo
hello
```
하위 모듈의 모든 변수나 하위 모듈 내의 단일 변수는 하위 모듈 또는 변수 경로를 지정하여 출력할 수 있습니다1.49.0:
```console
$ just --evaluate bob::bar
x := "world"
y := "hello"
$ just --evaluate bob::bar::y
hello
```
내보낸(exported) 변수의 형식은 `--evaluate-format`1.49.0을 사용하여 제어할 수 있습니다:
```console
$ just --evaluate --evaluate-format shell
bar="world"
foo="hello"
```
기본 형식은 `--evaluate-format just`입니다:
```console
$ just --evaluate --evaluate-format just
bar := "world"
foo := "hello"
```

### 중복 변수 허용 (Allow Duplicate Variables)
`allow-duplicate-variables`가 `true`로 설정된 경우, 이름이 같은 여러 변수를 정의해도 오류가 발생하지 않으며 마지막 정의가 사용됩니다. 기본값은 `false`입니다.
```just
set allow-duplicate-variables
a := "foo"
a := "bar"
@foo:
echo {{a}}
```
```console
$ just foo
bar
```

### 지연 평가 (Lazy)
`lazy` 설정1.47.0을 사용하면 평가기가 사용되지 않는 변수의 평가를 건너뜁니다. 이는 `justfile`에 평가는 비용이 많이 들지만 가끔만 사용되는 변수가 포함되어 있을 때 유용합니다.
다음 `justfile`에서 `bar`만 호출할 때는 `token`이 건너뛰어집니다:
```just
set lazy
token := `expensive-script-to-get-credentials`
foo:
curl -H "Authorization: Bearer {{ token }}" https://example.com/foo
bar:
cargo test
```
`just`는 내보낸 변수가 언제 사용되는지 판단할 수 없으므로, `export`가 포함된 할당과 `set export`가 있는 모듈 내의 할당은 항상 평가됩니다.

### 표현식 및 대체 (Expressions and Substitutions)
표현식에서는 다양한 연산자와 함수 호출이 지원되며, 이는 할당, 기본 레시피 인수, 그리고 레시피 본문의 `{{…}}` 대체 내에서 사용할 수 있습니다.
```just
tmpdir
```

:= `mktemp -d`
version := "0.2.7"
tardir := tmpdir / "awesomesauce-" + version
tarball := tardir + ".tar.gz"
config := quote(config\_dir() / ".project-config")
publish:
rm -f {{tarball}}
mkdir {{tardir}}
cp README.md \*.c {{ config }} {{tardir}}
tar zcvf {{tarball}} {{tardir}}
scp {{tarball}} me@server.com:release/
rm -rf {{tarball}} {{tardir}}
```
#### 문자열 연결 (Concatenation)
`+` 연산자는 왼쪽 인자와 오른쪽 인자를 연결한 결과를 반환합니다:
```just
foobar := 'foo' + 'bar'
```
#### 논리 연산자
논리 연산자 `&&`와 `||`는 Python의 `and` 및 `or`와 유사하게 값을 병합하는 데 사용할 수 있습니다1.37.0. 유일한 거짓(false) 값은 빈 리스트 `[]`이며, 빈 문자열 `''`을 포함한 다른 모든 값은 참(true)입니다.
이 연산자들은 현재 불안정(unstable) 상태인 `set lists`1.53.0를 필요로 합니다.
`&&` 연산자는 왼쪽 인자가 거짓이면 빈 리스트를 반환하고, 그렇지 않으면 오른쪽 인자를 반환합니다:
```justfile
foo := [] && 'goodbye' # []
bar := 'hello' && 'goodbye' # 'goodbye'
```
`||` 연산자는 왼쪽 인자가 참이면 해당 값을 반환하고, 그렇지 않으면 오른쪽 인자를 반환합니다:
```justfile
foo := [] || 'goodbye' # 'goodbye'
bar := 'hello' || 'goodbye' # 'hello'
```
#### 경로 결합
`/` 연산자는 슬래시를 사용하여 두 문자열을 결합하는 데 사용할 수 있습니다:
```just
foo := "a" / "b"
```
```
$ just --evaluate foo
a/b
```
이미 슬래시가 존재하는 경우에도 `/`가 추가된다는 점에 유의하세요:
```just
foo := "a/"
bar := foo / "b"
```
```
$ just --evaluate bar
a//b
```
절대 경로도 생성할 수 있습니다1.5.0:
```just
foo := / "b"
```
```
$ just --evaluate foo
/b
```
`/` 연산자는 Windows에서도 `/` 문자를 사용합니다. 따라서 범용 명명 규칙(UNC), 즉 `\\`로 시작하는 경로는 슬래시를 지원하지 않으므로, UNC 경로를 사용할 때는 `/` 연산자 사용을 피해야 합니다.
#### `{{` 이스케이프하기
`{{`를 포함하는 레시피를 작성하려면 `{{{{`를 사용하세요:
```just
braces:
echo 'I {{{{LOVE}} curly braces!'
```
(짝이 맞지 않는 `}}`는 무시되므로 이스케이프할 필요가 없습니다.)
다른 방법으로는 이스케이프하고 싶은 모든 텍스트를 보간(interpolation) 내부에 넣는 것입니다:
```just
braces:
echo '{{'I {{LOVE}} curly braces!'}}'
```
또 다른 방법은 `{{ "{{" }}`를 사용하는 것입니다:
```just
braces:
echo 'I {{ "{{" }}LOVE}} curly braces!'
```
### 문자열
`'single'`, `"double"`, 그리고 `'''triple'''` 따옴표로 감싼 문자열 리터럴이 지원됩니다. 레시피 본문과 달리, 문자열 내부에서는 `{{…}}` 보간이 지원되지 않습니다.
큰따옴표로 감싼 문자열은 이스케이프 시퀀스를 지원합니다:
```just
carriage-return := "\r"
double-quote := "\""
newline := "\n"
no-newline := "\
"
slash := "\\"
tab := "\t"
unicode-codepoint := "\u{1F916}"
```
```console
$ just --evaluate
"arriage-return := "
double-quote := """
newline := "
"
no-newline := ""
slash := "\"
tab := " "
unicode-codepoint := "🤖"
```
유니코드 문자 이스케이프 시퀀스 `\u{…}`1.36.0는 최대 6자리의 16진수를 허용합니다.
문자열에는 줄바꿈이 포함될 수 있습니다:
```just
single := '
hello
'
double := "
goodbye
"
```
작은따옴표로 감싼 문자열은 이스케이프 시퀀스를 인식하지 않습니다:
```just
escapes := '\t\n\r\"\\'
```
```console
$ just --evaluate
escapes := "\t\n\r\"\\"
```
삼중 작은따옴표나 삼중 큰따옴표로 구분되는 들여쓰기된 형태의 단일 및 이중 따옴표 문자열 모두 지원됩니다. 들여쓰기된 문자열의 각 줄에서는 선행 줄바꿈과, 비어 있지 않은 모든 줄에 공통으로 들어 있는 선행 공백이 제거됩니다:
```just
# 이 문자열은 `foo\nbar\n`로 평가됩니다.
x := '''
foo
bar
'''
# 이 문자열은 `abc\n wuv\nxyz\n`로 평가됩니다.
y := """
abc
wuv
xyz
"""
```
들여쓰기되지 않은 문자열과 유사하게, 들여쓰기된 큰따옴표 문자열은 이스케이프 시퀀스를 처리하고, 들여쓰기된 작은따옴표 문자열은 이스케이프 시퀀스를 무시합니다. 이스케이프 시퀀스 처리는 들여쓰기 제거(unindentation) 후에 이루어집니다. 들여쓰기 제거 알고리즘은 이스케이프 시퀀스로 인해 생성된 공백이나 줄바꿈은 고려하지 않습니다.
#### 셸 확장 문자열
`x` 접두사가 붙은 문자열은 셸 확장됩니다1.27.0:
```justfile
foobar := x'~/$FOO/${BAR}'
```
| 값 | 대체 |
|------|-------------|

| `$VAR` | 환경 변수 `VAR`의 값 |
| `${VAR}` | 환경 변수 `VAR`의 값 |
| `${VAR:-DEFAULT}` | 환경 변수 `VAR`의 값, 또는 `VAR`가 설정되지 않은 경우 `DEFAULT` |
| 맨 앞의 `~` | 현재 사용자의 홈 디렉터리 경로 |
| 맨 앞의 `~USER` | `USER`의 홈 디렉터리 경로 |
이 확장은 컴파일 시점에 수행되므로, `.env` 파일의 변수나 내보낸 `just` 변수는 사용할 수 없습니다. 하지만 이를 통해 셸에서 확장된 문자열을 `just` 변수나 `.env` 파일에 의존할 수 없는 설정 및 임포트 경로 같은 곳에서 사용할 수 있습니다.
#### 포맷 문자열
`f`로 시작하는 문자열은 포맷 문자열입니다 (1.44.0 버전에 도입됨):
```justfile
name := "world"
message := f'Hello, {{name}}!'
```
포맷 문자열은 표현식을 포함하는 `{{…}}`로 구분된 보간을 포함할 수 있습니다. 포맷 문자열은 연결된 문자열 조각과 평가된 표현식으로 평가됩니다.
포맷 문자열에 리터럴 `{{`를 포함하려면 `{{{{`를 사용하세요:
```justfile
foo := f'I {{{{LOVE} curly braces!'
```
### 리스트
`lists` 설정 (1.53.0 버전에 도입됨)은 문자열 리스트인 값을 허용합니다.
현재는 불안정하며 하위 호환성이 깨지는 방식으로 변경될 수 있습니다. 이 절에서는 `set lists`가 활성화되었을 때의 동작 변경 사항을 설명합니다.
많은 내장 함수에서 리스트가 어떻게 동작해야 하는지는 아직 결정되지 않았습니다. 리스트를 허용하도록 업데이트된 함수들은 이 절에서 언급됩니다. 다른 함수에 리스트를 사용하는 것은 오류입니다. 리스트를 업그레이드되지 않은 함수와 함께 사용할 수 있도록 공백으로 구분된 문자열로 변환하려면 `join\_list()` 함수를 사용할 수 있습니다. 내장 함수가 리스트와 함께 어떻게 동작해야 하는지, 그리고 전반적인 리스트에 대한 피드백을 환영합니다! [`set lists` 추적 이슈](https://github.com/casey/just/issues/3377)에 이슈를 열거나 코멘트를 남겨주세요.
가변 레시피 매개변수는 단일 공백으로 구분된 문자열 대신 문자열 리스트가 됩니다.
리스트 리터럴은 `[a, b, c]`와 같이 작성합니다. 리스트에는 다른 리스트가 포함될 수 없고 오직 문자열만 포함될 수 있으므로, 리스트 리터럴은 인수의 평탄화를 수행합니다. 예를 들어, `[["a", "b"], [], "c"]`는 `["a", "b", "c"]`로 평가됩니다.
레시피 및 `f` 문자열 보간에서의 리스트는 공백으로 결합되어 단일 문자열이 됩니다.
의존성에 대한 각 인수는 정확히 하나의 매개변수에 바인딩되며, 가변 의존성에 초과 인수를 공급하는 것은 오류입니다.
의존성은 `\*(recipe \*argument)`를 사용하여 리스트의 각 요소마다 한 번씩 호출할 수 있습니다.
인수가 빈 리스트일 때 매개변수는 기본값으로 평가됩니다.
기본값이 없는 non-`\*` 매개변수에 빈 리스트를 전달하는 것은 오류입니다.
`if`의 `else`는 생략할 수 있으며, 이 경우 조건이 거짓이면 `if`는 `[]`로 평가됩니다.
`assert(condition, message)` 및 `[confirm(message)]`의 메시지 값은 화면 표기를 위해 공백으로 결합됩니다.
`+` 및 `/` 연산자는 문자열과 리스트를 결합합니다. 문자열과 비어 있지 않은 리스트는 문자열을 리스트의 각 요소와 연결하여 결합됩니다.
길이가 같은 두 리스트는 두 피연산자의 대응하는 요소를 쌍으로 연결한 리스트로 결합됩니다. 길이가 다른 두 리스트를 결합하는 것은 오류입니다.
`++` 연산자는 리스트 연결을 수행합니다.
#### 부울
표준 부울 참 값은 문자열 `"true"`이고, 표준 부울 거짓 값은 빈 리스트 `[]`입니다. 빈 리스트를 제외한 모든 값은 `''`를 포함하여 참으로 취급됩니다.
`if` 또는 `assert()`의 조건은 참/거짓 평가를 위해 어떤 표현식이든 될 수 있습니다.
비교 연산자 `==`, `!=`, `=~`, `!~`는 `if`와 `assert()`뿐만 아니라 어디서든 사용할 수 있으며, `"true"` 또는 `[]`로 평가됩니다.
`value =~ regexes`는 `value`의 어떤 요소라도 `regexes`의 어떤 정규식과 일치하면 참입니다. `value` 또는 `regexes` 중 하나라도 비어 있으면 거짓입니다.
`value !~ regexes`는 `value`의 어떤 요소도 `regexes`의 정규식과 일치하지 않으면 참입니다. `value` 또는 `regexes` 중 하나라도 비어 있으면 참입니다.
값은 `!`로 부정할 수 있습니다. `expression`이 `[]`인 경우 `!expression`은 `"true"`로 평가되고, 그렇지 않으면 `[]`로 평가됩니다.
#### 설정
`script-interpret

er`, `shell`, 그리고 `windows-shell` 설정은 리스트 리터럴처럼 요소를 평탄화합니다.
`positional-arguments`가 설정된 경우, 가변 인자(variadic)가 아니라면 리스트 인자는 공백으로 결합되며, 가변 인자인 경우 요소당 하나의 위치 인자로 전달됩니다.
`--dotenv-filename` 및 `--dotenv-path` 옵션은 여러 번 전달될 수 있으며, `dotenv-filename` 및 `dotenv-path` 설정은 리스트를 허용하므로 여러 개의 환경 파일이 로드될 수 있습니다. `dotenv-path`의 값이 먼저 시도됩니다. 아무것도 찾을 수 없으면 현재 디렉토리에서 `dotenv-filename`의 이름을 검색하고, 그 다음으로 상위 디렉토리를 검색하며, 그중 하나라도 포함된 첫 번째 디렉토리에서 멈추고 해당 디렉토리의 모든 일치하는 파일을 로드합니다. 여러 개의 환경 파일이 로드된 경우, 리스트에서 나중에 오는 파일의 변수가 이전 파일의 변수보다 우선합니다.
`set dotenv-command` 값의 각 요소는 명령어로 실행되며, 리스트에서 나중에 오는 명령어의 변수가 이전 명령어의 변수보다 우선합니다.
#### Attributes
`[arg(flag)]` 속성은 매개변수를 명령줄에서 값을 받지 않는 플래그로 만듭니다. 예를 들어, `[arg('foo', long, flag)]`의 경우, `--foo`가 전달되면 `foo`는 `"true"`가 되고, 그렇지 않으면 `[]`가 됩니다. 플래그 매개변수는 기본값을 가질 수 없습니다.
`[arg(multiple)]` 속성은 옵션이나 플래그가 둘 이상 전달되는 것을 허용하며, 전달된 값의 리스트를 매개변수에 할당합니다. `flag` 또는 `value=VALUE`와 결합될 때, 각각 `"true"` 또는 `VALUE`가 플래그가 나타날 때마다 반복됩니다.
`[arg(min=MIN)]` 및 `[arg(max=MAX)]` 속성 1.56.0은 옵션이나 플래그가 받을 수 있는 값의 개수를 제한하는 데 사용할 수 있습니다.
`[arg(help)]`의 값은 리스트일 수 있으며, 이 경우 도움말 문자열은 리스트의 요소들이 공백으로 결합된 형태가 됩니다. 리스트가 비어 있으면 인수에 도움말 문자열이 없습니다.
`[arg(pattern)]`의 값은 리스트일 수 있으며, 이 경우 리스트의 어떤 패턴과든 일치하면 인수가 허용됩니다. 값이 빈 리스트인 경우 어떤 인수든 허용됩니다. 예를 들어, `[arg('foo', pattern=['--help', '--version'])]`의 경우 `foo`는 `--help` 또는 `--version`이 될 수 있습니다.
`[env(variable, value)]`에서 `value`가 `[]`인 경우 `variable`은 설정되지 않습니다. 그렇지 않으면 `value`가 공백으로 결합된 값으로 설정됩니다.
#### Functions
- `absolute\_path()` - 각 리스트 요소에 개별적으로 적용됩니다.
- `append()` - 각 리스트 요소에 개별적으로 적용되며 공백을 기준으로 요소를 분할하지 않습니다.
- `assert(condition, message)` - `condition`을 평가합니다.
- `bool(value)` - `value`를 표준 불리언 값으로 변환합니다. `value`가 `""`, `"0"`, `"false"`, 또는 `[]`인 경우 `[]`를 반환하고, `value`가 `"1"` 또는 `"true"`인 경우 `"true"`를 반환합니다. 그 외의 모든 값은 오류입니다. 인수나 환경 변수로 전달된 불리언을 파싱하는 데 사용할 수 있습니다.
- `env(keys, default)` - `keys`에 명명된 환경 변수를 순서대로 확인하고 설정된 첫 번째 변수의 값을 반환합니다. 설정된 것이 없으면 `default`를 반환하고, `default`가 생략된 경우 오류를 반환합니다.
- `is\_dependency()` - 표준 불리언을 반환합니다.
- `join\_list(value, separator)` - `value`를 단일 문자열로 결합합니다. 요소들은 `separator`로 결합되며, `separator`가 생략된 경우 단일 공백으로 결합됩니다.
- `len(value)` - `value`의 요소 개수를 반환합니다.
- `path\_exists()` - 표준 불리언을 반환합니다.
- `prepend()` - 각 리스트 요소에 개별적으로 적용되며 공백을 기준으로 요소를 분할하지 않습니다.
- `quote()` - 각 리스트 요소에 개별적으로 적용됩니다.
- `semver\_matches()` - 표준 불리언을 반환합니다.
- `show(value)` - `value`를 리터럴 표현이 포함된 문자열로 변환합니다. 빈 리스트 및 다중 요소 리스트(예: `"[]"` 및 `["foo", "bar"]`)에는 대괄호가 사용되지만, 단일 요소 리스트(예: `"foo"`)에는 사용되지 않습니다.
- `split(string, separator)` - `separator`가 나타날 때마다 `string`을 분할하여 리스트로 만듭니다. `separator`가 생략되면 `string`은 공백을 기준으로 분할되며, 앞뒤 공백은 잘립니다.
- `which()` - 다음을 반환합니다: 빈 리스트

실행 파일을 찾을 수 없는 경우입니다.
#### 예제
각 리스트 요소는 개별적으로 `quote()` 처리됩니다:
```just
set unstable
set lists
@foo \*args:
printf '%s\n' {{ quote(args) }}
```
```console
$ just foo bar 'baz bob'
bar
baz bob
```
`quote(args)`의 반환 값은 `set lists`를 사용하지 않았을 때의 `'bar baz bob'` 대신 `'bar' 'baz bob'`이 됩니다.
가변 위치 인수:
```just
set unstable
set lists
set positional-arguments
foo \*args: (bar args 'bob') (baz args)
@bar first second:
echo first=$1
echo second=$2
@baz \*args:
echo '$1='$1
echo '$2='$2
```
```console
$ just foo one two
first=one two
second=bob
$1=one
$2=two
```
매핑된 의존성은 별표가 붙은 인수의 각 요소마다 한 번씩 호출되며, `[parallel]`을 사용하여 병렬로 실행할 수 있습니다:
```just
set unstable
set lists
[parallel]
build target \*platform: \*(compile target \*platform)
@compile target platform:
echo compiling {{ target }} for {{ platform }}…
```
```console
$ just build x86 foo bar
compiling foo for x86…
compiling bar for x86…
```
옵션의 기본값으로는 표준 거짓 값인 `[]`를 사용하는 것이 권장됩니다:
```just
set unstable
set lists
[arg('bar', long)]
foo bar=[]:
```
### 조건식
`if`/`else` 표현식은 두 표현식이 동일한 값으로 평가되는지에 따라 서로 다른 분기를 평가합니다:
```just
foo := if "2" == "2" { "Good!" } else { "1984" }
bar:
@echo "{{foo}}"
```
```console
$ just bar
Good!
```
부등호 테스트도 가능합니다:
```just
foo := if "hello" != "goodbye" { "xyz" } else { "abc" }
bar:
@echo {{foo}}
```
```console
$ just bar
xyz
```
그리고 정규 표현식과 일치하는지 확인할 수 있습니다:
```just
foo := if "hello" =~ 'hel+o' { "match" } else { "mismatch" }
bar:
@echo {{foo}}
```
```console
$ just bar
match
```
정규 표현식은 [regex crate](https://github.com/rust-lang/regex)에서 제공하며, 구문은 [docs.rs](https://docs.rs/regex/1.5.4/regex/#syntax)에 문서화되어 있습니다. 정규 표현식은 백슬래시 이스케이프 시퀀스를 흔히 사용하므로, 슬래시를 정규 표현식 파서에 그대로 전달하는 싱글 코쿼테이션(single-quoted) 문자열 리터럴 사용을 고려해 보세요.
조건식은 단락 평가(short-circuit)를 수행하므로, 분기 중 하나만 평가합니다. 이를 통해 백틱 표현식이 실행되지 않아야 할 때 실행되지 않도록 보장할 수 있습니다.
```just
foo := if env\_var("RELEASE") == "true" { `get-something-from-release-database` } else { "dummy-value" }
```
조건문은 레시피 내부에서도 사용할 수 있습니다:
```just
bar foo:
echo {{ if foo == "bar" { "hello" } else { "goodbye" } }}
```
여러 개의 조건을 체인처럼 연결할 수 있습니다:
```just
foo := if "hello" == "goodbye" {
"xyz"
} else if "a" == "a" {
"abc"
} else {
"123"
}
bar:
@echo {{foo}}
```
```console
$ just bar
abc
```
### 백틱을 사용한 명령어 평가
백틱을 사용하여 명령어의 결과를 저장할 수 있습니다:
```just
localhost := `dumpinterfaces | cut -d: -f2 | sed 's/\/.\*//' | sed 's/ //g'`
serve:
./serve {{localhost}} 8080
```
세 개의 백틱으로 구분된 들여쓰기된 백틱은 들여쓰기된 문자열과 동일한 방식으로 들여쓰기가 제거됩니다:
````just
# 이 백틱은 `echo foo\necho bar\n` 명령어를 평가하여 `foo\nbar\n` 값을 생성합니다.
stuff := ```
echo foo
echo bar
```
````
들여쓰기 제거에 대한 자세한 내용은 [Strings](#strings) 섹션을 참조하세요.
백틱은 `#!`로 시작할 수 없습니다. 이 구문은 향후 업그레이드를 위해 예약되어 있습니다.
[`shell(…)` 함수](#external-commands)는 변수의 내용을 명령어로 실행하고 명령어에 인수를 전달하는 기능을 포함하여 외부 명령어를 호출하는 보다 일반적인 메커니즘을 제공합니다.
### 오류로 실행 중지
`error` 함수를 사용하여 실행을 중단할 수 있습니다. 예를 들어:
```just
foo := if "hello" == "goodbye" {
"xyz"
} else if "a" == "b" {
"abc"
} else {
error("123")
}
```
이를 실행하면 다음과 같은 오류가 발생합니다:
```
error: Call to function `error` failed: 123
|
16 | error("123")
```
### 내장 함수
`just`는 레시피 본문 `{{…}}` 치환, 대입, 기본 매개변수 v를 포함하여 표현식에서 사용할 수 있는 다양한 내장 함수를 제공합니다.

값.
`\_directory`로 끝나는 모든 함수는 `\_dir`로 축약할 수 있습니다. 따라서
`home\_directory()`는 `home\_dir()`로 작성할 수도 있습니다. 또한,
`invocation\_directory\_native()`는
`invocation\_dir\_native()`로 축약할 수 있습니다.
### 사용자 정의 함수
새로운 함수는 1.49.0부터 정의할 수 있습니다:
```just
set unstable
hello(name) := f"Hello, {{ name }}!"
foo:
echo '{{ hello("World") }}'
```
사용자 정의 함수는 현재 불안정(unstable) 상태입니다.
함수는 동일 모듈 내의 할당을 참조할 수 있습니다:
```just
set unstable
base := "foo"
join(extension) := base + "." + extension
create:
touch {{ join("c") }}
touch {{ join("html") }}
touch {{ join("txt") }}
```
실행
---------
### 기호 (Sigils)
쉘 레시피의 명령어에는 `-`, `@`, `?` 기호의 조합을 접두사로 붙일 수 있습니다.
`@` 기호는 명령어 에코(echoing)를 토글합니다:
```just
foo:
@echo "This line won't be echoed!"
echo "This line will be echoed!"
@bar:
@echo "This line will be echoed!"
echo "This line won't be echoed!"
```
`-` 기호는 명령어가 0이 아닌 종료 상태를 반환하더라도 레시피 실행을 계속하도록 만듭니다:
```just
# execution will continue, even if bar doesn't exist
foo:
-rmdir bar
mkdir bar
echo 'so much good stuff' > bar/stuff.txt
```
`?` 기호1.47.0는 명령어가 `1`번 상태 코드로 종료될 경우 현재 레시피의 실행을 중단하지만, 다른 레시피의 실행은 계속되도록 만듭니다. 종료 상태 `0`은 현재 레시피가 평소처럼 실행을 계속하도록 만듭니다. 다른 모든 종료 코드는 예약되어 있으며 향후 `just` 버전에서 의미가 부여될 수 있으므로 사용하지 않아야 합니다.
`guards` 설정이 해제되어 있거나 거짓(false)인 경우, `?` 기호는 무시되며 대신 명령어의 일부로 취급됩니다.
```just
set guards
@foo: bar
echo FOO
@bar:
?[[ -f baz ]]
echo BAR
```
```console
$ just foo
FOO
$ touch baz
$ just foo
BAR
FOO
```
### 조용한 레시피 (Quiet Recipes)
레시피 이름 앞에 `@`를 붙이면 각 줄 앞의 `@` 의미를 반전시킬 수 있습니다:
```just
@quiet:
echo hello
echo goodbye
@# all done!
```
이제 `@`로 시작하는 줄만 에코됩니다:
```console
$ just quiet
hello
goodbye
# all done!
```
justfile의 모든 레시피는 `set quiet`를 사용하여 조용하게 만들 수 있습니다:
```just
set quiet
foo:
echo "This is quiet"
@foo2:
echo "This is also quiet"
```
`[no-quiet]` 속성은 이 설정을 재정의합니다:
```just
set quiet
foo:
echo "This is quiet"
[no-quiet]
foo2:
echo "This is not quiet"
```
Shebang 레시피는 기본적으로 조용합니다:
```just
foo:
#!/usr/bin/env bash
echo 'Foo!'
```
```console
$ just foo
Foo!
```
Shebang 레시피 이름에 `@`를 추가하면 `just`가 실행하기 전에 레시피를 출력하도록 만듭니다:
```just
@bar:
#!/usr/bin/env bash
echo 'Bar!'
```
```console
$ just bar
#!/usr/bin/env bash
echo 'Bar!'
Bar!
```
`just`는 일반적으로 레시피 줄이 실패할 때 에러 메시지를 출력합니다. 이 에러 메시지는 개별 레시피에 `[no-exit-message]`1.7.0 속성을 사용하거나, 모듈 전체에 `set no-exit-message`1.39.0를 사용하여 숨길 수 있습니다. 이는 도구를 감싸는(wrapping) 레시피에서 특히 유용할 수 있습니다:
```just
git \*args:
@git {{args}}
```
```console
$ just git status
fatal: not a git repository (or any of the parent directories): .git
error: Recipe `git` failed on line 2 with exit code 128
```
도구가 0이 아닌 코드로 종료될 때 종료 에러 메시지를 숨기려면 속성을 추가하세요:
```just
[no-exit-message]
git \*args:
@git {{args}}
```
```console
$ just git status
fatal: not a git repository (or any of the parent directories): .git
```
### Shebang 레시피
`#!`로 시작하는 레시피를 Shebang 레시피라고 하며, 레시피 본문을 파일에 저장하고 실행하는 방식으로 동작합니다. 이를 통해 다양한 언어로 레시피를 작성할 수 있습니다:
```just
polyglot: python js perl sh ruby nu
python:
#!/usr/bin/env python3
print('Hello from python!')
js:
#!/usr/bin/env node
console.log('Greetings from JavaScript!')
perl:
#!/usr/bin/env perl
print "Larry Wall says Hi!\n";
sh:
#!/usr/bin/env sh
hello='Yo'
echo "$hello from a shell script!"
nu:
#!/usr/bin/env nu
let hello = 'Hola'
echo $"($hello) from a nushell script!"
ruby:
#!/usr

/bin/env ruby
puts "Hello from ruby!"
```
```console
$ just polyglot
Hello from python!
Greetings from JavaScript!
Larry Wall says Hi!
Yo from a shell script!
Hola from a nushell script!
Hello from ruby!
```
Linux와 macOS를 포함한 유닉스 계열 운영체제에서, 셰뱅(shebang) 레시피는 임시 디렉터리에 레시피 본문을 파일로 저장하고, 해당 파일을 실행 가능하도록 설정한 뒤 실행하는 방식으로 동작합니다. 그러면 OS가 셰뱅 라인을 커맨드라인으로 파싱하고 파일 경로를 포함하여 호출합니다. 예를 들어 레시피가 `#!/usr/bin/env bash`로 시작한다면, OS가 실행하는 최종 명령어는 `/usr/bin/env bash /tmp/PATH\_TO\_SAVED\_RECIPE\_BODY`와 같은 형태가 됩니다.
셰뱅 라인 분할은 운영체제에 따라 다릅니다. 인자가 포함된 명령어를 전달할 때는 `-S` 플래그를 사용하여 `env`에 인자를 명시적으로 분할하도록 지시해야 할 수 있습니다:
```just
run:
#!/usr/bin/env -S bash -x
ls
```
Windows는 셰뱅 라인을 지원하지 않습니다. Windows에서 `just`는 셰뱅 라인을 명령어와 인자로 분할하고, 레시피 본문을 파일에 저장한 뒤, 저장된 레시피 본문의 경로를 최종 인자로 추가하여 분할된 명령어와 인자를 호출합니다. 예를 들어 Windows에서 레시피가 `#! py`로 시작한다면, OS가 실행하는 최종 명령어는 `py C:\Temp\PATH\_TO\_SAVED\_RECIPE\_BODY`와 같은 형태가 됩니다.
### 스크립트 레시피
`[script(COMMAND)]`1.32.0 속성이 지정된 레시피는 `COMMAND`에 의해 해석되는 스크립트로 실행됩니다. 이를 통해 Windows에서의 `cygpath` 사용, `/usr/bin/env` 사용의 필요성, 유닉스 OS 간 셰뱅 라인 분할의 일관성 부재, 그리고 파일 실행을 위한 임시 디렉터리 필요성과 같은 셰뱅 레시피의 일부 문제들을 피할 수 있습니다.
비어 있는 `[script]` 속성이 있는 레시피는 `set script-interpreter := […]`1.33.0의 값으로 실행되며, 기본값은 `set shell`의 값이 *아니라* `sh -eu`입니다.
레시피 본문이 평가되어 임시 디렉터리의 디스크에 기록된 후, 해당 경로가 `COMMAND`의 인자로 전달되어 실행됩니다.
`[shell]` 속성1.52.0으로 오버라이드하지 않는 한, `set default-script := true`1.52.0을 사용하면 레시피는 기본적으로 쉘 레시피 대신 스크립트 레시피로 동작합니다.
### 스크립트 및 셰뱅 레시피 임시 파일
스크립트 레시피와 셰뱅 레시피 모두 실행을 위해 레시피 본문을 임시 파일에 기록합니다. 스크립트 레시피는 해당 파일을 명령어에 전달하여 실행하고, 셰뱅 레시피는 파일을 직접 실행합니다. 임시 파일이 포함된 파일 시스템이 `noexec`로 마운트되어 있거나 기타 이유로 실행 불가능한 경우 셰뱅 레시피 실행은 실패합니다.
`just`가 임시 파일을 쓰는 디렉터리는 우선순위가 높은 것부터 낮은 순서대로 다음과 같은 여러 가지 방법으로 설정할 수 있습니다:
- `--tempdir` 커맨드라인 옵션 또는 `JUST\_TEMPDIR` 환경 변수1.41.0를 통한 전역 설정.
- `tempdir` 설정을 통한 모듈별 설정.
- Linux에서 `XDG\_RUNTIME\_DIR` 환경 변수를 통한 전역 설정.
- [std::env::temp\_dir](https://doc.rust-lang.org/std/env/fn.temp\_dir.html)이 반환하는 디렉터리로 폴백.
### 더 안전한 Bash 셰뱅 레시피
`bash` 셰뱅 레시피를 작성하는 경우 `set -euxo pipefail` 추가를 고려하세요:
```just
foo:
#!/usr/bin/env bash
set -euxo pipefail
hello='Yo'
echo "$hello from Bash!"
```
반드시 필수적인 것은 아니지만, `set -euxo pipefail`은 `bash` 셰뱅 레시피가 일반적인 쉘 `just` 레시피처럼 동작하도록 만드는 몇 가지 유용한 기능을 활성화합니다:
- `set -e`는 명령어가 실패할 경우 `bash`를 종료시킵니다.
- `set -u`는 변수가 정의되지 않은 경우 `bash`를 종료시킵니다.
- `set -x`는 각 스크립트 라인이 실행되기 전에 출력되도록 합니다.
- `set -o pipefail`은 파이프라인 내의 명령어가 실패할 경우 `bash`를 종료시킵니다. 이는 `bash` 전용 기능이므로 일반 쉘 `just` 레시피에서는 활성화되지 않습니다.
이러한 설정들을 함께 사용하면 많은 쉘 스크립팅 함정을 피할 수 있습니다.
#### Windows에서의 셰뱅 레시피 실행
Windows에서 `/`가 포함된 셰뱅 인터프리터 경로는 [Cygwin](http://www.cygwin.com)과 함께 제공되는 유틸리티인 `cygpath`를 사용하여 유닉스 스타일 경로에서 Windows 스타일 경로로 변환됩니다.
예를 들어, 실행하려면

Windows에서 이 레시피를 실행합니다:
```just
echo:
#!/bin/sh
echo "Hello!"
```
인터프리터 경로 `/bin/sh`는 실행되기 전에 `cygpath`를 사용하여 Windows 스타일 경로로 변환됩니다.
인터프리터 경로에 `/`가 포함되어 있지 않으면 변환되지 않고 실행됩니다. 이는 `cygpath`를 사용할 수 없거나 Windows 스타일 경로를 인터프리터에 전달하려는 경우에 유용합니다.

### 들여쓰기
레시피 줄은 공백이나 탭으로 들여쓰기할 수 있지만, 둘을 혼용할 수는 없습니다. 레시피의 모든 줄은 동일한 유형의 들여쓰기를 사용해야 하지만, 동일한 `justfile` 내의 서로 다른 레시피는 서로 다른 들여쓰기를 사용할 수 있습니다.
각 레시피는 `recipe-name`에서 최소 한 단계 이상 들여쓰기해야 하며, 그 이후에는 추가로 들여쓰기할 수 있습니다.
다음은 공백(·로 표시)과 탭(→로 표시)으로 들여쓰기된 레시피가 포함된 justfile입니다.
```justfile
[windows]
set shell := ["pwsh", "-NoLogo", "-NoProfileLoadTime", "-Command"]
set ignore-comments
list-space directory:
··#!pwsh
··foreach ($item in $(Get-ChildItem {{directory}} )) {
····echo $item.Name
··}
··echo ""
# 들여쓰기 중첩은 개행 문자가 이스케이프된 경우에도 작동합니다.
list-tab directory:
→ @foreach ($item in $(Get-ChildItem {{directory}} )) { \
→ → echo $item.Name \
→ }
→ @echo ""
```
```pwsh
PS > just list-space ~
Desktop
Documents
Downloads
PS > just list-tab ~
Desktop
Documents
Downloads
```

### 여러 줄 구문
초기 셰뱅(shebang)이 없는 레시피는 줄 단위로 평가되고 실행되므로, 여러 줄 구문은 의도대로 작동하지 않을 수 있습니다.
예를 들어, 다음과 같은 `justfile`이 있다고 가정해 보겠습니다.
```justfile
conditional:
if true; then
echo 'True!'
fi
```
`conditional` 레시피의 두 번째 줄 앞에 있는 추가 선행 공백으로 인해 구문 오류가 발생합니다.
```console
$ just conditional
error: Recipe line has extra leading whitespace
|
3 | echo 'True!'
| ^^^^^^^^^^^^^^^^
```
이를 해결하려면 조건문을 한 줄로 작성하거나, 백슬래시로 개행 문자를 이스케이프하거나, 레시피에 셰뱅을 추가하면 됩니다. 참고할 수 있도록 여러 줄 구문의 몇 가지 예시가 제공됩니다.

#### `if` 문
```just
conditional:
if true; then echo 'True!'; fi
```
```just
conditional:
if true; then \
echo 'True!'; \
fi
```
```just
conditional:
#!/usr/bin/env sh
if true; then
echo 'True!'
fi
```

#### `for` 루프
```just
for:
for file in `ls .`; do echo $file; done
```
```just
for:
for file in `ls .`; do \
echo $file; \
done
```
```just
for:
#!/usr/bin/env sh
for file in `ls .`; do
echo $file
done
```

#### `while` 루프
```just
while:
while `server-is-dead`; do ping -c 1 server; done
```
```just
while:
while `server-is-dead`; do \
ping -c 1 server; \
done
```
```just
while:
#!/usr/bin/env sh
while `server-is-dead`; do
ping -c 1 server
done
```

#### 레시피 본문 외부에 작성
괄호로 묶인 표현식은 여러 줄에 걸쳐 작성할 수 있습니다.
```just
abc := ('a' +
'b'
+ 'c')
abc2 := (
'a' +
'b' +
'c'
)
foo param=('foo'
+ 'bar'
):
echo {{param}}
bar: (foo
'Foo'
)
echo 'Bar!'
```
백슬래시로 끝나는 줄은 마치 공백으로 연결된 것처럼 다음 줄로 계속 이어집니다1.15.0:
```just
a := 'foo' + \
'bar'
foo param1 \
param2='foo' \
\*varparam='': dep1 \
(dep2 'foo')
echo {{param1}} {{param2}} {{varparam}}
dep1: \
# 이 주석은 레시피 본문의 일부가 아닙니다.
echo 'dep1'
dep2 \
param:
echo 'Dependency with parameter {{param}}'
```
백슬래시를 사용한 줄 계속은 보간(interpolation) 내에서도 사용할 수 있습니다. 백슬래시 다음 줄은 들여쓰기되어야 합니다.
```just
recipe:
echo '{{ \
"This interpolation " + \
"has a lot of text." \
}}'
echo 'back to recipe body'
```

### 레시피에서 변수 설정하기
레시피 줄은 `just`가 아니라 셸에 의해 해석되므로, 레시피 중간에 `just` 변수를 설정하는 것은 불가능합니다.
```justfile
foo:
x := "hello" # 이건 작동하지 않습니다!
echo {{x}}
```
셸 변수를 사용하는 것은 가능하지만, 다른 문제가 있습니다. 모든 레시피 줄은 새로운 셸 인스턴스에 의해 실행되므로, 한 줄에서 설정한 변수는 다음 줄에서 유지되지 않습니다.
```just
foo:
x=hello && echo $x # 이건 작동합니다!
y=bye
echo $y # 이건 작동하지 않습니다. `y`가 정의되지 않음

여기서 정의합니다!
```
이 문제를 우회하는 가장 좋은 방법은 shebang 레시피를 사용하는 것입니다. Shebang 레시피 본문은 추출되어 스크립트로 실행되므로, 단일 shell 인스턴스가 전체 과정을 실행합니다:
```just
foo:
#!/usr/bin/env bash
set -euxo pipefail
x=hello
echo $x
```
### Shell 설정하기
`#!` shebang으로 시작하지 않는 레시피의 기본값인 shell 레시피를 위해 shell을 설정하는 방법에는 여러 가지가 있습니다. 우선순위는 높은 것부터 낮은 순으로 다음과 같습니다:
1. `--shell` 및 `--shell-arg` 명령어 라인 옵션. 이 옵션들 중 하나를 전달하면 `just`는 현재 justfile의 모든 설정을 무시합니다.
2. `set windows-shell := [...]` (더 이상 사용되지 않음)
3. `set windows-powershell` (더 이상 사용되지 않음)
4. `set shell := [...]`
Windows에서 다른 shell을 사용하려면 `set shell`과 함께 `[windows]` 및 `[unix]` 어트리뷰트를 사용하세요.
### Shell
`shell` 설정은 레시피 라인과 백틱을 호출하는 데 사용되는 명령어를 제어합니다. Shebang 레시피는 영향을 받지 않습니다. 기본 shell은 `sh -cu`입니다.
```just
# python3를 사용하여 레시피 라인과 백틱을 실행합니다
set shell := ["python3", "-c"]
# 평가 결과를 캡처하기 위해 print를 사용합니다
foos := `print("foo" \* 4)`
foo:
print("Snake snake snake snake.")
print("{{foos}}")
```
`just`는 실행할 명령어를 인수로 전달합니다. 많은 shell은 첫 번째 인수를 평가하도록 만들기 위해 종종 `-c`와 같은 추가 플래그가 필요합니다.
#### Windows Shell
`just`는 기본적으로 Windows에서 `sh`를 사용합니다. Windows에서 다른 shell을 사용하려면 `shell` 설정에 `[windows]` 어트리뷰트를 사용하세요:
```just
[windows]
set shell := ["powershell.exe", "-NoLogo", "-Command"]
hello:
Write-Host "Hello, world!"
```
모든 플랫폼에서 PowerShell을 사용하는 justfile을 보려면 [powershell.just](https://github.com/casey/just/blob/master/examples/powershell.just)를 참고하세요.
#### Python 3
```just
set shell := ["python3", "-c"]
```
#### Bash
```just
set shell := ["bash", "-uc"]
```
#### Z Shell
```just
set shell := ["zsh", "-uc"]
```
#### Fish
```just
set shell := ["fish", "-c"]
```
#### Nushell
```just
set shell := ["nu", "-c"]
```
기본 테이블 모드를 `light`로 변경하려면:
```just
set shell := ['nu', '-m', 'light', '-c']
```
\*[Nushell](https://github.com/nushell/nushell)은 Rust로 작성되었으며, \*\*Windows / macOS 및 Linux에 대한 크로스 플랫폼 지원을 제공합니다\*\*.\*
환경 변수
---------------------
### 환경 변수 가져오기 및 설정하기
#### `just` 변수 내보내기 (Export)
`export` 키워드로 시작하는 할당문은 환경 변수로 레시피에 내보내집니다:
```just
export RUST\_BACKTRACE := "1"
test:
# 크래시가 발생하면 스택 트레이스를 출력합니다
cargo test
```
`$`로 시작하는 매개변수는 환경 변수로 내보내집니다:
```just
test $RUST\_BACKTRACE="1":
# 크래시가 발생하면 스택 트레이스를 출력합니다
cargo test
```
또한 `[env(NAME, VALUE)]` 어트리뷰트를 사용하여 특정 레시피에 환경 변수를 내보낼 수 있습니다:
```just
[env("RUST\_BACKTRACE", "1")]
test:
# 크래시가 발생하면 스택 트레이스를 출력합니다
cargo test
```
내보낸 변수와 매개변수는 동일한 범위의 백틱으로 내보내지지 않습니다.
```just
export WORLD := "world"
# 이 백틱은 "WORLD: unbound variable" 오류와 함께 실패합니다
BAR := `echo hello $WORLD`
```
```just
# `just a foo` 실행은 "A: unbound variable" 오류와 함께 실패합니다
a $A $B=`echo $A`:
echo $A $B
```[export](#export)가 설정되면 모든 `just` 변수가 환경 변수로 내보내집니다.
#### 환경 변수 내보내기 해제하기
환경 변수는 `unexport` 키워드1.29.0를 사용하여 내보내기를 해제할 수 있습니다:
```just
unexport FOO
@foo:
echo $FOO
```
```
$ export FOO=bar
$ just foo
sh: FOO: unbound variable
```
#### 환경에서 환경 변수 가져오기
환경의 환경 변수는 레시피로 자동으로 전달됩니다.
```just
print\_home\_folder:
@echo "HOME is: '${HOME}'"
```
```console
$ just
HOME is: '/home/myuser'
```
#### 환경 변수에서 `just` 변수 설정하기
환경 변수는 `env()` 함수를 사용하여 `just` 변수로 전파할 수 있습니다.
[environment-varia](https://github.com/casey/just#environment-varia)를 참고하세요.

bles](#environment-variables).
### Dotenv 설정
`dotenv-load`, `dotenv-filename`, `dotenv-override`, `dotenv-path`,
또는 `dotenv-required` 중 하나라도 설정되어 있으면, `just`는 파일에서
환경 변수를 로드하려고 시도합니다.
`dotenv-path`가 설정된 경우, `just`는 지정된 경로에서 파일을 찾으며, 이
경로는 절대 경로이거나 작업 디렉토리 기준 상대 경로일 수 있습니다.
명령줄 옵션 `--dotenv-path` (단축 형태 `-E`)를 사용하면 런타임에
`dotenv-path`를 설정하거나 재정의할 수 있습니다.
`dotenv-filename`이 설정된 경우, `just`는 작업 디렉토리 및 그 상위
디렉토리들을 기준으로 해당 경로의 파일을 찾습니다.
명령줄 옵션 `--dotenv-filename` (단축 형태 `-F`)을 사용하면 런타임에
`dotenv-filename`을 설정하거나 재정의할 수 있습니다.
`dotenv-filename`이 설정되지 않았지만 `dotenv-load`나 `dotenv-required`가
설정된 경우, `just`는 작업 디렉토리 및 그 상위 디렉토리들을 기준으로
`.env`라는 이름의 파일을 찾습니다.
`dotenv-filename`과 `dotenv-path`는 비슷하지만, `dotenv-path`는 작업
디렉토리를 기준으로만 확인하는 반면, `dotenv-filename`은 작업 디렉토리와
각 상위 디렉토리를 기준으로 확인합니다.
`dotenv-required`가 설정된 경우가 아니라면, 환경 변수 파일을 찾지 못하더라도
에러가 발생하지 않습니다.
로드된 변수는 `just` 변수가 아니라 환경 변수이므로, 레시피와 백틱 내부에서는
`$VARIABLE\_NAME`을 사용하여 접근해야 합니다.
`dotenv-override`가 설정된 경우, 환경 파일의 변수가 기존 환경 변수를
재정의합니다.
`dotenv-command`가 설정된 경우, `just`는 설정된 `shell`로 이를 실행하고 그
표준 출력을 환경 파일로 로드합니다.
이는 시크릿 관리자나 볼트(vault)에서 시크릿을 가져오는 데 유용합니다:
```just
set dotenv-command := 'sops -d .enc.env'
```
명령줄 옵션 `--dotenv-command`를 사용하면 런타임에 `dotenv-command`를
설정하거나 재정의할 수 있으며, 여러 번 전달될 수 있습니다. 각 값은 명령어로
실행되며, 나중에 실행된 명령어의 변수가 이전 명령어의 변수보다 우선시됩니다.
예를 들어 `.env` 파일에 다음과 같이 포함되어 있는 경우:
```console
# a comment, will be ignored
DATABASE\_ADDRESS=localhost:6379
SERVER\_PORT=1337
```
그리고 `justfile`에 다음과 같이 포함되어 있는 경우:
```just
set dotenv-load
serve:
@echo "Starting server with database $DATABASE\_ADDRESS on port $SERVER\_PORT…"
./server --database $DATABASE\_ADDRESS --port $SERVER\_PORT
```
`just serve`는 다음을 출력합니다:
```console
$ just serve
Starting server with database localhost:6379 on port 1337…
./server --database $DATABASE\_ADDRESS --port $SERVER\_PORT
```
상위 모듈에서 로드된 환경 파일의 변수는 하위 모듈에 상속됩니다.
환경 파일은 하위 모듈1.49.0에서 로드되며 상위 모듈 환경 파일에 정의된 변수를
재정의할 수 있습니다.
### Export
`export` 설정은 모든 `just` 변수를 환경 변수로 내보내도록 합니다. 기본값은
`false`입니다.
```just
set export
a := "hello"
@foo b:
echo $a
echo $b
```
```console
$ just foo goodbye
hello
goodbye
```
### 레시피 간 환경 변수 공유
각 레시피의 각 줄은 새로운 셸(shell)에 의해 실행되므로, 레시피 간에 환경
변수를 공유하는 것은 불가능합니다.
#### Python 가상 환경 사용하기
[Python's venv](https://docs.python.org/3/library/venv.html)와 같은 일부
도구는 작동하기 위해 환경 변수 로드가 필요하므로, `just`와 함께 사용하기가
까다로울 수 있습니다. 우회 방법으로, 가상 환경 바이너리를 직접 실행할 수
있습니다:
```just
venv:
[ -d foo ] || python3 -m venv foo
run: venv
./foo/bin/python3 main.py
```
작업 디렉토리
-----------------
기본적으로 레시피는 `justfile`이 포함된 디렉토리를 작업 디렉토리로 설정하여
실행됩니다.
`[no-cd]` 어트리뷰트를 사용하면 `just`가 호출된 디렉토리를 작업 디렉토리로
설정하여 레시피를 실행할 수 있습니다.
```just
@foo:
pwd
[no-cd]
@bar:
pwd
```
```console
$ cd subdir
$ just foo
/
$ just bar
/subdir
```
이는 dotenv 파일 검색이나 백틱 및 `shell()` 호출의 작업 디렉토리에 영향을
미치지 않는다는 점에 유의하세요.
`set no-cd`1.51.0을 사용하여

현재 모듈의 모든 레시피는
기본적으로 동일한 동작을 따릅니다.
`set no-cd`와 `set working-directory`는 `[no-cd]` 및 `[working-directory]` 속성을 사용하여 레시피별로 재정의할 수 있습니다.
`set working-directory := '…'`를 사용하여 모든 레시피의 작업 디렉토리를 재정의할 수 있습니다:
```just
set working-directory := 'bar'
@foo:
pwd
```
```console
$ pwd
/home/bob
$ just foo
/home/bob/bar
```
`working-directory` 속성1.38.0을 사용하여 특정 레시피의 작업 디렉토리를 재정의할 수 있습니다:
```just
[working-directory: 'bar']
@foo:
pwd
```
```console
$ pwd
/home/bob
$ just foo
/home/bob/bar
```
`working-directory` 설정 또는 `working-directory` 속성에 전달하는 인자는 절대 경로이거나 상대 경로인 표현식1.51.0일 수 있습니다. 상대 경로인 경우 기본 작업 디렉토리를 기준으로 해석됩니다.
### 레시피에서 작업 디렉토리 변경하기
각 레시피 라인은 새로운 셸에 의해 실행되므로, 한 라인에서 작업 디렉토리를 변경해도 이후 라인에는 영향을 미치지 않습니다:
```just
foo:
pwd # 이 `pwd`는 동일한 디렉토리를 출력합니다…
cd bar
pwd # 이 `pwd`도 마찬가지입니다!
```
이를 우회하는 몇 가지 방법이 있습니다. 첫 번째는 실행하려는 명령어와 같은 라인에서 `cd`를 호출하는 것입니다:
```just
foo:
cd bar && pwd
```
다른 방법은 shebang 레시피를 사용하는 것입니다. Shebang 레시피 본문은 추출되어 스크립트로 실행되므로, 단일 셸 인스턴스가 전체를 실행하게 됩니다. 따라서 셸 스크립트와 마찬가지로 한 라인에서의 `cd`가 이후 라인에도 영향을 미칩니다:
```just
foo:
#!/usr/bin/env bash
set -euxo pipefail
cd bar
pwd
```
### 디렉토리 변경 비활성화하기
`just`는 기본적으로 `justfile`이 포함된 디렉토리를 현재 디렉토리로 설정하여 레시피를 실행합니다. 이는 `[no-cd]` 속성1.9.0을 사용하여 비활성화할 수 있습니다. 이를 통해 호출 디렉토리를 기준으로 하는 경로를 사용하거나 현재 디렉토리에서 작동하는 레시피를 만들 수 있습니다.
예를 들어, 이 `commit` 레시피는:
```just
[no-cd]
commit file:
git add {{file}}
git commit
```
`[no-cd]`가 `commit`을 실행할 때 `just`가 현재 디렉토리를 변경하는 것을 방지하기 때문에, 현재 디렉토리를 기준으로 하는 경로와 함께 사용할 수 있습니다.
이는 dotenv 파일 검색이나 백틱 및 `shell()` 호출의 작업 디렉토리에는 영향을 미치지 않습니다.
Organization
------------
### Imports
하나의 `justfile`은 `import` 문을 사용하여 다른 파일의 내용을 포함할 수 있습니다.
다음과 같은 `justfile`이 있고:
```justfile
import 'foo/bar.just'
a: b
@echo A
```
`foo/bar.just`에 다음과 같은 텍스트가 있는 경우:
```just
b:
@echo B
```
`foo/bar.just`가 `justfile`에 포함되며 레시피 `b`가 정의됩니다:
```console
$ just b
B
$ just a
B
A
```
`import` 경로는 절대 경로이거나 이를 포함하는 justfile의 위치를 기준으로 한 상대 경로일 수 있습니다. import 경로의 맨 앞에 있는 `~/`는 현재 사용자의 홈 디렉토리로 대체됩니다.
Justfile은 순서에 민감하지 않으므로, 포함된 파일은 `import` 문 뒤에 정의된 변수와 레시피를 참조할 수 있습니다.
가져온 파일 자체도 `import`를 포함할 수 있으며, 이는 재귀적으로 처리됩니다.
`allow-duplicate-recipes`와 `allow-duplicate-variables`를 사용하면 에러를 발생하는 대신 중복된 레시피와 변수가 서로를 재정의할 수 있습니다.
모듈 내에서는 나중에 정의된 것이 먼저 정의된 것을 재정의합니다:
```just
set allow-duplicate-recipes
foo:
foo:
echo 'yes'
```
`import`가 관여하면 상황이 불행히도 훨씬 복잡해지고 설명하기 어려워집니다.
더 상위 레벨의 정의가 항상 더 깊은 레벨의 정의보다 우선하므로, 최상위 레벨의 레시피는 import된 레시피를 재정의하고, import된 레시피는 그 레시피들을 다시 import하는 다른 import의 레시피를 재정의합니다.
두 개의 중복된 정의가 import되고 동일한 깊이에 있는 경우, 더 먼저 import된 것의 정의가 나중에 import된 것의 정의를 재정의합니다.
이는 `just`가 import를 처리할 때 스택을 사용하고, 소스 순서대로 import를 스택에 푸시한 다음 항상 스택의 맨 위를 먼저 처리하기 때문입니다. 따라서 더 일찍 작성된 import가 실제로는 컴파일러에 의해 나중에 처리됩니다.

이것은 확실히 버그이지만, `just`는 매우 강력한 하위 호환성 보장을 제공하고 누구의 `justfile`도 깨지지 않도록 엄청난 노력을 기울이기 때문에, 실제로 이를 수정할 수 있는지에 대한 논의는 이슈 [#2540](https://github.com/casey/just/issues/2540)을 참고하세요.
`import` 키워드 뒤에 `?`를 붙이면 임포트를 선택사항으로 만들 수 있습니다:
```just
import? 'foo/bar.just'
```
동일한 소스 파일을 여러 번 임포트하는 것은 오류가 아닙니다1.37.0.
이를 통해 공유 레시피를 포함하는 세 번째 `justfile`(예: `baz.just`)을 두 `justfile`(예: `foo.just`와 `bar.just`)이 각각 임포트할 때, `baz.just`의 중복 임포트로 인한 오류 없이 여러 justfile을 임포트할 수 있습니다:
```justfile
# justfile
import 'foo.just'
import 'bar.just'
```
```justfile
# foo.just
import 'baz.just'
foo: baz
```
```justfile
# bar.just
import 'baz.just'
bar: baz
```
```just
# baz
baz:
```
### 모듈
`justfile`은 `mod` 문을 사용하여 모듈을 선언할 수 있습니다1.19.0.
`mod` 문은 `just`1.31.0에서 안정화되었습니다.
다음과 같은 `justfile`이 있는 경우:
```justfile
mod bar
a:
@echo A
```
그리고 `bar.just`에 다음과 같은 텍스트가 있는 경우:
```just
b:
@echo B
```
`bar.just`는 서브모듈로 `justfile`에 포함됩니다. 하나의 서브모듈에 정의된 레시피, 별칭, 변수는 다른 서브모듈에서 사용할 수 없으며, 각 모듈은 고유한 설정을 사용합니다.
서브모듈의 레시피는 하위 명령어로 호출할 수 있습니다:
```console
$ just bar b
B
```
또는 경로 구문을 사용할 수 있습니다:
```console
$ just bar::b
B
```
모듈 이름이 `foo`인 경우, `just`는 `foo.just`, `foo/mod.just`, `foo/justfile`, 그리고 `foo/.justfile`에서 모듈 파일을 검색합니다. 후자의 두 경우, 모듈 파일의 대소문자는 상관없습니다.
모듈 문은 다음과 같은 형식일 수 있습니다:
```justfile
mod foo 'PATH'
```
이렇게 하면 일반적인 위치 대신 `PATH`에서 모듈의 소스 파일을 불러옵니다. `PATH`의 앞부분에 있는 `~/`는 현재 사용자의 홈 디렉터리로 대체됩니다. `PATH`는 모듈 소스 파일 자체를 가리킬 수도 있고, `mod.just`, `justfile`, `.justfile` 이름의 모듈 소스 파일을 포함하는 디렉터리를 가리킬 수도 있습니다. 후자의 두 경우, 모듈 파일의 대소문자는 상관없습니다.
환경 파일은 각 모듈에 대해 로드되며, 해당 모듈의 관련 설정을 따릅니다. 상위 모듈의 환경 변수는 하위 모듈에서 볼 수 있습니다.
`[no-cd]` 속성이 없는 서브모듈의 레시피는 서브모듈 소스 파일이 포함된 디렉터리로 작업 디렉터리가 설정된 채로 실행됩니다.
`justfile()`과 `justfile\_directory()`는 서브모듈 레시피에서 호출될 때조차 항상 루트 `justfile`의 경로와 이를 포함하는 디렉터리를 반환합니다.
`mod` 키워드 뒤에 `?`를 붙이면 모듈을 선택사항으로 만들 수 있습니다:
```just
mod? foo
```
선택적 모듈의 누락된 소스 파일은 오류를 발생시키지 않습니다. 레시피나 별칭이 누락된 선택적 모듈에 직접 또는 간접적으로 의존하는 경우, 해당 레시피나 별칭은 비활성화됩니다. 비활성화된 레시피나 별칭을 호출하려고 하면 오류가 발생하지만, 비활성화되지 않은 다른 레시피들은 정상적으로 실행할 수 있습니다.1.52.0
소스 파일이 없는 선택적 모듈들은 충돌하지 않으므로, 소스 파일이 최대 하나만 존재하는 한 동일한 이름을 가진 여러 `mod` 문을 가질 수 있습니다:
```just
mod? foo 'bar.just'
mod? foo 'baz.just'
```
모듈에 문서 주석을 부여할 수 있으며, 이는 `--list` 출력에 나타납니다1.30.0:
```justfile
# foo는 멋진 모듈입니다!
mod foo
```
```console
$ just --list
Available recipes:
foo ... # foo는 멋진 모듈입니다!
```
모듈에는 아직 다른 모듈의 변수를 참조하는 기능 등 많은 기능이 누락되어 있습니다. 자세한 내용은 [모듈 개선 추적 이슈](https://github.com/casey/just/issues/2252)를 참조하세요.
### 다른 디렉터리의 `justfile` 호출하기
`just`에 전달된 첫 번째 인자에 `/`가 포함된 경우, 다음 과정이 발생합니다:
1. 인자가 마지막 `/`를 기준으로 분할됩니다.
2. 마지막 `/` 이전의 부분은 디렉터리로 취급됩니다. `just`는 현재 디렉터리 대신 그곳에서 `justfile` 검색을 시작합니다.
3. 마지막 슬래시 이후의 부분은 다음과 같이 취급됩니다.

일반 인자이거나, 비어 있는 경우
무시됩니다.
조금 이상하게 느껴질 수 있지만, 하위 디렉터리에 있는 `justfile`의 명령어를
실행하고 싶을 때 유용합니다.
예를 들어, `foo`라는 하위 디렉터리를 포함하는 디렉터리에 있고, 이 `foo` 디렉터리가 기본 레시피이기도 한 `build` 레시피가 포함된 `justfile`을 가지고 있다면, 다음 명령어들은 모두 동일합니다:
```console
$ (cd foo && just build)
$ just foo/build
$ just foo/
```
첫 번째 레시피 이후의 추가 레시피들은 동일한 `justfile`에서 탐색됩니다.
예를 들어, 다음 두 명령어는 모두 동일합니다:
```console
$ just foo/a b
$ (cd foo && just a b)
```
그리고 두 명령어 모두 `foo/justfile`의 `a`와 `b` 레시피를 실행합니다.
### 상위 `justfile`로의 폴백 (Fallback)
`justfile`에서 레시피를 찾을 수 없고 `fallback` 설정이 켜져 있는 경우, `just`는 루트 디렉터리에 도달할 때까지 상위 디렉터리로 올라가며 `justfile`을 찾습니다. `just`는 `fallback` 설정이 `false`이거나 설정되지 않은 `justfile`에 도달하면 탐색을 멈춥니다.
예를 들어, 현재 디렉터리에 다음과 같은 `justfile`이 있다고 가정해 보겠습니다:
```just
set fallback
foo:
echo foo
```
그리고 상위 디렉터리에 다음과 같은 `justfile`이 있습니다:
```just
bar:
echo bar
```
```console
$ just bar
Trying ../justfile
echo bar
bar
```
### 원격 Justfiles
소스 파일을 중복해서 작성할 필요 없이 여러 `justfile`에 `mod`나 `import` 소스 파일을 포함하고 싶다면, 선택적 `mod` 또는 `import`를 모듈 소스를 가져오는 레시피와 함께 사용할 수 있습니다:
```just
import? 'foo.just'
fetch:
curl https://raw.githubusercontent.com/casey/just/master/justfile > foo.just
```
위의 `justfile`이 주어졌을 때, `just fetch`를 실행한 후에는 `foo.just`의 레시피들을 사용할 수 있게 됩니다.
### 전역 및 사용자 `justfile`
일부 레시피를 어디서나 사용할 수 있게 만들고 싶다면 몇 가지 방법이 있습니다.
#### 전역 Justfile
`just --global-justfile` 또는 줄여서 `just -g`는 justfile을 찾기 위해 다음 경로들을 순서대로 검색합니다:
- `$XDG\_CONFIG\_HOME/just/justfile`
- `$HOME/.config/just/justfile`
- `$HOME/justfile`
- `$HOME/.justfile`
여러 프로젝트에서 공통으로 사용되는 레시피를 전역 justfile에 넣으면 어떤 디렉터리에서든 쉽게 호출할 수 있습니다.
#### 사용자 justfile 팁
다음과 같은 작업 흐름을 채택할 수도 있습니다. 이 팁들은 `~/.user.justfile`에 `justfile`을 생성했다고 가정하지만, 이 `justfile`은 시스템상 원하는 편한 경로에 두어도 됩니다.
##### 레시피 별칭 (Aliases)
`~/.user.justfile`에 있는 레시피들을 이름으로 호출하고 싶고, 모든 레시피에 대해 별칭을 만드는 것이 번거롭지 않다면, 셸의 초기화 스크립트에 다음 내용을 추가하세요:
```console
for recipe in `just --justfile ~/.user.justfile --summary`; do
alias $recipe="just --justfile ~/.user.justfile --working-directory . $recipe"
done
```
이제 `~/.user.justfile`에 `foo`라는 레시피가 있다면, 명령줄에서 그냥 `foo`를 입력하여 실행할 수 있습니다.
이런 식으로 레시피 별칭을 만들 수 있다는 것을 깨닫는 데 너무 오래 걸렸습니다. 저의 이 늑장 부림에도 불구하고, `justfile` 기술의 이러한 엄청난 진보를 여러분께 소개하게 되어 매우 기쁩니다.
##### 전달 별칭 (Forwarding Alias)
모든 레시피에 대해 별칭을 만들고 싶지 않다면, 단 하나의 별칭만 만들 수 있습니다:
```console
alias .j='just --justfile ~/.user.justfile --working-directory .'
```
이제 `~/.user.justfile`에 `foo`라는 레시피가 있다면, 명령줄에서 `.j foo`를 입력하여 실행할 수 있습니다.
실제로 이 기능을 사용하는 사람은 아무도 없겠지만, 기능 자체는 존재합니다.
¯\\\\_(ツ)\\_/¯
##### 사용자 지정
위의 별칭을 추가 옵션으로 사용자 지정할 수 있습니다. 예를 들어, `justfile`의 레시피들이 현재 디렉터리 대신 홈 디렉터리에서 실행되도록 하고 싶다면:
```console
alias .j='just --justfile ~/.user.justfile --working-directory ~'
```
### Markdown `justfile`
`--justfile`의 인자가 `.md`로 끝나면, `just`는 들여쓰기 되지 않은 `just` 펜스 코드 블록의 내용을 추출하여 임시 디렉터리의 `justfile`에 씁니다1.53.0:
````markdown
# Project
프로젝트 빌드:
```just
build:
echo Building…
```
````
```console
$ just --justfile

README.md build
echo Building…
Building…
```
### 스크립트 활용
`justfile` 상단에 셰뱅(shebang) 줄을 추가하고 실행 가능하게 만들면,
`just`를 스크립트 인터프리터로 사용할 수 있습니다:
```console
$ cat > script <1.52.0:
```just
set default-list := true
```
이 설정은 모ジュール별로 적용되므로, `default-list`가 활성화된 모듈 경로를 호출하면 해당 모듈의 레시피 목록이 표시됩니다.
또한 환경 변수 `JUST\_DEFAULT\_LIST=true`를 설정하거나 `--default-list`1.52.0를 전달하여 이 동작을 기본값으로 지정할 수도 있습니다.
머리글 텍스트는 `--list-heading`으로 사용자 정의할 수 있습니다:
```console
$ just --list --list-heading $'Cool stuff…\n'
Cool stuff…
test
build
```
그리고 들여쓰기는 `--list-prefix`로 사용자 정의할 수 있습니다:
```console
$ just --list --list-prefix ····
Available recipes:
····test
····build
```
`--list-heading`에 전달하는 인자는 머리글과 그 뒤의 줄바꿈을 모두 대체하므로, 비어 있지 않은 경우 줄바꿈을 포함해야 합니다. 빈 문자열을 전달하여 머리글 줄을 완전히 숨길 수 있도록 이렇게 동작합니다:
```console
$ just --list --list-heading ''
test
build
```
### 여러 레시피 호출하기
명령줄에서 한 번에 여러 레시피를 호출할 수 있습니다:
```just
build:
make web
serve:
python3 -m http.server -d out 8000
```
```console
$ just build serve
make web
python3 -m http.server -d out 8000
```
매개변수가 있는 레시피는 다른 레시피의 이름과 일치하더라도 인자를 삼켜버리므로 주의해야 합니다:
```just
build project:
make {{project}}
serve:
python3 -m http.server -d out 8000
```
```console
$ just build serve
make: \*\*\* No rule to make target `serve'. Stop.
```
`--one` 플래그를 사용하면 명령줄 호출을 단일 레시피로 제한할 수 있습니다:
```console
$ just --one build serve
error: Expected 1 command-line recipe invocation but found 2.
```
### 명령줄에서 변수 설정하기
명령줄에서 변수를 재정의할 수 있습니다.
```just
os := "linux"
test: build
./test --test {{os}}
build:
./build {{os}}
```
```console
$ just
./build linux
./test --test linux
```
레시피 앞에 `NAME=VALUE` 형식의 인자를 원하는 만큼 전달할 수 있습니다:
```console
$ just os=plan9
./build plan9
./test --test plan9
```
또는 `--set` 플래그를 사용할 수 있습니다:
```console
$ just --set os bsd
./build bsd
./test --test bsd
```
하위 모듈의 변수는 `::`로 구분된 변수 경로를 사용하여 재정의할 수 있습니다. `foo`라는 하위 모듈에 있는 `bar`라는 변수는 `foo::bar=VALUE` 또는 `--set foo::bar VALUE`로 재정의할 수 있습니다.
### 명령줄 옵션
`just`는 레시피와 변수의 목록 표시, 덤프, 디버깅을 위한 유용한 명령줄 옵션을 지원합니다:
```console
$ just --list
Available recipes:
js
perl
polyglot
python
ruby
$ just --show perl
perl:
#!/usr/bin/env perl
print "Larry Wall says Hi!\n";
$ just --show polyglot
polyglot: python js perl sh ruby
```
#### 환경 변수로 명령줄 옵션 설정하기
일부 명령줄 옵션은 환경 변수로 설정할 수 있습니다.
예를 들어, 불안정(unstable) 기능은 `--unstable` 플래그로 활성화할 수 있습니다:
```console
$ just --unstable
```
또는 `JUST\_UNSTABLE` 환경 변수를 설정하여 활성화할 수 있습니다:
```console
$ export JUST\_UNSTABLE=1
$ just
```
환경 변수는 하위 프로세스에 상속되므로, 환경 변수로 설정된 명령줄 옵션은 `just`의 재귀적 호출 시 상속되지만, 인자로 설정된 명령줄 옵션은 상속되지 않습니다.
어떤 옵션을 환경 변수로 설정할 수 있는지에 대해서는 `just --help`를 참고하세요.
### 대화형 선택기로 실행할 레시피 선택하기
`--choose` 서브커맨드를 사용하면 `just`가 실행할 레시피를 선택하는 선택기(chooser)를 호출합니다. 선택기는 표준 입력에서 레시피 이름이 포함된 줄을 읽고, 그 중 하나 이상의 이름을 공백으로 구분하여 표준 출력으로 출력해야 합니다.
현재 `--choose`를 사용하여 인자가 필요한 레시피를 실행할 방법이 없으므로, 이러한 레시피는 선택기에 전달되지 않습니다. 비공개(private) 레시피와 별칭(alias)도 건너뜁니다.
선택기는 다음을 통해 재정의할 수 있습니다.

--chooser` 플래그. 만약 `--chooser`가 지정되지 않으면, `just`는 먼저 `$JUST\_CHOOSER`가 설정되어 있는지 확인합니다. 설정되어 있지 않다면, 널리 사용되는 퍼지 파인더(fuzzy finder)인 `fzf`를 기본 선택 도구(chooser)로 사용합니다.
선택 도구에 인수를 포함할 수 있습니다. 예: `fzf --exact`.
선택 도구는 레시피 줄과 같은 방식으로 실행됩니다. 예를 들어 선택 도구가 `fzf`인 경우, `sh -cu 'fzf'`로 실행되며, 셸이나 셸 인수가 오버라이드된 경우 선택 도구 실행 시 해당 오버라이드가 반영됩니다.
`just`가 기본적으로 선택 도구를 사용하여 레시피를 선택하도록 하려면, 다음과 같이 기본 레시피로 사용할 수 있습니다:
```just
default:
@just --choose
```
### 레시피 실행 확인 요청
`just`는 일반적으로 오류가 없는 한 모든 레시피를 실행합니다. `[confirm]`
어트리뷰트1.17.0를 사용하면 레시피가 실행되기 전에 터미널에서 확인을 거치도록 요구할 수 있습니다. 이는 `just`에 `--yes`를 전달하여 오버라이드할 수 있으며, 이 경우 해당 어트리뷰트가 표시된 모든 레시피가 자동으로 확인됩니다.
확인이 필요한 레시피에 의존하는 레시피는, 의존하는 레시피가 확인되지 않은 경우 실행되지 않으며, 확인이 필요한 레시피 뒤에 전달된 레시피들도 마찬가지로 실행되지 않습니다.
```just
[confirm]
delete-all:
rm -rf \*
```
#### 사용자 정의 확인 프롬프트
기본 확인 프롬프트는 `[confirm(PROMPT)]`1.23.0를 사용하여 오버라이드할 수 있습니다:
```just
[confirm("Are you sure you want to delete everything?")]
delete-everything:
rm -rf \*
```
확인 프롬프트는 할당이나 레시피 인수를 참조할 수 있는 표현식1.49.0일 수도 있습니다:
```just
[confirm("Deploy to " + env + "?")]
deploy env:
echo 'Deploying to {{env}}...'
```
### 타임스탬프
`just`는 각 레시피 명령어 앞에 타임스탬프를 출력할 수 있습니다:
```just
recipe:
echo one
sleep 2
echo two
```
```
$ just --timestamp recipe
[07:28:46] echo one
one
[07:28:46] sleep 2
[07:28:48] echo two
two
```
기본적으로 타임스탬프 형식은 `HH:MM:SS`입니다. 형식은 `--timestamp-format`으로 변경할 수 있습니다:
```
$ just --timestamp recipe --timestamp-format '%H:%M:%S%.3f %Z'
[07:32:11:.349 UTC] echo one
one
[07:32:11:.350 UTC] sleep 2
[07:32:13:.352 UTC] echo two
two
```
`--timestamp-format`에 전달되는 인수는 `strftime` 스타일의 형식 문자열이며, 자세한 내용은 [`chrono` 라이브러리 문서](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)를참조하세요.
`[timestamp]` 어트리뷰트1.58.0를 사용하면 특정 레시피에 대해 타임스탬프를 활성화할 수 있습니다:
```just
[timestamp]
foo:
echo hello
```
```
$ just foo
[07:28:46] echo hello
hello
```
형식 문자열을 포함할 수도 있습니다:
```just
[timestamp('%H:%M:%S%.3f')]
foo:
echo hello
```
```
$ just foo
[07:28:46.487] echo hello
hello
```
### 시그널 처리
[시그널](https://en.wikipedia.org/wiki/Signal\_(IPC))은 특정 동작을 유발하기 위해 실행 중인 프로그램에 전송되는 메시지입니다. 예를 들어, `ctrl-c`를 누르면 터미널 포그라운드 프로세스 그룹의 모든 프로세스에 `SIGINT`가 전송됩니다.
`just`는 시그널에 의해 요청될 때 종료하려고 시도하지만, 동시에 실행 중인 자식 프로세스가 방치되지 않도록 하려고도 시도합니다. 이 두 가지 목표는 어느 정도 상충됩니다.
`just`가 자식 프로세스를 남겨둔 채 종료되면, 사용자는 `ps aux | grep`으로 자식 프로세스를 찾아 수동으로 `kill`하는 번거로운 작업을 해야만 합니다.
#### 치명적 시그널
`SIGHUP`, `SIGINT`, `SIGQUIT`은 사용자가 각각 터미널을 닫거나, `ctrl-c`를 입력하거나, `ctrl-\`을 입력할 때 생성되며, 포그라운드 프로세스 그룹의 모든 프로세스에 전송됩니다.
`SIGTERM`은 `kill` 명령에 의해 전송되는 기본 시그널이며, 대상 프로세스에만 전달됩니다.
자식 프로세스가 실행 중이 아니면, `just`는 위 시그널 중 하나를 받는 즉시 종료됩니다.
자식 프로세스가 \*실제로\* 실행 중인 경우, `just`는 자식 프로세스가 방치되는 것을 막기 위해 종료될 때까지 기다립니다.
또한, `SIGTERM`을 수신하면 `just`는 다른 치명적 시그널과 달리 `SIGTERM`이 `just` 단독으로 전송되었을 가능성이 높으므로, 실행 중인 모든 자식 프로세스에 `SIGTERM`을 전달합니다1.41.0.
자식 프로세스가 `just`가 치명적 시그널을 받은 후 성공적으로 종료되는지 여부와 관계없이, `just`는 실행을 중단합니다.

#### 실행 계속하기
`[continue]`1.54.0 속성을 사용하면 `just`가 실행하는 자식 프로세스가 성공적으로 종료되는 한 치명적인 시그널을 받더라도 실행을 계속하도록 만들 수 있습니다.
인수가 없는 경우, `[continue]`는 `SIGINT` (`ctrl-c`)를 처리하므로 `SIGQUIT` (`ctrl-\`)을 사용하여 계속 실행을 중단할 수 있습니다.
인수가 있는 경우, `"SIGHUP"`, `"SIGINT"`, `"SIGQUIT"`과 같이 처리할 하나 이상의 시그널을 명시적으로 지정할 수 있습니다.
이 예제에서 `main.py`가 `SIGINT`를 잡아내고 성공적으로 종료되면, `cleanup`이 여전히 실행되고 `just`도 성공적으로 종료됩니다:
```just
[continue]
test: && cleanup
python3 main.py
cleanup:
echo cleanup
```
#### `SIGINFO`
`SIGINFO`는 macOS를 포함한 [BSD](https://en.wikipedia.org/wiki/Berkeley\_Software\_Distribution) 파생 운영 체제(단, Linux는 제외)에서 사용자가 `ctrl-t`를 입력할 때 포그라운드 프로세스 그룹의 모든 프로세스로 전송됩니다.
`just`는 이에 응답하여 모든 자식 프로세스 ID와 명령어 목록을 출력합니다1.41.0.
#### Windows
Windows에서 `just`는 사용자가 `ctrl-c`를 입력할 때 마치 `SIGINT`를 받은 것처럼 동작합니다. 다른 시그널은 지원되지 않습니다.
### 셸 자동 완성 스크립트
Bash, Elvish, Fish, Nushell, PowerShell, Zsh용 셸 자동 완성 스크립트는 [릴리스 아카이브](https://github.com/casey/just/releases)에서 사용할 수 있습니다.
`just` 바이너리는 `just --completions SHELL`을 사용하여 런타임에 동일한 자동 완성 스크립트를 생성할 수도 있습니다:
```console
$ just --completions bash > just
```
#### Bash
권장되는 방법은 `bash-completions` 패키지를 사용하여 자동 완성 스크립트를 지연 로딩(lazy-load)하는 것입니다:
```bash
mkdir -p ~/.local/share/bash-completion/completions
just --completions bash > ~/.local/share/bash-completion/completions/just
```
`bash-completions`가 설치되어 있지 않은 경우, `.bashrc`에서 자동 완성 스크립트를 소스(source)할 수 있습니다:
```bash
source <(just --completions bash)
```
`alias j=just`와 같은 별칭을 사용하는 경우, 지연 로딩 시 자동 완성 스크립트도 `j`라는 이름으로 저장해야 합니다:
```bash
just --completions bash > ~/.local/share/bash-completion/completions/j
```
또는 지연 로딩을 하지 않는 경우, `.bashrc`에서 자동 완성 스크립트를 소스한 후 다음 줄을 추가하세요:
```bash
complete -F \_clap\_complete\_just -o bashdefault -o default j
```
#### Elvish
`rc.elv` 파일에 다음을 추가하세요:
```elvish
set edit:completion:arg-completer[just] = { |@args|
eval (just --completions elvish | slurp)
set @result = (edit:completion:arg-completer[just] $@args)
put $@result
}
```
#### Fish
자동 완성 스크립트를 completions 디렉토리에 저장하여 지연 로딩합니다:
```fish
mkdir -p ~/.config/fish/completions
just --completions fish > ~/.config/fish/completions/just.fish
```
#### Nushell
먼저 자동 완성 스크립트를 저장합니다:
```nu
just --completions nushell | save -f ($nu.default-config-dir | path join just.nu)
```
그런 다음 `config.nu`에 다음을 추가합니다:
```nu
source just.nu
```
#### PowerShell
PowerShell `$PROFILE`에 다음을 추가하세요:
```powershell
just --completions powershell | Out-String | Invoke-Expression
```
#### Zsh
먼저 자동 완성 스크립트를 저장합니다:
```zsh
mkdir -p ~/.zsh/completions
just --completions zsh > ~/.zsh/completions/\_just
```
그런 다음 `.zshrc` 파일에 다음을 추가합니다:
```zsh
fpath=(~/.zsh/completions $fpath)
autoload -U compinit
compinit
```
### 매뉴얼 페이지
`just`는 `just --man`을 통해 자체 매뉴얼 페이지를 출력할 수 있습니다. 매뉴얼 페이지는 유닉스의 가장 오래된 실용적인 응용 프로그램 중 하나이자 유서 깊은 마크업 언어인 [`roff`](https://en.wikipedia.org/wiki/Roff\_%28software%29)로 작성되었습니다. [`groff`](https://www.gnu.org/software/groff/)가 설치되어 있다면 `just --man | groff -mandoc -Tascii | less` 명령어로 매뉴얼 페이지를 볼 수 있습니다.
### `justfile` 포맷팅 및 덤프
각 `justfile`은 공백 및 줄바꿈과 관련하여 표준화된 포맷을 가지고 있습니다.
`--fmt` 플래그를 사용하여 현재 justfile을 표준 포맷으로 덮어쓸 수 있습니다:
```console
$ cat justfile
# A lot of blank lines
some-recipe:
echo "foo"
$ just --fmt
$ cat justfile
# A lot of blank lines
some-recipe:
echo "foo"
```
`justfile`을 `--justfile -`을 통해 표준 입력으로 읽어오거나 추출할 때

markdown 파일, `--fmt`는 포맷된 `justfile`을 표준 출력(stdout)으로 출력합니다.
포맷팅은 하위 호환성 보장이 적용되지 않으며 수시로 변경될 수 있음에 유의하세요.
레시피 본문은 기본적으로 4칸의 공백으로 들여쓰기 됩니다. 이는 `--indentation` 명령줄 옵션, `JUST\_INDENTATION` 환경 변수 또는 `indentation` 설정으로 변경할 수 있습니다:
```just
set indentation := " "
```
`just --fmt --check`를 실행하면 `--fmt`가 체크 모드로 실행됩니다. `just`는 `justfile`을 덮어쓰는 대신, 올바르게 포맷되어 있으면 종료 코드 0으로 종료하고, 그렇지 않으면 1로 종료하며 diff를 출력합니다.
`--dump` 명령을 사용하여 포맷된 버전의 `justfile`을 표준 출력으로 출력할 수 있습니다:
```console
$ just --dump > formatted-justfile
```
`--dump` 명령을 `--dump-format json`과 함께 사용하여 `justfile`의 JSON 표현을 출력할 수 있습니다.

캐시된 레시피
--------------
`just`는 캐시에서 호출과 일치하는 항목을 찾으면 `[cache]` 속성1.54.0이 있는 레시피의 호출을 건너뜁니다. `[cache]` 속성은 스크립트 레시피에만 사용할 수 있으며 현재 불안정(unstable) 상태입니다.
예를 들어, `image.jpg`가 존재하고 `image.png`의 내용과 `convert -version`의 출력 결과가 마지막 실행 이후 변경되지 않은 경우 이 레시피는 건너뛰어집니다:
```just
set unstable
[script]
[cache(inputs = "image.png", outputs = "image.jpg", extra = `convert -version`)]
convert:
convert image.png image.jpg
```
대체로 잘 설계되어 있고 사용자 친화적인 `just`의 다른 많은 기능들과 달리, 캐시된 레시피는 본질적으로 취약합니다. 여기에 의존하기 전에 한계를 이해하는 것이 중요합니다. 아래의 친절한 경고를 포함하여 이 섹션을 주의 깊게 읽어주세요.

### 친절한 경고
`just`는 캐시된 레시피를 기꺼이 건너뛰겠지만, 이것이 안전한지, 그리고 캐시 키의 내용이 레시피 호출에 대한 충분한 정보를 포착하여 애초에 캐싱이 의미를 갖도록 하는지는 사용자의 책임입니다.
특히, 레시피가 실행되는 컨텍스트에 대한 많은 세부 정보들은 캐시 키에 포착되지 않습니다.
여기에는 시간, 입력 파일, 출력 파일, 시스템 바이너리, 운영체제 버전, 데이터베이스, 네트워크상의 시스템, DNS, 그리고 컴퓨터 프로그램의 실행을 변경할 수 있는 수많은 기타 요소들이 포함됩니다.
`just`가 사용하는 조잡한 휴리스틱 유형을 기반으로 실행을 건너뛰려는 시도는 길고 추잡한 역사를 가지고 있습니다. 그러나 이는 부인할 수 없이 편리하고 강력한 도구이며, 여러분이 유용하게 쓰시기를 바라는 마음으로 제공됩니다.

### 구현
캐시는 `justfile`과 함께 있는 `.justcache`라는 이름의 디렉토리이며, 버전 관리 시스템에 커밋해서는 안 됩니다. 여기에는 직렬화된 캐시 키 JSON 객체의 BLAKE3 해시인 `HASH` 이름을 가진 `HASH.json` 캐시 항목이 포함됩니다.
캐시 키 객체의 키는 다음과 같습니다:
- `body`: 평가된 레시피 본문
- `environment`: 환경 변수 이름과 값의 맵
- `executor`: 스크립트 인터프리터 또는 셰뱅(shebang)
- `extension`: 스크립트 파일 확장자
- `extra`: 사용자가 제공한 값
- `inputs`: 파일 경로와 콘텐츠 해시의 맵
- `positional`: 위치 인자
- `recipe`: 호출된 레시피에 대한 `::`로 구분된 모듈 경로
- `working\_directory`: 현재 작업 디렉토리
`extra`와 `inputs`를 제외한 모든 키는 자동으로 채워집니다.

호출된 레시피의 캐시 키 객체는 `just -vv`를 사용하여 표준 에러로 출력할 수 있습니다.
`environment`에 포함된 환경 변수는 `[cache(environment = EXPRESSION)]`master로 제어할 수 있습니다.
`extra`의 값은 `[cache(extra = EXPRESSION)]`을 사용하여 제공할 수 있으며, 여기서 `EXPRESSION`은 레시피 인자가 스코프 내에 있는 상태로 평가되는 임의의 표현식입니다. `extra` 값의 변경은 캐시 미스를 유발합니다.
`just`가 캐시된 레시피를 실행하기 전에 캐시 키를 생성하고, 해싱한 후, 해당하는 캐시 항목을 찾습니다.
캐시 항목이 비어 있지 않으면 호출을 건너뜁니다.
캐시 항목이 존재하지 않거나 비어 있으면

이는 호출을 실행하고 캐시 항목에 `{}`을(를) 기록합니다. 캐시 항목에는 파일 락(file lock)이 걸리므로, 여러 `just` 프로세스가 캐시된 레시피를 동시에 실행해도 안전합니다. 두 프로세스가 동일한 캐시 키로 레시피 호출을 실행하는 경우, 첫 번째 프로세스가 락을 획득하고, 레시피를 실행하고, 캐시 항목에 기록한 후 락을 해제합니다. 두 번째 프로세스는 첫 번째 프로세스가 락을 해제할 때까지 대기(block)한 다음, 항목이 비어 있지 않은 것을 확인하고 호출을 건너뜁니다.
`--no-cache` 플래그를 사용하면 캐시를 완전히 우회할 수 있습니다.

### 캐시 지우기
레시피 캐시는 `justfile`과 같은 위치에 있는 `.justcache`라는 디렉터리에 저장됩니다. 이 디렉터리를 삭제하면 캐시가 지워집니다.
`just --clean`을 사용해서 캐시를 지울 수도 있으며, 이를 통해 캐시 항목을 선택적으로 지울 수 있습니다:

```sh
# clear all cache entries
just --clean
# clear cache entries for recipe `foo`
just --clean foo
# clear cache entries for recipe `baz` in submodule `bar`
just --clean bar baz
# clear cache entries for recipes in submodule module `bar`
just --clean bar
# clear cache entries for recipes in submodule module `bar::bob`
just --clean bar bob
# '::'-separated paths may also be used
just --clean bar::bob
```

### 환경 변수 추가 및 제거
기본적으로 `justfile`에서 내보내거나(export) 내보내지 않은(unexport) 환경 변수는 캐시 키에 포함되며, `justfile` 외부에서 내보내지고 `just`에 상속된 환경 변수는 포함되지 않습니다.
`[cache(environment = EXPRESSION)]`master을 사용하여 캐시 키에 환경 변수를 추가하거나 제거할 수 있습니다.
이 예시에서 환경 변수 `foo`는 캐시 키에 포함되지 않지만, `PATH`는 포함됩니다:

```just
set unstable
set lists
export foo := 'bar'
[script]
[cache(environment = ['PATH'])]
build:
cc lib.c main.c -o main
```

### 입력 파일
`[cache(inputs = FILES)]`을 사용하여 입력 파일을 제공할 수 있습니다. 여기서 `FILES`는 레시피 인수가 유효한 범위(scope)에서 평가되는 표현식이며, 평가된 요소들은 경로입니다. 경로는 절대 경로이거나 레시피의 작업 디렉터리를 기준으로 한 상대 경로일 수 있습니다.
각 입력 파일은 BLAKE3으로 해시되며 경로와 해시의 맵(map)을 포함하는 `inputs` 캐시 키에 추가됩니다.
입력 파일의 내용이 조금이라도 변경되면 캐시 키가 바뀌므로, 다음 호출 시 캐시를 미스(miss)하고 다시 실행됩니다.
존재하지 않는 입력 및 디렉터리 경로는 오류 처리됩니다.
이 예시에서 `lib.c` 또는 `main.c`가 변경되면 `build` 레시피가 다시 실행됩니다:

```just
set unstable
set lists
[script]
[cache(inputs = ["lib.c", "main.c"])]
build:
cc lib.c main.c -o main
```

### 출력 파일
`[cache(outputs = FILES)]`을 사용하여 출력 파일을 제공할 수 있습니다. 여기서 `FILES`는 레시피 인수가 유효한 범위(scope)에서 평가되는 표현식이며, 평가된 요소들은 경로입니다. 경로는 절대 경로이거나 레시피의 작업 디렉터리를 기준으로 한 상대 경로일 수 있습니다.
출력 파일은 캐시 키의 일부가 아닙니다.
호출을 건너뛰려면 모든 출력 파일이 존재해야 하며, 호출이 성공적으로 실행된 후 출력 파일이 하나라도 존재하지 않으면 오류가 발생합니다.
이 예시에서 `main`이 없으면 `build`가 다시 실행되며, `main`을 생성하지 못한 채 실행되면 오류가 발생합니다:

```just
set unstable
set lists
[script]
[cache(inputs = ["lib.c", "main.c"], outputs = "main")]
build:
cc lib.c main.c -o main
clean:
rm -f main
```
이렇게 하면 `clean`에 의해 `main`이 삭제되었을 때 `build`가 강제로 다시 실행됩니다.

Reference
---------
### 속성
레시피, `mod` 문, 그리고 별칭(alias)에는 동작을 변경하는 속성을 주석으로 달 수 있습니다.

| 이름 | 타입 | 설명 |
|------|------|-------------|
| `[arg(ARG, help="HELP")]`1.46.0 | 레시피 | 사용법 메시지에서 `ARG`에 대한 도움말 문자열 `HELP`를 출력합니다. const 표현식일 수 있습니다1.55.0. |
| `[arg(ARG, long="LONG")]`1.46.0 | 레시피 | 인수 `ARG`의 값을 `--LONG` 옵션으로 전달하도록 요구합니다. 매개변수가 가변 인자(variadic)인 경우 옵션을 반복해서 사용할 수 있습니다1.55.0master. |
| `[arg(ARG, max="MAX")]`1.56.0 | 레시피 | 인수 `ARG`에 최대 `MAX`개의 값만 전달할 수 있도록 허용합니다. `multiple` 또는 가변 인자 매개변수가 필요합니다. |
| `[arg(ARG, min="MIN")]`1.

인자는 콜론과 함께 작성할 수 있습니다:
```just
[group: 'bar']
foo:
```
### 설정 (Settings)
설정은 해석과 실행을 제어합니다. 각 설정은 `justfile` 내의 어느 곳에서든 최대 한 번만 지정할 수 있습니다.
예를 들면:
```just
set shell := ["zsh", "-cu"]
foo:
# 이 줄은 `zsh -cu 'ls \*\*/\*.txt'`로 실행됩니다
ls \*\*/\*.txt
```
#### 설정 테이블
| 이름 | 값 | 기본값 | 설명 |
|------|-------|---------|-------------|
| `allow-duplicate-recipes` | boolean | `false` | `justfile`에서 나중에 나오는 레시피가 같은 이름을 가진 이전 레시피를 덮어쓰는 것을 허용합니다. |
| `allow-duplicate-variables` | boolean | `false` | `justfile`에서 나중에 나오는 변수가 같은 이름을 가진 이전 변수를 덮어쓰는 것을 허용합니다. |
| `default-list` | boolean | `false` | 기본 레시피를 실행하는 대신 레시피 목록을 표시합니다. |
| `default-script`1.52.0 | boolean | `false` | 셸 대신 스크립트를 기본 레시피로 설정합니다. |
| `dotenv-command`1.54.0 | string | - | 명령어를 실행하고 그 출력을 환경 파일로 로드합니다. |
| `dotenv-filename` | string | - | 존재하는 경우, 사용자 지정 이름을 가진 `.env` 파일을 로드합니다. |
| `dotenv-load` | boolean | `false` | 존재하는 경우 `.env` 파일을 로드합니다. |
| `dotenv-override` | boolean | `false` | `.env` 파일의 값으로 기존 환경 변수를 재정의합니다. |
| `dotenv-path` | string | - | 사용자 지정 경로에서 `.env` 파일을 로드하며, 존재하지 않을 경우 오류를 발생시킵니다. `dotenv-filename`보다 우선합니다. |
| `dotenv-required` | boolean | `false` | `.env` 파일을 찾을 수 없는 경우 오류를 발생시킵니다. |
| `export` | boolean | `false` | 모든 변수를 환경 변수로 내보냅니다. |
| `fallback` | boolean | `false` | 명령줄의 첫 번째 레시피를 찾을 수 없는 경우 상위 디렉터리에서 `justfile`을 검색합니다. |
| `guards`1.47.0 | boolean | `false` | 레시피 라인에서 `?` 가드 기호(sigil)를 활성화합니다. [sigils](#sigils)를 참고하세요. |
| `ignore-comments` | boolean | `false` | `#`으로 시작하는 셸 레시피 라인을 무시합니다. 스크립트 레시피에는 적용되지 않습니다. |
| `indentation`1.56.0 | string | - | `--fmt` 또는 `--dump`로 포맷팅할 때 사용되는 레시피 본문 들여쓰기를 설정합니다. |
| `lazy`1.47.0 | boolean | `false` | 사용되지 않는 변수는 평가하지 않습니다. |
| `lists`1.53.0 | boolean | `false` | 값은 문자열 대신 문자열 목록일 수 있습니다. 현재는 불안정(unstable)합니다. |
| `minimum-version`1.55.0 | string | - | `just`가 `minimum-version`보다 오래된 경우 오류를 발생시킵니다. `"1.55.0"`과 같은 `MAJOR.MINOR.PATCH` 형식의 문자열을 허용합니다. |
| `no-cd`1.51.0 | boolean | `false` | 레시피 속성에 의해 레시피를 실행할 때 디렉터리를 변경하지 않습니다. |
| `no-exit-message`1.39.0 | boolean | `false` | 레시피가 실패할 때 종료 메시지를 출력하지 않습니다. |
| `positional-arguments` | boolean | `false` | 위치 인자를 전달합니다. |
| `quiet` | boolean | `false` | 실행 전 레시피 라인 에코 출력을 비활성화합니다. |
| `script-interpreter`1.33.0 | `[COMMAND, ARGS…]` | `['sh', '-eu']` | 빈 `[script]` 속성을 가진 레시피를 호출할 때 사용하는 명령어를 설정합니다. |
| `shell` | `[COMMAND, ARGS…]` | - | 레시피를 호출하고 백틱을 평가하는 데 사용되는 명령어를 설정합니다. |
| `tempdir` | string | - | 시스템 기본 임시 디렉터리 대신 `tempdir`에 임시 디렉터리를 생성합니다. |
| `unstable`1.31.0 | boolean | `false` | 불안정(unstable) 기능을 활성화합니다. |
| `windows-powershell` | boolean | `false` | Windows에서 기본 셸로 PowerShell을 사용합니다. (폐기됨. `set shell`에 `[windows]` 속성을 사용하세요.) |
| `windows-shell` | `[COMMAND, ARGS…]` | - | 레시피를 호출하고 백틱을 평가하는 데 사용되는 명령어를 설정합니다. (폐기됨. `set shell`에 `[windows]` 속성을 사용하세요.) |
| `working-directory`1.33.0 | string | - | 기본 작업 디렉터리를 기준으로 레시피와 백틱의 작업 디렉터리를 설정합니다. |
부울(Boolean) 설정은 다음과 같이 작성할 수 있습니다:
```justfile
set NAME
```
이는 다음와 같습니다:
```justfile
set NAME := true
```
부울이 아닌 설정은 문자열과 표현식1.46.0 모두로 설정할 수 있습니다.
그러나 설정은 백틱과 많은 함수의 동작에 영향을 미치므로,
해당 표현식들은 백틱이나 함수 호출을 직접 또는 트리에 포함할 수 없습니다.

참조를 통해 민감하게 처리됩니다.
### 함수
#### 시스템 정보
- `arch()` — 명령어 세트 아키텍처입니다. 가능한 값은 다음과 같습니다: `"aarch64"`,
`"arm"`, `"asmjs"`, `"hexagon"`, `"mips"`, `"msp430"`, `"powerpc"`,
`"powerpc64"`, `"s390x"`, `"sparc"`, `"wasm32"`, `"x86"`, `"x86\_64"`, 그리고
`"xcore"`.
- `num\_cpus()`1.15.0 — 논리적 CPU의 개수입니다.
- `os()` — 운영 체제입니다. 가능한 값은 다음과 같습니다: `"android"`, `"bitrig"`,
`"dragonfly"`, `"emscripten"`, `"freebsd"`, `"haiku"`, `"ios"`, `"linux"`,
`"macos"`, `"netbsd"`, `"openbsd"`, `"solaris"`, 그리고 `"windows"`.
- `os\_family()` — 운영 체제 패밀리입니다. 가능한 값은 다음과 같습니다: `"unix"` 및
`"windows"`.
예를 들어:
```just
system-info:
@echo "This is an {{arch()}} machine."
```
```console
$ just system-info
This is an x86\_64 machine.
```
`os\_family()` 함수를 사용하면 다양한 운영 체제에서 작동하는 크로스 플랫폼 `justfile`을 만들 수 있습니다. 예시를 보려면
[cross-platform.just](https://github.com/casey/just/blob/master/examples/cross-platform.just)
파일을 참고하세요.
#### 외부 명령어
- `shell(command, args...)`1.27.0은 0개 이상의 위치 인자 `args`를 가진 쉘 스크립트 `command`의 표준 출력을 반환합니다. `command`를 해석하는 데 사용되는 쉘은 레시피 라인을 평가하는 데 사용되는 쉘과 동일하며, `set shell := […]`을 통해 변경할 수 있습니다.
`command`는 첫 번째 인자로 전달되므로, 명령어가 `'echo $@'`인 경우, 기본 쉘 명령어 `sh -cu` 및 인자 `'foo'`와 `'bar'`를 포함한 전체 커맨드 라인은 다음과 같습니다:
```
'sh' '-cu' 'echo $@' 'echo $@' 'foo' 'bar'
```
이는 `$@`가 예상대로 작동하고, `$1`이 첫 번째 인자를 가리키도록 하기 위함입니다. `$@`에는 실행 중인 프로그램의 이름일 것으로 예상되는 첫 번째 위치 인자가 포함되지 않습니다.
```just
# 인자는 변수나 표현식이 될 수 있습니다
file := '/sys/class/power\_supply/BAT0/status'
bat0stat := shell('cat $1', file)
# 명령어는 변수나 표현식이 될 수 있습니다
command := 'wc -l'
output := shell(command + ' "$1"', 'main.c')
# 쉘 명령어에서 참조되는 인자는 반드시 사용되어야 합니다
empty := shell('echo', 'foo')
full := shell('echo $1', 'foo')
error := shell('echo $1')
```
```just
# python을 쉘로 사용하는 경우. `python -c`는 `sys.argv[0]`을 `'-c'`로 설정하므로,
# 첫 번째 "실제" 위치 인자는 `sys.argv[2]`가 됩니다.
set shell := ["python3", "-c"]
olleh := shell('import sys; print(sys.argv[2][::-1])', 'hello')
```
#### 환경 변수
- `env(key)`1.15.0 — 이름이 `key`인 환경 변수를 가져오며, 존재하지 않으면 중단합니다.
```just
home\_dir := env('HOME')
test:
echo "{{home\_dir}}"
```
```console
$ just
/home/user1
```
- `env(key, default)`1.15.0 — 이름이 `key`인 환경 변수를 가져오며, 존재하지 않으면 `default`를 반환합니다.
- `env\_var(key)` — `env(key)`의 더 이상 사용되지 않는(deprecated) 별칭입니다.
- `env\_var\_or\_default(key, default)` — `env(key, default)`의 더 이상 사용되지 않는(deprecated) 별칭입니다.
#### 실행 파일
- `require(name)`1.39.0 — `PATH` 환경 변수의 디렉터리에서 실행 파일 `name`을 검색하여 전체 경로를 반환하거나, `name`인 실행 파일이 존재하지 않으면 오류와 함께 중단합니다.
```just
bash := require("bash")
@test:
echo "bash: '{{bash}}'"
```
```console
$ just
bash: '/bin/bash'
```
- `which(name)`1.39.0 — `PATH` 환경 변수의 디렉터리에서 실행 파일 `name`을 검색하여 전체 경로를 반환하거나, 찾지 못한 경우 빈 리스트를 반환합니다. `set lists`1.53.0이 필요합니다.
```just
set unstable
set lists
bosh := which("bosh")
@test:
echo "bosh: '{{bosh}}'"
```
```console
$ just
bosh: ''
```
#### 호출 정보
- `is\_dependency()` - 현재 레시피가 직접 실행되는 대신 다른 레시피의 의존성으로 실행되는 경우 문자열 `true`를 반환하고, 그렇지 않으면 문자열 `false`를 반환합니다.
- `num\_jobs()`1.56.0 — `--jobs`의 값 또는 전달되지 않은 경우 빈 리스트 `[]`를 반환합니다.
- `recipe\_name()`1.53.0 - 현재 레시피의 이름을 반환합니다.
#### 호출 디렉터리
- `invocation\_directory()` - `just`가 호출된 당시의 현재 디렉터리에 대한 절대 경로를 가져옵니다.

ed, `just`가 명령어를 실행하기 전에 디렉터리를 변경(chdir)하기 이전의
위치입니다. Windows에서 `invocation\_directory()`는 `cygpath`를 사용하여
호출 디렉터리를 Cygwin 호환 `/` 구분 경로로 변환합니다.
모든 플랫폼에서 원본 호출 디렉터리를 반환하려면 `invocation\_directory\_native()`를
사용하세요.
예를 들어, (사용자/호출자 관점에서) "현재 디렉터리" 바로 아래에 있는 파일들에 대해
`rustfmt`를 호출하려면 다음과 같은 레시피를 사용하세요:
```just
rustfmt:
find {{invocation\_directory()}} -name \\*.rs -exec rustfmt {} \;
```
대안으로, 현재 디렉터리에서 명령어를 실행해야 하는 경우 다음과 같이 사용할 수 있습니다 (예:):
```just
build:
cd {{invocation\_directory()}}; ./some\_script\_that\_needs\_to\_be\_run\_from\_here
```
- `invocation\_directory\_native()` - `just`가 명령어를 실행하기 전에 디렉터리를 변경(chdir)하기 전,
`just`가 호출되었을 때의 현재 디렉터리에 대한 절대 경로를 가져옵니다.

#### Justfile 및 Justfile 디렉터리
- `justfile()` - 현재 `justfile`의 경로를 가져옵니다.
- `justfile\_directory()` - 현재 `justfile`의 부모 디렉터리 경로를 가져옵니다.
현재 `justfile`의 위치를 기준으로 상대 경로 명령어를 실행하려면 다음과 같이 하세요:
```just
script:
{{justfile\_directory()}}/scripts/some\_script
```

#### 소스 및 소스 디렉터리
- `source\_file()`1.27.0 - 현재 소스 파일의 경로를 가져옵니다.
- `source\_directory()`1.27.0 - 현재 소스 파일의 부모 디렉터리 경로를 가져옵니다.
`source\_file()`과 `source\_directory()`는 루트 `justfile`에서는 `justfile()` 및
`justfile\_directory()`와 동일하게 동작하지만, import나 서브모듈 내에서 호출될 경우
각각 현재 `import` 또는 `mod` 소스 파일의 경로와 디렉터리를 반환합니다.

#### 모듈 및 모듈 디렉터리
- `module\_file()` - 현재 모듈 파일의 경로를 반환합니다.
- `module\_directory()` - 현재 모듈 파일의 부모 디렉터리 경로를 반환합니다.
- `module\_path()` - 현재 모듈에 대한 `::` 구분 경로를 반환합니다.
`module\_file()`과 `module\_directory()`는 루트 `justfile`에서는 `justfile()` 및
`justfile\_directory()`와 동일하게 동작하지만, 서브모듈 내에서 호출될 경우
각각 현재 `mod` 소스 파일의 경로와 디렉터리를 반환합니다.

#### Just 프로세스 및 실행 파일
- `just\_executable()` - `just` 실행 파일의 절대 경로입니다.
- `just\_pid()` - `just` 실행 파일의 프로세스 ID입니다.
- `just\_version()`1.55.0 - `just` 실행 파일의 버전입니다.
예시:
```just
just-info:
@echo The executable is at: {{just\_executable()}}
@echo The process ID is: {{ just\_pid() }}
@echo The version is: {{ just\_version() }}
```
```console
$ just
The executable is at: /bin/just
The process ID is: 420
The version is: 1.54.0
```

#### 문자열 조작
- `append(suffix, s)`1.27.0 - `s`의 공백으로 구분된 문자열들에
`suffix`를 추가합니다. `append('/src', 'foo bar baz')` →
`'foo/src bar/src baz/src'`
- `prepend(prefix, s)`1.27.0 - `s`의 공백으로 구분된 문자열들에
`prefix`를 추가합니다. `prepend('src/', 'foo bar baz')` →
`'src/foo src/bar src/baz'`
- `encode\_uri\_component(s)`1.27.0 - [JavaScript `encodeURIComponent` 함수](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/encodeURIComponent)의
동작과 같이, `[A-Za-z0-9\_.!~\*'()-]`를 제외한 `s`의 문자들을 퍼센트 인코딩합니다.
- `quote(s)` - 모든 작은따옴표를 `'\''`로 교체하고 `s`의 앞뒤에
작은따옴표를 붙입니다. 이는 대부분의 본(Bourne) shell 파생 버전을 포함하여
많은 셸에서 특수 문자를 이스케이프하기에 충분합니다.
- `replace(s, from, to)` - `s`에 있는 모든 `from`을 `to`로 교체합니다.
- `replace\_regex(s, regex, replacement)` - `s`에 있는 모든 `regex` 일치 항목을
`replacement`로 교체합니다. 정규 표현식은 [Rust `regex` 크레이트](https://docs.rs/regex/latest/regex/)에서 제공합니다.
사용 예시는 [구문 문서](https://docs.rs/regex/latest/regex/#syntax)를
참고하세요. 캡처 그룹이 지원됩니다. `replacement` 문자열은 [Repl

acement string syntax](https://docs.rs/regex/latest/regex/struct.Regex.html#replacement-string-syntax).
- `trim(s)` - `s`의 앞뒤 공백을 제거합니다.
- `trim\_end(s)` - `s`의 뒤쪽 공백을 제거합니다.
- `trim\_end\_match(s, substring)` - `substring`과 일치하는 `s`의 접미사를 제거합니다.
- `trim\_end\_matches(s, substring)` - `substring`과 일치하는 `s`의 접미사를 반복적으로 제거합니다.
- `trim\_start(s)` - `s`의 앞쪽 공백을 제거합니다.
- `trim\_start\_match(s, substring)` - `substring`과 일치하는 `s`의 접두사를 제거합니다.
- `trim\_start\_matches(s, substring)` - `substring`과 일치하는 `s`의 접두사를 반복적으로 제거합니다.
#### 대소문자 변환
- `capitalize(s)`1.7.0 - `s`의 첫 번째 문자는 대문자로, 나머지는 소문자로 변환합니다.
- `kebabcase(s)`1.7.0 - `s`를 `kebab-case`로 변환합니다.
- `lowercamelcase(s)`1.7.0 - `s`를 `lowerCamelCase`로 변환합니다.
- `lowercase(s)` - `s`를 소문자로 변환합니다.
- `shoutykebabcase(s)`1.7.0 - `s`를 `SHOUTY-KEBAB-CASE`로 변환합니다.
- `shoutysnakecase(s)`1.7.0 - `s`를 `SHOUTY\_SNAKE\_CASE`로 변환합니다.
- `snakecase(s)`1.7.0 - `s`를 `snake\_case`로 변환합니다.
- `titlecase(s)`1.7.0 - `s`를 `Title Case`로 변환합니다.
- `uppercamelcase(s)`1.7.0 - `s`를 `UpperCamelCase`로 변환합니다.
- `uppercase(s)` - `s`를 대문자로 변환합니다.
#### 경로 조작
##### 실패 가능 (Fallible)
- `absolute\_path(path)` - 작업 디렉토리 내의 상대 `path`에 대한 절대 경로입니다. `/foo` 디렉토리의 `absolute\_path("./bar.txt")`는 `/foo/bar.txt`입니다.
- `canonicalize(path)`1.24.0 - 심볼릭 링크를 해결하고 가능한 경우 `.`, `..`, 추가 `/`를 제거하여 `path`를 정규화합니다.
- `extension(path)` - `path`의 확장자입니다. `extension("/foo/bar.txt")`는 `txt`입니다.
- `file\_name(path)` - 상위 디렉토리 구성 요소가 제거된 `path`의 파일 이름입니다. `file\_name("/foo/bar.txt")`는 `bar.txt`입니다.
- `file\_stem(path)` - 확장자를 제외한 `path`의 파일 이름입니다. `file\_stem("/foo/bar.txt")`는 `bar`입니다.
- `parent\_directory(path)` - `path`의 부모 디렉토리입니다. `parent\_directory("/foo/bar.txt")`는 `/foo`입니다.
- `without\_extension(path)` - 확장자가 없는 `path`입니다. `without\_extension("/foo/bar.txt")`는 `/foo/bar`입니다.
이 함수들은 예를 들어 경로에 확장자가 없는 경우 등에서 실패할 수 있으며, 이 경우 실행이 중단됩니다.
##### 실패 불가 (Infallible)
- `clean(path)` - 추가 경로 구분자, 중간의 `.` 구성 요소, 가능한 경우 `..`를 제거하여 `path`를 단순화합니다. `clean("foo//bar")`는 `foo/bar`이고, `clean("foo/..")`는 `.`이며, `clean("foo/./bar")`는 `foo/bar`입니다.
- `join(a, b…)` - \*이 함수는 유닉스에서는 `/`를, 윈도우에서는 `\`를 사용하므로 원하지 않는 동작으로 이어질 수 있습니다. 윈도우에서 구체적으로 `\`가 필요한 경우가 아니라면, 항상 `/`를 사용하는 연산자(예: `a / b`)를 대체제로 고려해야 합니다.\* 경로 `a`와 경로 `b`를 결합합니다. `join("foo/bar", "baz")`는 `foo/bar/baz`입니다. 두 개 이상의 인수를 허용합니다.
#### 파일시스템 접근
- `path\_exists(path)` - 경로가 기존 엔터티를 가리키고 있으면 문자열 `true`를 반환하고, 그렇지 않으면 문자열 `false`를 반환합니다. 심볼릭 링크를 순회하며, 경로에 접근할 수 없거나 깨진 심볼릭 링크를 가리키는 경우 문자열 `false`를 반환합니다.
- `read(path)`1.39.0 - `path`에 있는 파일의 내용을 문자열로 반환합니다.
#### 어설션 및 오류 보고
- `assert(CONDITION, EXPRESSION)`1.27.0 - `CONDITION`이 거짓인 경우 `EXPRESSION` 메시지와 함께 오류를 발생시킵니다. `EXPRESSION`은 생략할 수 있습니다1.53.0.
- `error(message)` - 실행을 중단하고 사용자에게 `message` 오류를 보고합니다.
#### UUID 및 해시 생성
- `blake3(string)`1.25.0 - `string`의 [BLAKE3] 해시를 1진수(十六進數) 문자열로 반환합니다.
- `blake3\_file(path)`1.25.0 - `path`에 있는 파일의 [BLAKE3] 해시를 16진수 문자열로 반환합니다.
- `sha256(string)` - `string`의 SHA-256 해시를 16진수 문자열로 반환합니다.
- `sha256\_file(path)` - `path`에 있는 파일의 SHA-256 해시를 16진수 문자열로 반환합니다.
- `uuid()` - 무작위 버전 4 UUID를 생성합니다.
[BLAKE3]: https://github.com/BLAKE3-team/BLAKE3/
#### 랜덤
- `choose(n, alphabet)`1.27.0 - `alphabet`에서 무작위로 선택된 `n`개의 문자로 이루어진 문자열을 생성합니다(단, 중복 문자는 포함되지 않음).

문자열입니다. 예를 들어 `choose('64', HEX)`는 무작위로 64자의 소문자 16진수 문자열을 생성합니다.
#### 날짜 및 시간
- `datetime(format)`1.30.0 - `format`을 사용하여 로컬 시간을 반환합니다.
- `datetime\_utc(format)`1.30.0 - `format`을 사용하여 UTC 시간을 반환합니다.
`datetime`과 `datetime\_utc`의 인자는 `strftime` 스타일의 포맷 문자열입니다. 자세한 내용은
[`chrono` 라이브러리 문서](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)를
참고하세요.
#### 시멘틱 버전
- `semver\_matches(version, requirement)`1.16.0 - [시멘틱 `version`](https://semver.org)(예: `"0.1.0"`)이 `requirement`(예: `">=0.1.0"`)와 일치하는지 확인하고, 일치하는 경우 문자열 `"true"`를, 그렇지 않은 경우 문자열 `"false"`를 반환합니다.
#### 스타일
- `style(styles)`1.37.0 - `styles`에 지정된 이름의 스타일을 결합한 터미널 이스케이프 시퀀스를 반환합니다.
버전 1.37.0 이상에서 지원되는 스타일은 `just` 자체의 스타일을 복제하는 데 사용할 수 있습니다.
- `command`: 에코된 레시피 라인
- `error`: 에러
- `warning`: 경고
버전 1.55.0 이상에서 추가로 지원되는 스타일에는 다음 이름의 색상이 포함됩니다.
- `black`
- `blue`
- `cyan`
- `green`
- `magenta`
- `red`
- `white`
- `yellow`
`0`과 `255` 사이의 정수로 작성된 256개의 인덱스 색상(예: `1` 또는 `67`).
`#RRGGBB` 또는 `#RGB` 16진수 코드로 작성된 24비트 색상(예: `#065535` 또는 `#AAA`).
그리고 표시 속성:
- `blink`
- `bold`
- `dim`
- `hidden`
- `italic`
- `reverse`
- `strikethrough`
- `underline`
두 개의 스트림 이름1.55.0은 `--color`, `JUST\_COLOR`, 그리고 스트림이 터미널에 연결되어 있는지 여부에 따라 `just`가 출력 스트림을 컬러로 표시할지 여부를 결정합니다.
- `stdout`
- `stderr`
모든 색상 스타일은 기본적으로 전경색을 지정하며, `fg:`로 시작하는 명시적 전경색 변형과 `bg:`로 시작하는 배경색 변형이 있습니다(예: `bg:blue`, `fg:133`, `#FFF`).
`styles`는 스타일의 목록일 수 있으며, 이 경우 나열된 모든 스타일이 결합되어 최종 이스케이프 시퀀스를 생성합니다.
`style(styles)`가 반환하는 이스케이프 시퀀스는 접두사입니다. 사용 후 스타일을 초기화하려면 `NORMAL` 상수를 사용할 수 있습니다.
```just
error message:
echo '{{style("error") + message + NORMAL}}'
```
- `style(styles, text)`1.55.0 한 개의 인수 형태와 마찬가지로 `styles`를 사용하여 `text`에 스타일을 지정합니다. 스타일이 자동으로 초기화되므로 터미널을 초기화하기 위해 `NORMAL`을 사용할 필요가 없습니다.
```just
error message:
echo '{{style("error", message)}}'
```
##### 사용자 디렉터리
이 함수들1.23.0은 설정, 데이터, 캐시, 실행 파일, 사용자의 홈 디렉터리와 같은 항목을 위한 사용자별 디렉터리 경로를 반환합니다.
유닉스(Unix)에서 이 함수들은 [XDG Base Directory Specification](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html)을 따릅니다.
macOS 및 윈도우(Windows)에서 이 함수들은 시스템이 지정한 사용자별 디렉터리를 반환합니다. 예를 들어, `cache\_directory()`는 macOS에서 `~/Library/Caches`를, 윈도우에서 `{FOLDERID\_LocalAppData}`를 반환합니다.
자세한 내용은 [`dirs`](https://docs.rs/dirs/latest/dirs/index.html) 크레이트를 참고하세요.
- `cache\_directory()` - 사용자별 캐시 디렉터리입니다.
- `config\_directory()` - 사용자별 설정 디렉터리입니다.
- `config\_local\_directory()` - 로컬 사용자별 설정 디렉터리입니다.
- `data\_directory()` - 사용자별 데이터 디렉터리입니다.
- `data\_local\_directory()` - 로컬 사용자별 데이터 디렉터리입니다.
- `executable\_directory()` - 사용자별 실행 파일 디렉터리입니다.
- `home\_directory()` - 사용자의 홈 디렉터리입니다.
- `runtime\_directory()` - 사용자별 런타임 디렉터리입니다. 리눅스(Linux)에서만 정의됩니다.
모든 플랫폼에서 XDG 기본 디렉터리를 사용하려면 적절한 환경 변수와 대체값을 가진 `env(…)` 함수를 사용할 수 있습니다. 단, XDG 사양에서는 절대 경로가 아닌 경로는 무시해야 하므로 사양을 준수하는 애플리케이션과 완벽하게 호환되려면 다음과 같이 작성해야 합니다.
```just
xdg\_config\_dir := if env('XDG\_CONFIG\_HOME', '') =~ '^/' {
env('XDG\_CONFIG\_HOME')
} else {
home\_directory() / '.config'
}
```
##

# 상수
많은 상수가 미리 정의되어 있습니다:
| 이름 | 값 | Windows에서의 값 |
|---|---|---|
| `HEX`1.27.0 | `"0123456789abcdef"` | |
| `HEXLOWER`1.27.0 | `"0123456789abcdef"` | |
| `HEXUPPER`1.27.0 | `"0123456789ABCDEF"` | |
| `PATH\_SEP`1.41.0 | `"/"` | `"\"` |
| `PATH\_VAR\_SEP`1.41.0 | `":"` | `";"` |
| `CLEAR`1.37.0 | `"\ec"` | |
| `NORMAL`1.37.0 | `"\e[0m"` | |
| `BOLD`1.37.0 | `"\e[1m"` | |
| `ITALIC`1.37.0 | `"\e[3m"` | |
| `UNDERLINE`1.37.0 | `"\e[4m"` | |
| `INVERT`1.37.0 | `"\e[7m"` | |
| `HIDE`1.37.0 | `"\e[8m"` | |
| `STRIKETHROUGH`1.37.0 | `"\e[9m"` | |
| `BLACK`1.37.0 | `"\e[30m"` | |
| `RED`1.37.0 | `"\e[31m"` | |
| `GREEN`1.37.0 | `"\e[32m"` | |
| `YELLOW`1.37.0 | `"\e[33m"` | |
| `BLUE`1.37.0 | `"\e[34m"` | |
| `MAGENTA`1.37.0 | `"\e[35m"` | |
| `CYAN`1.37.0 | `"\e[36m"` | |
| `WHITE`1.37.0 | `"\e[37m"` | |
| `BG\_BLACK`1.37.0 | `"\e[40m"` | |
| `BG\_RED`1.37.0 | `"\e[41m"` | |
| `BG\_GREEN`1.37.0 | `"\e[42m"` | |
| `BG\_YELLOW`1.37.0 | `"\e[43m"` | |
| `BG\_BLUE`1.37.0 | `"\e[44m"` | |
| `BG\_MAGENTA`1.37.0 | `"\e[45m"` | |
| `BG\_CYAN`1.37.0 | `"\e[46m"` | |
| `BG\_WHITE`1.37.0 | `"\e[47m"` | |
```just
@foo:
echo {{HEX}}
```
```console
$ just foo
0123456789abcdef
```
`\e`로 시작하는 상수는
[ANSI escape sequences](https://en.wikipedia.org/wiki/ANSI\_escape\_code)입니다.
`CLEAR`는 `clear` 명령어와 유사하게 화면을 지웁니다. 나머지는
`\e[Nm` 형태이며, 여기서 `N`은 정수이고 터미널 디스플레이 속성을 설정합니다.
터미널 디스플레이 속성 이스케이프 시퀀스는 결합할 수 있습니다. 예를 들어 텍스트
굵기 `BOLD`, 텍스트 스타일 `STRIKETHROUGH`, 전경색 `CYAN`, 그리고
배경색 `BG\_BLUE`를 결합할 수 있습니다. 터미널을 기본값으로 재설정하려면 뒤에
`NORMAL`을 붙여야 합니다.
일부 쉘에서는 `[`을 특수 문자로 취급하므로 이스케이프 시퀀스는 따옴표로 묶어야 합니다.
```just
@foo:
echo '{{BOLD + STRIKETHROUGH + CYAN + BG\_BLUE}}Hi!{{NORMAL}}'
```
변경 로그 (Changelog)
---------------------
최신 릴리스의 변경 로그는
[CHANGELOG.md](https://raw.githubusercontent.com/casey/just/master/CHANGELOG.md)에서 확인할 수 있습니다.
이전 릴리스의 변경 로그는
[releases 페이지](https://github.com/casey/just/releases)에서 확인할 수 있습니다. `just --changelog`를
사용하여 `just` 바이너리가 자체 변경 로그를 출력하도록 할 수도 있습니다.
기타 (Miscellanea)
------------------
### 파일이 변경될 때 레시피 재실행하기
[`watchexec`](https://github.com/mattgreen/watchexec)를 사용하면 파일이 변경될 때
모든 명령어를 다시 실행할 수 있습니다.
파일이 변경될 때 `foo` 레시피를 다시 실행하려면 다음과 같이 하세요:
```console
watchexec just foo
```
어떤 파일을 변경 감지 대상으로 지정할지 등 자세한 내용은 `watchexec --help`를 참조하세요.
### 쉘 별칭 (Shell Alias)
번개처럼 빠른 명령어 실행을 위해 쉘의 설정 파일에 `alias j=just`를 추가하세요.
### 문법 (Grammar)
`justfile`의 비규범적 문법은
[GRAMMAR.md](https://github.com/casey/just/blob/master/GRAMMAR.md)에서 확인할 수 있습니다.
### just.sh
`just`가 멋진 Rust 프로그램이 되기 전에는 `make`를 호출하는 작은 쉘 스크립트였습니다.
이전 버전은 [contrib/just.sh](https://github.com/casey/just/blob/master/contrib/just.sh)에서
찾을 수 있습니다.
### Node.js `package.json` 스크립트 호환성
다음 export 문은 `just` 레시피가 로컬 Node 모듈 바이너리에 접근할 수 있도록 하며, `just` 레시피 명령어가 Node.js `package.json` 파일의 `script` 항목처럼 동작하도록 만듭니다:
```just
export PATH := "./node\_modules/.bin:" + env\_var('PATH')
```
### Windows에서의 경로
Windows에서는 `invocation\_directory()`를 제외한 경로를 반환하는 모든 함수가 `\`로 구분된 경로를 반환합니다. PowerShell이나 `cmd.exe`를 사용하지 않는 경우, `\`가 문자 이스케이프(character escape)로 해석되는 것을 방지하기 위해 이 경로들을 따옴표로 감싸야 합니다:
```just
ls:
echo '{{absolute\_path(".")}}'
```
`cygpath.exe`는 [Cygwin](https://www.cygwin.com/) 및 Windows용
[Git](https://git-scm.com/downloads)을 포함하여 Windows용 Unix 사용자 환경(userland)의 일부 배포판에 포함된 실행 파일입니다.
`just`는 두 곳에서 `cygpath.exe`를 사용합니다:
하위 호환성을 위해 `invocation\_directory()`는 `cygpath.exe`를 사용하여 호출된 디렉터리를 변환합니다.

cation 디렉토리를 유닉스 스타일의 `/`로 구분된 경로로 변환합니다. 네이티브 Windows 스타일 경로를 얻으려면 `invocation\_directory\_native()`를 사용하세요. 유닉스 환경에서는 `invocation\_directory()`와 `invocation\_directory\_native()` 모두 동일한 유닉스 스타일 경로를 반환합니다.
`cygpath.exe`는 유닉스 스타일의 셰뱅(shebang) 라인을 Windows 경로로 변환하는 데도 사용됩니다. 대안으로 `cygpath.exe`에 의존하지 않는 `[script]` 속성을 사용할 수 있습니다.
`cygpath.exe`를 사용할 수 있는 경우, 이를 사용하여 경로 스타일 간에 변환할 수 있습니다:
```just
foo\_unix := '/hello/world'
foo\_windows := shell('cygpath --windows $1', foo\_unix)
bar\_windows := 'C:\hello\world'
bar\_unix := shell('cygpath --unix $1', bar\_windows)
```
### 복잡한 문자열 출력하기
`echo`를 사용하여 문자열을 출력할 수 있지만, `\n`과 같은 이스케이프 시퀀스를 처리하는 방식과 `echo`의 구현체마다 인식하는 이스케이프 시퀀스가 다르기 때문에 `printf`를 사용하는 것이 더 좋은 선택일 때가 많습니다.
`printf`는 C 스타일의 형식 문자열과 형식 문자열에 보간될 임의 개수의 인수를 받습니다.
이를 들여쓰기된 삼중 따옴표 문자열과 결합하면 셸의 히어독(heredoc)을 에뮬레이트할 수 있습니다.
`{{…}}`를 사용하여 레시피 본문에 복잡한 문자열을 치환하는 것은 공백과 따옴표의 유무에 따라 셸에 의해 여러 개의 인수로 분할될 수 있으므로 문제를 일으킬 수 있습니다. 복잡한 문자열을 환경 변수로 내보내고 `"$NAME"`(이때 큰따옴표를 사용하는 것에 주의하세요)으로 참조하는 것도 도움이 될 수 있습니다.
이 모든 것을 종합하여, 다양한 이스케이프 시퀀스와 따옴표를 그대로 유지한 채 문자열을 표준 출력에 그대로(verbatim) 출력하려면 다음과 같이 합니다:
```just
export FOO := '''
a complicated string with
some dis\tur\bi\ng escape sequences
and "quotes" of 'different' kinds
'''
bar:
printf %s "$FOO"
```
### 에이전트를 위한 스킬
에이전트를 위한 스킬은 [skills/just](https://github.com/casey/just/blob/master/skills/just/)에서 제공되며, 수동으로 설치하거나 `npx skills add casey/just --global` 명령어로 설치할 수 있습니다.
### 대안 및 기존 도구
명령어 러너(command runner)는 부족함이 없습니다! `just`와 다소 유사한 대안들로는 다음과 같은 것들이 있습니다:
- [make](https://en.wikipedia.org/wiki/Make\_(software)): `just`에 영감을 준 유닉스 빌드 도구. 원래 `make`의 현대적 파생형으로는 [FreeBSD Make](https://www.freebsd.org/cgi/man.cgi?make(1))와 [GNU Make](https://www.gnu.org/software/make/) 등 여러 가지가 있습니다.
- [task](https://github.com/go-task/task): Go로 작성된 YAML 기반 명령어 러너.
- [maid](https://github.com/egoist/maid): JavaScript로 작성된 마크다운 기반 명령어 러너.
- [microsoft/just](https://github.com/microsoft/just): JavaScript로 작성된 JavaScript 기반 명령어 러너.
- [cargo-make](https://github.com/sagiegurari/cargo-make): Rust 프로젝트를 위한 명령어 러너.
- [mmake](https://github.com/tj/mmake): 원격 포함(remote includes)을 비롯한 여러 개선 사항이 적용된 `make` 래퍼.
- [robo](https://github.com/tj/robo): Go로 작성된 YAML 기반 명령어 러너.
- [mask](https://github.com/jakedeichert/mask): Rust로 작성된 마크다운 기반 명령어 러너.
- [makesure](https://github.com/xonixx/makesure): AWK와 셸로 작성된 간단하고 이식성 있는 명령어 러너.
- [haku](https://github.com/VladimirMarkelov/haku): Rust로 작성된 make 유사 명령어 러너.
- [mise](https://mise.jdx.dev/): TOML 파일의 태스크와 독립형 스크립트를 지원하는, Rust로 작성된 개발 환경 도구 매니저.
### 메타데이터
문자열 목록 형태의 메타데이터는 `[metadata(METADATA)]` 속성1.42.0을 사용하여 레시피에 첨부할 수 있습니다:
```just
[metadata("hello", "goodbye")]
foo:
```
메타데이터는 `just --dump --dump-format json`을 사용하여 읽을 수 있습니다.
### `uv`를 사용하는 Python 레시피
[`uv`](https://github.com/astral-sh/uv)는 Rust로 작성된 훌륭한 크로스 플랫폼 파이썬 프로젝트 매니저입니다.
`[script]` 속성과 `script-interpreter` 설정을 사용하면, `just`를 쉽게 설정하여 `uv`로 Python 레시피를 실행할 수 있습니다:
```just
set script-interpreter := ['uv', 'run', '--script']
[script]
hello:
print("Hell

o from Python!")
[script]
goodbye:
# /// script
# requires-python = ">=3.11"
# dependencies=["sh"]
# ///
import sh
print(sh.echo("Goodbye from Python!"), end='')
```
물론 shebang을 사용하는 것도 가능합니다:
```just
hello:
#!/usr/bin/env -S uv run --script
print("Hello from Python!")
```
### 환경 활성화하기
일부 도구는 Python 가상 환경처럼 활성화 단계가 필요합니다:
```sh
. .venv/bin/activate
```
이러한 도구들은 실행 중인 셸의 환경을 수정하기 때문에, `just`가 사용자를 대신하여 이 활성화 단계를 수행할 수는 없습니다. 하지만 몇 가지 우회 방법이 있습니다.
Python 환경 관리를 위한 가장 좋은 우회 방법은 [`uv`](https://docs.astral.sh/uv/)로 전환하는 것입니다. `uv`는 각 명령어에 맞는 올바른 환경을 설정해 주므로 활성화 단계가 필요 없습니다.
그럴 수 없는 경우나 다른 도구의 경우, 공통 프리lude(prelude)를 생성하여 이를 필요로 하는 스크립트 레시피에 포함할 수 있습니다. 이는 여러 줄에 걸쳐 작성할 수 있으며 원하는 만큼의 단계를 포함할 수 있습니다:
```just
prelude := '''
set -eux
. .venv/bin/activate
'''
[script]
run:
{{ prelude }}
python script.py
```
이 우회 방법은 각 명령어마다 새로운 셸을 생성하는 셸 레시피에서는 작동하지 않습니다.
기여하기 (Contributing)
------------
> [!NOTE]
> `just`는 현재 풀 리퀘스트(pull request)를 받고 있지 않습니다. 기여 섹션은 후세를 위해 남겨둡니다.
`just`는 여러분의 기여를 환영합니다! `just`는 가장 허용적인 
[CC0](https://creativecommons.org/publicdomain/zero/1.0/legalcode.txt) 퍼블릭 도메인 기증 및 대체 라이선스로 배포되므로, 여러분의 변경 사항 역시 이 라이선스에 따라 배포되어야 합니다.
### 시작하기
`just`는 Rust로 작성되었습니다. Rust 툴체인을 설치하려면 [rustup](https://www.rust-lang.org/tools/install)을 사용하세요.
`just`는 광범위하게 테스트됩니다. 모든 새로운 기능은 유닛 테스트나 통합 테스트를 거쳐야 합니다. 유닛 테스트는 [src](https://github.com/casey/just/blob/master/src)에 있으며, 테스트 대상 코드와 함께 위치하여 코드를 격리된 상태로 테스트합니다. 통합 테스트는 [tests 디렉토리](https://github.com/casey/just/blob/master/tests)에 있으며, 주어진 `justfile`과 명령줄 인수 세트로 `just`를 실행하고 출력을 확인함으로써 외부에서 `just` 바이너리를 테스트합니다.
여전히 좋은 테스트 커버리지를 제공하면서 작성하기 가장 쉬운 유형의 테스트를 작성하면 됩니다.
유닛 테스트는 내부적으로 사용되는 새로운 Rust 함수를 테스트하고 개발을 돕는 데 유용합니다. 좋은 예로는 삼중 따옴표 문자열과 백틱의 들여쓰기를 해제하는 데 사용되는 [`unindent()` 함수](https://github.com/casey/just/blob/master/src/unindent.rs)를 다루는 유닛 테스트가 있습니다. `unindent()`에는 `unindent()`를 직접 호출하는 유닛 테스트로 쉽게 테스트할 수 있는 까다로운 예외 상황들이 많이 있습니다.
통합 테스트는 `just` 바이너리의 최종 동작이 올바른지 확인하는 데 유용합니다. `unindent()` 역시 삼중 따옴표 문자열을 평가할 때 올바른 들여쓰기 해제 값이 생성되는지 확인하는 통합 테스트의 대상이 됩니다. 하지만 가능한 모든 경우에 대한 통합 테스트가 존재하는 것은 아닙니다. 이러한 부분은 `unindent()`를 직접 호출하는 더 빠르고 간결한 유닛 테스트로 다뤄집니다.
통합 테스트는 주어진 `justfile`, 인수, 환경 변수로 `just`를 쉽게 호출하고 프로그램의 표준 출력(stdout), 표준 에러(stderr), 종료 코드를 확인할 수 있는 빌더인 `Test` 구조체를 사용합니다.
### 기여 워크플로우
1. 해당 기능이 필요한지 확인하세요. 해당 기능이 좋은 아이디어이거나 타당해 보인다는 [@casey](https://github.com/casey)의 코멘트가 달린 열린 이슈가 있어야 합니다. 그렇지 않다면 새 이슈를 열고 피드백을 요청하세요.
역방향 호환성이 없거나, 코드베이스를 지나치게 복잡하게 만드는 구현 방식을 가졌거나, `just`의 디자인 철학에 어긋난다는 이유로 병합될 수 없는 좋은 기능들이 많이 있습니다.
2. 기능의 디자인을 확정하세요. 해당 기능에 여러 가지 가능한 구현 방식이나 문법이 있는 경우, 이슈에서 세부 사항을 확실히 매듭지으세요.
3. `just`를 클론하고 코딩을 시작하세요. 가장 좋은 작업은

flow 방식은 편집기에서 작업 중인 코드를 띄워두고, 파일이 변경될 때마다 테스트를 다시 실행하는 작업을 함께 띄워두는 것입니다. [cargo-watch](https://github.com/watchexec/cargo-watch)를 `cargo install cargo-watch`로 설치하고 `just watch test`를 실행하여 이러한 작업을 수행할 수 있습니다.
4. 기능에 대한 실패하는 테스트를 추가합니다. 대부분의 경우 이는 기능을 엔드투엔드로 검증하는 통합 테스트가 됩니다. 테스트를 배치할 적절한 파일을 [tests](https://github.com/casey/just/blob/master/tests)에서 찾거나, [tests](https://github.com/casey/just/blob/master/tests)에 새 파일을 추가하고 [tests/lib.rs](https://github.com/casey/just/blob/master/tests/lib.rs)에 해당 파일을 가져오는 `mod` 문을 추가하세요.
5. 기능을 구현합니다.
6. 모든 테스트, 린트, 검증이 통과하는지 확인하기 위해 `just ci`를 실행합니다. [mdBook](https://github.com/rust-lang/mdBook)과 [mdbook-linkcheck](https://github.com/Michael-F-Bryan/mdbook-linkcheck)가 필요합니다.
7. 메인이너가 편집할 수 있는 새 코드가 포함된 PR을 엽니다. PR은 종종 리베이스와 사소한 수정이 필요합니다. PR을 메인이너가 편집할 수 없는 경우, 리베이스와 수정마다 코드 리뷰 왕복 과정이 필요하게 됩니다. 메인이너가 편집할 수 없는 PR은 요약된 채로 닫힐 수 있습니다.
8. 피드백을 반영합니다.
9. PR이 병합되는 달콤한 기쁨을 즐기세요!
토론과 피드백을 위해 언제든지 드래프트 PR을 자유롭게 열어주세요.

### 힌트
위의 기여 워크플로와 함께 사용할 수 있는, 특정 종류의 새로운 기능을 시작하는 데 도움을 주는 몇 가지 힌트입니다.

#### 새로운 어트리뷰트 추가하기
1. [tests/attributes.rs](https://github.com/casey/just/blob/master/tests/attributes.rs)에 새로운 통합 테스트를 작성합니다.
2. [`Attribute`](https://github.com/casey/just/blob/master/src/attribute.rs) 열거형(enum)에 새로운 variant를 추가합니다.
3. 새로운 어트리뷰트의 기능을 구현합니다.
4. 모든 테스트가 통과하는지 확인하기 위해 `just ci`를 실행합니다.

### Janus
[Janus](https://github.com/casey/janus)는 `just`의 변경 사항이 기존 `justfile`의 해석을 깨뜨리거나 변경하는지 확인하기 위한 도구입니다. GitHub의 공개된 `justfile`들을 수집하고 분석합니다.
특히 크거나 위험한 변경 사항을 병합하기 전에, 아무것도 깨지지 않는지 확인하기 위해 Janus를 실행해야 합니다. 직접 Janus를 실행하는 것에 대해 걱정하지 마세요. Casey가 필요한 변경 사항에 대해 기꺼이 실행해 줄 것입니다.

### 최소 지원 Rust 버전
최소 지원 Rust 버전(MSRV)은 현재 최신 안정 버전(stable) Rust입니다. 더 오래된 버전의 Rust에서도 빌드될 수 있지만, 이는 보장되지 않습니다.

### 새 릴리스
사용자들이 새로운 기능을 빠르게 접할 수 있도록 `just`의 새 릴리스가 자주 배포됩니다.
릴리스 커밋 메시지는 다음 템플릿을 사용합니다:
```
Release x.y.z
- Bump version: x.y.z → x.y.z
- Update changelog
- Update changelog contributor credits
- Update dependencies
- Update version references in readme
```

자주 묻는 질문 (FAQ)
--------------------------
### Make에서 Just가 피하고자 하는 고유한 특성들은 무엇인가요?
`make`에는 혼란스럽고 복잡하거나, 일반적인 명령어 러너로 사용하기에 부적합하게 만드는 몇 가지 동작들이 있습니다.

한 가지 예로, 특정 상황에서 `make`는 레시피의 명령어를 실제로 실행하지 않습니다. 예를 들어, `test`라는 이름의 파일이 있고 다음과 같은 makefile이 있는 경우를 가정해 보겠습니다:
```just
test:
./test
```
`make`는 테스트 실행을 거부합니다:
```console
$ make test
make: `test' is up to date.
```
`make`는 `test` 레시피가 `test`라는 파일을 생성한다고 가정합니다. 이 파일이 존재하고 레시피에 다른 의존성이 없기 때문에, `make`는 할 일이 없다고 판단하고 종료합니다.

공정하게 말하자면, 이 동작은 `make`를 빌드 시스템으로 사용할 때는 바람직하지만 명령어 러너로 사용할 때는 그렇지 않습니다. `make`의 내장 [`.PHONY` 타겟 이름](https://www.gnu.org/software/make/manual/html\_node/Phony-Targets.html)을 사용하여 특정 타겟에 대해 이 동작을 비활성화할 수 있지만, 구문이 장황하고 기억하기 어려울 수 있습니다. 레시피 정의와 별개로 작성되는 명시적인 phony 타겟 목록은 실수로 이어질 위험도 도입합니다.

새로운 가짜가 아닌(non-phony) 타겟을 정의합니다. `just`에서는 모든
레시피가 마치 가짜인 것처럼 취급됩니다.
`make`의 특이점들에 대한 다른 예시로는 할당 시 `=`과 `:=`의 차이,
makefile을 잘못 작성했을 때 발생하는 혼란스러운 에러 메시지,
레시피에서 환경 변수를 사용하기 위해 `$$`가 필요한 점,
그리고 다양한 `make` 종류 간의 호환성 문제 등이 있습니다.

### Just와 Cargo 빌드 스크립트의 관계는 무엇인가요?

[`cargo` 빌드 스크립트](http://doc.crates.io/build-script.html)는
`cargo`가 Rust 프로젝트를 빌드하는 방식을 제어하는 매우 구체적인 용도가 있습니다.
여기에는 `rustc` 호출에 플래그 추가, 외부 의존성 빌드, 또는 일종의 코드 생성(codegen) 단계 실행 등이 포함될 수 있습니다.

반면에 `just`는 개발 과정의 일환으로 실행할 수 있는 기타 모든 잡다한 명령어들을 위한 것입니다.
다양한 설정에서 테스트 실행, 코드 린트(lint) 검사, 빌드 결과물을 서버에 푸시하기, 임시 파일 제거 등과 같은 작업들이 이에 해당합니다.

또한, `just`는 Rust로 작성되었지만 프로젝트가 사용하는 언어이나 빌드 시스템에 관계없이 사용할 수 있습니다.

### 추가적인 잡담

저는 개인적으로 크고 작은 거의 모든 프로젝트에 `justfile`을 작성하는 것이 매우 유용하다고 생각합니다.

여러 기여자가 참여하는 대형 프로젝트의 경우, 프로젝트 작업에 필요한 모든 명령어가 담긴 파일을 가까운 곳에 두는 것이 매우 유용합니다.

테스트, 빌드, 린트, 배포 등을 위한 다양한 명령어가 있기 마련인데, 이들을 한곳에 모아두면 유용하며 사람들에게 어떤 명령어를 실행해야 하고 어떻게 입력해야 하는지 알려주는 데 소요되는 시간을 줄일 수 있습니다.

또한 명령어를 둘 수 있는 쉬운 장소가 있으면, 프로젝트의 집단 지식의 일부이지만 어디에도 기록되어 있지 않은 유용한 작업들—예컨대 리비전 제어 워크플로우의 특정 부분에 필요한 난해한 명령어들, 프로젝트의 모든 의존성을 설치하는 방법, 또는 빌드 시스템에 전달해야 할 수도 있는 온갖 무작위 플래그들—을 자연스럽게 찾아내게 될 것입니다.

레시피 아이디어:
- 프로젝트 배포/발행
- 릴리스 모드 대 디버그 모드 빌드
- 디버그 모드 또는 로깅이 활성화된 상태로 실행
- 복잡한 git 워크플로우
- 의존성 업데이트
- 다양한 테스트 세트 실행 (예: 빠른 테스트 대 느린 테스트, 또는 상세 출력과 함께 실행)
- 기억해 내기 위해서라도 어딘가에 꼭 적어두어야 할 복잡한 명령어 모음

작고 개인적인 프로젝트의 경우에도 쉘 기록에서 역방향 검색(^Reverse searching)을 하는 대신 이름으로 명령어를 기억할 수 있어서 좋으며, 알 수 없는 빌드 시스템을 가진 낯선 언어로 작성된 오래된 프로젝트에 들어가더라도 필요한 작업을 수행하는 데 필요한 모든 명령어가 `justfile`에 있으며 `just`를 입력하면 유용한(또는 적어도 흥미로운!) 무언가가 실행될 것임을 알 수 있다는 것은 엄청난 이점입니다.

레시피에 대한 아이디어를 얻으려면 [이 프로젝트의 `justfile`](https://github.com/casey/just/blob/master/justfile)이나 [실제 사용 중인](https://github.com/search?q=path%3A\*\*%2Fjustfile&type=code) `justfile`들을 살펴보세요.

아무튼, 이 길고 긴 README는 이것으로 마칠까 합니다.
`just`를 즐겁게 사용하시고 모든 컴퓨팅 작업에서 큰 성공과 만족을 거두시기를 바랍니다!

😸

[🔼 맨 위로 돌아가기!](#just)

just

파일 탐색기

# 설치 가이드

2. Docker

3. Rust

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

just

파일 탐색기

# 설치 가이드

2. Docker

3. Rust

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README