—

              
#!perl
# FRAGMENT id=shcompgen-nohint
use 5.010001;
use strict;
use warnings;
use App::shcompgen;
use Perinci::CmdLine::Any;
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2022-10-07'; # DATE
our $DIST = 'App-shcompgen'; # DIST
our $VERSION = '0.325'; # VERSION
my $urlprefix = '/App/shcompgen/';
Perinci::CmdLine::Any->new(
    url => $urlprefix,
    log => $ENV{LOG} // 1,
    subcommands => {
        init     => {url=>"${urlprefix}init"},
        generate => {url=>"${urlprefix}generate"},
        list     => {url=>"${urlprefix}list"},
        remove   => {url=>"${urlprefix}remove"},
        'guess-shell' => {url=>"${urlprefix}guess_shell", summary => "(Utility) detect a program", tags=>["category:utility"]},
        'detect-prog' => {url=>"${urlprefix}detect_prog", summary => "(Utility) Guess running shell", tags=>["category:utility"]},
    },
)->run;
# ABSTRACT: Generate shell completion scripts
# PODNAME: shcompgen
__END__
HideShow 742 lines of Pod
=pod
=encoding UTF-8
=head1 NAME
shcompgen - Generate shell completion scripts
=head1 VERSION
This document describes version 0.325 of shcompgen (from Perl distribution App-shcompgen), released on 2022-10-07.
=head1 SYNOPSIS
Initialize (this will create completion scripts directory, create shell script
to initialize completion system):
 % shcompgen init
Generate shell completion scripts for all detectable programs in PATH:
 % shcompgen generate
Note that this distribution automatically runs 'init' and 'generate' the first
time it is installed, or when you upgrade from an older version. So normally you
don't have to do this manually.
Generate some programs only, replace if previously already exists, be verbose:
 % shcompgen generate --verbose --replace prog1 prog2 ./bin/prog3
List all shell completion scripts generated by us:
 % shcompgen list
 % shcompgen list --detail
Remove some shell completion scripts:
 % shcompgen remove prog1 prog2
Remove all generated shell completion scripts:
 % shcompgen remove
=head1 DESCRIPTION
Some shells, like bash/fish/zsh/tcsh, supports tab completion for programs. They
are usually activated by issuing one or more C<complete> (zsh uses C<compctl>)
internal shell commands. The completion scripts which contain these commands are
usually put in (e.g., for fish) C</etc/fish/completion/PROGNAME.fish> (if one
wants to install globally) or C<~/.config/fish/completions/PROGNAME.fish> (if
one wants to install per-user).
This utility, B<shcompgen>, can detect how to generate shell completion scripts
for some programs and then install the completion scripts into the
abovementioned location (the default is to per-user directory, but if running as
root or with C<--global> switch will install to the global directory).
It can also list all completion scripts generated by it, and be instructed to
uninstall them again.
It supports several shells, currently: bash, fish, zsh, and tcsh. Shell-specific
information can be found below.
=head2 Shell-specific information
=head3 bash
This script can work with the C<bash-completion> package (and uses the same
global completion directory: C</etc/bash_completion.d>). At the time of this
writing, bash-completion (at version 2.1) does not yet look at per-user
completion scripts directory. This script picks
C<~/.config/bash/completions/PROGNAME> as location for per-user completion
scripts. If later on C<bash-completion> package decides on a different per-user
location, this script will probably be adjusted too.
=head3 fish
Known issues include proper escaping of completion answer (e.g. when an answer
contains a whitespace). To demonstrate this problem, try
L<peri-eg-complete-fruits-any> and type:
 % peri-eg-complete-fruits-any --fruit <tab>
The answer C<butternut squash> is returned as C<butternut\\\ squash>.
=head3 tcsh
So far I couldn't get fallback (a.k.a catch-all) completion mechanism to work in
tcsh. For example if I do:
 complete '*' 'p/*/`helper`/'
then it will eclipse the other existing completion definitions.
So in tcsh, activating (or deactivating) completion is currently less convenient
compared to the other shells. Instead of the C<complete> definitions being put
on a per-command basis in C<~/.config/tcsh/completions/> directory, the init
script C<~/.config/shcompgen.tcsh> will directly contain all the C<complete>
definitions. This script must be sourced to update the definitions. So after you
 % shcompgen generate foo
you will need to re-source the init script (or logout from + login back to the
shell). And after you remove a completion script, you will need to C<uncomplete>
+ re-source the init script (or logout from + login back to the shell).
Known issues include proper escaping of completion answer (e.g. when an answer
contains a whitespace). To demonstrate this problem, try
L<peri-eg-complete-fruits-any> and type:
 % peri-eg-complete-fruits-any --fruit <tab>
The answer C<butternut squash> is only returned as C<butternut\\ >.
=head3 zsh
Known issues include proper escaping of completion answer (e.g. when an answer
contains a whitespace). To demonstrate this problem, try
L<peri-eg-complete-fruits-any> and type:
 % peri-eg-complete-fruits-any --fruit <tab>
The answer C<butternut squash> is only returned as C<butternut\\ >.
Another known issue is still having to C<compinit> after C<shcompgen generate>
or C<shcompgen remove>.
And yet another known issue is having to C<compinit> in the init script
(C<~/.config/shcompgen.zsh>) which is slowing down the shell startup.
=head2 Program detection
Below are the types/kinds of programs that can be detected. Expect the list to
expand as more methods are added.
=over
=item * Scripts which are tagged with hints of what completion program to use
You can put this line in a script, e.g. in a script called C<foo>:
 # FRAGMENT id=shcompgen-hint command=bar
The above line tells C<shcompgen> that the script should be completed using an
external program called C<bar>. This will construct this completion script, e.g.
for bash:
 complete -C bar foo
=item * Completion programs which are tagged with hints of what programs they complete
You can create a completion script in Perl (or other language, actually), e.g.
C<_foo> and tag it with hints of what programs they complete, e.g.
 # FRAGMENT id=shcompgen-hint completer=1 for=foo,foo-this-host
This will add completion script for C<foo>:
 complete -C _foo foo
as well as for C<foo-this-host>:
 complete -C _foo foo-this-host
=item * Getopt::Long::Complete-based CLI scripts
If a script C<foo> is detected as a Perl script using L<Getopt::Long::Complete>,
we know that it can complete itself. Thus, C<shcompgen> will generate this
completion script (e.g. for bash):
 complete -C foo foo
=item * Getopt::Long::Subcommand-based CLI scripts
If a script C<foo> is detected as a Perl script using
L<Getopt::Long::Subcommand>, we know that it can complete itself. Thus,
C<shcompgen> will generate this completion script (e.g. for bash):
 complete -C foo foo
=item * Getopt::Long-based CLI scripts
If a script C<foo> is detected as a Perl script using L<Getopt::Long>,
C<shcompgen> will try to extract the Getopt::Long spec specified by
C<GetOptions>, which can then tell it what options a script accepts. The
completion script cannot complete option values or arguments though, as there is
not enough information to do that. If you write the script, you might want to
switch to L<Getopt::Long::Complete> or L<Getopt::Long::Subcommand> for better
tab completion support.
=item * Getopt::Long::EvenLess-based CLI scripts
Basically the same as Getopt::Long-based scripts.
=item * Getopt::Long::Descriptive-based CLI scripts
Basically the same as Getopt::Long-based scripts.
=item * Getopt::Std-based CLI scripts
Basically the same as Getopt::Long-based scripts.
=item * Perinci::CmdLine-based CLI scripts
If a script like C<foo> is detected as a Perl script using L<Perinci::CmdLine>
(or its variant like L<Perinci::CmdLine::Lite> or L<Perinci::CmdLine::Any>) we
know that it can complete itself. Thus, C<shcompgen> will add this completion
script e.g. for bash:
 complete -C foo foo
=item * Other methods
Other methods will be added in the future, e.g. by parsing manpage or POD, and
so on.
=back
=head1 SUBCOMMANDS
=head2 B<detect-prog>
(Utility) Guess running shell.
=head2 B<generate>
Generate shell completion scripts for detectable programs.
=head2 B<guess-shell>
(Utility) detect a program.
=head2 B<init>
Initialize shcompgen.
This subcommand creates the completion directories and initialization shell
script, as well as run C<generate>.
=head2 B<list>
List all shell completion scripts generated by this script.
=head2 B<remove>
Remove shell completion scripts generated by this script.
=head1 OPTIONS
C<*> marks required options.
=head2 Common options
=over
=item B<--config-path>=I<s>, B<-c>
Set path to configuration file.
Can actually be specified multiple times to instruct application to read from
multiple configuration files (and merge them).
=item B<--config-profile>=I<s>, B<-P>
Set configuration profile to use.
A single configuration file can contain profiles, i.e. alternative sets of
values that can be selected. For example:
 [profile=dev]
 username=foo
 pass=beaver
  
 [profile=production]
 username=bar
 pass=honey
When you specify C<--config-profile=dev>, C<username> will be set to C<foo> and
C<password> to C<beaver>. When you specify C<--config-profile=production>,
C<username> will be set to C<bar> and C<password> to C<honey>.
=item B<--debug>
Shortcut for --log-level=debug.
=item B<--fish>
Shortcut for --shell=fish.
See C<--shell>.
=item B<--format>=I<s>
Choose output format, e.g. json, text.
Default value:
 undef
Output can be displayed in multiple formats, and a suitable default format is
chosen depending on the application and/or whether output destination is
interactive terminal (i.e. whether output is piped). This option specifically
chooses an output format.
=item B<--help>, B<-h>, B<-?>
Display help message and exit.
=item B<--json>
Set output format to json.
=item B<--log-level>=I<s>
Set log level.
By default, these log levels are available (in order of increasing level of
importance, from least important to most): C<trace>, C<debug>, C<info>,
C<warn>/C<warning>, C<error>, C<fatal>. By default, the level is usually set to
C<warn>, which means that log statements with level C<info> and less important
levels will not be shown. To increase verbosity, choose C<info>, C<debug>, or
C<trace>.
For more details on log level and logging, as well as how new logging levels can
be defined or existing ones modified, see L<Log::ger>.
=item B<--naked-res>
When outputing as JSON, strip result envelope.
Default value:
 0
By default, when outputing as JSON, the full enveloped result is returned, e.g.:
 [200,"OK",[1,2,3],{"func.extra"=>4}]
The reason is so you can get the status (1st element), status message (2nd
element) as well as result metadata/extra result (4th element) instead of just
the result (3rd element). However, sometimes you want just the result, e.g. when
you want to pipe the result for more post-processing. In this case you can use
C<--naked-res> so you just get:
 [1,2,3]
=item B<--no-config>, B<-C>
Do not use any configuration file.
If you specify C<--no-config>, the application will not read any configuration
file.
=item B<--no-env>
Do not read environment for default options.
If you specify C<--no-env>, the application wil not read any environment
variable.
=item B<--page-result>
Filter output through a pager.
This option will pipe the output to a specified pager program. If pager program
is not specified, a suitable default e.g. C<less> is chosen.
=item B<--quiet>
Shortcut for --log-level=error.
=item B<--shell>=I<s>
Override guessing and select shell manually.
Valid values:
 ["bash","fish","zsh","tcsh"]
=item B<--subcommands>
List available subcommands.
=item B<--tcsh>
Shortcut for --shell=tcsh.
See C<--shell>.
=item B<--trace>
Shortcut for --log-level=trace.
=item B<--verbose>
Shortcut for --log-level=info.
=item B<--version>, B<-v>
Display program's version and exit.
=item B<--view-result>
View output using a viewer.
This option will first save the output to a temporary file, then open a viewer
program to view the temporary file. If a viewer program is not chosen, a
suitable default, e.g. the browser, is chosen.
=item B<--zsh>
Shortcut for --shell=zsh.
See C<--shell>.
=back
=head2 Options for subcommand detect-prog
=over
=item B<--prog>=I<s>*
Can also be specified as the 1st command-line argument.
=back
=head2 Options for subcommand generate
=over
=item B<--per-option>
Create per-option completion script if possible.
If set to true, then attempt to create completion script that register each
option. This creates nicer completion in some shells, e.g. fish and zsh. For
example, option description can be shown.
This is possible for only some types of scripts, e.g. L<Perinci::CmdLine>-
(that does not have subcommands) or L<Getopt::Long::Descriptive>-based ones.
=item B<--prog-json>=I<s>
Program(s) to generate completion for (JSON-encoded).
See C<--prog>.
Can also be specified as the 1st command-line argument and onwards.
=item B<--prog>=I<s@>
Program(s) to generate completion for.
Can contain path (e.g. C<../foo>) or a plain word (C<foo>) in which case will be
searched from PATH.
Can also be specified as the 1st command-line argument and onwards.
Can be specified multiple times.
=item B<--remove>
Remove completion for script that (now) is not detected to have completion.
The default behavior is to simply ignore existing completion script if the
program is not detected to have completion. When the C<remove> setting is
enabled, however, such existing completion script will be removed.
=item B<--replace>
Replace existing script.
The default behavior is to skip if an existing completion script exists.
=item B<--stdout>
Output completion script to STDOUT.
=back
=head2 Options for subcommand init
=over
=item B<--per-option>
Create per-option completion script if possible.
If set to true, then attempt to create completion script that register each
option. This creates nicer completion in some shells, e.g. fish and zsh. For
example, option description can be shown.
This is possible for only some types of scripts, e.g. L<Perinci::CmdLine>-
(that does not have subcommands) or L<Getopt::Long::Descriptive>-based ones.
=back
=head2 Options for subcommand list
=over
=item B<--detail>, B<-l>
=item B<--per-option>
Create per-option completion script if possible.
If set to true, then attempt to create completion script that register each
option. This creates nicer completion in some shells, e.g. fish and zsh. For
example, option description can be shown.
This is possible for only some types of scripts, e.g. L<Perinci::CmdLine>-
(that does not have subcommands) or L<Getopt::Long::Descriptive>-based ones.
=back
=head2 Options for subcommand remove
=over
=item B<--per-option>
Create per-option completion script if possible.
If set to true, then attempt to create completion script that register each
option. This creates nicer completion in some shells, e.g. fish and zsh. For
example, option description can be shown.
This is possible for only some types of scripts, e.g. L<Perinci::CmdLine>-
(that does not have subcommands) or L<Getopt::Long::Descriptive>-based ones.
=item B<--prog-json>=I<s>
Program(s) to remove completion script of (JSON-encoded).
See C<--prog>.
Can also be specified as the 1st command-line argument and onwards.
=item B<--prog>=I<s@>
Program(s) to remove completion script of.
Can contain path (e.g. C<../foo>) or a plain word (C<foo>) in which case will be
searched from PATH.
Can also be specified as the 1st command-line argument and onwards.
Can be specified multiple times.
=back
=head1 COMPLETION
This script has shell tab completion capability with support for several
shells.
=head2 bash
To activate bash completion for this script, put:
 complete -C shcompgen shcompgen
in your bash startup (e.g. F<~/.bashrc>). Your next shell session will then
recognize tab completion for the command. Or, you can also directly execute the
line above in your shell to activate immediately.
It is recommended, however, that you install modules using L<cpanm-shcompgen>
which can activate shell completion for scripts immediately.
=head2 tcsh
To activate tcsh completion for this script, put:
 complete shcompgen 'p/*/`shcompgen`/'
in your tcsh startup (e.g. F<~/.tcshrc>). Your next shell session will then
recognize tab completion for the command. Or, you can also directly execute the
line above in your shell to activate immediately.
It is also recommended to install L<shcompgen> (see above).
=head2 other shells
For fish and zsh, install L<shcompgen> as described above.
=head1 CONFIGURATION FILE
This script can read configuration files. Configuration files are in the format of L<IOD>, which is basically INI with some extra features.
By default, these names are searched for configuration filenames (can be changed using C<--config-path>): F</home/u1/.config/shcompgen.conf>, F</home/u1/shcompgen.conf>, or F</etc/shcompgen.conf>.
All found files will be read and merged.
To disable searching for configuration files, pass C<--no-config>.
To put configuration for a certain subcommand only, use a section name like C<[subcommand=NAME]> or C<[SOMESECTION subcommand=NAME]>.
You can put multiple profiles in a single file by using section names like C<[profile=SOMENAME]> or C<[SOMESECTION profile=SOMENAME]> or C<[subcommand=SUBCOMMAND_NAME profile=SOMENAME]> or C<[SOMESECTION subcommand=SUBCOMMAND_NAME profile=SOMENAME]>. Those sections will only be read if you specify the matching C<--config-profile SOMENAME>.
You can also put configuration for multiple programs inside a single file, and use filter C<program=NAME> in section names, e.g. C<[program=NAME ...]> or C<[SOMESECTION program=NAME]>. The section will then only be used when the reading program matches.
You can also filter a section by environment variable using the filter C<env=CONDITION> in section names. For example if you only want a section to be read if a certain environment variable is true: C<[env=SOMEVAR ...]> or C<[SOMESECTION env=SOMEVAR ...]>. If you only want a section to be read when the value of an environment variable equals some string: C<[env=HOSTNAME=blink ...]> or C<[SOMESECTION env=HOSTNAME=blink ...]>. If you only want a section to be read when the value of an environment variable does not equal some string: C<[env=HOSTNAME!=blink ...]> or C<[SOMESECTION env=HOSTNAME!=blink ...]>. If you only want a section to be read when the value of an environment variable includes some string: C<[env=HOSTNAME*=server ...]> or C<[SOMESECTION env=HOSTNAME*=server ...]>. If you only want a section to be read when the value of an environment variable does not include some string: C<[env=HOSTNAME!*=server ...]> or C<[SOMESECTION env=HOSTNAME!*=server ...]>. Note that currently due to simplistic parsing, there must not be any whitespace in the value being compared because it marks the beginning of a new section filter or section name.
To load and configure plugins, you can use either the C<-plugins> parameter (e.g. C<< -plugins=DumpArgs >> or C<< -plugins=DumpArgs@before_validate_args >>), or use the C<[plugin=NAME ...]> sections, for example:
 [plugin=DumpArgs]
 -event=before_validate_args
 -prio=99
  
 [plugin=Foo]
 -event=after_validate_args
 arg1=val1
 arg2=val2
  
which is equivalent to setting C<< -plugins=-DumpArgs@before_validate_args@99,-Foo@after_validate_args,arg1,val1,arg2,val2 >>.
List of available configuration parameters:
=head2 Common for all subcommands
 format (see --format)
 log_level (see --log-level)
 naked_res (see --naked-res)
 shell (see --shell)
=head2 Configuration for subcommand detect-prog
 prog (see --prog)
=head2 Configuration for subcommand generate
 per_option (see --per-option)
 prog (see --prog)
 remove (see --remove)
 replace (see --replace)
 stdout (see --stdout)
=head2 Configuration for subcommand guess-shell
=head2 Configuration for subcommand init
 per_option (see --per-option)
=head2 Configuration for subcommand list
 detail (see --detail)
 per_option (see --per-option)
=head2 Configuration for subcommand remove
 per_option (see --per-option)
 prog (see --prog)
=head1 ENVIRONMENT
=head2 SHCOMPGEN_OPT
String. Specify additional command-line options.
=head1 FILES
=head2 /home/u1/.config/shcompgen.conf
=head2 /home/u1/shcompgen.conf
=head2 /etc/shcompgen.conf
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/App-shcompgen>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-App-shcompgen>.
=head1 SEE ALSO
L<Dist::Zilla::Plugin::GenShellCompletion>
=head1 AUTHOR
perlancar <perlancar@cpan.org>
=head1 CONTRIBUTING
To contribute, you can send patches by email/via RT, or send pull requests on
GitHub.
Most of the time, you don't need to build the distribution yourself. You can
simply modify the code, then test via:
 % prove -l
If you want to build the distribution (e.g. to try to install it locally on your
system), you can install L<Dist::Zilla>,
L<Dist::Zilla::PluginBundle::Author::PERLANCAR>,
L<Pod::Weaver::PluginBundle::Author::PERLANCAR>, and sometimes one or two other
Dist::Zilla- and/or Pod::Weaver plugins. Any additional steps required beyond
that are considered a bug and can be reported to me.
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2022, 2020, 2018, 2017, 2016, 2015, 2014 by perlancar <perlancar@cpan.org>.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=head1 BUGS
Please report any bugs or feature requests on the bugtracker website L<https://rt.cpan.org/Public/Dist/Display.html?Name=App-shcompgen>
When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.
=cut