Outputs text as a match for the active completion.
Returns the least-common-denominator of matches. It is assumed that text was the input to generate matches. As such it is expected that each match starts with text.
Returns a match by index from the matches output by clink.add_match().
Given a needle (such as the section of the current line buffer being completed), this function returns true or false if candidate begins with needle. Readline's -/_ case-mapping is respected if it is enabled.
Checks each match in the table matches and checks to see if they are all duplicates of each other.
Returns the number of matches output by calls to clink.add_match().
This variable can be set to a function so that matches can be filtered before they are displayed. See Display Filtering section for more info.
Tells Readline that the matches we are passing back to it are files. This will cause Readline to append the path separator character to the line if there's only one match, and mark directories when displaying multiple matches.
Registers a match generator function that is called to generate matches when the complete keys is press (TAB by default).
The generator function takes the form generator_function(text, first, last) where text is the portion of the line buffer that is to be completed, first and last are the start and end indices into the line buffer for text.
Explicitly sets match at index to value.
Adds more positional arguments to the parser. See parser:set_arguments().
Adds more flags to the parser. See parser:set_flags().
Ordinarily Clink only loosely matches word as it traverses a parser. Calling this will make Clink only accept an exact matching word to consider moving onto the next one.
If this is called then Clink will not default to matching the file system if parsing comes to an end or can not be completed.
Prints the parser to stdout.
This runs the parser for the table of words parts. It returns a table of argument options. It is this method that Clink uses internally.
Returns true of word is a valid flag.
By default parsers do not loop and parsing comes to an end when there are no more arguments to traverse through. If loop() is called Clink will loop back to argument at index rather than terminating the parse.
This method sets the parser's positional arguments. Each of the variable number of arguments to the method is a table of potential options for the argument at that position. Note that calling this method replaces any existing positional arguments the parser may already have. Use parser:add_arguments() to append more positional arguments.
Sets the parser's flags (which can be thought of as position independent arguments). Each argument is a string and must start with the expected flag prefix ("-" by default). Be aware that calling set_flags() will replace the parser's existing flags. To add more use parser:add_flags().
Used to register a filter function to pre-process the prompt before use by Readline. Filters are called by sort_id where lower sort ids get called first. Filter functions will receive no arguments and return true if filtering is finished. Getting and setting the prompt value is done through the clink.prompt.value variable.
User-provided prompt filter functions can get and set the prompt value using this variable.
Changes the current working directory to path. Clink caches and restores the working directory between calls to the match generation so that it does not interfere with the processes normal operation.
Returns a table (array) of directories that match the supplied mask. If case_map is true then Clink will adjust the last part of the mask's path so that returned matches respect Readline's case-mapping feature (if it is enabled). For example; .\foo_foo\bar_bar* becomes .\foo_foo\bar?bar*.
There is no support for recursively traversing the path in mask.
Returns a table (array) of files that match the supplied mask. See find_dirs for details on the case_map argument.
There is no support for recursively traversing the path in mask.
Returns the current working directory.
Returns a table of all the registered console aliases. Windows' console alias API is exposed via doskey or progromatically via the AddConsoleAlias() function.
Returns the value of the environment variable env_var_name. This is preferable to the built-in Lua function os.getenv() as the latter uses a cached version of the current process' environment which can result in incorrect results.
Returns a table of the names of the current process' environment variables.
Returns the name of the host process (the rl_readline_name variable).
Returns a table describing the current console buffer's state with the following contents;
{
-- Dimensions of the console's buffer.
buffer_width
buffer_height
-- Dimensions of the visible area of the console buffer.
window_width
window_height
}Retrieves the Clink setting name, returning it as a string. See Settings for more information on the available settings.
As clink.get_setting_str but returning a number instead.
Returns true if path resolves to a directory.
Returns the boolean value of a Readline variable. These can be set with the clink_inputrc file, more details of which can be found in the Readline manual.
Same as os.lower() but respects Readline's case-mapping feature which will consider - and _ as case insensitive.
Care should be taken when using this to generate masks for file/dir find operations due to the -/_ giving different results (unless of course Readline's extended case-mapping is disabled).
Globs files using pattern and adds results as matches. If full_path is true then the path from pattern is prefixed to the results (otherwise only the file names are included). The last argument find_func is the function to use to do the globbing. If it's unspecified (or nil) Clink falls back to clink.find_files.
Calls clink.is_match() on each word in the table words and adds matches to Clink that match the needle text.
This function takes the string str which is quoted by ql (the opening quote character) and qr (the closing character) and splits it into parts as per the quotes. A table of these parts is returned.
clink.quote_split("pre(middle)post", "(", ")") = {
"pre", "middle", "post"
}Controls how Clink will translate the path separating slashes for the current path being completed. Values for type are;
- -1 - no translation
- 0 - to backslashes
- 1 - to forward slashes.
Splits the string str into pieces separated by sep, returning a table of the pieces.
This stops Readline from adding a trailing character when completion is finished (usually when a single match is returned). The suffixing of a character is enabled before completion functions are called so a call to this will only apply for the current completion.
By default Readline appends a space character (' ') when the is only a single match unless it is completing files where it will use the path separator instead.
Suppress the prefixing and suffixing of quotes even if there is a character in the current word being completed that would ordinarily need surrounding in quotes.
Clink exposes a small amount of state from Readline in the global rl_state table. Readline's nomenclature is maintained (minus the rl prefix) so Readline's manual can also be used as reference. This table should be considered read-only - changes to the table's members are not fed back to Readline.
This variable contains the current state of the whole line being edited.
The current cursor position within the line buffer.