├── .gitignore
├── e2e
    ├── .gitignore
    ├── common.py
    ├── capture_postamble.zsh
    ├── requirements.txt
    ├── capture_preamble.zsh
    ├── test_zsh_pty.py
    ├── conftest.py
    ├── test_zsh.py
    ├── test_bash.py
    ├── test_fish.py
    └── test_validation.py
├── pytest.ini
├── .hypothesis
    ├── examples
    │   ├── 3829dcef94528797
    │   │   └── 1086a78797317d2d
    │   ├── 3ea86dbcb01b162b
    │   │   └── 1086a78797317d2d
    │   ├── 6a13d6a94003c708
    │   │   └── 1086a78797317d2d
    │   ├── 7375ce819d42ab0d
    │   │   └── 1086a78797317d2d
    │   ├── 77dae7b8778b88e0
    │   │   ├── 1086a78797317d2d
    │   │   └── bec021b4f368e306
    │   ├── 7a02f7143aa5bd0f
    │   │   └── 1086a78797317d2d
    │   ├── bb3263574321e5ea
    │   │   └── 1086a78797317d2d
    │   ├── c6871e3a81e8b20d
    │   │   └── 1086a78797317d2d
    │   └── f7b253aa616ff3a5
    │   │   ├── 25be50f1a45836e1
    │   │   ├── 74844d13d1d969b6
    │   │   └── aad329b8ac08c355
    └── unicode_data
    │   ├── 15.0.0
    │       └── charmap.json.gz
    │   └── 15.1.0
    │       └── charmap.json.gz
├── run-e2e-tests.bash
├── examples
    ├── complgen.usage
    ├── mygrep.usage
    └── darcs.usage
├── Cargo.toml
├── src
    ├── lib.rs
    ├── scrape.rs
    └── main.rs
├── .github
    └── workflows
    │   └── release.yml
├── CHANGELOG.md
├── CONTRIBUTING.md
├── README.md
└── Cargo.lock


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | /venv
3 | 


--------------------------------------------------------------------------------
/e2e/.gitignore:
--------------------------------------------------------------------------------
1 | __pycache__
2 | 


--------------------------------------------------------------------------------
/pytest.ini:
--------------------------------------------------------------------------------
1 | [pytest]
2 | addopts = --ignore=target
3 | 


--------------------------------------------------------------------------------
/.hypothesis/examples/3829dcef94528797/1086a78797317d2d:
--------------------------------------------------------------------------------
1 |   


--------------------------------------------------------------------------------
/.hypothesis/examples/3ea86dbcb01b162b/1086a78797317d2d:
--------------------------------------------------------------------------------
1 |   


--------------------------------------------------------------------------------
/.hypothesis/examples/6a13d6a94003c708/1086a78797317d2d:
--------------------------------------------------------------------------------
1 |   


--------------------------------------------------------------------------------
/.hypothesis/examples/7375ce819d42ab0d/1086a78797317d2d:
--------------------------------------------------------------------------------
1 |   


--------------------------------------------------------------------------------
/.hypothesis/examples/77dae7b8778b88e0/1086a78797317d2d:
--------------------------------------------------------------------------------
1 |   


--------------------------------------------------------------------------------
/.hypothesis/examples/77dae7b8778b88e0/bec021b4f368e306:
--------------------------------------------------------------------------------
1 |  


--------------------------------------------------------------------------------
/.hypothesis/examples/7a02f7143aa5bd0f/1086a78797317d2d:
--------------------------------------------------------------------------------
1 |   


--------------------------------------------------------------------------------
/.hypothesis/examples/bb3263574321e5ea/1086a78797317d2d:
--------------------------------------------------------------------------------
1 |   


--------------------------------------------------------------------------------
/.hypothesis/examples/c6871e3a81e8b20d/1086a78797317d2d:
--------------------------------------------------------------------------------
1 |   


--------------------------------------------------------------------------------
/.hypothesis/examples/f7b253aa616ff3a5/25be50f1a45836e1:
--------------------------------------------------------------------------------
1 | " 


--------------------------------------------------------------------------------
/.hypothesis/examples/f7b253aa616ff3a5/74844d13d1d969b6:
--------------------------------------------------------------------------------
1 | " 


--------------------------------------------------------------------------------
/.hypothesis/examples/f7b253aa616ff3a5/aad329b8ac08c355:
--------------------------------------------------------------------------------
1 | ?( 


--------------------------------------------------------------------------------
/.hypothesis/unicode_data/15.0.0/charmap.json.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/adaszko/complgen/HEAD/.hypothesis/unicode_data/15.0.0/charmap.json.gz


--------------------------------------------------------------------------------
/.hypothesis/unicode_data/15.1.0/charmap.json.gz:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/adaszko/complgen/HEAD/.hypothesis/unicode_data/15.1.0/charmap.json.gz


--------------------------------------------------------------------------------
/e2e/common.py:
--------------------------------------------------------------------------------
 1 | STRACE_EXPR_GRAMMAR = """
 2 | strace -e <EXPR>;
 3 | <EXPR> ::= [<qualifier>=][!]<value>[,<value>]...;
 4 | <qualifier> ::= trace | read | write | fault;
 5 | <value> ::= %file | file | all;
 6 | """
 7 | 
 8 | LSOF_FILTER_GRAMMAR = """
 9 | lsf -s<PROTOCOL>:<STATE-SPEC>[,<STATE-SPEC>]...;
10 | <PROTOCOL> ::= TCP | UDP;
11 | <STATE-SPEC> ::= [^]<STATE>;
12 | <STATE> ::= LISTEN | CLOSED;
13 | """
14 | 


--------------------------------------------------------------------------------
/e2e/capture_postamble.zsh:
--------------------------------------------------------------------------------
 1 | # signal success!
 2 | echo ok')
 3 | 
 4 | zpty -w z "$*"$'\t'
 5 | 
 6 | integer tog=0
 7 | # read from the pty, and parse linewise
 8 | while zpty -r z; do :; done | while IFS= read -r line; do
 9 |     if [[ $line == *$'\0\r' ]]; then
10 |         (( tog++ )) && return 0 || continue
11 |     fi
12 |     # display between toggles
13 |     (( tog )) && echo -E - $line
14 | done
15 | 
16 | return 2
17 | 


--------------------------------------------------------------------------------
/run-e2e-tests.bash:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | 
 3 | set -o errexit
 4 | set -o nounset
 5 | set -o pipefail
 6 | 
 7 | main () {
 8 |     local this_script_path=$(realpath $0)
 9 |     local project_dir=$(dirname "$this_script_path")
10 |     if [[ ! -d $project_dir/venv ]]; then
11 |         python3 -m venv "$project_dir/venv"
12 |         "$project_dir/venv/bin/pip" install -r $project_dir/e2e/requirements.txt
13 |     fi
14 |     $project_dir/venv/bin/pytest --no-header "$@"
15 | }
16 | 
17 | main "$@"
18 | 


--------------------------------------------------------------------------------
/examples/complgen.usage:
--------------------------------------------------------------------------------
 1 | complgen <OPTION> <PATH>;
 2 | <OPTION> ::= [(--bash <PATH>) "Write bash completion script"]
 3 |              [(--fish <PATH>) "Write fish completion script"]
 4 |              [(--zsh <PATH>) "Write zsh completion script"]
 5 |              [(--dfa <PATH>) "Dump resulting DFA as a GraphViz .dot format"]
 6 |              [(--railroad <PATH>) "Dump the parsed grammar as SVG railroad diagram"]
 7 |          ;
 8 | complgen --scrape "Read another program's --help output and generate a grammar SKELETON";
 9 | complgen --version;
10 | 


--------------------------------------------------------------------------------
/e2e/requirements.txt:
--------------------------------------------------------------------------------
 1 | asttokens==2.4.1
 2 | attrs==23.2.0
 3 | decorator==5.1.1
 4 | exceptiongroup==1.1.1
 5 | executing==2.2.0
 6 | hypothesis==6.103.2
 7 | iniconfig==2.0.0
 8 | inline-snapshot==0.20.7
 9 | ipython==8.25.0
10 | jedi==0.19.1
11 | markdown-it-py==3.0.0
12 | matplotlib-inline==0.1.7
13 | mdurl==0.1.2
14 | packaging==23.1
15 | parso==0.8.4
16 | pexpect==4.9.0
17 | pluggy==1.2.0
18 | prompt_toolkit==3.0.47
19 | ptyprocess==0.7.0
20 | pure-eval==0.2.2
21 | Pygments==2.18.0
22 | pytest==7.4.0
23 | rich==13.9.4
24 | six==1.16.0
25 | sortedcontainers==2.4.0
26 | stack-data==0.6.3
27 | tomli==2.0.1
28 | traitlets==5.14.3
29 | wcwidth==0.2.13
30 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "complgen"
 3 | version = "0.5.0"
 4 | edition = "2024"
 5 | description = "Declarative bash/fish/zsh completions without writing shell scripts"
 6 | 
 7 | [lib]
 8 | name = "complgen"
 9 | path = "src/lib.rs"
10 | 
11 | [[bin]]
12 | name = "complgen"
13 | path = "src/main.rs"
14 | 
15 | [dependencies]
16 | anyhow = "1.0.71"
17 | chic = "1.2.2"
18 | clap = { version = "4.2.1", features = ["derive"] }
19 | hashbrown = "0.13.2"
20 | indexmap = "2.7.0"
21 | itertools = "0.10.5"
22 | nom = "7.1.3"
23 | nom_locate = "4.2.0"
24 | regex = "1.9.5"
25 | roaring = "0.10.1"
26 | thiserror = "1.0.39"
27 | ustr = "0.9.0"
28 | 
29 | [dev-dependencies]
30 | proptest = "1.1.0"
31 | 
32 | [profile.dev]
33 | debug = "line-tables-only"
34 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | use grammar::HumanSpan;
 2 | use std::string::FromUtf8Error;
 3 | 
 4 | use crate::regex::Inp;
 5 | 
 6 | pub mod bash;
 7 | pub mod dfa;
 8 | pub mod fish;
 9 | pub mod grammar;
10 | pub mod regex;
11 | pub mod scrape;
12 | pub mod zsh;
13 | 
14 | #[derive(thiserror::Error, Debug)]
15 | pub enum Error {
16 |     #[error("Parse error")]
17 |     ParseError(HumanSpan),
18 | 
19 |     #[error("Grammar needs to contain at least one call variant, e.g. grep;")]
20 |     MissingCallVariants,
21 | 
22 |     #[error("Invalid command name")]
23 |     InvalidCommandName(HumanSpan),
24 | 
25 |     #[error("Multiple commands")]
26 |     VaryingCommandNames(Box<[HumanSpan]>),
27 | 
28 |     #[error("Nonterminal definitions depend on each other cyclically")]
29 |     NonterminalDefinitionsCycle(Box<[HumanSpan]>),
30 | 
31 |     #[error("Duplicate nonterminal definition")]
32 |     DuplicateNonterminalDefinition(HumanSpan, HumanSpan),
33 | 
34 |     #[error("Unknown shell")]
35 |     UnknownShell(HumanSpan),
36 | 
37 |     #[error("Can only specialize external commands")]
38 |     NonCommandSpecialization(HumanSpan),
39 | 
40 |     #[error("Ambiguity in matching: {:?} {:?}", .0, .1)]
41 |     AmbiguousMatchable(HumanSpan, HumanSpan),
42 | 
43 |     #[error("Ambiguity in matching")]
44 |     UnboundedMatchable(HumanSpan, HumanSpan),
45 | 
46 |     #[error("Clashing variants")]
47 |     ClashingVariants(HumanSpan, HumanSpan),
48 | 
49 |     #[error("Clashing subword leaders")]
50 |     ClashingSubwordLeaders(HumanSpan, HumanSpan),
51 | 
52 |     #[error("Two adjacent terminals in a subword expression")]
53 |     SubwordSpaces(HumanSpan, HumanSpan, Box<[HumanSpan]>),
54 | 
55 |     #[error("Ambiguous DFA: {:?} {:?}", .0, .1)]
56 |     AmbiguousDFA(Box<[Inp]>, Box<[Inp]>),
57 | 
58 |     #[error("UTF-8 conversion error")]
59 |     FromUtf8Error(#[from] FromUtf8Error),
60 | 
61 |     #[error("Formatting error")]
62 |     FmtError(#[from] std::fmt::Error),
63 | 
64 |     #[error("IO error")]
65 |     IoError(#[from] std::io::Error),
66 | }
67 | 
68 | pub type Result<T> = std::result::Result<T, Error>;
69 | 
70 | pub type StateId = u32;
71 | 


--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
 1 | name: Release
 2 | on:
 3 |   push:
 4 |     tags:
 5 |       - test
 6 |       - "v[0-9]+.[0-9]+.[0-9]+"
 7 | 
 8 | jobs:
 9 |   release-linux-x86_64-binaries:
10 |     runs-on: ubuntu-latest
11 |     steps:
12 |       - name: Checkout source code
13 |         uses: actions/checkout@v2
14 |       - name: Configure build cache
15 |         uses: actions/cache@v4
16 |         with:
17 |           path: |
18 |             ~/.cargo/registry
19 |             ~/.cargo/git
20 |             target
21 |           key: cargo-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}
22 |       - name: Build the binaries
23 |         uses: addnab/docker-run-action@v3
24 |         with:
25 |             image: registry.gitlab.com/rust_musl_docker/image:stable-latest
26 |             options: -v ${{ github.workspace }}:/workdir -v /home/runner/.cargo/git:/root/.cargo/git -v /home/runner/.cargo/registry:/root/.cargo/registry
27 |             run: |
28 |               rustup target add x86_64-unknown-linux-musl
29 |               cargo build --release --target=x86_64-unknown-linux-musl
30 |               cp target/x86_64-unknown-linux-musl/release/complgen complgen-x86_64-unknown-linux-musl
31 |       - uses: softprops/action-gh-release@v1
32 |         with:
33 |           fail_on_unmatched_files: true
34 |           files: |
35 |             complgen-x86_64-unknown-linux-musl
36 | 
37 | 
38 |   release-linux-arm-binaries:
39 |     runs-on: ubuntu-latest
40 |     steps:
41 |       - name: Checkout source code
42 |         uses: actions/checkout@v2
43 |       - name: Configure build cache
44 |         uses: actions/cache@v4
45 |         with:
46 |           path: |
47 |             ~/.cargo/registry
48 |             ~/.cargo/git
49 |             target
50 |           key: cargo-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}
51 |       - name: Build the binaries
52 |         uses: addnab/docker-run-action@v3
53 |         with:
54 |             image: messense/rust-musl-cross:aarch64-musl
55 |             options: -v ${{ github.workspace }}:/home/rust/src -v /home/runner/.cargo/git:/root/.cargo/git -v /home/runner/.cargo/registry:/root/.cargo/registry
56 |             run: |
57 |               rustup target add aarch64-unknown-linux-musl
58 |               cargo build --release
59 |               cp target/aarch64-unknown-linux-musl/release/complgen complgen-aarch64-unknown-linux-musl
60 |       - uses: softprops/action-gh-release@v1
61 |         with:
62 |           fail_on_unmatched_files: true
63 |           files: |
64 |             complgen-aarch64-unknown-linux-musl
65 | 
66 | 
67 |   release-macos-binaries:
68 |     runs-on: macos-latest
69 |     steps:
70 |       - uses: actions/checkout@v2
71 |       - name: Configure build cache
72 |         uses: actions/cache@v4
73 |         with:
74 |           path: |
75 |             ~/.cargo/registry
76 |             ~/.cargo/git
77 |             target
78 |           key: cargo-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}
79 |       - uses: actions-rs/toolchain@v1
80 |         with:
81 |           toolchain: stable
82 |           profile: minimal
83 |           target: aarch64-apple-darwin
84 |       - name: Build the release binaries
85 |         run: |
86 |           cargo build --release --target aarch64-apple-darwin
87 |           cp target/aarch64-apple-darwin/release/complgen complgen-aarch64-apple-darwin
88 |       - uses: softprops/action-gh-release@v1
89 |         with:
90 |           fail_on_unmatched_files: true
91 |           files: |
92 |             complgen-aarch64-apple-darwin
93 | 


--------------------------------------------------------------------------------
/e2e/capture_preamble.zsh:
--------------------------------------------------------------------------------
  1 | #!/bin/zsh
  2 | 
  3 | zmodload zsh/zpty || { echo 'error: missing module zsh/zpty' >&2; exit 1 }
  4 | 
  5 | # spawn shell
  6 | zpty z zsh -f -i
  7 | 
  8 | # line buffer for pty output
  9 | local line
 10 | 
 11 | setopt rcquotes
 12 | () {
 13 |     zpty -w z source $1
 14 |     repeat 4; do
 15 |         zpty -r z line
 16 |         [[ $line == ok* ]] && return
 17 |     done
 18 |     echo 'error initializing.' >&2
 19 |     exit 2
 20 | } =( <<< '
 21 | # no prompt!
 22 | PROMPT=
 23 | 
 24 | # load completion system
 25 | autoload compinit
 26 | compinit -d ~/.zcompdump_capture
 27 | 
 28 | # never run a command
 29 | bindkey ''^M'' undefined
 30 | bindkey ''^J'' undefined
 31 | bindkey ''^I'' complete-word
 32 | 
 33 | # send a line with null-byte at the end before and after completions are output
 34 | null-line () {
 35 |     echo -E - $''\0''
 36 | }
 37 | compprefuncs=( null-line )
 38 | comppostfuncs=( null-line exit )
 39 | 
 40 | # never group stuff!
 41 | zstyle '':completion:*'' list-grouped false
 42 | # don''t insert tab when attempting completion on empty line
 43 | zstyle '':completion:*'' insert-tab false
 44 | # no list separator, this saves some stripping later on
 45 | zstyle '':completion:*'' list-separator ''''
 46 | 
 47 | # we use zparseopts
 48 | zmodload zsh/zutil
 49 | 
 50 | # override compadd (this our hook)
 51 | compadd () {
 52 | 
 53 |     # check if any of -O, -A or -D are given
 54 |     if [[ ${@[1,(i)(-|--)]} == *-(O|A|D)\ * ]]; then
 55 |         # if that is the case, just delegate and leave
 56 |         builtin compadd "$@"
 57 |         return $?
 58 |     fi
 59 | 
 60 |     # ok, this concerns us!
 61 |     # echo -E - got this: "$@"
 62 | 
 63 |     # be careful with namespacing here, we don''t want to mess with stuff that
 64 |     # should be passed to compadd!
 65 |     typeset -a __hits __dscr __tmp
 66 | 
 67 |     # do we have a description parameter?
 68 |     # note we don''t use zparseopts here because of combined option parameters
 69 |     # with arguments like -default- confuse it.
 70 |     if (( $@[(I)-d] )); then # kind of a hack, $+@[(r)-d] doesn''t work because of line noise overload
 71 |         # next param after -d
 72 |         __tmp=${@[$[${@[(i)-d]}+1]]}
 73 |         # description can be given as an array parameter name, or inline () array
 74 |         if [[ $__tmp == \(* ]]; then
 75 |             eval "__dscr=$__tmp"
 76 |         else
 77 |             __dscr=( "${(@P)__tmp}" )
 78 |         fi
 79 |     fi
 80 | 
 81 |     # capture completions by injecting -A parameter into the compadd call.
 82 |     # this takes care of matching for us.
 83 |     builtin compadd -A __hits -D __dscr "$@"
 84 | 
 85 |     # JESUS CHRIST IT TOOK ME FOREVER TO FIGURE OUT THIS OPTION WAS SET AND WAS MESSING WITH MY SHIT HERE
 86 |     setopt localoptions norcexpandparam extendedglob
 87 | 
 88 |     # extract prefixes and suffixes from compadd call. we can''t do zsh''s cool
 89 |     # -r remove-func magic, but it''s better than nothing.
 90 |     typeset -A apre hpre hsuf asuf
 91 |     zparseopts -E P:=apre p:=hpre S:=asuf s:=hsuf
 92 | 
 93 |     # append / to directories? we are only emulating -f in a half-assed way
 94 |     # here, but it''s better than nothing.
 95 |     integer dirsuf=0
 96 |     # don''t be fooled by -default- >.>
 97 |     if [[ -z $hsuf && "${${@//-default-/}% -# *}" == *-[[:alnum:]]#f* ]]; then
 98 |         dirsuf=1
 99 |     fi
100 | 
101 |     # just drop
102 |     [[ -n $__hits ]] || return
103 | 
104 |     # this is the point where we have all matches in $__hits and all
105 |     # descriptions in $__dscr!
106 | 
107 |     # display all matches
108 |     local dsuf
109 |     for i in {1..$#__hits}; do
110 | 
111 |         # add a dir suffix?
112 |         (( dirsuf )) && [[ -d $__hits[$i] ]] && dsuf=/ || dsuf=
113 |         # description to be displayed afterwards
114 |         local compl="$IPREFIX$apre$hpre$__hits[$i]$dsuf$hsuf$asuf"
115 |         if (( $#__dscr >= $i )); then
116 |             echo -E - "$compl ${__dscr[$i]}"
117 |         else
118 |             echo -E - $compl
119 |         fi
120 | 
121 |     done
122 | 
123 | }
124 | 
125 | 


--------------------------------------------------------------------------------
/e2e/test_zsh_pty.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import re
  3 | import sys
  4 | import pty
  5 | import termios
  6 | import tempfile
  7 | import platform
  8 | import subprocess
  9 | from pathlib import Path
 10 | 
 11 | import pytest
 12 | 
 13 | from conftest import set_working_dir
 14 | 
 15 | 
 16 | def get_autoloaded_completion_output(complgen_binary_path: Path, grammar: str, cmd: str, input: bytes, working_dir: Path | None = None) -> list[str]:
 17 |     completion_script = subprocess.run([complgen_binary_path, '--zsh', '-', '-'], input=grammar.encode(), stdout=subprocess.PIPE, stderr=sys.stderr, check=True).stdout.decode()
 18 |     (pid, fd) = pty.fork()
 19 |     if pid == 0:
 20 |         # We're in the child
 21 |         def body(dir):
 22 |             (Path(dir) / 'autoload').mkdir()
 23 |             (Path(dir) / 'autoload' / '_{}'.format(cmd)).write_text(completion_script)
 24 |             Path('.zshrc').write_text('PS1=""; setopt complete_in_word; fpath=($ZDOTDIR/autoload $fpath)')
 25 |             os.execvpe('zsh', ['--noglobalrcs', '--interactive'], {'ZDOTDIR': dir, 'COLUMNS': '1000'})
 26 | 
 27 |         if working_dir is None:
 28 |             with tempfile.TemporaryDirectory() as dir:
 29 |                 with set_working_dir(Path(dir)):
 30 |                     body(dir)
 31 |         else:
 32 |             body(working_dir)
 33 |         return [] # dummy to silence type checker
 34 |     else:
 35 |         try:
 36 |             # We're in the parent
 37 |             attrs = termios.tcgetattr(fd)
 38 |             attrs[3] &= ~termios.ECHO
 39 |             termios.tcsetattr(fd, termios.TCSANOW, attrs)
 40 |             pty_write = os.fdopen(fd, mode='ab')
 41 |             pty_read = os.fdopen(os.dup(fd), mode='rb')
 42 |             pty_write.write('autoload compinit; compinit\n'.encode())
 43 |             pty_write.flush()
 44 |             pty_write.write(input)
 45 |             pty_write.flush()
 46 |             pty_write.write('\n'.encode())
 47 |             pty_write.write(b'')
 48 |             pty_write.flush()
 49 |             output = pty_read.read()
 50 |             bracketed_pastes = re.findall(rb'\x1b\[\?2004h(.*?)\x1b\[\?2004l', output, re.DOTALL)
 51 |             bracketed_pastes = [bp for bp in bracketed_pastes if bp != b'']
 52 |             bracketed_pastes = [bp.decode() for bp in bracketed_pastes]
 53 |             bracketed_pastes = [bp for bp in bracketed_pastes if bp != 'autoload compinit; compinit']
 54 |         finally:
 55 |             os.waitpid(pid, 0)
 56 |         return bracketed_pastes
 57 | 
 58 | 
 59 | 
 60 | @pytest.mark.skipif(platform.system() != 'Darwin', reason='Not running on macOS')
 61 | def test_completes_in_word(complgen_binary_path: Path):
 62 |     GRAMMAR = '''
 63 | cmd prefix-infix-good;
 64 | cmd prefix-infix-bad;
 65 | '''
 66 |     LEFT_ARROW = '\x1b[D'
 67 |     TAB = '	'
 68 |     bracketed_pastes = get_autoloaded_completion_output(complgen_binary_path, GRAMMAR, 'cmd', 'cmd prefix--good{}{}'.format(LEFT_ARROW * 5, TAB).encode())
 69 |     assert bracketed_pastes == ['cmd prefix--goodinfix-good  ']
 70 | 
 71 | 
 72 | @pytest.mark.skipif(platform.system() != 'Darwin', reason='Not running on macOS')
 73 | def test_tcsh_directory_completion(complgen_binary_path: Path):
 74 |     GRAMMAR = '''cmd <DIRECTORY>;'''
 75 |     with tempfile.TemporaryDirectory() as dir:
 76 |         working_dir = Path(dir)
 77 |         with set_working_dir(working_dir):
 78 |             Path('foo/bar/baz').mkdir(parents=True)
 79 |             bracketed_pastes = get_autoloaded_completion_output(complgen_binary_path, GRAMMAR, 'cmd', b'cmd f/b/b	', working_dir=working_dir)
 80 |             assert bracketed_pastes == ['cmd f/b/boo/bar/baz/ ']
 81 | 
 82 | 
 83 | @pytest.mark.skipif(platform.system() != 'Darwin', reason='Not running on macOS')
 84 | def test_autoload(complgen_binary_path: Path):
 85 |     GRAMMAR = '''hello world;'''
 86 |     with tempfile.TemporaryDirectory() as dir:
 87 |         working_dir = Path(dir)
 88 |         with set_working_dir(working_dir):
 89 |             bracketed_pastes = get_autoloaded_completion_output(complgen_binary_path, GRAMMAR, 'hello', b'hello 	', working_dir=working_dir)
 90 |             assert bracketed_pastes == ['hello world  ']
 91 | 
 92 | 
 93 | @pytest.mark.skipif(platform.system() != 'Darwin', reason='Not running on macOS')
 94 | def test_subword_specialization(complgen_binary_path: Path):
 95 |     GRAMMAR = r"""
 96 | cmd --option=<FOO>;
 97 | <FOO> ::= {{{ echo generic }}};
 98 | <FOO@zsh> ::= {{{ compadd -U -- ${1}zsh }}};
 99 | """
100 |     bracketed_pastes = get_autoloaded_completion_output(complgen_binary_path, GRAMMAR, 'cmd', b'cmd --option=	')
101 |     assert bracketed_pastes == ['cmd --option=zsh  ']
102 | 


--------------------------------------------------------------------------------
/e2e/conftest.py:
--------------------------------------------------------------------------------
  1 | import contextlib
  2 | import os
  3 | import subprocess
  4 | import sys
  5 | import tempfile
  6 | from pathlib import Path
  7 | from typing import Generator
  8 | 
  9 | import pytest
 10 | 
 11 | 
 12 | @pytest.fixture(scope="session")
 13 | def cargo_manifest_path() -> Path:
 14 |     this_file = Path(__file__)
 15 |     return this_file.parent.parent / "Cargo.toml"
 16 | 
 17 | 
 18 | @pytest.fixture(scope="session")
 19 | def examples_directory_path() -> Path:
 20 |     this_file = Path(__file__)
 21 |     return this_file.parent.parent / "examples"
 22 | 
 23 | 
 24 | @pytest.fixture(scope="session")
 25 | def complgen_binary_path(cargo_manifest_path: Path) -> Path:
 26 |     subprocess.run(
 27 |         ["cargo", "build", "--manifest-path", cargo_manifest_path, "--release"],
 28 |         cwd="..",
 29 |         stdout=sys.stdout,
 30 |         stderr=sys.stderr,
 31 |         check=True,
 32 |     )
 33 |     binary_path = cargo_manifest_path.parent / "target/release/complgen"
 34 |     assert binary_path.exists()
 35 |     return binary_path
 36 | 
 37 | 
 38 | @contextlib.contextmanager
 39 | def set_working_dir(path: Path):
 40 |     origin = Path().absolute()
 41 |     try:
 42 |         os.chdir(path)
 43 |         yield
 44 |     finally:
 45 |         os.chdir(origin)
 46 | 
 47 | 
 48 | @contextlib.contextmanager
 49 | def temp_file_with_contents(contents: str) -> Generator[Path, None, None]:
 50 |     with tempfile.NamedTemporaryFile() as f:
 51 |         f.write(contents.encode())
 52 |         f.flush()
 53 |         yield Path(f.name)
 54 | 
 55 | 
 56 | def get_sorted_bash_completions(completions_file_path: Path, input: str) -> list[str]:
 57 |     bash_process = subprocess.run(
 58 |         ["bash", "--noprofile", "--rcfile", completions_file_path, "-i"],
 59 |         input=input.encode(),
 60 |         stdout=subprocess.PIPE,
 61 |         stderr=sys.stderr,
 62 |         check=True,
 63 |     )
 64 |     lines = bash_process.stdout.decode().splitlines()
 65 |     lines.sort()
 66 |     return lines
 67 | 
 68 | 
 69 | def fish_completions_from_stdout(stdout: str) -> list[tuple[str, str]]:
 70 |     result = []
 71 |     for line in stdout.splitlines():
 72 |         fields = line.split("\t", maxsplit=2)
 73 |         if len(fields) == 1:
 74 |             result.append((fields[0], ""))
 75 |         else:
 76 |             result.append((fields[0], fields[1]))
 77 |     return result
 78 | 
 79 | 
 80 | def get_sorted_fish_completions(
 81 |     completions_script_path: Path, input: str
 82 | ) -> list[tuple[str, str]]:
 83 |     completed_process = subprocess.run(
 84 |         [
 85 |             "fish",
 86 |             "--private",
 87 |             "--no-config",
 88 |             "--init-command",
 89 |             "source {}".format(completions_script_path),
 90 |             "--command",
 91 |             input,
 92 |         ],
 93 |         stdout=subprocess.PIPE,
 94 |         stderr=sys.stderr,
 95 |         check=True,
 96 |     )
 97 |     completions = completed_process.stdout.decode()
 98 |     parsed = fish_completions_from_stdout(completions)
 99 |     parsed.sort(key=lambda pair: pair[0])
100 |     return parsed
101 | 
102 | 
103 | @contextlib.contextmanager
104 | def gen_fish_aot_completion_script_path(
105 |     complgen_binary_path: Path, grammar: str
106 | ) -> Generator[Path, None, None]:
107 |     fish_script = subprocess.run(
108 |         [complgen_binary_path, "--fish", "-", "-"],
109 |         input=grammar.encode(),
110 |         stdout=subprocess.PIPE,
111 |         stderr=sys.stderr,
112 |         check=True,
113 |     ).stdout
114 |     with tempfile.NamedTemporaryFile() as f:
115 |         f.write(fish_script)
116 |         f.flush()
117 |         yield Path(f.name)
118 | 
119 | 
120 | @contextlib.contextmanager
121 | def gen_zsh_capture_script_path(completion_script: str) -> Generator[Path, None, None]:
122 |     this_file = Path(__file__)
123 |     capture_preamble_path = this_file.parent / "capture_preamble.zsh"
124 |     capture_postamble_path = this_file.parent / "capture_postamble.zsh"
125 |     with tempfile.NamedTemporaryFile(mode="w") as f:
126 |         f.write(capture_preamble_path.read_text())
127 |         f.write("\n")
128 |         f.write(completion_script.replace("'", "''"))
129 |         f.write("\n")
130 |         f.write(capture_postamble_path.read_text())
131 |         f.flush()
132 |         yield Path(f.name)
133 | 
134 | 
135 | @contextlib.contextmanager
136 | def gen_grammar_zsh_capture_script_path(
137 |     complgen_binary_path: Path, grammar: str
138 | ) -> Generator[Path, None, None]:
139 |     completion_script = subprocess.run(
140 |         [complgen_binary_path, "--zsh", "-", "-"],
141 |         input=grammar,
142 |         stdout=subprocess.PIPE,
143 |         stderr=sys.stderr,
144 |         check=True,
145 |         text=True,
146 |     ).stdout
147 |     with gen_zsh_capture_script_path(completion_script) as path:
148 |         yield path
149 | 
150 | 
151 | def get_zsh_capture_script_sorted_lines(
152 |     generated_script_path: Path, input: str
153 | ) -> list[str]:
154 |     zsh_process = subprocess.run(
155 |         ["zsh", generated_script_path, input],
156 |         stdout=subprocess.PIPE,
157 |         stderr=sys.stderr,
158 |         check=True,
159 |     )
160 |     stdout = zsh_process.stdout.decode()
161 |     completions = stdout.splitlines()
162 |     completions.sort()
163 |     return completions
164 | 
165 | 
166 | def get_bash_completion_sh_path() -> str:
167 |     if os.path.exists("/opt/homebrew/etc/profile.d/bash_completion.sh"):
168 |         return "/opt/homebrew/etc/profile.d/bash_completion.sh"
169 |     elif os.path.exists("/etc/bash_completion"):
170 |         return "/etc/bash_completion"
171 |     elif os.path.exists("/usr/share/bash-completion/bash_completion"):
172 |         return "/usr/share/bash-completion/bash_completion"
173 |     else:
174 |         assert False, "Make sure OS package bash-completion is installed"
175 | 


--------------------------------------------------------------------------------
/examples/mygrep.usage:
--------------------------------------------------------------------------------
 1 | mygrep [<OPTION>]... [--] <PATTERNS> [<PATH>]...;
 2 | 
 3 | <OPTION> ::= (--extended-regexp || -E)                                                      "PATTERNS are extended regular expressions"
 4 |            | (--fixed-strings || -F)                                                        "PATTERNS are strings"
 5 |            | (--basic-regexp || -G)                                                         "PATTERNS are basic regular expressions"
 6 |            | (--perl-regexp || -P)                                                          "PATTERNS are Perl regular expressions"
 7 |            | (--regexp=<PATTERNS> || -e <PATTERNS>)                                         "use PATTERNS for matching"
 8 |            | (--file=<PATH> || -f <PATH>)                                                   "take PATTERNS from FILE"
 9 |            | (--ignore-case || -i)                                                          "ignore case distinctions in patterns and data"
10 |            | --no-ignore-case                                                               "do not ignore case distinctions (default)"
11 |            | (--word-regexp || -w)                                                          "match only whole words"
12 |            | (--line-regexp || -x)                                                          "match only whole lines"
13 |            | (--null-data || -z)                                                            "a data line ends in 0 byte, not newline"
14 |            | (--no-messages || -s)                                                          "suppress error messages"
15 |            | (--invert-match || -v)                                                         "select non-matching lines"
16 |            | (--version || -V)                                                              "display version information and exit"
17 |            | --help                                                                         "display this help text and exit"
18 |            | (--max-count=<NUM> || --max-count <NUM> | -m <NUM>)                            "stop after NUM selected lines"
19 |            | (--byte-offset || -b)                                                          "print the byte offset with output lines"
20 |            | (--line-number || -n)                                                          "print line number with output lines"
21 |            | --line-buffered                                                                "flush output on every line"
22 |            | (--with-filename || -H)                                                        "print file name with output lines"
23 |            | (--no-filename || -h)                                                          "suppress the file name prefix on output"
24 |            | (--label=<LABEL>)                                                              "use LABEL as the standard input file name prefix"
25 |            | (--only-matching || -o)                                                        "show only nonempty parts of lines that match"
26 |            | (--quiet | --silent || -q)                                                     "suppress all normal output"
27 |            | (--binary-files=<TYPE>)                                                        "assume that binary files are <TYPE>"
28 |            | (--text || -a)                                                                 "equivalent to --binary-files=text"
29 |            | (--directories=<ACTION-DIRECTORIES> || -d <ACTION-DIRECTORIES>)                "how to handle directories"
30 |            | (--devices=<ACTION-DEVICES> || -D <ACTION-DEVICES>)                            "how to handle devices, FIFOs and sockets"
31 |            | (--recursive || -r)                                                            "like --directories=recurse"
32 |            | (--dereference-recursive || -R)                                                "like --directories=recurse, but follow all symlinks"
33 |            | (--include=<GLOB>)                                                             "search only files that match GLOB (a file pattern)"
34 |            | (--exclude=<GLOB>)                                                             "skip files that match GLOB"
35 |            | (--exclude-from=<PATH>)                                                        "skip files that match any file pattern from FILE"
36 |            | (--exclude-dir=<GLOB>)                                                         "skip directories that match GLOB"
37 |            | (--files-without-match || -L)                                                  "print only names of FILEs with no selected lines"
38 |            | (--files-with-matches || -l)                                                   "print only names of FILEs with selected lines"
39 |            | (--count || -c)                                                                "print only a count of selected lines per FILE"
40 |            | (--initial-tab || -T)                                                          "make tabs line up (if needed)"
41 |            | (--null || -Z)                                                                 "print 0 byte after FILE name"
42 |            | (--before-context=<NUM> || -B <NUM>)                                           "print NUM lines of leading context"
43 |            | (--after-context=<NUM> || -A <NUM>)                                            "print NUM lines of trailing context"
44 |            | (--context=<NUM> || -C <NUM> | -<NUM>)                                         "print NUM lines of output context"
45 |            | --group-separator=<SEP>                                                        "print SEP on line between matches with context"
46 |            | --no-group-separator                                                           "do not print separator for matches with context"
47 |            | (--color=[<WHEN>] || --color [<WHEN>] | --colour=[<WHEN>] | --colour [<WHEN>]) "use markers to highlight the matching strings"
48 |            | (--binary || -U)                                                               "do not strip CR characters at EOL (MSDOS/Windows)"
49 |            ;
50 | 
51 | <ACTION-DIRECTORIES> ::= read       "read directories in the same manner as normal files"
52 |                        | recurse    "read directories recursively (same effect as -R and -r option)"
53 |                        | skip       "silently ignore the directories";
54 | 
55 | <ACTION-DEVICES> ::= read "read devices as if they were normal files"
56 |                    | skip "devices are skipped silently";
57 | 
58 | <TYPE> ::= binary           "Search binary files but do not print them"
59 |          | text             "Treat all files as text"
60 |          | without-match    "Do not search binary files";
61 | 
62 | <WHEN> ::= always | never | auto "only when stdout is a tty";
63 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | All notable changes to this project will be documented in this file.
  4 | 
  5 | The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
  6 | and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
  7 | 
  8 | ## Unreleased
  9 | ## 0.6.0
 10 | ### Fixed
 11 | 
 12 |  - ZSH specialized commands should now use `compadd` instead of writing on stdout
 13 | 
 14 | ### Changed
 15 | 
 16 |  - Error message location are now 1-based to make them easier to use in a text editor
 17 | 
 18 | ### Added
 19 | 
 20 |  - Specialization command now also support regexes
 21 |  - Added `--regex` option for writing generated regular expression into a .dot file for debugging
 22 |  - More precise ambiguity detector: Detect clashing subword leaders
 23 | 
 24 | ### Removed
 25 | 
 26 |  - Removed `--railroad` option for diagrams generation due to limited utility
 27 | 
 28 | ## 0.5.0
 29 | ### Changed
 30 | 
 31 |  - Ambiguity detection now works on an earlier compilation phase for better error messages
 32 | 
 33 | ## 0.4.0
 34 | ### Changed
 35 | 
 36 |  - Breaking: Simplified CLI interface (there's no subcommands anymore; aot is now implicit)
 37 | 
 38 | ### Removed
 39 | 
 40 |  - Breaking: JIT mode has been removed (its functioning changed over time, rendering it largely redundant)
 41 | 
 42 | ### Added
 43 | 
 44 |  - Nontail-position commands
 45 |  - Descriptions under fish and zsh are now deduplicated
 46 | 
 47 | ### Fixed
 48 | 
 49 |  - Breaking: Tail commands detection is more precise now, resulting in more rejected grammars (that would have previously been silently ambiguous)
 50 |  - Breaking: Two adjacent literals used in subword context are now rejected as an error as this may lead to surprising behavior (https://github.com/adaszko/complgen/issues/63)
 51 |  - Bash: Bug in `prefix{{{ shell command }}}` case
 52 | 
 53 | ## 0.3.0
 54 | ### Added
 55 | 
 56 |  - Fish,AOT: Implemented fallbacks
 57 |  - Fish,JIT: Implemented fallbacks
 58 | 
 59 | ### Fixed
 60 | 
 61 |  - Fish,JIT: Descriptions were wrongly being made part of the completion
 62 |  - Bash: Respect `completion-ignore-case` readline setting
 63 | 
 64 | ## 0.2.0
 65 | ### Changed
 66 | 
 67 |  - **Breaking**: `{{{ ... }}}` commands and many predefined nonterminals (e.g. `<PATH>`, etc) are now allowed
 68 |    in fewer places to keep grammars unambiguous.  It statically safeguards against some bugs in completion
 69 |    scripts.
 70 |  - **Breaking**: Releases aren't published via Homebrew anymore -- use `cargo install`.
 71 |  - **Breaking**: JIT completion now emits shell scripts (as opposed to plain strings) in all shells.  Integration scripts need to be adjusted accordingly.  Details in README.md.
 72 | 
 73 | ### Fixed
 74 | 
 75 |  - Autoloading of ZSH completion scripts works now (#38)
 76 | 
 77 | ### Added
 78 | 
 79 |  - Fallback completions.  It's not implemented across the board yet.  See README for details.
 80 | 
 81 | ## 0.1.8
 82 | ### Changed
 83 | 
 84 |  - **Breaking**: `complgen complete` has been renamed to `complgen jit` to better reflect it's for just-in-time completion
 85 |  - **Breaking**: `complgen compile` has been renamed to `complgen aot` to better reflect it's for ahead-of-time completion script generation
 86 | 
 87 | ### Fixed
 88 | 
 89 |  - Bash,AOT: Completion trailing spaces are now added precisely (#35)
 90 |  - Bash,JIT: Completion trailing spaces are now added precisely (#35)
 91 |  - Zsh,JIT: Completion trailing spaces are now added precisely (#35)
 92 |  - Bash,AOT: Further improve $COMP_WORDBREAKS characters handling
 93 |  - Bash,JIT: Further improve $COMP_WORDBREAKS characters handling
 94 | 
 95 | ## 0.1.7
 96 | ### Fixed
 97 | 
 98 |  - Bash,JIT: Shell integration should now handle $COMP_WORDBREAKS characters correctly
 99 |  - Bash,JIT: Fixed Bash shell integration
100 | 
101 | ## 0.1.6
102 | ### Fixed
103 | 
104 | - ZSH,JIT: Completing in the middle of a word (with `complete_in_word` option set) works now
105 | - ZSH,JIT: Completing paths tcsh style (f/b/b<TAB> -> foo/bar/baz) works now
106 | 
107 | ### Changed
108 | 
109 |  - Breaking: `complgen complete` CLI interface has changed. Shell integration configuration needs to be updated.  See README.
110 | 
111 | ## 0.1.5
112 | 
113 | ### Fixed
114 | 
115 | - JIT completion bug: Grammar `cmd +{{{ echo foo }}}<TAB>` was being completed ad infinitum.
116 | 
117 | ## 0.1.4
118 | 
119 | ### Added
120 | 
121 | - In zsh, for the grammar `--color=(always|never)` and input `--color=<TAB>`, you will now see `always` and
122 |   `never`, not `--color=always` and `--color=never`.   This generalized to all subword completions of course.
123 | - Descriptions can now contain escaped characters, e.g. a quote character or a backslash.
124 | - More readable parsing errors using the chic Rust crate
125 | - Scraper is now based on a bunch of regexes instead of a complicated parser.  This simplifies the code a lot.
126 | 
127 | ### Changed
128 | 
129 | - If multiple literals have the same decription, they're now grouped into a single line (this can be
130 |   controlled with `zstyle ':completion:*' list-grouped true/false`)
131 | 
132 | ### Removed
133 | 
134 | - Single brackets external commands as they're superfluous (replaced with triple brackets ones)
135 | 
136 | ## 0.1.3
137 | ### Fixed
138 | 
139 | - More compact zsh completions in JIT mode
140 | - Zsh,JIT: Only consider completions with descriptions when aligning completions for better appearance
141 | - Remove leftover parenthesis in ZSH subword descriptions
142 | 
143 | ## 0.1.2
144 | ### Fixed
145 | 
146 | - A bug in Bash output where order of arguments to `mapfile` was wrong
147 | 
148 | ## 0.1.1
149 | ### Added
150 | 
151 | - Binary releases on GitHub
152 | 
153 | ### Fixed
154 | 
155 | - Bug in parser where descriptions were being distributed too generously.
156 | 
157 | ## 0.1.0
158 | ### Added
159 | 
160 | - Add a Homebrew tap formula for automatic updates on new versions.
161 | 
162 | - "Distributive" descriptions: you can now use a shorthand descriptions:
163 |   `mygrep (--color=<WHEN> | --color <WHEN>) "use markers to highlight the matching strings"`
164 |   and the "use marker..." description is going to apply to both `--color=` and `--color ...` so you don't need to repeat it.
165 | 
166 | - Improve performance when running on `darcs.usage` example by 4x :O
167 | - Only the completed part appears in ZSH description now instead of the entire shell word (less noise, more like native ZSH)
168 | - Zsh descriptions now look like the ones produced by _arguments for consistency
169 | - Only emit subword processing shell script code if it's actually used in the grammar to conserve space
170 | - Write ZSH completion each on separate lines if any contains a description to better mimic what _arguments does
171 | - New CLI subcommand: `complgen check` that checks the passed grammar and doesn't write annything to disk.
172 | 
173 | ### Fixed
174 | 
175 | - In Bash integration script, `grep --color=<TAB>` didn't complete anything.
176 | 
177 | - Bug in JIT mode: Completing subdirectory files wasn't working due to the entered prefix not being passed
178 |   properly.
179 | 
180 | - Output proper completion prefix in subword completion in shell integration (JIT mode).  Even though
181 |   completions were produced by complgen, shells were filtering them out due to lack of a proper prefix.
182 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
  1 | This document is intended to lower the bar for contributing to `complgen`.
  2 | 
  3 | # How it works
  4 | 
  5 | `complgen` is architected somewhat like a compiler: it has several transformation stages and data flows only
  6 | in one direction like in a pipeline.
  7 | 
  8 | The stages are as follows:
  9 | 
 10 | 1. Parse a `.usage` file into a Rust data structure
 11 | 1. Convert the data structure into a regular expression (in the textbook sense, not in the programmar sense)
 12 | 1. Convert the regular expression into a Deterministic Finite Automaton (DFA)
 13 |     * For details, see [Compilers Principles, Techniques and
 14 |       Tools](https://en.wikipedia.org/wiki/Compilers:_Principles,_Techniques,_and_Tools) (aka The Dragon
 15 |       Book), 2nd edition, section 3.9.5, "Converting a Regular Expression Directly to a DFA"
 16 | 1. Minimize the DFA
 17 |     * For details, see [Engineering a Compiler](https://www.amazon.com/Engineering-Compiler-Keith-D-Cooper/dp/0128154128), 3rd edition, section "2.4.4 DFA to Minimal DFA"
 18 |     * And also section 3.9.6, "Minimizing the Number of States of a DFA" from The Dragon Book.
 19 | 1. Emit a shell completion script
 20 |     * Bash: [Creating a bash completion script](https://iridakos.com/programming/2018/03/01/bash-programmable-completion-tutorial)
 21 |     * Fish: [Writing your own completions — fish-shell documentation](https://fishshell.com/docs/current/completions.html)
 22 |     * ZSH (zsh's completion system can be somewhat arcane in places):
 23 |         * [zsh-completions/zsh-completions-howto.org](https://github.com/zsh-users/zsh-completions/blob/master/zsh-completions-howto.org)
 24 |         * [ZSH – Writing own completion functions](https://askql.wordpress.com/2011/01/11/zsh-writing-own-completion/)
 25 |         * [Dynamic zsh autocomplete for custom commands](https://unix.stackexchange.com/questions/239528/dynamic-zsh-autocomplete-for-custom-commands/240192#240192)
 26 |         * [Writing zsh completion scripts](https://blog.mads-hartmann.com/2017/08/06/writing-zsh-completion-scripts.html)
 27 |         * [Current Word Completion](https://jonathanh.co.uk/blog/current-word-completion/)
 28 | 
 29 | `complgen` is based on [compleat](https://github.com/mbrubeck/compleat), so it may also be useful sometimes to
 30 | reference it.
 31 | 
 32 | # Visualizations
 33 | 
 34 | To ease understanding and debugging, some of the stages can generate visualizations (see output of `complgen
 35 | --help` for the relevant option name).
 36 | 
 37 | For the following grammar:
 38 | 
 39 | ```
 40 | grep [<OPTION>]... <PATTERNS> [<FILE>]...;
 41 | 
 42 | <OPTION> ::= --extended-regexp                      "PATTERNS are extended regular expressions"
 43 |            | --fixed-strings                        "PATTERNS are strings"
 44 |            | --basic-regexp                         "PATTERNS are basic regular expressions"
 45 |            | --perl-regexp                          "PATTERNS are Perl regular expressions"
 46 |            | --regexp                               "use PATTERNS for matching" <PATTERNS>
 47 |            | --file                                 "take PATTERNS from FILE" <FILE>
 48 |            | --ignore-case                          "ignore case distinctions in patterns and data"
 49 |            | --no-ignore-case                       "do not ignore case distinctions (default)"
 50 |            | --word-regexp                          "match only whole words"
 51 |            | --line-regexp                          "match only whole lines"
 52 |            | --null-data                            "a data line ends in 0 byte, not newline"
 53 |            | --no-messages                          "suppress error messages"
 54 |            | --invert-match                         "select non-matching lines"
 55 |            | --version                              "display version information and exit"
 56 |            | --help                                 "display this help text and exit"
 57 |            | --max-count                            "stop after NUM selected lines" <NUM>
 58 |            | --byte-offset                          "print the byte offset with output lines"
 59 |            | --line-number                          "print line number with output lines"
 60 |            | --line-buffered                        "flush output on every line"
 61 |            | --with-filename                        "print file name with output lines"
 62 |            | --no-filename                          "suppress the file name prefix on output"
 63 |            | --label                                "use LABEL as the standard input file name prefix" <LABEL>
 64 |            | --only-matching                        "show only nonempty parts of lines that match"
 65 |            | --quiet                                "suppress all normal output"
 66 |            | --silent                               "suppress all normal output"
 67 |            | --binary-files                         "assume that binary files are TYPE; TYPE is 'binary', 'text', or 'without-match'" <TYPE>
 68 |            | --text                                 "equivalent to --binary-files=text"
 69 |            | --directories                          "how to handle directories;" <ACTION-DIRECTORIES>
 70 |            | --devices                              "how to handle devices, FIFOs and sockets;" <ACTION-DEVICES>
 71 |            | --recursive                            "like --directories=recurse"
 72 |            | --dereference-recursive                "likewise, but follow all symlinks"
 73 |            | --include                              "search only files that match GLOB (a file pattern)" <GLOB>
 74 |            | --exclude                              "skip files that match GLOB" <GLOB>
 75 |            | --exclude-from                         "skip files that match any file pattern from FILE" <FILE>
 76 |            | --exclude-dir                          "skip directories that match GLOB" <GLOB>
 77 |            | --files-without-match                  "print only names of FILEs with no selected lines"
 78 |            | --files-with-matches                   "print only names of FILEs with selected lines"
 79 |            | --count                                "print only a count of selected lines per FILE"
 80 |            | --initial-tab                          "make tabs line up (if needed)"
 81 |            | --null                                 "print 0 byte after FILE name"
 82 |            | --before-context                       "print NUM lines of leading context" <NUM>
 83 |            | --after-context                        "print NUM lines of trailing context" <NUM>
 84 |            | --context NUM                          "print NUM lines of output context" <NUM>
 85 |            | --group-separator                      "print SEP on line between matches with context" <SEP>
 86 |            | --no-group-separator                   "do not print separator for matches with context"
 87 |            | --color                                "use markers to highlight the matching strings" [<WHEN>]
 88 |            | --colour                               "WHEN is 'always', 'never', or 'auto'" [<WHEN>]
 89 |            | --binary                               "do not strip CR characters at EOL (MSDOS/Windows)"
 90 |            ;
 91 | 
 92 | <ACTION-DIRECTORIES> ::= read | recurse | skip;
 93 | 
 94 | <ACTION-DEVICES> ::= read | skip;
 95 | 
 96 | <TYPE> ::= binary | text | without-match;
 97 | 
 98 | <WHEN> ::= always | never | auto;
 99 | 
100 | <FILE> ::= { ls };
101 | ```
102 | 
103 | The DFA can be visualized as a [Graphviz diagram](https://graphviz.org/):
104 | 
105 | ![DFA](assets/dfa.svg)
106 | 
107 | ## Related Projects
108 | 
109 |  * [clap](https://docs.rs/clap_complete/)
110 |     * `complgen` is able to produce completions by executing an arbitrary shell command (e.g. `cargo -Z
111 |       <TAB>`, complete test name in `cargo test <TAB>`)
112 |     * All the grammar specification mechanisms are available for completing option parameters.  That means
113 |       `complgen` is able to complete DSLs of the likes of `strace -e <TAB>` or `lsof -i <TAB>`.
114 |     * No recompilation and reloading necessary in shell integration mode -- just modify the grammar file and completions automatically reflect that.
115 |     * There's a possibility of the program options and completion grammar diverging since they're maintained
116 |       separately.  On the plus side, `complgen` isn't tied to the implementation language and independent
117 |       users can write their custom completion grammars suited for their own needs.
118 |  * [zsh-capture-completion](https://github.com/Valodim/zsh-capture-completion)
119 |     * This must have been painful to implement but is indispensable to complgen!
120 |  * [argcomplete](https://github.com/kislyuk/argcomplete)
121 |  * [Oil's shellac protocol](https://github.com/oilshell/oil/wiki/Shell-Autocompletion)
122 |  * [_regex_arguments and _regex_words completions](https://github.com/zsh-users/zsh-completions/blob/master/zsh-completions-howto.org#writing-completion-functions-using-_regex_arguments-and-_regex_words)
123 |  * [sh-manpage-completions](https://github.com/nevesnunes/sh-manpage-completions)
124 |  * [Little Language](https://wiki.c2.com/?LittleLanguage=)
125 | 


--------------------------------------------------------------------------------
/src/scrape.rs:
--------------------------------------------------------------------------------
  1 | use crate::Result;
  2 | use itertools::PutBack;
  3 | use regex::Regex;
  4 | use std::io::Write;
  5 | 
  6 | fn take_lines_while_descr<'a>(
  7 |     iter: &mut PutBack<impl Iterator<Item = &'a str>>,
  8 |     line: &str,
  9 |     descr_first_line: &'a str,
 10 |     continued_descr_rx: &Regex,
 11 | ) -> String {
 12 |     let mut descr_lines: Vec<&'a str> = vec![descr_first_line];
 13 |     let non_descr_len = line.len() - descr_first_line.len();
 14 |     while let Some(l) = iter.next() {
 15 |         if let Some(c) = continued_descr_rx.captures(l) {
 16 |             if c.get(1).unwrap().len() == non_descr_len {
 17 |                 descr_lines.push(c.get(2).unwrap().as_str());
 18 |             } else {
 19 |                 iter.put_back(l);
 20 |                 break;
 21 |             }
 22 |         } else {
 23 |             iter.put_back(l);
 24 |             break;
 25 |         }
 26 |     }
 27 |     itertools::join(descr_lines, " ")
 28 | }
 29 | 
 30 | pub fn scrape<W: Write>(input: &str, output: &mut W) -> Result<()> {
 31 |     let short_long_opt_triangle_arg_descr =
 32 |         Regex::new(r#"^\s*(-\S),\s*(--\S+) \[<([^>]+)>\]\s+(.+)$"#).unwrap();
 33 |     let short_long_triangle_arg_descr =
 34 |         Regex::new(r#"^\s*(-\S),\s*(--\S+) <([^>]+)>\s+(.+)$"#).unwrap();
 35 |     let short_long_arg_descr =
 36 |         Regex::new(r#"^\s*(-\S),\s*(--\S+)=(\p{Uppercase}+)\s+(.+)$"#).unwrap();
 37 |     let short_long_descr = Regex::new(r#"^\s*(-\S),\s*(--\S+)\s+(.+)$"#).unwrap();
 38 |     let long_arg_descr = Regex::new(r#"^\s*(--\S+)=(\p{Uppercase}+)\s+(.+)$"#).unwrap();
 39 |     let long_triangle_arg_descr = Regex::new(r#"^\s*(--\S+) <([^>]+)>\s+(.+)$"#).unwrap();
 40 |     let long_opt_triangle_arg_descr = Regex::new(r#"^\s*(--\S+) \[<([^>]+)>\]\s+(.+)$"#).unwrap();
 41 |     let long_opt_arg_descr = Regex::new(r#"^\s*(--\S+)\[=(\p{Uppercase}+)\]\s+(.+)$"#).unwrap();
 42 |     let long_descr = Regex::new(r#"^\s*(--\S+)\s+(.+)$"#).unwrap();
 43 |     let short_triangle_arg_descr = Regex::new(r#"^\s*(-\S)\s*<([^>]+)>\s+(.+)$"#).unwrap();
 44 |     let short_descr = Regex::new(r#"^\s*(-\S)\s+(.+)$"#).unwrap();
 45 |     let continued_descr_rx = Regex::new(r#"^(\s*)(.+)$"#).unwrap();
 46 | 
 47 |     let mut iter = itertools::put_back(input.lines());
 48 |     while let Some(line) = iter.next() {
 49 |         if let Some(caps) = short_long_opt_triangle_arg_descr.captures(line) {
 50 |             let short = caps.get(1).unwrap().as_str();
 51 |             let long = caps.get(2).unwrap().as_str();
 52 |             let arg = format!("<{}>", caps.get(3).unwrap().as_str());
 53 |             let descr = caps.get(4).unwrap().as_str();
 54 |             writeln!(output, r#" | ({short} [{arg}] | {long} [{arg}]) "{descr}""#)?;
 55 |             continue;
 56 |         }
 57 | 
 58 |         if let Some(caps) = short_long_triangle_arg_descr.captures(line) {
 59 |             let short = caps.get(1).unwrap().as_str();
 60 |             let long = caps.get(2).unwrap().as_str();
 61 |             let arg = format!("<{}>", caps.get(3).unwrap().as_str());
 62 |             let descr = caps.get(4).unwrap().as_str();
 63 |             writeln!(output, r#" | ({short} {arg} | {long} {arg}) "{descr}""#)?;
 64 |             continue;
 65 |         }
 66 | 
 67 |         if let Some(caps) = short_long_arg_descr.captures(line) {
 68 |             let short = caps.get(1).unwrap().as_str();
 69 |             let long = caps.get(2).unwrap().as_str();
 70 |             let arg = format!("<{}>", caps.get(3).unwrap().as_str());
 71 |             let descr = caps.get(4).unwrap().as_str();
 72 |             writeln!(output, r#" | ({short} {arg} | {long}={arg}) "{descr}""#)?;
 73 |             continue;
 74 |         }
 75 | 
 76 |         if let Some(caps) = short_long_descr.captures(line) {
 77 |             let short = caps.get(1).unwrap().as_str();
 78 |             let long = caps.get(2).unwrap().as_str();
 79 |             let descr = caps.get(3).unwrap().as_str();
 80 |             writeln!(output, r#" | ({short} | {long}) "{descr}""#)?;
 81 |             continue;
 82 |         }
 83 | 
 84 |         if let Some(caps) = long_arg_descr.captures(line) {
 85 |             let long = caps.get(1).unwrap().as_str();
 86 |             let arg = format!("<{}>", caps.get(2).unwrap().as_str());
 87 |             let descr = caps.get(3).unwrap().as_str();
 88 |             let description = take_lines_while_descr(&mut iter, line, descr, &continued_descr_rx);
 89 |             writeln!(output, r#" | {long}={arg} "{description}""#,)?;
 90 |             continue;
 91 |         }
 92 | 
 93 |         if let Some(caps) = long_opt_triangle_arg_descr.captures(line) {
 94 |             let long = caps.get(1).unwrap().as_str();
 95 |             let arg = format!("<{}>", caps.get(2).unwrap().as_str());
 96 |             let descr = caps.get(3).unwrap().as_str();
 97 |             writeln!(output, r#" | ({long} [{arg}]) "{descr}""#)?;
 98 |             continue;
 99 |         }
100 | 
101 |         if let Some(caps) = long_triangle_arg_descr.captures(line) {
102 |             let long = caps.get(1).unwrap().as_str();
103 |             let arg = format!("<{}>", caps.get(2).unwrap().as_str());
104 |             let descr = caps.get(3).unwrap().as_str();
105 |             writeln!(output, r#" | ({long} {arg}) "{descr}""#)?;
106 |             continue;
107 |         }
108 | 
109 |         if let Some(caps) = long_opt_arg_descr.captures(line) {
110 |             let long = caps.get(1).unwrap().as_str();
111 |             let arg = format!("<{}>", caps.get(2).unwrap().as_str());
112 |             let descr = caps.get(3).unwrap().as_str();
113 |             writeln!(output, r#" | {long}[={arg}] "{descr}""#)?;
114 |             continue;
115 |         }
116 | 
117 |         if let Some(caps) = long_descr.captures(line) {
118 |             let long = caps.get(1).unwrap().as_str();
119 |             let descr = caps.get(2).unwrap().as_str();
120 |             let description = take_lines_while_descr(&mut iter, line, descr, &continued_descr_rx);
121 |             writeln!(output, r#" | {long} "{description}""#)?;
122 |             continue;
123 |         }
124 | 
125 |         if let Some(caps) = short_triangle_arg_descr.captures(line) {
126 |             let short = caps.get(1).unwrap().as_str();
127 |             let arg = format!("<{}>", caps.get(2).unwrap().as_str());
128 |             let descr = caps.get(3).unwrap().as_str();
129 |             writeln!(output, r#" | ({short} {arg}) "{descr}""#)?;
130 |             continue;
131 |         }
132 | 
133 |         if let Some(caps) = short_descr.captures(line) {
134 |             let short = caps.get(1).unwrap().as_str();
135 |             let descr = caps.get(2).unwrap().as_str();
136 |             writeln!(output, r#" | {short} "{descr}""#)?;
137 |             continue;
138 |         }
139 |     }
140 |     output.flush()?;
141 |     Ok(())
142 | }
143 | 
144 | #[cfg(test)]
145 | mod tests {
146 |     use super::*;
147 | 
148 |     fn do_scrape(input: &str) -> String {
149 |         let mut buffer: Vec<u8> = Default::default();
150 |         scrape(input, &mut buffer).unwrap();
151 |         String::from_utf8(buffer).unwrap()
152 |     }
153 | 
154 |     #[test]
155 |     fn short_long_descr() {
156 |         const INPUT: &str =
157 |             r#"-E, --extended-regexp     PATTERNS are extended regular expressions"#;
158 |         let output = do_scrape(INPUT);
159 |         assert_eq!(
160 |             output,
161 |             r#" | (-E | --extended-regexp) "PATTERNS are extended regular expressions"
162 | "#
163 |         );
164 |     }
165 | 
166 |     #[test]
167 |     fn short_long_arg_descr() {
168 |         const INPUT: &str = r#"-e, --regexp=PATTERNS     use PATTERNS for matching"#;
169 |         let output = do_scrape(INPUT);
170 |         assert_eq!(
171 |             output,
172 |             r#" | (-e <PATTERNS> | --regexp=<PATTERNS>) "use PATTERNS for matching"
173 | "#
174 |         );
175 |     }
176 | 
177 |     #[test]
178 |     fn long_descr() {
179 |         const INPUT: &str = "--list                List installed commands";
180 |         let output = do_scrape(INPUT);
181 |         assert_eq!(
182 |             output,
183 |             r#" | --list "List installed commands"
184 | "#
185 |         );
186 |     }
187 | 
188 |     #[test]
189 |     fn short_triangle_arg_descr() {
190 |         const INPUT: &str =
191 |             "  -C <DIRECTORY>            Change to DIRECTORY before doing anything (nightly-only)";
192 |         let output = do_scrape(INPUT);
193 |         assert_eq!(
194 |             output,
195 |             r#" | (-C <DIRECTORY>) "Change to DIRECTORY before doing anything (nightly-only)"
196 | "#
197 |         );
198 |     }
199 | 
200 |     #[test]
201 |     fn long_triangle_arg_descr() {
202 |         const INPUT: &str = "      --explain <CODE>      Run `rustc --explain CODE`";
203 |         let output = do_scrape(INPUT);
204 |         assert_eq!(
205 |             output,
206 |             r#" | (--explain <CODE>) "Run `rustc --explain CODE`"
207 | "#
208 |         );
209 |     }
210 | 
211 |     #[test]
212 |     fn long_opt_triangle_arg_descr() {
213 |         const INPUT: &str = "      --bin [<NAME>]            Build only the specified binary";
214 |         let output = do_scrape(INPUT);
215 |         assert_eq!(
216 |             output,
217 |             r#" | (--bin [<NAME>]) "Build only the specified binary"
218 | "#
219 |         );
220 |     }
221 | 
222 |     #[test]
223 |     fn short_long_opt_triangle_arg_descr() {
224 |         const INPUT: &str =
225 |             "  -p, --package [<SPEC>]        Package to build (see `cargo help pkgid`)";
226 |         let output = do_scrape(INPUT);
227 |         assert_eq!(
228 |             output,
229 |             r#" | (-p [<SPEC>] | --package [<SPEC>]) "Package to build (see `cargo help pkgid`)"
230 | "#
231 |         );
232 |     }
233 | 
234 |     #[test]
235 |     fn short_long_triangle_arg_descr() {
236 |         const INPUT: &str =
237 |             "  -j, --jobs <N>                Number of parallel jobs, defaults to # of CPUs.";
238 |         let output = do_scrape(INPUT);
239 |         assert_eq!(
240 |             output,
241 |             r#" | (-j <N> | --jobs <N>) "Number of parallel jobs, defaults to # of CPUs."
242 | "#
243 |         );
244 |     }
245 | 
246 |     #[test]
247 |     fn long_arg_multiline_descr() {
248 |         const INPUT: &str = "
249 |       --quoting-style=WORD   use quoting style WORD for entry names:
250 |                              literal, locale, shell, shell-always,
251 |                              shell-escape, shell-escape-always, c, escape
252 |                              (overrides QUOTING_STYLE environment variable)
253 | ";
254 |         let output = do_scrape(INPUT);
255 |         assert_eq!(
256 |             output,
257 |             r#" | --quoting-style=<WORD> "use quoting style WORD for entry names: literal, locale, shell, shell-always, shell-escape, shell-escape-always, c, escape (overrides QUOTING_STYLE environment variable)"
258 | "#
259 |         );
260 |     }
261 | 
262 |     #[test]
263 |     fn long_multiline_descr() {
264 |         const INPUT: &str = "
265 |           --allow-untrusted     Install packages with untrusted signature or no
266 |                                 signature
267 | ";
268 |         let output = do_scrape(INPUT);
269 |         assert_eq!(
270 |             output,
271 |             r#" | --allow-untrusted "Install packages with untrusted signature or no signature"
272 | "#
273 |         );
274 |     }
275 | }
276 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ## Value Proposition
  2 | 
  3 | `complgen` compiles man-page/EBNF-like grammars into standalone completion scripts.  See
  4 | [examples](examples/).
  5 | 
  6 | ## Demo
  7 | 
  8 | ![demo](https://github.com/adaszko/complgen/blob/demo/complgen.gif)
  9 | 
 10 | ## Usage
 11 | 
 12 | ### Bash
 13 | 
 14 | <details>
 15 | 
 16 | ```sh
 17 | $ cat hello.usage
 18 | hello --color=(always | never | auto);
 19 | $ complgen --bash hello.bash hello.usage
 20 | $ source hello.bash
 21 | $ hello --color=<TAB>
 22 | always auto never
 23 | ```
 24 | 
 25 | </details>
 26 | 
 27 | ### Fish
 28 | 
 29 | <details>
 30 | 
 31 | ```sh
 32 | $ cat hello.usage
 33 | hello --color=(always | never | auto);
 34 | $ complgen --fish hello.fish hello.usage
 35 | $ source hello.fish
 36 | $ hello --color=<TAB>
 37 | --color=always  --color=auto  --color=never
 38 | ```
 39 | 
 40 | </details>
 41 | 
 42 | ### Zsh
 43 | 
 44 | <details>
 45 | 
 46 | ```sh
 47 | % cat hello.usage
 48 | hello --color=(always | never | auto);
 49 | % complgen --zsh _hello hello.usage
 50 | % source _hello
 51 | % hello --color=<TAB>
 52 | always
 53 | auto
 54 | never
 55 | ```
 56 | 
 57 | 💡 Note: Under ZSH, `source` isn't strictly necessary — it is enough to put the output file in one of the
 58 | directories listed in `$fpath` variable.
 59 | </details>
 60 | 
 61 | ## Installation
 62 | 
 63 | ```sh
 64 | cargo install --git https://github.com/adaszko/complgen --tag v0.5.0 complgen
 65 | ```
 66 | 
 67 | ## Syntax
 68 | 
 69 | See the [`examples` subdirectory](examples/).
 70 | 
 71 | Try piping through the `scrape` subcommand to quickly generate grammar skeleton that can be tweaked
 72 | further, e.g.:
 73 | 
 74 | ```
 75 | $ grep --help | complgen --scrape
 76 |  | (-E | --extended-regexp) "PATTERNS are extended regular expressions"
 77 |  | (-F | --fixed-strings) "PATTERNS are strings"
 78 |  | (-G | --basic-regexp) "PATTERNS are basic regular expressions"
 79 | [...]
 80 | ```
 81 | 
 82 | The grammar is based on [compleat](https://github.com/mbrubeck/compleat/blob/master/README.markdown#syntax)'s one.
 83 | 
 84 | A grammar is a series of lines terminated by a semicolon (`;`).  Each line either represents a single variant
 85 | of invoking the completed command or is a nonterminal definition.
 86 | 
 87 |  * `a b` matches `a` followed by `b`.
 88 |  * `a b | c` matches either `a b` or `c` (IOW: sequence binds stronger than alternative).
 89 |  * `[a]` matches zero or one occurrences of `a`.
 90 |  * `a...` matches one or more occurrences of `a`
 91 |  * `[a]...` matches zero or more occurrences of `a`.
 92 |  * `(aaa | bbb || ccc)` shows `aaa` and `bbb` as candidates, and `ccc` only when current input matches neither
 93 |    `aaa` nor `bbb`.  `||` behaves exactly like `|` when matching, it differs only when offering completions.
 94 | 
 95 | Use parentheses to group patterns:
 96 | 
 97 |  * `a (b | c)` matches `a` followed by either `b` or `c`.
 98 |  * `(a | b) ...` matches `a` or `b` followed by any number of additional
 99 |    `a` or `b`.
100 | 
101 | ### Filename completion
102 | 
103 | There's a couple of predefined nonterminals that are handled specially by `complgen`:
104 | 
105 | | Name          | bash | fish | zsh | Description |
106 | |---------------|------|------|-----|-------------|
107 | |`<PATH>`       | ✅   | ✅   | ✅  | file or directory path |
108 | |`<DIRECTORY>`  | ✅   | ✅   | ✅  | directory path |
109 | |`<PID>`        | ❌   | ✅   | ✅  | process id |
110 | |`<USER>`       | ✅   | ✅   | ✅  | user name |
111 | |`<GROUP>`      | ✅   | ✅   | ✅  | group name |
112 | |`<HOST>`       | ✅   | ✅   | ✅  | hostname |
113 | |`<INTERFACE>`  | ❌   | ✅   | ✅  | network interface name |
114 | |`<PACKAGE>`    | ❌   | ✅   | ❌  | OS package name |
115 | 
116 | The reason there's no predefined `<FILE>` nonterminal is that it would work only for files from the current
117 | directory which is too specific to be generally useful.
118 | 
119 | These nonterminals can still be defined in the grammar in the usual way (`<PATH> ::= ...`), in which case
120 | their predefined meaning gets overriden.
121 | 
122 | ### Descriptions (fish/zsh only)
123 | 
124 | If a literal is immediately followed with a quoted string, it's going to appear as a hint to the user at
125 | completion time.  E.g. the grammar:
126 | 
127 | ```sh
128 | grep --extended-regexp "PATTERNS are extended regular expressions" | --exclude  "skip files that match GLOB";
129 | ```
130 | 
131 | results in something like this under fish (and zsh):
132 | 
133 | ```fish
134 | fish> grep --ex<TAB>
135 | --exclude  (skip files that match GLOB)  --extended-regexp  (PATTERNS are extended regular expressions)
136 | ```
137 | 
138 | Note that `bash` does not support showing descriptions.
139 | 
140 | ### Sourcing completions from external commands output
141 | 
142 | It is possible to use entire shell commands as a source of completions:
143 | 
144 | ```
145 | cargo {{{ rustup toolchain list | cut -d' ' -f1 | sed 's/^/+/' }}};
146 | ```
147 | 
148 | The stdout of the pipeline above will be automatically filtered by the shell based on the prefix entered so
149 | far.
150 | 
151 | ##### The prefix entered so far
152 | 
153 | Sometimes, it's more efficient to take into account the entered prefix in the shell command itself.  For all
154 | three shells (bash, fish, zsh), it's available in the `$1` variable:
155 | 
156 | ```
157 | cargo {{{ rustup toolchain list | cut -d' ' -f1 | grep "^$1" | sed 's/^/+/' }}};
158 | ```
159 | 
160 | Note that in general, it's best to leave the filtering up to the executing shell since it may be configured to
161 | perform some non-standard filtering.  zsh for example is capable of expanding `/u/l/b` to `/usr/local/bin`.
162 | 
163 | ##### Descriptions
164 | 
165 | Externals commands are also assumed to produce descriptions similar to those described in the [section
166 | above](#descriptions).  Their expected stdout format is a sequence of lines of the form
167 | 
168 | ```
169 | COMPLETION\tDESCRIPTION
170 | ```
171 | 
172 | For fish and zsh, the `DESCRIPTION` part will be presented to the user.  Under bash, only the `COMPLETION`
173 | part will be visible.  All external commands nonetheless need to take care as to *not* produce superfluous
174 | `\t` characters that may confuse the resulting shell scripts.
175 | 
176 | ### Bypassing tail restriction
177 | 
178 | `complgen` will error out if you place `{{{ ... }}}` at a position where it's a subject to matching (as
179 | opposed to completing).  It is possible to overcome that restriction by providing a regular expression
180 | matching the command output:
181 | 
182 | ```
183 | cmd ({{{ echo foo }}}@bash"foo" | bar);
184 | ```
185 | 
186 | ### Target shell-specific behavior
187 | 
188 | In order to make use of shell-specific completion functions, `complgen` supports a mechanism that allows for
189 | picking a specific nonterminal expansion based on the target shell.  To use an example: all shells are able to
190 | complete a user on the system, although each has a different function for it.  We unify their interface under
191 | the nonterminal `<USER>` using few `nonterminal@shell` definitions:
192 | 
193 | ```
194 | cmd <USER>;
195 | <USER@bash> ::= {{{ compgen -A user "$1" | sort | uniq }}}; # produce candidates on stdout under bash
196 | <USER@fish> ::= {{{ __fish_complete_users "$1" }}}; # produce candidates on stdout under fish
197 | <USER@zsh> ::= {{{ _users }}}; # produce candidates via compadd and friends under zsh
198 | ```
199 | 
200 | ⚠️ Gotcha: Under ZSH, when calling `compadd` within a subword, candidates are automatically filtered based on
201 | the prefix input so far.  It may result in some completions not showing up.  You may want call it as `compadd
202 | ${1}<YOUR_CANDIDATE>` to include the entered prefix, or as `compadd -U` to disable the builtin filtering
203 | mechanism.
204 | 
205 | ### Completing option arguments
206 | 
207 | It's possible to match not only entire words, but also *within* words themselves, using the same grammar
208 | syntax as for matching entire words.  In that sense, it all fractally works on subwords too (there are
209 | limitations on `{{{ ... }}}` usage though).  The most common application of that general mechanism is to
210 | handle equal sign arguments (`--option=ARGUMENT`):
211 | 
212 | ```
213 | grep --color=(always | never | auto);
214 | ```
215 | 
216 | Note however that equal sign arguments aren't some special case within complgen — the same mechanism works for
217 | more complicated things, e.g.:
218 | 
219 | ```
220 | strace -e <EXPR>;
221 | <EXPR> ::= [<qualifier>=][!]<value>[,<value>]...;
222 | <qualifier> ::= trace | read | write | fault;
223 | <value> ::= %file | file | all;
224 | ```
225 | 
226 | The above grammar was pulled straight out of [`strace` man page](https://man7.org/linux/man-pages/man1/strace.1.html#OPTIONS).
227 | 
228 | 
229 | ### Cleaning up the list of completion candidates
230 | 
231 | If you do `git <TAB>` in most shells you're presented with a list of git subcommands.  Even though git accepts
232 | a bunch of global options (`--help`, `--version`, etc.), they don't show up there (sic!).  That's a special
233 | mechanism intended for reducing clutter.  Under complgen, the same effect is achieved via a construction
234 | called fallbacks, which are represented in the grammar as the double bar operator (`||`):
235 | 
236 | ```
237 | mygit (<SUBCOMMAND> || <OPTION>);
238 | <SUBCOMMAND> ::= fetch | add | commit | push;
239 | <OPTION> ::= --help | --version;
240 | ```
241 | 
242 | With the grammar above, `git <TAB>` will offer to complete *only* subcommands.  For `git --<TAB>` OTOH,
243 | `complgen` will offer to complete options.
244 | 
245 | `||` has the lowest priority of all operators, so the grammar above might have been written without any use of
246 | `<NONTERMINALS>`.  They're there only for readability sake.
247 | 
248 | ## Trailing spaces handling
249 | 
250 | There are few general rules governing whether to append a space to a completion:
251 | 
252 |  * A space is appended if the completion corresponds to an entire literal from the `.usage` file, e.g.
253 |    for the grammar `cmd --help;` and the command line `cmd <TAB>`, it completes to `cmd --help<SPACE>`.
254 | 
255 |  * A trailing space isn't appended if the literal is a part of a subword and the entire subword hasn't been
256 |    completed yet, e.g. for the grammar `cmd --color=(auto|always);` and the command line `cmd --col<TAB>`, it
257 |  completes to `cmd --color=` (no trailing space).
258 | 
259 | There are exceptions:
260 | 
261 |  * Under Fish, if your completion contains [one of the special
262 |    characters](https://github.com/fish-shell/fish-shell/blob/408ab860906fbf6e08f314bea982220fdee3428e/src/complete.cpp#L183),
263 |  fish won't insert the trailing space.  See also [Not adding space after dot at completion time · Issue #6928](https://github.com/fish-shell/fish-shell/issues/6928).
264 | 
265 | ## Caveats
266 | 
267 | * The tail commands limitation applies to predefined nonterminals (`<PATH>`, `<DIRECTORY>`, etc.) since
268 |   they're internally implemented as external commands.
269 | 
270 | * Bash requires `bash-completion` OS package to be installed because completion scripts produced by
271 |   `complgen`, call shell functions from that package at *completion* time.  This is necessary to work around
272 |   Bash's default behavior of [breaking shell words on any character present in the
273 |   `$COMP_WORDBREAKS`](https://stackoverflow.com/a/12495480) environment variable.
274 | 
275 | * [Fish 4.0 fuzzy subsequence filtering](https://fishshell.com/docs/4.0/relnotes.html#completions) does not
276 |   work in scripts generated by complgen.
277 | 
278 | * Non-regular grammars aren't completed 100% *precisely*. For instance, in case of `find(1)`, `complgen` will
279 |   still suggest `)` even in cases when all `(` have already been properly closed before the cursor.
280 | 
281 | ## License
282 | 
283 | `complgen`'s source code is covered by [License](LICENSE).  Completion scripts generated by `complgen` are
284 | subject only to [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).
285 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
  1 | use std::ffi::OsStr;
  2 | use std::io::{BufWriter, Read, Write};
  3 | use std::path::Path;
  4 | use std::process::exit;
  5 | 
  6 | use anyhow::{Context, bail};
  7 | use clap::Parser;
  8 | 
  9 | use complgen::grammar::{Grammar, HumanSpan, Shell, ValidGrammar};
 10 | 
 11 | use complgen::Error;
 12 | use complgen::dfa::DFA;
 13 | use complgen::regex::{Regex, diagnostic_display_input};
 14 | 
 15 | #[derive(clap::Parser)]
 16 | struct Cli {
 17 |     #[clap(
 18 |         long,
 19 |         help = "Read another program's --help output and generate a grammar *skeleton*"
 20 |     )]
 21 |     scrape: bool,
 22 | 
 23 |     #[clap(long, help = "Show version and exit")]
 24 |     version: bool,
 25 | 
 26 |     usage_file_path: Option<String>,
 27 | 
 28 |     #[clap(long, help = "Write bash completion script", name = "BASH_SCRIPT_PATH")]
 29 |     bash: Option<String>,
 30 | 
 31 |     #[clap(long, help = "Write fish completion script", name = "FISH_SCRIPT_PATH")]
 32 |     fish: Option<String>,
 33 | 
 34 |     #[clap(long, help = "Write zsh completion script", name = "ZSH_SCRIPT_PATH")]
 35 |     zsh: Option<String>,
 36 | 
 37 |     #[clap(
 38 |         long,
 39 |         help = "Write regex in GraphViz .dot format",
 40 |         name = "REGEX_DOT_PATH"
 41 |     )]
 42 |     regex: Option<String>,
 43 | 
 44 |     #[clap(
 45 |         long,
 46 |         help = "Write DFA in GraphViz .dot format",
 47 |         name = "DFA_DOT_PATH"
 48 |     )]
 49 |     dfa: Option<String>,
 50 | }
 51 | 
 52 | fn get_file_or_stdin(path: &str) -> anyhow::Result<Box<dyn Read>> {
 53 |     let result: Box<dyn Read> = if path == "-" {
 54 |         Box::new(std::io::stdin())
 55 |     } else {
 56 |         Box::new(std::fs::File::open(path).context(path.to_owned())?)
 57 |     };
 58 |     Ok(result)
 59 | }
 60 | 
 61 | struct ErrMsg {
 62 |     err: chic::Error,
 63 | }
 64 | 
 65 | impl ErrMsg {
 66 |     fn new(label: &str) -> Self {
 67 |         Self {
 68 |             err: chic::Error::new(label),
 69 |         }
 70 |     }
 71 | 
 72 |     fn error(self, span: &HumanSpan, source: &str, what: &str) -> Self {
 73 |         Self {
 74 |             err: self.err.error(
 75 |                 span.line,
 76 |                 span.column_start_machine(),
 77 |                 span.column_end_machine(),
 78 |                 source.lines().nth(span.line_machine()).unwrap(),
 79 |                 what,
 80 |             ),
 81 |         }
 82 |     }
 83 | 
 84 |     fn help(self, label: &str) -> Self {
 85 |         Self {
 86 |             err: self.err.help(label),
 87 |         }
 88 |     }
 89 | 
 90 |     fn into_string(self, path: &str, span: &HumanSpan) -> String {
 91 |         format!(
 92 |             "{}:{}:{}:{}",
 93 |             path,
 94 |             span.line,
 95 |             span.column_start,
 96 |             self.err.to_string()
 97 |         )
 98 |     }
 99 | }
100 | 
101 | struct WarnMsg {
102 |     warning: chic::Warning,
103 | }
104 | 
105 | impl WarnMsg {
106 |     fn new(label: &str) -> Self {
107 |         Self {
108 |             warning: chic::Warning::new(label),
109 |         }
110 |     }
111 | 
112 |     fn warning(self, span: &HumanSpan, source: &str, what: &str) -> Self {
113 |         Self {
114 |             warning: self.warning.warning(
115 |                 span.line,
116 |                 span.column_start_machine(),
117 |                 span.column_end_machine(),
118 |                 source.lines().nth(span.line_machine()).unwrap(),
119 |                 what,
120 |             ),
121 |         }
122 |     }
123 | 
124 |     fn into_string(self, path: &str, span: &HumanSpan) -> String {
125 |         format!(
126 |             "{}:{}:{}:{}",
127 |             path,
128 |             span.line,
129 |             span.column_start,
130 |             self.warning.to_string()
131 |         )
132 |     }
133 | }
134 | 
135 | fn handle_error(e: Error, path: &str, source: &str, command: &str) -> anyhow::Result<()> {
136 |     match e {
137 |         Error::ParseError(span) => {
138 |             let err = ErrMsg::new("Parse error").error(&span, source, "");
139 |             eprintln!("{}", err.into_string(path, &span));
140 |         }
141 |         Error::InvalidCommandName(span) => {
142 |             let err = ErrMsg::new("Invalid command name").error(&span, source, "");
143 |             eprintln!("{}", err.into_string(path, &span));
144 |         }
145 |         Error::VaryingCommandNames(spans) => {
146 |             for span in spans {
147 |                 let err = ErrMsg::new("Varying command names:").error(&span, source, "");
148 |                 eprintln!("{}", err.into_string(path, &span));
149 |             }
150 |         }
151 |         Error::NonterminalDefinitionsCycle(spans) => {
152 |             for span in spans {
153 |                 let err = ErrMsg::new("Nonterminal definitions cycle").error(&span, source, "");
154 |                 eprintln!("{}", err.into_string(path, &span));
155 |             }
156 |         }
157 |         Error::DuplicateNonterminalDefinition(first, second) => {
158 |             let err = ErrMsg::new("Duplicate nonterminal definition").error(&second, source, "");
159 |             eprintln!("{}", err.into_string(path, &second));
160 |             let err = ErrMsg::new("Previous definition").error(&first, source, "");
161 |             eprintln!("{}", err.into_string(path, &first));
162 |         }
163 |         Error::UnknownShell(span) => {
164 |             let err = ErrMsg::new("Unknown shell").error(&span, source, "");
165 |             eprintln!("{}", err.into_string(path, &span));
166 |         }
167 |         Error::NonCommandSpecialization(span) => {
168 |             let err = ErrMsg::new("Can only specialize external commands").error(&span, source, "");
169 |             eprintln!("{}", err.into_string(path, &span));
170 |         }
171 |         Error::SubwordSpaces(left, right, trace) => {
172 |             let err = ErrMsg::new("Adjacent literals in expression used in a subword context")
173 |                 .error(&left, source, "First one");
174 |             eprintln!("{}", err.into_string(path, &left));
175 | 
176 |             let err = ErrMsg::new("").error(&right, source, "Second one").help(
177 |                 "Join the adjacent literals into one as spaces are invalid in a subword context",
178 |             );
179 |             eprintln!("{}", err.into_string(path, &right));
180 | 
181 |             for t in trace {
182 |                 let err = ErrMsg::new("Referenced in a subword context at").error(&t, source, "");
183 |                 eprintln!("{}", err.into_string(path, &t));
184 |             }
185 |         }
186 |         Error::AmbiguousMatchable(left, right) => {
187 |             let err = ErrMsg::new("Ambiguous grammar.  Matching can't differentiate:")
188 |                 .error(&left, source, "");
189 |             eprintln!("{}", err.into_string(path, &left));
190 | 
191 |             let err = ErrMsg::new("and:").error(&right, source, "");
192 |             eprintln!("{}", err.into_string(path, &right));
193 |         }
194 |         Error::UnboundedMatchable(left, right) => {
195 |             let err = ErrMsg::new(
196 |                 "Ambiguous grammar.  Matching can't ascertain where below element ends:",
197 |             )
198 |             .error(&left, source, "");
199 |             eprintln!("{}", err.into_string(path, &left));
200 | 
201 |             let err = ErrMsg::new("...and where below element begins:").error(&right, source, "");
202 |             eprintln!("{}", err.into_string(path, &right));
203 |         }
204 |         Error::AmbiguousDFA(path, ambiguous_inputs) => {
205 |             let joined_path = {
206 |                 let mut buf = String::new();
207 |                 for (i, inp) in path.iter().enumerate() {
208 |                     diagnostic_display_input(&mut buf, inp)?;
209 |                     if i < path.len() - 1 {
210 |                         buf.push(' ');
211 |                     }
212 |                 }
213 |                 buf
214 |             };
215 |             eprintln!("Ambiguity:");
216 |             for input in ambiguous_inputs {
217 |                 let mut buffer = String::new();
218 |                 diagnostic_display_input(&mut buffer, &input)?;
219 |                 eprintln!("  {command} {joined_path} {buffer}");
220 |             }
221 |         }
222 |         Error::ClashingVariants(left, right) => {
223 |             let err = ErrMsg::new("Clashing variants.  Completion can't differentiate:")
224 |                 .error(&left, source, "");
225 |             eprintln!("{}", err.into_string(path, &left));
226 | 
227 |             let err = ErrMsg::new("and:").error(&right, source, "");
228 |             eprintln!("{}", err.into_string(path, &right));
229 |         }
230 |         Error::ClashingSubwordLeaders(left, right) => {
231 |             let err = ErrMsg::new("Clashing subword leaders.  Completion can't differentiate:")
232 |                 .error(&left, source, "");
233 |             eprintln!("{}", err.into_string(path, &left));
234 | 
235 |             let err = ErrMsg::new("and:").error(&right, source, "");
236 |             eprintln!("{}", err.into_string(path, &right));
237 |         }
238 |         e => {
239 |             eprintln!("{}", e);
240 |         }
241 |     }
242 |     exit(1);
243 | }
244 | 
245 | fn get_file_or_stdout(path: &str) -> anyhow::Result<Box<dyn Write>> {
246 |     let result: Box<dyn Write> = if path == "-" {
247 |         Box::new(std::io::stdout())
248 |     } else {
249 |         Box::new(std::fs::File::create(path).context(path.to_owned())?)
250 |     };
251 |     Ok(result)
252 | }
253 | 
254 | fn aot(args: &Cli) -> anyhow::Result<()> {
255 |     let Some(ref usage_file_path) = args.usage_file_path else {
256 |         bail!("Missing usage file path argument")
257 |     };
258 | 
259 |     let input = {
260 |         let mut usage_file = get_file_or_stdin(usage_file_path)?;
261 |         let mut input = String::default();
262 |         usage_file
263 |             .read_to_string(&mut input)
264 |             .context(usage_file_path.to_owned())?;
265 |         input
266 |     };
267 | 
268 |     let grammar = match Grammar::parse(&input) {
269 |         Ok(grammar) => grammar,
270 |         Err(e) => return handle_error(e, usage_file_path, &input, "dummy"),
271 |     };
272 | 
273 |     let (shell, path) = match (&args.bash, &args.fish, &args.zsh) {
274 |         (Some(path), None, None) => (Shell::Bash, path),
275 |         (None, Some(path), None) => (Shell::Fish, path),
276 |         (None, None, Some(path)) => (Shell::Zsh, path),
277 | 
278 |         _ => {
279 |             eprintln!("Please specify exactly one of: --bash, --fish, --zsh");
280 |             exit(1);
281 |         }
282 |     };
283 | 
284 |     let validated = match ValidGrammar::from_grammar(grammar, shell) {
285 |         Ok(validated) => validated,
286 |         Err(e) => return handle_error(e, usage_file_path, &input, "dummy"),
287 |     };
288 | 
289 |     if !validated.undefined_nonterminals.is_empty() {
290 |         for span in validated.undefined_nonterminals.values() {
291 |             let err = WarnMsg::new("Undefined nonterminal").warning(span, &input, "");
292 |             eprintln!("{}", err.into_string(usage_file_path, span));
293 |         }
294 |     }
295 | 
296 |     if !validated.unused_nonterminals.is_empty() {
297 |         for span in validated.unused_nonterminals.values() {
298 |             let err = WarnMsg::new("Unused nonterminal").warning(span, &input, "");
299 |             eprintln!("{}", err.into_string(usage_file_path, span));
300 |         }
301 |     }
302 | 
303 |     let regex = match Regex::from_valid_grammar(&validated, shell) {
304 |         Ok(regex) => regex,
305 |         Err(e) => return handle_error(e, usage_file_path, &input, &validated.command),
306 |     };
307 | 
308 |     if let Some(regex_dot_file_path) = &args.regex {
309 |         let mut dot_file = get_file_or_stdout(regex_dot_file_path)?;
310 |         regex
311 |             .to_dot(&mut dot_file)
312 |             .context(regex_dot_file_path.clone())?;
313 |     }
314 | 
315 |     let dfa = match DFA::from_regex(regex, validated.subdfas) {
316 |         Ok(dfa) => dfa,
317 |         Err(e) => return handle_error(e, usage_file_path, &input, &validated.command),
318 |     };
319 | 
320 |     let dfa = dfa.minimize();
321 | 
322 |     if let Some(dot_file_path) = &args.dfa {
323 |         let mut dot_file = get_file_or_stdout(dot_file_path)?;
324 |         dfa.to_dot(&mut dot_file).context(dot_file_path.clone())?;
325 |     }
326 | 
327 |     let script_file = get_file_or_stdout(path)?;
328 |     let mut writer = BufWriter::new(script_file);
329 | 
330 |     match shell {
331 |         Shell::Bash => {
332 |             complgen::bash::write_completion_script(&mut writer, &validated.command, &dfa)?
333 |         }
334 |         Shell::Fish => {
335 |             complgen::fish::write_completion_script(&mut writer, &validated.command, &dfa)?
336 |         }
337 |         Shell::Zsh => {
338 |             let expected_name = format!("_{}", validated.command);
339 |             if path != "-"
340 |                 && Path::new(path).file_name().unwrap_or_default() != OsStr::new(&expected_name)
341 |             {
342 |                 eprintln!(
343 |                     "warning: ZSH requires the output script to be named {expected_name:?} for autoloading to work"
344 |                 );
345 |             }
346 |             complgen::zsh::write_completion_script(&mut writer, &validated.command, &dfa)?;
347 |         }
348 |     }
349 | 
350 |     Ok(())
351 | }
352 | 
353 | fn scrape() -> anyhow::Result<()> {
354 |     let input: String = {
355 |         let mut input = String::default();
356 |         std::io::stdin().read_to_string(&mut input)?;
357 |         input
358 |     };
359 | 
360 |     let mut writer = BufWriter::new(std::io::stdout());
361 |     complgen::scrape::scrape(&input, &mut writer)?;
362 |     Ok(())
363 | }
364 | 
365 | fn main() -> anyhow::Result<()> {
366 |     let args = Cli::parse();
367 | 
368 |     if args.version {
369 |         println!("{}", env!("COMPLGEN_VERSION"));
370 |         return Ok(());
371 |     }
372 | 
373 |     if args.scrape {
374 |         return scrape();
375 |     }
376 | 
377 |     aot(&args)
378 | }
379 | 


--------------------------------------------------------------------------------
/e2e/test_zsh.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import string
  3 | import tempfile
  4 | from pathlib import Path
  5 | 
  6 | from common import LSOF_FILTER_GRAMMAR, STRACE_EXPR_GRAMMAR
  7 | from conftest import (
  8 |     gen_grammar_zsh_capture_script_path,
  9 |     get_zsh_capture_script_sorted_lines,
 10 |     set_working_dir,
 11 | )
 12 | 
 13 | import pytest
 14 | from hypothesis import given, settings
 15 | from hypothesis.strategies import text
 16 | 
 17 | 
 18 | def get_sorted_aot_completions(
 19 |     complgen_binary_path: Path, grammar: str, input: str
 20 | ) -> list[str]:
 21 |     with gen_grammar_zsh_capture_script_path(
 22 |         complgen_binary_path, grammar
 23 |     ) as capture_zsh_path:
 24 |         return get_zsh_capture_script_sorted_lines(capture_zsh_path, input)
 25 | 
 26 | 
 27 | def test_zsh_uses_correct_description_with_duplicated_literals(
 28 |     complgen_binary_path: Path,
 29 | ):
 30 |     GRAMMAR = """
 31 | cmd <COMMAND> [--help];
 32 | 
 33 | <COMMAND> ::= rm           "Remove a project" <RM-OPTION>
 34 |             | remote       "Manage a project's remotes" [<REMOTE-SUBCOMMAND>]
 35 |             ;
 36 | 
 37 | <REMOTE-SUBCOMMAND> ::= rm <name>;
 38 | """
 39 | 
 40 |     assert get_sorted_aot_completions(complgen_binary_path, GRAMMAR, "cmd ") == sorted(
 41 |         ["rm rm     -- Remove a project", "remote remote -- Manage a project's remotes"]
 42 |     )
 43 | 
 44 | 
 45 | def test_zsh_uses_correct_description_with_duplicated_descriptions(
 46 |     complgen_binary_path: Path,
 47 | ):
 48 |     GRAMMAR = """
 49 | mygrep [<OPTION>]...;
 50 | 
 51 | <OPTION> ::= --color    "use markers to highlight the matching strings" [<WHEN>]
 52 |            | --colour   "use markers to highlight the matching strings" [<WHEN>]
 53 |            ;
 54 | """
 55 | 
 56 |     assert get_sorted_aot_completions(
 57 |         complgen_binary_path, GRAMMAR, "mygrep "
 58 |     ) == sorted(
 59 |         [
 60 |             "--color --color  -- use markers to highlight the matching strings",
 61 |             "--colour --colour -- use markers to highlight the matching strings",
 62 |         ]
 63 |     )
 64 | 
 65 | 
 66 | def test_zsh_external_command_produces_description(complgen_binary_path: Path):
 67 |     GRAMMAR = r"""
 68 | cmd {{{ echo -e "completion\tdescription" }}};
 69 | """
 70 |     actual = [
 71 |         s.split()
 72 |         for s in get_sorted_aot_completions(complgen_binary_path, GRAMMAR, "cmd ")
 73 |     ]
 74 |     assert actual == sorted([["completion", "completion", "--", "description"]])
 75 | 
 76 | 
 77 | def test_completes_paths(complgen_binary_path: Path):
 78 |     GRAMMAR = r"""cmd <PATH> [--help];"""
 79 |     with tempfile.TemporaryDirectory() as dir:
 80 |         with set_working_dir(Path(dir)):
 81 |             Path("filename with spaces").write_text("dummy")
 82 |             Path("?[^a]*{foo,*bar}").write_text("dummy")
 83 |             os.mkdir("dir with spaces")
 84 |             assert get_sorted_aot_completions(
 85 |                 complgen_binary_path, GRAMMAR, "cmd "
 86 |             ) == sorted(
 87 |                 [
 88 |                     r"\?\[\^a\]\*\{foo,\*bar\}",
 89 |                     r"filename\ with\ spaces",
 90 |                     r"dir\ with\ spaces",
 91 |                 ]
 92 |             )
 93 | 
 94 | 
 95 | def test_completes_directories(complgen_binary_path: Path):
 96 |     GRAMMAR = """cmd <DIRECTORY> [--help];"""
 97 |     with tempfile.TemporaryDirectory() as dir:
 98 |         with set_working_dir(Path(dir)):
 99 |             os.mkdir("dir with spaces")
100 |             os.mkdir("?[^a]*{foo,*bar}")
101 |             Path("filename with spaces").write_text("dummy")
102 |             assert get_sorted_aot_completions(
103 |                 complgen_binary_path, GRAMMAR, "cmd "
104 |             ) == sorted(
105 |                 [
106 |                     r"\?\[\^a\]\*\{foo,\*bar\}",
107 |                     r"dir\ with\ spaces",
108 |                 ]
109 |             )
110 | 
111 | 
112 | def test_completes_file_with_spaces(complgen_binary_path: Path):
113 |     GRAMMAR = """cmd <PATH>;"""
114 |     with tempfile.TemporaryDirectory() as dir:
115 |         with set_working_dir(Path(dir)):
116 |             Path("file with spaces").write_text("dummy")
117 |             assert get_sorted_aot_completions(
118 |                 complgen_binary_path, GRAMMAR, "cmd "
119 |             ) == sorted(["file\\ with\\ spaces"])
120 | 
121 | 
122 | def test_specializes_for_zsh(complgen_binary_path: Path):
123 |     GRAMMAR = (
124 |         """cmd <FOO>; <FOO> ::= {{{ echo foo }}}; <FOO@zsh> ::= {{{ compadd zsh }}};"""
125 |     )
126 |     assert get_sorted_aot_completions(complgen_binary_path, GRAMMAR, "cmd ") == sorted(
127 |         ["zsh"]
128 |     )
129 | 
130 | 
131 | def test_specializes_for_zsh_with_regex(complgen_binary_path: Path):
132 |     GRAMMAR = """
133 | cmd (<FOO> foo | <BAR> bar);
134 | <FOO@zsh> ::= {{{ compadd zsh }}}@zsh"zsh";
135 | """
136 |     assert get_sorted_aot_completions(complgen_binary_path, GRAMMAR, "cmd zsh ") == sorted(
137 |         ["foo"]
138 |     )
139 | 
140 | 
141 | def test_subword_specializes_for_zsh_with_regex(complgen_binary_path: Path):
142 |     GRAMMAR = """
143 | cmd <FOO>bar;
144 | <FOO@zsh> ::= {{{ compadd zsh }}}@zsh"zsh";
145 | """
146 |     assert get_sorted_aot_completions(complgen_binary_path, GRAMMAR, "cmd zsh") == sorted(
147 |         ["bar"]
148 |     )
149 | 
150 | 
151 | def test_nontail_matching_alternative(complgen_binary_path: Path):
152 |     GRAMMAR = """cmd <LEFT> | right; <LEFT> ::= {{{ echo left }}}@zsh"left";"""
153 |     assert get_sorted_aot_completions(
154 |         complgen_binary_path, GRAMMAR, "cmd rig"
155 |     ) == sorted(["right"])
156 | 
157 | 
158 | def test_nontail_matching_fallback(complgen_binary_path: Path):
159 |     GRAMMAR = """cmd <LEFT> || right; <LEFT> ::= {{{ echo left }}}@zsh"left";"""
160 |     assert get_sorted_aot_completions(
161 |         complgen_binary_path, GRAMMAR, "cmd rig"
162 |     ) == sorted(["right"])
163 | 
164 | 
165 | def test_nontail_matching_subword(complgen_binary_path: Path):
166 |     GRAMMAR = """cmd <LEFT>right; <LEFT> ::= {{{ echo left }}}@zsh"left";"""
167 |     assert get_sorted_aot_completions(
168 |         complgen_binary_path, GRAMMAR, "cmd left"
169 |     ) == sorted(["leftright right"])
170 | 
171 | 
172 | def test_nontail_completion(complgen_binary_path: Path):
173 |     GRAMMAR = """cmd {{{ echo left }}}@zsh"left";"""
174 |     assert get_sorted_aot_completions(
175 |         complgen_binary_path, GRAMMAR, "cmd "
176 |     ) == sorted(["left"])
177 | 
178 | 
179 | def test_nontail_completion_subword(complgen_binary_path: Path):
180 |     GRAMMAR = """cmd left{{{ echo right }}}@zsh"right";"""
181 |     assert get_sorted_aot_completions(
182 |         complgen_binary_path, GRAMMAR, "cmd left"
183 |     ) == sorted(["leftright"])
184 | 
185 | 
186 | def test_nontail_completion_truncates_to_regex(complgen_binary_path: Path):
187 |     GRAMMAR = """cmd {{{ echo leftspam }}}@zsh"left";"""
188 |     assert get_sorted_aot_completions(
189 |         complgen_binary_path, GRAMMAR, "cmd "
190 |     ) == sorted(["left"])
191 | 
192 | 
193 | def test_nontail_completion_subword_truncates_to_regex(complgen_binary_path: Path):
194 |     GRAMMAR = """cmd left{{{ echo rightspam }}}@zsh"right";"""
195 |     assert get_sorted_aot_completions(
196 |         complgen_binary_path, GRAMMAR, "cmd left"
197 |     ) == sorted(["leftright"])
198 | 
199 | 
200 | def test_mycargo(complgen_binary_path: Path):
201 |     GRAMMAR = r"""
202 | cargo [+<toolchain>] [<COMMAND>];
203 | <toolchain> ::= {{{ echo toolchain }}};
204 | <COMMAND> ::= t "Run the tests" <TESTNAME>;
205 | <TESTNAME> ::= {{{ echo testname }}};
206 | """
207 | 
208 |     assert get_sorted_aot_completions(
209 |         complgen_binary_path, GRAMMAR, "cargo t "
210 |     ) == sorted(["testname"])
211 | 
212 | 
213 | def test_matches_prefix(complgen_binary_path: Path):
214 |     GRAMMAR = """
215 | cargo +<toolchain> foo;
216 | cargo test --test testname;
217 | <toolchain> ::= stable-aarch64-apple-darwin | stable-x86_64-apple-darwin;
218 | """
219 |     assert get_sorted_aot_completions(
220 |         complgen_binary_path, GRAMMAR, "cargo +stable-aarch64-apple-darwin "
221 |     ) == sorted(["foo"])
222 | 
223 | 
224 | def test_completes_prefix(complgen_binary_path: Path):
225 |     GRAMMAR = """
226 | cargo +<toolchain>;
227 | <toolchain> ::= stable-aarch64-apple-darwin | stable-x86_64-apple-darwin;
228 | """
229 |     actual = [
230 |         s.split()
231 |         for s in get_sorted_aot_completions(complgen_binary_path, GRAMMAR, "cargo +")
232 |     ]
233 |     assert actual == sorted(
234 |         [
235 |             ["+stable-aarch64-apple-darwin", "stable-aarch64-apple-darwin"],
236 |             ["+stable-x86_64-apple-darwin", "stable-x86_64-apple-darwin"],
237 |         ]
238 |     )
239 | 
240 | 
241 | def test_completes_strace_expr(complgen_binary_path: Path):
242 |     actual = [
243 |         s.split()
244 |         for s in get_sorted_aot_completions(
245 |             complgen_binary_path, STRACE_EXPR_GRAMMAR, "strace -e "
246 |         )
247 |     ]
248 |     assert actual == sorted(
249 |         [
250 |             ["%file", "%file"],
251 |             ["!", "!"],
252 |             ["all", "all"],
253 |             ["fault", "fault"],
254 |             ["file", "file"],
255 |             ["read", "read"],
256 |             ["trace", "trace"],
257 |             ["write", "write"],
258 |         ]
259 |     )
260 | 
261 | 
262 | def test_completes_lsof_filter(complgen_binary_path: Path):
263 |     actual = [
264 |         s.split()
265 |         for s in get_sorted_aot_completions(
266 |             complgen_binary_path, LSOF_FILTER_GRAMMAR, "lsf -sTCP:"
267 |         )
268 |     ]
269 |     assert actual == sorted(
270 |         [
271 |             ["-sTCP:LISTEN", "LISTEN"],
272 |             ["-sTCP:CLOSED", "CLOSED"],
273 |             ["-sTCP:^", "^"],
274 |         ]
275 |     )
276 | 
277 | 
278 | def test_subword_completes_only_not_entered_yet(complgen_binary_path: Path):
279 |     GRAMMAR = r"""mygrep --color=(always | never | auto);"""
280 |     assert get_sorted_aot_completions(
281 |         complgen_binary_path, GRAMMAR, "mygrep --color="
282 |     ) == sorted(
283 |         ["--color=always always", "--color=never never ", "--color=auto auto  "]
284 |     )
285 | 
286 | 
287 | def test_subword_descriptions(complgen_binary_path: Path):
288 |     GRAMMAR = r"""cmd --option=(arg1 "descr1" | arg2 "descr2");"""
289 |     actual = [
290 |         s.split()
291 |         for s in get_sorted_aot_completions(
292 |             complgen_binary_path, GRAMMAR, "cmd --option="
293 |         )
294 |     ]
295 |     assert actual == sorted(
296 |         [
297 |             ["--option=arg1", "--option=arg1", "--", "descr1"],
298 |             ["--option=arg2", "--option=arg2", "--", "descr2"],
299 |         ]
300 |     )
301 | 
302 | 
303 | def test_subword_descriptions_bug(complgen_binary_path: Path):
304 |     GRAMMAR = r"""
305 | cmd --binary-files=<TYPE> "assume that binary files are <TYPE>";
306 | <TYPE> ::= binary "Search binary files but do not print them"
307 |          | text "Treat all files as text"
308 |          | without-match "Do not search binary files";
309 | """
310 |     actual = [
311 |         s.split(maxsplit=2)
312 |         for s in get_sorted_aot_completions(
313 |             complgen_binary_path, GRAMMAR, "cmd --binary-files="
314 |         )
315 |     ]
316 |     assert actual == sorted(
317 |         [
318 |             [
319 |                 "--binary-files=binary",
320 |                 "--binary-files=binary",
321 |                 "-- Search binary files but do not print them",
322 |             ],
323 |             [
324 |                 "--binary-files=text",
325 |                 "--binary-files=text",
326 |                 "-- Treat all files as text",
327 |             ],
328 |             [
329 |                 "--binary-files=without-match",
330 |                 "--binary-files=without-match",
331 |                 "-- Do not search binary files",
332 |             ],
333 |         ]
334 |     )
335 | 
336 | 
337 | def test_completes_subword_external_command(complgen_binary_path: Path):
338 |     GRAMMAR = r"""cmd --option={{{ echo -e "argument\tdescription" }}};"""
339 |     actual = [
340 |         s.split()
341 |         for s in get_sorted_aot_completions(
342 |             complgen_binary_path, GRAMMAR, "cmd --option="
343 |         )
344 |     ]
345 |     assert actual == sorted(
346 |         [
347 |             ["--option=argument", "argument", "--", "description"],
348 |         ]
349 |     )
350 | 
351 | 
352 | def test_description_special_characters(complgen_binary_path: Path):
353 |     GRAMMAR = r"""
354 | cmd --option "$f\"\\";
355 | """
356 |     actual = [
357 |         s.split()
358 |         for s in get_sorted_aot_completions(complgen_binary_path, GRAMMAR, "cmd --")
359 |     ]
360 |     assert actual == sorted([["--option", "--option", "--", '$f"\\']])
361 | 
362 | 
363 | def test_fallback_completes_default(complgen_binary_path: Path):
364 |     GRAMMAR = r"""cmd (foo || --bar);"""
365 |     assert get_sorted_aot_completions(complgen_binary_path, GRAMMAR, "cmd ") == sorted(
366 |         ["foo"]
367 |     )
368 | 
369 | 
370 | def test_fallbacks_on_no_matches(complgen_binary_path: Path):
371 |     GRAMMAR = r"""cmd (foo || --bar);"""
372 |     assert get_sorted_aot_completions(
373 |         complgen_binary_path, GRAMMAR, "cmd --"
374 |     ) == sorted(["--bar"])
375 | 
376 | 
377 | def test_subword_fallback_completes_default(complgen_binary_path: Path):
378 |     GRAMMAR = r"""cmd --option=(primary || secondary);"""
379 |     assert get_sorted_aot_completions(
380 |         complgen_binary_path, GRAMMAR, "cmd --option="
381 |     ) == sorted(["--option=primary primary"])
382 | 
383 | 
384 | def test_subword_fallbacks_on_no_matches(complgen_binary_path: Path):
385 |     GRAMMAR = r"""cmd --option=(primary || secondary);"""
386 |     assert get_sorted_aot_completions(
387 |         complgen_binary_path, GRAMMAR, "cmd --option=sec"
388 |     ) == sorted(["--option=secondary secondary"])
389 | 
390 | 
391 | def test_subword_fallback_bug(complgen_binary_path: Path):
392 |     GRAMMAR = r"""
393 | cmd (--color=<WHEN> || --color <WHEN> | --colour=<WHEN> | --colour <WHEN>);
394 | <WHEN> ::= always | never | auto;
395 | """
396 |     assert get_sorted_aot_completions(
397 |         complgen_binary_path, GRAMMAR, "cmd --colour"
398 |     ) == sorted(["--colour", "--colour= --colour="])
399 | 
400 | 
401 | def test_handles_quotes(complgen_binary_path: Path):
402 |     GRAMMAR = r"""cmd <ANYTHING> baz;"""
403 |     assert get_sorted_aot_completions(
404 |         complgen_binary_path, GRAMMAR, r'''cmd "foo bar" '''
405 |     ) == sorted(["baz"])
406 | 
407 | 
408 | 
409 | LITERALS_ALPHABET = string.ascii_letters + ":="
410 | 
411 | 
412 | @given(text(LITERALS_ALPHABET, min_size=1))
413 | @settings(max_examples=10, deadline=None)
414 | def test_handles_special_characters(complgen_binary_path: Path, literal: str):
415 |     GRAMMAR = """cmd {};""".format(literal)
416 |     assert get_sorted_aot_completions(complgen_binary_path, GRAMMAR, "cmd ") == [
417 |         literal
418 |     ]
419 | 


--------------------------------------------------------------------------------
/e2e/test_bash.py:
--------------------------------------------------------------------------------
  1 | import contextlib
  2 | import os
  3 | import string
  4 | import subprocess
  5 | import sys
  6 | import tempfile
  7 | from pathlib import Path
  8 | from typing import Generator
  9 | 
 10 | from common import LSOF_FILTER_GRAMMAR, STRACE_EXPR_GRAMMAR
 11 | from conftest import (
 12 |     get_bash_completion_sh_path,
 13 |     get_sorted_bash_completions,
 14 |     set_working_dir,
 15 | )
 16 | 
 17 | import pytest
 18 | from hypothesis import given, settings
 19 | from hypothesis.strategies import text
 20 | 
 21 | 
 22 | @contextlib.contextmanager
 23 | def completion_script_path(
 24 |     complgen_binary_path: Path, grammar: str
 25 | ) -> Generator[Path, None, None]:
 26 |     bash_script = subprocess.run(
 27 |         [complgen_binary_path, "--bash", "-", "-"],
 28 |         input=grammar.encode(),
 29 |         stdout=subprocess.PIPE,
 30 |         stderr=sys.stderr,
 31 |         check=True,
 32 |     ).stdout
 33 |     with tempfile.NamedTemporaryFile() as f:
 34 |         f.write("source {}\n".format(get_bash_completion_sh_path()).encode())
 35 |         f.write(bash_script)
 36 |         f.flush()
 37 |         yield Path(f.name)
 38 | 
 39 | 
 40 | SPECIAL_CHARACTERS = "?[^a]*{foo,*bar}"
 41 | 
 42 | 
 43 | def test_completes_paths(complgen_binary_path: Path):
 44 |     with completion_script_path(
 45 |         complgen_binary_path, """cmd <PATH> [--help];"""
 46 |     ) as completions_file_path:
 47 |         with tempfile.TemporaryDirectory() as dir:
 48 |             with set_working_dir(Path(dir)):
 49 |                 Path("filename with spaces").write_text("dummy")
 50 |                 Path(SPECIAL_CHARACTERS).write_text("dummy")
 51 |                 os.mkdir("baz")
 52 |                 completions = get_sorted_bash_completions(
 53 |                     completions_file_path,
 54 |                     '''COMP_WORDS=(cmd); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"''',
 55 |                 )
 56 |                 assert completions == sorted(
 57 |                     ["filename with spaces", SPECIAL_CHARACTERS, "baz"]
 58 |                 )
 59 | 
 60 | 
 61 | def test_completes_directories(complgen_binary_path: Path):
 62 |     with completion_script_path(
 63 |         complgen_binary_path, """cmd <DIRECTORY> [--help];"""
 64 |     ) as completions_file_path:
 65 |         with tempfile.TemporaryDirectory() as dir:
 66 |             with set_working_dir(Path(dir)):
 67 |                 os.mkdir("dir with spaces")
 68 |                 os.mkdir(SPECIAL_CHARACTERS)
 69 |                 Path("baz").write_text("dummy")
 70 |                 completions = get_sorted_bash_completions(
 71 |                     completions_file_path,
 72 |                     '''COMP_WORDS=(cmd); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"''',
 73 |                 )
 74 |                 assert completions == sorted(["dir with spaces", SPECIAL_CHARACTERS])
 75 | 
 76 | 
 77 | def test_bash_uses_correct_transition_with_duplicated_literals(
 78 |     complgen_binary_path: Path,
 79 | ):
 80 |     GRAMMAR = """
 81 | cmd <COMMAND> [--help];
 82 | 
 83 | <COMMAND> ::= rm           "Remove a project" <RM-OPTION>
 84 |             | remote       "Manage a project's remotes" [<REMOTE-SUBCOMMAND>]
 85 |             ;
 86 | 
 87 | <REMOTE-SUBCOMMAND> ::= rm <name>;
 88 | """
 89 | 
 90 |     with completion_script_path(complgen_binary_path, GRAMMAR) as completions_file_path:
 91 |         assert get_sorted_bash_completions(
 92 |             completions_file_path,
 93 |             r"""COMP_WORDS=(cmd remote); COMP_CWORD=2; _cmd; if [[ ${#COMPREPLY[@]} -gt 0 ]]; then printf '%s\n' "${COMPREPLY[@]}"; fi""",
 94 |         ) == sorted(["--help ", "rm "])
 95 |         assert get_sorted_bash_completions(
 96 |             completions_file_path,
 97 |             r"""COMP_WORDS=(cmd rm); COMP_CWORD=2; _cmd; if [[ ${#COMPREPLY[@]} -gt 0 ]]; then printf '%s\n' "${COMPREPLY[@]}"; fi""",
 98 |         ) == sorted([])
 99 | 
100 | 
101 | def test_bash_external_command_produces_description(complgen_binary_path: Path):
102 |     GRAMMAR = r"""
103 | cmd {{{ echo -e "completion\tdescription" }}};
104 | """
105 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
106 |         input = (
107 |             r'''COMP_WORDS=(cmd); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
108 |         )
109 |         assert get_sorted_bash_completions(path, input) == sorted(["completion"])
110 | 
111 | 
112 | def test_specializes_for_bash(complgen_binary_path: Path):
113 |     GRAMMAR = (
114 |         """cmd <FOO>; <FOO> ::= {{{ echo foo }}}; <FOO@bash> ::= {{{ echo bash }}};"""
115 |     )
116 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
117 |         input = (
118 |             r'''COMP_WORDS=(cmd); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
119 |         )
120 |         assert get_sorted_bash_completions(path, input) == sorted(["bash"])
121 | 
122 | 
123 | def test_specializes_for_bash_with_regex(complgen_binary_path: Path):
124 |     GRAMMAR = (
125 |         """cmd <FOO>bar; <FOO> ::= {{{ echo foo }}}; <FOO@bash> ::= {{{ echo bash }}}@bash"bash";"""
126 |     )
127 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
128 |         input = (
129 |             r'''COMP_WORDS=(cmd bash); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
130 |         )
131 |         assert get_sorted_bash_completions(path, input) == sorted(["bashbar"])
132 | 
133 | 
134 | def test_nontail_matching_alternative(complgen_binary_path: Path):
135 |     GRAMMAR = """cmd <LEFT> | right; <LEFT> ::= {{{ echo left }}}@bash"left";"""
136 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
137 |         input = r'''COMP_WORDS=(cmd rig); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
138 |         assert get_sorted_bash_completions(path, input) == sorted(["right"])
139 | 
140 | 
141 | def test_nontail_matching_fallback(complgen_binary_path: Path):
142 |     GRAMMAR = """cmd <LEFT> || right; <LEFT> ::= {{{ echo left }}}@bash"left";"""
143 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
144 |         input = r'''COMP_WORDS=(cmd rig); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
145 |         assert get_sorted_bash_completions(path, input) == sorted(["right"])
146 | 
147 | 
148 | def test_nontail_matching_subword(complgen_binary_path: Path):
149 |     GRAMMAR = """cmd {{{ echo left }}}@bash"left";"""
150 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
151 |         input = r'''COMP_WORDS=(cmd left); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
152 |         assert get_sorted_bash_completions(path, input) == sorted(["left"])
153 | 
154 | 
155 | def test_nontail_completion(complgen_binary_path: Path):
156 |     GRAMMAR = """cmd {{{ echo left }}}@bash"left";"""
157 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
158 |         input = r'''COMP_WORDS=(cmd left); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
159 |         assert get_sorted_bash_completions(path, input) == sorted(["left"])
160 | 
161 | 
162 | def test_nontail_completion_subword(complgen_binary_path: Path):
163 |     GRAMMAR = """cmd left{{{ echo right }}}@bash"right";"""
164 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
165 |         input = r'''COMP_WORDS=(cmd left); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
166 |         assert get_sorted_bash_completions(path, input) == sorted(["leftright"])
167 | 
168 | 
169 | def test_nontail_completion_truncates_to_regex(complgen_binary_path: Path):
170 |     GRAMMAR = """cmd {{{ echo leftspam }}}@bash"left";"""
171 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
172 |         input = r'''COMP_WORDS=(cmd left); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
173 |         assert get_sorted_bash_completions(path, input) == sorted(["left"])
174 | 
175 | 
176 | def test_nontail_completion_subword_truncates_to_regex(complgen_binary_path: Path):
177 |     GRAMMAR = """cmd left{{{ echo rightspam }}}@bash"right";"""
178 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
179 |         input = r'''COMP_WORDS=(cmd left); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
180 |         assert get_sorted_bash_completions(path, input) == sorted(["leftright"])
181 | 
182 | 
183 | def test_mycargo(complgen_binary_path: Path):
184 |     GRAMMAR = r"""
185 | mycargo test <TESTNAME>;
186 | <TESTNAME> ::= {{{ echo foo; echo bar }}};
187 | """
188 |     with completion_script_path(complgen_binary_path, GRAMMAR) as completions_file_path:
189 |         assert get_sorted_bash_completions(
190 |             completions_file_path,
191 |             r"""COMP_WORDS=(mycargo test); COMP_CWORD=2; _mycargo; if [[ ${#COMPREPLY[@]} -gt 0 ]]; then printf '%s\n' "${COMPREPLY[@]}"; fi""",
192 |         ) == sorted(["foo", "bar"])
193 | 
194 | 
195 | def test_matches_prefix(complgen_binary_path: Path):
196 |     GRAMMAR = """
197 | cargo +<toolchain> foo;
198 | cargo test --test testname;
199 | <toolchain> ::= stable-aarch64-apple-darwin | stable-x86_64-apple-darwin;
200 | """
201 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
202 |         input = r'''COMP_WORDS=(cargo +stable-aarch64-apple-darwin); COMP_CWORD=2; _cargo; printf '%s\n' "${COMPREPLY[@]}"'''
203 |         assert get_sorted_bash_completions(path, input) == sorted(["foo "])
204 | 
205 | 
206 | def test_completes_prefix(complgen_binary_path: Path):
207 |     GRAMMAR = """
208 | cargo +<toolchain>;
209 | <toolchain> ::= stable-aarch64-apple-darwin | stable-x86_64-apple-darwin;
210 | """
211 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
212 |         input = r'''COMP_WORDS=(cargo +); COMP_CWORD=1; _cargo; printf '%s\n' "${COMPREPLY[@]}"'''
213 |         assert get_sorted_bash_completions(path, input) == sorted(
214 |             ["+stable-aarch64-apple-darwin", "+stable-x86_64-apple-darwin"]
215 |         )
216 | 
217 | 
218 | def test_completes_strace_expr(complgen_binary_path: Path):
219 |     with completion_script_path(complgen_binary_path, STRACE_EXPR_GRAMMAR) as path:
220 |         input = r'''COMP_WORDS=(strace -e trace=); COMP_CWORD=2; _strace; printf '%s\n' "${COMPREPLY[@]}"'''
221 |         assert get_sorted_bash_completions(path, input) == sorted(
222 |             ["!", "%file", "file", "all"]
223 |         )
224 | 
225 | 
226 | def test_completes_lsof_filter(complgen_binary_path: Path):
227 |     with completion_script_path(complgen_binary_path, LSOF_FILTER_GRAMMAR) as path:
228 |         input = r'''COMP_WORDS=(lsf -sTCP:); COMP_CWORD=1; _lsf; printf '%s\n' "${COMPREPLY[@]}"'''
229 |         assert get_sorted_bash_completions(path, input) == sorted(
230 |             ["LISTEN", "CLOSED", "^"]
231 |         )
232 | 
233 | 
234 | def test_subword_descriptions(complgen_binary_path: Path):
235 |     GRAMMAR = r"""cmd --option=(arg1 "descr1" | arg2 "descr2");"""
236 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
237 |         input = r'''COMP_WORDS=(cmd --option=); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
238 |         assert get_sorted_bash_completions(path, input) == sorted(["arg1", "arg2"])
239 | 
240 | 
241 | def test_completes_subword_external_command(complgen_binary_path: Path):
242 |     GRAMMAR = r"""cmd --option={{{ echo -e "argument\tdescription" }}};"""
243 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
244 |         input = r'''COMP_WORDS=(cmd --option=); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
245 |         assert get_sorted_bash_completions(path, input) == sorted(["argument"])
246 | 
247 | 
248 | def test_subword_specialization(complgen_binary_path: Path):
249 |     GRAMMAR = r"""
250 | cmd --option=<FOO>;
251 | <FOO> ::= {{{ echo generic }}};
252 | <FOO@bash> ::= {{{ echo bash }}};
253 | """
254 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
255 |         input = r'''COMP_WORDS=(cmd --option=); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
256 |         assert get_sorted_bash_completions(path, input) == sorted(["bash"])
257 | 
258 | 
259 | # https://github.com/adaszko/complgen/issues/41
260 | def test_respects_ignore_case_option(complgen_binary_path: Path):
261 |     GRAMMAR = r"""cmd --case-lower | --CASE-UPPER;"""
262 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
263 |         input = r'''COMP_WORDS=(cmd --case-); COMP_CWORD=1; bind "set completion-ignore-case on"; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
264 |         assert get_sorted_bash_completions(path, input) == sorted(
265 |             ["--case-lower", "--CASE-UPPER"]
266 |         )
267 | 
268 |         input = r'''COMP_WORDS=(cmd --case-); COMP_CWORD=1; bind "set completion-ignore-case off"; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
269 |         assert get_sorted_bash_completions(path, input) == sorted(["--case-lower"])
270 | 
271 | 
272 | def test_respects_ignore_case_option_subwords(complgen_binary_path: Path):
273 |     GRAMMAR = r"""cmd --option=(lower | UPPER);"""
274 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
275 |         input = r'''COMP_WORDS=(cmd --option=LO); COMP_CWORD=1; bind "set completion-ignore-case on"; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
276 |         assert get_sorted_bash_completions(path, input) == sorted(["lower"])
277 | 
278 |         input = r'''COMP_WORDS=(cmd --option=LO); COMP_CWORD=1; bind "set completion-ignore-case off"; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
279 |         assert get_sorted_bash_completions(path, input) == sorted([""])
280 | 
281 | 
282 | def test_fallback_completes_default(complgen_binary_path: Path):
283 |     GRAMMAR = r"""cmd (foo || --bar);"""
284 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
285 |         input = (
286 |             r'''COMP_WORDS=(cmd); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
287 |         )
288 |         assert get_sorted_bash_completions(path, input) == sorted(["foo "])
289 | 
290 | 
291 | def test_fallbacks_on_no_matches(complgen_binary_path: Path):
292 |     GRAMMAR = r"""cmd (foo || --bar);"""
293 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
294 |         input = r'''COMP_WORDS=(cmd --); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
295 |         assert get_sorted_bash_completions(path, input) == sorted(["--bar"])
296 | 
297 | 
298 | def test_subword_fallback_completes_default(complgen_binary_path: Path):
299 |     GRAMMAR = r"""cmd --option=(primary || secondary);"""
300 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
301 |         input = r'''COMP_WORDS=(cmd --option=); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
302 |         assert get_sorted_bash_completions(path, input) == sorted(["primary"])
303 | 
304 | 
305 | def test_subword_fallbacks_on_no_matches(complgen_binary_path: Path):
306 |     GRAMMAR = r"""cmd --option=(primary || secondary);"""
307 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
308 |         input = r'''COMP_WORDS=(cmd --option=sec); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
309 |         assert get_sorted_bash_completions(path, input) == sorted(["secondary"])
310 | 
311 | 
312 | def test_handles_quotes(complgen_binary_path: Path):
313 |     GRAMMAR = r"""cmd <ANYTHING> baz;"""
314 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
315 |         input = r'''COMP_WORDS=(cmd "foo bar"); COMP_CWORD=2; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
316 |         assert get_sorted_bash_completions(path, input) == sorted(["baz "])
317 | 
318 | 
319 | LITERALS_ALPHABET = string.ascii_letters + ":="
320 | 
321 | 
322 | @given(text(LITERALS_ALPHABET, min_size=1))
323 | @settings(max_examples=10, deadline=None)
324 | def test_handles_special_characters(complgen_binary_path: Path, literal: str):
325 |     GRAMMAR = """cmd {};""".format(literal)
326 |     with completion_script_path(complgen_binary_path, GRAMMAR) as path:
327 |         input = (
328 |             r'''COMP_WORDS=(cmd); COMP_CWORD=1; _cmd; printf '%s\n' "${COMPREPLY[@]}"'''
329 |         )
330 |         assert get_sorted_bash_completions(path, input) == sorted([literal + " "])
331 | 


--------------------------------------------------------------------------------
/e2e/test_fish.py:
--------------------------------------------------------------------------------
  1 | import os
  2 | import string
  3 | import tempfile
  4 | from pathlib import Path
  5 | 
  6 | from common import LSOF_FILTER_GRAMMAR, STRACE_EXPR_GRAMMAR
  7 | from conftest import (
  8 |     gen_fish_aot_completion_script_path,
  9 |     get_sorted_fish_completions,
 10 |     set_working_dir,
 11 | )
 12 | 
 13 | import pytest
 14 | from hypothesis import given, settings
 15 | from hypothesis.strategies import text
 16 | 
 17 | 
 18 | def test_fish_uses_correct_description_with_duplicated_literals(
 19 |     complgen_binary_path: Path,
 20 | ):
 21 |     GRAMMAR = """
 22 | cmd <COMMAND> [--help];
 23 | 
 24 | <COMMAND> ::= rm           "Remove a project" <RM-OPTION>
 25 |             | remote       "Manage a project's remotes" [<REMOTE-SUBCOMMAND>]
 26 |             ;
 27 | 
 28 | <REMOTE-SUBCOMMAND> ::= rm <name>;
 29 | """
 30 | 
 31 |     with gen_fish_aot_completion_script_path(
 32 |         complgen_binary_path, GRAMMAR
 33 |     ) as completions_file_path:
 34 |         input = 'complete --do-complete "cmd "'
 35 |         assert get_sorted_fish_completions(completions_file_path, input) == sorted(
 36 |             [("rm", "Remove a project"), ("remote", "Manage a project's remotes")],
 37 |             key=lambda pair: pair[0],
 38 |         )
 39 | 
 40 | 
 41 | def test_fish_uses_correct_description_with_duplicated_descriptions(
 42 |     complgen_binary_path: Path,
 43 | ):
 44 |     GRAMMAR = """
 45 | cmd [<OPTION>]...;
 46 | 
 47 | <OPTION> ::= --color    "use markers to highlight the matching strings" [<WHEN>]
 48 |            | --colour   "use markers to highlight the matching strings" [<WHEN>]
 49 |            ;
 50 | """
 51 | 
 52 |     with gen_fish_aot_completion_script_path(
 53 |         complgen_binary_path, GRAMMAR
 54 |     ) as completions_file_path:
 55 |         input = 'complete --do-complete "cmd "'
 56 |         assert get_sorted_fish_completions(completions_file_path, input) == sorted(
 57 |             [
 58 |                 ("--color", "use markers to highlight the matching strings"),
 59 |                 ("--colour", "use markers to highlight the matching strings"),
 60 |             ],
 61 |             key=lambda pair: pair[0],
 62 |         )
 63 | 
 64 | 
 65 | def test_fish_external_command_produces_description(complgen_binary_path: Path):
 66 |     GRAMMAR = r"""
 67 | cmd {{{ echo -e "completion\tdescription" }}};
 68 | """
 69 | 
 70 |     with gen_fish_aot_completion_script_path(
 71 |         complgen_binary_path, GRAMMAR
 72 |     ) as completions_file_path:
 73 |         input = 'complete --do-complete "cmd "'
 74 |         assert get_sorted_fish_completions(completions_file_path, input) == [
 75 |             ("completion", "description")
 76 |         ]
 77 | 
 78 | 
 79 | SPECIAL_CHARACTERS = "?[^a]*{foo,*bar}"
 80 | 
 81 | 
 82 | def test_completes_paths(complgen_binary_path: Path):
 83 |     with gen_fish_aot_completion_script_path(
 84 |         complgen_binary_path, """cmd <PATH> [--help];"""
 85 |     ) as completions_file_path:
 86 |         with tempfile.TemporaryDirectory() as dir:
 87 |             with set_working_dir(Path(dir)):
 88 |                 Path("filename with spaces").write_text("dummy")
 89 |                 Path(SPECIAL_CHARACTERS).write_text("dummy")
 90 |                 os.mkdir("dir with spaces")
 91 |                 input = 'complete --do-complete "cmd "'
 92 |                 completions = get_sorted_fish_completions(completions_file_path, input)
 93 |                 assert completions == sorted(
 94 |                     [
 95 |                         (SPECIAL_CHARACTERS, ""),
 96 |                         ("dir with spaces/", ""),
 97 |                         ("filename with spaces", ""),
 98 |                     ]
 99 |                 )
100 | 
101 | 
102 | def test_completes_directories(complgen_binary_path: Path):
103 |     with gen_fish_aot_completion_script_path(
104 |         complgen_binary_path, """cmd <DIRECTORY> [--help];"""
105 |     ) as completions_file_path:
106 |         with tempfile.TemporaryDirectory() as dir:
107 |             with set_working_dir(Path(dir)):
108 |                 os.mkdir("dir with spaces")
109 |                 os.mkdir(SPECIAL_CHARACTERS)
110 |                 Path("baz").write_text("dummy")
111 |                 input = 'complete --do-complete "cmd "'
112 |                 completions = get_sorted_fish_completions(completions_file_path, input)
113 |                 assert completions == sorted(
114 |                     [
115 |                         (SPECIAL_CHARACTERS + "/", "Directory"),
116 |                         ("dir with spaces/", "Directory"),
117 |                     ]
118 |                 )
119 | 
120 | 
121 | def test_specializes_for_fish(complgen_binary_path: Path):
122 |     GRAMMAR = (
123 |         """cmd <FOO>; <FOO> ::= {{{ echo foo }}}; <FOO@fish> ::= {{{ echo fish }}};"""
124 |     )
125 |     with gen_fish_aot_completion_script_path(
126 |         complgen_binary_path, GRAMMAR
127 |     ) as completions_file_path:
128 |         input = 'complete --do-complete "cmd "'
129 |         assert get_sorted_fish_completions(completions_file_path, input) == [
130 |             ("fish", "")
131 |         ]
132 | 
133 | 
134 | def test_specializes_for_fish_with_regex(complgen_binary_path: Path):
135 |     GRAMMAR = (
136 |         """cmd <FOO>bar; <FOO> ::= {{{ echo foo }}}; <FOO@fish> ::= {{{ echo fish }}}@fish"fish";"""
137 |     )
138 |     with gen_fish_aot_completion_script_path(
139 |         complgen_binary_path, GRAMMAR
140 |     ) as completions_file_path:
141 |         input = 'complete --do-complete "cmd fish"'
142 |         assert get_sorted_fish_completions(completions_file_path, input) == [
143 |             ("fishbar", "")
144 |         ]
145 | 
146 | 
147 | def test_nontail_matching_alternative(complgen_binary_path: Path):
148 |     GRAMMAR = """cmd <LEFT> | right; <LEFT> ::= {{{ echo left }}}@fish"left";"""
149 |     with gen_fish_aot_completion_script_path(
150 |         complgen_binary_path, GRAMMAR
151 |     ) as completions_file_path:
152 |         input = 'complete --do-complete "cmd rig"'
153 |         assert get_sorted_fish_completions(completions_file_path, input) == [
154 |             ("right", "")
155 |         ]
156 | 
157 | 
158 | def test_nontail_matching_fallback(complgen_binary_path: Path):
159 |     GRAMMAR = """cmd <LEFT> || right; <LEFT> ::= {{{ echo left }}}@fish"left";"""
160 |     with gen_fish_aot_completion_script_path(
161 |         complgen_binary_path, GRAMMAR
162 |     ) as completions_file_path:
163 |         input = 'complete --do-complete "cmd rig"'
164 |         assert get_sorted_fish_completions(completions_file_path, input) == [
165 |             ("right", "")
166 |         ]
167 | 
168 | 
169 | def test_nontail_matching_subword(complgen_binary_path: Path):
170 |     GRAMMAR = """cmd <LEFT>right; <LEFT> ::= {{{ echo left }}}@fish"left";"""
171 |     with gen_fish_aot_completion_script_path(
172 |         complgen_binary_path, GRAMMAR
173 |     ) as completions_file_path:
174 |         input = 'complete --do-complete "cmd left"'
175 |         assert get_sorted_fish_completions(completions_file_path, input) == [
176 |             ("leftright", "")
177 |         ]
178 | 
179 | 
180 | def test_nontail_completion(complgen_binary_path: Path):
181 |     GRAMMAR = """cmd {{{ echo left }}}@fish"left";"""
182 |     with gen_fish_aot_completion_script_path(
183 |         complgen_binary_path, GRAMMAR
184 |     ) as completions_file_path:
185 |         input = 'complete --do-complete "cmd "'
186 |         assert get_sorted_fish_completions(completions_file_path, input) == [
187 |             ("left", "")
188 |         ]
189 | 
190 | 
191 | def test_nontail_completion_subword(complgen_binary_path: Path):
192 |     GRAMMAR = """cmd {{{ echo left }}}@fish"left"right;"""
193 |     with gen_fish_aot_completion_script_path(
194 |         complgen_binary_path, GRAMMAR
195 |     ) as completions_file_path:
196 |         input = 'complete --do-complete "cmd left"'
197 |         assert get_sorted_fish_completions(completions_file_path, input) == [
198 |             ("leftright", "")
199 |         ]
200 | 
201 | 
202 | def test_nontail_completion_truncates_to_regex(complgen_binary_path: Path):
203 |     GRAMMAR = """cmd {{{ echo leftspam }}}@fish"left";"""
204 |     with gen_fish_aot_completion_script_path(
205 |         complgen_binary_path, GRAMMAR
206 |     ) as completions_file_path:
207 |         input = 'complete --do-complete "cmd "'
208 |         assert get_sorted_fish_completions(completions_file_path, input) == [
209 |             ("left", "")
210 |         ]
211 | 
212 | 
213 | def test_nontail_completion_subword_truncates_to_regex(complgen_binary_path: Path):
214 |     GRAMMAR = """cmd {{{ echo leftspam }}}@fish"left"right;"""
215 |     with gen_fish_aot_completion_script_path(
216 |         complgen_binary_path, GRAMMAR
217 |     ) as completions_file_path:
218 |         input = 'complete --do-complete "cmd left"'
219 |         assert get_sorted_fish_completions(completions_file_path, input) == [
220 |             ("leftright", "")
221 |         ]
222 | 
223 | 
224 | def test_matches_prefix(complgen_binary_path: Path):
225 |     GRAMMAR = """
226 | cmd +<toolchain> foo;
227 | cmd test --test testname;
228 | <toolchain> ::= stable-aarch64-apple-darwin | stable-x86_64-apple-darwin;
229 | """
230 |     with gen_fish_aot_completion_script_path(
231 |         complgen_binary_path, GRAMMAR
232 |     ) as completions_file_path:
233 |         input = 'complete --do-complete "cmd +stable-aarch64-apple-darwin "'
234 |         completions = get_sorted_fish_completions(completions_file_path, input)
235 |         assert completions == sorted([("foo", "")])
236 | 
237 | 
238 | def test_completes_prefix(complgen_binary_path: Path):
239 |     GRAMMAR = """
240 | cargo +<toolchain>;
241 | <toolchain> ::= stable-aarch64-apple-darwin | stable-x86_64-apple-darwin;
242 | """
243 |     with gen_fish_aot_completion_script_path(
244 |         complgen_binary_path, GRAMMAR
245 |     ) as completions_file_path:
246 |         input = 'complete --do-complete "cargo +"'
247 |         completions = get_sorted_fish_completions(completions_file_path, input)
248 |         assert completions == sorted(
249 |             [("+stable-aarch64-apple-darwin", ""), ("+stable-x86_64-apple-darwin", "")]
250 |         )
251 | 
252 | 
253 | def test_completes_strace_expr(complgen_binary_path: Path):
254 |     with gen_fish_aot_completion_script_path(
255 |         complgen_binary_path, STRACE_EXPR_GRAMMAR
256 |     ) as completions_file_path:
257 |         input = 'complete --do-complete "strace -e "'
258 |         completions = get_sorted_fish_completions(completions_file_path, input)
259 |         assert completions == sorted(
260 |             [
261 |                 ("!", ""),
262 |                 ("%file", ""),
263 |                 ("file", ""),
264 |                 ("all", ""),
265 |                 ("read", ""),
266 |                 ("trace", ""),
267 |                 ("write", ""),
268 |                 ("fault", ""),
269 |             ]
270 |         )
271 | 
272 | 
273 | def test_completes_lsof_filter(complgen_binary_path: Path):
274 |     with gen_fish_aot_completion_script_path(
275 |         complgen_binary_path, LSOF_FILTER_GRAMMAR
276 |     ) as completions_file_path:
277 |         input = 'complete --do-complete "lsf "'
278 |         completions = get_sorted_fish_completions(completions_file_path, input)
279 |         assert completions == sorted([("-s", "")])
280 | 
281 | 
282 | def test_issue_59(complgen_binary_path: Path):
283 |     GRAMMAR = """hello [ id=<ID> | foo ]...;"""
284 |     with gen_fish_aot_completion_script_path(
285 |         complgen_binary_path, GRAMMAR
286 |     ) as completions_file_path:
287 |         input = 'complete --do-complete "hello id=42 "'
288 |         completions = get_sorted_fish_completions(completions_file_path, input)
289 |         assert completions == sorted([("foo", ""), ("id=", "")])
290 | 
291 | 
292 | def test_subword_descriptions(complgen_binary_path: Path):
293 |     GRAMMAR = r"""cmd --option=(arg1 "descr1" | arg2 "descr2");"""
294 |     with gen_fish_aot_completion_script_path(
295 |         complgen_binary_path, GRAMMAR
296 |     ) as completions_file_path:
297 |         input = 'complete --do-complete "cmd --option="'
298 |         assert get_sorted_fish_completions(completions_file_path, input) == [
299 |             ("--option=arg1", "descr1"),
300 |             ("--option=arg2", "descr2"),
301 |         ]
302 | 
303 | 
304 | def test_completes_subword_external_command(complgen_binary_path: Path):
305 |     GRAMMAR = r"""cmd --option={{{ echo -e "argument\tdescription" }}};"""
306 |     with gen_fish_aot_completion_script_path(
307 |         complgen_binary_path, GRAMMAR
308 |     ) as completions_file_path:
309 |         input = 'complete --do-complete "cmd --option="'
310 |         assert get_sorted_fish_completions(completions_file_path, input) == [
311 |             ("--option=argument", "description")
312 |         ]
313 | 
314 | 
315 | def test_subword_specialization(complgen_binary_path: Path):
316 |     GRAMMAR = r"""
317 | cmd --option=<FOO>;
318 | <FOO> ::= {{{ echo generic }}};
319 | <FOO@fish> ::= {{{ echo fish }}};
320 | """
321 |     with gen_fish_aot_completion_script_path(
322 |         complgen_binary_path, GRAMMAR
323 |     ) as completions_file_path:
324 |         input = 'complete --do-complete "cmd --option="'
325 |         assert get_sorted_fish_completions(completions_file_path, input) == [
326 |             ("--option=fish", "")
327 |         ]
328 | 
329 | 
330 | def test_description_special_characters(complgen_binary_path: Path):
331 |     GRAMMAR = r"""
332 | cmd --option "$f\"\\";
333 | """
334 |     with gen_fish_aot_completion_script_path(
335 |         complgen_binary_path, GRAMMAR
336 |     ) as completions_file_path:
337 |         input = 'complete --do-complete "cmd --option"'
338 |         assert get_sorted_fish_completions(completions_file_path, input) == [
339 |             ("--option", '$f"\\')
340 |         ]
341 | 
342 | 
343 | def test_fallback_completes_default(complgen_binary_path: Path):
344 |     GRAMMAR = r"""cmd (foo || --bar);"""
345 |     with gen_fish_aot_completion_script_path(
346 |         complgen_binary_path, GRAMMAR
347 |     ) as completions_file_path:
348 |         input = 'complete --do-complete "cmd "'
349 |         assert get_sorted_fish_completions(completions_file_path, input) == sorted(
350 |             [("foo", "")]
351 |         )
352 | 
353 | 
354 | def test_fallbacks_on_no_matches(complgen_binary_path: Path):
355 |     GRAMMAR = r"""cmd (foo || --bar);"""
356 |     with gen_fish_aot_completion_script_path(
357 |         complgen_binary_path, GRAMMAR
358 |     ) as completions_file_path:
359 |         input = 'complete --do-complete "cmd --"'
360 |         assert get_sorted_fish_completions(completions_file_path, input) == sorted(
361 |             [("--bar", "")]
362 |         )
363 | 
364 | 
365 | def test_subword_fallback_completes_default(complgen_binary_path: Path):
366 |     GRAMMAR = r"""cmd --option=(primary || secondary);"""
367 |     with gen_fish_aot_completion_script_path(
368 |         complgen_binary_path, GRAMMAR
369 |     ) as completions_file_path:
370 |         input = 'complete --do-complete "cmd --option="'
371 |         assert get_sorted_fish_completions(completions_file_path, input) == sorted(
372 |             [("--option=primary", "")]
373 |         )
374 | 
375 | 
376 | def test_subword_fallbacks_on_no_matches(complgen_binary_path: Path):
377 |     GRAMMAR = r"""cmd --option=(primary || secondary);"""
378 |     with gen_fish_aot_completion_script_path(
379 |         complgen_binary_path, GRAMMAR
380 |     ) as completions_file_path:
381 |         input = 'complete --do-complete "cmd --option=sec"'
382 |         assert get_sorted_fish_completions(completions_file_path, input) == sorted(
383 |             [("--option=secondary", "")]
384 |         )
385 | 
386 | 
387 | def test_handles_quotes(complgen_binary_path: Path):
388 |     GRAMMAR = r"""cmd <ANYTHING> baz;"""
389 |     with gen_fish_aot_completion_script_path(
390 |         complgen_binary_path, GRAMMAR
391 |     ) as completions_file_path:
392 |         input = '''complete --do-complete 'cmd "foo bar" ' '''
393 |         assert get_sorted_fish_completions(completions_file_path, input) == sorted(
394 |             [("baz", "")]
395 |         )
396 | 
397 | 
398 | LITERALS_ALPHABET = string.ascii_letters + ":="
399 | 
400 | 
401 | @given(text(LITERALS_ALPHABET, min_size=1))
402 | @settings(max_examples=10, deadline=None)
403 | def test_handles_special_characters(complgen_binary_path: Path, literal: str):
404 |     GRAMMAR = """cmd {};""".format(literal)
405 |     with gen_fish_aot_completion_script_path(
406 |         complgen_binary_path, GRAMMAR
407 |     ) as completions_file_path:
408 |         input = 'complete --do-complete "cmd "'
409 |         assert get_sorted_fish_completions(completions_file_path, input) == sorted(
410 |             [(literal, "")]
411 |         )
412 | 


--------------------------------------------------------------------------------
/e2e/test_validation.py:
--------------------------------------------------------------------------------
  1 | import glob
  2 | import subprocess
  3 | from pathlib import Path
  4 | 
  5 | import pytest
  6 | from inline_snapshot import snapshot
  7 | 
  8 | 
  9 | def complgen_check_path(complgen_binary_path: Path, path: str) -> subprocess.CompletedProcess:
 10 |     return subprocess.run(
 11 |         [complgen_binary_path, '--bash', '/dev/null', path],
 12 |         capture_output=True,
 13 |         text=True,
 14 |     )
 15 | 
 16 | 
 17 | def test_examples(complgen_binary_path: Path, examples_directory_path: Path):
 18 |     for usage_file_path in glob.glob(str(examples_directory_path / "*.usage")):
 19 |         r = complgen_check_path(complgen_binary_path, usage_file_path)
 20 |         assert r.returncode == 0, usage_file_path
 21 | 
 22 | 
 23 | def test_complgen_example(complgen_binary_path: Path, examples_directory_path: Path):
 24 |     r = complgen_check_path(complgen_binary_path, str(examples_directory_path / "complgen.usage"))
 25 |     assert r.returncode == 0
 26 |     assert r.stderr == snapshot('')
 27 | 
 28 | 
 29 | def complgen_check(complgen_binary_path: Path, grammar: str) -> subprocess.CompletedProcess:
 30 |     args = [complgen_binary_path, "--bash", "-", "-"]
 31 |     result = subprocess.run(
 32 |         args,
 33 |         input=grammar,
 34 |         capture_output=True,
 35 |         text=True,
 36 |     )
 37 |     return result
 38 | 
 39 | 
 40 | def test_ambiguous_transition1(complgen_binary_path: Path):
 41 |     assert complgen_check(complgen_binary_path, """cmd {{{ echo foo }}} {{{ echo bar }}};""").returncode == 0
 42 | 
 43 | 
 44 | def test_ambiguous_transition2(complgen_binary_path: Path):
 45 |     r = complgen_check(complgen_binary_path, """cmd {{{ echo foo }}} | {{{ echo bar }}};""")
 46 |     assert r.returncode == 1
 47 |     assert r.stderr == snapshot("""\
 48 | -:1:5:error: Ambiguous grammar.  Matching can't differentiate:
 49 |   |
 50 | 1 | cmd {{{ echo foo }}} | {{{ echo bar }}};
 51 |   |     ^^^^^^^^^^^^^^^^
 52 |   |
 53 | -:1:24:error: and:
 54 |   |
 55 | 1 | cmd {{{ echo foo }}} | {{{ echo bar }}};
 56 |   |                        ^^^^^^^^^^^^^^^^
 57 |   |
 58 | """)
 59 | 
 60 | def test_ambiguous_transition3(complgen_binary_path: Path):
 61 |     assert complgen_check(complgen_binary_path, """cmd (foo | {{{ echo bar }}});""").returncode == 0
 62 | 
 63 | def test_ambiguous_transition4(complgen_binary_path: Path):
 64 |     r = complgen_check(complgen_binary_path, """cmd {{{ echo foo }}} || {{{ echo bar }}};""")
 65 |     assert r.returncode == 1
 66 |     assert r.stderr == snapshot("""\
 67 | -:1:5:error: Ambiguous grammar.  Matching can't differentiate:
 68 |   |
 69 | 1 | cmd {{{ echo foo }}} || {{{ echo bar }}};
 70 |   |     ^^^^^^^^^^^^^^^^
 71 |   |
 72 | -:1:25:error: and:
 73 |   |
 74 | 1 | cmd {{{ echo foo }}} || {{{ echo bar }}};
 75 |   |                         ^^^^^^^^^^^^^^^^
 76 |   |
 77 | """)
 78 | 
 79 | def test_ambiguous_transition5(complgen_binary_path: Path):
 80 |     assert complgen_check(complgen_binary_path, """cmd foo || {{{ echo bar }}};""").returncode == 0
 81 | 
 82 | def test_ambiguous_transition6(complgen_binary_path: Path):
 83 |     assert complgen_check(complgen_binary_path, """cmd [{{{ echo foo }}}] foo;""").returncode == 0
 84 | 
 85 | def test_ambiguous_transition7(complgen_binary_path: Path):
 86 |     assert complgen_check(complgen_binary_path, """cmd {{{ echo foo }}}... foo baz;""").returncode == 0
 87 | 
 88 | def test_ambiguous_transition8(complgen_binary_path: Path):
 89 |     GRAMMAR = """
 90 | mygit (<command> || [-c <name>=<value>] <command>);
 91 | <command> ::= clone;
 92 | """
 93 |     r = complgen_check(complgen_binary_path, GRAMMAR)
 94 |     assert r.returncode == 1
 95 |     assert r.stderr == snapshot("""\
 96 | -:2:25:error: Ambiguous grammar.  Matching can't ascertain where below element ends:
 97 |   |
 98 | 2 | mygit (<command> || [-c <name>=<value>] <command>);
 99 |   |                         ^^^^^^
100 |   |
101 | -:2:31:error: ...and where below element begins:
102 |   |
103 | 2 | mygit (<command> || [-c <name>=<value>] <command>);
104 |   |                               ^
105 |   |
106 | """)
107 | 
108 | 
109 | 
110 | def test_issue_45(complgen_binary_path: Path):
111 |     GRAMMAR = r"""
112 | hyprctl [<OPTION>]... <COMMAND>;
113 | 
114 | <COMMAND> ::= animations          "list animations and beziers (not in --help)"
115 |             | switchxkblayout     "switch keyboard layout" <DEVICE> (next | prev)
116 |             ;
117 | 
118 | <DEVICE> ::= {{{ hyprctl devices -j | awk '/^"keyboards"/,/^\],$/' | sed -n 's/.*"name": "\(.*\)".*/\1/p' }}};
119 | """
120 |     assert complgen_check(complgen_binary_path, GRAMMAR).returncode == 0
121 | 
122 | 
123 | def test_subword_spaces_detection1(complgen_binary_path: Path):
124 |     r = complgen_check(complgen_binary_path, """aerc :(quit -f);""")
125 |     assert r.returncode == 1
126 |     assert r.stderr == snapshot("""\
127 | -:1:8:error: Adjacent literals in expression used in a subword context
128 |   |
129 | 1 | aerc :(quit -f);
130 |   |        ^^^^ First one
131 |   |
132 | -:1:13:error
133 |   |
134 | 1 | aerc :(quit -f);
135 |   |             ^^ Second one
136 |   |
137 |   = help: Join the adjacent literals into one as spaces are invalid in a subword context
138 | """)
139 | 
140 | 
141 | def test_subword_spaces_detection2(complgen_binary_path: Path):
142 |     r = complgen_check(complgen_binary_path, """aerc :<COMMAND>; <COMMAND> ::= quit -f;""")
143 |     assert r.returncode == 1
144 |     assert r.stderr == snapshot("""\
145 | -:1:32:error: Adjacent literals in expression used in a subword context
146 |   |
147 | 1 | aerc :<COMMAND>; <COMMAND> ::= quit -f;
148 |   |                                ^^^^ First one
149 |   |
150 | -:1:37:error
151 |   |
152 | 1 | aerc :<COMMAND>; <COMMAND> ::= quit -f;
153 |   |                                     ^^ Second one
154 |   |
155 |   = help: Join the adjacent literals into one as spaces are invalid in a subword context
156 | -:1:7:error: Referenced in a subword context at
157 |   |
158 | 1 | aerc :<COMMAND>; <COMMAND> ::= quit -f;
159 |   |       ^^^^^^^^^
160 |   |
161 | """)
162 | 
163 | def test_subword_spaces_detection3(complgen_binary_path: Path):
164 |     r = complgen_check(complgen_binary_path, """aerc [<OPTION>]...;
165 | aerc [<OPTION>]... mbox:<PATH>;
166 | aerc [<OPTION>]... mailto:<MAILTOLINK>;
167 | aerc [<OPTION>]... :<COMMAND>;
168 | 
169 | # shortened for brevity
170 | 
171 | <COMMAND> ::= (help <topic> | man <topic>) "show help page inside aerc"
172 |     # shortened for brevity
173 |     | (quit <QUIT_ARGS> | exit <QUIT_ARGS> | q <QUIT_ARGS>) "exit aerc"
174 |     | (redraw) "force a full redraw of the screen"
175 |     ;
176 | 
177 | <QUIT_ARGS> ::= ( -f) "force close aerc"
178 |     ;""")
179 |     assert r.returncode == 1
180 |     assert r.stderr == snapshot("""\
181 | -:10:8:error: Adjacent literals in expression used in a subword context
182 |    |
183 | 10 |     | (quit <QUIT_ARGS> | exit <QUIT_ARGS> | q <QUIT_ARGS>) "exit aerc"
184 |    |        ^^^^ First one
185 |    |
186 | -:14:19:error
187 |    |
188 | 14 | <QUIT_ARGS> ::= ( -f) "force close aerc"
189 |    |                   ^^ Second one
190 |    |
191 |    = help: Join the adjacent literals into one as spaces are invalid in a subword context
192 | -:4:21:error: Referenced in a subword context at
193 |   |
194 | 4 | aerc [<OPTION>]... :<COMMAND>;
195 |   |                     ^^^^^^^^^
196 |   |
197 | """)
198 | 
199 | 
200 | def test_subword_spaces4(complgen_binary_path: Path):
201 |     r = complgen_check(complgen_binary_path, """cmd foo[bar];""")
202 |     assert r.returncode == 0
203 | 
204 |     r = complgen_check(complgen_binary_path, """cmd foo((bar)...);""")
205 |     assert r.returncode == 0
206 | 
207 | 
208 | def test_bug1(complgen_binary_path: Path):
209 |     r = complgen_check(complgen_binary_path, """cmd (--bash-script <PATH>) | --help;""")
210 |     assert r.returncode == 0
211 | 
212 | 
213 | def test_bug2(complgen_binary_path: Path):
214 |     r = complgen_check(complgen_binary_path, """darcs ( <FILE> | <DIRECTORY> );""")
215 |     assert r.returncode == 1
216 |     assert r.stderr == snapshot("""\
217 | -:1:9:warning: Undefined nonterminal
218 |   |
219 | 1 | darcs ( <FILE> | <DIRECTORY> );
220 |   |         ------
221 |   |
222 | -:1:9:error: Ambiguous grammar.  Matching can't differentiate:
223 |   |
224 | 1 | darcs ( <FILE> | <DIRECTORY> );
225 |   |         ^^^^^^
226 |   |
227 | -:1:18:error: and:
228 |   |
229 | 1 | darcs ( <FILE> | <DIRECTORY> );
230 |   |                  ^^^^^^^^^^^
231 |   |
232 | """)
233 | 
234 | 
235 | def test_bug3(complgen_binary_path: Path):
236 |     r = complgen_check(complgen_binary_path, """
237 | aerc [<OPTION>]...;
238 | aerc [<OPTION>]... foo;
239 | """)
240 |     assert r.returncode == 1
241 |     assert r.stderr == snapshot("""\
242 | -:3:7:warning: Undefined nonterminal
243 |   |
244 | 3 | aerc [<OPTION>]... foo;
245 |   |       --------
246 |   |
247 | -:2:7:error: Ambiguous grammar.  Matching can't differentiate:
248 |   |
249 | 2 | aerc [<OPTION>]...;
250 |   |       ^^^^^^^^
251 |   |
252 | -:3:7:error: and:
253 |   |
254 | 3 | aerc [<OPTION>]... foo;
255 |   |       ^^^^^^^^
256 |   |
257 | """)
258 | 
259 | 
260 | def test_bug4(complgen_binary_path: Path):
261 |     r = complgen_check(complgen_binary_path, """darcs [<INITIALIZATION>] <COMMAND>;""")
262 |     assert r.returncode == 1
263 |     assert r.stderr == snapshot("""\
264 | -:1:8:warning: Undefined nonterminal
265 |   |
266 | 1 | darcs [<INITIALIZATION>] <COMMAND>;
267 |   |        ----------------
268 |   |
269 | -:1:26:warning: Undefined nonterminal
270 |   |
271 | 1 | darcs [<INITIALIZATION>] <COMMAND>;
272 |   |                          ---------
273 |   |
274 | -:1:8:error: Ambiguous grammar.  Matching can't differentiate:
275 |   |
276 | 1 | darcs [<INITIALIZATION>] <COMMAND>;
277 |   |        ^^^^^^^^^^^^^^^^
278 |   |
279 | -:1:26:error: and:
280 |   |
281 | 1 | darcs [<INITIALIZATION>] <COMMAND>;
282 |   |                          ^^^^^^^^^
283 |   |
284 | """)
285 | 
286 | 
287 | def test_clashing_variants(complgen_binary_path: Path):
288 |     r = complgen_check(complgen_binary_path, r"""
289 | mygit (clone "Clone a repository into a new directory" | clone --bare);
290 | """)
291 |     assert r.returncode == 1
292 |     assert r.stderr == snapshot("""\
293 | -:2:8:error: Clashing variants.  Completion can't differentiate:
294 |   |
295 | 2 | mygit (clone "Clone a repository into a new directory" | clone --bare);
296 |   |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
297 |   |
298 | -:2:58:error: and:
299 |   |
300 | 2 | mygit (clone "Clone a repository into a new directory" | clone --bare);
301 |   |                                                          ^^^^^
302 |   |
303 | """)
304 | 
305 | 
306 | def test_ambiguous_dfa(complgen_binary_path: Path):
307 |     r = complgen_check(complgen_binary_path, """
308 | darcs <SOURCE> ... <DESTINATION>;
309 | """)
310 |     assert r.returncode == 1
311 |     assert r.stderr == snapshot("""\
312 | -:2:7:warning: Undefined nonterminal
313 |   |
314 | 2 | darcs <SOURCE> ... <DESTINATION>;
315 |   |       --------
316 |   |
317 | -:2:20:warning: Undefined nonterminal
318 |   |
319 | 2 | darcs <SOURCE> ... <DESTINATION>;
320 |   |                    -------------
321 |   |
322 | -:2:7:error: Ambiguous grammar.  Matching can't differentiate:
323 |   |
324 | 2 | darcs <SOURCE> ... <DESTINATION>;
325 |   |       ^^^^^^^^
326 |   |
327 | -:2:20:error: and:
328 |   |
329 | 2 | darcs <SOURCE> ... <DESTINATION>;
330 |   |                    ^^^^^^^^^^^^^
331 |   |
332 | """)
333 | 
334 | 
335 | def test_ambiguous_subword_leader(complgen_binary_path: Path):
336 |     r = complgen_check(complgen_binary_path, """
337 | foo <BAR>=bar;
338 | foo baz;
339 | """)
340 |     assert r.returncode == 1
341 |     assert r.stderr == snapshot("""\
342 | -:2:5:error: Ambiguous grammar.  Matching can't ascertain where below element ends:
343 |   |
344 | 2 | foo <BAR>=bar;
345 |   |     ^^^^^
346 |   |
347 | -:2:10:error: ...and where below element begins:
348 |   |
349 | 2 | foo <BAR>=bar;
350 |   |          ^^^^
351 |   |
352 | """)
353 | 
354 | 
355 | def test_unambiguous_subword_leaders(complgen_binary_path: Path):
356 |     r = complgen_check(complgen_binary_path, """
357 | darcs foo={{{ echo first }}};
358 | darcs foo=bar{{{ echo second }}};
359 | """)
360 |     assert r.returncode == 0
361 |     assert r.stderr == snapshot('')
362 | 
363 | 
364 | def test_duplicated_subword_leader(complgen_binary_path: Path):
365 |     r = complgen_check(complgen_binary_path, """
366 | foo bar=<BAR>;
367 | foo bar=<BAZ>;
368 | """)
369 |     assert r.returncode == 1
370 |     assert r.stderr == snapshot("""\
371 | -:2:9:warning: Undefined nonterminal
372 |   |
373 | 2 | foo bar=<BAR>;
374 |   |         -----
375 |   |
376 | -:3:9:warning: Undefined nonterminal
377 |   |
378 | 3 | foo bar=<BAZ>;
379 |   |         -----
380 |   |
381 | -:2:5:error: Clashing subword leaders.  Completion can't differentiate:
382 |   |
383 | 2 | foo bar=<BAR>;
384 |   |     ^^^^^^^^^
385 |   |
386 | -:3:5:error: and:
387 |   |
388 | 3 | foo bar=<BAZ>;
389 |   |     ^^^^^^^^^
390 |   |
391 | """)
392 | 
393 | 
394 | def test_varying_command_names(complgen_binary_path: Path):
395 |     r = complgen_check(complgen_binary_path, """
396 | foo quux;
397 | bar quux;
398 | """)
399 |     assert r.returncode == 1
400 |     assert r.stderr == snapshot("""\
401 | -:2:1:error: Varying command names:
402 |   |
403 | 2 | foo quux;
404 |   | ^^^
405 |   |
406 | -:3:1:error: Varying command names:
407 |   |
408 | 3 | bar quux;
409 |   | ^^^
410 |   |
411 | """)
412 | 
413 | 
414 | def test_unknown_shell(complgen_binary_path: Path):
415 |     r = complgen_check(complgen_binary_path, """
416 | foo quux;
417 | <BAR@quux> ::= {{{ echo foo }}};
418 | """)
419 |     assert r.returncode == 1
420 |     assert r.stderr == snapshot("""\
421 | -:3:6:error: Unknown shell
422 |   |
423 | 3 | <BAR@quux> ::= {{{ echo foo }}};
424 |   |      ^^^^
425 |   |
426 | """)
427 | 
428 | 
429 | def test_invalid_command_name(complgen_binary_path: Path):
430 |     r = complgen_check(complgen_binary_path, """
431 | foo/bar quux;
432 | """)
433 |     assert r.returncode == 1
434 |     assert r.stderr == snapshot("""\
435 | -:2:1:error: Invalid command name
436 |   |
437 | 2 | foo/bar quux;
438 |   | ^^^^^^^
439 |   |
440 | """)
441 | 
442 | def test_nonterminal_cycle_outer(complgen_binary_path: Path):
443 |     r = complgen_check(complgen_binary_path, """
444 | cmd <FOO>;
445 | <FOO> ::= <BAR>;
446 | <BAR> ::= <FOO>;
447 | """)
448 |     assert r.returncode == 1
449 |     assert r.stderr == snapshot("""\
450 | -:3:1:error: Nonterminal definitions cycle
451 |   |
452 | 3 | <FOO> ::= <BAR>;
453 |   | ^^^^^
454 |   |
455 | -:3:11:error: Nonterminal definitions cycle
456 |   |
457 | 3 | <FOO> ::= <BAR>;
458 |   |           ^^^^^
459 |   |
460 | -:4:11:error: Nonterminal definitions cycle
461 |   |
462 | 4 | <BAR> ::= <FOO>;
463 |   |           ^^^^^
464 |   |
465 | """)
466 | 
467 | def test_nonterminal_cycle_inner(complgen_binary_path: Path):
468 |     r = complgen_check(complgen_binary_path, """
469 | cmd <FOO>;
470 | <FOO> ::= <BAR>;
471 | <BAR> ::= <QUUX>;
472 | <QUUX> ::= <BAR>;
473 | """)
474 |     assert r.returncode == 1
475 |     assert r.stderr == snapshot("""\
476 | -:3:1:error: Nonterminal definitions cycle
477 |   |
478 | 3 | <FOO> ::= <BAR>;
479 |   | ^^^^^
480 |   |
481 | -:3:11:error: Nonterminal definitions cycle
482 |   |
483 | 3 | <FOO> ::= <BAR>;
484 |   |           ^^^^^
485 |   |
486 | -:4:11:error: Nonterminal definitions cycle
487 |   |
488 | 4 | <BAR> ::= <QUUX>;
489 |   |           ^^^^^^
490 |   |
491 | -:5:12:error: Nonterminal definitions cycle
492 |   |
493 | 5 | <QUUX> ::= <BAR>;
494 |   |            ^^^^^
495 |   |
496 | """)
497 | 
498 | def test_non_command_specialization(complgen_binary_path: Path):
499 |     r = complgen_check(complgen_binary_path, """
500 | cmd <FOO>;
501 | <FOO@bash> ::= foo;
502 | <FOO@bash> ::= bar;
503 | """)
504 |     assert r.returncode == 1
505 |     assert r.stderr == snapshot("""\
506 | -:3:1:error: Can only specialize external commands
507 |   |
508 | 3 | <FOO@bash> ::= foo;
509 |   | ^^^^^^^^^^
510 |   |
511 | """)
512 | 
513 | 
514 | def test_duplicated_nonterminal_definition(complgen_binary_path: Path):
515 |     r = complgen_check(complgen_binary_path, """
516 | cmd <FOO>;
517 | <FOO> ::= foo;
518 | <FOO> ::= bar;
519 | """)
520 |     assert r.returncode == 1
521 |     assert r.stderr == snapshot("""\
522 | -:4:1:error: Duplicate nonterminal definition
523 |   |
524 | 4 | <FOO> ::= bar;
525 |   | ^^^^^
526 |   |
527 | -:3:1:error: Previous definition
528 |   |
529 | 3 | <FOO> ::= foo;
530 |   | ^^^^^
531 |   |
532 | """)
533 | 
534 | 
535 | def test_duplicated_nonterminal_definition_specialization(complgen_binary_path: Path):
536 |     r = complgen_check(complgen_binary_path, """
537 | cmd <FOO>;
538 | <FOO@bash> ::= {{{ echo foo }}};
539 | <FOO@bash> ::= {{{ echo bar }}};
540 | """)
541 |     assert r.returncode == 1
542 |     assert r.stderr == snapshot("""\
543 | -:4:1:error: Duplicate nonterminal definition
544 |   |
545 | 4 | <FOO@bash> ::= {{{ echo bar }}};
546 |   | ^^^^^^^^^^
547 |   |
548 | -:3:1:error: Previous definition
549 |   |
550 | 3 | <FOO@bash> ::= {{{ echo foo }}};
551 |   | ^^^^^^^^^^
552 |   |
553 | """)
554 | 


--------------------------------------------------------------------------------
/examples/darcs.usage:
--------------------------------------------------------------------------------
 1 | darcs help ( ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [<DARCS_COMMAND> [<DARCS_SUBCOMMAND>]]  ;
 2 | darcs add ( --boring | ( --case-ok | --reserved-ok ) | ( ( -r | --recursive ) | --not-recursive ) | ( --date-trick | --no-date-trick ) | --repodir <DIRECTORY> | --dry-run | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... <PATH>...;
 3 | darcs remove ( --repodir <DIRECTORY> | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... <PATH>...;
 4 | darcs move ( ( --case-ok | --reserved-ok ) | --repodir <DIRECTORY> | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ...;
 5 | darcs replace ( --token-chars <"[CHARS]"> | ( ( -f | --force ) | --no-force ) | --repodir <DIRECTORY> | --ignore-times | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... <OLD> <NEW> <FILE> ...;
 6 | darcs revert ( ( ( -a | --all ) | ( -i | --interactive ) ) | --repodir <DIRECTORY> | --ignore-times | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [<PATH>]...;
 7 | darcs unrevert ( --ignore-times | ( ( -a | --all ) | ( -i | --interactive ) ) | --repodir <DIRECTORY> | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... ;
 8 | darcs whatsnew ( ( ( -s | --summary ) | --no-summary ) | ( -u | --unified ) | ( ( -l | --look-for-adds ) | --dont-look-for-adds ) | --repodir <DIRECTORY> | --ignore-times | --boring | --no-cache | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [ <PATH> ]...;
 9 | darcs record ( ( -m <PATCHNAME> | --patch-name <PATCHNAME> ) | ( -A <EMAIL> | --author <EMAIL> ) | ( --no-test | --test ) | ( --leave-test-directory | --remove-test-directory ) | ( ( -a | --all ) | --pipe | ( -i | --interactive ) ) | ( --ask-deps | --no-ask-deps ) | ( --edit-long-comment | --skip-long-comment | --prompt-long-comment ) | ( ( -l | --look-for-adds ) | --dont-look-for-adds ) | --repodir <DIRECTORY> | --logfile <FILE> | --delete-logfile | ( --compress | --dont-compress ) | --ignore-times | --umask <UMASK> | ( --set-scripts-executable | --dont-set-scripts-executable ) | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [ ( <PATH> ) ]...;
10 | darcs unrecord ( ( --from-match <PATTERN> | --from-patch <REGEXP> | --from-tag <REGEXP> | --last <NUMBER> | --matches <PATTERN> | ( -p <REGEXP> | --patches <REGEXP> ) | ( -t <REGEXP> | --tags <REGEXP> ) ) | ( --no-deps | --dont-prompt-for-dependencies | --prompt-for-dependencies ) | ( ( -a | --all ) | ( -i | --interactive ) ) | --repodir <DIRECTORY> | ( --compress | --dont-compress ) | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... ;
11 | darcs amend-record ( ( --match <PATTERN> | ( -p <REGEXP> | --patch <REGEXP> ) | ( -n <N> | --index <N> ) ) | ( --no-test | --test ) | ( --leave-test-directory | --remove-test-directory ) | ( ( -a | --all ) | ( -i | --interactive ) ) | ( -A <EMAIL> | --author <EMAIL> ) | ( -m <PATCHNAME> | --patch-name <PATCHNAME> ) | ( --edit-long-comment | --skip-long-comment | --prompt-long-comment ) | ( ( -l | --look-for-adds ) | --dont-look-for-adds ) | --repodir <DIRECTORY> | ( --compress | --dont-compress ) | --ignore-times | --umask <UMASK> | ( --set-scripts-executable | --dont-set-scripts-executable ) | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [ ( <PATH> ) ]...;
12 | darcs mark-conflicts ( --ignore-times | --repodir <DIRECTORY> | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... ;
13 | darcs tag ( ( -m <PATCHNAME> | --patch-name <PATCHNAME> ) | ( -A <EMAIL> | --author <EMAIL> ) | ( --pipe | ( -i | --interactive ) ) | ( --edit-long-comment | --skip-long-comment | --prompt-long-comment ) | --repodir <DIRECTORY> | ( --compress | --dont-compress ) | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [TAGNAME];
14 | darcs setpref ( --repodir <DIRECTORY> | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... <PREF> <VALUE>;
15 | darcs diff ( ( --to-match <PATTERN> | --to-patch <REGEXP> | --to-tag <REGEXP> | --from-match <PATTERN> | --from-patch <REGEXP> | --from-tag <REGEXP> | --match <PATTERN> | ( -p <REGEXP> | --patch <REGEXP> ) | --last <NUMBER> | ( -n <N-M> | --index <N-M> ) ) | --diff-command <COMMAND> | --diff-opts <OPTIONS> | ( -u | --unified ) | --repodir <DIRECTORY> | --store-in-memory | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [ ( <PATH> ) ]...;
16 | darcs changes ( ( --to-match <PATTERN> | --to-patch <REGEXP> | --to-tag <REGEXP> | --from-match <PATTERN> | --from-patch <REGEXP> | --from-tag <REGEXP> | --last <NUMBER> | ( -n <N-M> | --index <N-M> ) | --matches <PATTERN> | ( -p <REGEXP> | --patches <REGEXP> ) | ( -t <REGEXP> | --tags <REGEXP> ) ) | --max-count <NUMBER> | --only-to-files | ( --context | --xml-output | --human-readable | --number | --count ) | ( ( -s | --summary ) | --no-summary ) | --reverse | --repo <URL> | --repodir <DIRECTORY> | ( ( -a | --all ) | ( -i | --interactive ) ) | ( --ssh-cm | --no-ssh-cm ) | ( --http-pipelining | --no-http-pipelining ) | --no-cache | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [ ( <PATH> ) ]...;
17 | darcs annotate ( ( ( -s | --summary ) | --no-summary ) | ( -u | --unified ) | --human-readable | --xml-output | ( --match <PATTERN> | ( -p <REGEXP> | --patch <REGEXP> ) | ( -t <REGEXP> | --tag <REGEXP> ) | ( -n <N> | --index <N> ) ) | --creator-hash <HASH> | --repodir <DIRECTORY> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [ ( <PATH> ) ]...;
18 | darcs dist ( ( -d <DISTNAME> | --dist-name <DISTNAME> ) | --repodir <DIRECTORY> | ( --match <PATTERN> | ( -p <REGEXP> | --patch <REGEXP> ) | ( -t <REGEXP> | --tag <REGEXP> ) | ( -n <N> | --index <N> ) ) | --store-in-memory | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... ;
19 | darcs trackdown ( --repodir <DIRECTORY> | ( --set-scripts-executable | --dont-set-scripts-executable ) | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ...;
20 | darcs show ( contents ( ( --match <PATTERN> | ( -p <REGEXP> | --patch <REGEXP> ) | ( -t <REGEXP> | --tag <REGEXP> ) | ( -n <N> | --index <N> ) ) | --repodir <DIRECTORY> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [FILE]... | files ( ( --files | --no-files ) | ( --directories | --no-directories ) | ( --pending | --no-pending ) | ( -0 | --null ) | --repodir <DIRECTORY> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ...  | index ( ( --files | --no-files ) | ( --directories | --no-directories ) | ( -0 | --null ) | --repodir <DIRECTORY> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ...  | pristine ( ( --files | --no-files ) | ( --directories | --no-directories ) | ( -0 | --null ) | --repodir <DIRECTORY> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ...  | repo ( --repodir <DIRECTORY> | ( --files | --no-files ) | --xml-output | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ...  | authors ( --repodir <DIRECTORY> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ...  | tags ( --repodir <DIRECTORY> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ...  );
21 | darcs pull ( ( --matches <PATTERN> | ( -p <REGEXP> | --patches <REGEXP> ) | ( -t <REGEXP> | --tags <REGEXP> ) ) | ( ( -a | --all ) | ( -i | --interactive ) ) | ( --mark-conflicts | --allow-conflicts | --dont-allow-conflicts | --skip-conflicts ) | --external-merge <COMMAND> | ( --test | --no-test ) | --dry-run | --xml-output | ( ( -s | --summary ) | --no-summary ) | ( --no-deps | --dont-prompt-for-dependencies | --prompt-for-dependencies ) | ( --set-default | --no-set-default ) | --repodir <DIRECTORY> | --ignore-unrelated-repos | ( --intersection | --union | --complement ) | ( --compress | --dont-compress ) | --nolinks | --ignore-times | --remote-repo <URL> | ( --set-scripts-executable | --dont-set-scripts-executable ) | --umask <UMASK> | ( --restrict-paths | --dont-restrict-paths ) | ( --ssh-cm | --no-ssh-cm ) | ( --http-pipelining | --no-http-pipelining ) | --no-cache | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [REPOSITORY]...;
22 | darcs obliterate ( ( --from-match <PATTERN> | --from-patch <REGEXP> | --from-tag <REGEXP> | --last <NUMBER> | --matches <PATTERN> | ( -p <REGEXP> | --patches <REGEXP> ) | ( -t <REGEXP> | --tags <REGEXP> ) ) | ( --no-deps | --dont-prompt-for-dependencies | --prompt-for-dependencies ) | ( ( -a | --all ) | ( -i | --interactive ) ) | --repodir <DIRECTORY> | ( ( -s | --summary ) | --no-summary ) | ( --compress | --dont-compress ) | --ignore-times | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... ;
23 | darcs rollback ( ( --from-match <PATTERN> | --from-patch <REGEXP> | --from-tag <REGEXP> | --last <NUMBER> | --matches <PATTERN> | ( -p <REGEXP> | --patches <REGEXP> ) | ( -t <REGEXP> | --tags <REGEXP> ) ) | ( ( -a | --all ) | ( -i | --interactive ) ) | ( -A <EMAIL> | --author <EMAIL> ) | ( -m <PATCHNAME> | --patch-name <PATCHNAME> ) | ( --edit-long-comment | --skip-long-comment | --prompt-long-comment ) | ( --no-test | --test ) | ( --leave-test-directory | --remove-test-directory ) | --repodir <DIRECTORY> | ( --compress | --dont-compress ) | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [ ( <PATH> ) ]...;
24 | darcs push ( ( --matches <PATTERN> | ( -p <REGEXP> | --patches <REGEXP> ) | ( -t <REGEXP> | --tags <REGEXP> ) ) | ( --no-deps | --dont-prompt-for-dependencies | --prompt-for-dependencies ) | ( ( -a | --all ) | ( -i | --interactive ) ) | ( --sign | --sign-as <KEYID> | --sign-ssl <IDFILE> | --dont-sign ) | --dry-run | --xml-output | ( ( -s | --summary ) | --no-summary ) | --repodir <DIRECTORY> | ( --set-default | --no-set-default ) | --ignore-unrelated-repos | ( --apply-as <USERNAME> | --apply-as-myself ) | --nolinks | --remote-repo <URL> | ( --ssh-cm | --no-ssh-cm ) | ( --http-pipelining | --no-http-pipelining ) | --no-cache | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [REPOSITORY];
25 | darcs send ( ( --matches <PATTERN> | ( -p <REGEXP> | --patches <REGEXP> ) | ( -t <REGEXP> | --tags <REGEXP> ) ) | ( --no-deps | --dont-prompt-for-dependencies | --prompt-for-dependencies ) | ( ( -a | --all ) | ( -i | --interactive ) ) | --from <EMAIL> | ( -A <EMAIL> | --author <EMAIL> ) | --to <EMAIL> | --cc <EMAIL> | --subject <SUBJECT> | --in-reply-to <EMAIL> | ( -o <FILE> | --output <FILE> ) | ( -O [<DIRECTORY>] | --output-auto-name [<DIRECTORY>] ) | ( --sign | --sign-as <KEYID> | --sign-ssl <IDFILE> | --dont-sign ) | --dry-run | --xml-output | ( ( -s | --summary ) | --no-summary ) | ( --edit-description | --dont-edit-description ) | ( --set-default | --no-set-default ) | --repodir <DIRECTORY> | --sendmail-command <COMMAND> | --ignore-unrelated-repos | --logfile <FILE> | --delete-logfile | --remote-repo <URL> | --context <FILENAME> | ( --ssh-cm | --no-ssh-cm ) | ( --http-pipelining | --no-http-pipelining ) | --no-cache | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... [REPOSITORY];
26 | darcs apply ( ( --verify <PUBRING> | --verify-ssl <KEYS> | --no-verify ) | ( ( -a | --all ) | ( -i | --interactive ) ) | --dry-run | --xml-output | ( --mark-conflicts | --allow-conflicts | --no-resolve-conflicts | --dont-allow-conflicts | --skip-conflicts ) | --external-merge <COMMAND> | ( --no-test | --test ) | ( --leave-test-directory | --remove-test-directory ) | --repodir <DIRECTORY> | --reply <FROM> | --cc <EMAIL> | --happy-forwarding | --sendmail-command <COMMAND> | --ignore-times | ( --compress | --dont-compress ) | ( --set-scripts-executable | --dont-set-scripts-executable ) | --umask <UMASK> | ( --restrict-paths | --dont-restrict-paths ) | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... <PATCHFILE>;
27 | darcs get ( ( --repo-name <DIRECTORY> | --repodir <DIRECTORY> ) | ( --partial | --lazy | --ephemeral | --complete ) | ( --to-match <PATTERN> | --to-patch <REGEXP> | ( -t <REGEXP> | --tag <REGEXP> ) | --context <FILENAME> ) | ( --set-default | --no-set-default ) | ( --set-scripts-executable | --dont-set-scripts-executable ) | --nolinks | ( --hashed | --old-fashioned-inventory ) | ( --ssh-cm | --no-ssh-cm ) | ( --http-pipelining | --no-http-pipelining ) | --no-cache | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... <REPOSITORY> [<DIRECTORY>];
28 | darcs put ( ( --to-match <PATTERN> | --to-patch <REGEXP> | ( -t <REGEXP> | --tag <REGEXP> ) | --context <FILENAME> ) | ( --set-scripts-executable | --dont-set-scripts-executable ) | ( --hashed | --old-fashioned-inventory ) | ( --set-default | --no-set-default ) | --repodir <DIRECTORY> | ( --apply-as <USERNAME> | --apply-as-myself ) | ( --ssh-cm | --no-ssh-cm ) | ( --http-pipelining | --no-http-pipelining ) | --no-cache | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... <NEW_REPOSITORY>;
29 | darcs initialize ( ( --hashed | --darcs-2 | --old-fashioned-inventory ) | --repodir <DIRECTORY> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... ;
30 | darcs optimize ( --repodir <DIRECTORY> | --reorder-patches | --sibling <URL> | --relink | --relink-pristine | --upgrade | --pristine | ( --compress | --dont-compress | --uncompress ) | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... ;
31 | darcs check ( ( --complete | --partial ) | ( --no-test | --test ) | ( --leave-test-directory | --remove-test-directory ) | --repodir <DIRECTORY> | --ignore-times | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... ;
32 | darcs repair ( --repodir <DIRECTORY> | --umask <UMASK> | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... ;
33 | darcs convert ( ( --repo-name <DIRECTORY> | --repodir <DIRECTORY> ) | ( --set-scripts-executable | --dont-set-scripts-executable ) | ( --ssh-cm | --no-ssh-cm ) | ( --http-pipelining | --no-http-pipelining ) | --no-cache | ( --debug | --debug-verbose | --debug-http | ( -v | --verbose ) | ( -q | --quiet ) | --standard-verbosity ) | --timings | ( --posthook <COMMAND> | --no-posthook ) | ( --prompt-posthook | --run-posthook ) | ( --prehook <COMMAND> | --no-prehook ) | ( --prompt-prehook | --run-prehook ) ) ... <SOURCE> [<DESTINATION>];
34 | 


--------------------------------------------------------------------------------
/Cargo.lock:
--------------------------------------------------------------------------------
  1 | # This file is automatically @generated by Cargo.
  2 | # It is not intended for manual editing.
  3 | version = 4
  4 | 
  5 | [[package]]
  6 | name = "ahash"
  7 | version = "0.7.6"
  8 | source = "registry+https://github.com/rust-lang/crates.io-index"
  9 | checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
 10 | dependencies = [
 11 |  "getrandom",
 12 |  "once_cell",
 13 |  "version_check",
 14 | ]
 15 | 
 16 | [[package]]
 17 | name = "ahash"
 18 | version = "0.8.3"
 19 | source = "registry+https://github.com/rust-lang/crates.io-index"
 20 | checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
 21 | dependencies = [
 22 |  "cfg-if",
 23 |  "once_cell",
 24 |  "version_check",
 25 | ]
 26 | 
 27 | [[package]]
 28 | name = "aho-corasick"
 29 | version = "1.0.2"
 30 | source = "registry+https://github.com/rust-lang/crates.io-index"
 31 | checksum = "43f6cb1bf222025340178f382c426f13757b2960e89779dfcb319c32542a5a41"
 32 | dependencies = [
 33 |  "memchr",
 34 | ]
 35 | 
 36 | [[package]]
 37 | name = "annotate-snippets"
 38 | version = "0.6.1"
 39 | source = "registry+https://github.com/rust-lang/crates.io-index"
 40 | checksum = "c7021ce4924a3f25f802b2cccd1af585e39ea1a363a1aa2e72afe54b67a3a7a7"
 41 | 
 42 | [[package]]
 43 | name = "anstream"
 44 | version = "0.6.20"
 45 | source = "registry+https://github.com/rust-lang/crates.io-index"
 46 | checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192"
 47 | dependencies = [
 48 |  "anstyle",
 49 |  "anstyle-parse",
 50 |  "anstyle-query",
 51 |  "anstyle-wincon",
 52 |  "colorchoice",
 53 |  "is_terminal_polyfill",
 54 |  "utf8parse",
 55 | ]
 56 | 
 57 | [[package]]
 58 | name = "anstyle"
 59 | version = "1.0.11"
 60 | source = "registry+https://github.com/rust-lang/crates.io-index"
 61 | checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd"
 62 | 
 63 | [[package]]
 64 | name = "anstyle-parse"
 65 | version = "0.2.7"
 66 | source = "registry+https://github.com/rust-lang/crates.io-index"
 67 | checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
 68 | dependencies = [
 69 |  "utf8parse",
 70 | ]
 71 | 
 72 | [[package]]
 73 | name = "anstyle-query"
 74 | version = "1.1.4"
 75 | source = "registry+https://github.com/rust-lang/crates.io-index"
 76 | checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
 77 | dependencies = [
 78 |  "windows-sys 0.60.2",
 79 | ]
 80 | 
 81 | [[package]]
 82 | name = "anstyle-wincon"
 83 | version = "3.0.10"
 84 | source = "registry+https://github.com/rust-lang/crates.io-index"
 85 | checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
 86 | dependencies = [
 87 |  "anstyle",
 88 |  "once_cell_polyfill",
 89 |  "windows-sys 0.60.2",
 90 | ]
 91 | 
 92 | [[package]]
 93 | name = "anyhow"
 94 | version = "1.0.71"
 95 | source = "registry+https://github.com/rust-lang/crates.io-index"
 96 | checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
 97 | 
 98 | [[package]]
 99 | name = "autocfg"
100 | version = "1.1.0"
101 | source = "registry+https://github.com/rust-lang/crates.io-index"
102 | checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
103 | 
104 | [[package]]
105 | name = "bit-set"
106 | version = "0.5.3"
107 | source = "registry+https://github.com/rust-lang/crates.io-index"
108 | checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
109 | dependencies = [
110 |  "bit-vec",
111 | ]
112 | 
113 | [[package]]
114 | name = "bit-vec"
115 | version = "0.6.3"
116 | source = "registry+https://github.com/rust-lang/crates.io-index"
117 | checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
118 | 
119 | [[package]]
120 | name = "bitflags"
121 | version = "1.3.2"
122 | source = "registry+https://github.com/rust-lang/crates.io-index"
123 | checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
124 | 
125 | [[package]]
126 | name = "bytecount"
127 | version = "0.6.3"
128 | source = "registry+https://github.com/rust-lang/crates.io-index"
129 | checksum = "2c676a478f63e9fa2dd5368a42f28bba0d6c560b775f38583c8bbaa7fcd67c9c"
130 | 
131 | [[package]]
132 | name = "bytemuck"
133 | version = "1.13.1"
134 | source = "registry+https://github.com/rust-lang/crates.io-index"
135 | checksum = "17febce684fd15d89027105661fec94afb475cb995fbc59d2865198446ba2eea"
136 | 
137 | [[package]]
138 | name = "byteorder"
139 | version = "1.4.3"
140 | source = "registry+https://github.com/rust-lang/crates.io-index"
141 | checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
142 | 
143 | [[package]]
144 | name = "cc"
145 | version = "1.0.79"
146 | source = "registry+https://github.com/rust-lang/crates.io-index"
147 | checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
148 | 
149 | [[package]]
150 | name = "cfg-if"
151 | version = "1.0.0"
152 | source = "registry+https://github.com/rust-lang/crates.io-index"
153 | checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
154 | 
155 | [[package]]
156 | name = "chic"
157 | version = "1.2.2"
158 | source = "registry+https://github.com/rust-lang/crates.io-index"
159 | checksum = "a5b5db619f3556839cb2223ae86ff3f9a09da2c5013be42bc9af08c9589bf70c"
160 | dependencies = [
161 |  "annotate-snippets",
162 | ]
163 | 
164 | [[package]]
165 | name = "clap"
166 | version = "4.4.18"
167 | source = "registry+https://github.com/rust-lang/crates.io-index"
168 | checksum = "1e578d6ec4194633722ccf9544794b71b1385c3c027efe0c55db226fc880865c"
169 | dependencies = [
170 |  "clap_builder",
171 |  "clap_derive",
172 | ]
173 | 
174 | [[package]]
175 | name = "clap_builder"
176 | version = "4.4.18"
177 | source = "registry+https://github.com/rust-lang/crates.io-index"
178 | checksum = "4df4df40ec50c46000231c914968278b1eb05098cf8f1b3a518a95030e71d1c7"
179 | dependencies = [
180 |  "anstream",
181 |  "anstyle",
182 |  "clap_lex",
183 |  "strsim",
184 | ]
185 | 
186 | [[package]]
187 | name = "clap_derive"
188 | version = "4.4.7"
189 | source = "registry+https://github.com/rust-lang/crates.io-index"
190 | checksum = "cf9804afaaf59a91e75b022a30fb7229a7901f60c755489cc61c9b423b836442"
191 | dependencies = [
192 |  "heck",
193 |  "proc-macro2",
194 |  "quote",
195 |  "syn 2.0.13",
196 | ]
197 | 
198 | [[package]]
199 | name = "clap_lex"
200 | version = "0.6.0"
201 | source = "registry+https://github.com/rust-lang/crates.io-index"
202 | checksum = "702fc72eb24e5a1e48ce58027a675bc24edd52096d5397d4aea7c6dd9eca0bd1"
203 | 
204 | [[package]]
205 | name = "colorchoice"
206 | version = "1.0.4"
207 | source = "registry+https://github.com/rust-lang/crates.io-index"
208 | checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
209 | 
210 | [[package]]
211 | name = "complgen"
212 | version = "0.5.0"
213 | dependencies = [
214 |  "anyhow",
215 |  "chic",
216 |  "clap",
217 |  "hashbrown 0.13.2",
218 |  "indexmap",
219 |  "itertools",
220 |  "nom",
221 |  "nom_locate",
222 |  "proptest",
223 |  "regex",
224 |  "roaring",
225 |  "thiserror",
226 |  "ustr",
227 | ]
228 | 
229 | [[package]]
230 | name = "either"
231 | version = "1.8.1"
232 | source = "registry+https://github.com/rust-lang/crates.io-index"
233 | checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
234 | 
235 | [[package]]
236 | name = "equivalent"
237 | version = "1.0.1"
238 | source = "registry+https://github.com/rust-lang/crates.io-index"
239 | checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
240 | 
241 | [[package]]
242 | name = "errno"
243 | version = "0.3.1"
244 | source = "registry+https://github.com/rust-lang/crates.io-index"
245 | checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a"
246 | dependencies = [
247 |  "errno-dragonfly",
248 |  "libc",
249 |  "windows-sys 0.48.0",
250 | ]
251 | 
252 | [[package]]
253 | name = "errno-dragonfly"
254 | version = "0.1.2"
255 | source = "registry+https://github.com/rust-lang/crates.io-index"
256 | checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
257 | dependencies = [
258 |  "cc",
259 |  "libc",
260 | ]
261 | 
262 | [[package]]
263 | name = "fastrand"
264 | version = "1.9.0"
265 | source = "registry+https://github.com/rust-lang/crates.io-index"
266 | checksum = "e51093e27b0797c359783294ca4f0a911c270184cb10f85783b118614a1501be"
267 | dependencies = [
268 |  "instant",
269 | ]
270 | 
271 | [[package]]
272 | name = "fnv"
273 | version = "1.0.7"
274 | source = "registry+https://github.com/rust-lang/crates.io-index"
275 | checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
276 | 
277 | [[package]]
278 | name = "getrandom"
279 | version = "0.2.8"
280 | source = "registry+https://github.com/rust-lang/crates.io-index"
281 | checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
282 | dependencies = [
283 |  "cfg-if",
284 |  "libc",
285 |  "wasi",
286 | ]
287 | 
288 | [[package]]
289 | name = "hashbrown"
290 | version = "0.13.2"
291 | source = "registry+https://github.com/rust-lang/crates.io-index"
292 | checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
293 | dependencies = [
294 |  "ahash 0.8.3",
295 | ]
296 | 
297 | [[package]]
298 | name = "hashbrown"
299 | version = "0.15.2"
300 | source = "registry+https://github.com/rust-lang/crates.io-index"
301 | checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
302 | 
303 | [[package]]
304 | name = "heck"
305 | version = "0.4.1"
306 | source = "registry+https://github.com/rust-lang/crates.io-index"
307 | checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
308 | 
309 | [[package]]
310 | name = "hermit-abi"
311 | version = "0.3.1"
312 | source = "registry+https://github.com/rust-lang/crates.io-index"
313 | checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286"
314 | 
315 | [[package]]
316 | name = "indexmap"
317 | version = "2.7.0"
318 | source = "registry+https://github.com/rust-lang/crates.io-index"
319 | checksum = "62f822373a4fe84d4bb149bf54e584a7f4abec90e072ed49cda0edea5b95471f"
320 | dependencies = [
321 |  "equivalent",
322 |  "hashbrown 0.15.2",
323 | ]
324 | 
325 | [[package]]
326 | name = "instant"
327 | version = "0.1.12"
328 | source = "registry+https://github.com/rust-lang/crates.io-index"
329 | checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
330 | dependencies = [
331 |  "cfg-if",
332 | ]
333 | 
334 | [[package]]
335 | name = "io-lifetimes"
336 | version = "1.0.11"
337 | source = "registry+https://github.com/rust-lang/crates.io-index"
338 | checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
339 | dependencies = [
340 |  "hermit-abi",
341 |  "libc",
342 |  "windows-sys 0.48.0",
343 | ]
344 | 
345 | [[package]]
346 | name = "is_terminal_polyfill"
347 | version = "1.70.1"
348 | source = "registry+https://github.com/rust-lang/crates.io-index"
349 | checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
350 | 
351 | [[package]]
352 | name = "itertools"
353 | version = "0.10.5"
354 | source = "registry+https://github.com/rust-lang/crates.io-index"
355 | checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
356 | dependencies = [
357 |  "either",
358 | ]
359 | 
360 | [[package]]
361 | name = "lazy_static"
362 | version = "1.4.0"
363 | source = "registry+https://github.com/rust-lang/crates.io-index"
364 | checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
365 | 
366 | [[package]]
367 | name = "libc"
368 | version = "0.2.147"
369 | source = "registry+https://github.com/rust-lang/crates.io-index"
370 | checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
371 | 
372 | [[package]]
373 | name = "libm"
374 | version = "0.2.6"
375 | source = "registry+https://github.com/rust-lang/crates.io-index"
376 | checksum = "348108ab3fba42ec82ff6e9564fc4ca0247bdccdc68dd8af9764bbc79c3c8ffb"
377 | 
378 | [[package]]
379 | name = "linux-raw-sys"
380 | version = "0.3.8"
381 | source = "registry+https://github.com/rust-lang/crates.io-index"
382 | checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
383 | 
384 | [[package]]
385 | name = "lock_api"
386 | version = "0.4.9"
387 | source = "registry+https://github.com/rust-lang/crates.io-index"
388 | checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df"
389 | dependencies = [
390 |  "autocfg",
391 |  "scopeguard",
392 | ]
393 | 
394 | [[package]]
395 | name = "memchr"
396 | version = "2.6.3"
397 | source = "registry+https://github.com/rust-lang/crates.io-index"
398 | checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c"
399 | 
400 | [[package]]
401 | name = "minimal-lexical"
402 | version = "0.2.1"
403 | source = "registry+https://github.com/rust-lang/crates.io-index"
404 | checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
405 | 
406 | [[package]]
407 | name = "nom"
408 | version = "7.1.3"
409 | source = "registry+https://github.com/rust-lang/crates.io-index"
410 | checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
411 | dependencies = [
412 |  "memchr",
413 |  "minimal-lexical",
414 | ]
415 | 
416 | [[package]]
417 | name = "nom_locate"
418 | version = "4.2.0"
419 | source = "registry+https://github.com/rust-lang/crates.io-index"
420 | checksum = "1e3c83c053b0713da60c5b8de47fe8e494fe3ece5267b2f23090a07a053ba8f3"
421 | dependencies = [
422 |  "bytecount",
423 |  "memchr",
424 |  "nom",
425 | ]
426 | 
427 | [[package]]
428 | name = "num-traits"
429 | version = "0.2.15"
430 | source = "registry+https://github.com/rust-lang/crates.io-index"
431 | checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
432 | dependencies = [
433 |  "autocfg",
434 |  "libm",
435 | ]
436 | 
437 | [[package]]
438 | name = "once_cell"
439 | version = "1.17.1"
440 | source = "registry+https://github.com/rust-lang/crates.io-index"
441 | checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
442 | 
443 | [[package]]
444 | name = "once_cell_polyfill"
445 | version = "1.70.1"
446 | source = "registry+https://github.com/rust-lang/crates.io-index"
447 | checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
448 | 
449 | [[package]]
450 | name = "parking_lot"
451 | version = "0.11.2"
452 | source = "registry+https://github.com/rust-lang/crates.io-index"
453 | checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
454 | dependencies = [
455 |  "instant",
456 |  "lock_api",
457 |  "parking_lot_core",
458 | ]
459 | 
460 | [[package]]
461 | name = "parking_lot_core"
462 | version = "0.8.6"
463 | source = "registry+https://github.com/rust-lang/crates.io-index"
464 | checksum = "60a2cfe6f0ad2bfc16aefa463b497d5c7a5ecd44a23efa72aa342d90177356dc"
465 | dependencies = [
466 |  "cfg-if",
467 |  "instant",
468 |  "libc",
469 |  "redox_syscall 0.2.16",
470 |  "smallvec",
471 |  "winapi",
472 | ]
473 | 
474 | [[package]]
475 | name = "ppv-lite86"
476 | version = "0.2.17"
477 | source = "registry+https://github.com/rust-lang/crates.io-index"
478 | checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
479 | 
480 | [[package]]
481 | name = "proc-macro2"
482 | version = "1.0.55"
483 | source = "registry+https://github.com/rust-lang/crates.io-index"
484 | checksum = "1d0dd4be24fcdcfeaa12a432d588dc59bbad6cad3510c67e74a2b6b2fc950564"
485 | dependencies = [
486 |  "unicode-ident",
487 | ]
488 | 
489 | [[package]]
490 | name = "proptest"
491 | version = "1.1.0"
492 | source = "registry+https://github.com/rust-lang/crates.io-index"
493 | checksum = "29f1b898011ce9595050a68e60f90bad083ff2987a695a42357134c8381fba70"
494 | dependencies = [
495 |  "bit-set",
496 |  "bitflags",
497 |  "byteorder",
498 |  "lazy_static",
499 |  "num-traits",
500 |  "quick-error 2.0.1",
501 |  "rand",
502 |  "rand_chacha",
503 |  "rand_xorshift",
504 |  "regex-syntax 0.6.28",
505 |  "rusty-fork",
506 |  "tempfile",
507 |  "unarray",
508 | ]
509 | 
510 | [[package]]
511 | name = "quick-error"
512 | version = "1.2.3"
513 | source = "registry+https://github.com/rust-lang/crates.io-index"
514 | checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
515 | 
516 | [[package]]
517 | name = "quick-error"
518 | version = "2.0.1"
519 | source = "registry+https://github.com/rust-lang/crates.io-index"
520 | checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
521 | 
522 | [[package]]
523 | name = "quote"
524 | version = "1.0.26"
525 | source = "registry+https://github.com/rust-lang/crates.io-index"
526 | checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc"
527 | dependencies = [
528 |  "proc-macro2",
529 | ]
530 | 
531 | [[package]]
532 | name = "rand"
533 | version = "0.8.5"
534 | source = "registry+https://github.com/rust-lang/crates.io-index"
535 | checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
536 | dependencies = [
537 |  "libc",
538 |  "rand_chacha",
539 |  "rand_core",
540 | ]
541 | 
542 | [[package]]
543 | name = "rand_chacha"
544 | version = "0.3.1"
545 | source = "registry+https://github.com/rust-lang/crates.io-index"
546 | checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
547 | dependencies = [
548 |  "ppv-lite86",
549 |  "rand_core",
550 | ]
551 | 
552 | [[package]]
553 | name = "rand_core"
554 | version = "0.6.4"
555 | source = "registry+https://github.com/rust-lang/crates.io-index"
556 | checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
557 | dependencies = [
558 |  "getrandom",
559 | ]
560 | 
561 | [[package]]
562 | name = "rand_xorshift"
563 | version = "0.3.0"
564 | source = "registry+https://github.com/rust-lang/crates.io-index"
565 | checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
566 | dependencies = [
567 |  "rand_core",
568 | ]
569 | 
570 | [[package]]
571 | name = "redox_syscall"
572 | version = "0.2.16"
573 | source = "registry+https://github.com/rust-lang/crates.io-index"
574 | checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
575 | dependencies = [
576 |  "bitflags",
577 | ]
578 | 
579 | [[package]]
580 | name = "redox_syscall"
581 | version = "0.3.5"
582 | source = "registry+https://github.com/rust-lang/crates.io-index"
583 | checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
584 | dependencies = [
585 |  "bitflags",
586 | ]
587 | 
588 | [[package]]
589 | name = "regex"
590 | version = "1.9.5"
591 | source = "registry+https://github.com/rust-lang/crates.io-index"
592 | checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47"
593 | dependencies = [
594 |  "aho-corasick",
595 |  "memchr",
596 |  "regex-automata",
597 |  "regex-syntax 0.7.5",
598 | ]
599 | 
600 | [[package]]
601 | name = "regex-automata"
602 | version = "0.3.8"
603 | source = "registry+https://github.com/rust-lang/crates.io-index"
604 | checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795"
605 | dependencies = [
606 |  "aho-corasick",
607 |  "memchr",
608 |  "regex-syntax 0.7.5",
609 | ]
610 | 
611 | [[package]]
612 | name = "regex-syntax"
613 | version = "0.6.28"
614 | source = "registry+https://github.com/rust-lang/crates.io-index"
615 | checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
616 | 
617 | [[package]]
618 | name = "regex-syntax"
619 | version = "0.7.5"
620 | source = "registry+https://github.com/rust-lang/crates.io-index"
621 | checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
622 | 
623 | [[package]]
624 | name = "retain_mut"
625 | version = "0.1.7"
626 | source = "registry+https://github.com/rust-lang/crates.io-index"
627 | checksum = "8c31b5c4033f8fdde8700e4657be2c497e7288f01515be52168c631e2e4d4086"
628 | 
629 | [[package]]
630 | name = "roaring"
631 | version = "0.10.1"
632 | source = "registry+https://github.com/rust-lang/crates.io-index"
633 | checksum = "ef0fb5e826a8bde011ecae6a8539dd333884335c57ff0f003fbe27c25bbe8f71"
634 | dependencies = [
635 |  "bytemuck",
636 |  "byteorder",
637 |  "retain_mut",
638 | ]
639 | 
640 | [[package]]
641 | name = "rustix"
642 | version = "0.37.27"
643 | source = "registry+https://github.com/rust-lang/crates.io-index"
644 | checksum = "fea8ca367a3a01fe35e6943c400addf443c0f57670e6ec51196f71a4b8762dd2"
645 | dependencies = [
646 |  "bitflags",
647 |  "errno",
648 |  "io-lifetimes",
649 |  "libc",
650 |  "linux-raw-sys",
651 |  "windows-sys 0.48.0",
652 | ]
653 | 
654 | [[package]]
655 | name = "rusty-fork"
656 | version = "0.3.0"
657 | source = "registry+https://github.com/rust-lang/crates.io-index"
658 | checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f"
659 | dependencies = [
660 |  "fnv",
661 |  "quick-error 1.2.3",
662 |  "tempfile",
663 |  "wait-timeout",
664 | ]
665 | 
666 | [[package]]
667 | name = "scopeguard"
668 | version = "1.1.0"
669 | source = "registry+https://github.com/rust-lang/crates.io-index"
670 | checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
671 | 
672 | [[package]]
673 | name = "smallvec"
674 | version = "1.10.0"
675 | source = "registry+https://github.com/rust-lang/crates.io-index"
676 | checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
677 | 
678 | [[package]]
679 | name = "strsim"
680 | version = "0.10.0"
681 | source = "registry+https://github.com/rust-lang/crates.io-index"
682 | checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
683 | 
684 | [[package]]
685 | name = "syn"
686 | version = "1.0.109"
687 | source = "registry+https://github.com/rust-lang/crates.io-index"
688 | checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
689 | dependencies = [
690 |  "proc-macro2",
691 |  "quote",
692 |  "unicode-ident",
693 | ]
694 | 
695 | [[package]]
696 | name = "syn"
697 | version = "2.0.13"
698 | source = "registry+https://github.com/rust-lang/crates.io-index"
699 | checksum = "4c9da457c5285ac1f936ebd076af6dac17a61cfe7826f2076b4d015cf47bc8ec"
700 | dependencies = [
701 |  "proc-macro2",
702 |  "quote",
703 |  "unicode-ident",
704 | ]
705 | 
706 | [[package]]
707 | name = "tempfile"
708 | version = "3.6.0"
709 | source = "registry+https://github.com/rust-lang/crates.io-index"
710 | checksum = "31c0432476357e58790aaa47a8efb0c5138f137343f3b5f23bd36a27e3b0a6d6"
711 | dependencies = [
712 |  "autocfg",
713 |  "cfg-if",
714 |  "fastrand",
715 |  "redox_syscall 0.3.5",
716 |  "rustix",
717 |  "windows-sys 0.48.0",
718 | ]
719 | 
720 | [[package]]
721 | name = "thiserror"
722 | version = "1.0.39"
723 | source = "registry+https://github.com/rust-lang/crates.io-index"
724 | checksum = "a5ab016db510546d856297882807df8da66a16fb8c4101cb8b30054b0d5b2d9c"
725 | dependencies = [
726 |  "thiserror-impl",
727 | ]
728 | 
729 | [[package]]
730 | name = "thiserror-impl"
731 | version = "1.0.39"
732 | source = "registry+https://github.com/rust-lang/crates.io-index"
733 | checksum = "5420d42e90af0c38c3290abcca25b9b3bdf379fc9f55c528f53a269d9c9a267e"
734 | dependencies = [
735 |  "proc-macro2",
736 |  "quote",
737 |  "syn 1.0.109",
738 | ]
739 | 
740 | [[package]]
741 | name = "unarray"
742 | version = "0.1.4"
743 | source = "registry+https://github.com/rust-lang/crates.io-index"
744 | checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
745 | 
746 | [[package]]
747 | name = "unicode-ident"
748 | version = "1.0.8"
749 | source = "registry+https://github.com/rust-lang/crates.io-index"
750 | checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
751 | 
752 | [[package]]
753 | name = "ustr"
754 | version = "0.9.0"
755 | source = "registry+https://github.com/rust-lang/crates.io-index"
756 | checksum = "371436099f2980de56dc385b615696d3eabbdac9649a72b85f9d75f68474fa9c"
757 | dependencies = [
758 |  "ahash 0.7.6",
759 |  "byteorder",
760 |  "lazy_static",
761 |  "parking_lot",
762 | ]
763 | 
764 | [[package]]
765 | name = "utf8parse"
766 | version = "0.2.1"
767 | source = "registry+https://github.com/rust-lang/crates.io-index"
768 | checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
769 | 
770 | [[package]]
771 | name = "version_check"
772 | version = "0.9.4"
773 | source = "registry+https://github.com/rust-lang/crates.io-index"
774 | checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
775 | 
776 | [[package]]
777 | name = "wait-timeout"
778 | version = "0.2.0"
779 | source = "registry+https://github.com/rust-lang/crates.io-index"
780 | checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
781 | dependencies = [
782 |  "libc",
783 | ]
784 | 
785 | [[package]]
786 | name = "wasi"
787 | version = "0.11.0+wasi-snapshot-preview1"
788 | source = "registry+https://github.com/rust-lang/crates.io-index"
789 | checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
790 | 
791 | [[package]]
792 | name = "winapi"
793 | version = "0.3.9"
794 | source = "registry+https://github.com/rust-lang/crates.io-index"
795 | checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
796 | dependencies = [
797 |  "winapi-i686-pc-windows-gnu",
798 |  "winapi-x86_64-pc-windows-gnu",
799 | ]
800 | 
801 | [[package]]
802 | name = "winapi-i686-pc-windows-gnu"
803 | version = "0.4.0"
804 | source = "registry+https://github.com/rust-lang/crates.io-index"
805 | checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
806 | 
807 | [[package]]
808 | name = "winapi-x86_64-pc-windows-gnu"
809 | version = "0.4.0"
810 | source = "registry+https://github.com/rust-lang/crates.io-index"
811 | checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
812 | 
813 | [[package]]
814 | name = "windows-link"
815 | version = "0.1.3"
816 | source = "registry+https://github.com/rust-lang/crates.io-index"
817 | checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
818 | 
819 | [[package]]
820 | name = "windows-sys"
821 | version = "0.48.0"
822 | source = "registry+https://github.com/rust-lang/crates.io-index"
823 | checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
824 | dependencies = [
825 |  "windows-targets 0.48.1",
826 | ]
827 | 
828 | [[package]]
829 | name = "windows-sys"
830 | version = "0.60.2"
831 | source = "registry+https://github.com/rust-lang/crates.io-index"
832 | checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
833 | dependencies = [
834 |  "windows-targets 0.53.3",
835 | ]
836 | 
837 | [[package]]
838 | name = "windows-targets"
839 | version = "0.48.1"
840 | source = "registry+https://github.com/rust-lang/crates.io-index"
841 | checksum = "05d4b17490f70499f20b9e791dcf6a299785ce8af4d709018206dc5b4953e95f"
842 | dependencies = [
843 |  "windows_aarch64_gnullvm 0.48.0",
844 |  "windows_aarch64_msvc 0.48.0",
845 |  "windows_i686_gnu 0.48.0",
846 |  "windows_i686_msvc 0.48.0",
847 |  "windows_x86_64_gnu 0.48.0",
848 |  "windows_x86_64_gnullvm 0.48.0",
849 |  "windows_x86_64_msvc 0.48.0",
850 | ]
851 | 
852 | [[package]]
853 | name = "windows-targets"
854 | version = "0.53.3"
855 | source = "registry+https://github.com/rust-lang/crates.io-index"
856 | checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91"
857 | dependencies = [
858 |  "windows-link",
859 |  "windows_aarch64_gnullvm 0.53.0",
860 |  "windows_aarch64_msvc 0.53.0",
861 |  "windows_i686_gnu 0.53.0",
862 |  "windows_i686_gnullvm",
863 |  "windows_i686_msvc 0.53.0",
864 |  "windows_x86_64_gnu 0.53.0",
865 |  "windows_x86_64_gnullvm 0.53.0",
866 |  "windows_x86_64_msvc 0.53.0",
867 | ]
868 | 
869 | [[package]]
870 | name = "windows_aarch64_gnullvm"
871 | version = "0.48.0"
872 | source = "registry+https://github.com/rust-lang/crates.io-index"
873 | checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
874 | 
875 | [[package]]
876 | name = "windows_aarch64_gnullvm"
877 | version = "0.53.0"
878 | source = "registry+https://github.com/rust-lang/crates.io-index"
879 | checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
880 | 
881 | [[package]]
882 | name = "windows_aarch64_msvc"
883 | version = "0.48.0"
884 | source = "registry+https://github.com/rust-lang/crates.io-index"
885 | checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
886 | 
887 | [[package]]
888 | name = "windows_aarch64_msvc"
889 | version = "0.53.0"
890 | source = "registry+https://github.com/rust-lang/crates.io-index"
891 | checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
892 | 
893 | [[package]]
894 | name = "windows_i686_gnu"
895 | version = "0.48.0"
896 | source = "registry+https://github.com/rust-lang/crates.io-index"
897 | checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
898 | 
899 | [[package]]
900 | name = "windows_i686_gnu"
901 | version = "0.53.0"
902 | source = "registry+https://github.com/rust-lang/crates.io-index"
903 | checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
904 | 
905 | [[package]]
906 | name = "windows_i686_gnullvm"
907 | version = "0.53.0"
908 | source = "registry+https://github.com/rust-lang/crates.io-index"
909 | checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
910 | 
911 | [[package]]
912 | name = "windows_i686_msvc"
913 | version = "0.48.0"
914 | source = "registry+https://github.com/rust-lang/crates.io-index"
915 | checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
916 | 
917 | [[package]]
918 | name = "windows_i686_msvc"
919 | version = "0.53.0"
920 | source = "registry+https://github.com/rust-lang/crates.io-index"
921 | checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
922 | 
923 | [[package]]
924 | name = "windows_x86_64_gnu"
925 | version = "0.48.0"
926 | source = "registry+https://github.com/rust-lang/crates.io-index"
927 | checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
928 | 
929 | [[package]]
930 | name = "windows_x86_64_gnu"
931 | version = "0.53.0"
932 | source = "registry+https://github.com/rust-lang/crates.io-index"
933 | checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
934 | 
935 | [[package]]
936 | name = "windows_x86_64_gnullvm"
937 | version = "0.48.0"
938 | source = "registry+https://github.com/rust-lang/crates.io-index"
939 | checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
940 | 
941 | [[package]]
942 | name = "windows_x86_64_gnullvm"
943 | version = "0.53.0"
944 | source = "registry+https://github.com/rust-lang/crates.io-index"
945 | checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
946 | 
947 | [[package]]
948 | name = "windows_x86_64_msvc"
949 | version = "0.48.0"
950 | source = "registry+https://github.com/rust-lang/crates.io-index"
951 | checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
952 | 
953 | [[package]]
954 | name = "windows_x86_64_msvc"
955 | version = "0.53.0"
956 | source = "registry+https://github.com/rust-lang/crates.io-index"
957 | checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
958 | 


--------------------------------------------------------------------------------