| Server IP : 80.87.202.40 / Your IP : 216.73.216.169 Web Server : Apache System : Linux rospirotorg.ru 5.14.0-539.el9.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Dec 5 22:26:13 UTC 2024 x86_64 User : bitrix ( 600) PHP Version : 8.2.27 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : ON | Pkexec : ON Directory : /usr/lib64/python3.9/site-packages/mercurial/__pycache__/ |
Upload File : |
a
�+�b � � @ s~ d dl mZ d dlZd dlZddlmZ ddlmZ ddlm Z
m Z m Z m
Z
mZ ddlmZ ddlmZmZ e �d �Zd
d � Zd d
� Zdd� ZdEdd�ZdFdd�Zdd� Z dd� Z dd� Z dd� Z d d � Z d d � Z!d Z"dZ#d Z$d!d"� Z%d#d$� Z&d%d&� Z'd'd(� Z(d)d*� Z)dGd+d,�Z*d-d.� Z+d/d0� Z,dHd1d2�Z-d3d4� Z.d5d6� Z/d7d8� Z0G d9d:� d:e1�Z2d;d<� Z3d=d>� Z4d?d@� Z5dAdB� Z6dCdD� Z7dS )I� )�absolute_importN� )�_)�nullrev)�match�pathutil�policy�pycompat�util)�
stringutil)�flagutil�sidedataZ copy_tracingc C sH t |�� �D ]6\}}||kr$||= q || vr4||= q ||vr ||= q dS )z)filters out invalid copies after chainingN)�list�items)�src�dst�t�k�v� r �6/usr/lib64/python3.9/site-packages/mercurial/copies.py�_filter$ s r c C s0 | � � }t�|�D ]\}}| �||�||< q|S )z.chain two sets of copies 'prefix' and 'suffix')�copyr � iteritems�get)�prefix�suffix�result�key�valuer r r �_chainE s r c C sV | � � D ]H}|�� }|�|d�|�� kr0| S |r|�|d�|�� kr| S qdS )a return file context that is the ancestor of fctx present in ancestor
manifest am
Note: we used to try and stop after a given limit, however checking if that
limit is reached turned out to be very expensive. we are better off
disabling that feature.N)� ancestors�pathr Zfilenode)�fctx�am�basemf�fr" r r r �
_tracefileM s r' c C sB | j }|�� �� }t|�D ]"}|�|�jr6|r||�s||= q|S �N)�dirstate�copiesr r Z get_entryZtracked)�repor Zds�cr r r r �_dirstatecopies] s r- c C s | � � }|� � }|j||d�S )z�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 )�manifest�
filesnotin)�a�br Zma�mbr r r �_computeforwardmissingf s r4 c C s( | j dkrdS | j�dd�}d}||v S )z9Checks if we should use changeset-centric copy algorithms� changeset-sidedataT� experimentals copies.read-from)s changeset-onlys
compatibility)�filecopiesmode�ui�config)r+ ZreadfromZchangesetsourcer r r �usechangesetcentricalgop s
r: c C s� | j }t|�rt| ||�S |jjo.|j�dd�}|jj}|rL|d| |f � | �� }|du r`dn|�� }i } |}
|�� | kr�|� � �
� t kr�t �
|�� �} t �|| �}
|j�dd�r�t|�|��} |r�|dt| � � n"t| ||
d�} |r�|dt| � � | j jj|�
� gd d
�}
t| �D ]z}|�r0|d | � || }|
|_|�rLt�� }t|||�}|�rx|�rp|d | � || |< |�r|d
t�� | � �q| S )z@Like _forwardcopies(), but b.rev() cannot be None (working copy)� devel� debug.copiess3 debug.copies: looking into rename from %s to %s
Ns copy-tracing.trace-all-filess+ debug.copies: searching all files: %d
r. s/ debug.copies: missing files to search: %d
T�Z inclusives& debug.copies: tracing file: %s
s% debug.copies: rename of: %s
s( debug.copies: time: %f seconds
)�_repor: �_changesetforwardcopiesr8 � debugflag�
configbool�debugr/ �p1�p2�revr �matchmod�exact�filesZintersectmatchersr �walk�lenr4 � changelogr! �sortedZ_ancestrycontextr
Ztimerr' )r1 r2 �baser r+ rB Zdbgr$ r% �cmZforwardmissingmatchZ filesmatcher�missingZancestrycontextr& r# �startZopathr r r �_committedforwardcopiesy sZ ��
��rQ c sP | j }|j�|j�tj� |j�tdur:� ���fdd�}n� ���fdd�}|S )z�returns a function that returns the following data given a <rev>"
* p1: revision number of first parent
* p2: revision number of first parent
* changes: a ChangingFiles object
Nc s: �| �\}}�| �� @ r,�| �j �tj�}nd }|||fS r( )Z _sidedatar � sidedatamodZSD_FILES)rE rC rD �raw�Z
HASCOPIESINFO�changelogrevision�flags�parentsr r �revinfo� s
z _revinfo_getter.<locals>.revinfoc s2 �| �\}}�| �� @ r$�| �j }nd }|||fS r( )�changes)rE rC rD rY rT r r rX � s
)rK �
parentrevsrV r ZREVIDX_HASCOPIESINFOrU �rustmod)r+ r �clrX r rT r �_revinfo_getter� s
r] c s i � � �fdd�}|S )z&return a cached version of is_ancestorc sH | |kr dS | |krdS | |f}� � |�}|d u rD�| |� }� |< |S )NFT)r )ZancZdescr �ret��cache� is_ancestorr r � _is_ancestor� s
z(cached_is_ancestor.<locals>._is_ancestorr )ra rb r r_ r �cached_is_ancestor� s rc c s� | � � t|� � fv ri S | �� �� }|j}|j}|j}ttf}|j| � � gdd�}|j| � � g|� � gd�} t � }
d} |j
� dd�} | D ]V}
||
�}||kr�d} q�|\}}|tkr�||v r�|
� |� |tkr�||v r�|
� |� q�|
s�i S | �r4t
|
�}
t|
�}|� � g}|j|||
dd�� t � �� � fdd �| D �} |jd
k�r�td d � |
D ��}| D ]H}
|�|
�D ]6}|tk�rv�qdd
||
< ||v �rd|| d7 < �qd�qVt||�}|j�� �( t| ||� � |||| �W d � S 1 �s�0 Y n�tdd � |
D ��}| D ]F}
|�|
�D ]4}|tk�r&�qg ||
< ||v �r|| �|
� �q�q| �� }| �|
� | �� t|�}t| ||� � |||�S d S )NTr= )�commonZheadsFr; s copy-tracing.multi-thread)Z includepathc s g | ]}|� v r|�qS r r ��.0�r�Z
roots_to_headr r �
<listcomp>+ � z+_changesetforwardcopies.<locals>.<listcomp>r5 c s s | ]}|d fV qdS )r Nr re r r r � <genexpr>7 rj z*_changesetforwardcopies.<locals>.<genexpr>r r c s s | ]}|g fV qd S r( r re r r r rk M rj ) rE r r+ Z
unfilteredrK Z
isancestorrevZ_uncheckedparentrevsr! Zfindmissingrevs�setr8 rA �addr �minZreachablerootsr7 �dictrZ r] Zreading�_combine_changeset_copies�append�pop�extend�sort�_revinfo_getter_extra� _combine_changeset_copies_extra)r1 r2 r r+ r\ �
isancestorrW Z graph_rootsr! �revs�rootsZhas_graph_roots� multi_threadrg ZpsrC rD �m�h�children_count�prX �children�xr rh r r? � s�
�&
�r? c C s2 |� � }tdur*t�t| �||||�}�n�t|�}i } | D �]�}
||
�\} } }
d}d| fd| ffD �]^\}}|tkrvqb|�|�}|du r�qb|d8 }|||< |r�| �|d�}n | �|d�}|du r�i }}n|r�|�� }n|}|
du�r�i }|dkr�|
j }n|dk�r
|
j
}|�rd|�� }t � |�D ]@\}}|�|�}|du�rT|d du�rT|d }|
|f||< �q"|
j
�r�|
j
D ].}||v �rr||u �r�|�� }|
df||< �qr|du �r�|}qbt||||
|
�}qb|| |
< q:i }| | }|�� D ] \}\}}|du�r�|||< �q�|�s.t|�� �D ]}||��s||= �q|S )a� combine the copies information for each item of iterrevs
revs: sorted iterable of revision to visit
children_count: a {parent: <number-of-relevant-children>} mapping.
targetrev: the final copies destination revision (not in iterrevs)
revinfo(rev): a function that return (p1, p2, p1copies, p2copies, removed)
match: a matcher
It returns the aggregated copies information for `targetrev`.
Nr � )�alwaysr[ Zcombine_changeset_copiesr rc r r rr r Zcopied_from_p1Zcopied_from_p2r r �removed�_merge_copies_dictr �keys) rx r} � targetrevrX r rw rz � alwaysmatch� final_copies�
all_copiesZ current_revrC rD rY Zcurrent_copies�parentZ
parent_revZremaining_childrenr* � newcopies� childcopies�dest�source�prevr& Ztargetrev_items�tt�filenamer r r rp ` s� �
�
rp r� c
C s� |� � D ]x\}}| �|�}|du r,|| |< qt|||||�\}} | rp|tkr^||d f| |< q�||d f| |< q|tkr|| |< q| S )a� merge two copies-mapping together, minor and major
In case of conflict, value from "major" will be picked.
- `isancestors(low_rev, high_rev)`: callable return True if `low_rev` is an
ancestors of `high_rev`,
- `ismerged(path)`: callable return True if `path` have been merged in the
current revision,
return the resulting dict (in practice, the "minor" object, updated)
Nr )r r �_compare_values�
PICK_MAJOR)
�minor�majorrw rY Z
current_merger� r �otherZpickZ overwriter r r r� � s
�
r� c C s� |\}}|\}}||kr t dfS | durJ|durJ|du rJ|| jv rJtdfS | durt|durt|du rt|| jv rttdfS |||�r�| dur�|| jv r�tdfS tdfS nV|||�r�| dur�|| jv r�tdfS tdfS n(|du r�tdfS |du r�tdfS tdfS dS )z�compare two value within a _merge_copies_dict loop iteration
return (pick, overwrite).
- pick is one of PICK_MINOR, PICK_MAJOR or PICK_EITHER
- overwrite is True if pick is a return of an ambiguity that needs resolution.
FNT)� PICK_EITHERZsalvaged�
PICK_MINORr� Zmerged) rY rw r� r� r� Zmajor_ttZ major_valueZminor_ttZ minor_valuer r r r� � sF ��������
r� c s, �j }|j��fdd�� � ��fdd�}|S )aW return a function that return multiple data given a <rev>"i
* p1: revision number of first parent
* p2: revision number of first parent
* p1copies: mapping of copies from p1
* p2copies: mapping of copies from p2
* removed: a list of removed files
* ismerged: a callback to know if file was merged in that revision
c s �| � � �fdd�}|S )Nc sN | � � � vrdS � | }|j�|j�}d}|D ]}|�jkr.|d7 }q.|dkS )NFr r r� )rH Z_filelogrW Z _filenodeZnullid)r" r# rW Z
nb_parents�n)�ctxr+ r r �ismerged@ s
z=_revinfo_getter_extra.<locals>.get_ismerged.<locals>.ismergedr )rE r� )r+ )r� r � get_ismerged= s z+_revinfo_getter_extra.<locals>.get_ismergedc s: �| �\}}�| }|j \}}|�� }|||||� | �fS r( )Z_copiesZ filesremoved)rE rC rD r� �p1copies�p2copiesr� �r� rW r+ r r rX M s
z&_revinfo_getter_extra.<locals>.revinfo)rK rZ )r+ r\ rX r r� r ru 0 s
ru c s� i }� � � }| D �]P}|�|d�} | du r.i } t|| �D �]$\}
} || �\} }
}}}}|| krjd}|}nd}|}|s�� fdd�|�� D �}| }|r�| �� }t�|�D ]:\}}| �|�}|dur�|d dur�|d }| |f||< q�|D ]*}||v r�|| u �r| �� }| df||< q�|�| �}|du �r0||| < q:|dk�rJt||||� q:t||||� ||| < q:qi }|| �� D ] \}\}}|du�rt|||< �qt|S )zyversion of `_combine_changeset_copies` that works with the Google
specific "extra" based storage for copy informationNr r� c s i | ]\}}� |�r||�qS r r )rf r r r. r r �
<dictcomp>m s z3_combine_changeset_copies_extra.<locals>.<dictcomp>) r� rr � enumerater r r r r �_merge_copies_dict_extra) rx r r� rX r rw r� r� rg r* �ir, rC rD r� r� r� r� r� r� r� r� r� r� r& Z othercopiesr� r� r r. r rv W s\
�
��
rv c C sv |� � D ]h\}}| �|�}|du r,|| |< q|d }|d }|d |d krNq||ksh|||�rh||�r|| |< qdS )zrversion of `_merge_copies_dict` that works with the Google
specific "extra" based storage for copy informationNr r )r r ) r� r� rw r� r� r r� Znew_ttZother_ttr r r r� � s
���r� c C s^ |du r | }| � � �|�}|�� du rLt| |�� ||�}t|t|j|��}nt| |||�}|S )z<find {dst@b: src@a} copy mapping where a is an ancestor of bN)r+ � narrowmatchrE rQ rC r r- r> )r1 r2 rM r rN r* r r r �_forwardcopies� s r� c C s. | j j�dd�dkri S t|| �}t|| |�S )zfind renames from a to br6 � copytraces off)r> r8 r9 r� �_reverse_renames)r1 r2 r r* r r r �_backwardrenames� s
r� c C s@ i }t t�| ��D ](\}}|r(||�s(q||v r2q|||< q|S )z>given copies to context 'dst', finds renames from that context)rL r r )r* r r rg r r r r r r� � s
r� c
C sv | j }|jjo|j�dd�}|r4|j�d| |f � | |ksD| rD|sHi S |�� du rz| |�� krz|rp|j�d� t||�S |�| �}|| kr�|r�|j�d� t | ||d�}n�||kr�|r�|j�d� t
| ||d�}n�|r�|j�d � d}|�� t kr�| }t || �}t ||||d�} t |�t | �@ }
|
D ](} |�
| �| �
| �k�r&|| = | | = �q&t|| |�} t| | �}t| ||� |S )
z5find {dst@y: src@x} copy mapping for directed comparer; r< s- debug.copies: searching copies from %s to %s
Ns$ debug.copies: search mode: dirstate
s# debug.copies: search mode: forward
r. s$ debug.copies: search mode: backward
s$ debug.copies: search mode: combined
)r> r8 r@ rA rB rE rC r- Zancestorr� r� r rl r r� r r )
r� �yr r+ rB r1 r* rM Zx_copiesZy_copiesZ same_keysr Zx_backward_renamesr r r �
pathcopies� sP
�
� r� c C s� |r|r||kr t � t � i fS |�� �� }|�� du r^|�� | j�� kr^t t| |��t � i fS | j�dd�}t �
|�du r�t � t � i fS t | �r�t | |||�S |dkr�t
| ||�r�t | |||�S t| |||�S t | |||�S dS )a�
Finds 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 a tuple where:
"branch_copies" an instance of branch_copies.
"diverge" is a mapping of source name -> list of destination names
for divergent renames.
This function calls different copytracing algorithms based on config.
Nr6 r� Fs
heuristics)�
branch_copiesr+ r� �noder) rC r- r8 r9 r Z parseboolr: �_fullcopytracing�_isfullcopytraceable�_heuristicscopytracing)r+ �c1�c2rM r� Z copytracingr r r � mergecopies
s$ ! � r� c C sX |� � du r|�� }|�� rT|�� rT| j�dd�}t| �d|� � |� � ��}||k S dS )a� 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.
Nr6 s copytrace.sourcecommitlimit� %d::%dF)rE rC Zmutabler8 � configintrJ rx )r+ r� rM ZsourcecommitlimitZcommitsr r r r� S s �r� c
C s� | |vr| |vr�||| < nf| |vr$n\|| || krJt || || �sJd S || || ksn|�| �|�| �kr�|D ] } | || < qrd S r( )�_relatedrV )
r �dsts1�m1�m2r3 r� rM r � renamedeleter r r r �_checksinglesidecopiesg s
"$r� c @ s" e Zd ZdZddd�Zdd� ZdS )r� a Information about copies made on one side of a merge/graft.
"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.
"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.
Nc C sL |d u r i n|| _ |d u r i n|| _|d u r0i n|| _|d u rBi n|| _d S r( �r r� �dirmove� movewithdir)�selfr r� r� r� r r r �__init__� s zbranch_copies.__init__c C s d| j | j| j| jf S )NzJ<branch_copies
copy=%r
renamedelete=%r
dirmove=%r
movewithdir=%r
>r� )r� r r r �__repr__� s �zbranch_copies.__repr__)NNNN)�__name__�
__module__� __qualname__�__doc__r� r� r r r r r� | s �
r� c $ s� |� � �|� � �|� � �t||�}t||�}|sB|sBt� t� i fS i }i }|�� D ]\}} |�| g ��|� qR|�� D ]\}} |�| g ��|� qvi }
i } i } i }
i }t|�t|�B }|D �]} |�| �}|�| �}|�r�|�r�| �v�rB| �v�rBt|�}t|�}||@ �r0||@ D ]}| |
|< | | |< �qnt||B �| | < nD| �v �r�| �v �r�t|�}t|�}||@ D ]}| |
|< | | |< �qnq�|�r�t | |���|||
|
� q�|r�t | |���||| |� q�g ������fdd�� � fdd�}� fdd�}�j
j �rf|� }|� }d}|�r4�j
� d|d d �
|�f � |�rX�j
� d|d
d �
|�f � t� }t� }| �� D ]}|�|� �ql|
�� D ]}|�|� �q�|�� D ]}|�|� �q��j
� d � d|fd |ffD ]�\}}|�s�qΈj
� d
| � t|�D ]d} d} | |
v �s| | v �r | d7 } | |v �r.| d7 } | |v �r@| d7 } �j
� d|| | | f � �q��q�~~�j
� d� t�||
||�\} } t�|| ||�\} }!t|
|
| |!�}"t| || | �}#|"|#| fS )a' 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.
c sR � sJ�� ���� �}�� ���� �}t|| �}t|| �}� �||f� � | S r( )r0 r� rL rs )�idxZ addedinm1Z addedinm2�u1�u2)r` r� r� r3 r+ r r �_get_addedfiles� s z)_fullcopytracing.<locals>._get_addedfilesc s � d�S )Nr r r �r� r r �<lambda>� rj z"_fullcopytracing.<locals>.<lambda>c s � d�S )Nr r r r� r r r� � rj s unmatched files in %ss
%s:
%s
s locals
s othersK all copies found (* = to merge, ! = divergent, % = renamed and deleted):
s remotes on %s side:
rj � *� !� %s src: '%s' -> dst: '%s' %s
s! checking for directory renames
)r/ r� r� r �
setdefaultrq rl r rL r� r8 r@ rB �join�values�update� _dir_renames)$r+ r� r� rM �copies1�copies2Zinversecopies1Zinversecopies2r r Zcopy1�copy2ZdivergeZ
renamedelete1Z
renamedelete2Z
allsourcesr� Zdsts2Zu1fnZu2fnr� r� �headerZrenamedeletesetZ
divergesetZdstsZsider* r& ZnoteZdirmove1Z movewithdir2Zdirmove2Z movewithdir1Zbranch_copies1Zbranch_copies2r )r� r` r� r� r3 r+ r r� � s�
��
�� �
� r� c C sj t � }i }t�|�D ]r\}}t�|�t�|� } }
| |v r>qq|�| �r^|�|
�r^|�| � q| |v r~|| |
kr~|�| � q|
|| < q|D ]} | |v r�|| = q�~|s�i i fS dd� t�|�D �}|D ] } | j�d| || f � q�t |dd�}
i }|� D ]f}||vr�|
D ]T} |�
| ��r
|| |t | �d� }||v�rX|||< | j�d||f � q��q
q�||fS )a� Finds moved directories and files that should move with them.
ctx: the context for one of the sides
copy: files copied on the same side (as ctx)
fullcopy: files copied on the same side (as ctx), including those that
merge.manifestmerge() won't care about
addedfilesfn: function returning added files on the other side (compared to
ctx)
c S s i | ]\}}|d |d �qS )� /r )rf r r r r r r� S rj z _dir_renames.<locals>.<dictcomp>s) discovered dir src: '%s' -> dst: '%s'
T)�reverseNs' pending file src: '%s' -> dst: '%s'
) rl r r r �dirnameZhasdirrm r8 rB rL �
startswithrJ )r+ r� r ZfullcopyZ addedfilesfnZinvalidr� r r ZdsrcZddstr� �dZdirmove_children_firstr� r& Zdfr r r r� , sL
�
��
r� c s. |� � du r|�� }�� � du r(��� �t� }|�� �| �d� � � �� � �sf| j�d� t| |�� �S �}|� kr�t|� � �dkr�| j�d� t| |�� �S |�
|� � � |�� }qji }t � ��}t
�|�D ]\}} | �v r�| ||< q̇ ��fdd���fdd �|D �}
i } |
�r t�t�} t�t�}
��� �� �D ]:}tj�|�}tj�|�}| | �|� |
| �|� �q4|
D ]�}tj�|�}tj�|�}| | }|
| }|| }��|�}| j�d
d �}t|�|k�r�| j�td �|t|�f � �qt|D ]$}|�|�}t ||��r�|| |< �q�qtt | �t |�i fS )
a} 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.
Nr� s? switching to full copytracing as base is not an ancestor of c2
r� s0 switching to full copytracing because of merges
c s | �vo| � v o| �v S r( r )r& )rM r� r� r r r� � rj z(_heuristicscopytracing.<locals>.<lambda>c s g | ]}� |�r|�qS r r )rf r& )�filtr r ri � rj z*_heuristicscopytracing.<locals>.<listcomp>r6 s copytrace.movecandidateslimitsB skipping copytracing for '%s', more candidates than the limit: %d
) rE rC rl r/ rx r8 rB r� rJ rW r� rH r� r r � collections� defaultdictr r0 �osr" �basenamer� rq Zfilectxr� �statusr r� r� )r+ r� r� rM Z changedfilesr� r� Zcpr r Z missingfilesr� ZbasenametofilenameZdirnametofilenamer& r� r� Z samebasenameZ samedirnameZmovecandidates�f2Z
maxcandidates� candidate�f1r )rM r� r� r� r r� s st �
��
��
r� c C s� | |kr dS | � � |� � }}zx| �� |�� }}|du rBt|�} |du rRt|�}| �� |�� }}||krvt|�} qR||kr�t|�}qR| |kW S qRW n ty� Y dS 0 dS )aF 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).
TNF)r! Zlinkrev�next�
StopIteration)r� r� Zg1Zg2Zf1rZf2rr r r r� � s"
r� c C sh t ||�}| �� }t|| |� t|�� �D ]\}}||v r*||= q*t�|�D ]\}}| | �|� qLdS )a reproduce copies between base and ctx in the wctx
Unlike mergecopies(), this function will only consider copies between base
and ctx; it will ignore copies between base and wctx. Also unlike
mergecopies(), this function will apply copies to the working copy (instead
of just returning information about the copies). That makes it cheaper
(especially in the common case of base==ctx.p1()) and useful also when
experimental.copytrace=off.
merge.update() will have already marked most copies, but it will only
mark copies if it thinks the source files are related (see
merge._related()). It will also not mark copies if the file wasn't modified
on the local side. This function adds the copies that were "missed"
by merge.update().
N)r� rC r r r r r Z
markcopied) Zwctxr� rM Z
new_copiesr� r� �__r r r r r � graftcopies s
r� )N)N)NN)N)8Z
__future__r r� r� Zi18nr r� r � r rF r r r r
Zutilsr Z revlogutilsr r
rR Z
importrustr[ r r r' r- r4 r: rQ r] rc r? rp r� r� r� r� r� ru rv r� r� r� r� r� r� r� r� �objectr� r� r� r� r� r� r r r r �<module> sR
!
C&lr :'F
.F$
Gm!