File: //usr/lib64/python2.7/site-packages/mercurial/copies.pyo
�
1�3\c @@ s@ d d l m Z d d l Z d d l Z d d l Z d d l m Z d d l m Z m
Z
m Z m Z m
Z
d d l m Z d � Z d � Z d d
� Z d d � Z d d � Z d
� Z d d � Z d � Z d d � Z d d � Z d � Z d � Z d � Z d � Z d � Z d � Z d � Z! d � Z" d d � Z# d S( i ( t absolute_importNi ( t _( t matcht nodet pathutilt scmutilt util( t
stringutilc
C@ s� | j } t | � } | d k r* | } n | d k r? | } n i d | 6d | 6} | | g } t j | � t | � } t } | } x#| r�t j | � }
|
| k r� g | j j � D] } | j | � ^ q� } n | j
|
� } x� | D]� } | d k rq� n | | k rL| |
| | <| | r8| d 7} n t j | | � q� | | r� | | | |
k r� d | | <| d 8} t } q� q� W| |
r� |
} | d 8} q� q� W| s�d St
| | | � S( s�
Find the last revision that needs to be checked to ensure that a full
transitive closure for file copies can be properly calculated.
Generally, this means finding the earliest revision number that's an
ancestor of a or b but not both, except when a or b is a direct descendent
of the other, in which case we can return the minimum revnum of a and b.
None if no such revision exists.
i����i i N( t changelogt lent Nonet heapqt heapifyt Falset heappopt dirstatet parentst revt
parentrevst heappusht Truet min(
t repot at bt clt workingt sidet visitt interestingt hascommonancestort limitt rt pR ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt
_findlimit sF
.
c C@ s� | j � } xy | j � D]k \ } } | | k rk | | | k rR | | | | <n | | k rk | | =qk n | | k r | | | <q q WxB t | j � � D]. \ } } | | k r� | | k r� | | =q� q� W| S( s chain two sets of copies a->b( t copyt iteritemst listt items( t srct dstR R t tt kt v( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt _chainp s
i����c C@ sw xp | j � D]b } | j | j � d � | j � k r; | S| d k r
| j � | k r
| j � | k r
d Sq
Wd S( s� return file context that is the ancestor of fctx present in ancestor
manifest am, stopping after the first ancestor lower than limiti N( t ancestorst gett pathR
t filenodet linkrevR ( t fctxt amR t f( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt
_tracefile� s
$0c C@ sf | j j } | j � j � } xA t | � D]3 } | | d k sT | r+ | | � r+ | | =q+ q+ W| S( Nt anm( t _repoR t copiesR# R% ( t dR t dst cR* ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt _dirstatecopies� s #c C@ s+ | j � } | j � } | j | d | �S( s� Computes which files are in b but not a.
This is its own function so extensions can easily wrap this call to see what
files _forwardcopies is about to process.
R ( t manifestt
filesnotin( R R R t mat mb( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt _computeforwardmissing� s c C@ s" | j } | j j o' | j j d d � } | j j } | rS | d | | f � n t | | j � | j � � } | d k r� d } n | r� | d | � n | j � } i } | } | j � | k r| j
� j � t j k rt
j | j | j � � }
t j | |
� } n t | | d | �} | j j j | j � g d t �} | rh| d t | � � n x� | D]� }
| r�| d |
� n | |
} | | _ | r�t j � } n t | | | � } | r�| r�| d
| j � n | j � | |
<n | ro| d t j � | � qoqoW| S(
s@ Like _forwardcopies(), but b.rev() cannot be None (working copy)t devels debug.copiess3 debug.copies: looking into rename from %s to %s
i����s$ debug.copies: search limit: %d
R t inclusives. debug.copies: missing file to search: %d
s& debug.copies: tracing file: %s
s% debug.copies: rename of: %s
s( debug.copies: time: %f seconds
N( R7 t uit debugflagt
configboolt debugR" R R
R= t p1t p2R t nullidR t
matchfilest filest matchmodt intersectmatchersRA R R- R R t _ancestrycontextR t timerR5 t _pathR/ ( R R R R RG t dbgR R3 t cmt forwardmissingmatcht filesmatchert missingt ancestrycontextR4 R2 t startt ofctx( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt _committedforwardcopies� sJ ! -$
c C@ s� | j � j | � } | j � d k rz | | j � k rF t | | � St | | j � | � } t | | | t | | � � St | | | � S( s< find {dst@b: src@a} copy mapping where a is an ancestor of bN( R t narrowmatchR R
RH R< RZ R, ( R R R RS ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt _forwardcopies� s
c C@ sz | j j j d d � d k r" i St | | � } i } x< t | j � � D]( \ } } | | k rh qJ n | | | <qJ W| S( Nt experimentalt copytracet off( R7 RD t configR\ t sortedR$ ( R R R4 R R* R+ ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt _backwardrenames� s c C@ s( | j } | j j o' | j j d d � } | rM | j j d | | f � n | | k sg | sg | rk i S| j | � } | | k r� | r� | j j d � n t | | d | �S| | k r� | r� | j j d � n t | | � S| r� | j j d � n t | | t | | � t | | d | �� S( s5 find {dst@y: src@x} copy mapping for directed compareRB s debug.copiess- debug.copies: searching copies from %s to %s
s# debug.copies: search mode: forward
R s$ debug.copies: search mode: backward
s$ debug.copies: search mode: combined
( R7 RD RE RF RG t ancestorR\ Rb R, ( t xt yR R RG R ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt
pathcopies� s( !
t c C@ s� t | | � } t | | � } d } | r= | d | 7} n | rm | j j d | d d j | � f � n | r� | j j d | d d j | � f � n | | f S( s� Computes, based on addedinm1 and addedinm2, the files exclusive to c1
and c2. This is its own function so extensions can easily wrap this call
to see what files mergecopies is about to process.
Even though c1 and c2 are not used in this function, they are useful in
other extensions for being able to read the file nodes of the changed files.
"baselabel" can be passed to help distinguish the multiple computations
done in the graft case.
s unmatched files in %ss
(from %s)s
%s:
%s
t locals
t other( Ra RD RG t join( R t c1t c2t addedinm1t addedinm2t baselabelt u1t u2t header( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt _computenonoverlap s **c @ s� � j � � � j � t � d d � � � d k r� � g } � d k rp g � j � D] } | j � ^ qU } n � j j | d t �� � � _ n � � � � f d � } t j
| � S( s� return a 'getfctx' function suitable for _checkcopies usage
We have to re-setup the function building 'filectx' for each
'_checkcopies' to ensure the linkrev adjustment is properly setup for
each. Linkrev adjustment is important to avoid bug in rename
detection. Moreover, having a proper '_ancestrycontext' setup ensures
the performance impact of this adjustment is kept limited. Without it,
each file could do a full dag traversal making the time complexity of
the operation explode (see issue4537).
This function exists here mostly to limit the impact on stable. Feel
free to refactor on default.
RO RC c @ se | t j k r: � j � d k r. � j | � S� d | S� j | d | �} � | _ � | _ | S( Nt fileid( R t wdirfilenodeidsR R
t filectxRO t _descendantrev( R4 t nR2 ( t act ctxR R ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt makectx@ s
N( R R7 t getattrR
R R R- R RO R t lrucachefunc( Rz t revsR! R{ ( ( Ry Rz R R s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt _makegetfctx) s (
c C@ s� i } x6 | D]. } | | k r
| | | | | <| | =q
q
WxQ | D]I } | | } | d | k r� | | d | d g | | <qF | | | <qF W| S( s combine partial copy pathsi i ( ( t copyfromt copytot finalcopyt diverget incompletediverget remainderR4 t ic( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt _combinecopiesL s
c C@ s | s | s | | k r- i i i i i f S| j � d k rv | j � | j j � k rv | j j � i i i i f S| j j d d � } t j | � } | d k r� t | | | � r� t
| | | | � St | | | | � S| t k r� i i i i i f St
| | | | � Sd S( s�
The function calling different copytracing algorithms on the basis of config
which find moves and copies between context c1 and c2 that are relevant for
merging. 'base' will be used as the merge base.
Copytracing is used in commands like rebase, merge, unshelve, etc to merge
files that were moved/ copied in one merge parent and modified in another.
For example:
o ---> 4 another commit
|
| o ---> 3 commit that modifies a.txt
| /
o / ---> 2 commit that moves a.txt to b.txt
|/
o ---> 1 merge base
If we try to rebase revision 3 on revision 4, since there is no a.txt in
revision 4, and if user have copytrace disabled, we prints the following
message:
```other changed <file> which local deleted```
Returns five dicts: "copy", "movewithdir", "diverge", "renamedelete" and
"dirmove".
"copy" is a mapping from destination name -> source name,
where source is in c1 and destination is in c2 or vice-versa.
"movewithdir" is a mapping from source name -> destination name,
where the file at source present in one context but not the other
needs to be moved to destination by the merge process, because the
other context moved the directory it is in.
"diverge" is a mapping of source name -> list of destination names
for divergent renames.
"renamedelete" is a mapping of source name -> list of destination
names for files deleted in c1 that were renamed in c2 or vice-versa.
"dirmove" is a mapping of detected source dir -> destination dir renames.
This is needed for handling changes to new files previously grafted into
renamed directories.
R] R^ t
heuristicsN(
R R
R RH R8 RD R` R t parseboolt _isfullcopytraceablet _fullcopytracingt _heuristicscopytracingR
( R Rk Rl t baset copytracingt
boolctrace( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt mergecopies\ s .- c C@ s� | j � d k r! | j � } n | j � r | j � r | j j d d � } t | j d | j � | j � � � } | | k St S( s� Checks that if base, source and destination are all no-public branches,
if yes let's use the full copytrace algorithm for increased capabilities
since it will be fast enough.
`experimental.copytrace.sourcecommitlimit` can be used to set a limit for
number of changesets from c1 to base such that if number of changesets are
more than the limit, full copytracing algorithm won't be used.
R] s copytrace.sourcecommitlimits %d::%dN( R R
RH t mutableRD t configintR R~ R
( R Rk R� t sourcecommitlimitt commits( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyR� � s '
c 5
C@ s� | j � d k r | j � n | } | j � d k rB | j � n | } | j | � } | j | � } | pq | } | } | r� | j | � } n t | | j � | j � � }
|
d k r� i i i i i f S| j j d |
� | j � } | j � } | j � }
i } i } i i d 6i d 6i d 6| d 6| d 6} i i d 6i d 6i d 6| d 6| d 6} | j |
| j
� � } | j |
| j
� � } t | | @� } | | k r�t | | | | | � \ } } | | } } nx t | | | | | d d �\ } } | j � } t | | | | j | | j
� � | j | | j
� � d d �\ } } x- | D]% } t
| | | | | | |
| � q^Wx- | D]% } t
| | | | | | |
| � q�Wt | d � } | j | d � t | d � } | j | d � | r t | d | d | | | � n t | d | d | | | � i } t � } t � } x� t | j � � D]� \ } }! t |! � d
k s�| | k s�| | k r| | =| | k r| | k rg |! D]$ } | | k s�| | k r�| ^ q�| | <| j |! � qqi| j |! � qiW| r=| j j d d j | � � n i }" i }# i }$ i i d 6i d 6i d 6|" d 6|# d 6}% i i d 6i d 6i d 6|" d 6|# d 6}& xL | D]D } t
| | | | | | |
|% � t
| | | | | | |
|& � q�W| rt i |% d | |" |# � }$ n% | r:t i |& d | |" |# � }$ n xA |$ D]9 } |$ | }' |' d
| rd| n | k rA|' |" | <qAqAWxQ |" j � D]C \ } }! t |! � d k r�|! d
|! d
k r�| | |! d
<q�q�W| r�| j j r�| j j d � x� t | � D]x } d }( | | k r&|( d 7}( n | | k r?|( d 7}( n | | k rX|( d 7}( n | j j d | | | |( f � qWn ~ | s�| i | | i f S| j j d � | j � | j � }) }* |) j d � |* j d � t � }+ i }, x� | j � D]� \ }- }. t j |. � t j |- � }/ }0 |/ |+ k r8q�q�|/ |) k r`|0 |) k r`|+ j |/ � q�|/ |* k r�|0 |* k r�|+ j |/ � q�|/ |, k r�|, |/ |0 k r�|+ j |/ � q�|0 |, |/ <q�Wx$ |+ D] }1 |1 |, k r�|, |1 =q�q�W~) ~* ~+ |, s | i | | i f Sd � |, j � D� }, x, |, D]$ }2 | j j d |2 |, |2 f � q(Wi }3 x� | | D]� } | | k raxo |, D]d }2 | j |2 � rz|, |2 | t |2 � }4 |4 | k r�|4 |3 | <| j j d | |4 f � n PqzqzWqaqaW| |3 | | |, f S( s( The full copytracing algorithm which finds all the new files that were
added from merge base up to the top commit and for each file it checks if
this file was copied from another file.
This is pretty slow when a lot of changesets are involved but will track all
the copies.
s& searching for copies back to rev %d
R# t fullcopyt
incompleteR� R� Ro R� s topological common ancestori s% unmatched files new in both:
%s
s
i i sK all copies found (* = to merge, ! = divergent, % = renamed and deleted):
Rg t *t !t %s src: '%s' -> dst: '%s' %s
s! checking for directory renames
t /c S@ s' i | ] \ } } | d | d � q S( R� ( ( t .0R* R+ ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pys
<dictcomp>� s s) discovered dir src: '%s' -> dst: '%s'
s' pending file src: '%s' -> dst: '%s'
N( R R
RH t isancestorofRc R" RD RG R= R> R[ Ra Rs t _checkcopiest dictt updateR� t setR% R& R Rj RE t dirst addpathR$ R t dirnamet addt
startswith(5 R Rk Rl R� t _c1t _c2t dirtyc1t dirtyc2t graftt tcaR t m1t m2R@ R� R� t data1t data2Rm Rn t bothnewt u1rt u2rt u1ut u2ut mtaR4 R# R� t renamedeletet renamedeletesett
divergesett oft flt bothdiverget bothincompletedivergeR� t both1t both2R� t notet d1t d2t invalidt dirmoveR( R' t dsrct ddstt iR9 t movewithdirt df( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyR� � s* $$
#
#
*5
#
&
c @ s$ | j � d k r! | j � } n � j � d k rB � j � � n i } t � } | j � � | j d � j � � j � � s� | j j d � t | | � � � S� } xj | � k rt | j
� � d k r� | j j d � t | | � � � S| j | j � � | j � } q� Wt
� � � } x3 | j � D]% \ } } | � k r0| | | <q0q0W� � � f d � }
g | D] } |
| � ru| ^ qu} | rt j t � }
t j t � } xc � j � j � � D]L } t j j | � } t j j | � } |
| j | � | | j | � q�Wx� | D]� } t j j | � } t j j | � } |
| } | | } | | } � j | � } | j j d d � } t | � | k r�| j j t d � | t | � f � q$n x9 | D]1 } | j | � } t | | � r�| | | <q�q�Wq$Wn | i i i i f S(
s~ Fast copytracing using filename heuristics
Assumes that moves or renames are of following two types:
1) Inside a directory only (same directory name but different filenames)
2) Move from one directory to another
(same filenames but different directory names)
Works only when there are no merge commits in the "source branch".
Source branch is commits from base up to c2 not including base.
If merge is involved it fallbacks to _fullcopytracing().
Can be used by setting the following config:
[experimental]
copytrace = heuristics
In some cases the copy/move candidates found by heuristics can be very large
in number and that will make the algorithm slow. The number of possible
candidates to check can be limited by using the config
`experimental.copytrace.movecandidateslimit` which defaults to 100.
s %d::%ds? switching to full copytracing as base is not an ancestor of c2
i s0 switching to full copytracing because of merges
c @ s" | � k o! | � k o! | � k S( N( ( R4 ( R� Rl R� ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt <lambda>� Rg R] s copytrace.movecandidateslimitsB skipping copytracing for '%s', more candidates than the limit: %d
N( R R
RH R� R= R~ RD RG R� R R R� RL R\ R$ t collectionst defaultdictR% R> t osR/ t basenameR� t appendRv R� t statusR t _related( R Rk Rl R� R8 t changedfilesRz t cpR( R' t filtR4 t missingfilest basenametofilenamet dirnametofilenameR� R� t samebasenamet samedirnamet movecandidatest f2t
maxcandidatest candidatet f1( ( R� Rl R� s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyR� � sb ! %
c C@ s� | | k r | S| j � | j � } } y� | j � | j � } } | d k r` t | � } n | d k r{ t | � } n xc t r� | j � | j � } } | | k r� t | � } q~ | | k r� t | � } q~ | | k Sq~ WWn t k
r� t SXd S( sF return True if f1 and f2 filectx have a common ancestor
Walk back to common ancestor to see if the two files originate
from the same file. Since workingfilectx's rev() is None it messes
up the integer comparison logic, hence the pre-step check for
None (f1 and f2 can only be workingfilectx's initially).
N( R- R1 R
t nextR t
StopIterationR
( R� R� t g1t g2t f1rt f2r( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyR� s$
c C@ s� | j � } | j � } | j � }
| j � } | oL | | k oL | |
k } t | � }
t | � } | | |
j | � k r� | r� d Sd } | h } x�|
| | | � j � D]~} | j � } | | k r� | j � | k r� Pq� q� n | j | � | r| | d | <n | | d | <| | k r2q� n | | |
j | � k rOd S| | | | � } t | | � } | r� | | k s�| | j � k r� | r�| | d | <n� | |
k r�| | d | <ne | r�| | d | <| d | =| | d | <n5 x2 | D]* } | |
k r | | g | d | <Pq q Wd Sq� W| | k r�| sN| r_| | d | <q�xa | D]V } | |
k rf| | k r�| d j | g � j
| � n | | g | d | <d SqfWn d S( s�
check possible copies of f from msrc to mdst
srcctx = starting context for f in msrc
dstctx = destination context for f in mdst
f = the filename to check (as in msrc)
base = the changectx used as a merge base
tca = topological common ancestor for graft-like scenarios
remotebase = True if base is outside tca::srcctx, False otherwise
limit = the rev number to not search beyond
data = dictionary of dictionary to store copy data. (see mergecopies)
note: limit is only an optimization, and provides no guarantee that
irrelevant revisions will not be visited
there is no easy way to make this algorithm stop in a guaranteed way
once it "goes behind a certain revision".
NR� R# R� R� R� ( R= R R. R
R- R/ R1 R� R� t
setdefaultR� ( t srcctxt dstctxR4 R� R� t
remotebaseR t datat msrct mdstR@ R� t backwardst
getsrcfctxt
getdstfctxR� t seent ocRl t crt sf( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyR� ' sd
$
c
C@ s� i } | j j d d � } t j | � } | d k rn | d k sT | sT | d k rn t | | | | � } n xN t | | | | � j � D]/ \ } } | | k r� q� n | | j | � q� Wd S( s+ reproduce copies from fromrev to rev in the dirstate
If skiprev is specified, it's a revision that should be used to
filter copy records. Any copies that occur between fromrev and
skiprev will not be duplicated, even if they appear in the set of
copies between fromrev and rev.
R] R^ R� N( RD R` R R� R
Rf R$ t
markcopied(
R t wctxR t fromrevt skiprevt excludet ctraceconfigt bctraceR( R' ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt duplicatecopies� s * ($ t
__future__R R� R R� t i18nR Rg R RM R R R R t utilsR R" R, R5 R
R< RA RZ R\ Rb Rf Rs R R� R� R� R� R� R� R� R� ( ( ( s6 /usr/lib64/python2.7/site-packages/mercurial/copies.pyt <module> s2 ( U
9 # I � e ]