System.CommandLine.StaticCompletions
Extensions for marking options or arguments require dynamic completions. Such symbols get special handling
in the static completion generation logic.
The state that is used to track which symbols are dynamic.
Indicates whether this option requires a dynamic call into the dotnet process to compute completions.
Indicates whether this argument requires a dynamic call into the dotnet process to compute completions.
Create a unique shell function name for a command - these names should be
* distinct from the 'root' command's name (i.e. we should not generate the function name 'dotnet' for the binary 'dotnet')
* distinct based on 'path' to get to this function (hence the parentCommandNames)
The chain of commands to get to this command
Sanitizes a function name to be safe for bash
Get all names for an option, including the primary name and all aliases
Get all names for a command, including the primary name and all aliases
Generates a call to dotnet complete <string> --position <int> for dynamic completions where necessary, but in a more generic way
TODO: this is currently bound to the .NET CLI's 'dotnet complete' command - this should be definable/injectable per-host instead.
Emit a bash command that calls compgen with a set of choices given the current work/stem, and sets those choices to COMPREPLY.
Think of this like a 'return' from a function.
The expression used to generate the set of choices - will be passed to compgen with the -W flag, so should be either
* a concrete set of choices in a bash array already ($opts), or
* a subprocess that will return such an array (aka '(dotnet complete --position 10 'dotnet ad')')
Generates a concrete set of bash completion selection for a given option.
If the option's completions are dynamic, this will emit a call to the dynamic completion function (dotnet complete)
to get completions when the user requests completions for this option.
a bash switch case expression for providing completions for this option
Recursively collect all visible commands into a flat list with numeric state IDs.
State 0 is the root command.
Write the command line tokenization logic.
Uses fish's commandline builtin to get completed tokens up to the cursor.
Generate the state machine that walks completed tokens to determine which subcommand context we're in.
For each state, we check if the current word matches a known subcommand (transitioning to that subcommand's state)
or a value-taking option (skipping tokens for the option's value(s), respecting the option's arity).
Emit a fish loop that skips value tokens after a multi-value option.
Stops when it has consumed maxValues tokens, or encounters a token starting with '-',
whichever comes first. For unbounded arities, only the '-' check applies.
Generate option value completions.
Scans backward through completed tokens to find the nearest option, then checks whether
we're still within that option's arity. This correctly handles both single-value and
multi-value options (e.g. --sources foo bar with arity 3 still offers completions
for the third value).
Generate the main completion output for each state.
Emits subcommands, options, and positional argument completions for the current context.
Write a single completion candidate line with an optional description.
Fish uses tab-separated format: candidate\tdescription
Generate a dynamic completion call that invokes the binary's 'complete' subcommand.
Uses the actual command from the command line ($tokens[1]) so it works regardless of how the binary was invoked.
TODO: this is currently bound to the .NET CLI's 'complete' command pattern - this should be definable/injectable per-host instead.
Escape a string for use in a fish single-quoted string.
Fish single-quoted strings support \' and \\ as escape sequences.
Generations completion-list items for the names of the given option. Typically used by commands/subcommands for static lookup lists.
Generate completions for the statically-known arguments
Generate completions for the subcommands of a given command. Each subcommand generates a list of switches for the staticly-known flags and arguments.
Dynamically-generated completions are not yet supported
Generate completions for the statically-known options, arguments, and subcommands of a given command.
Generate a call into `dotnet complete` for dynamic argument completions, then binds the returned values as CompletionResults.
TODO: this is currently bound to the .NET CLI's 'dotnet complete' command - this should be definable/injectable per-host instead.
Provides and manages completions scripts for a specific shell.
The name of this shell as exposed on the completion command line arguments.
The file extension typically used for this shell's completions scripts (sans period).
This will be used when specifying the shell in CLI completions and help text. Use it to provide any specific details about the shell.
For example, the PowershellShellProvider will clarify that it only works for PowerShell Core.
Generates a shell-specific completions script for the given command tree.
Commands for generating and registering completions for supported shells
The shell for which to generate or register completions
Could not determine the shell from the environment - the SHELL environment variable was not set.
The shell application '{0}' is not supported. The following shells are supported by this application: {1}
Generate the completion script for a supported shell
Generates a completion script for the Bourne Again SHell (bash).
Generates a completion script for PowerShell Core. These scripts will not work on Windows PowerShell.
Generates a completion script for the Fish shell.
Generates a completion script for the Zsh shell.
Generates a completion script for the NuShell shell.