Full Code of casey/just for AI

gitextract_22bxt1ib/

├── .editorconfig
├── .gitattributes
├── .github/
│   └── workflows/
│       ├── ci.yaml
│       └── release.yaml
├── .gitignore
├── CHANGELOG.md
├── CONTRIBUTING.md
├── Cargo.toml
├── GRAMMAR.md
├── LICENSE
├── README.md
├── README.中文.md
├── Vagrantfile
├── bin/
│   ├── forbid
│   └── package
├── book/
│   ├── en/
│   │   └── book.toml
│   └── zh/
│       └── book.toml
├── build.rs
├── clippy.toml
├── completions/
│   ├── just.bash
│   ├── just.elvish
│   ├── just.fish
│   ├── just.nu
│   ├── just.powershell
│   └── just.zsh
├── contrib/
│   └── just.sh
├── crates/
│   ├── generate-book/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   └── update-contributors/
│       ├── Cargo.toml
│       └── src/
│           └── main.rs
├── crates-io-readme.md
├── examples/
│   ├── cross-platform.just
│   ├── keybase.just
│   ├── kitchen-sink.just
│   ├── powershell.just
│   ├── pre-commit.just
│   └── screenshot.just
├── fuzz/
│   ├── Cargo.toml
│   └── fuzz_targets/
│       └── compile.rs
├── justfile
├── rustfmt.toml
├── src/
│   ├── alias.rs
│   ├── alias_style.rs
│   ├── analyzer.rs
│   ├── arg_attribute.rs
│   ├── assignment.rs
│   ├── assignment_resolver.rs
│   ├── ast.rs
│   ├── attribute.rs
│   ├── attribute_set.rs
│   ├── binding.rs
│   ├── color.rs
│   ├── color_display.rs
│   ├── command_color.rs
│   ├── command_ext.rs
│   ├── compilation.rs
│   ├── compile_error.rs
│   ├── compile_error_kind.rs
│   ├── compiler.rs
│   ├── completions.rs
│   ├── condition.rs
│   ├── conditional_operator.rs
│   ├── config.rs
│   ├── config_error.rs
│   ├── const_error.rs
│   ├── constants.rs
│   ├── count.rs
│   ├── delimiter.rs
│   ├── dependency.rs
│   ├── dump_format.rs
│   ├── enclosure.rs
│   ├── error.rs
│   ├── evaluator.rs
│   ├── execution_context.rs
│   ├── executor.rs
│   ├── expression.rs
│   ├── filesystem.rs
│   ├── format_string_part.rs
│   ├── fragment.rs
│   ├── function.rs
│   ├── fuzzing.rs
│   ├── interpreter.rs
│   ├── invocation.rs
│   ├── invocation_parser.rs
│   ├── item.rs
│   ├── justfile.rs
│   ├── keyed.rs
│   ├── keyword.rs
│   ├── lexer.rs
│   ├── lib.rs
│   ├── line.rs
│   ├── list.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/
│   │   ├── unix.rs
│   │   └── windows.rs
│   ├── platform.rs
│   ├── platform_interface.rs
│   ├── position.rs
│   ├── positional.rs
│   ├── ran.rs
│   ├── range_ext.rs
│   ├── recipe.rs
│   ├── recipe_resolver.rs
│   ├── recipe_signature.rs
│   ├── request.rs
│   ├── run.rs
│   ├── scope.rs
│   ├── search.rs
│   ├── search_config.rs
│   ├── search_error.rs
│   ├── set.rs
│   ├── setting.rs
│   ├── settings.rs
│   ├── shebang.rs
│   ├── show_whitespace.rs
│   ├── sigil.rs
│   ├── signal.rs
│   ├── signal_handler.rs
│   ├── signals.rs
│   ├── source.rs
│   ├── string_delimiter.rs
│   ├── string_kind.rs
│   ├── string_literal.rs
│   ├── string_state.rs
│   ├── subcommand.rs
│   ├── suggestion.rs
│   ├── summary.rs
│   ├── switch.rs
│   ├── table.rs
│   ├── testing.rs
│   ├── thunk.rs
│   ├── token.rs
│   ├── token_kind.rs
│   ├── tree.rs
│   ├── unindent.rs
│   ├── unresolved_dependency.rs
│   ├── unresolved_recipe.rs
│   ├── unstable_feature.rs
│   ├── usage.rs
│   ├── use_color.rs
│   ├── variables.rs
│   ├── verbosity.rs
│   ├── warning.rs
│   └── which.rs
├── tests/
│   ├── alias.rs
│   ├── alias_style.rs
│   ├── allow_duplicate_recipes.rs
│   ├── allow_duplicate_variables.rs
│   ├── allow_missing.rs
│   ├── arg_attribute.rs
│   ├── assert_stdout.rs
│   ├── assert_success.rs
│   ├── assertions.rs
│   ├── assignment.rs
│   ├── attributes.rs
│   ├── backticks.rs
│   ├── byte_order_mark.rs
│   ├── ceiling.rs
│   ├── changelog.rs
│   ├── choose.rs
│   ├── command.rs
│   ├── completions/
│   │   ├── just.bash
│   │   ├── justfile
│   │   └── subdir/
│   │       └── justfile
│   ├── 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
│   ├── functions.rs
│   ├── global.rs
│   ├── groups.rs
│   ├── guards.rs
│   ├── ignore_comments.rs
│   ├── imports.rs
│   ├── init.rs
│   ├── interpolation.rs
│   ├── invocation_directory.rs
│   ├── json.rs
│   ├── lazy.rs
│   ├── lib.rs
│   ├── line_prefixes.rs
│   ├── list.rs
│   ├── logical_operators.rs
│   ├── man.rs
│   ├── misc.rs
│   ├── modules.rs
│   ├── multibyte_char.rs
│   ├── newline_escape.rs
│   ├── no_aliases.rs
│   ├── no_cd.rs
│   ├── no_dependencies.rs
│   ├── no_exit_message.rs
│   ├── options.rs
│   ├── os_attributes.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
│   ├── 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
│   ├── 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
└── www/
    ├── .nojekyll
    ├── CNAME
    ├── index.css
    ├── index.html
    └── install.sh

SYMBOL INDEX (2170 symbols across 223 files)

FILE: build.rs
  function main (line 1) | fn main() {

FILE: crates/generate-book/src/main.rs
  type Result (line 13) | type Result<T = ()> = std::result::Result<T, Box<dyn Error>>;
  type Language (line 16) | enum Language {
    method code (line 22) | fn code(&self) -> &'static str {
    method suffix (line 29) | fn suffix(&self) -> &'static str {
    method introduction (line 36) | fn introduction(&self) -> &'static str {
  type Chapter (line 45) | struct Chapter<'a> {
  function title (line 53) | fn title(&self) -> String {
  function filename (line 71) | fn filename(&self) -> String {
  function markdown (line 75) | fn markdown(&self) -> Result<String> {
  function slug (line 85) | fn slug(s: &str) -> String {
  function main (line 98) | fn main() -> Result {

FILE: crates/update-contributors/src/main.rs
  function author (line 6) | fn author(pr: u64) -> String {
  function main (line 25) | fn main() {

FILE: src/alias.rs
  type Alias (line 5) | pub(crate) struct Alias<'src, T = Arc<Recipe<'src>>> {
  function resolve (line 16) | pub(crate) fn resolve(self, target: Arc<Recipe<'src>>) -> Alias<'src> {
  function is_public (line 28) | pub(crate) fn is_public(&self) -> bool {
  function key (line 35) | fn key(&self) -> &'src str {
  method fmt (line 41) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  method fmt (line 47) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/alias_style.rs
  type AliasStyle (line 4) | pub(crate) enum AliasStyle {

FILE: src/analyzer.rs
  type Analyzer (line 4) | pub(crate) struct Analyzer<'run, 'src> {
  function analyze (line 15) | pub(crate) fn analyze(
  function justfile (line 32) | fn justfile(
  function define (line 299) | fn define(
  function analyze_recipe (line 327) | fn analyze_recipe(recipe: &UnresolvedRecipe<'src>) -> CompileResult<'src> {
  function analyze_set (line 383) | fn analyze_set(&self, set: &Set<'src>) -> CompileResult<'src> {
  function resolve_alias (line 394) | fn resolve_alias<'a>(
  function resolve_recipe (line 408) | pub(crate) fn resolve_recipe<'a>(

FILE: src/arg_attribute.rs
  type ArgAttribute (line 3) | pub(crate) struct ArgAttribute<'src> {

FILE: src/assignment.rs
  type Assignment (line 4) | pub(crate) type Assignment<'src> = Binding<'src, Expression<'src>>;
  method fmt (line 7) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/assignment_resolver.rs
  type AssignmentResolver (line 3) | pub(crate) struct AssignmentResolver<'src: 'run, 'run> {
  function resolve_assignments (line 10) | pub(crate) fn resolve_assignments(
  function resolve_assignment (line 26) | fn resolve_assignment(&mut self, assignment: &Assignment<'src>) -> Compi...

FILE: src/ast.rs
  type Ast (line 7) | pub(crate) struct Ast<'src> {
  method fmt (line 16) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/attribute.rs
  type Attribute (line 12) | pub(crate) enum Attribute<'src> {
  method argument_range (line 50) | fn argument_range(self) -> RangeInclusive<usize> {
  function check_option_name (line 78) | fn check_option_name(
  function new (line 101) | pub(crate) fn new(
  function remove_required (line 236) | fn remove_required(
  function discriminant (line 250) | pub(crate) fn discriminant(&self) -> AttributeDiscriminant {
  function name (line 254) | pub(crate) fn name(&self) -> &'static str {
  function repeatable (line 258) | pub(crate) fn repeatable(&self) -> bool {
  method fmt (line 267) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function name (line 351) | fn name() {

FILE: src/attribute_set.rs
  type AttributeSet (line 4) | pub(crate) struct AttributeSet<'src>(BTreeSet<Attribute<'src>>);
  function len (line 7) | pub(crate) fn len(&self) -> usize {
  function contains (line 11) | pub(crate) fn contains(&self, target: AttributeDiscriminant) -> bool {
  function get (line 15) | pub(crate) fn get(&self, discriminant: AttributeDiscriminant) -> Option<...
  function iter (line 22) | pub(crate) fn iter<'a>(&'a self) -> collections::btree_set::Iter<'a, Att...
  function ensure_valid_attributes (line 26) | pub(crate) fn ensure_valid_attributes(
  function from_iter (line 47) | fn from_iter<T: IntoIterator<Item = attribute::Attribute<'src>>>(iter: T...
  type Item (line 53) | type Item = &'a Attribute<'src>;
  type IntoIter (line 55) | type IntoIter = collections::btree_set::Iter<'a, Attribute<'src>>;
  method into_iter (line 57) | fn into_iter(self) -> Self::IntoIter {
  type Item (line 63) | type Item = Attribute<'src>;
  type IntoIter (line 65) | type IntoIter = collections::btree_set::IntoIter<Attribute<'src>>;
  method into_iter (line 67) | fn into_iter(self) -> Self::IntoIter {

FILE: src/binding.rs
  type Binding (line 5) | pub(crate) struct Binding<'src, V = String> {
  function key (line 20) | fn key(&self) -> &'src str {

FILE: src/color.rs
  type Color (line 8) | pub(crate) struct Color {
    method active (line 15) | pub(crate) fn active(&self) -> bool {
    method alias (line 23) | pub(crate) fn alias(self) -> Self {
    method always (line 27) | pub(crate) fn always() -> Self {
    method annotation (line 34) | pub(crate) fn annotation(self) -> Self {
    method auto (line 38) | pub(crate) fn auto() -> Self {
    method banner (line 42) | pub(crate) fn banner(self) -> Self {
    method command (line 46) | pub(crate) fn command(self, foreground: Option<ansi_term::Color>) -> S...
    method context (line 54) | pub(crate) fn context(self) -> Self {
    method diff_added (line 58) | pub(crate) fn diff_added(self) -> Self {
    method diff_deleted (line 62) | pub(crate) fn diff_deleted(self) -> Self {
    method doc (line 66) | pub(crate) fn doc(self) -> Self {
    method doc_backtick (line 70) | pub(crate) fn doc_backtick(self) -> Self {
    method effective_style (line 74) | fn effective_style(&self) -> Style {
    method error (line 82) | pub(crate) fn error(self) -> Self {
    method group (line 86) | pub(crate) fn group(self) -> Self {
    method message (line 90) | pub(crate) fn message(self) -> Self {
    method never (line 94) | pub(crate) fn never() -> Self {
    method paint (line 101) | pub(crate) fn paint<'a>(&self, text: &'a str) -> ANSIGenericString<'a,...
    method parameter (line 105) | pub(crate) fn parameter(self) -> Self {
    method prefix (line 109) | pub(crate) fn prefix(&self) -> Prefix {
    method redirect (line 113) | fn redirect(self, stream: impl IsTerminal) -> Self {
    method restyle (line 120) | fn restyle(self, style: Style) -> Self {
    method stderr (line 124) | pub(crate) fn stderr(self) -> Self {
    method stdout (line 128) | pub(crate) fn stdout(self) -> Self {
    method string (line 132) | pub(crate) fn string(self) -> Self {
    method suffix (line 136) | pub(crate) fn suffix(&self) -> Suffix {
    method warning (line 140) | pub(crate) fn warning(self) -> Self {
    method heading (line 144) | pub(crate) fn heading(self) -> Self {
    method option (line 148) | pub(crate) fn option(self) -> Self {
    method argument (line 152) | pub(crate) fn argument(self) -> Self {
    method from (line 158) | fn from(use_color: UseColor) -> Self {
  method default (line 167) | fn default() -> Self {

FILE: src/color_display.rs
  type ColorDisplay (line 3) | pub(crate) trait ColorDisplay {
    method color_display (line 4) | fn color_display(&self, color: Color) -> Wrapper
    method fmt (line 11) | fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result;
  type Wrapper (line 14) | pub(crate) struct Wrapper<'a>(&'a dyn ColorDisplay, Color);
  method fmt (line 17) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/command_color.rs
  type CommandColor (line 4) | pub(crate) enum CommandColor {
  function from (line 15) | fn from(command_color: CommandColor) -> Self {

FILE: src/command_ext.rs
  type CommandExt (line 3) | pub(crate) trait CommandExt {
    method export (line 4) | fn export(
    method export_scope (line 12) | fn export_scope(&mut self, settings: &Settings, scope: &Scope, unexpor...
    method output_guard (line 14) | fn output_guard(self) -> (io::Result<process::Output>, Option<Signal>);
    method output_guard_stdout (line 16) | fn output_guard_stdout(self) -> Result<String, OutputError>;
    method status_guard (line 18) | fn status_guard(self) -> (io::Result<ExitStatus>, Option<Signal>);
    method export (line 22) | fn export(
    method export_scope (line 40) | fn export_scope(&mut self, settings: &Settings, scope: &Scope, unexpor...
    method output_guard (line 56) | fn output_guard(self) -> (io::Result<process::Output>, Option<Signal>) {
    method output_guard_stdout (line 60) | fn output_guard_stdout(self) -> Result<String, OutputError> {
    method status_guard (line 82) | fn status_guard(self) -> (io::Result<ExitStatus>, Option<Signal>) {

FILE: src/compilation.rs
  type Compilation (line 4) | pub(crate) struct Compilation<'src> {
  function root_ast (line 12) | pub(crate) fn root_ast(&self) -> &Ast<'src> {

FILE: src/compile_error.rs
  type CompileError (line 4) | pub(crate) struct CompileError<'src> {
  function context (line 10) | pub(crate) fn context(&self) -> Token<'src> {
  function new (line 14) | pub(crate) fn new(token: Token<'src>, kind: CompileErrorKind<'src>) -> S...
  function source (line 21) | pub(crate) fn source(&self) -> Option<&dyn std::error::Error> {
  function capitalize (line 29) | fn capitalize(s: &str) -> String {
  method fmt (line 38) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/compile_error_kind.rs
  type CompileErrorKind (line 4) | pub(crate) enum CompileErrorKind<'src> {

FILE: src/compiler.rs
  type Compiler (line 3) | pub(crate) struct Compiler;
    method compile (line 6) | pub(crate) fn compile<'src>(
    method find_module_file (line 117) | fn find_module_file<'src>(
    method expand_tilde (line 213) | fn expand_tilde(path: &str) -> RunResult<'static, PathBuf> {
    method test_compile (line 224) | pub(crate) fn test_compile(src: &str) -> RunResult<Justfile> {
  function recursive_includes_fail (line 252) | fn recursive_includes_fail() {
  function find_module_file (line 273) | fn find_module_file() {

FILE: src/completions.rs
  type Shell (line 4) | pub(crate) enum Shell {
    method script (line 15) | pub(crate) fn script(self) -> &'static str {
  function scripts (line 37) | fn scripts() {
  function clap (line 62) | fn clap(shell: clap_complete::Shell) -> String {
  constant FISH_RECIPE_COMPLETIONS (line 117) | const FISH_RECIPE_COMPLETIONS: &str = r#"function __fish_just_complete_r...
  constant ZSH_COMPLETION_REPLACEMENTS (line 133) | const ZSH_COMPLETION_REPLACEMENTS: &[(&str, &str)] = &[
  constant POWERSHELL_COMPLETION_REPLACEMENTS (line 247) | const POWERSHELL_COMPLETION_REPLACEMENTS: &[(&str, &str)] = &[(
  constant BASH_COMPLETION_REPLACEMENTS (line 274) | const BASH_COMPLETION_REPLACEMENTS: &[(&str, &str)] = &[

FILE: src/condition.rs
  type Condition (line 4) | pub(crate) struct Condition<'src> {
  method fmt (line 11) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  method serialize (line 17) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: src/conditional_operator.rs
  type ConditionalOperator (line 5) | pub(crate) enum ConditionalOperator {
  method fmt (line 17) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/config.rs
  type Config (line 15) | pub(crate) struct Config {
    method app (line 142) | pub(crate) fn app() -> Command {
    method parse_modulepath (line 649) | fn parse_modulepath(values: ValuesRef<String>) -> ConfigResult<Modulep...
    method search_config (line 666) | fn search_config(matches: &ArgMatches, positional: &Positional) -> Con...
    method timestamp (line 699) | pub(crate) fn timestamp(&self) -> Option<String> {
    method parse_override (line 707) | fn parse_override(path: &str) -> ConfigResult<(Modulepath, String)> {
    method from_matches (line 716) | pub(crate) fn from_matches(matches: &ArgMatches) -> ConfigResult<Self> {
    method require_unstable (line 915) | pub(crate) fn require_unstable(
  constant CHANGELOG (line 53) | pub(crate) const CHANGELOG: &str = "CHANGELOG";
  constant CHOOSE (line 54) | pub(crate) const CHOOSE: &str = "CHOOSE";
  constant COMMAND (line 55) | pub(crate) const COMMAND: &str = "COMMAND";
  constant COMPLETIONS (line 56) | pub(crate) const COMPLETIONS: &str = "COMPLETIONS";
  constant DUMP (line 57) | pub(crate) const DUMP: &str = "DUMP";
  constant EDIT (line 58) | pub(crate) const EDIT: &str = "EDIT";
  constant EVALUATE (line 59) | pub(crate) const EVALUATE: &str = "EVALUATE";
  constant FORMAT (line 60) | pub(crate) const FORMAT: &str = "FORMAT";
  constant GROUPS (line 61) | pub(crate) const GROUPS: &str = "GROUPS";
  constant INIT (line 62) | pub(crate) const INIT: &str = "INIT";
  constant JSON (line 63) | pub(crate) const JSON: &str = "JSON";
  constant LIST (line 64) | pub(crate) const LIST: &str = "LIST";
  constant MAN (line 65) | pub(crate) const MAN: &str = "MAN";
  constant REQUEST (line 66) | pub(crate) const REQUEST: &str = "REQUEST";
  constant SHOW (line 67) | pub(crate) const SHOW: &str = "SHOW";
  constant SUMMARY (line 68) | pub(crate) const SUMMARY: &str = "SUMMARY";
  constant USAGE (line 69) | pub(crate) const USAGE: &str = "USAGE";
  constant VARIABLES (line 70) | pub(crate) const VARIABLES: &str = "VARIABLES";
  constant ALL (line 72) | pub(crate) const ALL: &[&str] = &[
  constant ARGLESS (line 91) | pub(crate) const ARGLESS: &[&str] = &[
  constant HEADING (line 95) | pub(crate) const HEADING: &str = "Commands";
  constant ALIAS_STYLE (line 99) | pub(crate) const ALIAS_STYLE: &str = "ALIAS_STYLE";
  constant ALLOW_MISSING (line 100) | pub(crate) const ALLOW_MISSING: &str = "ALLOW-MISSING";
  constant ARGUMENTS (line 101) | pub(crate) const ARGUMENTS: &str = "ARGUMENTS";
  constant CEILING (line 102) | pub(crate) const CEILING: &str = "CEILING";
  constant CHECK (line 103) | pub(crate) const CHECK: &str = "CHECK";
  constant CHOOSER (line 104) | pub(crate) const CHOOSER: &str = "CHOOSER";
  constant CLEAR_SHELL_ARGS (line 105) | pub(crate) const CLEAR_SHELL_ARGS: &str = "CLEAR-SHELL-ARGS";
  constant COLOR (line 106) | pub(crate) const COLOR: &str = "COLOR";
  constant COMMAND_COLOR (line 107) | pub(crate) const COMMAND_COLOR: &str = "COMMAND-COLOR";
  constant CYGPATH (line 108) | pub(crate) const CYGPATH: &str = "CYGPATH";
  constant DOTENV_FILENAME (line 109) | pub(crate) const DOTENV_FILENAME: &str = "DOTENV-FILENAME";
  constant DOTENV_PATH (line 110) | pub(crate) const DOTENV_PATH: &str = "DOTENV-PATH";
  constant DRY_RUN (line 111) | pub(crate) const DRY_RUN: &str = "DRY-RUN";
  constant DUMP_FORMAT (line 112) | pub(crate) const DUMP_FORMAT: &str = "DUMP-FORMAT";
  constant EXPLAIN (line 113) | pub(crate) const EXPLAIN: &str = "EXPLAIN";
  constant GLOBAL_JUSTFILE (line 114) | pub(crate) const GLOBAL_JUSTFILE: &str = "GLOBAL-JUSTFILE";
  constant HIGHLIGHT (line 115) | pub(crate) const HIGHLIGHT: &str = "HIGHLIGHT";
  constant JUSTFILE (line 116) | pub(crate) const JUSTFILE: &str = "JUSTFILE";
  constant GROUP (line 117) | pub(crate) const GROUP: &str = "GROUP";
  constant LIST_HEADING (line 118) | pub(crate) const LIST_HEADING: &str = "LIST-HEADING";
  constant LIST_PREFIX (line 119) | pub(crate) const LIST_PREFIX: &str = "LIST-PREFIX";
  constant LIST_SUBMODULES (line 120) | pub(crate) const LIST_SUBMODULES: &str = "LIST-SUBMODULES";
  constant NO_ALIASES (line 121) | pub(crate) const NO_ALIASES: &str = "NO-ALIASES";
  constant NO_DEPS (line 122) | pub(crate) const NO_DEPS: &str = "NO-DEPS";
  constant NO_DOTENV (line 123) | pub(crate) const NO_DOTENV: &str = "NO-DOTENV";
  constant NO_HIGHLIGHT (line 124) | pub(crate) const NO_HIGHLIGHT: &str = "NO-HIGHLIGHT";
  constant ONE (line 125) | pub(crate) const ONE: &str = "ONE";
  constant QUIET (line 126) | pub(crate) const QUIET: &str = "QUIET";
  constant SET (line 127) | pub(crate) const SET: &str = "SET";
  constant SHELL (line 128) | pub(crate) const SHELL: &str = "SHELL";
  constant SHELL_ARG (line 129) | pub(crate) const SHELL_ARG: &str = "SHELL-ARG";
  constant SHELL_COMMAND (line 130) | pub(crate) const SHELL_COMMAND: &str = "SHELL-COMMAND";
  constant TEMPDIR (line 131) | pub(crate) const TEMPDIR: &str = "TEMPDIR";
  constant TIMESTAMP (line 132) | pub(crate) const TIMESTAMP: &str = "TIMESTAMP";
  constant TIMESTAMP_FORMAT (line 133) | pub(crate) const TIMESTAMP_FORMAT: &str = "TIMESTAMP-FORMAT";
  constant UNSORTED (line 134) | pub(crate) const UNSORTED: &str = "UNSORTED";
  constant UNSTABLE (line 135) | pub(crate) const UNSTABLE: &str = "UNSTABLE";
  constant VERBOSE (line 136) | pub(crate) const VERBOSE: &str = "VERBOSE";
  constant WORKING_DIRECTORY (line 137) | pub(crate) const WORKING_DIRECTORY: &str = "WORKING-DIRECTORY";
  constant YES (line 138) | pub(crate) const YES: &str = "YES";
  function test (line 984) | fn test(arguments: &[&str], want: Config) {

FILE: src/config_error.rs
  type ConfigError (line 5) | pub(crate) enum ConfigError {
    method internal (line 56) | pub(crate) fn internal(message: impl Into<String>) -> Self {

FILE: src/const_error.rs
  type ConstError (line 4) | pub(crate) enum ConstError<'src> {
  function context (line 11) | pub(crate) fn context(self) -> Token<'src> {
  method fmt (line 20) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/constants.rs
  constant CONSTANTS (line 3) | const CONSTANTS: &[(&str, &str, Option<&str>, &str)] = &[
  function constants (line 35) | pub(crate) fn constants() -> &'static BTreeMap<&'static str, &'static st...
  function readme_table (line 61) | fn readme_table() {

FILE: src/count.rs
  type Count (line 3) | pub(crate) struct Count<T: Display>(pub T, pub usize);
  method fmt (line 6) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function count (line 20) | fn count() {

FILE: src/delimiter.rs
  type Delimiter (line 4) | pub(crate) enum Delimiter {
    method open (line 12) | pub(crate) fn open(self) -> char {
    method close (line 20) | pub(crate) fn close(self) -> char {

FILE: src/dependency.rs
  type Dependency (line 4) | pub(crate) struct Dependency<'src> {
  function flatten_arguments (line 11) | fn flatten_arguments<S: Serializer>(
  method fmt (line 26) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/dump_format.rs
  type DumpFormat (line 4) | pub(crate) enum DumpFormat {

FILE: src/enclosure.rs
  type Enclosure (line 3) | pub(crate) struct Enclosure<T: Display> {
  function tick (line 9) | pub(crate) fn tick(value: T) -> Self {
  method fmt (line 18) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function tick (line 28) | fn tick() {

FILE: src/error.rs
  type Error (line 4) | pub(crate) enum Error<'src> {
  function code (line 261) | pub(crate) fn code(&self) -> Option<i32> {
  function context (line 284) | fn context(&self) -> Option<Token<'src>> {
  function internal (line 299) | pub(crate) fn internal(message: impl Into<String>) -> Self {
  function print_message (line 305) | pub(crate) fn print_message(&self) -> bool {
  function source (line 315) | fn source(&self) -> Option<&dyn std::error::Error> {
  function from (line 324) | fn from(compile_error: CompileError<'src>) -> Self {
  function from (line 330) | fn from(config_error: ConfigError) -> Self {
  function from (line 336) | fn from(const_error: ConstError<'src>) -> Self {
  function from (line 342) | fn from(search_error: SearchError) -> Self {
  method fmt (line 348) | fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
  function format_cmd (line 845) | fn format_cmd(binary: &OsString, arguments: &Vec<OsString>) -> String {

FILE: src/evaluator.rs
  type Evaluator (line 3) | pub(crate) struct Evaluator<'src: 'run, 'run> {
  function context (line 14) | fn context(
  function evaluate_settings (line 21) | pub(crate) fn evaluate_settings(
  function evaluate_sets (line 48) | fn evaluate_sets(&mut self, sets: Table<'src, Set<'src>>) -> RunResult<'...
  function evaluate_interpreter (line 125) | pub(crate) fn evaluate_interpreter(
  function evaluate_assignments (line 139) | pub(crate) fn evaluate_assignments(
  function evaluate_assignment (line 182) | fn evaluate_assignment(&mut self, assignment: &Assignment<'src>) -> RunR...
  function function_context (line 210) | fn function_context(&self, thunk: &Thunk<'src>) -> RunResult<'src, funct...
  function evaluate_expression (line 219) | pub(crate) fn evaluate_expression(
  function evaluate_condition (line 397) | fn evaluate_condition(&mut self, condition: &Condition<'src>) -> RunResu...
  function run_command (line 413) | pub(crate) fn run_command(
  function evaluate_line (line 447) | pub(crate) fn evaluate_line(
  function evaluate_parameters (line 474) | pub(crate) fn evaluate_parameters(
  function new (line 546) | pub(crate) fn new(

FILE: src/execution_context.rs
  type ExecutionContext (line 4) | pub(crate) struct ExecutionContext<'src: 'run, 'run> {
  function tempdir (line 12) | pub(crate) fn tempdir<D>(&self, recipe: &Recipe<'src, D>) -> RunResult<'...
  function working_directory (line 42) | pub(crate) fn working_directory(&self) -> PathBuf {

FILE: src/executor.rs
  type Executor (line 3) | pub(crate) enum Executor<'a> {
  function command (line 9) | pub(crate) fn command<'src>(
  function script_filename (line 50) | pub(crate) fn script_filename(&self, recipe: &str, extension: Option<&st...
  function error (line 67) | pub(crate) fn error<'src>(&self, io_error: io::Error, recipe: &'src str)...
  function script (line 94) | pub(crate) fn script<D>(&self, recipe: &Recipe<D>, lines: &[String]) -> ...
  function shebang_script_filename (line 133) | fn shebang_script_filename() {

FILE: src/expression.rs
  type Expression (line 10) | pub(crate) enum Expression<'src> {
  function variables (line 55) | pub(crate) fn variables<'expression>(&'expression self) -> Variables<'ex...
  method fmt (line 61) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  method serialize (line 104) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: src/filesystem.rs
  function is_file (line 3) | pub(crate) fn is_file(path: &Path) -> RunResult<'static, bool> {

FILE: src/format_string_part.rs
  type FormatStringPart (line 2) | pub(crate) enum FormatStringPart {

FILE: src/fragment.rs
  type Fragment (line 5) | pub(crate) enum Fragment<'src> {
  method serialize (line 13) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: src/function.rs
  type Function (line 13) | pub(crate) enum Function {
    method argc (line 119) | pub(crate) fn argc(&self) -> RangeInclusive<usize> {
  type Context (line 23) | pub(crate) struct Context<'src: 'run, 'run> {
  function get (line 30) | pub(crate) fn get(name: &str) -> Option<Function> {
  function absolute_path (line 132) | fn absolute_path(context: Context, path: &str) -> FunctionResult {
  function append (line 147) | fn append(_context: Context, suffix: &str, s: &str) -> FunctionResult {
  function arch (line 156) | fn arch(_context: Context) -> FunctionResult {
  function blake3 (line 160) | fn blake3(_context: Context, s: &str) -> FunctionResult {
  function blake3_file (line 164) | fn blake3_file(context: Context, path: &str) -> FunctionResult {
  function canonicalize (line 173) | fn canonicalize(context: Context, path: &str) -> FunctionResult {
  function capitalize (line 185) | fn capitalize(_context: Context, s: &str) -> FunctionResult {
  function choose (line 197) | fn choose(_context: Context, n: &str, alphabet: &str) -> FunctionResult {
  function clean (line 223) | fn clean(_context: Context, path: &str) -> FunctionResult {
  function dir (line 227) | fn dir(name: &'static str, f: fn() -> Option<PathBuf>) -> FunctionResult {
  function datetime (line 243) | fn datetime(_context: Context, format: &str) -> FunctionResult {
  function datetime_utc (line 247) | fn datetime_utc(_context: Context, format: &str) -> FunctionResult {
  function encode_uri_component (line 251) | fn encode_uri_component(_context: Context, s: &str) -> FunctionResult {
  function env (line 265) | fn env(context: Context, key: &str, default: Option<&str>) -> FunctionRe...
  function env_var (line 272) | fn env_var(context: Context, key: &str) -> FunctionResult {
  function env_var_or_default (line 288) | fn env_var_or_default(context: Context, key: &str, default: &str) -> Fun...
  function error (line 304) | fn error(_context: Context, message: &str) -> FunctionResult {
  function extension (line 308) | fn extension(_context: Context, path: &str) -> FunctionResult {
  function file_name (line 315) | fn file_name(_context: Context, path: &str) -> FunctionResult {
  function file_stem (line 322) | fn file_stem(_context: Context, path: &str) -> FunctionResult {
  function invocation_directory (line 329) | fn invocation_directory(context: Context) -> FunctionResult {
  function invocation_directory_native (line 338) | fn invocation_directory_native(context: Context) -> FunctionResult {
  function is_dependency (line 357) | fn is_dependency(context: Context) -> FunctionResult {
  function prepend (line 361) | fn prepend(_context: Context, prefix: &str, s: &str) -> FunctionResult {
  function join (line 370) | fn join(_context: Context, base: &str, with: &str, and: &[String]) -> Fu...
  function just_executable (line 378) | fn just_executable(_context: Context) -> FunctionResult {
  function just_pid (line 390) | fn just_pid(_context: Context) -> FunctionResult {
  function justfile (line 394) | fn justfile(context: Context) -> FunctionResult {
  function justfile_directory (line 409) | fn justfile_directory(context: Context) -> FunctionResult {
  function kebabcase (line 433) | fn kebabcase(_context: Context, s: &str) -> FunctionResult {
  function lowercamelcase (line 437) | fn lowercamelcase(_context: Context, s: &str) -> FunctionResult {
  function lowercase (line 441) | fn lowercase(_context: Context, s: &str) -> FunctionResult {
  function module_directory (line 445) | fn module_directory(context: Context) -> FunctionResult {
  function module_file (line 455) | fn module_file(context: Context) -> FunctionResult {
  function num_cpus (line 465) | fn num_cpus(_context: Context) -> FunctionResult {
  function os (line 470) | fn os(_context: Context) -> FunctionResult {
  function os_family (line 474) | fn os_family(_context: Context) -> FunctionResult {
  function parent_directory (line 478) | fn parent_directory(_context: Context, path: &str) -> FunctionResult {
  function path_exists (line 485) | fn path_exists(context: Context, path: &str) -> FunctionResult {
  function quote (line 496) | fn quote(_context: Context, s: &str) -> FunctionResult {
  function read (line 500) | fn read(context: Context, filename: &str) -> FunctionResult {
  function replace (line 505) | fn replace(_context: Context, s: &str, from: &str, to: &str) -> Function...
  function require (line 509) | fn require(context: Context, name: &str) -> FunctionResult {
  function replace_regex (line 513) | fn replace_regex(_context: Context, s: &str, regex: &str, replacement: &...
  function sha256 (line 522) | fn sha256(_context: Context, s: &str) -> FunctionResult {
  function sha256_file (line 530) | fn sha256_file(context: Context, path: &str) -> FunctionResult {
  function shell (line 542) | fn shell(context: Context, command: &str, args: &[String]) -> FunctionRe...
  function shoutykebabcase (line 557) | fn shoutykebabcase(_context: Context, s: &str) -> FunctionResult {
  function shoutysnakecase (line 561) | fn shoutysnakecase(_context: Context, s: &str) -> FunctionResult {
  function snakecase (line 565) | fn snakecase(_context: Context, s: &str) -> FunctionResult {
  function source_directory (line 569) | fn source_directory(context: Context) -> FunctionResult {
  function source_file (line 589) | fn source_file(context: Context) -> FunctionResult {
  function style (line 607) | fn style(context: Context, s: &str) -> FunctionResult {
  function titlecase (line 621) | fn titlecase(_context: Context, s: &str) -> FunctionResult {
  function trim (line 625) | fn trim(_context: Context, s: &str) -> FunctionResult {
  function trim_end (line 629) | fn trim_end(_context: Context, s: &str) -> FunctionResult {
  function trim_end_match (line 633) | fn trim_end_match(_context: Context, s: &str, pat: &str) -> FunctionResu...
  function trim_end_matches (line 637) | fn trim_end_matches(_context: Context, s: &str, pat: &str) -> FunctionRe...
  function trim_start (line 641) | fn trim_start(_context: Context, s: &str) -> FunctionResult {
  function trim_start_match (line 645) | fn trim_start_match(_context: Context, s: &str, pat: &str) -> FunctionRe...
  function trim_start_matches (line 649) | fn trim_start_matches(_context: Context, s: &str, pat: &str) -> Function...
  function uppercamelcase (line 653) | fn uppercamelcase(_context: Context, s: &str) -> FunctionResult {
  function uppercase (line 657) | fn uppercase(_context: Context, s: &str) -> FunctionResult {
  function uuid (line 661) | fn uuid(_context: Context) -> FunctionResult {
  function which (line 665) | fn which(context: Context, name: &str) -> FunctionResult {
  function without_extension (line 669) | fn without_extension(_context: Context, path: &str) -> FunctionResult {
  function semver_matches (line 683) | fn semver_matches(_context: Context, version: &str, requirement: &str) -...
  function dir_not_found (line 702) | fn dir_not_found() {
  function dir_not_unicode (line 708) | fn dir_not_unicode() {

FILE: src/fuzzing.rs
  function compile (line 3) | pub fn compile(text: &str) {

FILE: src/interpreter.rs
  type Interpreter (line 4) | pub(crate) struct Interpreter<T> {
  function default_script_interpreter (line 10) | pub(crate) fn default_script_interpreter() -> &'static Self {
  method fmt (line 20) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/invocation.rs
  type Invocation (line 4) | pub(crate) struct Invocation<'src, 'run> {

FILE: src/invocation_parser.rs
  type InvocationParser (line 20) | pub(crate) struct InvocationParser<'src: 'run, 'run> {
  function parse_invocations (line 27) | pub(crate) fn parse_invocations(
  function parse_invocation (line 50) | fn parse_invocation(&mut self) -> RunResult<'src, Invocation<'src, 'run>> {
  function resolve_recipe (line 249) | fn resolve_recipe(
  function next (line 299) | fn next(&self) -> Option<&'run str> {
  function rest (line 303) | fn rest(&self) -> &[&'run str] {
  type TempDirExt (line 312) | trait TempDirExt {
    method write (line 313) | fn write(&self, path: &str, content: &str);
    method write (line 317) | fn write(&self, path: &str, content: &str) {
  function single_no_arguments (line 325) | fn single_no_arguments() {
  function single_with_argument (line 336) | fn single_with_argument() {
  function single_argument_count_mismatch (line 347) | fn single_argument_count_mismatch() {
  function single_unknown (line 363) | fn single_unknown() {
  function multiple_unknown (line 376) | fn multiple_unknown() {
  function recipe_in_submodule (line 389) | fn recipe_in_submodule() {
  function recipe_in_submodule_unknown (line 407) | fn recipe_in_submodule_unknown() {
  function recipe_in_submodule_path_unknown (line 426) | fn recipe_in_submodule_path_unknown() {
  function module_path_not_consumed (line 449) | fn module_path_not_consumed() {
  function no_recipes (line 471) | fn no_recipes() {
  function default_recipe_requires_arguments (line 490) | fn default_recipe_requires_arguments() {
  function no_default_recipe (line 512) | fn no_default_recipe() {
  function complex_grouping (line 532) | fn complex_grouping() {
  function long_argument (line 572) | fn long_argument() {
  function long_argument_with_positional (line 589) | fn long_argument_with_positional() {
  function long_argument_terminator (line 609) | fn long_argument_terminator() {

FILE: src/item.rs
  type Item (line 5) | pub(crate) enum Item<'src> {
  method fmt (line 31) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/justfile.rs
  type Justfile (line 4) | pub(crate) struct Justfile<'src> {
  function find_suggestion (line 32) | fn find_suggestion(
  function suggest_recipe (line 43) | pub(crate) fn suggest_recipe(&self, input: &str) -> Option<Suggestion<'s...
  function suggest_variable (line 67) | pub(crate) fn suggest_variable(&self, input: &str) -> Option<Suggestion<...
  function evaluate_scopes (line 77) | fn evaluate_scopes<'run>(
  function run (line 117) | pub(crate) fn run(
  function check_unstable (line 303) | pub(crate) fn check_unstable(&self, config: &Config) -> RunResult<'src> {
  function get_alias (line 315) | pub(crate) fn get_alias(&self, name: &str) -> Option<&Alias<'src>> {
  function get_recipe (line 319) | pub(crate) fn get_recipe(&self, name: &str) -> Option<&Recipe<'src>> {
  function is_submodule (line 327) | pub(crate) fn is_submodule(&self) -> bool {
  function name (line 331) | pub(crate) fn name(&self) -> &'src str {
  function run_recipe (line 335) | fn run_recipe(
  function run_dependencies (line 414) | fn run_dependencies<'run>(
  function public_modules (line 470) | pub(crate) fn public_modules(&self, config: &Config) -> Vec<&Justfile> {
  function public_recipes (line 489) | pub(crate) fn public_recipes(&self, config: &Config) -> Vec<&Recipe> {
  function groups (line 504) | pub(crate) fn groups(&self) -> Vec<&str> {
  function public_groups (line 512) | pub(crate) fn public_groups(&self, config: &Config) -> Vec<String> {
  method fmt (line 544) | fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
  function key (line 575) | fn key(&self) -> &'src str {
  function case (line 795) | fn case(input: &str, expected: &str) {
  function parse_empty (line 805) | fn parse_empty() {
  function parse_string_default (line 818) | fn parse_string_default() {
  function parse_multiple (line 831) | fn parse_multiple() {
  function parse_variadic (line 843) | fn parse_variadic() {
  function parse_variadic_string_default (line 856) | fn parse_variadic_string_default() {
  function parse_raw_string_default (line 869) | fn parse_raw_string_default() {
  function parse_export (line 882) | fn parse_export() {
  function parse_alias_after_target (line 893) | fn parse_alias_after_target() {
  function parse_alias_before_target (line 908) | fn parse_alias_before_target() {
  function parse_alias_with_comment (line 923) | fn parse_alias_with_comment() {
  function parse_complex (line 938) | fn parse_complex() {
  function parse_shebang (line 978) | fn parse_shebang() {
  function parse_simple_shebang (line 999) | fn parse_simple_shebang() {
  function parse_assignments (line 1004) | fn parse_assignments() {
  function parse_assignment_backticks (line 1019) | fn parse_assignment_backticks() {
  function parse_interpolation_backticks (line 1033) | fn parse_interpolation_backticks() {
  function eof_test (line 1043) | fn eof_test() {
  function string_quote_escape (line 1048) | fn string_quote_escape() {
  function string_escapes (line 1053) | fn string_escapes() {
  function parameters (line 1058) | fn parameters() {
  function unary_functions (line 1068) | fn unary_functions() {
  function env_functions (line 1083) | fn env_functions() {
  function parameter_default_string (line 1098) | fn parameter_default_string() {
  function parameter_default_raw_string (line 1108) | fn parameter_default_raw_string() {
  function parameter_default_backtick (line 1118) | fn parameter_default_backtick() {
  function parameter_default_concatenation_string (line 1128) | fn parameter_default_concatenation_string() {
  function parameter_default_concatenation_variable (line 1138) | fn parameter_default_concatenation_variable() {
  function parameter_default_multiple (line 1151) | fn parameter_default_multiple() {
  function concatenation_in_group (line 1164) | fn concatenation_in_group() {
  function string_in_group (line 1169) | fn string_in_group() {
  function escaped_dos_newlines (line 1175) | fn escaped_dos_newlines() {

FILE: src/keyed.rs
  type Keyed (line 3) | pub(crate) trait Keyed<'key> {
    method key (line 4) | fn key(&self) -> &'key str;
  function key (line 8) | fn key(&self) -> &'key str {
  function serialize (line 13) | pub(crate) fn serialize<'src, S, K>(keyed: &K, serializer: S) -> Result<...
  function serialize_option (line 22) | pub(crate) fn serialize_option<'src, S, K>(

FILE: src/keyword.rs
  type Keyword (line 5) | pub(crate) enum Keyword {
    method from_lexeme (line 44) | pub(crate) fn from_lexeme(lexeme: &str) -> Option<Self> {
    method lexeme (line 48) | pub(crate) fn lexeme(self) -> &'static str {
    method eq (line 54) | fn eq(&self, other: &&'a str) -> bool {
  function keyword_case (line 64) | fn keyword_case() {

FILE: src/lexer.rs
  type Lexer (line 11) | pub(crate) struct Lexer<'src> {
  constant INTERPOLATION_END (line 39) | pub(crate) const INTERPOLATION_END: &'static str = "}}";
  constant INTERPOLATION_ESCAPE (line 40) | pub(crate) const INTERPOLATION_ESCAPE: &'static str = "{{{{";
  constant INTERPOLATION_START (line 41) | pub(crate) const INTERPOLATION_START: &'static str = "{{";
  function lex (line 44) | pub(crate) fn lex(path: &'src Path, src: &'src str) -> CompileResult<'sr...
  function test_lex (line 49) | pub(crate) fn test_lex(src: &'src str) -> CompileResult<'src, Vec<Token<...
  function new (line 54) | fn new(path: &'src Path, src: &'src str) -> Self {
  function advance (line 82) | fn advance(&mut self) -> CompileResult<'src> {
  function lexeme (line 104) | fn lexeme(&self) -> &'src str {
  function current_token_length (line 109) | fn current_token_length(&self) -> usize {
  function accepted (line 113) | fn accepted(&mut self, c: char) -> CompileResult<'src, bool> {
  function presume (line 122) | fn presume(&mut self, c: char) -> CompileResult<'src> {
  function presume_str (line 132) | fn presume_str(&mut self, s: &str) -> CompileResult<'src> {
  function next_is (line 141) | fn next_is(&self, c: char) -> bool {
  function next_is_whitespace (line 146) | fn next_is_whitespace(&self) -> bool {
  function rest (line 151) | fn rest(&self) -> &'src str {
  function rest_starts_with (line 156) | fn rest_starts_with(&self, prefix: &str) -> bool {
  function at_eol (line 161) | fn at_eol(&self) -> bool {
  function at_eof (line 166) | fn at_eof(&self) -> bool {
  function at_eol_or_eof (line 171) | fn at_eol_or_eof(&self) -> bool {
  function indentation (line 176) | fn indentation(&self) -> &'src str {
  function indented (line 181) | fn indented(&self) -> bool {
  function token (line 187) | fn token(&mut self, kind: TokenKind) {
  function internal_error (line 203) | fn internal_error(&self, message: impl Into<String>) -> CompileError<'sr...
  function error (line 223) | fn error(&self, kind: CompileErrorKind<'src>) -> CompileError<'src> {
  function unterminated_interpolation_error (line 251) | fn unterminated_interpolation_error(interpolation_start: Token<'src>) ->...
  function is_identifier_start (line 256) | pub(crate) fn is_identifier_start(c: char) -> bool {
  function is_identifier_continue (line 261) | pub(crate) fn is_identifier_continue(c: char) -> bool {
  function tokenize (line 266) | fn tokenize(mut self) -> CompileResult<'src, Vec<Token<'src>>> {
  function lex_line_start (line 304) | fn lex_line_start(&mut self) -> CompileResult<'src> {
  function lex_normal (line 462) | fn lex_normal(&mut self, start: char) -> CompileResult<'src> {
  function lex_interpolation (line 518) | fn lex_interpolation(
  function lex_body (line 544) | fn lex_body(&mut self) -> CompileResult<'src> {
  function lex_dedent (line 598) | fn lex_dedent(&mut self) {
  function lex_single (line 607) | fn lex_single(&mut self, kind: TokenKind) -> CompileResult<'src> {
  function lex_double (line 614) | fn lex_double(&mut self, kind: TokenKind) -> CompileResult<'src> {
  function lex_choices (line 624) | fn lex_choices(
  function lex_delimiter (line 662) | fn lex_delimiter(&mut self, kind: TokenKind) -> CompileResult<'src> {
  function open_delimiter (line 684) | fn open_delimiter(&mut self, delimiter: Delimiter) {
  function close_delimiter (line 691) | fn close_delimiter(&mut self, close: Delimiter) -> CompileResult<'src> {
  function open_delimiters_or_interpolation (line 704) | fn open_delimiters_or_interpolation(&self) -> bool {
  function lex_digraph (line 709) | fn lex_digraph(&mut self, left: char, right: char, token: TokenKind) -> ...
  function lex_colon (line 736) | fn lex_colon(&mut self) -> CompileResult<'src> {
  function lex_escape (line 752) | fn lex_escape(&mut self) -> CompileResult<'src> {
  function lex_eol (line 777) | fn lex_eol(&mut self) -> CompileResult<'src> {
  function lex_identifier (line 797) | fn lex_identifier(&mut self) -> CompileResult<'src> {
  function lex_comment (line 814) | fn lex_comment(&mut self) -> CompileResult<'src> {
  function lex_whitespace (line 827) | fn lex_whitespace(&mut self) -> CompileResult<'src> {
  function lex_string (line 842) | fn lex_string(&mut self, format_string_kind: Option<StringKind>) -> Comp...
  function test (line 961) | fn test(text: &str, unindent_text: bool, want_kinds: &[TokenKind], want_...
  function default_lexeme (line 1011) | fn default_lexeme(kind: TokenKind) -> &'static str {
  function error (line 1073) | fn error(
  function presume_error (line 2469) | fn presume_error() {

FILE: src/lib.rs
  type CompileResult (line 163) | type CompileResult<'a, T = ()> = Result<T, CompileError<'a>>;
  type ConfigResult (line 164) | type ConfigResult<T> = Result<T, ConfigError>;
  type FunctionResult (line 165) | type FunctionResult = Result<String, String>;
  type RunResult (line 166) | type RunResult<'a, T = ()> = Result<T, Error<'a>>;
  type SearchResult (line 167) | type SearchResult<T> = Result<T, SearchError>;

FILE: src/line.rs
  type Line (line 6) | pub(crate) struct Line<'src> {
  function first (line 13) | fn first(&self) -> Option<&str> {
  function sigils (line 21) | pub(crate) fn sigils(&self, settings: &Settings) -> BTreeSet<Sigil> {
  function is_comment (line 42) | pub(crate) fn is_comment(&self) -> bool {
  function is_continuation (line 46) | pub(crate) fn is_continuation(&self) -> bool {
  function is_empty (line 53) | pub(crate) fn is_empty(&self) -> bool {
  function is_shebang (line 57) | pub(crate) fn is_shebang(&self) -> bool {

FILE: src/list.rs
  type List (line 3) | pub(crate) struct List<T: Display, I: Iterator<Item = T> + Clone> {
  function or (line 9) | pub(crate) fn or<II: IntoIterator<Item = T, IntoIter = I>>(values: II) -...
  function and (line 16) | pub(crate) fn and<II: IntoIterator<Item = T, IntoIter = I>>(values: II) ...
  function or_ticked (line 23) | pub(crate) fn or_ticked<II: IntoIterator<Item = T, IntoIter = I>>(
  function and_ticked (line 29) | pub(crate) fn and_ticked<II: IntoIterator<Item = T, IntoIter = I>>(
  method fmt (line 37) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function or (line 84) | fn or() {
  function and (line 92) | fn and() {
  function or_ticked (line 100) | fn or_ticked() {
  function and_ticked (line 111) | fn and_ticked() {

FILE: src/load_dotenv.rs
  function load_dotenv (line 3) | pub(crate) fn load_dotenv(
  function load_from_file (line 50) | fn load_from_file(

FILE: src/loader.rs
  type Loader (line 3) | pub(crate) struct Loader {
    method new (line 9) | pub(crate) fn new() -> Self {
    method load (line 16) | pub(crate) fn load<'src>(

FILE: src/main.rs
  function main (line 1) | fn main() {

FILE: src/modulepath.rs
  type Modulepath (line 4) | pub(crate) struct Modulepath {
    method is_empty (line 10) | pub(crate) fn is_empty(&self) -> bool {
    method starts_with (line 14) | pub(crate) fn starts_with(&self, other: &Modulepath) -> bool {
    method from (line 29) | fn from(namepath: &Namepath) -> Self {
    type Error (line 38) | type Error = ();
    method try_from (line 40) | fn try_from(path: &[&str]) -> Result<Self, Self::Error> {
  method serialize (line 20) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method fmt (line 79) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function try_from_ok (line 99) | fn try_from_ok() {
  function try_from_err (line 115) | fn try_from_err() {

FILE: src/name.rs
  type Name (line 6) | pub(crate) struct Name<'src> {
  function from_identifier (line 11) | pub(crate) fn from_identifier(token: Token<'src>) -> Self {
  type Target (line 18) | type Target = Token<'src>;
  method deref (line 20) | fn deref(&self) -> &Self::Target {
  method fmt (line 26) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function key (line 32) | fn key(&self) -> &'src str {
  method serialize (line 38) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: src/namepath.rs
  type Namepath (line 4) | pub(crate) struct Namepath<'src>(Vec<Name<'src>>);
  function join (line 7) | pub(crate) fn join(&self, name: Name<'src>) -> Self {
  function push (line 11) | pub(crate) fn push(&mut self, name: Name<'src>) {
  function last (line 15) | pub(crate) fn last(&self) -> &Name<'src> {
  function split_last (line 19) | pub(crate) fn split_last(&self) -> (&Name<'src>, &[Name<'src>]) {
  function iter (line 23) | pub(crate) fn iter(&self) -> slice::Iter<'_, Name<'src>> {
  function components (line 27) | pub(crate) fn components(&self) -> usize {
  method fmt (line 33) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function from (line 45) | fn from(name: Name<'src>) -> Self {
  method serialize (line 51) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: src/node.rs
  type Node (line 4) | pub(crate) trait Node<'src> {
    method tree (line 7) | fn tree(&self) -> Tree<'src>;
  function tree (line 11) | fn tree(&self) -> Tree<'src> {
  function tree (line 19) | fn tree(&self) -> Tree<'src> {
  function tree (line 67) | fn tree(&self) -> Tree<'src> {
  function tree (line 80) | fn tree(&self) -> Tree<'src> {
  function tree (line 90) | fn tree(&self) -> Tree<'src> {
  function tree (line 104) | fn tree(&self) -> Tree<'src> {
  function tree (line 217) | fn tree(&self) -> Tree<'src> {
  function tree (line 281) | fn tree(&self) -> Tree<'src> {
  function tree (line 293) | fn tree(&self) -> Tree<'src> {
  function tree (line 299) | fn tree(&self) -> Tree<'src> {
  function tree (line 308) | fn tree(&self) -> Tree<'src> {
  method tree (line 351) | fn tree(&self) -> Tree<'src> {
  function tree (line 357) | fn tree(&self) -> Tree<'src> {

FILE: src/number.rs
  type Number (line 2) | pub(crate) struct Number(pub(crate) u32);

FILE: src/numerator.rs
  type Numerator (line 3) | pub(crate) struct Numerator(u32);
    method new (line 6) | pub(crate) fn new() -> Self {
    method next (line 10) | pub(crate) fn next(&mut self) -> Number {
    method constant (line 16) | pub(crate) fn constant(i: usize) -> Number {

FILE: src/ordinal.rs
  type Ordinal (line 1) | pub(crate) trait Ordinal {
    method ordinal (line 3) | fn ordinal(self) -> Self;
    method ordinal (line 7) | fn ordinal(self) -> Self {

FILE: src/output_error.rs
  type OutputError (line 4) | pub(crate) enum OutputError {
    method result_from_exit_status (line 20) | pub(crate) fn result_from_exit_status(exit_status: ExitStatus) -> Resu...
  method fmt (line 33) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/parameter.rs
  type Parameter (line 4) | pub(crate) struct Parameter<'src> {
  function is_option (line 19) | pub(crate) fn is_option(&self) -> bool {
  function is_required (line 23) | pub(crate) fn is_required(&self) -> bool {
  function check_pattern_match (line 27) | pub(crate) fn check_pattern_match(
  method fmt (line 50) | fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {

FILE: src/parameter_kind.rs
  type ParameterKind (line 6) | pub(crate) enum ParameterKind {
    method prefix (line 16) | pub(crate) fn prefix(self) -> Option<&'static str> {
    method is_variadic (line 24) | pub(crate) fn is_variadic(self) -> bool {

FILE: src/parser.rs
  type Parser (line 26) | pub(crate) struct Parser<'run, 'src> {
  function parse (line 41) | pub(crate) fn parse(
  function parse_source (line 64) | pub(crate) fn parse_source(
  function parse_tokens (line 83) | pub(crate) fn parse_tokens(
  function error (line 90) | fn error(&self, kind: CompileErrorKind<'src>) -> CompileResult<'src, Com...
  function unexpected_token (line 96) | fn unexpected_token(&self) -> CompileResult<'src, CompileError<'src>> {
  function internal_error (line 108) | fn internal_error(&self, message: impl Into<String>) -> CompileResult<'s...
  function rest (line 115) | fn rest(&self) -> impl Iterator<Item = Token<'src>> + 'run {
  function next (line 123) | fn next(&self) -> CompileResult<'src, Token<'src>> {
  function next_is (line 132) | fn next_is(&mut self, kind: TokenKind) -> bool {
  function next_are (line 139) | fn next_are(&mut self, kinds: &[TokenKind]) -> bool {
  function advance (line 159) | fn advance(&mut self) -> CompileResult<'src, Token<'src>> {
  function expect (line 175) | fn expect(&mut self, expected: TokenKind) -> CompileResult<'src, Token<'...
  function expect_any (line 185) | fn expect_any(&mut self, expected: &[TokenKind]) -> CompileResult<'src, ...
  function expect_eol (line 196) | fn expect_eol(&mut self) -> CompileResult<'src> {
  function expect_keyword (line 206) | fn expect_keyword(&mut self, expected: Keyword) -> CompileResult<'src> {
  function presume_keyword (line 221) | fn presume_keyword(&mut self, keyword: Keyword) -> CompileResult<'src> {
  function presume (line 240) | fn presume(&mut self, kind: TokenKind) -> CompileResult<'src, Token<'src...
  function presume_any (line 254) | fn presume_any(&mut self, kinds: &[TokenKind]) -> CompileResult<'src, To...
  function accept (line 268) | fn accept(&mut self, kind: TokenKind) -> CompileResult<'src, Option<Toke...
  function forbid (line 277) | fn forbid<F>(&self, forbidden: TokenKind, error: F) -> CompileResult<'src>
  function accept_namepath (line 291) | fn accept_namepath(&mut self) -> CompileResult<'src, Option<Namepath<'sr...
  function accept_keyword (line 299) | fn accept_keyword(&mut self, keyword: Keyword) -> CompileResult<'src, Op...
  function accepted_keyword (line 310) | fn accepted_keyword(&mut self, keyword: Keyword) -> CompileResult<'src, ...
  function accept_dependency (line 315) | fn accept_dependency(&mut self) -> CompileResult<'src, Option<Unresolved...
  function accepted (line 337) | fn accepted(&mut self, kind: TokenKind) -> CompileResult<'src, bool> {
  function parse_ast (line 342) | fn parse_ast(mut self) -> CompileResult<'src, Ast<'src>> {
  function parse_alias (line 552) | fn parse_alias(
  function parse_assignment (line 572) | fn parse_assignment(
  function parse_expression (line 600) | fn parse_expression(&mut self) -> CompileResult<'src, Expression<'src>> {
  function parse_disjunct (line 629) | fn parse_disjunct(&mut self) -> CompileResult<'src, Expression<'src>> {
  function parse_conjunct (line 646) | fn parse_conjunct(&mut self) -> CompileResult<'src, Expression<'src>> {
  function parse_conditional (line 671) | fn parse_conditional(&mut self) -> CompileResult<'src, Expression<'src>> {
  function parse_condition (line 698) | fn parse_condition(&mut self) -> CompileResult<'src, Condition<'src>> {
  function parse_format_string (line 718) | fn parse_format_string(&mut self) -> CompileResult<'src, Expression<'src...
  function next_is_shell_expanded_string (line 746) | fn next_is_shell_expanded_string(&self) -> bool {
  function next_is_format_string (line 764) | fn next_is_format_string(&self) -> bool {
  function parse_value (line 780) | fn parse_value(&mut self) -> CompileResult<'src, Expression<'src>> {
  function parse_string_literal (line 843) | fn parse_string_literal(&mut self) -> CompileResult<'src, StringLiteral<...
  function parse_string_literal_in_state (line 848) | fn parse_string_literal_in_state(
  function cook_string (line 938) | fn cook_string(token: Token<'src>, text: &str) -> CompileResult<'src, St...
  function parse_name (line 1020) | fn parse_name(&mut self) -> CompileResult<'src, Name<'src>> {
  function parse_namepath (line 1025) | fn parse_namepath(&mut self) -> CompileResult<'src, Namepath<'src>> {
  function parse_sequence (line 1038) | fn parse_sequence(&mut self) -> CompileResult<'src, Vec<Expression<'src>...
  function parse_recipe (line 1057) | fn parse_recipe(
  function parse_parameter (line 1237) | fn parse_parameter(
  function parse_body (line 1285) | fn parse_body(&mut self) -> CompileResult<'src, Vec<Line<'src>>> {
  function parse_set_bool (line 1324) | fn parse_set_bool(&mut self) -> CompileResult<'src, bool> {
  function parse_set (line 1346) | fn parse_set(&mut self) -> CompileResult<'src, Set<'src>> {
  function parse_interpreter (line 1409) | fn parse_interpreter(&mut self) -> CompileResult<'src, Interpreter<Expre...
  function parse_attributes (line 1432) | fn parse_attributes(&mut self) -> CompileResult<'src, Option<(Token<'src...
  function test (line 1560) | fn test(text: &str, want: Tree) {
  function error (line 1593) | fn error(

FILE: src/pattern.rs
  type Pattern (line 4) | pub(crate) struct Pattern<'src> {
  function is_match (line 10) | pub(crate) fn is_match(&self, haystack: &str) -> bool {
  function new (line 14) | pub(crate) fn new(literal: &StringLiteral<'src>) -> Result<Self, Compile...
  function original (line 33) | pub(crate) fn original(&self) -> &str {
  method cmp (line 41) | fn cmp(&self, other: &pattern::Pattern) -> Ordering {
  method eq (line 47) | fn eq(&self, other: &pattern::Pattern) -> bool {
  method partial_cmp (line 53) | fn partial_cmp(&self, other: &pattern::Pattern) -> Option<Ordering> {
  method serialize (line 59) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: src/platform.rs
  type Platform (line 3) | pub(crate) struct Platform;

FILE: src/platform/unix.rs
  method make_shebang_command (line 4) | fn make_shebang_command(
  method set_execute_permission (line 20) | fn set_execute_permission(path: &Path) -> io::Result<()> {
  method signal_from_exit_status (line 34) | fn signal_from_exit_status(exit_status: ExitStatus) -> Option<i32> {
  method convert_native_path (line 39) | fn convert_native_path(
  method install_signal_handler (line 50) | fn install_signal_handler<T: Fn(Signal) + Send + 'static>(handler: T) ->...

FILE: src/platform/windows.rs
  method make_shebang_command (line 4) | fn make_shebang_command(
  method set_execute_permission (line 48) | fn set_execute_permission(_path: &Path) -> io::Result<()> {
  method signal_from_exit_status (line 54) | fn signal_from_exit_status(_exit_status: process::ExitStatus) -> Option<...
  method convert_native_path (line 60) | fn convert_native_path(config: &Config, working_directory: &Path, path: ...
  method install_signal_handler (line 81) | fn install_signal_handler<T: Fn(Signal) + Send + 'static>(handler: T) ->...

FILE: src/platform_interface.rs
  type PlatformInterface (line 3) | pub(crate) trait PlatformInterface {
    method convert_native_path (line 5) | fn convert_native_path(config: &Config, working_directory: &Path, path...
    method install_signal_handler (line 8) | fn install_signal_handler<T: Fn(Signal) + Send + 'static>(handler: T) ...
    method make_shebang_command (line 12) | fn make_shebang_command(
    method set_execute_permission (line 20) | fn set_execute_permission(path: &Path) -> io::Result<()>;
    method signal_from_exit_status (line 23) | fn signal_from_exit_status(exit_status: ExitStatus) -> Option<i32>;

FILE: src/position.rs
  type Position (line 3) | pub(crate) struct Position {

FILE: src/positional.rs
  type Positional (line 30) | pub(crate) struct Positional {
    method from_values (line 40) | pub(crate) fn from_values<'values>(
    method override_from_value (line 79) | fn override_from_value(value: &str) -> Option<(String, String)> {

FILE: src/ran.rs
  type Ran (line 4) | pub(crate) struct Ran(Mutex<BTreeMap<Modulepath, BTreeMap<Vec<Vec<String...
    method mutex (line 7) | pub(crate) fn mutex(&self, recipe: &Recipe, arguments: &[Vec<String>])...

FILE: src/range_ext.rs
  type RangeExt (line 3) | pub(crate) trait RangeExt<T> {
    method display (line 4) | fn display(&self) -> DisplayRange<&Self> {
  type DisplayRange (line 9) | pub(crate) struct DisplayRange<T>(T);
  method fmt (line 12) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function display (line 31) | fn display() {

FILE: src/recipe.rs
  function error_from_signal (line 5) | fn error_from_signal(recipe: &str, line_number: Option<usize>, exit_stat...
  type Recipe (line 21) | pub(crate) struct Recipe<'src, D = Dependency<'src>> {
  function module_path (line 45) | pub(crate) fn module_path(&self) -> &Modulepath {
  function recipe_path (line 49) | pub(crate) fn recipe_path(&self) -> &Modulepath {
  function spaced_recipe_path (line 53) | pub(crate) fn spaced_recipe_path(&self) -> String {
  function argument_range (line 59) | pub(crate) fn argument_range(&self) -> RangeInclusive<usize> {
  function group_arguments (line 63) | pub(crate) fn group_arguments(
  function min_arguments (line 87) | pub(crate) fn min_arguments(&self) -> usize {
  function max_arguments (line 91) | pub(crate) fn max_arguments(&self) -> usize {
  function name (line 99) | pub(crate) fn name(&self) -> &'src str {
  function line_number (line 103) | pub(crate) fn line_number(&self) -> usize {
  function confirm (line 107) | pub(crate) fn confirm(&self) -> RunResult<'src, bool> {
  function check_can_be_default_recipe (line 125) | pub(crate) fn check_can_be_default_recipe(&self) -> RunResult<'src> {
  function is_parallel (line 137) | pub(crate) fn is_parallel(&self) -> bool {
  function is_public (line 141) | pub(crate) fn is_public(&self) -> bool {
  function is_script (line 145) | pub(crate) fn is_script(&self) -> bool {
  function takes_positional_arguments (line 149) | pub(crate) fn takes_positional_arguments(&self, settings: &Settings) -> ...
  function change_directory (line 156) | pub(crate) fn change_directory(&self) -> bool {
  function enabled (line 160) | pub(crate) fn enabled(&self) -> bool {
  function print_exit_message (line 182) | fn print_exit_message(&self, settings: &Settings) -> bool {
  function working_directory (line 194) | fn working_directory<'a>(&'a self, context: &'a ExecutionContext) -> Opt...
  function no_quiet (line 210) | fn no_quiet(&self) -> bool {
  function run (line 214) | pub(crate) fn run<'run>(
  function run_linewise (line 244) | fn run_linewise<'run>(
  function run_script (line 400) | pub(crate) fn run_script<'run>(
  function groups (line 548) | pub(crate) fn groups(&self) -> BTreeSet<String> {
  function doc (line 562) | pub(crate) fn doc(&self) -> Option<&str> {
  function priors (line 572) | pub(crate) fn priors(&self) -> &[D] {
  function subsequents (line 576) | pub(crate) fn subsequents(&self) -> &[D] {
  method fmt (line 582) | fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
  function key (line 638) | fn key(&self) -> &'src str {

FILE: src/recipe_resolver.rs
  type RecipeResolver (line 3) | pub(crate) struct RecipeResolver<'src: 'run, 'run> {
  function resolve_recipes (line 13) | pub(crate) fn resolve_recipes(
  function resolve_recipe (line 36) | fn resolve_recipe(
  function resolve_dependency (line 74) | fn resolve_dependency(

FILE: src/recipe_signature.rs
  type RecipeSignature (line 3) | pub(crate) struct RecipeSignature<'a> {
  method fmt (line 9) | fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {

FILE: src/request.rs
  type Request (line 5) | pub enum Request {
  type Response (line 13) | pub enum Response {

FILE: src/run.rs
  function run (line 5) | pub fn run(args: impl Iterator<Item = impl Into<OsString> + Clone>) -> R...
  function run_can_be_called_more_than_once (line 43) | fn run_can_be_called_more_than_once() {

FILE: src/scope.rs
  type Scope (line 4) | pub(crate) struct Scope<'src: 'run, 'run> {
  function child (line 10) | pub(crate) fn child(&'run self) -> Self {
  function root (line 17) | pub(crate) fn root() -> Self {
  function bind (line 49) | pub(crate) fn bind(&mut self, binding: Binding<'src>) {
  function bound (line 53) | pub(crate) fn bound(&self, name: &str) -> bool {
  function value (line 57) | pub(crate) fn value(&self, name: &str) -> Option<&str> {
  function bindings (line 65) | pub(crate) fn bindings(&self) -> impl Iterator<Item = &Binding<String>> {
  function names (line 69) | pub(crate) fn names(&self) -> impl Iterator<Item = &str> {
  function parent (line 73) | pub(crate) fn parent(&self) -> Option<&'run Self> {

FILE: src/search.rs
  constant DEFAULT_JUSTFILE_NAME (line 3) | const DEFAULT_JUSTFILE_NAME: &str = JUSTFILE_NAMES[0];
  constant JUSTFILE_NAMES (line 4) | pub(crate) const JUSTFILE_NAMES: [&str; 2] = ["justfile", ".justfile"];
  constant PROJECT_ROOT_CHILDREN (line 5) | const PROJECT_ROOT_CHILDREN: &[&str] = &[".bzr", ".git", ".hg", ".svn", ...
  type Search (line 8) | pub(crate) struct Search {
    method global_justfile_paths (line 14) | fn global_justfile_paths() -> Vec<(PathBuf, &'static str)> {
    method find (line 33) | pub(crate) fn find(
    method find_global_justfile (line 73) | fn find_global_justfile() -> SearchResult<PathBuf> {
    method search_parent_directory (line 94) | pub(crate) fn search_parent_directory(&self, ceiling: Option<&Path>) -...
    method find_in_directory (line 106) | fn find_in_directory(ceiling: Option<&Path>, starting_dir: &Path) -> S...
    method init (line 116) | pub(crate) fn init(
    method justfile (line 160) | fn justfile(ceiling: Option<&Path>, directory: &Path) -> SearchResult<...
    method clean (line 199) | fn clean(invocation_directory: &Path, path: &Path) -> PathBuf {
    method project_root (line 220) | fn project_root(ceiling: Option<&Path>, directory: &Path) -> SearchRes...
    method working_directory_from_justfile (line 249) | fn working_directory_from_justfile(justfile: &Path) -> SearchResult<Pa...
  function not_found (line 267) | fn not_found() {
  function multiple_candidates (line 276) | fn multiple_candidates() {
  function found (line 296) | fn found() {
  function found_spongebob_case (line 308) | fn found_spongebob_case() {
  function found_from_inner_dir (line 331) | fn found_from_inner_dir() {
  function found_and_stopped_at_first_justfile (line 347) | fn found_and_stopped_at_first_justfile() {
  function justfile_symlink_parent (line 371) | fn justfile_symlink_parent() {
  function clean (line 396) | fn clean() {

FILE: src/search_config.rs
  type SearchConfig (line 5) | pub(crate) enum SearchConfig {

FILE: src/search_error.rs
  type SearchError (line 5) | pub(crate) enum SearchError {
  function multiple_candidates_formatting (line 40) | fn multiple_candidates_formatting() {

FILE: src/set.rs
  type Set (line 4) | pub(crate) struct Set<'src> {
  function key (line 10) | fn key(&self) -> &'src str {
  method fmt (line 16) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/setting.rs
  type Setting (line 4) | pub(crate) enum Setting<'src> {
  function expressions (line 30) | pub(crate) fn expressions(&self) -> impl Iterator<Item = &Expression<'sr...
  method fmt (line 54) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/settings.rs
  constant DEFAULT_SHELL (line 3) | pub(crate) const DEFAULT_SHELL: &str = "sh";
  constant DEFAULT_SHELL_ARGS (line 4) | pub(crate) const DEFAULT_SHELL_ARGS: &[&str] = &["-cu"];
  constant WINDOWS_POWERSHELL_SHELL (line 5) | pub(crate) const WINDOWS_POWERSHELL_SHELL: &str = "powershell.exe";
  constant WINDOWS_POWERSHELL_ARGS (line 6) | pub(crate) const WINDOWS_POWERSHELL_ARGS: &[&str] = &["-NoLogo", "-Comma...
  type Settings (line 9) | pub(crate) struct Settings {
    method shell_command (line 36) | pub(crate) fn shell_command(&self, config: &Config) -> Command {
    method shell (line 46) | pub(crate) fn shell<'a>(&'a self, config: &'a Config) -> (&'a str, Vec...
  function default_shell (line 80) | fn default_shell() {
  function default_shell_powershell (line 92) | fn default_shell_powershell() {
  function overwrite_shell (line 114) | fn overwrite_shell() {
  function overwrite_shell_powershell (line 128) | fn overwrite_shell_powershell() {
  function shell_cooked (line 145) | fn shell_cooked() {
  function shell_present_but_not_shell_args (line 163) | fn shell_present_but_not_shell_args() {
  function shell_args_present_but_not_shell (line 178) | fn shell_args_present_but_not_shell() {

FILE: src/shebang.rs
  type Shebang (line 2) | pub(crate) struct Shebang<'line> {
  function new (line 8) | pub(crate) fn new(line: &'line str) -> Option<Self> {
  function interpreter_filename (line 33) | pub(crate) fn interpreter_filename(&self) -> &str {
  function include_shebang_line (line 41) | pub(crate) fn include_shebang_line(&self) -> bool {
  function split_shebang (line 51) | fn split_shebang() {
  function interpreter_filename_with_forward_slash (line 111) | fn interpreter_filename_with_forward_slash() {
  function interpreter_filename_with_backslash (line 121) | fn interpreter_filename_with_backslash() {
  function dont_include_shebang_line_cmd (line 131) | fn dont_include_shebang_line_cmd() {
  function dont_include_shebang_line_cmd_exe (line 136) | fn dont_include_shebang_line_cmd_exe() {
  function include_shebang_line_other (line 141) | fn include_shebang_line_other() {

FILE: src/show_whitespace.rs
  type ShowWhitespace (line 4) | pub(crate) struct ShowWhitespace<'str>(pub &'str str);
  method fmt (line 7) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/sigil.rs
  type Sigil (line 2) | pub(crate) enum Sigil {

FILE: src/signal.rs
  type Signal (line 5) | pub(crate) enum Signal {
    constant ALL (line 23) | pub(crate) const ALL: &'static [Self] = &[
    method code (line 39) | pub(crate) fn code(self) -> i32 {
    method is_fatal (line 43) | pub(crate) fn is_fatal(self) -> bool {
    method number (line 58) | pub(crate) fn number(self) -> i32 {
    type Error (line 109) | type Error = io::Error;
    method try_from (line 111) | fn try_from(n: u8) -> Result<Self, Self::Error> {
  method fmt (line 64) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function from (line 89) | fn from(signal: Signal) -> Self {
  function signals_fit_in_u8 (line 137) | fn signals_fit_in_u8() {
  function signals_have_valid_exit_codes (line 144) | fn signals_have_valid_exit_codes() {
  function signal_numbers_are_correct (line 151) | fn signal_numbers_are_correct() {

FILE: src/signal_handler.rs
  type SignalHandler (line 3) | pub(crate) struct SignalHandler {
    method install (line 11) | pub(crate) fn install(verbosity: Verbosity) -> RunResult<'static> {
    method instance (line 21) | pub(crate) fn instance() -> MutexGuard<'static, Self> {
    method new (line 37) | const fn new() -> Self {
    method handle (line 46) | fn handle(&mut self, signal: Signal) {
    method spawn (line 110) | pub(crate) fn spawn<T>(

FILE: src/signals.rs
  constant INVALID_FILENO (line 16) | const INVALID_FILENO: i32 = -1;
  function die (line 20) | fn die(message: &str) -> ! {
  function handler (line 46) | extern "C" fn handler(signal: libc::c_int) {
  function fcntl (line 66) | fn fcntl(fd: &OwnedFd, arg: FcntlArg) -> RunResult<'static, libc::c_int> {
  function set_cloexec (line 72) | fn set_cloexec(fd: &OwnedFd) -> RunResult<'static> {
  type Signals (line 82) | pub(crate) struct Signals(File);
    method new (line 85) | pub(crate) fn new() -> RunResult<'static, Self> {
  type Item (line 132) | type Item = io::Result<Signal>;
  method next (line 134) | fn next(&mut self) -> Option<Self::Item> {

FILE: src/source.rs
  type Source (line 4) | pub(crate) struct Source<'src> {
  function root (line 14) | pub(crate) fn root(path: &Path) -> Self {
  function import (line 25) | pub(crate) fn import(&self, path: PathBuf, import_offset: usize) -> Self {
  function module (line 46) | pub(crate) fn module(&self, name: Name<'src>, path: PathBuf) -> Self {

FILE: src/string_delimiter.rs
  type StringDelimiter (line 2) | pub(crate) enum StringDelimiter {

FILE: src/string_kind.rs
  type StringKind (line 4) | pub(crate) struct StringKind {
    constant ALL (line 13) | const ALL: &'static [Self] = &[
    method new (line 22) | const fn new(delimiter: StringDelimiter, indented: bool) -> Self {
    method delimiter (line 29) | pub(crate) fn delimiter(self) -> &'static str {
    method delimiter_len (line 40) | pub(crate) fn delimiter_len(self) -> usize {
    method token_kind (line 44) | pub(crate) fn token_kind(self) -> TokenKind {
    method unterminated_error_kind (line 51) | pub(crate) fn unterminated_error_kind(self) -> CompileErrorKind<'stati...
    method processes_escape_sequences (line 60) | pub(crate) fn processes_escape_sequences(self) -> bool {
    method indented (line 67) | pub(crate) fn indented(self) -> bool {
    method from_string_or_backtick (line 71) | pub(crate) fn from_string_or_backtick(token: Token) -> CompileResult<S...
    method from_token_start (line 79) | pub(crate) fn from_token_start(token_start: &str) -> Option<Self> {

FILE: src/string_literal.rs
  type StringLiteral (line 4) | pub(crate) struct StringLiteral<'src> {
  method fmt (line 13) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  method serialize (line 27) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: src/string_state.rs
  type StringState (line 3) | pub(crate) enum StringState {

FILE: src/subcommand.rs
  constant INIT_JUSTFILE (line 3) | pub const INIT_JUSTFILE: &str = "\
  constant CHOOSER_CANCELLED_EXIT_STATUS (line 12) | const CHOOSER_CANCELLED_EXIT_STATUS: i32 = 130;
  type Subcommand (line 15) | pub(crate) enum Subcommand {
    method execute (line 66) | pub(crate) fn execute<'src>(&self, config: &Config, loader: &'src Load...
    method groups (line 130) | fn groups(config: &Config, justfile: &Justfile) {
    method run (line 137) | fn run<'src>(
    method compile (line 195) | fn compile<'src>(
    method changelog (line 213) | fn changelog() {
    method choose (line 217) | fn choose<'src>(
    method completions (line 309) | fn completions(shell: completions::Shell) {
    method dump (line 313) | fn dump(compilation: Compilation, format: DumpFormat) -> RunResult<'st...
    method edit (line 325) | fn edit(search: &Search) -> RunResult<'static> {
    method format (line 347) | fn format<'src>(config: &Config, loader: &'src Loader, search: &Search...
    method init (line 418) | fn init(config: &Config) -> RunResult<'static> {
    method man (line 445) | fn man() -> RunResult<'static> {
    method request (line 465) | fn request(request: &Request) -> RunResult<'static> {
    method list (line 485) | fn list(config: &Config, mut module: &Justfile, path: &Modulepath) -> ...
    method list_module (line 500) | fn list_module(
    method show (line 783) | fn show<'src>(config: &Config, module: &Justfile<'src>, path: &Modulep...
    method summary (line 795) | fn summary(config: &Config, justfile: &Justfile) {
    method summary_recursive (line 805) | fn summary_recursive<'a>(
    method usage (line 833) | fn usage<'src>(config: &Config, module: &Justfile<'src>, path: &Module...
    method resolve_path (line 853) | fn resolve_path<'src, 'run>(
    method variables (line 880) | fn variables(justfile: &Justfile) {
  method default (line 58) | fn default() -> Self {
  function init_justfile (line 901) | fn init_justfile() {

FILE: src/suggestion.rs
  type Suggestion (line 4) | pub(crate) struct Suggestion<'src> {
  method fmt (line 10) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/summary.rs
  function summary (line 28) | pub fn summary(path: &Path) -> io::Result<Result<Summary, String>> {
  type Summary (line 42) | pub struct Summary {
    method new (line 48) | fn new(justfile: &full::Justfile) -> Self {
  type Recipe (line 79) | pub struct Recipe {
    method new (line 90) | fn new(recipe: &full::Recipe, aliases: Vec<String>) -> Self {
  type Parameter (line 104) | pub struct Parameter {
    method new (line 111) | fn new(parameter: &full::Parameter) -> Self {
  type ParameterKind (line 121) | pub enum ParameterKind {
    method new (line 128) | fn new(parameter_kind: full::ParameterKind) -> Self {
  type Line (line 138) | pub struct Line {
    method new (line 143) | fn new(line: &full::Line) -> Self {
  type Fragment (line 151) | pub enum Fragment {
    method new (line 157) | fn new(fragment: &full::Fragment) -> Self {
  type Assignment (line 170) | pub struct Assignment {
    method new (line 176) | fn new(assignment: &full::Assignment) -> Self {
  type Expression (line 185) | pub enum Expression {
    method new (line 233) | fn new(expression: &full::Expression) -> Self {
  type Condition (line 364) | pub struct Condition {
  type ConditionalOperator (line 371) | pub enum ConditionalOperator {
    method new (line 379) | fn new(operator: full::ConditionalOperator) -> Self {
  type Dependency (line 390) | pub struct Dependency {
    method new (line 396) | fn new(dependency: &full::Dependency) -> Self {

FILE: src/switch.rs
  type Switch (line 4) | pub(crate) enum Switch {
  method fmt (line 10) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/table.rs
  type Table (line 5) | pub(crate) struct Table<'key, V: Keyed<'key>> {
  function new (line 10) | pub(crate) fn new() -> Self {
  function insert (line 16) | pub(crate) fn insert(&mut self, value: V) {
  function len (line 20) | pub(crate) fn len(&self) -> usize {
  function get (line 24) | pub(crate) fn get(&self, key: &str) -> Option<&V> {
  function is_empty (line 28) | pub(crate) fn is_empty(&self) -> bool {
  function values (line 32) | pub(crate) fn values(&self) -> btree_map::Values<&'key str, V> {
  function contains_key (line 36) | pub(crate) fn contains_key(&self, key: &str) -> bool {
  function keys (line 40) | pub(crate) fn keys(&self) -> btree_map::Keys<&'key str, V> {
  function iter (line 44) | pub(crate) fn iter(&self) -> btree_map::Iter<&'key str, V> {
  function pop (line 48) | pub(crate) fn pop(&mut self) -> Option<V> {
  function remove (line 53) | pub(crate) fn remove(&mut self, key: &str) -> Option<V> {
  method default (line 59) | fn default() -> Self {
  function from_iter (line 65) | fn from_iter<I: IntoIterator<Item = V>>(iter: I) -> Self {
  type Output (line 73) | type Output = V;
  function index (line 76) | fn index(&self, key: &str) -> &V {
  type IntoIter (line 82) | type IntoIter = btree_map::IntoIter<&'key str, V>;
  type Item (line 83) | type Item = (&'key str, V);
  method into_iter (line 85) | fn into_iter(self) -> btree_map::IntoIter<&'key str, V> {
  type IntoIter (line 91) | type IntoIter = btree_map::Iter<'table, &'table str, V>;
  type Item (line 92) | type Item = (&'table &'table str, &'table V);
  method into_iter (line 94) | fn into_iter(self) -> btree_map::Iter<'table, &'table str, V> {

FILE: src/testing.rs
  function compile (line 3) | pub(crate) fn compile(src: &str) -> Justfile {
  function config (line 7) | pub(crate) fn config(args: &[&str]) -> Config {
  function search (line 18) | pub(crate) fn search(config: &Config) -> Search {
  function tempdir (line 28) | pub(crate) fn tempdir() -> tempfile::TempDir {
  function analysis_error (line 52) | pub(crate) fn analysis_error(

FILE: src/thunk.rs
  type Thunk (line 6) | pub(crate) enum Thunk<'src> {
  function name (line 51) | pub(crate) fn name(&self) -> Name<'src> {
  function resolve (line 63) | pub(crate) fn resolve(
  method fmt (line 139) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  method serialize (line 188) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: src/token.rs
  type Token (line 4) | pub(crate) struct Token<'src> {
  function lexeme (line 15) | pub(crate) fn lexeme(&self) -> &'src str {
  function error (line 19) | pub(crate) fn error(&self, kind: CompileErrorKind<'src>) -> CompileError...
  method fmt (line 25) | fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {

FILE: src/token_kind.rs
  type TokenKind (line 4) | pub(crate) enum TokenKind {
  method fmt (line 48) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/tree.rs
  type Tree (line 50) | pub(crate) enum Tree<'text> {
  function atom (line 59) | pub(crate) fn atom(text: impl Into<Cow<'text, str>>) -> Self {
  function list (line 64) | pub(crate) fn list(children: impl IntoIterator<Item = Self>) -> Self {
  function string (line 69) | pub(crate) fn string(contents: impl AsRef<str>) -> Self {
  function push (line 74) | pub(crate) fn push(self, tree: impl Into<Self>) -> Self {
  function extend (line 86) | pub(crate) fn extend<I, T>(self, tail: I) -> Self
  function push_mut (line 105) | pub(crate) fn push_mut(&mut self, tree: impl Into<Self>) {
  method fmt (line 111) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {
  function from (line 134) | fn from(text: T) -> Self {

FILE: src/unindent.rs
  function unindent (line 2) | pub fn unindent(text: &str) -> String {
  function indentation (line 47) | fn indentation(line: &str) -> &str {
  function blank (line 58) | fn blank(line: &str) -> bool {
  function common (line 62) | fn common<'s>(a: &'s str, b: &'s str) -> &'s str {
  function unindents (line 79) | fn unindents() {
  function indentations (line 112) | fn indentations() {
  function blanks (line 121) | fn blanks() {
  function commons (line 128) | fn commons() {

FILE: src/unresolved_dependency.rs
  type UnresolvedDependency (line 4) | pub(crate) struct UnresolvedDependency<'src> {
  method fmt (line 10) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/unresolved_recipe.rs
  type UnresolvedRecipe (line 3) | pub(crate) type UnresolvedRecipe<'src> = Recipe<'src, UnresolvedDependen...
  function resolve (line 6) | pub(crate) fn resolve(
  function resolve_variable (line 118) | fn resolve_variable(

FILE: src/unstable_feature.rs
  type UnstableFeature (line 4) | pub(crate) enum UnstableFeature {
  method fmt (line 13) | fn fmt(&self, f: &mut Formatter) -> fmt::Result {

FILE: src/usage.rs
  type Usage (line 3) | pub(crate) struct Usage<'a, D> {
  method fmt (line 10) | fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
  type UsageParameter (line 118) | struct UsageParameter<'a> {
  method fmt (line 124) | fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {

FILE: src/use_color.rs
  type UseColor (line 4) | pub(crate) enum UseColor {

FILE: src/variables.rs
  type Variables (line 3) | pub(crate) struct Variables<'expression, 'src> {
  function new (line 8) | pub(crate) fn new(root: &'expression Expression<'src>) -> Self {
  type Item (line 14) | type Item = Name<'src>;
  method next (line 16) | fn next(&mut self) -> Option<Name<'src>> {

FILE: src/verbosity.rs
  type Verbosity (line 3) | pub(crate) enum Verbosity {
    method from_flag_occurrences (line 11) | pub(crate) fn from_flag_occurrences(flag_occurrences: u8) -> Self {
    method quiet (line 19) | pub(crate) fn quiet(self) -> bool {
    method loud (line 23) | pub(crate) fn loud(self) -> bool {
    method loquacious (line 27) | pub(crate) fn loquacious(self) -> bool {
    method grandiloquent (line 31) | pub(crate) fn grandiloquent(self) -> bool {
    method default (line 35) | pub(crate) const fn default() -> Self {
  method default (line 41) | fn default() -> Self {

FILE: src/warning.rs
  type Warning (line 4) | pub(crate) enum Warning {}
    method context (line 8) | fn context(&self) -> Option<&Token> {
  method fmt (line 14) | fn fmt(&self, f: &mut Formatter, color: Color) -> fmt::Result {
  method serialize (line 32) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

FILE: src/which.rs
  function which (line 3) | pub(crate) fn which(context: function::Context, name: &str) -> Result<Op...

FILE: tests/alias.rs
  function alias_nested_module (line 4) | fn alias_nested_module() {
  function unknown_nested_alias (line 24) | fn unknown_nested_alias() {
  function alias_in_submodule (line 48) | fn alias_in_submodule() {

FILE: tests/alias_style.rs
  function default (line 4) | fn default() {
  function multiple (line 28) | fn multiple() {
  function right (line 53) | fn right() {
  function left (line 77) | fn left() {
  function separate (line 101) | fn separate() {

FILE: tests/allow_duplicate_recipes.rs
  function allow_duplicate_recipes (line 4) | fn allow_duplicate_recipes() {
  function allow_duplicate_recipes_with_args (line 22) | fn allow_duplicate_recipes_with_args() {

FILE: tests/allow_duplicate_variables.rs
  function allow_duplicate_variables (line 4) | fn allow_duplicate_variables() {

FILE: tests/allow_missing.rs
  function allow_missing_recipes_in_run_invocation (line 4) | fn allow_missing_recipes_in_run_invocation() {
  function allow_missing_modules_in_run_invocation (line 14) | fn allow_missing_modules_in_run_invocation() {
  function allow_missing_does_not_apply_to_compilation_errors (line 24) | fn allow_missing_does_not_apply_to_compilation_errors() {
  function allow_missing_does_not_apply_to_other_subcommands (line 41) | fn allow_missing_does_not_apply_to_other_subcommands() {

FILE: tests/arg_attribute.rs
  function pattern_match (line 4) | fn pattern_match() {
  function pattern_mismatch (line 17) | fn pattern_mismatch() {
  function patterns_are_regulare_expressions (line 35) | fn patterns_are_regulare_expressions() {
  function pattern_must_match_entire_string (line 53) | fn pattern_must_match_entire_string() {
  function pattern_invalid_regex_error (line 71) | fn pattern_invalid_regex_error() {
  function dump (line 96) | fn dump() {
  function duplicate_attribute_error (line 115) | fn duplicate_attribute_error() {
  function extra_keyword_error (line 138) | fn extra_keyword_error() {
  function unknown_argument_error (line 160) | fn unknown_argument_error() {
  function split_across_multiple_lines (line 182) | fn split_across_multiple_lines() {
  function optional_trailing_comma (line 198) | fn optional_trailing_comma() {
  function positional_arguments_cannot_follow_keyword_arguments (line 214) | fn positional_arguments_cannot_follow_keyword_arguments() {
  function pattern_mismatches_are_caught_before_running_dependencies (line 236) | fn pattern_mismatches_are_caught_before_running_dependencies() {
  function pattern_mismatches_are_caught_before_running_invocation (line 257) | fn pattern_mismatches_are_caught_before_running_invocation() {
  function pattern_mismatches_are_caught_in_evaluated_arguments (line 278) | fn pattern_mismatches_are_caught_in_evaluated_arguments() {
  function alternates_do_not_bind_to_anchors (line 297) | fn alternates_do_not_bind_to_anchors() {
  function pattern_match_variadic (line 315) | fn pattern_match_variadic() {
  function pattern_mismatch_variadic (line 328) | fn pattern_mismatch_variadic() {
  function pattern_requires_value (line 346) | fn pattern_requires_value() {
  function short_requires_value (line 367) | fn short_requires_value() {
  function value_requires_value (line 388) | fn value_requires_value() {

FILE: tests/assert_stdout.rs
  function assert_stdout (line 3) | pub(crate) fn assert_stdout(output: &std::process::Output, stdout: &str) {

FILE: tests/assert_success.rs
  function assert_success (line 2) | pub(crate) fn assert_success(output: &std::process::Output) {

FILE: tests/assertions.rs
  function assert_pass (line 4) | fn assert_pass() {
  function assert_fail (line 16) | fn assert_fail() {

FILE: tests/assignment.rs
  function set_export_parse_error (line 4) | fn set_export_parse_error() {
  function set_export_parse_error_eol (line 24) | fn set_export_parse_error_eol() {
  function invalid_attributes_are_an_error (line 44) | fn invalid_attributes_are_an_error() {

FILE: tests/attributes.rs
  function all (line 4) | fn all() {
  function duplicate_attributes_are_disallowed (line 26) | fn duplicate_attributes_are_disallowed() {
  function multiple_attributes_one_line (line 49) | fn multiple_attributes_one_line() {
  function multiple_attributes_one_line_error_message (line 64) | fn multiple_attributes_one_line_error_message() {
  function multiple_attributes_one_line_duplicate_check (line 87) | fn multiple_attributes_one_line_duplicate_check() {
  function unexpected_attribute_argument (line 110) | fn unexpected_attribute_argument() {
  function multiple_metadata_attributes (line 132) | fn multiple_metadata_attributes() {
  function multiple_metadata_attributes_with_multiple_args (line 148) | fn multiple_metadata_attributes_with_multiple_args() {
  function expected_metadata_attribute_argument (line 164) | fn expected_metadata_attribute_argument() {
  function doc_attribute (line 186) | fn doc_attribute() {
  function doc_attribute_suppress (line 207) | fn doc_attribute_suppress() {
  function doc_multiline (line 228) | fn doc_multiline() {
  function extension (line 250) | fn extension() {
  function extension_on_linewise_error (line 265) | fn extension_on_linewise_error() {
  function duplicate_non_repeatable_attributes_are_forbidden (line 286) | fn duplicate_non_repeatable_attributes_are_forbidden() {
  function shell_expanded_strings_can_be_used_in_attributes (line 308) | fn shell_expanded_strings_can_be_used_in_attributes() {
  function env_attribute_single (line 320) | fn env_attribute_single() {
  function env_attribute_multiple (line 334) | fn env_attribute_multiple() {
  function env_attribute_in_recipe_params (line 349) | fn env_attribute_in_recipe_params() {
  function env_attribute_not_in_env_function (line 363) | fn env_attribute_not_in_env_function() {
  function env_attribute_too_few_arguments (line 388) | fn env_attribute_too_few_arguments() {
  function env_attribute_too_many_arguments (line 410) | fn env_attribute_too_many_arguments() {
  function env_attribute_duplicate_error (line 432) | fn env_attribute_duplicate_error() {

FILE: tests/backticks.rs
  function trailing_newlines_are_stripped (line 4) | fn trailing_newlines_are_stripped() {

FILE: tests/byte_order_mark.rs
  function ignore_leading_byte_order_mark (line 4) | fn ignore_leading_byte_order_mark() {
  function non_leading_byte_order_mark_produces_error (line 18) | fn non_leading_byte_order_mark_produces_error() {
  function dont_mention_byte_order_mark_in_errors (line 39) | fn dont_mention_byte_order_mark_in_errors() {

FILE: tests/ceiling.rs
  function justfile_run_search_stops_at_ceiling_dir (line 4) | fn justfile_run_search_stops_at_ceiling_dir() {
  function ceiling_can_be_passed_as_environment_variable (line 32) | fn ceiling_can_be_passed_as_environment_variable() {
  function justfile_init_search_stops_at_ceiling_dir (line 60) | fn justfile_init_search_stops_at_ceiling_dir() {

FILE: tests/changelog.rs
  function print_changelog (line 4) | fn print_changelog() {

FILE: tests/choose.rs
  function env (line 4) | fn env() {
  function chooser (line 23) | fn chooser() {
  function override_variable (line 43) | fn override_variable() {
  function skip_private_recipes (line 65) | fn skip_private_recipes() {
  function recipes_in_submodules_can_be_chosen (line 84) | fn recipes_in_submodules_can_be_chosen() {
  function skip_recipes_that_require_arguments (line 100) | fn skip_recipes_that_require_arguments() {
  function no_choosable_recipes (line 119) | fn no_choosable_recipes() {
  function multiple_recipes (line 136) | fn multiple_recipes() {
  function invoke_error_function (line 156) | fn invoke_error_function() {
  function status_error (line 176) | fn status_error() {
  function cancelled_by_user (line 217) | fn cancelled_by_user() {
  function default (line 249) | fn default() {

FILE: tests/command.rs
  function long (line 4) | fn long() {
  function short (line 20) | fn short() {
  function command_color (line 36) | fn command_color() {
  function no_binary (line 54) | fn no_binary() {
  function env_is_loaded (line 74) | fn env_is_loaded() {
  function exports_are_available (line 91) | fn exports_are_available() {
  function set_overrides_work (line 110) | fn set_overrides_work() {
  function run_in_shell (line 132) | fn run_in_shell() {
  function exit_status (line 148) | fn exit_status() {
  function working_directory_is_correct (line 163) | fn working_directory_is_correct() {
  function command_not_found (line 184) | fn command_not_found() {
  function dont_evaluate_unnecessary_variables (line 204) | fn dont_evaluate_unnecessary_variables() {

FILE: tests/completions.rs
  function bash (line 4) | fn bash() {
  function replacements (line 32) | fn replacements() {

FILE: tests/conditional.rs
  function then_branch_unevaluated (line 4) | fn then_branch_unevaluated() {
  function otherwise_branch_unevaluated (line 18) | fn otherwise_branch_unevaluated() {
  function otherwise_branch_unevaluated_inverted (line 32) | fn otherwise_branch_unevaluated_inverted() {
  function then_branch_unevaluated_inverted (line 46) | fn then_branch_unevaluated_inverted() {
  function complex_expressions (line 60) | fn complex_expressions() {
  function undefined_lhs (line 74) | fn undefined_lhs() {
  function undefined_rhs (line 97) | fn undefined_rhs() {
  function undefined_then (line 120) | fn undefined_then() {
  function undefined_otherwise (line 143) | fn undefined_otherwise() {
  function unexpected_op (line 166) | fn unexpected_op() {
  function dump (line 189) | fn dump() {
  function if_else (line 212) | fn if_else() {
  function missing_else (line 228) | fn missing_else() {
  function incorrect_else_identifier (line 248) | fn incorrect_else_identifier() {

FILE: tests/confirm.rs
  function confirm_recipe_arg (line 4) | fn confirm_recipe_arg() {
  function recipe_with_confirm_recipe_dependency_arg (line 20) | fn recipe_with_confirm_recipe_dependency_arg() {
  function confirm_recipe (line 39) | fn confirm_recipe() {
  function recipe_with_confirm_recipe_dependency (line 55) | fn recipe_with_confirm_recipe_dependency() {
  function do_not_confirm_recipe (line 74) | fn do_not_confirm_recipe() {
  function do_not_confirm_recipe_with_confirm_recipe_dependency (line 88) | fn do_not_confirm_recipe_with_confirm_recipe_dependency() {
  function confirm_recipe_with_prompt (line 105) | fn confirm_recipe_with_prompt() {
  function confirm_recipe_with_prompt_too_many_args (line 121) | fn confirm_recipe_with_prompt_too_many_args() {
  function confirm_attribute_is_formatted_correctly (line 143) | fn confirm_attribute_is_formatted_correctly() {

FILE: tests/constants.rs
  function constants_are_defined (line 4) | fn constants_are_defined() {
  function constants_can_have_different_values_on_windows (line 9) | fn constants_can_have_different_values_on_windows() {
  function constants_are_defined_in_recipe_bodies (line 15) | fn constants_are_defined_in_recipe_bodies() {
  function constants_are_defined_in_recipe_parameters (line 28) | fn constants_are_defined_in_recipe_parameters() {
  function constants_can_be_redefined (line 41) | fn constants_can_be_redefined() {
  function constants_are_not_exported (line 54) | fn constants_are_not_exported() {

FILE: tests/datetime.rs
  function datetime (line 4) | fn datetime() {
  function datetime_utc (line 17) | fn datetime_utc() {

FILE: tests/default.rs
  function default_attribute_overrides_first_recipe (line 4) | fn default_attribute_overrides_first_recipe() {
  function default_attribute_may_only_appear_once_per_justfile (line 21) | fn default_attribute_may_only_appear_once_per_justfile() {

FILE: tests/delimiters.rs
  function mismatched_delimiter (line 4) | fn mismatched_delimiter() {
  function unexpected_delimiter (line 20) | fn unexpected_delimiter() {
  function paren_continuation (line 36) | fn paren_continuation() {
  function brace_continuation (line 56) | fn brace_continuation() {
  function bracket_continuation (line 76) | fn bracket_continuation() {
  function dependency_continuation (line 95) | fn dependency_continuation() {
  function interpolation_continuation (line 114) | fn interpolation_continuation() {

FILE: tests/dependencies.rs
  function recipe_doubly_nested_module_dependencies (line 4) | fn recipe_doubly_nested_module_dependencies() {
  function recipe_singly_nested_module_dependencies (line 21) | fn recipe_singly_nested_module_dependencies() {
  function dependency_not_in_submodule (line 37) | fn dependency_not_in_submodule() {
  function dependency_submodule_missing (line 59) | fn dependency_submodule_missing() {
  function recipe_dependency_on_module_fails (line 83) | fn recipe_dependency_on_module_fails() {
  function recipe_module_dependency_subsequent_mix (line 106) | fn recipe_module_dependency_subsequent_mix() {
  function recipe_module_dependency_only_runs_once (line 124) | fn recipe_module_dependency_only_runs_once() {

FILE: tests/directories.rs
  function cache_directory (line 4) | fn cache_directory() {
  function config_directory (line 13) | fn config_directory() {
  function config_local_directory (line 22) | fn config_local_directory() {
  function data_directory (line 35) | fn data_directory() {
  function data_local_directory (line 44) | fn data_local_directory() {
  function executable_directory (line 53) | fn executable_directory() {
  function home_directory (line 78) | fn home_directory() {

FILE: tests/dotenv.rs
  function dotenv (line 4) | fn dotenv() {
  function set_false (line 16) | fn set_false() {
  function set_implicit (line 32) | fn set_implicit() {
  function set_true (line 49) | fn set_true() {
  function no_warning (line 66) | fn no_warning() {
  function dotenv_required (line 81) | fn dotenv_required() {
  function path_resolves (line 95) | fn path_resolves() {
  function filename_resolves (line 114) | fn filename_resolves() {
  function filename_flag_overwrites_no_load (line 131) | fn filename_flag_overwrites_no_load() {
  function path_flag_overwrites_no_load (line 150) | fn path_flag_overwrites_no_load() {
  function can_set_dotenv_filename_from_justfile (line 171) | fn can_set_dotenv_filename_from_justfile() {
  function can_set_dotenv_path_from_justfile (line 189) | fn can_set_dotenv_path_from_justfile() {
  function program_argument_has_priority_for_dotenv_filename (line 209) | fn program_argument_has_priority_for_dotenv_filename() {
  function program_argument_has_priority_for_dotenv_path (line 229) | fn program_argument_has_priority_for_dotenv_path() {
  function dotenv_path_is_relative_to_working_directory (line 251) | fn dotenv_path_is_relative_to_working_directory() {
  function dotenv_variable_in_recipe (line 269) | fn dotenv_variable_in_recipe() {
  function dotenv_variable_in_backtick (line 286) | fn dotenv_variable_in_backtick() {
  function dotenv_variable_in_function_in_recipe (line 303) | fn dotenv_variable_in_function_in_recipe() {
  function dotenv_variable_in_function_in_backtick (line 320) | fn dotenv_variable_in_function_in_backtick() {
  function no_dotenv (line 339) | fn no_dotenv() {
  function dotenv_env_var_default_no_override (line 356) | fn dotenv_env_var_default_no_override() {
  function dotenv_env_var_override (line 372) | fn dotenv_env_var_override() {
  function dotenv_env_var_override_no_load (line 390) | fn dotenv_env_var_override_no_load() {
  function dotenv_path_usable_from_subdir (line 407) | fn dotenv_path_usable_from_subdir() {
  function dotenv_path_does_not_override_dotenv_file (line 425) | fn dotenv_path_does_not_override_dotenv_file() {
  function error_message (line 438) | fn error_message() {

FILE: tests/dump.rs
  function dump (line 4) | fn dump() {
  function json (line 25) | fn json() {

FILE: tests/edit.rs
  constant JUSTFILE (line 3) | const JUSTFILE: &str = "Yooooooo, hopefully this never becomes valid syn...
  function invalid_justfile (line 7) | fn invalid_justfile() {
  function invoke_error (line 27) | fn invoke_error() {
  function status_error (line 54) | fn status_error() {
  function editor_precedence (line 95) | fn editor_precedence() {
  function editor_working_directory (line 149) | fn editor_working_directory() {

FILE: tests/equals.rs
  function export_recipe (line 4) | fn export_recipe() {
  function alias_recipe (line 18) | fn alias_recipe() {

FILE: tests/error_messages.rs
  function invalid_alias_attribute (line 4) | fn invalid_alias_attribute() {
  function expected_keyword (line 20) | fn expected_keyword() {
  function unexpected_character (line 36) | fn unexpected_character() {
  function argument_count_mismatch (line 52) | fn argument_count_mismatch() {
  function file_path_is_indented_if_justfile_is_long (line 67) | fn file_path_is_indented_if_justfile_is_long() {
  function file_paths_are_relative (line 83) | fn file_paths_are_relative() {
  function file_paths_not_in_subdir_are_absolute (line 100) | fn file_paths_not_in_subdir_are_absolute() {
  function redefinition_errors_properly_swap_types (line 121) | fn redefinition_errors_properly_swap_types() {

FILE: tests/evaluate.rs
  function evaluate (line 4) | fn evaluate() {
  function evaluate_empty (line 29) | fn evaluate_empty() {
  function evaluate_multiple (line 46) | fn evaluate_multiple() {
  function evaluate_single_free (line 63) | fn evaluate_single_free() {
  function evaluate_no_suggestion (line 79) | fn evaluate_no_suggestion() {
  function evaluate_suggestion (line 98) | fn evaluate_suggestion() {
  function evaluate_private (line 116) | fn evaluate_private() {
  function evaluate_single_private (line 132) | fn evaluate_single_private() {
  function dont_evaluate_unnecessary_variables (line 149) | fn dont_evaluate_unnecessary_variables() {

FILE: tests/examples.rs
  function examples (line 4) | fn examples() {

FILE: tests/explain.rs
  function explain_recipe (line 4) | fn explain_recipe() {

FILE: tests/export.rs
  function success (line 4) | fn success() {
  function parameter (line 23) | fn parameter() {
  function parameter_not_visible_to_backtick (line 41) | fn parameter_not_visible_to_backtick() {
  function override_variable (line 58) | fn override_variable() {
  function shebang (line 81) | fn shebang() {
  function recipe_backtick (line 100) | fn recipe_backtick() {
  function setting_implicit (line 116) | fn setting_implicit() {
  function setting_true (line 138) | fn setting_true() {
  function setting_false (line 160) | fn setting_false() {
  function setting_shebang (line 178) | fn setting_shebang() {
  function setting_override_undefined (line 199) | fn setting_override_undefined() {
  function setting_variable_not_visible (line 221) | fn setting_variable_not_visible() {
  function variables_exported_with_setting_are_visible_in_child (line 239) | fn variables_exported_with_setting_are_visible_in_child() {

FILE: tests/fallback.rs
  function fallback_from_subdir_bugfix (line 4) | fn fallback_from_subdir_bugfix() {
  function fallback_from_subdir_message (line 23) | fn fallback_from_subdir_message() {
  function fallback_from_subdir_verbose_message (line 44) | fn fallback_from_subdir_verbose_message() {
  function runs_recipe_in_parent_if_not_found_in_current (line 71) | fn runs_recipe_in_parent_if_not_found_in_current() {
  function setting_accepts_value (line 101) | fn setting_accepts_value() {
  function print_error_from_parent_if_recipe_not_found_in_current (line 131) | fn print_error_from_parent_if_recipe_not_found_in_current() {
  function requires_setting (line 159) | fn requires_setting() {
  function works_with_provided_search_directory (line 182) | fn works_with_provided_search_directory() {
  function doesnt_work_with_justfile (line 212) | fn doesnt_work_with_justfile() {
  function doesnt_work_with_justfile_and_working_directory (line 235) | fn doesnt_work_with_justfile_and_working_directory() {
  function prints_correct_error_message_when_recipe_not_found (line 258) | fn prints_correct_error_message_when_recipe_not_found() {
  function multiple_levels_of_fallback_work (line 287) | fn multiple_levels_of_fallback_work() {
  function stop_fallback_when_fallback_is_false (line 325) | fn stop_fallback_when_fallback_is_false() {
  function works_with_modules (line 361) | fn works_with_modules() {

FILE: tests/format.rs
  function unstable_not_passed (line 4) | fn unstable_not_passed() {
  function check_without_fmt (line 13) | fn check_without_fmt() {
  function check_ok (line 26) | fn check_ok() {
  function check_found_diff (line 51) | fn check_found_diff() {
  function check_found_diff_quiet (line 72) | fn check_found_diff_quiet() {
  function check_diff_color (line 83) | fn check_diff_color() {
  function unstable_passed (line 97) | fn unstable_passed() {
  function write_error (line 121) | fn write_error() {
  function alias_good (line 161) | fn alias_good() {
  function alias_fix_indent (line 184) | fn alias_fix_indent() {
  function assignment_singlequote (line 207) | fn assignment_singlequote() {
  function assignment_doublequote (line 224) | fn assignment_doublequote() {
  function assignment_indented_singlequote (line 241) | fn assignment_indented_singlequote() {
  function assignment_indented_doublequote (line 262) | fn assignment_indented_doublequote() {
  function assignment_backtick (line 283) | fn assignment_backtick() {
  function assignment_indented_backtick (line 300) | fn assignment_indented_backtick() {
  function assignment_name (line 321) | fn assignment_name() {
  function assignment_parenthesized_expression (line 340) | fn assignment_parenthesized_expression() {
  function assignment_export (line 357) | fn assignment_export() {
  function assignment_concat_values (line 374) | fn assignment_concat_values() {
  function assignment_if_oneline (line 391) | fn assignment_if_oneline() {
  function assignment_if_multiline (line 408) | fn assignment_if_multiline() {
  function assignment_nullary_function (line 429) | fn assignment_nullary_function() {
  function assignment_unary_function (line 446) | fn assignment_unary_function() {
  function assignment_binary_function (line 463) | fn assignment_binary_function() {
  function assignment_path_functions (line 480) | fn assignment_path_functions() {
  function recipe_ordinary (line 505) | fn recipe_ordinary() {
  function recipe_with_docstring (line 524) | fn recipe_with_docstring() {
  function recipe_with_comments_in_body (line 545) | fn recipe_with_comments_in_body() {
  function recipe_body_is_comment (line 566) | fn recipe_body_is_comment() {
  function recipe_several_commands (line 585) | fn recipe_several_commands() {
  function recipe_quiet (line 606) | fn recipe_quiet() {
  function recipe_quiet_command (line 625) | fn recipe_quiet_command() {
  function recipe_quiet_comment (line 644) | fn recipe_quiet_comment() {
  function recipe_ignore_errors (line 663) | fn recipe_ignore_errors() {
  function recipe_parameter (line 682) | fn recipe_parameter() {
  function recipe_parameter_default (line 701) | fn recipe_parameter_default() {
  function recipe_parameter_envar (line 720) | fn recipe_parameter_envar() {
  function recipe_parameter_default_envar (line 739) | fn recipe_parameter_default_envar() {
  function recipe_parameter_concat (line 758) | fn recipe_parameter_concat() {
  function recipe_parameters (line 777) | fn recipe_parameters() {
  function recipe_parameters_envar (line 796) | fn recipe_parameters_envar() {
  function recipe_variadic_plus (line 815) | fn recipe_variadic_plus() {
  function recipe_variadic_star (line 834) | fn recipe_variadic_star() {
  function recipe_positional_variadic (line 853) | fn recipe_positional_variadic() {
  function recipe_variadic_default (line 872) | fn recipe_variadic_default() {
  function recipe_parameter_in_body (line 891) | fn recipe_parameter_in_body() {
  function recipe_parameter_conditional (line 910) | fn recipe_parameter_conditional() {
  function recipe_escaped_braces (line 929) | fn recipe_escaped_braces() {
  function recipe_assignment_in_body (line 948) | fn recipe_assignment_in_body() {
  function recipe_dependency (line 971) | fn recipe_dependency() {
  function recipe_dependency_param (line 996) | fn recipe_dependency_param() {
  function recipe_dependency_params (line 1021) | fn recipe_dependency_params() {
  function recipe_dependencies (line 1046) | fn recipe_dependencies() {
  function recipe_dependencies_params (line 1077) | fn recipe_dependencies_params() {
  function set_true_explicit (line 1108) | fn set_true_explicit() {
  function set_true_implicit (line 1125) | fn set_true_implicit() {
  function set_false (line 1142) | fn set_false() {
  function set_shell (line 1159) | fn set_shell() {
  function comment (line 1176) | fn comment() {
  function comment_multiline (line 1193) | fn comment_multiline() {
  function comment_leading (line 1212) | fn comment_leading() {
  function comment_trailing (line 1233) | fn comment_trailing() {
  function comment_before_recipe (line 1254) | fn comment_before_recipe() {
  function comment_before_docstring_recipe (line 1277) | fn comment_before_docstring_recipe() {
  function group_recipes (line 1302) | fn group_recipes() {
  function group_aliases (line 1326) | fn group_aliases() {
  function group_assignments (line 1358) | fn group_assignments() {
  function group_sets (line 1377) | fn group_sets() {
  function group_comments (line 1396) | fn group_comments() {
  function separate_recipes_aliases (line 1416) | fn separate_recipes_aliases() {
  function no_trailing_newline (line 1438) | fn no_trailing_newline() {
  function subsequent (line 1456) | fn subsequent() {
  function exported_parameter (line 1477) | fn exported_parameter() {
  function multi_argument_attribute (line 1486) | fn multi_argument_attribute() {
  function doc_attribute_suppresses_comment (line 1509) | fn doc_attribute_suppresses_comment() {
  function unchanged_justfiles_are_not_written_to_disk (line 1533) | fn unchanged_justfiles_are_not_written_to_disk() {
  function if_else (line 1551) | fn if_else() {
  function private_variable (line 1568) | fn private_variable() {
  function module_groups_are_preserved (line 1587) | fn module_groups_are_preserved() {
  function module_docs_are_preserved (line 1609) | fn module_docs_are_preserved() {
  function arg_attribute_long (line 1629) | fn arg_attribute_long() {
  function arg_attribute_pattern (line 1648) | fn arg_attribute_pattern() {
  function arg_attribute_long_and_pattern (line 1667) | fn arg_attribute_long_and_pattern() {
  function arg_attribute_help (line 1686) | fn arg_attribute_help() {
  function missing_import_file (line 1705) | fn missing_import_file() {
  function missing_module_file (line 1714) | fn missing_module_file() {
  function undefined_variable (line 1723) | fn undefined_variable() {

FILE: tests/format_string.rs
  function empty (line 4) | fn empty() {
  function simple (line 20) | fn simple() {
  function compound (line 35) | fn compound() {
  function newline (line 51) | fn newline() {
  function conditional (line 69) | fn conditional() {
  function conditional_no_whitespace (line 86) | fn conditional_no_whitespace() {
  function inner_delimiter (line 101) | fn inner_delimiter() {
  function nested (line 117) | fn nested() {
  function recipe_body (line 133) | fn recipe_body() {
  function unclosed (line 147) | fn unclosed() {
  function unmatched_close_is_ignored (line 163) | fn unmatched_close_is_ignored() {
  function delimiter_may_be_escaped_in_double_quoted_strings (line 179) | fn delimiter_may_be_escaped_in_double_quoted_strings() {
  function delimiter_may_be_escaped_in_single_quoted_strings (line 192) | fn delimiter_may_be_escaped_in_single_quoted_strings() {
  function escaped_delimiter_is_ignored_in_normal_strings (line 205) | fn escaped_delimiter_is_ignored_in_normal_strings() {
  function escaped_delimiter_in_single_quoted_format_string (line 218) | fn escaped_delimiter_in_single_quoted_format_string() {
  function escaped_delimiter_in_double_quoted_format_string (line 231) | fn escaped_delimiter_in_double_quoted_format_string() {
  function double_quotes_process_escapes (line 252) | fn double_quotes_process_escapes() {
  function single_quotes_do_not_process_escapes (line 265) | fn single_quotes_do_not_process_escapes() {
  function indented_format_strings (line 278) | fn indented_format_strings() {
  function un_indented_format_strings (line 295) | fn un_indented_format_strings() {
  function dump (line 313) | fn dump() {
  function undefined_variable_error (line 336) | fn undefined_variable_error() {
  function format_string_followed_by_recipe (line 356) | fn format_string_followed_by_recipe() {

FILE: tests/functions.rs
  function test_os_arch_functions_in_interpolation (line 4) | fn test_os_arch_functions_in_interpolation() {
  function test_os_arch_functions_in_expression (line 36) | fn test_os_arch_functions_in_expression() {
  function env_var_functions_unix (line 73) | fn env_var_functions_unix() {
  function path_functions (line 100) | fn path_functions() {
  function path_functions2 (line 124) | fn path_functions2() {
  function broken_without_extension_function (line 147) | fn broken_without_extension_function() {
  function broken_extension_function (line 176) | fn broken_extension_function() {
  function broken_extension_function2 (line 204) | fn broken_extension_function2() {
  function broken_file_stem_function (line 232) | fn broken_file_stem_function() {
  function broken_file_name_function (line 260) | fn broken_file_name_function() {
  function broken_directory_function (line 288) | fn broken_directory_function() {
  function broken_directory_function2 (line 317) | fn broken_directory_function2() {
  function env_var_functions_windows (line 346) | fn env_var_functions_windows() {
  function env_var_failure (line 373) | fn env_var_failure() {
  function test_just_executable_function (line 389) | fn test_just_executable_function() {
  function test_os_arch_functions_in_default (line 403) | fn test_os_arch_functions_in_default() {
  function clean (line 435) | fn clean() {
  function uppercase (line 449) | fn uppercase() {
  function lowercase (line 463) | fn lowercase() {
  function uppercamelcase (line 477) | fn uppercamelcase() {
  function lowercamelcase (line 491) | fn lowercamelcase() {
  function snakecase (line 505) | fn snakecase() {
  function kebabcase (line 519) | fn kebabcase() {
  function shoutysnakecase (line 533) | fn shoutysnakecase() {
  function titlecase (line 547) | fn titlecase() {
  function shoutykebabcase (line 561) | fn shoutykebabcase() {
  function trim (line 575) | fn trim() {
  function replace (line 589) | fn replace() {
  function replace_regex (line 603) | fn replace_regex() {
  function invalid_replace_regex (line 617) | fn invalid_replace_regex() {
  function capitalize (line 640) | fn capitalize() {
  function semver_matches (line 654) | fn semver_matches() {
  function trim_end_matches (line 669) | fn trim_end_matches() {
  function trim_end_match (line 676) | fn trim_end_match() {
  function trim_start_matches (line 682) | fn trim_start_matches() {
  function trim_start_match (line 689) | fn trim_start_match() {
  function trim_start (line 695) | fn trim_start() {
  function trim_end (line 700) | fn trim_end() {
  function append (line 705) | fn append() {
  function prepend (line 725) | fn prepend() {
  function join_unix (line 747) | fn join_unix() {
  function join_windows (line 758) | fn join_windows() {
  function join_argument_count_error (line 769) | fn join_argument_count_error() {
  function test_path_exists_filepath_exist (line 786) | fn test_path_exists_filepath_exist() {
  function test_path_exists_filepath_doesnt_exist (line 798) | fn test_path_exists_filepath_doesnt_exist() {
  function error_errors_with_message (line 807) | fn error_errors_with_message() {
  function test_absolute_path_resolves (line 824) | fn test_absolute_path_resolves() {
  function test_absolute_path_resolves_parent (line 844) | fn test_absolute_path_resolves_parent() {
  function path_exists_subdir (line 872) | fn path_exists_subdir() {
  function uuid (line 887) | fn uuid() {
  function choose (line 896) | fn choose() {
  function choose_bad_alphabet_empty (line 905) | fn choose_bad_alphabet_empty() {
  function choose_bad_alphabet_repeated (line 922) | fn choose_bad_alphabet_repeated() {
  function choose_bad_length (line 939) | fn choose_bad_length() {
  function sha256 (line 956) | fn sha256() {
  function sha256_file (line 965) | fn sha256_file() {
  function just_pid (line 980) | fn just_pid() {
  function shell_no_argument (line 991) | fn shell_no_argument() {
  function shell_minimal (line 1008) | fn shell_minimal() {
  function shell_args (line 1013) | fn shell_args() {
  function shell_first_arg (line 1018) | fn shell_first_arg() {
  function shell_error (line 1023) | fn shell_error() {
  function blake3 (line 1040) | fn blake3() {
  function blake3_file (line 1049) | fn blake3_file() {
  function canonicalize (line 1065) | fn canonicalize() {
  function encode_uri_component (line 1075) | fn encode_uri_component() {
  function source_file (line 1084) | fn source_file() {
  function source_directory (line 1115) | fn source_directory() {
  function module_paths (line 1132) | fn module_paths() {
  function is_dependency (line 1253) | fn is_dependency() {
  function unary_argument_count_mismamatch_error_message (line 1276) | fn unary_argument_count_mismamatch_error_message() {
  function dir_abbreviations_are_accepted (line 1293) | fn dir_abbreviations_are_accepted() {
  function invocation_dir_native_abbreviation_is_accepted (line 1308) | fn invocation_dir_native_abbreviation_is_accepted() {
  function absolute_path_argument_is_relative_to_submodule_working_directory (line 1323) | fn absolute_path_argument_is_relative_to_submodule_working_directory() {
  function blake3_file_argument_is_relative_to_submodule_working_directory (line 1341) | fn blake3_file_argument_is_relative_to_submodule_working_directory() {
  function canonicalize_argument_is_relative_to_submodule_working_directory (line 1359) | fn canonicalize_argument_is_relative_to_submodule_working_directory() {
  function path_exists_argument_is_relative_to_submodule_working_directory (line 1377) | fn path_exists_argument_is_relative_to_submodule_working_directory() {
  function sha256_file_argument_is_relative_to_submodule_working_directory (line 1395) | fn sha256_file_argument_is_relative_to_submodule_working_directory() {
  function style_command_default (line 1413) | fn style_command_default() {
  function style_command_non_default (line 1426) | fn style_command_non_default() {
  function style_error (line 1440) | fn style_error() {
  function style_warning (line 1453) | fn style_warning() {
  function style_unknown (line 1466) | fn style_unknown() {
  function read (line 1487) | fn read() {
  function read_file_not_found (line 1497) | fn read_file_not_found() {

FILE: tests/global.rs
  function macos (line 4) | fn macos() {
  function not_macos (line 26) | fn not_macos() {
  function unix (line 45) | fn unix() {
  function case_insensitive (line 74) | fn case_insensitive() {

FILE: tests/groups.rs
  function list_group_unknown (line 4) | fn list_group_unknown() {
  function list_group (line 18) | fn list_group() {
  function list_multiple_groups (line 45) | fn list_multiple_groups() {
  function list_with_groups (line 83) | fn list_with_groups() {
  function list_with_groups_unsorted (line 127) | fn list_with_groups_unsorted() {
  function list_with_groups_unsorted_group_order (line 177) | fn list_with_groups_unsorted_group_order() {
  function list_groups (line 217) | fn list_groups() {
  function list_groups_with_custom_prefix (line 242) | fn list_groups_with_custom_prefix() {
  function list_groups_with_shorthand_syntax (line 266) | fn list_groups_with_shorthand_syntax() {
  function list_groups_unsorted (line 289) | fn list_groups_unsorted() {
  function list_groups_private_unsorted (line 316) | fn list_groups_private_unsorted() {
  function list_groups_private (line 343) | fn list_groups_private() {
  function list_group_with_submodules (line 366) | fn list_group_with_submodules() {

FILE: tests/guards.rs
  function guard_lines_halt_execution (line 4) | fn guard_lines_halt_execution() {
  function guard_lines_have_no_effect_if_successful (line 19) | fn guard_lines_have_no_effect_if_successful() {
  function exit_codes_above_one_are_reserved (line 35) | fn exit_codes_above_one_are_reserved() {
  function guard_sigil_may_not_be_used_with_infallible_sigil (line 50) | fn guard_sigil_may_not_be_used_with_infallible_sigil() {
  function guard_lines_are_ignored_without_setting (line 73) | fn guard_lines_are_ignored_without_setting() {

FILE: tests/ignore_comments.rs
  function ignore_comments_in_recipe (line 4) | fn ignore_comments_in_recipe() {
  function dont_ignore_comments_in_recipe_by_default (line 21) | fn dont_ignore_comments_in_recipe_by_default() {
  function ignore_recipe_comments_with_shell_setting (line 36) | fn ignore_recipe_comments_with_shell_setting() {
  function continuations_with_echo_comments_false (line 54) | fn continuations_with_echo_comments_false() {
  function continuations_with_echo_comments_true (line 71) | fn continuations_with_echo_comments_true() {
  function dont_evaluate_comments (line 87) | fn dont_evaluate_comments() {
  function dont_analyze_comments (line 101) | fn dont_analyze_comments() {
  function comments_still_must_be_parsable_when_ignored (line 115) | fn comments_still_must_be_parsable_when_ignored() {

FILE: tests/imports.rs
  function import_succeeds (line 4) | fn import_succeeds() {
  function missing_import_file_error (line 26) | fn missing_import_file_error() {
  function missing_optional_imports_are_ignored (line 50) | fn missing_optional_imports_are_ignored() {
  function trailing_spaces_after_import_are_ignored (line 66) | fn trailing_spaces_after_import_are_ignored() {
  function import_after_recipe (line 83) | fn import_after_recipe() {
  function circular_import (line 102) | fn circular_import() {
  function import_recipes_are_not_default (line 116) | fn import_recipes_are_not_default() {
  function listed_recipes_in_imports_are_in_load_order (line 127) | fn listed_recipes_in_imports_are_in_load_order() {
  function include_error (line 148) | fn include_error() {
  function recipes_in_import_are_overridden_by_recipes_in_parent (line 164) | fn recipes_in_import_are_overridden_by_recipes_in_parent() {
  function variables_in_import_are_overridden_by_variables_in_parent (line 188) | fn variables_in_import_are_overridden_by_variables_in_parent() {
  function import_paths_beginning_with_tilde_are_expanded_to_homdir (line 213) | fn import_paths_beginning_with_tilde_are_expanded_to_homdir() {
  function imports_dump_correctly (line 231) | fn imports_dump_correctly() {
  function optional_imports_dump_correctly (line 245) | fn optional_imports_dump_correctly() {
  function imports_in_root_run_in_justfile_directory (line 259) | fn imports_in_root_run_in_justfile_directory() {
  function imports_in_submodules_run_in_submodule_directory (line 274) | fn imports_in_submodules_run_in_submodule_directory() {
  function nested_import_paths_are_relative_to_containing_submodule (line 287) | fn nested_import_paths_are_relative_to_containing_submodule() {
  function recipes_in_nested_imports_run_in_parent_module (line 298) | fn recipes_in_nested_imports_run_in_parent_module() {
  function shebang_recipes_in_imports_in_root_run_in_justfile_directory (line 310) | fn shebang_recipes_in_imports_in_root_run_in_justfile_directory() {
  function recipes_imported_in_root_run_in_command_line_provided_working_directory (line 328) | fn recipes_imported_in_root_run_in_command_line_provided_working_directo...
  function reused_import_are_allowed (line 344) | fn reused_import_are_allowed() {
  function multiply_imported_items_do_not_conflict (line 363) | fn multiply_imported_items_do_not_conflict() {
  function nested_multiply_imported_items_do_not_conflict (line 386) | fn nested_multiply_imported_items_do_not_conflict() {

FILE: tests/init.rs
  function current_dir (line 4) | fn current_dir() {
  function exists (line 22) | fn exists() {
  function write_error (line 37) | fn write_error() {
  function invocation_directory (line 56) | fn invocation_directory() {
  function parent_dir (line 75) | fn parent_dir() {
  function alternate_marker (line 96) | fn alternate_marker() {
  function search_directory (line 116) | fn search_directory() {
  function justfile (line 139) | fn justfile() {
  function justfile_and_working_directory (line 163) | fn justfile_and_working_directory() {
  function fmt_compatibility (line 189) | fn fmt_compatibility() {

FILE: tests/interpolation.rs
  function closing_curly_brace_can_abut_interpolation_close (line 4) | fn closing_curly_brace_can_abut_interpolation_close() {
  function eol_with_continuation_in_interpolation (line 18) | fn eol_with_continuation_in_interpolation() {
  function eol_without_continuation_in_interpolation (line 34) | fn eol_without_continuation_in_interpolation() {
  function comment_in_interopolation (line 50) | fn comment_in_interopolation() {
  function indent_and_dedent_are_ignored_in_interpolation (line 73) | fn indent_and_dedent_are_ignored_in_interpolation() {
  function shebang_line_numbers_are_correct_with_multi_line_interpolations (line 92) | fn shebang_line_numbers_are_correct_with_multi_line_interpolations() {

FILE: tests/invocation_directory.rs
  function convert_native_path (line 4) | fn convert_native_path(path: &Path) -> String {
  function convert_native_path (line 13) | fn convert_native_path(path: &Path) -> String {
  function test_invocation_directory (line 36) | fn test_invocation_directory() {
  function invocation_directory_native (line 85) | fn invocation_directory_native() {

FILE: tests/json.rs
  type Alias (line 5) | struct Alias<'a> {
  type Assignment (line 13) | struct Assignment<'a> {
  type Dependency (line 23) | struct Dependency<'a> {
  type Interpreter (line 30) | struct Interpreter<'a> {
  type Module (line 37) | struct Module<'a> {
  type Parameter (line 53) | struct Parameter<'a> {
  type Recipe (line 67) | struct Recipe<'a> {
  type Settings (line 83) | struct Settings<'a> {
  function case (line 108) | fn case(justfile: &str, expected: Module) {
  function fix_source (line 112) | fn fix_source(dir: &Path, module: &mut Module) {
  function case_with_submodule (line 131) | fn case_with_submodule(justfile: &str, submodule: Option<(&str, &str)>, ...
  function alias (line 150) | fn alias() {
  function assignment (line 183) | fn assignment() {
  function private_assignment (line 202) | fn private_assignment() {
  function body (line 237) | fn body() {
  function dependencies (line 262) | fn dependencies() {
  function dependency_argument (line 301) | fn dependency_argument() {
  function duplicate_recipes (line 380) | fn duplicate_recipes() {
  function duplicate_variables (line 425) | fn duplicate_variables() {
  function doc_comment (line 452) | fn doc_comment() {
  function empty_justfile (line 473) | fn empty_justfile() {
  function parameters (line 478) | fn parameters() {
  function priors (line 579) | fn priors() {
  function private (line 633) | fn private() {
  function quiet (line 654) | fn quiet() {
  function settings (line 675) | fn settings() {
  function shebang (line 726) | fn shebang() {
  function simple (line 751) | fn simple() {
  function attribute (line 771) | fn attribute() {
  function single_metadata_attribute (line 795) | fn single_metadata_attribute() {
  function multiple_metadata_attributes (line 819) | fn multiple_metadata_attributes() {
  function multiple_metadata_attributes_with_multiple_arguments (line 848) | fn multiple_metadata_attributes_with_multiple_arguments() {
  function module (line 877) | fn module() {
  function module_group (line 910) | fn module_group() {
  function recipes_with_private_attribute_are_private (line 943) | fn recipes_with_private_attribute_are_private() {
  function doc_attribute_overrides_comment (line 968) | fn doc_attribute_overrides_comment() {
  function format_string (line 994) | fn format_string() {
  function arg_pattern (line 1056) | fn arg_pattern() {
  function arg_long (line 1094) | fn arg_long() {
  function arg_short (line 1132) | fn arg_short() {
  function arg_value (line 1170) | fn arg_value() {
  function arg_help (line 1209) | fn arg_help() {

FILE: tests/lazy.rs
  function lazy_is_unstable (line 4) | fn lazy_is_unstable() {
  function eager_is_unstable (line 18) | fn eager_is_unstable() {
  function unused_assignments_are_evaluated_without_lazy (line 32) | fn unused_assignments_are_evaluated_without_lazy() {
  function unused_assignment_not_evaluated (line 54) | fn unused_assignment_not_evaluated() {
  function used_assignment_evaluated (line 72) | fn used_assignment_evaluated() {
  function transitively_used_assignment_evaluated (line 98) | fn transitively_used_assignment_evaluated() {
  function assignment_used_in_parameter_default_evaluated (line 125) | fn assignment_used_in_parameter_default_evaluated() {
  function assignment_used_in_dependency_argument_evaluated (line 150) | fn assignment_used_in_dependency_argument_evaluated() {
  function assignment_in_body_interpolation_evaluated (line 177) | fn assignment_in_body_interpolation_evaluated() {
  function multiple_invocations_evaluate_union (line 203) | fn multiple_invocations_evaluate_union() {
  function assignment_used_in_dependency_evaluated (line 227) | fn assignment_used_in_dependency_evaluated() {
  function assignment_used_in_transitive_dependency_evaluated (line 255) | fn assignment_used_in_transitive_dependency_evaluated() {
  function exported_assignment_is_evaluated (line 285) | fn exported_assignment_is_evaluated() {
  function assignment_with_set_export_is_evaluated (line 303) | fn assignment_with_set_export_is_evaluated() {
  function eager_assignments_are_evaluated (line 322) | fn eager_assignments_are_evaluated() {

FILE: tests/lib.rs
  constant JUST (line 31) | const JUST: &str = env!("CARGO_BIN_EXE_just");
  function default (line 36) | fn default<T: Default>() -> T {
  function path (line 149) | fn path(s: &str) -> String {
  function path_for_regex (line 157) | fn path_for_regex(s: &str) -> String {

FILE: tests/line_prefixes.rs
  function infallible_after_quiet (line 4) | fn infallible_after_quiet() {
  function quiet_after_infallible (line 16) | fn quiet_after_infallible() {

FILE: tests/list.rs
  function modules_unsorted (line 4) | fn modules_unsorted() {
  function unsorted_list_order (line 27) | fn unsorted_list_order() {
  function list_submodule (line 150) | fn list_submodule() {
  function list_nested_submodule (line 169) | fn list_nested_submodule() {
  function list_invalid_path (line 206) | fn list_invalid_path() {
  function list_unknown_submodule (line 214) | fn list_unknown_submodule() {
  function list_with_groups_in_modules (line 222) | fn list_with_groups_in_modules() {
  function list_displays_recipes_in_submodules (line 249) | fn list_displays_recipes_in_submodules() {
  function modules_are_space_separated_in_output (line 269) | fn modules_are_space_separated_in_output() {
  function module_recipe_list_alignment_ignores_private_recipes (line 295) | fn module_recipe_list_alignment_ignores_private_recipes() {
  function nested_modules_are_properly_indented (line 325) | fn nested_modules_are_properly_indented() {
  function module_doc_rendered (line 347) | fn module_doc_rendered() {
  function module_doc_aligned (line 367) | fn module_doc_aligned() {
  function submodules_without_groups (line 397) | fn submodules_without_groups() {
  function no_space_before_submodules_not_following_groups (line 422) | fn no_space_before_submodules_not_following_groups() {
  function backticks_highlighted (line 441) | fn backticks_highlighted() {
  function unclosed_backticks (line 459) | fn unclosed_backticks() {
  function list_submodules_requires_list (line 477) | fn list_submodules_requires_list() {

FILE: tests/logical_operators.rs
  function evaluate (line 4) | fn evaluate(expression: &str, expected: &str) {
  function logical_operators_are_unstable (line 14) | fn logical_operators_are_unstable() {
  function and_returns_empty_string_if_lhs_is_empty (line 29) | fn and_returns_empty_string_if_lhs_is_empty() {
  function and_returns_rhs_if_lhs_is_non_empty (line 34) | fn and_returns_rhs_if_lhs_is_non_empty() {
  function and_has_lower_precedence_than_plus (line 39) | fn and_has_lower_precedence_than_plus() {
  function or_returns_rhs_if_lhs_is_empty (line 50) | fn or_returns_rhs_if_lhs_is_empty() {
  function or_returns_lhs_if_lhs_is_non_empty (line 55) | fn or_returns_lhs_if_lhs_is_non_empty() {
  function or_has_lower_precedence_than_plus (line 60) | fn or_has_lower_precedence_than_plus() {
  function and_has_higher_precedence_than_or (line 71) | fn and_has_higher_precedence_than_or() {
  function nesting (line 78) | fn nesting() {

FILE: tests/man.rs
  function output (line 4) | fn output() {

FILE: tests/misc.rs
  function alias_listing (line 4) | fn alias_listing() {
  function alias_listing_with_doc (line 25) | fn alias_listing_with_doc() {
  function alias_listing_multiple_aliases (line 47) | fn alias_listing_multiple_aliases() {
  function alias_listing_parameters (line 61) | fn alias_listing_parameters() {
  function alias_listing_private (line 75) | fn alias_listing_private() {
  function alias (line 89) | fn alias() {
  function alias_with_parameters (line 99) | fn alias_with_parameters() {
  function bad_setting (line 110) | fn bad_setting() {
  function bad_setting_with_keyword_name (line 130) | fn bad_setting_with_keyword_name() {
  function alias_with_dependencies (line 150) | fn alias_with_dependencies() {
  function duplicate_alias (line 160) | fn duplicate_alias() {
  function unknown_alias_target (line 176) | fn unknown_alias_target() {
  function alias_shadows_recipe (line 192) | fn alias_shadows_recipe() {
  function default (line 208) | fn default() {
  function quiet (line 217) | fn quiet() {
  function verbose (line 225) | fn verbose() {
  function order (line 235) | fn order() {
  function select (line 264) | fn select() {
  function print (line 274) | fn print() {
  function status_passthrough (line 285) | fn status_passthrough() {
  function unknown_dependency (line 301) | fn unknown_dependency() {
  function backtick_success (line 317) | fn backtick_success() {
  function backtick_trimming (line 326) | fn backtick_trimming() {
  function backtick_code_assignment (line 335) | fn backtick_code_assignment() {
  function backtick_code_interpolation (line 351) | fn backtick_code_interpolation() {
  function backtick_code_interpolation_mod (line 367) | fn backtick_code_interpolation_mod() {
  function backtick_code_interpolation_tab (line 383) | fn backtick_code_interpolation_tab() {
  function backtick_code_interpolation_tabs (line 403) | fn backtick_code_interpolation_tabs() {
  function backtick_code_interpolation_inner_tab (line 423) | fn backtick_code_interpolation_inner_tab() {
  function backtick_code_interpolation_leading_emoji (line 444) | fn backtick_code_interpolation_leading_emoji() {
  function backtick_code_interpolation_unicode_hell (line 465) | fn backtick_code_interpolation_unicode_hell() {
  function backtick_code_long (line 486) | fn backtick_code_long() {
  function shebang_backtick_failure (line 515) | fn shebang_backtick_failure() {
  function command_backtick_failure (line 536) | fn command_backtick_failure() {
  function assignment_backtick_failure (line 558) | fn assignment_backtick_failure() {
  function dry_run (line 579) | fn dry_run() {
  function line_error_spacing (line 613) | fn line_error_spacing() {
  function argument_single (line 641) | fn argument_single() {
  function argument_multiple (line 657) | fn argument_multiple() {
  function argument_mismatch_more (line 674) | fn argument_mismatch_more() {
  function argument_mismatch_fewer (line 691) | fn argument_mismatch_fewer() {
  function argument_mismatch_more_with_default (line 706) | fn argument_mismatch_more_with_default() {
  function argument_mismatch_fewer_with_default (line 723) | fn argument_mismatch_fewer_with_default() {
  function unknown_recipe (line 744) | fn unknown_recipe() {
  function unknown_recipes (line 753) | fn unknown_recipes() {
  function color_always (line 763) | fn color_always() {
  function color_never (line 773) | fn color_never() {
  function color_auto (line 790) | fn color_auto() {
  function colors_no_context (line 807) | fn colors_no_context() {
  function mixed_whitespace (line 823) | fn mixed_whitespace() {
  function extra_leading_whitespace (line 839) | fn extra_leading_whitespace() {
  function inconsistent_leading_whitespace (line 854) | fn inconsistent_leading_whitespace() {
  function required_after_default (line 870) | fn required_after_default() {
  function required_after_plus_variadic (line 885) | fn required_after_plus_variadic() {
  function required_after_star_variadic (line 900) | fn required_after_star_variadic() {
  function use_string_default (line 915) | fn use_string_default() {
  function use_raw_string_default (line 932) | fn use_raw_string_default() {
  function supply_use_default (line 949) | fn supply_use_default() {
  function supply_defaults (line 966) | fn supply_defaults() {
  function list (line 984) | fn list() {
  function list_alignment (line 1013) | fn list_alignment() {
  function list_alignment_long (line 1041) | fn list_alignment_long() {
  function list_sorted (line 1074) | fn list_sorted() {
  function list_unsorted (line 1095) | fn list_unsorted() {
  function list_heading (line 1117) | fn list_heading() {
  function list_prefix (line 1139) | fn list_prefix() {
  function list_empty_prefix_and_heading (line 1161) | fn list_empty_prefix_and_heading() {
  function run_suggestion (line 1184) | fn run_suggestion() {
  function private_recipes_are_not_suggested (line 1193) | fn private_recipes_are_not_suggested() {
  function alias_suggestion (line 1207) | fn alias_suggestion() {
  function private_aliases_are_not_suggested (line 1224) | fn private_aliases_are_not_suggested() {
  function line_continuation_with_space (line 1240) | fn line_continuation_with_space() {
  function line_continuation_with_quoted_space (line 1256) | fn line_continuation_with_quoted_space() {
  function line_continuation_no_space (line 1272) | fn line_continuation_no_space() {
  function infallible_command (line 1288) | fn infallible_command() {
  function infallible_with_failing (line 1301) | fn infallible_with_failing() {
  function quiet_recipe (line 1320) | fn quiet_recipe() {
  function quiet_shebang_recipe (line 1336) | fn quiet_shebang_recipe() {
  function complex_dependencies (line 1351) | fn complex_dependencies() {
  function unknown_function_in_assignment (line 1365) | fn unknown_function_in_assignment() {
  function dependency_takes_arguments_exact (line 1384) | fn dependency_takes_arguments_exact() {
  function dependency_takes_arguments_at_least (line 1405) | fn dependency_takes_arguments_at_least() {
  function dependency_takes_arguments_at_most (line 1426) | fn dependency_takes_arguments_at_most() {
  function duplicate_parameter (line 1447) | fn duplicate_parameter() {
  function duplicate_recipe (line 1463) | fn duplicate_recipe() {
  function duplicate_variable (line 1479) | fn duplicate_variable() {
  function unexpected_token_in_dependency_position (line 1495) | fn unexpected_token_in_dependency_position() {
  function unexpected_token_after_name (line 1512) | fn unexpected_token_after_name() {
  function self_dependency (line 1528) | fn self_dependency() {
  function long_circular_recipe_dependency (line 1544) | fn long_circular_recipe_dependency() {
  function variable_self_dependency (line 1560) | fn variable_self_dependency() {
  function variable_circular_dependency (line 1576) | fn variable_circular_dependency() {
  function variable_circular_dependency_with_additional_variable (line 1592) | fn variable_circular_dependency_with_additional_variable() {
  function plus_variadic_recipe (line 1616) | fn plus_variadic_recipe() {
  function plus_variadic_ignore_default (line 1636) | fn plus_variadic_ignore_default() {
  function plus_variadic_use_default (line 1656) | fn plus_variadic_use_default() {
  function plus_variadic_too_few (line 1673) | fn plus_variadic_too_few() {
  function star_variadic_recipe (line 1695) | fn star_variadic_recipe() {
  function star_variadic_none (line 1715) | fn star_variadic_none() {
  function star_variadic_ignore_default (line 1732) | fn star_variadic_ignore_default() {
  function star_variadic_use_default (line 1752) | fn star_variadic_use_default() {
  function star_then_plus_variadic (line 1769) | fn star_then_plus_variadic() {
  function plus_then_star_variadic (line 1789) | fn plus_then_star_variadic() {
  function argument_grouping (line 1809) | fn argument_grouping() {
  function missing_second_dependency (line 1838) | fn missing_second_dependency() {
  function list_colors (line 1859) | fn list_colors() {
  function run_colors (line 1884) | fn run_colors() {
  function no_highlight (line 1903) | fn no_highlight() {
  function trailing_flags (line 1923) | fn trailing_flags() {
  function comment_before_variable (line 1941) | fn comment_before_variable() {
  function invalid_escape_sequence_message (line 1958) | fn invalid_escape_sequence_message() {
  function unknown_variable_in_default (line 1977) | fn unknown_variable_in_default() {
  function unknown_function_in_default (line 1996) | fn unknown_function_in_default() {
  function default_string (line 2015) | fn default_string() {
  function default_concatenation (line 2029) | fn default_concatenation() {
  function default_backtick (line 2043) | fn default_backtick() {
  function default_variable (line 2057) | fn default_variable() {
  function unterminated_interpolation_eol (line 2072) | fn unterminated_interpolation_eol() {
  function unterminated_interpolation_eof (line 2093) | fn unterminated_interpolation_eof() {
  function unknown_start_of_token (line 2114) | fn unknown_start_of_token() {
  function unknown_start_of_token_invisible_unicode (line 2134) | fn unknown_start_of_token_invisible_unicode() {
  function unknown_start_of_token_ascii_control_char (line 2154) | fn unknown_start_of_token_ascii_control_char() {
  function backtick_variable_cat (line 2174) | fn backtick_variable_cat() {
  function backtick_default_cat_stdin (line 2191) | fn backtick_default_cat_stdin() {
  function backtick_default_cat_justfile (line 2206) | fn backtick_default_cat_justfile() {
  function backtick_variable_read_single (line 2230) | fn backtick_variable_read_single() {
  function backtick_variable_read_multiple (line 2247) | fn backtick_variable_read_multiple() {
  function backtick_default_read_multiple (line 2266) | fn backtick_default_read_multiple() {
  function old_equals_assignment_syntax_produces_error (line 2283) | fn old_equals_assignment_syntax_produces_error() {
  function dependency_argument_string (line 2306) | fn dependency_argument_string() {
  function dependency_argument_parameter (line 2323) | fn dependency_argument_parameter() {
  function dependency_argument_function (line 2342) | fn dependency_argument_function() {
  function env_function_as_env_var (line 2359) | fn env_function_as_env_var() {
  function env_function_as_env_var_or_default (line 2377) | fn env_function_as_env_var_or_default() {
  function env_function_as_env_var_with_existing_env_var (line 2395) | fn env_function_as_env_var_with_existing_env_var() {
  function env_function_as_env_var_or_default_with_existing_env_var (line 2413) | fn env_function_as_env_var_or_default_with_existing_env_var() {
  function dependency_argument_backtick (line 2431) | fn dependency_argument_backtick() {
  function dependency_argument_assignment (line 2451) | fn dependency_argument_assignment() {
  function dependency_argument_plus_variadic (line 2470) | fn dependency_argument_plus_variadic() {
  function duplicate_dependency_no_args (line 2487) | fn duplicate_dependency_no_args() {
  function duplicate_dependency_argument (line 2504) | fn duplicate_dependency_argument() {
  function pwsh_invocation_directory (line 2521) | fn pwsh_invocation_directory() {
  function variables (line 2539) | fn variables() {
  function interpolation_evaluation_ignore_quiet (line 2554) | fn interpolation_evaluation_ignore_quiet() {
  function interpolation_evaluation_ignore_quiet_continuation (line 2573) | fn interpolation_evaluation_ignore_quiet_continuation() {
  function brace_escape (line 2593) | fn brace_escape() {
  function brace_escape_extra (line 2611) | fn brace_escape_extra() {
  function multi_line_string_in_interpolation (line 2629) | fn multi_line_string_in_interpolation() {
  function windows_interpreter_path_no_base (line 2646) | fn windows_interpreter_path_no_base() {

FILE: tests/modules.rs
  function modules_are_stable (line 4) | fn modules_are_stable() {
  function default_recipe_in_submodule_must_have_no_arguments (line 18) | fn default_recipe_in_submodule_must_have_no_arguments() {
  function module_recipes_can_be_run_as_subcommands (line 32) | fn module_recipes_can_be_run_as_subcommands() {
  function module_recipes_can_be_run_with_path_syntax (line 47) | fn module_recipes_can_be_run_with_path_syntax() {
  function nested_module_recipes_can_be_run_with_path_syntax (line 61) | fn nested_module_recipes_can_be_run_with_path_syntax() {
  function invalid_path_syntax (line 76) | fn invalid_path_syntax() {
  function missing_recipe_after_invalid_path (line 94) | fn missing_recipe_after_invalid_path() {
  function assignments_are_evaluated_in_modules (line 103) | fn assignments_are_evaluated_in_modules() {
  function module_subcommand_runs_default_recipe (line 119) | fn module_subcommand_runs_default_recipe() {
  function modules_can_contain_other_modules (line 133) | fn modules_can_contain_other_modules() {
  function circular_module_imports_are_detected (line 150) | fn circular_module_imports_are_detected() {
  function modules_use_module_settings (line 169) | fn modules_use_module_settings() {
  function modules_conflict_with_recipes (line 219) | fn modules_conflict_with_recipes() {
  function modules_conflict_with_aliases (line 241) | fn modules_conflict_with_aliases() {
  function modules_conflict_with_other_modules (line 264) | fn modules_conflict_with_other_modules() {
  function modules_are_dumped_correctly (line 288) | fn modules_are_dumped_correctly() {
  function optional_modules_are_dumped_correctly (line 302) | fn optional_modules_are_dumped_correctly() {
  function modules_can_be_in_subdirectory (line 316) | fn modules_can_be_in_subdirectory() {
  function modules_in_subdirectory_can_be_named_justfile (line 331) | fn modules_in_subdirectory_can_be_named_justfile() {
  function modules_in_subdirectory_can_be_named_justfile_with_any_case (line 346) | fn modules_in_subdirectory_can_be_named_justfile_with_any_case() {
  function modules_in_subdirectory_can_have_leading_dot (line 361) | fn modules_in_subdirectory_can_have_leading_dot() {
  function modules_require_unambiguous_file (line 376) | fn modules_require_unambiguous_file() {
  function missing_module_file_error (line 399) | fn missing_module_file_error() {
  function missing_optional_modules_do_not_trigger_error (line 419) | fn missing_optional_modules_do_not_trigger_error() {
  function missing_optional_modules_do_not_conflict (line 434) | fn missing_optional_modules_do_not_conflict() {
  function root_dotenv_is_available_to_submodules (line 451) | fn root_dotenv_is_available_to_submodules() {
  function dotenv_settings_in_submodule_are_ignored (line 468) | fn dotenv_settings_in_submodule_are_ignored() {
  function modules_may_specify_path (line 488) | fn modules_may_specify_path() {
  function modules_may_specify_path_to_directory (line 503) | fn modules_may_specify_path_to_directory() {
  function modules_with_paths_are_dumped_correctly (line 518) | fn modules_with_paths_are_dumped_correctly() {
  function optional_modules_with_paths_are_dumped_correctly (line 532) | fn optional_modules_with_paths_are_dumped_correctly() {
  function recipes_may_be_named_mod (line 546) | fn recipes_may_be_named_mod() {
  function submodule_linewise_recipes_run_in_submodule_directory (line 561) | fn submodule_linewise_recipes_run_in_submodule_directory() {
  function submodule_shebang_recipes_run_in_submodule_directory (line 577) | fn submodule_shebang_recipes_run_in_submodule_directory() {
  function cross_module_dependency_runs_in_submodule_directory (line 593) | fn cross_module_dependency_runs_in_submodule_directory() {
  function cross_module_dependency_with_no_cd_runs_in_invocation_directory (line 610) | fn cross_module_dependency_with_no_cd_runs_in_invocation_directory() {
  function nested_cross_module_dependency_runs_in_correct_directory (line 634) | fn nested_cross_module_dependency_runs_in_correct_directory() {
  function modulepaths_beginning_with_tilde_are_expanded_to_homdir (line 652) | fn modulepaths_beginning_with_tilde_are_expanded_to_homdir() {
  function recipes_with_same_name_are_both_run (line 671) | fn recipes_with_same_name_are_both_run() {
  function submodule_recipe_not_found_error_message (line 689) | fn submodule_recipe_not_found_error_message() {
  function submodule_recipe_not_found_spaced_error_message (line 697) | fn submodule_recipe_not_found_spaced_error_message() {
  function submodule_recipe_not_found_colon_separated_error_message (line 711) | fn submodule_recipe_not_found_colon_separated_error_message() {
  function colon_separated_path_does_not_run_recipes (line 725) | fn colon_separated_path_does_not_run_recipes() {
  function expected_submodule_but_found_recipe_in_root_error (line 742) | fn expected_submodule_but_found_recipe_in_root_error() {
  function expected_submodule_but_found_recipe_in_submodule_error (line 751) | fn expected_submodule_but_found_recipe_in_submodule_error() {
  function colon_separated_path_components_are_not_used_as_arguments (line 761) | fn colon_separated_path_components_are_not_used_as_arguments() {
  function comments_can_follow_modules (line 770) | fn comments_can_follow_modules() {
  function doc_comment_on_module (line 784) | fn doc_comment_on_module() {
  function doc_attribute_on_module (line 800) | fn doc_attribute_on_module() {
  function group_attribute_on_module (line 817) | fn group_attribute_on_module() {
  function group_attribute_on_module_unsorted (line 863) | fn group_attribute_on_module_unsorted() {
  function group_attribute_on_module_list_submodule (line 910) | fn group_attribute_on_module_list_submodule() {
  function group_attribute_on_module_list_submodule_unsorted (line 960) | fn group_attribute_on_module_list_submodule_unsorted() {
  function bad_module_attribute_fails (line 1011) | fn bad_module_attribute_fails() {
  function empty_doc_attribute_on_module (line 1027) | fn empty_doc_attribute_on_module() {
  function overrides_work_when_submodule_is_present (line 1044) | fn overrides_work_when_submodule_is_present() {
  function exported_variables_are_available_in_submodules (line 1064) | fn exported_variables_are_available_in_submodules() {
  function exported_variables_can_be_unexported_in_submodules (line 1081) | fn exported_variables_can_be_unexported_in_submodules() {
  function exported_variables_can_be_overridden_in_submodules (line 1098) | fn exported_variables_can_be_overridden_in_submodules() {

FILE: tests/multibyte_char.rs
  function bugfix (line 4) | fn bugfix() {

FILE: tests/newline_escape.rs
  function newline_escape_deps (line 4) | fn newline_escape_deps() {
  function newline_escape_deps_no_indent (line 25) | fn newline_escape_deps_no_indent() {
  function newline_escape_deps_linefeed (line 46) | fn newline_escape_deps_linefeed() {
  function newline_escape_deps_invalid_esc (line 64) | fn newline_escape_deps_invalid_esc() {
  function newline_escape_unpaired_linefeed (line 84) | fn newline_escape_unpaired_linefeed() {

FILE: tests/no_aliases.rs
  function skip_alias (line 4) | fn skip_alias() {

FILE: tests/no_cd.rs
  function linewise (line 4) | fn linewise() {
  function shebang (line 25) | fn shebang() {

FILE: tests/no_dependencies.rs
  function skip_normal_dependency (line 4) | fn skip_normal_dependency() {
  function skip_prior_dependency (line 20) | fn skip_prior_dependency() {
  function skip_dependency_multi (line 36) | fn skip_dependency_multi() {

FILE: tests/no_exit_message.rs
  function recipe_exit_message_suppressed (line 4) | fn recipe_exit_message_suppressed() {
  function silent_recipe_exit_message_suppressed (line 20) | fn silent_recipe_exit_message_suppressed() {
  function recipe_has_doc_comment (line 36) | fn recipe_has_doc_comment() {
  function unknown_attribute (line 57) | fn unknown_attribute() {
  function empty_attribute (line 80) | fn empty_attribute() {
  function extraneous_attribute_before_comment (line 103) | fn extraneous_attribute_before_comment() {
  function extraneous_attribute_before_empty_line (line 126) | fn extraneous_attribute_before_empty_line() {
  function shebang_exit_message_suppressed (line 149) | fn shebang_exit_message_suppressed() {
  function no_exit_message (line 165) | fn no_exit_message() {
  function exit_message (line 180) | fn exit_message() {
  function recipe_exit_message_setting_suppressed (line 196) | fn recipe_exit_message_setting_suppressed() {
  function shebang_exit_message_setting_suppressed (line 213) | fn shebang_exit_message_setting_suppressed() {
  function exit_message_override_no_exit_setting (line 230) | fn exit_message_override_no_exit_setting() {
  function exit_message_and_no_exit_message_compile_forbidden (line 246) | fn exit_message_and_no_exit_message_compile_forbidden() {

FILE: tests/options.rs
  function long_options_may_not_be_empty (line 4) | fn long_options_may_not_be_empty() {
  function short_options_may_not_be_empty (line 26) | fn short_options_may_not_be_empty() {
  function short_options_may_not_have_multiple_characters (line 48) | fn short_options_may_not_have_multiple_characters() {
  function parameters_may_be_passed_with_long_options (line 70) | fn parameters_may_be_passed_with_long_options() {
  function long_option_defaults_to_parameter_name (line 85) | fn long_option_defaults_to_parameter_name() {
  function parameters_may_be_passed_with_short_options (line 100) | fn parameters_may_be_passed_with_short_options() {
  constant LONG_SHORT (line 114) | const LONG_SHORT: &str = "
  function parameters_with_both_long_and_short_option_may_be_passed_as_long (line 121) | fn parameters_with_both_long_and_short_option_may_be_passed_as_long() {
  function parameters_with_both_long_and_short_option_may_be_passed_as_short (line 130) | fn parameters_with_both_long_and_short_option_may_be_passed_as_short() {
  function parameters_with_both_long_and_short_may_not_use_both (line 139) | fn parameters_with_both_long_and_short_may_not_use_both() {
  function multiple_short_options_in_one_argument_is_an_error (line 148) | fn multiple_short_options_in_one_argument_is_an_error() {
  function duplicate_long_option_attributes_are_forbidden (line 163) | fn duplicate_long_option_attributes_are_forbidden() {
  function defaulted_duplicate_long_option (line 185) | fn defaulted_duplicate_long_option() {
  function duplicate_short_option_attributes_are_forbidden (line 210) | fn duplicate_short_option_attributes_are_forbidden() {
  function variadics_with_long_options_are_forbidden (line 232) | fn variadics_with_long_options_are_forbidden() {
  function variadics_with_short_options_are_forbidden (line 253) | fn variadics_with_short_options_are_forbidden() {
  function long_option_names_may_not_contain_equal_sign (line 274) | fn long_option_names_may_not_contain_equal_sign() {
  function short_option_names_may_not_contain_equal_sign (line 295) | fn short_option_names_may_not_contain_equal_sign() {
  function long_options_may_follow_an_omitted_positional_argument (line 316) | fn long_options_may_follow_an_omitted_positional_argument() {
  function short_options_may_follow_an_omitted_positional_argument (line 337) | fn short_options_may_follow_an_omitted_positional_argument() {
  function options_with_a_default_may_be_omitted (line 358) | fn options_with_a_default_may_be_omitted() {
  function variadics_can_follow_options (line 377) | fn variadics_can_follow_options() {
  function argument_values_starting_with_dashes_are_accepted_if_recipe_does_not_take_options (line 398) | fn argument_values_starting_with_dashes_are_accepted_if_recipe_does_not_...
  function argument_values_starting_with_dashes_are_an_error_if_recipe_takes_options (line 416) | fn argument_values_starting_with_dashes_are_an_error_if_recipe_takes_opt...
  function argument_values_starting_with_dashes_are_accepted_after_double_dash (line 432) | fn argument_values_starting_with_dashes_are_accepted_after_double_dash() {
  function positional_and_long_option_arguments_can_be_intermixed (line 453) | fn positional_and_long_option_arguments_can_be_intermixed() {
  function positional_and_short_option_arguments_can_be_intermixed (line 481) | fn positional_and_short_option_arguments_can_be_intermixed() {
  function unknown_options_are_an_error (line 509) | fn unknown_options_are_an_error() {
  function missing_required_options_are_an_error (line 523) | fn missing_required_options_are_an_error() {
  function duplicate_long_options_are_an_error (line 537) | fn duplicate_long_options_are_an_error() {
  function duplicate_short_options_are_an_error (line 551) | fn duplicate_short_options_are_an_error() {
  function options_require_value (line 565) | fn options_require_value() {
  function recipes_with_long_options_have_correct_positional_argument_mismatch_message (line 579) | fn recipes_with_long_options_have_correct_positional_argument_mismatch_m...
  function recipes_with_short_options_have_correct_positional_argument_mismatch_message (line 599) | fn recipes_with_short_options_have_correct_positional_argument_mismatch_...
  function long_options_with_values_are_flags (line 619) | fn long_options_with_values_are_flags() {
  function short_options_with_values_are_flags (line 634) | fn short_options_with_values_are_flags() {
  function flags_cannot_take_values (line 649) | fn flags_cannot_take_values() {
  function value_requires_long_or_short (line 663) | fn value_requires_long_or_short() {
  function options_arg_passed_as_positional_arguments (line 685) | fn options_arg_passed_as_positional_arguments() {

FILE: tests/os_attributes.rs
  function os_family (line 4) | fn os_family() {
  function os (line 35) | fn os() {
  function all (line 106) | fn all() {
  function none (line 128) | fn none() {

FILE: tests/overrides.rs
  function unknown_override (line 4) | fn unknown_override() {
  function unknown_override_options (line 22) | fn unknown_override_options() {
  function unknown_override_args (line 49) | fn unknown_override_args() {
  function unknown_override_arg (line 70) | fn unknown_override_arg() {
  function overrides_first (line 87) | fn overrides_first() {
  function overrides_not_evaluated (line 109) | fn overrides_not_evaluated() {
  function invalid_override_path_set (line 131) | fn invalid_override_path_set() {
  function invalid_override_path_positional (line 141) | fn invalid_override_path_positional() {
  function unknown_variable_in_submodule_override (line 149) | fn unknown_variable_in_submodule_override() {
  function override_variable_in_submodule (line 160) | fn override_variable_in_submodule() {
  function override_variable_in_nested_submodule (line 171) | fn override_variable_in_nested_submodule() {
  function override_variable_used_in_setting (line 183) | fn override_variable_used_in_setting() {
  function submodule_override_does_not_affect_parent (line 201) | fn submodule_override_does_not_affect_parent() {
  function unknown_submodule_in_override_path (line 219) | fn unknown_submodule_in_override_path() {
  function submodule_override_not_evaluated (line 227) | fn submodule_override_not_evaluated() {

FILE: tests/parallel.rs
  function prior_dependencies_run_in_parallel (line 5) | fn prior_dependencies_run_in_parallel() {
  function subsequent_dependencies_run_in_parallel (line 46) | fn subsequent_dependencies_run_in_parallel() {
  function parallel_dependencies_report_errors (line 86) | fn parallel_dependencies_report_errors() {
  function dependents_block_on_running_dependencies (line 108) | fn dependents_block_on_running_dependencies() {

FILE: tests/parameters.rs
  function parameter_default_values_may_use_earlier_parameters (line 4) | fn parameter_default_values_may_use_earlier_parameters() {
  function parameter_default_values_may_not_use_later_parameters (line 18) | fn parameter_default_values_may_not_use_later_parameters() {
  function star_may_follow_default (line 40) | fn star_may_follow_default() {

FILE: tests/parser.rs
  function dont_run_duplicate_recipes (line 4) | fn dont_run_duplicate_recipes() {
  function invalid_bang_operator (line 16) | fn invalid_bang_operator() {
  function truncated_bang_operator (line 36) | fn truncated_bang_operator() {

FILE: tests/positional_arguments.rs
  function linewise (line 4) | fn linewise() {
  function linewise_with_attribute (line 40) | fn linewise_with_attribute() {
  function variadic_linewise (line 75) | fn variadic_linewise() {
  function shebang (line 93) | fn shebang() {
  function shebang_with_attribute (line 111) | fn shebang_with_attribute() {
  function variadic_shebang (line 128) | fn variadic_shebang() {
  function default_arguments (line 149) | fn default_arguments() {
  function empty_variadic_is_undefined (line 165) | fn empty_variadic_is_undefined() {
  function variadic_arguments_are_separate (line 181) | fn variadic_arguments_are_separate() {

FILE: tests/private.rs
  function private_attribute_for_recipe (line 4) | fn private_attribute_for_recipe() {
  function private_attribute_for_alias (line 22) | fn private_attribute_for_alias() {
  function private_attribute_for_module (line 43) | fn private_attribute_for_module() {
  function private_variables_are_not_listed (line 66) | fn private_variables_are_not_listed() {

FILE: tests/quiet.rs
  function no_stdout (line 4) | fn no_stdout() {
  function stderr (line 17) | fn stderr() {
  function command_echoing (line 30) | fn command_echoing() {
  function error_messages (line 43) | fn error_messages() {
  function assignment_backtick_stderr (line 56) | fn assignment_backtick_stderr() {
  function interpolation_backtick_stderr (line 70) | fn interpolation_backtick_stderr() {
  function choose_none (line 84) | fn choose_none() {
  function choose_invocation (line 93) | fn choose_invocation() {
  function choose_status (line 105) | fn choose_status() {
  function edit_invocation (line 116) | fn edit_invocation() {
  function edit_status (line 126) | fn edit_status() {
  function init_exists (line 136) | fn init_exists() {
  function show_missing (line 145) | fn show_missing() {
  function quiet_shebang (line 155) | fn quiet_shebang() {
  function no_quiet_setting (line 168) | fn no_quiet_setting() {
  function quiet_setting (line 182) | fn quiet_setting() {
  function quiet_setting_with_no_quiet_attribute (line 197) | fn quiet_setting_with_no_quiet_attribute() {
  function quiet_setting_with_quiet_recipe (line 214) | fn quiet_setting_with_quiet_recipe() {
  function quiet_setting_with_quiet_line (line 229) | fn quiet_setting_with_quiet_line() {
  function quiet_setting_with_no_quiet_attribute_and_quiet_recipe (line 244) | fn quiet_setting_with_no_quiet_attribute_and_quiet_recipe() {
  function quiet_setting_with_no_quiet_attribute_and_quiet_line (line 260) | fn quiet_setting_with_no_quiet_attribute_and_quiet_line() {

FILE: tests/quote.rs
  function single_quotes_are_prepended_and_appended (line 4) | fn single_quotes_are_prepended_and_appended() {
  function quotes_are_escaped (line 17) | fn quotes_are_escaped() {
  function quoted_strings_can_be_used_as_arguments (line 30) | fn quoted_strings_can_be_used_as_arguments() {

FILE: tests/readme.rs
  function readme (line 4) | fn readme() {

FILE: tests/recursion_limit.rs
  function bugfix (line 4) | fn bugfix() {
  constant RECURSION_LIMIT_REACHED (line 15) | const RECURSION_LIMIT_REACHED: &str = if cfg!(windows) {

FILE: tests/regexes.rs
  function match_succeeds_evaluates_to_first_branch (line 4) | fn match_succeeds_evaluates_to_first_branch() {
  function match_fails_evaluates_to_second_branch (line 24) | fn match_fails_evaluates_to_second_branch() {
  function bad_regex_fails_at_runtime (line 44) | fn bad_regex_fails_at_runtime() {
  function mismatch (line 68) | fn mismatch() {

FILE: tests/request.rs
  function environment_variable_set (line 4) | fn environment_variable_set() {
  function environment_variable_missing (line 19) | fn environment_variable_missing() {

FILE: tests/run.rs
  function dont_run_duplicate_recipes (line 4) | fn dont_run_duplicate_recipes() {
  function one_flag_only_allows_one_invocation (line 18) | fn one_flag_only_allows_one_invocation() {

FILE: tests/scope.rs
  function dependencies_in_submodules_run_with_submodule_scope (line 4) | fn dependencies_in_submodules_run_with_submodule_scope() {
  function aliases_in_submodules_run_with_submodule_scope (line 20) | fn aliases_in_submodules_run_with_submodule_scope() {
  function dependencies_in_nested_submodules_run_with_submodule_scope (line 37) | fn dependencies_in_nested_submodules_run_with_submodule_scope() {
  function imported_recipes_run_in_correct_scope (line 56) | fn imported_recipes_run_in_correct_scope() {

FILE: tests/script.rs
  function runs_with_command (line 4) | fn runs_with_command() {
  function no_arguments (line 24) | fn no_arguments() {
  function with_arguments (line 38) | fn with_arguments() {
  function allowed_with_shebang (line 53) | fn allowed_with_shebang() {
  function script_line_numbers (line 73) | fn script_line_numbers() {
  function script_line_numbers_with_multi_line_recipe_signature (line 97) | fn script_line_numbers_with_multi_line_recipe_signature() {
  function shebang_line_numbers (line 135) | fn shebang_line_numbers() {
  function shebang_line_numbers_with_multiline_constructs (line 170) | fn shebang_line_numbers_with_multiline_constructs() {
  function multiline_shebang_line_numbers (line 211) | fn multiline_shebang_line_numbers() {
  function shebang_line_numbers_windows (line 250) | fn shebang_line_numbers_windows() {
  function no_arguments_with_default_script_interpreter (line 286) | fn no_arguments_with_default_script_interpreter() {
  function no_arguments_with_non_default_script_interpreter (line 311) | fn no_arguments_with_non_default_script_interpreter() {

FILE: tests/search.rs
  function search_test (line 3) | fn search_test<P: AsRef<Path>>(path: P, args: &[&str]) {
  function test_justfile_search (line 20) | fn test_justfile_search() {
  function test_capitalized_justfile_search (line 36) | fn test_capitalized_justfile_search() {
  function test_upwards_path_argument (line 52) | fn test_upwards_path_argument() {
  function test_downwards_path_argument (line 65) | fn test_downwards_path_argument() {
  function test_upwards_multiple_path_argument (line 84) | fn test_upwards_multiple_path_argument() {
  function test_downwards_multiple_path_argument (line 100) | fn test_downwards_multiple_path_argument() {
  function single_downwards (line 121) | fn single_downwards() {
  function single_upwards (line 133) | fn single_upwards() {
  function double_upwards (line 145) | fn double_upwards() {
  function find_dot_justfile (line 161) | fn find_dot_justfile() {
  function dot_justfile_conflicts_with_justfile (line 184) | fn dot_justfile_conflicts_with_justfile() {

FILE: tests/search_arguments.rs
  function argument_with_different_path_prefix_is_allowed (line 4) | fn argument_with_different_path_prefix_is_allowed() {
  function passing_dot_as_argument_is_allowed (line 12) | fn passing_dot_as_argument_is_allowed() {

FILE: tests/settings.rs
  function all_settings_allow_expressions (line 4) | fn all_settings_allow_expressions() {
  function undefined_variable_in_working_directory (line 30) | fn undefined_variable_in_working_directory() {
  function undefined_variable_in_dotenv_filename (line 50) | fn undefined_variable_in_dotenv_filename() {
  function undefined_variable_in_dotenv_path (line 70) | fn undefined_variable_in_dotenv_path() {
  function undefined_variable_in_tempdir (line 90) | fn undefined_variable_in_tempdir() {
  function undefined_variable_in_script_interpreter_command (line 110) | fn undefined_variable_in_script_interpreter_command() {
  function undefined_variable_in_script_interpreter_argument (line 130) | fn undefined_variable_in_script_interpreter_argument() {
  function undefined_variable_in_shell_command (line 150) | fn undefined_variable_in_shell_command() {
  function undefined_variable_in_shell_argument (line 170) | fn undefined_variable_in_shell_argument() {
  function undefined_variable_in_windows_shell_command (line 190) | fn undefined_variable_in_windows_shell_command() {
  function undefined_variable_in_windows_shell_argument (line 210) | fn undefined_variable_in_windows_shell_argument() {
  function built_in_constant (line 230) | fn built_in_constant() {
  function variable (line 246) | fn variable() {
  function unused_non_const_assignments (line 265) | fn unused_non_const_assignments() {
  function variable_with_override (line 286) | fn variable_with_override() {
  function expression (line 306) | fn expression() {
  function expression_with_override (line 325) | fn expression_with_override() {
  function backtick (line 344) | fn backtick() {
  function function_call (line 364) | fn function_call() {
  function non_const_variable (line 384) | fn non_const_variable() {
  function assert (line 406) | fn assert() {
  function bad_regex (line 426) | fn bad_regex() {
  function backtick_override (line 449) | fn backtick_override() {
  function submodule_expression (line 470) | fn submodule_expression() {
  function overrides_are_ignored_in_submodules (line 497) | fn overrides_are_ignored_in_submodules() {

FILE: tests/shadowing_parameters.rs
  function parameter_may_shadow_variable (line 4) | fn parameter_may_shadow_variable() {
  function shadowing_parameters_do_not_change_environment (line 15) | fn shadowing_parameters_do_not_change_environment() {
  function exporting_shadowing_parameters_does_change_environment (line 26) | fn exporting_shadowing_parameters_does_change_environment() {

FILE: tests/shebang.rs
  function powershell (line 4) | fn powershell() {
  function powershell_exe (line 21) | fn powershell_exe() {
  function cmd (line 38) | fn cmd() {
  function cmd_exe (line 55) | fn cmd_exe() {
  function multi_line_cmd_shebangs_are_removed (line 72) | fn multi_line_cmd_shebangs_are_removed() {
  function simple (line 90) | fn simple() {
  function echo (line 104) | fn echo() {
  function echo_with_command_color (line 119) | fn echo_with_command_color() {
  function run_shebang (line 140) | fn run_shebang() {

FILE: tests/shell.rs
  constant JUSTFILE (line 3) | const JUSTFILE: &str = "
  function flag (line 15) | fn flag() {
  function cmd (line 42) | fn cmd() {
  function powershell (line 68) | fn powershell() {
  function shell_args (line 94) | fn shell_args() {
  function shell_override (line 111) | fn shell_override() {
  function shell_arg_override (line 130) | fn shell_arg_override() {
  function set_shell (line 149) | fn set_shell() {
  function recipe_shell_not_found_error_message (line 169) | fn recipe_shell_not_found_error_message() {
  function backtick_recipe_shell_not_found_error_message (line 186) | fn backtick_recipe_shell_not_found_error_message() {

FILE: tests/shell_expansion.rs
  function strings_are_shell_expanded (line 4) | fn strings_are_shell_expanded() {
  function shell_expanded_strings_must_not_have_whitespace (line 18) | fn shell_expanded_strings_must_not_have_whitespace() {
  function shell_expanded_error_messages_highlight_string_token (line 38) | fn shell_expanded_error_messages_highlight_string_token() {
  function shell_expanded_strings_are_dumped_correctly (line 59) | fn shell_expanded_strings_are_dumped_correctly() {
  function shell_expanded_strings_can_be_used_in_settings (line 73) | fn shell_expanded_strings_can_be_used_in_settings() {
  function shell_expanded_strings_can_be_used_in_import_paths (line 90) | fn shell_expanded_strings_can_be_used_in_import_paths() {
  function shell_expanded_strings_can_be_used_in_mod_paths (line 106) | fn shell_expanded_strings_can_be_used_in_mod_paths() {
  function shell_expanded_strings_do_not_conflict_with_dependencies (line 121) | fn shell_expanded_strings_do_not_conflict_with_dependencies() {

FILE: tests/show.rs
  function show (line 4) | fn show() {
  function alias_show (line 24) | fn alias_show() {
  function alias_show_missing_target (line 40) | fn alias_show_missing_target() {
  function show_suggestion (line 58) | fn show_suggestion() {
  function show_alias_suggestion (line 75) | fn show_alias_suggestion() {
  function show_no_suggestion (line 99) | fn show_no_suggestion() {
  function show_no_alias_suggestion (line 116) | fn show_no_alias_suggestion() {
  function show_recipe_at_path (line 135) | fn show_recipe_at_path() {
  function show_invalid_path (line 149) | fn show_invalid_path() {
  function show_space_separated_path (line 157) | fn show_space_separated_path() {

FILE: tests/signals.rs
  function kill (line 3) | fn kill(child: &Child, signal: Signal) {
  function interrupt_test (line 7) | fn interrupt_test(arguments: &[&str], justfile: &str) {
  function interrupt_shebang (line 46) | fn interrupt_shebang() {
  function interrupt_line (line 59) | fn interrupt_line() {
  function interrupt_backtick (line 71) | fn interrupt_backtick() {
  function interrupt_command (line 85) | fn interrupt_command() {
  function forwarding (line 94) | fn forwarding() {
  function siginfo_prints_current_process (line 166) | fn siginfo_prints_current_process() {

FILE: tests/slash_operator.rs
  function once (line 4) | fn once() {
  function twice (line 13) | fn twice() {
  function no_lhs_once (line 22) | fn no_lhs_once() {
  function no_lhs_twice (line 31) | fn no_lhs_twice() {
  function no_rhs_once (line 45) | fn no_rhs_once() {
  function default_un_parenthesized (line 61) | fn default_un_parenthesized() {
  function no_lhs_un_parenthesized (line 82) | fn no_lhs_un_parenthesized() {
  function default_parenthesized (line 103) | fn default_parenthesized() {
  function no_lhs_parenthesized (line 117) | fn no_lhs_parenthesized() {

FILE: tests/string.rs
  function raw_string (line 4) | fn raw_string() {
  function multiline_raw_string (line 20) | fn multiline_raw_string() {
  function multiline_backtick (line 46) | fn multiline_backtick() {
  function multiline_cooked_string (line 69) | fn multiline_cooked_string() {
  function cooked_string_suppress_newline (line 95) | fn cooked_string_suppress_newline() {
  function invalid_escape_sequence (line 117) | fn invalid_escape_sequence() {
  function error_line_after_multiline_raw_string (line 136) | fn error_line_after_multiline_raw_string() {
  function error_column_after_multiline_raw_string (line 161) | fn error_column_after_multiline_raw_string() {
  function multiline_raw_string_in_interpolation (line 186) | fn multiline_raw_string_in_interpolation() {
  function error_line_after_multiline_raw_string_in_interpolation (line 212) | fn error_line_after_multiline_raw_string_in_interpolation() {
  function unterminated_raw_string (line 236) | fn unterminated_raw_string() {
  function unterminated_string (line 257) | fn unterminated_string() {
  function unterminated_backtick (line 278) | fn unterminated_backtick() {
  function unterminated_indented_raw_string (line 299) | fn unterminated_indented_raw_string() {
  function unterminated_indented_string (line 320) | fn unterminated_indented_string() {
  function unterminated_indented_backtick (line 341) | fn unterminated_indented_backtick() {
  function indented_raw_string_contents_indentation_removed (line 362) | fn indented_raw_string_contents_indentation_removed() {
  function indented_cooked_string_contents_indentation_removed (line 385) | fn indented_cooked_string_contents_indentation_removed() {
  function indented_backtick_string_contents_indentation_removed (line 408) | fn indented_backtick_string_contents_indentation_removed() {
  function indented_raw_string_escapes (line 428) | fn indented_raw_string_escapes() {
  function indented_cooked_string_escapes (line 451) | fn indented_cooked_string_escapes() {
  function indented_backtick_string_escapes (line 475) | fn indented_backtick_string_escapes() {
  function shebang_backtick (line 495) | fn shebang_backtick() {
  function valid_unicode_escape (line 515) | fn valid_unicode_escape() {
  function unicode_escapes_with_all_hex_digits (line 524) | fn unicode_escapes_with_all_hex_digits() {
  function maximum_valid_unicode_escape (line 533) | fn maximum_valid_unicode_escape() {
  function unicode_escape_no_braces (line 542) | fn unicode_escape_no_braces() {
  function unicode_escape_empty (line 559) | fn unicode_escape_empty() {
  function unicode_escape_requires_immediate_opening_brace (line 576) | fn unicode_escape_requires_immediate_opening_brace() {
  function unicode_escape_non_hex (line 593) | fn unicode_escape_non_hex() {
  function unicode_escape_invalid_character (line 610) | fn unicode_escape_invalid_character() {
  function unicode_escape_too_long (line 627) | fn unicode_escape_too_long() {
  function unicode_escape_unterminated (line 644) | fn unicode_escape_unterminated() {

FILE: tests/subsequents.rs
  function success (line 4) | fn success() {
  function failure (line 31) | fn failure() {
  function circular_dependency (line 59) | fn circular_dependency() {
  function unknown (line 79) | fn unknown() {
  function unknown_argument (line 99) | fn unknown_argument() {
  function argument (line 121) | fn argument() {
  function duplicate_subsequents_dont_run (line 145) | fn duplicate_subsequents_dont_run() {
  function subsequents_run_even_if_already_ran_as_prior (line 182) | fn subsequents_run_even_if_already_ran_as_prior() {

FILE: tests/summary.rs
  function summary (line 4) | fn summary() {
  function summary_sorted (line 21) | fn summary_sorted() {
  function summary_unsorted (line 36) | fn summary_unsorted() {
  function summary_none (line 52) | fn summary_none() {
  function no_recipes (line 62) | fn no_recipes() {
  function submodule_recipes (line 71) | fn submodule_recipes() {
  function summary_implies_unstable (line 90) | fn summary_implies_unstable() {

FILE: tests/tempdir.rs
  function tempdir (line 3) | pub(crate) fn tempdir() -> TempDir {
  function setting (line 19) | fn setting() {
  function argument_overrides_setting (line 54) | fn argument_overrides_setting() {

FILE: tests/test.rs
  type Output (line 6) | pub(crate) struct Output {
  type Test (line 13) | pub(crate) struct Test {
    method new (line 32) | pub(crate) fn new() -> Self {
    method with_tempdir (line 36) | pub(crate) fn with_tempdir(tempdir: TempDir) -> Self {
    method arg (line 56) | pub(crate) fn arg(mut self, val: &str) -> Self {
    method args (line 61) | pub(crate) fn args<'a>(mut self, args: impl AsRef<[&'a str]>) -> Self {
    method create_dir (line 68) | pub(crate) fn create_dir(self, path: impl AsRef<Path>) -> Self {
    method current_dir (line 73) | pub(crate) fn current_dir(mut self, path: impl AsRef<Path>) -> Self {
    method env (line 78) | pub(crate) fn env(mut self, key: &str, val: &str) -> Self {
    method justfile (line 83) | pub(crate) fn justfile(mut self, justfile: impl Into<String>) -> Self {
    method justfile_path (line 88) | pub(crate) fn justfile_path(&self) -> PathBuf {
    method symlink (line 94) | pub(crate) fn symlink(self, original: &str, link: &str) -> Self {
    method no_justfile (line 103) | pub(crate) fn no_justfile(mut self) -> Self {
    method response (line 108) | pub(crate) fn response(mut self, response: Response) -> Self {
    method shell (line 113) | pub(crate) fn shell(mut self, shell: bool) -> Self {
    method stderr (line 118) | pub(crate) fn stderr(mut self, stderr: impl Into<String>) -> Self {
    method stderr_regex (line 123) | pub(crate) fn stderr_regex(mut self, stderr_regex: impl AsRef<str>) ->...
    method stdin (line 128) | pub(crate) fn stdin(mut self, stdin: impl Into<String>) -> Self {
    method stdout (line 133) | pub(crate) fn stdout(mut self, stdout: impl Into<String>) -> Self {
    method stdout_regex (line 138) | pub(crate) fn stdout_regex(mut self, stdout_regex: impl AsRef<str>) ->...
    method test_round_trip (line 143) | pub(crate) fn test_round_trip(mut self, test_round_trip: bool) -> Self {
    method tree (line 148) | pub(crate) fn tree(self, mut tree: Tree) -> Self {
    method unindent_stdout (line 154) | pub(crate) fn unindent_stdout(mut self, unindent_stdout: bool) -> Self {
    method write (line 159) | pub(crate) fn write(self, path: impl AsRef<Path>, content: impl AsRef<...
    method make_executable (line 166) | pub(crate) fn make_executable(self, path: impl AsRef<Path>) -> Self {
    method expect_file (line 190) | pub(crate) fn expect_file(mut self, path: impl AsRef<Path>, content: i...
    method success (line 199) | pub(crate) fn success(self) -> Output {
    method failure (line 204) | pub(crate) fn failure(self) -> Output {
    method status (line 209) | pub(crate) fn status(self, status: i32) -> Output {
    method round_trip (line 323) | fn round_trip(&self) {
  function assert_eval_eq (line 361) | pub(crate) fn assert_eval_eq(expression: &str, result: &str) {

FILE: tests/timestamps.rs
  function quiet (line 4) | fn quiet() {
  function linewise (line 20) | fn linewise() {
  function script (line 35) | fn script() {
  function format_string (line 51) | fn format_string() {

FILE: tests/undefined_variables.rs
  function parameter_default_unknown_variable_in_expression (line 4) | fn parameter_default_unknown_variable_in_expression() {
  function unknown_variable_in_unary_call (line 20) | fn unknown_variable_in_unary_call() {
  function unknown_first_variable_in_binary_call (line 40) | fn unknown_first_variable_in_binary_call() {
  function unknown_second_variable_in_binary_call (line 60) | fn unknown_second_variable_in_binary_call() {
  function unknown_variable_in_ternary_call (line 80) | fn unknown_variable_in_ternary_call() {

FILE: tests/unexport.rs
  function unexport_environment_variable_linewise (line 4) | fn unexport_environment_variable_linewise() {
  function unexport_environment_variable_shebang (line 20) | fn unexport_environment_variable_shebang() {
  function duplicate_unexport_fails (line 37) | fn duplicate_unexport_fails() {
  function export_unexport_conflict (line 63) | fn export_unexport_conflict() {
  function unexport_doesnt_override_local_recipe_export (line 88) | fn unexport_doesnt_override_local_recipe_export() {
  function unexport_does_not_conflict_with_recipe_syntax (line 104) | fn unexport_does_not_conflict_with_recipe_syntax() {
  function unexport_does_not_conflict_with_assignment_syntax (line 118) | fn unexport_does_not_conflict_with_assignment_syntax() {

FILE: tests/unstable.rs
  function set_unstable_true_with_env_var (line 4) | fn set_unstable_true_with_env_var() {
  function set_unstable_false_with_env_var (line 16) | fn set_unstable_false_with_env_var() {
  function set_unstable_false_with_env_var_unset (line 28) | fn set_unstable_false_with_env_var_unset() {
  function set_unstable_with_setting (line 37) | fn set_unstable_with_setting() {
  function unstable_setting_does_not_affect_submodules (line 50) | fn unstable_setting_does_not_affect_submodules() {

FILE: tests/usage.rs
  function usage (line 4) | fn usage() {

FILE: tests/which_function.rs
  constant HELLO_SCRIPT (line 3) | const HELLO_SCRIPT: &str = "#!/usr/bin/env bash
  function finds_executable (line 8) | fn finds_executable() {
  function prints_empty_string_for_missing_executable (line 24) | fn prints_empty_string_for_missing_executable() {
  function skips_non_executable_files (line 39) | fn skips_non_executable_files() {
  function supports_multiple_paths (line 55) | fn supports_multiple_paths() {
  function supports_shadowed_executables (line 82) | fn supports_shadowed_executables() {
  function ignores_nonexecutable_candidates (line 124) | fn ignores_nonexecutable_candidates() {
  function handles_absolute_path (line 154) | fn handles_absolute_path() {
  function handles_dotslash (line 173) | fn handles_dotslash() {
  function handles_dir_slash (line 198) | fn handles_dir_slash() {
  function is_unstable (line 223) | fn is_unstable() {
  function require_error (line 238) | fn require_error() {
  function finds_executable_via_pathext (line 255) | fn finds_executable_via_pathext() {
  function pathext_not_applied_when_candidate_has_extension (line 276) | fn pathext_not_applied_when_candidate_has_extension() {
  function pathext_custom_extension (line 296) | fn pathext_custom_extension() {
  function pathext_entry_missing_dot_is_error (line 316) | fn pathext_entry_missing_dot_is_error() {
  function pathext_ignored_on_non_windows (line 337) | fn pathext_ignored_on_non_windows() {
  function require_success (line 357) | fn require_success() {

FILE: tests/windows.rs
  function bare_bash_in_shebang (line 4) | fn bare_bash_in_shebang() {

FILE: tests/windows_shell.rs
  function windows_shell_setting (line 4) | fn windows_shell_setting() {
  function windows_powershell_setting_uses_powershell_set_shell (line 22) | fn windows_powershell_setting_uses_powershell_set_shell() {
  function windows_powershell_setting_uses_powershell (line 40) | fn windows_powershell_setting_uses_powershell() {

FILE: tests/working_directory.rs
  constant JUSTFILE (line 3) | const JUSTFILE: &str = r#"
  constant DATA (line 16) | const DATA: &str = "OK";
  constant WANT (line 18) | const WANT: &str = "shebang: OK\nexpression: OK\ndefault: OK\nlinewise: ...
  function justfile_without_working_directory (line 23) | fn justfile_without_working_directory() -> Result<(), Box<dyn Error>> {
  function justfile_without_working_directory_relative (line 49) | fn justfile_without_working_directory_relative() -> Result<(), Box<dyn E...
  function change_working_directory_to_search_justfile_parent (line 76) | fn change_working_directory_to_search_justfile_parent() -> Result<(), Bo...
  function justfile_and_working_directory (line 102) | fn justfile_and_working_directory() -> Result<(), Box<dyn Error>> {
  function search_dir_child (line 132) | fn search_dir_child() -> Result<(), Box<dyn Error>> {
  function search_dir_parent (line 160) | fn search_dir_parent() -> Result<(), Box<dyn Error>> {
  function setting (line 186) | fn setting() {
  function no_cd_overrides_setting (line 216) | fn no_cd_overrides_setting() {
  function working_dir_in_submodule_is_relative_to_module_path (line 239) | fn working_dir_in_submodule_is_relative_to_module_path() {
  function working_dir_applies_to_backticks (line 258) | fn working_dir_applies_to_backticks() {
  function working_dir_applies_to_shell_function (line 276) | fn working_dir_applies_to_shell_function() {
  function working_dir_applies_to_backticks_in_submodules (line 294) | fn working_dir_applies_to_backticks_in_submodules() {
  function working_dir_applies_to_shell_function_in_submodules (line 315) | fn working_dir_applies_to_shell_function_in_submodules() {
  function attribute_duplicate (line 336) | fn attribute_duplicate() {
  function attribute (line 357) | fn attribute() {
  function attribute_with_nocd_is_forbidden (line 372) | fn attribute_with_nocd_is_forbidden() {
  function setting_and_attribute (line 394) | fn setting_and_attribute() {

[
  {
    "path": ".editorconfig",
    "chars": 358,
    "preview": "# EditorConfig is awesome: https://EditorConfig.org\n\n# top-most EditorConfig file\nroot = true\n\n[*]\n# Text is UTF-8\nchars"
  },
  {
    "path": ".gitattributes",
    "chars": 8,
    "preview": "* -text\n"
  },
  {
    "path": ".github/workflows/ci.yaml",
    "chars": 2017,
    "preview": "name: CI\n\non:\n  pull_request:\n    branches:\n    - '*'\n  push:\n    branches:\n    - master\n\ndefaults:\n  run:\n    shell: ba"
  },
  {
    "path": ".github/workflows/release.yaml",
    "chars": 5314,
    "preview": "name: Release\n\non:\n  push:\n    tags:\n    - '*'\n\ndefaults:\n  run:\n    shell: bash\n\nenv:\n  RUSTFLAGS: --deny warnings\n\njob"
  },
  {
    "path": ".gitignore",
    "chars": 214,
    "preview": ".DS_Store\n.idea\n/.vagrant\n/.vscode\n/README.html\n/book/en/build\n/book/en/src\n/book/zh/build\n/book/zh/src\n/fuzz/artifacts\n"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 157513,
    "preview": "Changelog\n=========\n\n[1.47.1](https://github.com/casey/just/releases/tag/1.47.1) - 2026-03-16\n--------------------------"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 309,
    "preview": "Contributing\n============\n\nUnless you explicitly state otherwise, any contribution intentionally submitted\nfor inclusion"
  },
  {
    "path": "Cargo.toml",
    "chars": 2793,
    "preview": "[package]\nname = \"just\"\nversion = \"1.47.1\"\nauthors = [\"Casey Rodarmor <casey@rodarmor.com>\"]\nautotests = false\ncategorie"
  },
  {
    "path": "GRAMMAR.md",
    "chars": 4109,
    "preview": "justfile grammar\n================\n\nJustfiles are processed by a mildly context-sensitive tokenizer\nand a recursive desce"
  },
  {
    "path": "LICENSE",
    "chars": 7048,
    "preview": "Creative Commons Legal Code\n\nCC0 1.0 Universal\n\n    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE\n"
  },
  {
    "path": "README.md",
    "chars": 132192,
    "preview": "<div align=right>Table of Contents↗️</div>\n\n<h1 align=center><code>just</code></h1>\n\n<div align=center>\n  <a href=https:"
  },
  {
    "path": "README.中文.md",
    "chars": 52873,
    "preview": "↖️ 目录\n\n<h1 align=\"center\"><code>just</code></h1>\n\n<div align=\"center\">\n  <a href=\"https://crates.io/crates/just\">\n    <i"
  },
  {
    "path": "Vagrantfile",
    "chars": 512,
    "preview": "Vagrant.configure(2) do |config|\n  config.vm.box = 'debian/jessie64'\n\n  config.vm.provision \"shell\", inline: <<-EOS\n    "
  },
  {
    "path": "bin/forbid",
    "chars": 283,
    "preview": "#!/usr/bin/env bash\n\nset -euo pipefail\n\nif ! which rg > /dev/null; then\n  echo 'error: `rg` not found, please install ri"
  },
  {
    "path": "bin/package",
    "chars": 1149,
    "preview": "#!/usr/bin/env bash\n\nset -euxo pipefail\n\nVERSION=${REF#\"refs/tags/\"}\nDIST=`pwd`/dist\n\necho \"Packaging just $VERSION for "
  },
  {
    "path": "book/en/book.toml",
    "chars": 209,
    "preview": "[book]\nlanguage = \"en\"\nsrc = \"src\"\ntitle = \"Just Programmer's Manual\"\n\n[build]\nbuild-dir = \"build\"\n\n[output.html]\ngit-re"
  },
  {
    "path": "book/zh/book.toml",
    "chars": 194,
    "preview": "[book]\nlanguage = \"zh\"\nsrc = \"src\"\ntitle = \"Just 用户指南\"\n\n[build]\nbuild-dir = \"build\"\n\n[output.html]\ngit-repository-url = "
  },
  {
    "path": "build.rs",
    "chars": 334,
    "preview": "fn main() {\n  let os = std::env::var(\"CARGO_CFG_TARGET_OS\").unwrap();\n  let env = std::env::var(\"CARGO_CFG_TARGET_ENV\")."
  },
  {
    "path": "clippy.toml",
    "chars": 89,
    "preview": "cognitive-complexity-threshold = 1337\nsource-item-ordering = ['enum', 'struct', 'trait']\n"
  },
  {
    "path": "completions/just.bash",
    "chars": 7252,
    "preview": "_just() {\n    local i cur prev words cword opts cmd\n    COMPREPLY=()\n\n    # Modules use \"::\" as the separator, which is "
  },
  {
    "path": "completions/just.elvish",
    "chars": 5714,
    "preview": "use builtin;\nuse str;\n\nset edit:completion:arg-completer[just] = {|@words|\n    fn spaces {|n|\n        builtin:repeat $n "
  },
  {
    "path": "completions/just.fish",
    "chars": 5414,
    "preview": "function __fish_just_complete_recipes\n        if string match -rq '(-f|--justfile)\\s*=?(?<justfile>[^\\s]+)' -- (string s"
  },
  {
    "path": "completions/just.nu",
    "chars": 367,
    "preview": "def \"nu-complete just\" [] {\n    (^just --dump --unstable --dump-format json | from json).recipes | transpose recipe data"
  },
  {
    "path": "completions/just.powershell",
    "chars": 12336,
    "preview": "using namespace System.Management.Automation\nusing namespace System.Management.Automation.Language\n\nRegister-ArgumentCom"
  },
  {
    "path": "completions/just.zsh",
    "chars": 7655,
    "preview": "#compdef just\n\nautoload -U is-at-least\n\n_just() {\n    typeset -A opt_args\n    typeset -a _arguments_options\n    local re"
  },
  {
    "path": "contrib/just.sh",
    "chars": 645,
    "preview": "#!/usr/bin/env bash\n\n# cd upwards to the justfile\nwhile [[ ! -e justfile ]]; do\n  if [[ $PWD = / ]] || [[ $PWD = $JUSTST"
  },
  {
    "path": "crates/generate-book/Cargo.toml",
    "chars": 160,
    "preview": "[package]\nname = \"generate-book\"\nversion = \"0.0.0\"\nedition = \"2018\"\npublish = false\n\n[dependencies]\npulldown-cmark = \"0."
  },
  {
    "path": "crates/generate-book/src/main.rs",
    "chars": 5066,
    "preview": "use {\n  pulldown_cmark::{CowStr, Event, HeadingLevel, Options, Parser, Tag},\n  pulldown_cmark_to_cmark::cmark,\n  std::{\n"
  },
  {
    "path": "crates/update-contributors/Cargo.toml",
    "chars": 122,
    "preview": "[package]\nname = \"update-contributors\"\nversion = \"0.0.0\"\nedition = \"2021\"\npublish = false\n\n[dependencies]\nregex = \"1.5.4"
  },
  {
    "path": "crates/update-contributors/src/main.rs",
    "chars": 922,
    "preview": "use {\n  regex::{Captures, Regex},\n  std::{fs, process::Command, str},\n};\n\nfn author(pr: u64) -> String {\n  eprintln!(\"#{"
  },
  {
    "path": "crates-io-readme.md",
    "chars": 585,
    "preview": "`just` is a handy way to save and run project-specific commands.\n\nCommands are stored in a file called `justfile` or `Ju"
  },
  {
    "path": "examples/cross-platform.just",
    "chars": 796,
    "preview": "# use with https://github.com/casey/just\n#\n# Example cross-platform Python project\n#\n\npython_dir := if os_family() == \"w"
  },
  {
    "path": "examples/keybase.just",
    "chars": 356,
    "preview": "# use with https://github.com/casey/just\n\n# Be inspired to use just to notify a chat\n# channel, this examples shows use "
  },
  {
    "path": "examples/kitchen-sink.just",
    "chars": 4462,
    "preview": "set shell := [\"sh\", \"-c\"]\nset windows-shell := [\"powershell.exe\", \"-NoLogo\", \"-Command\"]\nset allow-duplicate-recipes\nset"
  },
  {
    "path": "examples/powershell.just",
    "chars": 663,
    "preview": "# Cross platform shebang:\nshebang := if os() == 'windows' {\n  'powershell.exe'\n} else {\n  '/usr/bin/env pwsh'\n}\n\n# Set s"
  },
  {
    "path": "examples/pre-commit.just",
    "chars": 2193,
    "preview": "# use with https://github.com/casey/just\n\n# Example combining just + pre-commit\n# pre-commit: https://pre-commit.com/\n# "
  },
  {
    "path": "examples/screenshot.just",
    "chars": 196,
    "preview": "alias b := build\n\nhost := `uname -a`\n\n# build main\nbuild:\n    cc *.c -o main\n\n# test everything\ntest-all: build\n    ./te"
  },
  {
    "path": "fuzz/Cargo.toml",
    "chars": 420,
    "preview": "[package]\nname = \"just-fuzz\"\nversion = \"0.0.0\"\nauthors = [\"Automatically generated\"]\npublish = false\nedition = \"2018\"\n\n["
  },
  {
    "path": "fuzz/fuzz_targets/compile.rs",
    "chars": 115,
    "preview": "#![no_main]\nuse libfuzzer_sys::fuzz_target;\n\nfuzz_target!(|src: &str| {\n  let _ = just::fuzzing::compile(src);\n});\n"
  },
  {
    "path": "justfile",
    "chars": 4720,
    "preview": "#!/usr/bin/env -S just --justfile\n# ^ A shebang isn't required, but allows a justfile to be executed\n#   like a script, "
  },
  {
    "path": "rustfmt.toml",
    "chars": 128,
    "preview": "edition = \"2024\"\nmax_width = 100\nnewline_style = \"Unix\"\ntab_spaces = 2\nuse_field_init_shorthand = true\nuse_try_shorthand"
  },
  {
    "path": "src/alias.rs",
    "chars": 1286,
    "preview": "use super::*;\n\n/// An alias, e.g. `alias name := target`\n#[derive(Debug, PartialEq, Clone, Serialize)]\npub(crate) struct"
  },
  {
    "path": "src/alias_style.rs",
    "chars": 143,
    "preview": "use super::*;\n\n#[derive(Debug, Default, PartialEq, Clone, ValueEnum)]\npub(crate) enum AliasStyle {\n  Left,\n  #[default]\n"
  },
  {
    "path": "src/analyzer.rs",
    "chars": 14875,
    "preview": "use {super::*, CompileErrorKind::*};\n\n#[derive(Default)]\npub(crate) struct Analyzer<'run, 'src> {\n  aliases: Table<'src,"
  },
  {
    "path": "src/arg_attribute.rs",
    "chars": 273,
    "preview": "use super::*;\n\npub(crate) struct ArgAttribute<'src> {\n  pub(crate) help: Option<String>,\n  pub(crate) long: Option<Strin"
  },
  {
    "path": "src/assignment.rs",
    "chars": 380,
    "preview": "use super::*;\n\n/// An assignment, e.g `foo := bar`\npub(crate) type Assignment<'src> = Binding<'src, Expression<'src>>;\n\n"
  },
  {
    "path": "src/assignment_resolver.rs",
    "chars": 3004,
    "preview": "use {super::*, CompileErrorKind::*};\n\npub(crate) struct AssignmentResolver<'src: 'run, 'run> {\n  assignments: &'run Tabl"
  },
  {
    "path": "src/ast.rs",
    "chars": 954,
    "preview": "use super::*;\n\n/// The top-level type produced by the parser. Not all successful parses result\n/// in valid justfiles, s"
  },
  {
    "path": "src/attribute.rs",
    "chars": 10077,
    "preview": "use super::*;\n\n#[allow(clippy::large_enum_variant)]\n#[derive(\n  EnumDiscriminants, PartialEq, Debug, Clone, Serialize, O"
  },
  {
    "path": "src/attribute_set.rs",
    "chars": 1874,
    "preview": "use {super::*, std::collections};\n\n#[derive(Default, Debug, Clone, PartialEq, Serialize)]\npub(crate) struct AttributeSet"
  },
  {
    "path": "src/binding.rs",
    "chars": 527,
    "preview": "use super::*;\n\n/// A binding of `name` to `value`\n#[derive(Debug, Clone, PartialEq, Serialize)]\npub(crate) struct Bindin"
  },
  {
    "path": "src/color.rs",
    "chars": 3488,
    "preview": "use {\n  super::*,\n  ansi_term::{ANSIGenericString, Color::*, Prefix, Style, Suffix},\n  std::io::{self, IsTerminal},\n};\n\n"
  },
  {
    "path": "src/color_display.rs",
    "chars": 401,
    "preview": "use super::*;\n\npub(crate) trait ColorDisplay {\n  fn color_display(&self, color: Color) -> Wrapper\n  where\n    Self: Size"
  },
  {
    "path": "src/command_color.rs",
    "chars": 568,
    "preview": "use super::*;\n\n#[derive(Copy, Clone, ValueEnum)]\npub(crate) enum CommandColor {\n  Black,\n  Blue,\n  Cyan,\n  Green,\n  Purp"
  },
  {
    "path": "src/command_ext.rs",
    "chars": 2182,
    "preview": "use super::*;\n\npub(crate) trait CommandExt {\n  fn export(\n    &mut self,\n    settings: &Settings,\n    dotenv: &BTreeMap<"
  },
  {
    "path": "src/compilation.rs",
    "chars": 361,
    "preview": "use super::*;\n\n#[derive(Debug)]\npub(crate) struct Compilation<'src> {\n  pub(crate) asts: HashMap<PathBuf, Ast<'src>>,\n  "
  },
  {
    "path": "src/compile_error.rs",
    "chars": 12615,
    "preview": "use super::*;\n\n#[derive(Debug, PartialEq)]\npub(crate) struct CompileError<'src> {\n  pub(crate) kind: Box<CompileErrorKin"
  },
  {
    "path": "src/compile_error_kind.rs",
    "chars": 3934,
    "preview": "use super::*;\n\n#[derive(Debug, PartialEq)]\npub(crate) enum CompileErrorKind<'src> {\n  ArgAttributeValueRequiresOption,\n "
  },
  {
    "path": "src/compiler.rs",
    "chars": 9740,
    "preview": "use super::*;\n\npub(crate) struct Compiler;\n\nimpl Compiler {\n  pub(crate) fn compile<'src>(\n    config: &Config,\n    load"
  },
  {
    "path": "src/completions.rs",
    "chars": 10264,
    "preview": "use super::*;\n\n#[derive(ValueEnum, Debug, Clone, Copy, PartialEq)]\npub(crate) enum Shell {\n  Bash,\n  Elvish,\n  Fish,\n  #"
  },
  {
    "path": "src/condition.rs",
    "chars": 706,
    "preview": "use super::*;\n\n#[derive(PartialEq, Debug, Clone)]\npub(crate) struct Condition<'src> {\n  pub(crate) lhs: Box<Expression<'"
  },
  {
    "path": "src/conditional_operator.rs",
    "chars": 530,
    "preview": "use super::*;\n\n/// A conditional expression operator.\n#[derive(PartialEq, Debug, Copy, Clone)]\npub(crate) enum Condition"
  },
  {
    "path": "src/config.rs",
    "chars": 48580,
    "preview": "use {\n  super::*,\n  clap::{\n    Arg, ArgAction, ArgGroup, ArgMatches, Command,\n    builder::{\n      FalseyValueParser, S"
  },
  {
    "path": "src/config_error.rs",
    "chars": 1834,
    "preview": "use super::*;\n\n#[derive(Debug, Snafu)]\n#[snafu(visibility(pub(crate)), context(suffix(Context)))]\npub(crate) enum Config"
  },
  {
    "path": "src/const_error.rs",
    "chars": 780,
    "preview": "use super::*;\n\n#[derive(Clone, Copy, Debug)]\npub(crate) enum ConstError<'src> {\n  Backtick(Token<'src>),\n  FunctionCall("
  },
  {
    "path": "src/constants.rs",
    "chars": 2464,
    "preview": "use super::*;\n\nconst CONSTANTS: &[(&str, &str, Option<&str>, &str)] = &[\n  (\"HEX\", \"0123456789abcdef\", None, \"1.27.0\"),\n"
  },
  {
    "path": "src/count.rs",
    "chars": 502,
    "preview": "use super::*;\n\npub(crate) struct Count<T: Display>(pub T, pub usize);\n\nimpl<T: Display> Display for Count<T> {\n  fn fmt("
  },
  {
    "path": "src/delimiter.rs",
    "chars": 505,
    "preview": "use super::*;\n\n#[derive(Clone, Copy, Debug, Eq, PartialEq)]\npub(crate) enum Delimiter {\n  Brace,\n  Bracket,\n  FormatStri"
  },
  {
    "path": "src/dependency.rs",
    "chars": 1016,
    "preview": "use super::*;\n\n#[derive(Clone, PartialEq, Debug, Serialize)]\npub(crate) struct Dependency<'src> {\n  #[serde(serialize_wi"
  },
  {
    "path": "src/dump_format.rs",
    "chars": 136,
    "preview": "use super::*;\n\n#[derive(Clone, Copy, Debug, Default, PartialEq, ValueEnum)]\npub(crate) enum DumpFormat {\n  Json,\n  #[def"
  },
  {
    "path": "src/enclosure.rs",
    "chars": 535,
    "preview": "use super::*;\n\npub(crate) struct Enclosure<T: Display> {\n  enclosure: &'static str,\n  value: T,\n}\n\nimpl<T: Display> Encl"
  },
  {
    "path": "src/error.rs",
    "chars": 23197,
    "preview": "use super::*;\n\n#[derive(Debug)]\npub(crate) enum Error<'src> {\n  AmbiguousModuleFile {\n    module: Name<'src>,\n    found:"
  },
  {
    "path": "src/evaluator.rs",
    "chars": 17653,
    "preview": "use super::*;\n\npub(crate) struct Evaluator<'src: 'run, 'run> {\n  assignments: Option<&'run Table<'src, Assignment<'src>>"
  },
  {
    "path": "src/execution_context.rs",
    "chars": 1639,
    "preview": "use super::*;\n\n#[derive(Copy, Clone)]\npub(crate) struct ExecutionContext<'src: 'run, 'run> {\n  pub(crate) config: &'run "
  },
  {
    "path": "src/executor.rs",
    "chars": 4228,
    "preview": "use super::*;\n\npub(crate) enum Executor<'a> {\n  Command(Interpreter<String>),\n  Shebang(Shebang<'a>),\n}\n\nimpl Executor<'"
  },
  {
    "path": "src/expression.rs",
    "chars": 5729,
    "preview": "use super::*;\n\n/// An expression. Note that the Just language grammar has both an `expression`\n/// production of additio"
  },
  {
    "path": "src/filesystem.rs",
    "chars": 374,
    "preview": "use super::*;\n\npub(crate) fn is_file(path: &Path) -> RunResult<'static, bool> {\n  match path.metadata() {\n    Ok(metadat"
  },
  {
    "path": "src/format_string_part.rs",
    "chars": 131,
    "preview": "#[derive(PartialEq, Debug, Clone, Ord, Eq, PartialOrd)]\npub(crate) enum FormatStringPart {\n  Continue,\n  End,\n  Single,\n"
  },
  {
    "path": "src/fragment.rs",
    "chars": 679,
    "preview": "use super::*;\n\n/// A line fragment consisting either of…\n#[derive(PartialEq, Debug, Clone)]\npub(crate) enum Fragment<'sr"
  },
  {
    "path": "src/function.rs",
    "chars": 20251,
    "preview": "use {\n  super::*,\n  Function::*,\n  heck::{\n    ToKebabCase, ToLowerCamelCase, ToShoutyKebabCase, ToShoutySnakeCase, ToSn"
  },
  {
    "path": "src/fuzzing.rs",
    "chars": 80,
    "preview": "use super::*;\n\npub fn compile(text: &str) {\n  let _ = testing::compile(text);\n}\n"
  },
  {
    "path": "src/interpreter.rs",
    "chars": 687,
    "preview": "use super::*;\n\n#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Serialize)]\npub(crate) struct Interpreter<T> {\n  p"
  },
  {
    "path": "src/invocation.rs",
    "chars": 171,
    "preview": "use super::*;\n\n#[derive(Debug, PartialEq)]\npub(crate) struct Invocation<'src, 'run> {\n  pub(crate) arguments: Vec<Vec<St"
  },
  {
    "path": "src/invocation_parser.rs",
    "chars": 16982,
    "preview": "use super::*;\n\n#[allow(clippy::doc_markdown)]\n/// The invocation parser is responsible for grouping command-line positio"
  },
  {
    "path": "src/item.rs",
    "chars": 1784,
    "preview": "use super::*;\n\n/// A single top-level item\n#[derive(Debug, Clone)]\npub(crate) enum Item<'src> {\n  Alias(Alias<'src, Name"
  },
  {
    "path": "src/justfile.rs",
    "chars": 23866,
    "preview": "use {super::*, serde::Serialize};\n\n#[derive(Debug, PartialEq, Serialize)]\npub(crate) struct Justfile<'src> {\n  pub(crate"
  },
  {
    "path": "src/keyed.rs",
    "chars": 697,
    "preview": "use super::*;\n\npub(crate) trait Keyed<'key> {\n  fn key(&self) -> &'key str;\n}\n\nimpl<'key, T: Keyed<'key>> Keyed<'key> fo"
  },
  {
    "path": "src/keyword.rs",
    "chars": 1104,
    "preview": "use super::*;\n\n#[derive(Debug, Eq, PartialEq, IntoStaticStr, Display, Copy, Clone, EnumString)]\n#[strum(serialize_all = "
  },
  {
    "path": "src/lexer.rs",
    "chars": 52362,
    "preview": "use {super::*, CompileErrorKind::*, TokenKind::*};\n\n/// Just language lexer\n///\n/// The lexer proceeds character-by-char"
  },
  {
    "path": "src/lib.rs",
    "chars": 6561,
    "preview": "//! `just` is primarily used as a command-line binary, but does provide a\n//! limited public library interface.\n//!\n//! "
  },
  {
    "path": "src/line.rs",
    "chars": 1388,
    "preview": "use super::*;\n\n/// A single line in a recipe body, consisting of any number of `Fragment`s.\n#[derive(Debug, Clone, Parti"
  },
  {
    "path": "src/list.rs",
    "chars": 3249,
    "preview": "use super::*;\n\npub(crate) struct List<T: Display, I: Iterator<Item = T> + Clone> {\n  conjunction: &'static str,\n  values"
  },
  {
    "path": "src/load_dotenv.rs",
    "chars": 1646,
    "preview": "use super::*;\n\npub(crate) fn load_dotenv(\n  config: &Config,\n  settings: &Settings,\n  working_directory: &Path,\n) -> Run"
  },
  {
    "path": "src/loader.rs",
    "chars": 616,
    "preview": "use super::*;\n\npub(crate) struct Loader {\n  paths: Arena<PathBuf>,\n  srcs: Arena<String>,\n}\n\nimpl Loader {\n  pub(crate) "
  },
  {
    "path": "src/main.rs",
    "chars": 102,
    "preview": "fn main() {\n  if let Err(code) = just::run(std::env::args_os()) {\n    std::process::exit(code);\n  }\n}\n"
  },
  {
    "path": "src/modulepath.rs",
    "chars": 2755,
    "preview": "use super::*;\n\n#[derive(Debug, Default, Eq, Ord, PartialEq, PartialOrd, Clone)]\npub(crate) struct Modulepath {\n  pub(cra"
  },
  {
    "path": "src/name.rs",
    "chars": 929,
    "preview": "use super::*;\n\n/// A name. This is just a `Token` of kind `Identifier`, but we give it its own\n/// type for clarity.\n#[d"
  },
  {
    "path": "src/namepath.rs",
    "chars": 1233,
    "preview": "use super::*;\n\n#[derive(Clone, Debug, PartialEq, Eq, Ord, PartialOrd)]\npub(crate) struct Namepath<'src>(Vec<Name<'src>>)"
  },
  {
    "path": "src/node.rs",
    "chars": 9644,
    "preview": "use super::*;\n\n/// Methods common to all AST nodes. Currently only used in parser unit tests.\npub(crate) trait Node<'src"
  },
  {
    "path": "src/number.rs",
    "chars": 93,
    "preview": "#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]\npub(crate) struct Number(pub(crate) u32);\n"
  },
  {
    "path": "src/numerator.rs",
    "chars": 377,
    "preview": "use super::*;\n\npub(crate) struct Numerator(u32);\n\nimpl Numerator {\n  pub(crate) fn new() -> Self {\n    Self(constants()."
  },
  {
    "path": "src/ordinal.rs",
    "chars": 196,
    "preview": "pub(crate) trait Ordinal {\n  /// Convert an index starting at 0 to an ordinal starting at 1\n  fn ordinal(self) -> Self;\n"
  },
  {
    "path": "src/output_error.rs",
    "chars": 1352,
    "preview": "use super::*;\n\n#[derive(Debug)]\npub(crate) enum OutputError {\n  /// Non-zero exit code\n  Code(i32),\n  /// Interrupted by"
  },
  {
    "path": "src/parameter.rs",
    "chars": 1632,
    "preview": "use super::*;\n\n#[derive(PartialEq, Debug, Clone, Serialize)]\npub(crate) struct Parameter<'src> {\n  pub(crate) default: O"
  },
  {
    "path": "src/parameter_kind.rs",
    "chars": 617,
    "preview": "use super::*;\n\n/// Parameters can either be…\n#[derive(Debug, Copy, Clone, Eq, PartialEq, Serialize)]\n#[serde(rename_all "
  },
  {
    "path": "src/parser.rs",
    "chars": 78642,
    "preview": "use {super::*, TokenKind::*};\n\n/// Just language parser\n///\n/// The parser is a (hopefully) straightforward recursive de"
  },
  {
    "path": "src/pattern.rs",
    "chars": 1523,
    "preview": "use super::*;\n\n#[derive(Debug, Clone)]\npub(crate) struct Pattern<'src> {\n  pub(crate) regex: Regex,\n  pub(crate) token: "
  },
  {
    "path": "src/platform/unix.rs",
    "chars": 1823,
    "preview": "use super::*;\n\nimpl PlatformInterface for Platform {\n  fn make_shebang_command(\n    _config: &Config,\n    path: &Path,\n "
  },
  {
    "path": "src/platform/windows.rs",
    "chars": 2466,
    "preview": "use super::*;\n\nimpl PlatformInterface for Platform {\n  fn make_shebang_command(\n    config: &Config,\n    path: &Path,\n  "
  },
  {
    "path": "src/platform.rs",
    "chars": 97,
    "preview": "use super::*;\n\npub(crate) struct Platform;\n\n#[cfg(unix)]\nmod unix;\n\n#[cfg(windows)]\nmod windows;\n"
  },
  {
    "path": "src/platform_interface.rs",
    "chars": 865,
    "preview": "use super::*;\n\npub(crate) trait PlatformInterface {\n  /// translate path from \"native\" path to path interpreter expects\n"
  },
  {
    "path": "src/position.rs",
    "chars": 174,
    "preview": "/// Source position\n#[derive(Copy, Clone, PartialEq, Debug)]\npub(crate) struct Position {\n  pub(crate) column: usize,\n  "
  },
  {
    "path": "src/positional.rs",
    "chars": 5787,
    "preview": "use super::*;\n\n/// A struct containing the parsed representation of positional command-line\n/// arguments, i.e. argument"
  },
  {
    "path": "src/ran.rs",
    "chars": 422,
    "preview": "use super::*;\n\n#[derive(Default)]\npub(crate) struct Ran(Mutex<BTreeMap<Modulepath, BTreeMap<Vec<Vec<String>>, Arc<Mutex<"
  },
  {
    "path": "src/range_ext.rs",
    "chars": 1059,
    "preview": "use super::*;\n\npub(crate) trait RangeExt<T> {\n  fn display(&self) -> DisplayRange<&Self> {\n    DisplayRange(self)\n  }\n}\n"
  },
  {
    "path": "src/recipe.rs",
    "chars": 17075,
    "preview": "use super::*;\n\n/// Return a `Error::Signal` if the process was terminated by a signal,\n/// otherwise return an `Error::U"
  },
  {
    "path": "src/recipe_resolver.rs",
    "chars": 5202,
    "preview": "use {super::*, CompileErrorKind::*};\n\npub(crate) struct RecipeResolver<'src: 'run, 'run> {\n  assignments: &'run Table<'s"
  },
  {
    "path": "src/recipe_signature.rs",
    "chars": 393,
    "preview": "use super::*;\n\npub(crate) struct RecipeSignature<'a> {\n  pub(crate) name: &'a str,\n  pub(crate) recipe: &'a Recipe<'a>,\n"
  },
  {
    "path": "src/request.rs",
    "chars": 377,
    "preview": "use super::*;\n\n#[derive(Clone, Debug, Deserialize, PartialEq)]\n#[serde(rename_all = \"kebab-case\")]\npub enum Request {\n  "
  },
  {
    "path": "src/run.rs",
    "chars": 1357,
    "preview": "use super::*;\n\n/// Main entry point into `just`. Parse arguments from `args` and run.\n#[allow(clippy::missing_errors_doc"
  },
  {
    "path": "src/scope.rs",
    "chars": 1687,
    "preview": "use super::*;\n\n#[derive(Debug)]\npub(crate) struct Scope<'src: 'run, 'run> {\n  bindings: Table<'src, Binding<'src, String"
  },
  {
    "path": "src/search.rs",
    "chars": 12756,
    "preview": "use {super::*, std::path::Component};\n\nconst DEFAULT_JUSTFILE_NAME: &str = JUSTFILE_NAMES[0];\npub(crate) const JUSTFILE_"
  },
  {
    "path": "src/search_config.rs",
    "chars": 826,
    "preview": "use super::*;\n\n/// Controls how `just` will search for the justfile.\n#[derive(Debug, Default, PartialEq)]\npub(crate) enu"
  },
  {
    "path": "src/search_error.rs",
    "chars": 1366,
    "preview": "use super::*;\n\n#[derive(Debug, Snafu)]\n#[snafu(visibility(pub(crate)))]\npub(crate) enum SearchError {\n  #[snafu(display("
  },
  {
    "path": "src/set.rs",
    "chars": 376,
    "preview": "use super::*;\n\n#[derive(Debug, Clone)]\npub(crate) struct Set<'src> {\n  pub(crate) name: Name<'src>,\n  pub(crate) value: "
  },
  {
    "path": "src/setting.rs",
    "chars": 2297,
    "preview": "use super::*;\n\n#[derive(Debug, Clone)]\npub(crate) enum Setting<'src> {\n  AllowDuplicateRecipes(bool),\n  AllowDuplicateVa"
  },
  {
    "path": "src/settings.rs",
    "chars": 4977,
    "preview": "use super::*;\n\npub(crate) const DEFAULT_SHELL: &str = \"sh\";\npub(crate) const DEFAULT_SHELL_ARGS: &[&str] = &[\"-cu\"];\npub"
  },
  {
    "path": "src/shebang.rs",
    "chars": 3448,
    "preview": "#[derive(Copy, Clone)]\npub(crate) struct Shebang<'line> {\n  pub(crate) argument: Option<&'line str>,\n  pub(crate) interp"
  },
  {
    "path": "src/show_whitespace.rs",
    "chars": 412,
    "preview": "use super::*;\n\n/// String wrapper that uses nonblank characters to display spaces and tabs\npub(crate) struct ShowWhitesp"
  },
  {
    "path": "src/sigil.rs",
    "chars": 100,
    "preview": "#[derive(Eq, Ord, PartialEq, PartialOrd)]\npub(crate) enum Sigil {\n  Guard,\n  Infallible,\n  Quiet,\n}\n"
  },
  {
    "path": "src/signal.rs",
    "chars": 3895,
    "preview": "use super::*;\n\n#[derive(Clone, Copy, Debug, PartialEq)]\n#[repr(i32)]\npub(crate) enum Signal {\n  Hangup = 1,\n  #[cfg(any("
  },
  {
    "path": "src/signal_handler.rs",
    "chars": 3757,
    "preview": "use super::*;\n\npub(crate) struct SignalHandler {\n  caught: Option<Signal>,\n  children: BTreeMap<i32, Command>,\n  initial"
  },
  {
    "path": "src/signals.rs",
    "chars": 3515,
    "preview": "use {\n  super::*,\n  nix::{\n    errno::Errno,\n    fcntl::{FcntlArg, FdFlag},\n    sys::signal::{SaFlags, SigAction, SigHan"
  },
  {
    "path": "src/source.rs",
    "chars": 1659,
    "preview": "use super::*;\n\n#[derive(Debug)]\npub(crate) struct Source<'src> {\n  pub(crate) file_depth: u32,\n  pub(crate) file_path: V"
  },
  {
    "path": "src/string_delimiter.rs",
    "chars": 140,
    "preview": "#[derive(Debug, PartialEq, Clone, Copy, Ord, PartialOrd, Eq)]\npub(crate) enum StringDelimiter {\n  Backtick,\n  QuoteDoubl"
  },
  {
    "path": "src/string_kind.rs",
    "chars": 2627,
    "preview": "use super::*;\n\n#[derive(Debug, PartialEq, Clone, Copy, Ord, PartialOrd, Eq)]\npub(crate) struct StringKind {\n  pub(crate)"
  },
  {
    "path": "src/string_literal.rs",
    "chars": 765,
    "preview": "use super::*;\n\n#[derive(PartialEq, Debug, Clone, Ord, Eq, PartialOrd)]\npub(crate) struct StringLiteral<'src> {\n  pub(cra"
  },
  {
    "path": "src/string_state.rs",
    "chars": 102,
    "preview": "use super::*;\n\npub(crate) enum StringState {\n  FormatContinue(StringKind),\n  FormatStart,\n  Normal,\n}\n"
  },
  {
    "path": "src/subcommand.rs",
    "chars": 23207,
    "preview": "use {super::*, clap_mangen::Man};\n\npub const INIT_JUSTFILE: &str = \"\\\n# https://just.systems\n\ndefault:\n    echo 'Hello, "
  },
  {
    "path": "src/suggestion.rs",
    "chars": 418,
    "preview": "use super::*;\n\n#[derive(Clone, Copy, Debug, PartialEq)]\npub(crate) struct Suggestion<'src> {\n  pub(crate) name: &'src st"
  },
  {
    "path": "src/summary.rs",
    "chars": 10786,
    "preview": "//! Justfile summary creation, for testing purposes only.\n//!\n//! The contents of this module are not bound by any stabi"
  },
  {
    "path": "src/switch.rs",
    "chars": 310,
    "preview": "use super::*;\n\n#[derive(Debug, PartialEq)]\npub(crate) enum Switch {\n  Long(String),\n  Short(char),\n}\n\nimpl Display for S"
  },
  {
    "path": "src/table.rs",
    "chars": 2243,
    "preview": "use {super::*, std::collections::btree_map};\n\n#[derive(Debug, PartialEq, Serialize)]\n#[serde(transparent)]\npub(crate) st"
  },
  {
    "path": "src/testing.rs",
    "chars": 3698,
    "preview": "use {super::*, pretty_assertions::assert_eq};\n\npub(crate) fn compile(src: &str) -> Justfile {\n  Compiler::test_compile(s"
  },
  {
    "path": "src/thunk.rs",
    "chars": 6592,
    "preview": "use super::*;\n\n#[allow(clippy::arbitrary_source_item_ordering)]\n#[derive_where(Debug, PartialEq)]\n#[derive(Clone)]\npub(c"
  },
  {
    "path": "src/token.rs",
    "chars": 2826,
    "preview": "use super::*;\n\n#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd)]\npub(crate) struct Token<'src> {\n  pub(crate"
  },
  {
    "path": "src/token_kind.rs",
    "chars": 1983,
    "preview": "use super::*;\n\n#[derive(Debug, PartialEq, Clone, Copy, Ord, PartialOrd, Eq)]\npub(crate) enum TokenKind {\n  AmpersandAmpe"
  },
  {
    "path": "src/tree.rs",
    "chars": 3209,
    "preview": "use {super::*, std::borrow::Cow};\n\n/// Construct a `Tree` from a symbolic expression literal. This macro, and the\n/// Tr"
  },
  {
    "path": "src/unindent.rs",
    "chars": 2920,
    "preview": "#[must_use]\npub fn unindent(text: &str) -> String {\n  // find line start and end indices\n  let mut lines = Vec::new();\n "
  },
  {
    "path": "src/unresolved_dependency.rs",
    "chars": 519,
    "preview": "use super::*;\n\n#[derive(PartialEq, Debug, Clone)]\npub(crate) struct UnresolvedDependency<'src> {\n  pub(crate) arguments:"
  },
  {
    "path": "src/unresolved_recipe.rs",
    "chars": 3839,
    "preview": "use super::*;\n\npub(crate) type UnresolvedRecipe<'src> = Recipe<'src, UnresolvedDependency<'src>>;\n\nimpl<'src> Unresolved"
  },
  {
    "path": "src/unstable_feature.rs",
    "chars": 803,
    "preview": "use super::*;\n\n#[derive(Copy, Clone, Debug, PartialEq, Ord, Eq, PartialOrd)]\npub(crate) enum UnstableFeature {\n  EagerAs"
  },
  {
    "path": "src/usage.rs",
    "chars": 3946,
    "preview": "use super::*;\n\npub(crate) struct Usage<'a, D> {\n  pub(crate) long: bool,\n  pub(crate) path: &'a Modulepath,\n  pub(crate)"
  },
  {
    "path": "src/use_color.rs",
    "chars": 123,
    "preview": "use super::*;\n\n#[derive(Copy, Clone, Debug, PartialEq, ValueEnum)]\npub(crate) enum UseColor {\n  Always,\n  Auto,\n  Never,"
  },
  {
    "path": "src/variables.rs",
    "chars": 3156,
    "preview": "use super::*;\n\npub(crate) struct Variables<'expression, 'src> {\n  stack: Vec<&'expression Expression<'src>>,\n}\n\nimpl<'ex"
  },
  {
    "path": "src/verbosity.rs",
    "chars": 835,
    "preview": "#[allow(clippy::arbitrary_source_item_ordering)]\n#[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]\npub(crate) enum Ve"
  },
  {
    "path": "src/warning.rs",
    "chars": 887,
    "preview": "use super::*;\n\n#[derive(Clone, Debug, PartialEq)]\npub(crate) enum Warning {}\n\nimpl Warning {\n  #[allow(clippy::unused_se"
  },
  {
    "path": "src/which.rs",
    "chars": 1991,
    "preview": "use super::*;\n\npub(crate) fn which(context: function::Context, name: &str) -> Result<Option<String>, String> {\n  let nam"
  },
  {
    "path": "tests/alias.rs",
    "chars": 939,
    "preview": "use super::*;\n\n#[test]\nfn alias_nested_module() {\n  Test::new()\n    .write(\"foo.just\", \"mod bar\\nbaz: \\n @echo FOO\")\n   "
  },
  {
    "path": "tests/alias_style.rs",
    "chars": 1638,
    "preview": "use super::*;\n\n#[test]\nfn default() {\n  Test::new()\n    .justfile(\n      \"\n        alias f := foo\n\n        # comment\n   "
  },
  {
    "path": "tests/allow_duplicate_recipes.rs",
    "chars": 573,
    "preview": "use super::*;\n\n#[test]\nfn allow_duplicate_recipes() {\n  Test::new()\n    .justfile(\n      \"\n      b:\n        echo foo\n   "
  },
  {
    "path": "tests/allow_duplicate_variables.rs",
    "chars": 287,
    "preview": "use super::*;\n\n#[test]\nfn allow_duplicate_variables() {\n  Test::new()\n    .justfile(\n      \"\n      a := 'foo'\n      a :="
  },
  {
    "path": "tests/allow_missing.rs",
    "chars": 1024,
    "preview": "use super::*;\n\n#[test]\nfn allow_missing_recipes_in_run_invocation() {\n  Test::new()\n    .arg(\"foo\")\n    .stderr(\"error: "
  },
  {
    "path": "tests/arg_attribute.rs",
    "chars": 7132,
    "preview": "use super::*;\n\n#[test]\nfn pattern_match() {\n  Test::new()\n    .justfile(\n      \"\n        [arg('bar', pattern='BAR')]\n   "
  },
  {
    "path": "tests/assert_stdout.rs",
    "chars": 181,
    "preview": "use super::*;\n\npub(crate) fn assert_stdout(output: &std::process::Output, stdout: &str) {\n  assert_success(output);\n  as"
  },
  {
    "path": "tests/assert_success.rs",
    "chars": 289,
    "preview": "#[track_caller]\npub(crate) fn assert_success(output: &std::process::Output) {\n  if !output.status.success() {\n    eprint"
  },
  {
    "path": "tests/assertions.rs",
    "chars": 538,
    "preview": "use super::*;\n\n#[test]\nfn assert_pass() {\n  Test::new()\n    .justfile(\n      \"\n        foo:\n          {{ assert('a' == '"
  },
  {
    "path": "tests/assignment.rs",
    "chars": 984,
    "preview": "use super::*;\n\n#[test]\nfn set_export_parse_error() {\n  Test::new()\n    .justfile(\n      \"\n    set export := fals\n  \",\n  "
  },
  {
    "path": "tests/attributes.rs",
    "chars": 7102,
    "preview": "use super::*;\n\n#[test]\nfn all() {\n  Test::new()\n    .justfile(\n      \"\n      [dragonfly]\n      [freebsd]\n      [linux]\n "
  },
  {
    "path": "tests/backticks.rs",
    "chars": 270,
    "preview": "use super::*;\n\n#[test]\nfn trailing_newlines_are_stripped() {\n  Test::new()\n    .shell(false)\n    .args([\"--evaluate\", \"f"
  },
  {
    "path": "tests/byte_order_mark.rs",
    "chars": 885,
    "preview": "use super::*;\n\n#[test]\nfn ignore_leading_byte_order_mark() {\n  Test::new()\n    .justfile(\n      \"\n      \\u{feff}foo:\n   "
  },
  {
    "path": "tests/ceiling.rs",
    "chars": 1917,
    "preview": "use super::*;\n\n#[test]\nfn justfile_run_search_stops_at_ceiling_dir() {\n  let tempdir = tempdir();\n\n  let ceiling = tempd"
  },
  {
    "path": "tests/changelog.rs",
    "chars": 162,
    "preview": "use super::*;\n\n#[test]\nfn print_changelog() {\n  Test::new()\n    .args([\"--changelog\"])\n    .stdout(fs::read_to_string(\"C"
  },
  {
    "path": "tests/choose.rs",
    "chars": 4850,
    "preview": "use super::*;\n\n#[test]\nfn env() {\n  Test::new()\n    .arg(\"--choose\")\n    .env(\"JUST_CHOOSER\", \"head -n1\")\n    .justfile("
  },
  {
    "path": "tests/command.rs",
    "chars": 3436,
    "preview": "use super::*;\n\n#[test]\nfn long() {\n  Test::new()\n    .arg(\"--command\")\n    .arg(\"printf\")\n    .arg(\"foo\")\n    .justfile("
  },
  {
    "path": "tests/completions/just.bash",
    "chars": 1510,
    "preview": "#!/usr/bin/env bash\n\n# --- Shared functions ---\nreply_equals() {\n  local reply=$(declare -p COMPREPLY)\n  local expected="
  },
  {
    "path": "tests/completions/justfile",
    "chars": 38,
    "preview": "install:\ntest:\ndeploy:\npush:\npublish:\n"
  },
  {
    "path": "tests/completions/subdir/justfile",
    "chars": 19,
    "preview": "special:\nsurprise:\n"
  },
  {
    "path": "tests/completions.rs",
    "chars": 936,
    "preview": "use super::*;\n\n#[test]\nfn bash() {\n  if cfg!(not(target_os = \"linux\")) {\n    return;\n  }\n  let output = Command::new(JUS"
  },
  {
    "path": "tests/conditional.rs",
    "chars": 4269,
    "preview": "use super::*;\n\n#[test]\nfn then_branch_unevaluated() {\n  Test::new()\n    .justfile(\n      \"\n    foo:\n      echo {{ if 'a'"
  },
  {
    "path": "tests/confirm.rs",
    "chars": 3116,
    "preview": "use super::*;\n\n#[test]\nfn confirm_recipe_arg() {\n  Test::new()\n    .arg(\"--yes\")\n    .justfile(\n      \"\n        [confirm"
  },
  {
    "path": "tests/constants.rs",
    "chars": 1181,
    "preview": "use super::*;\n\n#[test]\nfn constants_are_defined() {\n  assert_eval_eq(\"HEX\", \"0123456789abcdef\");\n}\n\n#[test]\nfn constants"
  },
  {
    "path": "tests/datetime.rs",
    "chars": 439,
    "preview": "use super::*;\n\n#[test]\nfn datetime() {\n  Test::new()\n    .justfile(\n      \"\n        x := datetime('%Y-%m-%d %z')\n      \""
  },
  {
    "path": "tests/default.rs",
    "chars": 657,
    "preview": "use super::*;\n\n#[test]\nfn default_attribute_overrides_first_recipe() {\n  Test::new()\n    .justfile(\n      \"\n        foo:"
  },
  {
    "path": "tests/delimiters.rs",
    "chars": 1620,
    "preview": "use super::*;\n\n#[test]\nfn mismatched_delimiter() {\n  Test::new()\n    .justfile(\"(]\")\n    .stderr(\n      \"\n    error: Mis"
  },
  {
    "path": "tests/dependencies.rs",
    "chars": 2291,
    "preview": "use super::*;\n\n#[test]\nfn recipe_doubly_nested_module_dependencies() {\n  Test::new()\n    .write(\"foo.just\", \"mod bar\\nba"
  },
  {
    "path": "tests/directories.rs",
    "chars": 1953,
    "preview": "use super::*;\n\n#[test]\nfn cache_directory() {\n  Test::new()\n    .justfile(\"x := cache_directory()\")\n    .args([\"--evalua"
  },
  {
    "path": "tests/dotenv.rs",
    "chars": 8331,
    "preview": "use super::*;\n\n#[test]\nfn dotenv() {\n  Test::new()\n    .write(\".env\", \"KEY=ROOT\")\n    .write(\"sub/.env\", \"KEY=SUB\")\n    "
  },
  {
    "path": "tests/dump.rs",
    "chars": 476,
    "preview": "use super::*;\n\n#[test]\nfn dump() {\n  Test::new()\n    .arg(\"--dump\")\n    .justfile(\n      \"\n        # this recipe does so"
  },
  {
    "path": "tests/edit.rs",
    "chars": 3845,
    "preview": "use super::*;\n\nconst JUSTFILE: &str = \"Yooooooo, hopefully this never becomes valid syntax.\";\n\n/// Test that --edit does"
  },
  {
    "path": "tests/equals.rs",
    "chars": 392,
    "preview": "use super::*;\n\n#[test]\nfn export_recipe() {\n  Test::new()\n    .justfile(\n      \"\n      export foo='bar':\n        echo {{"
  },
  {
    "path": "tests/error_messages.rs",
    "chars": 2461,
    "preview": "use super::*;\n\n#[test]\nfn invalid_alias_attribute() {\n  Test::new()\n    .justfile(\"[private]\\n[linux]\\nalias t := test\\n"
  },
  {
    "path": "tests/evaluate.rs",
    "chars": 2140,
    "preview": "use super::*;\n\n#[test]\nfn evaluate() {\n  Test::new()\n    .arg(\"--evaluate\")\n    .justfile(\n      r#\"\nfoo := \"a\\t\"\nhello "
  },
  {
    "path": "tests/examples.rs",
    "chars": 371,
    "preview": "use super::*;\n\n#[test]\nfn examples() {\n  for result in fs::read_dir(\"examples\").unwrap() {\n    let entry = result.unwrap"
  },
  {
    "path": "tests/explain.rs",
    "chars": 366,
    "preview": "use super::*;\n\n#[test]\nfn explain_recipe() {\n  Test::new()\n    .justfile(\n      \"\n      # List some fruits\n      fruits:"
  },
  {
    "path": "tests/export.rs",
    "chars": 4103,
    "preview": "use super::*;\n\n#[test]\nfn success() {\n  Test::new()\n    .justfile(\n      r#\"\nexport FOO := \"a\"\nbaz := \"c\"\nexport BAR := "
  },
  {
    "path": "tests/fallback.rs",
    "chars": 5715,
    "preview": "use super::*;\n\n#[test]\nfn fallback_from_subdir_bugfix() {\n  Test::new()\n    .write(\n      \"sub/justfile\",\n      unindent"
  },
  {
    "path": "tests/format.rs",
    "chars": 22424,
    "preview": "use super::*;\n\n#[test]\nfn unstable_not_passed() {\n  Test::new()\n    .arg(\"--fmt\")\n    .justfile(\"\")\n    .stderr_regex(\"e"
  },
  {
    "path": "tests/format_string.rs",
    "chars": 5605,
    "preview": "use super::*;\n\n#[test]\nfn empty() {\n  Test::new()\n    .justfile(\n      \"\n        foo := f''\n\n        @baz:\n          ech"
  },
  {
    "path": "tests/functions.rs",
    "chars": 29308,
    "preview": "use super::*;\n\n#[test]\nfn test_os_arch_functions_in_interpolation() {\n  Test::new()\n    .justfile(\n      r\"\nfoo:\n  echo "
  }
]

// ... and 69 more files (download for full content)