��Qc@�s�dZd
dl
mZ
dZd
dlZd
dlZd
dlZd
dlZd
dlZd
dl	Z	d
dl
mZ
ddlm
Z
mZmZ
ddlmZ
dd	lmZmZ
dd
lmZ
ddlmZ
ed�Zd
ef
d��YZd�Zd�Zd�Zd�Z ej!ddfkr[
d
dl"Z"e"j#Z$d�Z%d�Z&ne#Z$e Z%e Z&d�Z'def
d��YZ(de)f
d��YZ*def
d��YZ+de*f
d��YZ,dS( s�Refactoring framework.

Used as a main program, this can refactor any number of files and/or
recursively descend down directories.  Imported as a module, this
provides infrastructure to write your own refactoring tool.
i�(
twith_statements#Guido van Rossum <[email protected]>N(
tchaini
(tdriverttokenizettoken(
t	find_root(tpytreetpygram(
t	btm_utils(
tbtm_matchercC�s�t|ggd
g
�}t
jj|j�}g}xbtt
j|��D]K}|jd�rI|jd�rI|
r�|d}n|j	|d �
qIqIW|S(sEReturn a sorted list of all available fix names in the given package.t
*tfix_s.pyii�(
t
__import__tostpathtdirnamet__file__tsortedtlistdirt
startswithtendswithtappend(t	fixer_pkgt
remove_prefixtpkgt	fixer_dirt	fix_namestname((s&/sys/lib/python2.7/lib2to3/refactor.pytget_all_fix_names!s








t
_EveryNodec
B�seZ
RS((t__name__t
__module__(((s&/sys/lib/python2.7/lib2to3/refactor.pyR.s
c
C�s�t|t
jt
jf�rC|jdkr3t�nt|jg
�St|t
j�rt|j	rkt
|j	�St�nt|t
j�r�t�}
x5|j	D]*}x!|D]}|
jt
|��
q�Wq�W|
St
d
|��dS(sf Accepts a pytree Pattern Node and returns a set
        of the pattern types which will match first. s$Oh no! I don't understand pattern %sN(t
isinstanceRtNodePatterntLeafPatternttypetNoneRtsettNegatedPatterntcontentt_get_head_typestWildcardPatterntupdatet	Exception(tpatt
rt
pt
x((s&/sys/lib/python2.7/lib2to3/refactor.pyR(2s
	

	


		




c
C�s
tj
t�}
g}x�|D]�}|jr�yt|j�}Wntk
r^


|j|�
q�XxU|D]}|
|j|�
qfWq|jd
k	r�|
|jj|�
q|j|�
qWx:t	t
jjj
�t
jj�D]}|
|j|�
q�Wt|
�S(s^ Accepts a list of fixers and returns a dictionary
        of head node type --> fixer list.  N(tcollectionstdefaultdicttlisttpatternR(RRt_accept_typeR$R
Rtpython_grammart
symbol2numbert
itervaluesttokenstextendtdict(t
fixer_listt
head_nodesteverytfixertheadst	node_type((s&/sys/lib/python2.7/lib2to3/refactor.pyt_get_headnode_dictNs"



	











c
C�s(gt|t
�D]}
|d
|
^qS(sN
    Return the fully qualified names for fixers in the package pkg_name.
    t
.(RtFalse(tpkg_nametfix_name((s&/sys/lib/python2.7/lib2to3/refactor.pytget_fixers_from_packagegs
c


C�s|S(
N((
tobj((s&/sys/lib/python2.7/lib2to3/refactor.pyt	_identityns
iic

C�s|jd
d�S(Nu
u

(
treplace(
tinput((s&/sys/lib/python2.7/lib2to3/refactor.pyt_from_system_newlinesus
c

C�s*tj
d
kr"|jdtj
�S|SdS(Ns

u

(R
tlinesepRI(
RJ((s&/sys/lib/python2.7/lib2to3/refactor.pyt_to_system_newlinesws

c
�s�t}
t
jtj|�j���f
d
�}ttjt
jtj	f�}t
�}yk
xd
tr�|�\}}||kr�q]q]|tjkr�|
r�Pnt}
q]|tj
kr�|dkr�|�\}}|tj
ks�dkr�n|�\}}|tj
ks
|dkr
Pn|�\}}|tjkrY
|dkrY
|�\}}nxa|tj
kr�|j|�
|�\}}|tjks�|dkr�Pn|�\}}q\
Wq]Pq]WWntk
r�


n
Xt|�S(Nc
�s�j�}|d
|dfS(Nii
(
tnext(
ttok(
tgen(s&/sys/lib/python2.7/lib2to3/refactor.pytadvance�s

ufromu
__future__uimportu
(u
,(RCRtgenerate_tokenstStringIOtreadlinet	frozensetRtNEWLINEtNLtCOMMENTR%tTruetSTRINGtNAMEtOPtaddt
StopIteration(tsourcethave_docstringRQtignoretfeaturesttptvalue((
RPs&/sys/lib/python2.7/lib2to3/refactor.pyt_detect_future_features�sD



	

	






	
















	



t
FixerErrorc
B�seZ
dZRS(
sA fixer could not be loaded.(RRt__doc__(((s&/sys/lib/python2.7/lib2to3/refactor.pyRf�s
tRefactoringToolcB�s!
eZ
ied6ed
6ZdZdZddd�Zd�Zd�Z	d�Z
d�Zd	�Zeed
�Z
eed�Zd�Zeed
�Zd�Zed�Zd�Zd�Zdedd�Zdd�ZdZdZd�Zd�Zd�Zd�Zd�Zd�ZRS(tprint_functiontwrite_unchanged_filestFixRcC�s�|
|_|pg|_
|jj�|_|dk	rI|jj|�
n|jd
retj|_	ntj
|_	|jjd�|_g|_
tjd�|_g|_t|_tj|j	dtjd|j�|_|j�\|_|_g|_tj�|_g|_g|_ x}t!|j|j�D]f}|j"rT
|jj#|�
q2
||jkrv
|jj$|�
q2
||jkr2
|j j$|�
q2
q2
Wt%|j�|_&t%|j �|_'dS(s�Initializer.

        Args:
            fixer_names: a list of fixers to import
            options: an dict with configuration.
            explicit: a list of fixers to run even if they are explicit.
        RiRjRhtconverttloggerN((tfixerstexplicitt_default_optionstcopytoptionsR$R*Rt!python_grammar_no_print_statementtgrammarR5tgetRjterrorstloggingt	getLoggerRmt	fixer_logRCtwroteRtDriverRRlt
get_fixerst	pre_ordert
post_ordertfilestbmt
BottomMatchertBMt
bmi_pre_ordertbmi_post_orderR
t
BM_compatiblet	add_fixerRRAtbmi_pre_order_headstbmi_post_order_heads(tselftfixer_namesRrRoR>((s&/sys/lib/python2.7/lib2to3/refactor.pyt__init__�s<	







	

	
	

	

	
	
	
	




c
C�s�g}
g}x�|jD]�}t
|iid
g
�}|jdd�d}|j|j�rr|t|j�}n|jd�}|jdjg|D]}|j	�^q��}yt
||�}	Wn'tk
r�

td||f��n
X|	|j
|j�}
|
jr?
|jtk	r?
||jkr?
|jd|�
qn|jd	|�
|
jd
krn
|
j|
�
q|
jdkr�|j|
�
qtd|
j��qWtjd
�}|
jd|�

|jd|�

|
|fS(s
Inspects the options to load the requested patterns and handlers.

        Returns:
          (pre_order, post_order), where pre_order is the list of fixers that
          want a pre-order AST traversal, and post_order is the list that want
          post-order traversal.
        R
RBi
i�t
_tsCan't find %s.%ssSkipping implicit fixer: %ssAdding transformation: %stpretpostsIllegal fixer order: %rt	run_ordertkey(RnRtrsplitRtFILE_PREFIXtlentsplittCLASS_PREFIXtjointtitletgetattrtAttributeErrorRfRrRyRoRYtlog_messaget	log_debugtorderRtoperatort
attrgettertsort(R�tpre_order_fixerstpost_order_fixerstfix_mod_pathtmodREtpartsR.t
class_namet	fix_classR>tkey_func((s&/sys/lib/python2.7/lib2to3/refactor.pyR|�s8







/
















c
O�s�d
S(sCalled when an error occurs.N((R�tmsgtargstkwds((s&/sys/lib/python2.7/lib2to3/refactor.pyt	log_error
scG�s'|r|
|}
n|jj
|
�
d
S(sHook to log a message.N(Rmtinfo(R�R�R�((s&/sys/lib/python2.7/lib2to3/refactor.pyR�
s


cG�s'|r|
|}
n|jj
|
�
dS(
N(Rmtdebug(R�R�R�((s&/sys/lib/python2.7/lib2to3/refactor.pyR�
s



c
C�sd
S(sTCalled with the old version, new version, and filename of a
        refactored file.N((R�told_texttnew_texttfilenametequal((s&/sys/lib/python2.7/lib2to3/refactor.pytprint_output!
scC�sPxI|
D]A}tj
j|�r5|j|||�
q|j|||�
qWd
S(s)Refactor a list of files and directories.N(R
Rtisdirtrefactor_dirt
refactor_file(R�titemstwritet
doctests_onlytdir_or_file((s&/sys/lib/python2.7/lib2to3/refactor.pytrefactor&
s


cC�s�tj
d
}x�tj|
�D]�\}}}|jd|�
|j�
|j�
xe|D]]}|jd�rWtjj|�d|krWtjj||�}	|j	|	||�
qWqWWg|D]}
|
jd�s�|
^q�|(qWdS(s�Descends down a directory and refactor every Python file found.

        Python files are assumed to have a .py extension.

        Files and subdirectories starting with '.' are skipped.
        tpysDescending into %sRBi
N(
R
textseptwalkR�R�RRtsplitextR�R�(R�tdir_nameR�R�tpy_exttdirpathtdirnamest	filenamesRtfullnametdn((s&/sys/lib/python2.7/lib2to3/refactor.pyR�/
s












cC�s�yt|
d
�}Wn't
k
r<
}
|jd|
|�
dSXztj|j�d}Wd|j�
Xt|
dd|�
�}t	|j
��|fSWdQXdS(sG
        Do our best to decode a Python source file correctly.
        trbsCan't open %s: %siNR-tencoding(NN(topentIOErrorR�R$Rtdetect_encodingRTtcloset_open_with_encodingRKtread(R�R�t
fterrR�((s&/sys/lib/python2.7/lib2to3/refactor.pyt_read_python_sourceC
s







c	C�s
|j|
�\}}|d
kr%d
S|d7}|r�|jd|
�
|j||
�}|jsl||kr�|j||
|||�
q�jd|
�
nc|j||
�}|js�|r�jr�jt|�d |
d|d|�
n|jd|
�
d
S(	sRefactors a file.Nu

sRefactoring doctests in %ssNo doctest changes in %si�R�R�sNo changes in %s(	R�R$R�trefactor_docstringRjtprocessed_filetrefactor_stringtwas_changedtunicode(R�R�R�R�RJR�toutputttree((s&/sys/lib/python2.7/lib2to3/refactor.pyR�S
s









cC�s�t|
�}d
|kr*t
j|j_nzMy|jj|
�}Wn0tk
ru
}
|jd||jj	|�
dSXWd|j|j_X||_
|jd|�
|j||�
|S(sF
Refactor a given input string.

        Args:
            data: a string holding the code to be refactored.
            name: a human-readable name for use in error/log messages.

        Returns:
            An AST corresponding to the refactored input stream; None if
            there were errors during the parse.
        RisCan't parse %s: %s: %sNsRefactoring %s(
ReRRsRRttparse_stringR+R�t	__class__Rtfuture_featuresR�t
refactor_tree(R�tdataRRbR�R�((s&/sys/lib/python2.7/lib2to3/refactor.pyR�j
s





	

	
	


cC�s�tj
j�}|
ro|jd
�
|j|d�}|jsI||kr_|j|d|�
q�|jd�
nS|j|d�}|js�|r�|jr�|jt	|�d|�
n
|jd�
dS(NsRefactoring doctests in stdins<stdin>sNo doctest changes in stdinsNo changes in stdin(
tsyststdinR�R�R�RjR�R�R�R�(R�R�RJR�R�((s&/sys/lib/python2.7/lib2to3/refactor.pytrefactor_stdin�s








c
C�s�x-t|j
|j�D]}|j|
|�
qW|j|j|
j
��
|j|j|
j��
|jj|
j	��}x�
|j��rcx�|jjD]�}||kr�||r�||j
d
tjjdt�
|jr�|j
d
tjj�

nx[
t||�D]F
}|||kr9
||j|�
nyt|�
Wntk
r]



q
n
X|jr|
||jkr|
q
n|j|�}|r
|j||�}|dk	rU|j|�
x9|j�D]+}|js�|_n|jj|�
q�W|jj|j	��}x?|D]4}	|	|kr6g||	<n||	j||	�
qWqUq
q
Wq�q�Wq}Wx-t|j
|j�D]}|j|
|�
qzW|
j S(s�Refactors a parse tree (modifying the tree in place).

        For compatible patterns the bottom matcher module is
        used. Otherwise the tree is traversed node-to-node for
        matches.

        Args:
            tree: a pytree.Node instance representing the root of the tree
                  to be refactored.
            name: a human-readable name for this tree.

        Returns:
            True if the tree was modified, False otherwise.
        R�treverseN(!R
R}R~t
start_treettraverse_byR�R�R�truntleavestanytvaluesRnR�RtBasetdepthRYtkeep_line_ordert
get_linenoR2tremoveRt
ValueErrortfixers_appliedtmatcht	transformR$RIRR9tfinish_treeR�(
R�R�RR>t	match_settnodetresultstnewtnew_matchestfxr((s&/sys/lib/python2.7/lib2to3/refactor.pyR��sJ



 	








	






.

cC�s�|
s
d
Sxr|D]j}xa|
|jD]R}|j
|�}|r%|j||�}|d
k	rw|j|�
|}qwq%q%WqWd
S(s
Traverse an AST, applying a set of fixers to each node.

        This is a helper method for refactor_tree().

        Args:
            fixers: a list of fixer instances.
            traversal: a generator that yields AST nodes.

        Returns:
            None
        N(R#R�R�R$RI(R�Rnt	traversalR�R>R�R�((s&/sys/lib/python2.7/lib2to3/refactor.pyR��s










cC�s�|jj
|�
|dkrB|j|�d
}|dkrBdSn||
k}|j||
||�
|r�|jd|�
|js�dSn|r�|j|
|||�
n|jd|�
dS(sR
        Called when a file has been refactored and there may be changes.
        iNsNo changes to %ssNot writing changes to %s(RRR$R�R�R�Rjt
write_file(R�R�R�R�R�R�R�((s&/sys/lib/python2.7/lib2to3/refactor.pyR��s








	


cC�s�yt|d
d|�
}Wn*t
jk
rE
}
|jd||�
dSXzGy|jt|
��
Wn)t
jk
r�
}
|jd||�
n
XWd|j�
X|jd|�
t|_	dS(s�Writes a string to a file.

        It first shows a unified diff between the old text and the new text, and
        then rewrites the file; the latter is only done if the write option is
        set.
        t
wR�sCan't create %s: %sNsCan't write %s: %ssWrote changes to %s(
R�R
terrorR�R�RMR�R�RYRz(R�R�R�R�R�R�R�((s&/sys/lib/python2.7/lib2to3/refactor.pyR�s









s>>> s... c
	C�s�g}d}d}d}d
}x+
|
j
t�D]
}|d7}|j�j|j�r�|dk	r�|j|j||||��
n|}|g
}|j|j�}	||	 }q.|dk	r

|j||j	�s�||j	j
�dkr

|j|�
q.|dk	r/
|j|j||||��
nd}d}|j|�
q.W|dk	rz
|j|j||||��
ndj|�S(s�Refactors a docstring, looking for doctests.

        This returns a modified version of the input string.  It looks
        for doctests, which start with a ">>>" prompt, and may be
        continued with "..." prompts, as long as the "..." is indented
        the same as the ">>>".

        (Unfortunately we can't use the doctest module's parser,
        since, like most parsers, it is not geared towards preserving
        the original source.)
        ii
u

uN(
R$t
splitlinesRYtlstripRtPS1R9trefactor_doctesttfindtPS2trstripRR�(
R�RJR�tresulttblocktblock_linenotindenttlinenotlinet
i((s&/sys/lib/python2.7/lib2to3/refactor.pyR�(s:












	















c
C�ss
y|j|
||�}Wnut
k
r�
}
|jjtj�rmx*|
D]}|jd
|jd��
qGWn|jd|||j	j
|�
|
SX|j||�ro
t|�j
t�}||d ||d}	}|	dg
|dks�|	��|djd�s
|dcd7<n||j|jd�g
}
|ro
|
g|D]}||j|^qK
7}
qo
n|
S(s�Refactors one doctest.

        A doctest is given as a block of lines, the first of which starts
        with ">>>" (possibly indented), while the remaining lines start
        with "..." (identically indented).

        s
Source: %su

s+Can't parse docstring in %s line %s: %s: %si
i�i(tparse_blockR+RmtisEnabledForRwtDEBUGR�R
R�R�RR�R�R�RYtAssertionErrorRR�tpopR

(
R�R
R
R
R�R�R�R
R�tclipped((s&/sys/lib/python2.7/lib2to3/refactor.pyR�Ss&





 
	




#




.
c
C�s
|jrd
}
nd}
|j
s4|jd|
�
n1|jd|
�
x|j
D]}|j|�
qNW|jr�|jd�
x!|jD]}|j|�
q�Wn|jr
t|j�dkr�|jd�
n|jdt|j��
x0|jD]"\}}}|j|||�
q�dS(	Ntweres
need to besNo files %s modified.sFiles that %s modified:s$Warnings/messages while refactoring:i
sThere was 1 error:sThere were %d errors:(RzRR�RyRvR�(R�R
tfiletmessageR�R�R�((s&/sys/lib/python2.7/lib2to3/refactor.pyt	summarizeps$
	
	
	



	




	



cC�s1|jj
|j|
||��}t�|_|S(
s�Parses a block into a tree.

        This is necessary to get correct line number / offset information
        in the parser diagnostics and embedded into the parse tree.
        (Rtparse_tokenst	wrap_toksRUR�(R�R
R
R
R�((s&/sys/lib/python2.7/lib2to3/refactor.pyR

�s!

cc�s�tj
|j|
|�j�}xe|D]]\}}\}}\}	}
}||d
7}|	|d
7}	||||f|	|
f|fV
q%WdS(s;Wraps a tokenize stream to systematically modify start/end.i
N(RRRt	gen_linesRN(R�R
R
R
R8R#Rdtline0tcol0tline1tcol1t	line_text((s&/sys/lib/python2.7/lib2to3/refactor.pyR
�s

(

cc�s�||j}||j
}|}xi|
D]a}|j|�rN|t|�V
n4||j�d
krld
V
ntd||f��|}q'Wxtr�dV
q�WdS(s�Generates lines as expected by tokenize from a list of lines.

        This strips the first len(indent + self.PS1) characters off each line.
        u

sline=%r, prefix=%rR�N(R�R

RR�R
R

RY(R�R
R
tprefix1tprefix2tprefixR
((s&/sys/lib/python2.7/lib2to3/refactor.pyR
�s












	
N(RRRCRpR�R�R$R�R|R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R

R�R�R
R

R
R
(((s&/sys/lib/python2.7/lib2to3/refactor.pyRh�s:



4	(								O	

	+			
	tMultiprocessingUnsupportedc
B�seZ
RS((RR(((s&/sys/lib/python2.7/lib2to3/refactor.pyR
�s
tMultiprocessRefactoringToolcB�s5eZ
d�Zeed
d�Zd�Zd�ZRS(c
O�s/tt
|�j|
|�
d|_d|_dS(
N(tsuperR 
R�R$tqueuetoutput_lock(R�R�tkwargs((s&/sys/lib/python2.7/lib2to3/refactor.pyR��s

	
i
c	C�sf
|d
kr(tt
|�j|
||�Syddl}Wntk
rQ


t�n
X|jdk	rptd��n|j	�|_|j
�|_gt|�D]}|j
d|j�
^q�}z;x|D]}|j�
q�Wtt
|�j|
||�
Wd|jj�
x$t|�D]}|jjd�
q
Wx'|D]}|j�r5
|j�
q5
q5
Wd|_XdS(Ni
i�s already doing multiple processesttarget(R!
R 
R�tmultiprocessingtImportErrorR
R"
R$tRuntimeErrort
JoinableQueuetLockR#
txrangetProcesst_childtstartR�tputtis_alive(	R�R�R�R�t
num_processesR&
R	
t	processesR.((s&/sys/lib/python2.7/lib2to3/refactor.pyR��s2














+













c
C�so|jj
�}
xY|
dk	rj|
\}}ztt|�j||�
Wd|jj�
X|jj
�}
qWdS(
N(R"
RuR$R!
R 
R�t	task_done(R�ttaskR�R$
((s&/sys/lib/python2.7/lib2to3/refactor.pyR-
�s






c
O�sE|jdk	r(|jj|
|f�
ntt|�j|
|�SdS(
N(R"
R$R/
R!
R 
R�(R�R�R$
((s&/sys/lib/python2.7/lib2to3/refactor.pyR��s


(RRR�RCR�R-
R�(((s&/sys/lib/python2.7/lib2to3/refactor.pyR 
�s
	
	(-Rgt
__future__Rt
__author__R
R�RwR�R0RSt	itertoolsR
tpgen2RRRt
fixer_utilRR�RRRtbuR	R�RYRR+RR(RARFRHtversion_infotcodecsR�R�RKRMReRftobjectRhR
R 
(((s&/sys/lib/python2.7/lib2to3/refactor.pyt<module>	sF










				

		

	(�