twisted.python.zshcomp.ArgumentsGenerator : API documentation

t.p.z.ArgumentsGenerator : class documentation

Generate a call to the zsh _arguments completion function based on data in a usage.Options subclass

Method	__init__
Method	write	Write the zsh completion code to the file given to __init__ @return: `None`
Method	writeHeader	This is the start of the code that calls _arguments @return: `None`
Method	writeOptions	Write out zsh code for each option in this command @return: `None`
Method	writeExtras	Write out the "extras" list. These are just passed verbatim to the _arguments call @return: `None`
Method	writeFooter	Write the last bit of code that finishes the call to _arguments @return: `None`
Method	verifyZshNames	No summary
Method	excludeStr	Generate an "exclusion string" for the given option
Method	makeExcludesDict
Method	writeOpt	Write out the zsh code for the given argument. This is just part of the one big call to _arguments
Method	getAction	Return a zsh "action" string for the given argument @return: `str`
Method	getActionDescr	Return the description to be used when this argument is completed @return: `str`
Method	getDescription	Return the description to be used for this argument @return: `str`
Method	getShortOption	Return the short option letter or None @return: `str` or `None`
Method	addAdditionalOptions	Add additional options to the optFlags and optParams lists. These will be defined by 'opt_foo' methods of the Options subclass @return: `None`

def __init__(self, cmd_name, options, file): (source)

Parameters	cmd_name	The name of the command (type: `str`)
	options	The `twisted.usage.Options` instance defined for this command (type: `twisted.usage.Options`)
	file	The `file` to write the completion function to (type: `file`)

def write(self): (source)

Write the zsh completion code to the file given to __init__

Returns None

def writeHeader(self): (source)

This is the start of the code that calls _arguments

Returns None

def writeOptions(self): (source)

Write out zsh code for each option in this command

Returns None

def writeExtras(self): (source)

Write out the "extras" list. These are just passed verbatim to the _arguments call

Returns None

def writeFooter(self): (source)

Write the last bit of code that finishes the call to _arguments

Returns None

def verifyZshNames(self): (source)

Ensure that none of the names given in zsh_* variables are typoed

Returns	`None`
Raises	ValueError	Raised if unknown option names have been given in zsh_* variables

def excludeStr(self, longname, buildShort=False): (source)

Generate an "exclusion string" for the given option

Parameters	longname	The long name of the option (i.e. "verbose" instead of "v") (type: `str`)
	buildShort	May be True to indicate we're building an excludes string for the short option that correspondes to the given long opt (type: `bool`)
Returns	The generated `str`

def makeExcludesDict(self): (source)

Returns A dict that maps each option name appearing in self.mutuallyExclusive to a list of those option names that is it mutually exclusive with (can't appear on the cmd line with)

def writeOpt(self, longname): (source)

Write out the zsh code for the given argument. This is just part of the one big call to _arguments

Parameters	longname	The long name of the option (i.e. "verbose" instead of "v") (type: `str`)
Returns	`None`

def getAction(self, longname): (source)

Return a zsh "action" string for the given argument

Returns str

def getActionDescr(self, longname): (source)

Return the description to be used when this argument is completed

Returns str

def getDescription(self, longname): (source)

Return the description to be used for this argument

Returns str

def getShortOption(self, longname): (source)

Return the short option letter or None

Returns str or None

def addAdditionalOptions(self): (source)

Add additional options to the optFlags and optParams lists. These will be defined by 'opt_foo' methods of the Options subclass

Returns None