ï»¿
Your IP : 172.28.240.42

Current Path : /usr/lib/python2.7/dist-packages/twisted/python/
Current File : //usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyc
�
�V�Nc@s�dZddlZddlZddlZddlmZmZmZd�Zdej	fd��YZ
defd��YZd	efd
��YZ
defd��YZd
�Zd�ZdS(s�
No public APIs are provided by this module. Internal use only.

This module implements dynamic tab-completion for any command that uses
twisted.python.usage. Currently, only zsh is supported. Bash support may
be added in the future.

Maintainer: Eric P. Mangold - twisted AT teratorn DOT org

In order for zsh completion to take place the shell must be able to find an
appropriate "stub" file ("completion function") that invokes this code and
displays the results to the user.

The stub used for Twisted commands is in the file C{twisted-completion.zsh},
which is also included in the official Zsh distribution at
C{Completion/Unix/Command/_twisted}. Use this file as a basis for completion
functions for your own commands. You should only need to change the first line
to something like C{#compdef mycommand}.

The main public documentation exists in the L{twisted.python.usage.Options}
docstring, the L{twisted.python.usage.Completions} docstring, and the 
Options howto.
i����N(treflecttutiltusagecCs�|djd�\}}t|�}|d8}||}x5|dkrp||djd�rl|d8}q<Pq<W|| }t|dd�}|r�d}y%tj||j|j�\}	}Wntjk
r�nX|rSxu|j	D]g\}
}}}
|d|
ks|d|kr�|�}||_
t||||�}|j�dSq�Wnt
}|jd�rqt}nt|||�}|jd	|�nt|||�}|j�dS(
so
    Perform shell completion.

    A completion function (shell script) is generated for the requested
    shell and written to C{shellCompFile}, typically C{stdout}. The result
    is then eval'd by the shell to produce the desired completions.

    @type config: L{twisted.python.usage.Options}
    @param config: The L{twisted.python.usage.Options} instance to generate
        completions for.

    @type cmdName: C{str}
    @param cmdName: The name of the command we're generating completions for.
        In the case of zsh, this is used to print an appropriate
        "#compdef $CMD" line at the top of the output. This is
        not necessary for the functionality of the system, but it
        helps in debugging, since the output we produce is properly
        formed and may be saved in a file and used as a stand-alone
        completion function.

    @type words: C{list} of C{str}
    @param words: The raw command-line words passed to use by the shell
        stub function. argv[0] has already been stripped off.

    @type shellCompFile: C{file}
    @param shellCompFile: The file to write completion data to.
    i����t:iit-tsubCommandsiNtgenSubs(tsplittintt
startswithtgetattrtNonetgetopttshortOpttlongOptterrorRtparenttZshSubcommandBuildertwritetTruetFalset
ZshBuilder(tconfigtcmdNametwordst
shellCompFilet	shellNametpositiontcWordRtargstoptstcmdtshorttparsertdoct
subOptionstgenR((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyt
shellComplete"sB




	 			
	tSubcommandActioncBseZd�ZRS(cCs*|tjkrdStd|f��dS(Ns*::subcmd:->subcmdsUnknown shellType %r(Rt_ZSHtNotImplementedError(tselftoptNamet	shellType((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyt
_shellCode�s(t__name__t
__module__R,(((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR&�sRcBs#eZdZd�Zed�ZRS(s�
    Constructs zsh code that will complete options for a given usage.Options
    instance, possibly including a list of subcommand names.

    Completions for options to subcommands won't be generated because this
    class will never be used if the user is completing options for a specific
    subcommand. (See L{ZshSubcommandBuilder} below)

    @type options: L{twisted.python.usage.Options}
    @ivar options: The L{twisted.python.usage.Options} instance defined for this
        command.

    @type cmdName: C{str}
    @ivar cmdName: The name of the command we're generating completions for.

    @type file: C{file}
    @ivar file: The C{file} to write the completion function to.
    cCs||_||_||_dS(N(toptionsRtfile(R)R/RR0((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyt__init__�s		cCs�|r�t|jdd�dk	r�t|j|j|j�}|jjdt��|j	�|jj	d�x:|jj
D],\}}}}|jj	d||f�qyW|jj	d�|jj	d�n%t|j|j|j�}|j	�dS(s�
        Generate the completion function and write it to the output file
        @return: C{None}

        @type genSubs: C{bool}
        @param genSubs: Flag indicating whether or not completions for the list
            of subcommand should be generated. Only has an effect
            if the C{subCommands} attribute has been defined on the
            L{twisted.python.usage.Options} instance.
        Ris.local _zsh_subcmds_array
_zsh_subcmds_array=(
s"%s:%s"
s)

s+_describe "sub-command" _zsh_subcmds_array
N(R
R/RtZshArgumentsGeneratorRR0textraActionstinsertR&RR(R)RR$RR R!tdesc((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR�s!
(R-R.t__doc__R1RR(((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR�s	RcBs eZdZd�Zd�ZRS(s�
    Constructs zsh code that will complete options for a given usage.Options
    instance, and also for a single sub-command. This will only be used in
    the case where the user is completing options for a specific subcommand.

    @type subOptions: L{twisted.python.usage.Options}
    @ivar subOptions: The L{twisted.python.usage.Options} instance defined for
        the sub command.
    cGs||_tj||�dS(N(R#RR1(R)R#R((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR1�s	cCsdt|j|j|j�}|jjdt��|j�t|j|j|j�}|j�dS(sk
        Generate the completion function and write it to the output file
        @return: C{None}
        iN(	R2R/RR0R3R4R&RR#(R)R$((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR�s

(R-R.R6R1R(((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR�s		R2cBs�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	e
d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�ZRS(s�
    Generate a call to the zsh _arguments completion function
    based on data in a usage.Options instance

    @type options: L{twisted.python.usage.Options}
    @ivar options: The L{twisted.python.usage.Options} instance to generate for

    @type cmdName: C{str}
    @ivar cmdName: The name of the command we're generating completions for.

    @type file: C{file}
    @ivar file: The C{file} to write the completion function to

    The following non-constructor variables are populated by this class
    with data gathered from the C{Options} instance passed in, and its
    base classes.

    @type descriptions: C{dict}
    @ivar descriptions: A dict mapping long option names to alternate
        descriptions. When this variable is defined, the descriptions
        contained here will override those descriptions provided in the
        optFlags and optParameters variables.

    @type multiUse: C{list}
    @ivar multiUse: An iterable containing those long option names which may
        appear on the command line more than once. By default, options will
        only be completed one time.

    @type mutuallyExclusive: C{list} of C{tuple}
    @ivar mutuallyExclusive: A sequence of sequences, with each sub-sequence
        containing those long option names that are mutually exclusive. That is,
        those options that cannot appear on the command line together.

    @type optActions: C{dict}
    @ivar optActions: A dict mapping long option names to shell "actions".
        These actions define what may be completed as the argument to the
        given option, and should be given as instances of
        L{twisted.python.usage.Completer}.

        Callables may instead be given for the values in this dict. The
        callable should accept no arguments, and return a C{Completer}
        instance used as the action.

    @type extraActions: C{list} of C{twisted.python.usage.Completer}
    @ivar extraActions: Extra arguments are those arguments typically
        appearing at the end of the command-line, which are not associated
        with any particular named option. That is, the arguments that are
        given to the parseArgs() method of your usage.Options subclass.
    cCs�||_||_||_i|_t�|_g|_i|_g|_x�t	t
j|j��D]�}t
|dd�}|rd|jj|j�|jj|j�|jj|j�|jj|j�|jr�|j|_q�qdqdWtj}tj}g}g}	||jd|�||jd|	�xEt|�D]7\}
}t|�dkr>tjd|�||
<q>q>WxEt|	�D]7\}
}t|�dkr�tjd|�|	|
<q�q�W||_|	|_i}x |	D]}|d||d<q�W||_i}
x |D]}|d|
|d<qW|
|_i}|j|�|j|
�||_|j�|j�|j�|_ dS(NtcompDatatoptFlagst
optParametersiiii(!R/RR0tdescriptionstsettmultiUsetmutuallyExclusivet
optActionsR3treversedtinspecttgetmrot	__class__R
RtupdatetextendRtaccumulateClassListtaccumulateClassDictt	enumeratetlenRtpadToR8t	optParamstparamNameToDefinitiontflagNameToDefinitiontallOptionsNameToDefinitiontaddAdditionalOptionstverifyZshNamestmakeExcludesDicttexcludes(R)R/RR0tclstdatataCLtaCDR8RJtitoptListRKRLRM((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR1s\												
	
	

	

cCs,|j�|j�|j�|j�dS(sf
        Write the zsh completion code to the file given to __init__
        @return: C{None}
        N(twriteHeadertwriteExtrastwriteOptionstwriteFooter(R)((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyRRs


cCs|jjd|jf�dS(s^
        This is the start of the code that calls _arguments
        @return: C{None}
        s%#compdef %s

_arguments -s -A "-*" \
N(R0RR(R)((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyRX]scCs;|jj�}|j�x|D]}|j|�q WdS(s]
        Write out zsh code for each option in this command
        @return: C{None}
        N(RMtkeystsorttwriteOpt(R)toptNamestlongname((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyRZfs

cCs�x�t|j�D]�\}}d}|jr7|j}n|jrh|t|j�dkrhtd��n|jjt|j	dt
j���|jjd�qWdS(s�
        Write out completion information for extra arguments appearing on the
        command-line. These are extra positional arguments not associated
        with a named option. That is, the stuff that gets passed to
        Options.parseArgs().

        @return: C{None}

        @raises: ValueError: if C{Completer} with C{repeat=True} is found and
            is not the last item in the C{extraActions} list.
        tisDCompleter with repeat=True must be last item in Options.extraActionss \
N(RGR3t_descrt_repeatRHt
ValueErrorR0RtescapeR,RR'(R)RVtactiontdescr((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyRYqs	"%cCs|jjd�dS(sj
        Write the last bit of code that finishes the call to _arguments
        @return: C{None}
        s&& return 0
N(R0R(R)((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR[�scs��fd�}xBtj�j�j�j�D]"}|�jkr.||�q.q.Wx>�jD]3}x*|D]"}|�jkrk||�qkqkWq^WdS(s�
        Ensure that none of the option names given in the metadata are typoed
        @return: C{None}
        @raise ValueError: Raised if unknown option names have been found.
        cstd|�jf��dS(NsJUnknown option name "%s" found while
examining Completions instances on %s(RdR/(tname(R)(s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyterr�sN(t	itertoolstchainR:R>R<RMR=(R)RiRhtseq((R)s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyRO�s
cCs�||jkr%|j|j�}n	t�}||jkr�|tkrw|j|�}|dk	r�|j|�q�q�|j|�n|s�dSg}xE|D]=}t|�dkr�|j	d|�q�|j	d|�q�W|j
�ddj|�S(s�
        Generate an "exclusion string" for the given option

        @type longname: C{str}
        @param longname: The long option name (e.g. "verbose" instead of "v")

        @type buildShort: C{bool}
        @param buildShort: May be True to indicate we're building an excludes
            string for the short option that correspondes to the given long opt.

        @return: The generated C{str}
        RaiRs--s(%s)t N(RQtcopyR;R<RtgetShortOptionRtaddRHtappendR]tjoin(R)R`t
buildShortt
exclusionsR tstringsR*((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyt
excludeStr�s$
	

c	Csi}xEtj|j|j�D]+}|ddkr|d||d<qqWi}x�|jD]�}x�t|�D]�\}}t|| ||d�}x4|j�D]&}||kr�|j	||�q�q�W||kr�||j
|�||<qq|||<qqWq^W|S(s�
        @return: A C{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).
        iiN(RjRkRJR8RR=RGR;RnRptunion(	R)tlongToShortRWRQtlstRVR`ttmpRh((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyRP�scCsa||jkrd|}n
d|}|j|�}|dkrNd|}nd}|j|�}|jdd�}|jdd�}d	|}|j|�}||jkr�d
}nd}|j|�}	|r$|j|dt�}
|j	j
td|
||||f��|j	j
d
�n|j	j
td|	||||f��|j	j
d
�dS(s
        Write out the zsh code for the given argument. This is just part of the
        one big call to _arguments

        @type longname: C{str}
        @param longname: The long option name (e.g. "verbose" instead of "v")

        @return: C{None}
        s--%ss--%s=RRat[s\[t]s\]s[%s]t*Rss
%s%s%s%s%ss \
N(RLRoRtgetDescriptiontreplacet	getActionR<RvRR0RRe(R)R`t	longFieldR t
shortFieldRgtdescriptionFieldtactionFieldt
multiFieldtlongExclusionsFieldtshortExclusionsField((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR^�s0



	cCss||jkrUt|j|�r5|j|�}n
|j|}|j|tj�S||jkrod|fSdS(s]
        Return a zsh "action" string for the given argument
        @return: C{str}
        s
:%s:_filesRa(R>tcallableR,RR'RK(R)R`Rf((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR�s
cCs�||jkr|j|Sy|j|d}Wn@tk
rqy|j|d}Wqrtk
rmd}qrXnX|dk	r�|S|jdd�}t|jd|d�}|dk	r�t|�}|dk	r�|Sn|S(s]
        Return the description to be used for this argument
        @return: C{str}
        iiRt_sopt_%sN(	R:RLtKeyErrorRKRRR
R/tdescrFromDoc(R)R`RgtlongMangledtobj((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR~.s$

cCs|j|}|dpdS(s[
        Return the short option letter or None
        @return: C{str} or C{None}
        iN(RMR(R)R`RW((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyRoNs
c
Cs�i}tj|j|d�i}x>|j�D]0}t|�dkr/||||<||=q/q/Wx|j�D]	\}}|jdd�}||jkr�qpn|j|�}d}||kr�||}n|j
jj}	|	dkr7|j
j||d|g�|d|g|j|<|d|g|j|<qp|jj|||g�||g|j|<|d|g|j|<qpWdS(s�
        Add additional options to the optFlags and optParams lists.
        These will be defined by 'opt_foo' methods of the Options subclass
        @return: C{None}
        topt_iR�RiN(RtaccumulateMethodsR/RnRHtitemsRRMR~Rtim_funct	func_codetco_argcountRJRqRKR8RL(
R)tmethodsDictt
methodToShortRht
methodNamet	methodObjR`RgR treqArgs((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyRNWs.
(R-R.R6R1RRXRZRYR[RORRvRPR^R�R~RoRN(((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR2�s1	G							+		/		 		cCsm|jdks|jj�r"dSg|jjd�D]%}|r5|j�r5|j�^q5}dj|�S(sP
    Generate an appropriate description from docstring of the given object
    s
RmN(R6RtisspaceRtstripRr(R�txtlines((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyR��s
%cCs`d|krd|dSd}x1|D])}|dkrD|d}n||}q%W|d}|S(sw
    Shell escape the given string

    Implementation borrowed from now-deprecated commands.mkarg() in the stdlib
    s't"s\$"`s\((R�tstc((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyRe�s


(R6RjRR@ttwisted.pythonRRRR%t	CompleterR&tobjectRRR2R�Re(((s=/usr/lib/python2.7/dist-packages/twisted/python/_shellcomp.pyt<module>s$	_3��