bash-completion

For CLIs - most reasonable commands either have a `-h`, `--help`, `-help`, `/?`, or what have you. And manpages exist. Hunt the verb isn't really a problem for CLIs. And furthermore - aren't there shells that will give you the --help if you try to tab-complete certain commands? Obviously there's the issue of a lack of standardization for how command-line switches work, but broadly speaking it's not difficult to have a list of common (or even uncommon) commands and how their args work. (spends a few minutes researching...) This project evidently exists, and I think it's even fairly well supported in e.g. Debian-based systems: https://github.com/scop/bash-completion.

I was referring to the bash-completion project, the default on Debian/Ubuntu - https://github.com/scop/bash-completion/ But yes, ble.sh also has a shell parser in shell, although it uses a state machine style that's more principled than bash regex / sed crap. --- Also, distro build systems like Alpine Linux and others tend to parse shell in shell (or with sed). They often need package metadata without executing package builds, so they do that by trying to parse shell. In YSH, you will be able to do that with reflection, basically like Lisp/Python/Ruby, rather than ad hoc parsing. --- I'm glad to hear you can see the effect of the optimizations ! That took a long time :-) Some more benchmarks here, which I'll write about: https://oils.pub/release/0.33.0/benchmarks.wwz/osh-runtime/

I have the same habit. The lack of tilde expansion after the equals sign has helped a bit in breaking this habit, however. Interestingly, bash does do tilde expansion, but not tab completion, after the first equal sign, and after every colon, in variable-style arguments: $ /bin/echo --foo=~ bar=~:~root --foo=~ bar=/home/jtm:/root While tab completion can be fixed in appropriate contexts using custom completion functions (e.g., [1]), AFAIK there's no way to customize tilde expansion contexts (other than the fact that tilde expanding variable-style arguments is disabled in POSIX mode). [1] https://github.com/scop/bash-completion/blob/8a8880db78e9b04...

Bash-completion does something like this for commands with consistent --help output (most Coreutils, bash, awk, grep, sed...) by parsing it in the completion function: https://github.com/scop/bash-completion/blob/29508ce70914f78...

> - Oh-my-zsh has a lot of plugins for auto-completion As does bash-completion, which is available in many (but not all :-/) Linux distros and via Homebrew on MacOS and [pre-dates](https://github.com/scop/bash-completion/tree/09b07d57a7031d9...) [oh-my-zsh](https://github.com/ohmyzsh/ohmyzsh/tree/5da20b9dddb1f7a91106...) by about 6 years. But, zsh users and oh-my-zsh fan-boys seem to be entirely ignorant of bash-completion.

When you install bash-completion on your system, usually a function is defined to autocomplete make rules for you. It works with all projects, as it does not rely on the rules being specially marked. (https://github.com/scop/bash-completion/blob/master/completi...) Before I knew about it, I had written a similar thing: # Autocomplete make rules _make () { local cur prev words cword cmdline _init_completion || return # command to generate the rules words="$(make -pRrq |\ awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($1 !~ "^[#.]") {print $1}}' |\ sort | egrep -v -e '^[^[:alnum:]]' | xargs)" COMPREPLY+=( $( compgen -W "$words" -- $cur) ) } if declare -f _init_completion > /dev/null; then complete -F _make make fi It relies o

bash-completion provides sufficiently smart completions for dd: https://github.com/scop/bash-completion/blob/master/completi...

These [0] two [1] sections of the GNU Bash man pages were very useful. I also found that this tutorial [2] provided a useful perspective. I spent a small amount of time looking through the bash-completion [3] project as well as the git bash completions [4]. Generally, my process for writing is google around until I have some base level of knowledge, then building one or more demo applications to ensure my understanding is correct. Then as I'm writing the blog post I'll be refining the demo applications into examples for the blog post and/or library code that I want to open source. [0]: https://www.gnu.org/software/bash/manual/html_node/Programma... [1]: https://www.gnu.org/software/bash/manual/html_node/Programma... [2]: https://hackaday.com/2018/01/19/linux-fu-custom-bash-command... [3]: https://github.com/scop/bash-completion [4]: https

I'm working in this area right now if you want to help :) http://www.oilshell.org/ I took a survey of what people use here: https://lobste.rs/s/z96uyr/survey_what_shell_completion_scri... That produced a link to this old project which tried to do something like what you want: a completion system that works for multiple shells (in this case, by code generation from a DSL) https://github.com/mbrubeck/compleat It's easy for you to say "completion should be specified in the binary" without actually specifying HOW. That's not straightforward, although I agree it's a good goal. ----- Right now I'm implementing a bash-compatible completion API, and I'm actually getting pretty far without too much code. git-completion.bash is 3000 lines of code, so it's actually easier to emulate bash (with all its warts) than to write an entirely new completio

Bash has programmable completion as well. See for example: https://github.com/scop/bash-completion