| 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 : /lib64/python3.9/site-packages/hgext/__pycache__/ |
Upload File : |
a
�+�bܣ �
@ s� d Z ddlmZ ddlZddlmZ ddlmZmZ ddl m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZmZmZmZ ddlmZ dZi Z e� e �Z i Z e� e �Z e d d
d d � e d d
dd � e d ddd � dddd�Z ej!Z!G dd� de"�Z#G dd� de"�Z$dd� Z%d<dd�Z&d=d d �Z'G d d � d ej(�Z)d>d d!�Z*G d"d#� d#e"�Z+G d$d%� d%e"�Z,d&d'� Z-d(d)� Z.d?d*d+�Z/e d d,d-ded.�fd/d0ded1�fd2d3ded4�fd5d6ded7�fge j0 e j1 e j2 ed8�e j3d d9�d:d;� �Z4dS )@a? apply working directory changes to changesets (EXPERIMENTAL)
The absorb extension provides a command to use annotate information to
amend modified chunks into the corresponding non-public changesets.
::
[absorb]
# only check 50 recent non-public changesets at most
max-stack-size = 50
# whether to add noise to new commits to avoid obsolescence cycle
add-noise = 1
# make `amend --correlated` a shortcut to the main command
amend-flag = correlated
[color]
absorb.description = yellow
absorb.node = blue bold
absorb.path = bold
� )�absolute_importN)�_)�hex�short)�cmdutil�commands�context�crecord�error�linelog�mdiff�obsolete�patch�phases�pycompat� registrar� rewriteutil�scmutil�util)�
stringutils ships-with-hg-core� absorb� add-noiseT��defaults
amend-flag� max-stack-size�2 s yellows blue bolds bold)� absorb.description� absorb.node� absorb.pathc @ s$ e Zd ZdZdZdZdZdd� ZdS )�nulluiz blank ui object doing nothingFTc C s dd� }|S )Nc _ s d S �N� )�args�kwdsr! r! �2/usr/lib64/python3.9/site-packages/hgext/absorb.py�nullfunc_ s z$nullui.__getitem__.<locals>.nullfuncr! )�namer% r! r! r$ � __getitem__^ s znullui.__getitem__N)�__name__�
__module__� __qualname__�__doc__� debugflag�verbose�quietr' r! r! r! r$ r W s
r c @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �emptyfilecontextz.minimal filecontext representing an empty filec C s
|| _ d S r )�_repo)�self�repor! r! r$ �__init__h s zemptyfilecontext.__init__c C s dS )N� r! �r1 r! r! r$ �datak s zemptyfilecontext.datac C s | j jS r )r0 �nullidr5 r! r! r$ �noden s zemptyfilecontext.nodeN)r( r) r* r+ r3 r6 r8 r! r! r! r$ r/ e s r/ c C s4 t � }g }| D ] }||vr|�|� |�|� q|S )z@list -> list. remove duplicated items without changing the order)�set�add�append)Zlst�seen�result�xr! r! r$ �uniqr s
r? c C s^ | }g }|� � tjkrR|r(t|�|kr(qR|�� }t|�dkr>qR|�|� |d }q|�� |S )a) (ctx, int?) -> [ctx]. get a linear stack of non-public changesets.
changesets are sorted in topo order, oldest first.
return at most limit items, if limit is a positive number.
merges are considered as non-draft as well. i.e. every commit
returned has and only has 1 parent.
� r )Zphaser Zpublic�len�parentsr; �reverse)�headctx�limit�ctxr= rB r! r! r$ �
getdraftstack} s
rG c C s� |du rt � }|| d vr"g i fS g }i }| d �� }t| �D ]b}||vrR|} q�|| }|�|� ||v rtd} q�|||< |�� }|r>|}||v r>|�� } q�q>|dur�||v r�|�|| � n|�t|�� �� |�� t|�|fS )aP ([ctx], str, set) -> [fctx], {ctx: fctx}
stack is a list of contexts, from old to new. usually they are what
"getdraftstack" returns.
follows renames, but not copies.
seenfctxs is a set of filecontexts that will be considered "immutable".
they are usually what this function returned in earlier calls, useful
to avoid issues that a file was "moved" to multiple places and was then
modified differently, like: "a" was copied to "b", "a" was also copied to
"c" and then "a" was deleted, then both "b" and "c" were "moved" from "a"
and we enforce only one of them to be able to affect "a"'s content.
return an empty list and an empty dict, if the specified path does not
exist in stack[-1] (the top of the stack).
otherwise, return a list of de-duplicated filecontexts, and the map to
convert ctx in the stack to fctx, for possible mutable fctxs. the first item
of the list would be outside the stack and should be considered immutable.
the remaining items are within the stack.
for example, given the following changelog and corresponding filelog
revisions:
changelog: 3----4----5----6----7
filelog: x 0----1----1----2 (x: no such file yet)
- if stack = [5, 6, 7], returns ([0, 1, 2], {5: 1, 6: 1, 7: 2})
- if stack = [3, 4, 5], returns ([e, 0, 1], {4: 0, 5: 1}), where "e" is a
dummy empty filecontext.
- if stack = [2], returns ([], {})
- if stack = [7], returns ([1, 2], {7: 2})
- if stack = [6, 7], returns ([1, 2], {6: 1, 7: 2}), although {6: 1} can be
removed, since 1 is immutable.
N���r ) r9 �p1�reversedr; �
copysourcer/ r2 rC r? ) �stack�path� seenfctxs�fctxs�fctxmap�pctxrF �fctx�copyr! r! r$ � getfilestack� s: %
rT c @ s e Zd ZdZdd� Zdd� ZdS )� overlaystorezsread-only, hybrid store based on a dict and ctx.
memworkingcopy: {path: content}, overrides file contents.
c C s || _ || _d S r )�basectx�memworkingcopy)r1 rV rW r! r! r$ r3 � s zoverlaystore.__init__c C sX || j vrdS | j | }|| jv r.| j| }n|�� }|�� |�� f}|�� }|||fS )z-comply with mercurial.patch.filestore.getfile)NNN)rV rW r6 �islinkZisexecrK )r1 rM rR �content�moderS r! r! r$ �getfile� s
zoverlaystore.getfileN)r( r) r* r+ r3 r[ r! r! r! r$ rU � s rU c C s� |du r |� � j�|�� �}|du r,|�� }|du r<|�� }|�� }|�� }t|� � ��
| �}t || �}t j
|� � ||||||d|d� S )zi({path: content}, ctx, (p1node, p2node)?, {}?) -> memctx
memworkingcopy overrides file contents.
N) r2 rB �text�filesZ filectxfn�user�date�branch�extra)r2 Z changelogrB r8 ra � descriptionr_ r^ r9 r] �unionrU r Zmemctx) rW rF rB ra �descr_ r^ r] �storer! r! r$ �overlaycontext� s*
�rf c @ s� e Zd ZdZd dd�Zd dd�Zdd� Zd d
� Zd d � Ze d
d� �Z
dd� Z dd� Z dd� Z
dd� Zd dd�Zdd� Zd d � ZdS )!�filefixupstatea state needed to apply fixups to a single file
internally, it keeps file contents of several revisions and a linelog.
the linelog uses odd revision numbers for original contents (fctxs passed
to __init__), and even revision numbers for fixups, like:
linelog rev 1: self.fctxs[0] (from an immutable "public" changeset)
linelog rev 2: fixups made to self.fctxs[0]
linelog rev 3: self.fctxs[1] (a child of fctxs[0])
linelog rev 4: fixups made to self.fctxs[1]
...
a typical use is like:
1. call diffwith, to calculate self.fixups
2. (optionally), present self.fixups to the user, or change it
3. call apply, to apply changes
4. read results from "finalcontents", or call getfinalcontent
Nc C s~ || _ || _|pt� | _|p i | _dd� |D �| _t�tj | j�| _
| � � | _ | jj
rVddg| _g | _g | _g | _t� | _dS )z�([fctx], ui or None) -> None
fctxs should be linear, and sorted by topo order - oldest first.
fctxs[0] will be considered as "immutable" and will not be changed.
c S s g | ] }|� � �qS r! )r6 ��.0�fr! r! r$ �
<listcomp>; r4 z+filefixupstate.__init__.<locals>.<listcomp>r N)rO rM r �ui�opts�contentsr Zmaplistr �
splitnewlines� contentlines�
_buildlinelogr r, �
chunkstats� targetlines�fixups�
finalcontentsr9 � ctxaffected)r1 rO rM rl rm r! r! r$ r3 / s
zfilefixupstate.__init__c C s� | j d }| jd }|�� }t�|�}|| _| j�| jj� | jj }|rn|d d |d d d f}|�
|� | � ||||�D ]`} | � | |�}
| j
d t|
�7 < | j
d d7 < | j|
7 _|dur~| �|||| |
� q~dS )a� calculate fixups needed by examining the differences between
self.fctxs[-1] and targetfctx, chunk by chunk.
targetfctx is the target state we move towards. we may or may not be
able to get there because not all modified chunks can be amended into
a non-public fctx unambiguously.
call this only once, before apply().
update self.fixups, self.chunkstats, and self.targetlines.
rH r r@ N)rn rp r6 r ro rs r �annotateZmaxrev�annotateresultr; �_alldiffchunks�_analysediffchunkrr �boolrt � _showchanges) r1 �
targetfctx�fm�a�alines�b�blines� annotatedZ dummyendline�chunk� newfixupsr! r! r$ �diffwithH s"
zfilefixupstate.diffwithc C s� t | j�D ]x\}}}}}| j||� }| jjrnt|d d�d }| j�td�t| j | �
� �||t |�f � | j �
|||||� q
| j�dd�r�| �� | _n
| �� | _dS )z�apply self.fixups. update self.linelog, self.finalcontents.
call this only once, before getfinalcontent(), after diffwith().
r@ r � s %s: chunk %d:%d -> %d lines
�
edit_linesFN)rJ rt rs rl r, �max�writer r rO r8 rA r � replacelinesrm �get�_checkoutlinelogwitheditsru �_checkoutlinelog)r1 �rev�a1�a2�b1�b2r� �idxr! r! r$ �applyk s �� zfilefixupstate.applyc C s | j �|�}| j| S )z@(fctx) -> str. get modified file content for a given filecontext)rO �indexru )r1 rR r� r! r! r$ �getfinalcontent� s z filefixupstate.getfinalcontentc s6 |\}}}}� ||� }|sD� rD|t d|d �h}� fdd�|D �}tdd� |D ��} g }
t| �dkr�| �||d d�r�| d } | dkr�| d } |
�| ||||f� n�|| || ks�||k�r,t�||�D ]^}
� |
\} }| dkr�||kr�d }}n||
| }|d }| d } |
�| |
|
d ||f� q�| �|
�S )a� analyse a different chunk and return new fixups found
return [] if no lines from the chunk can be safely applied.
the chunk (or lines) cannot be safely applied, if, for example:
- the modified (deleted) lines belong to a public changeset
(self.fctxs[0])
- the chunk is a pure insertion and the adjacent lines (at most 2
lines) belong to different non-public changesets, or do not belong
to any non-public changesets.
- the chunk is modifying lines from different changesets.
in this case, if the number of lines deleted equals to the number
of lines added, assume it's a simple 1:1 map (could be wrong).
otherwise, give up.
- the chunk is modifying lines from a single non-public changeset,
but other revisions touch the area as well. i.e. the lines are
not continuous as seen from the linelog.
r r@ c s$ g | ] }� | d dkr� | �qS �r r@ r! )ri �i�r� r! r$ rk � s z4filefixupstate._analysediffchunk.<locals>.<listcomp>c S s h | ] \}}|�qS r! r! )ri �r�lr! r! r$ � <setcomp>� r4 z3filefixupstate._analysediffchunk.<locals>.<setcomp>T)r� �listrA �
_iscontinuousr; r �xrange�_optimizefixups)r1 r� r� r� r� r� r� ZinvolvedZnearbylinenumsZ involvedrevsr� r� Zfixuprevr� �linenumZnb1Znb2r! r� r$ rz � s2
�
z filefixupstate._analysediffchunkc c s4 t j| |||d�}|D ]\}}|dkr(q|V qdS )z5like mdiff.allblocks, but only care about differences)Zlines1Zlines2� !N)r Z allblocks)r r� r� r� Zblocksr� Zbtyper! r! r$ ry � s
z filefixupstate._alldiffchunksc
C s� t � � }dg }}t�t| j��D ]l}| j| | j| }}|d d }| �||||�}tt|��D ] \} }
} } |� || |
| | � qd|| }}q"|S )z~calculate the initial linelog based on self.content{,line}s.
this is similar to running a partial "annotate".
r4 r� r@ )
r r r� rA rn rp ry rJ r� r� )
r1 �llogr r� r� r� r� Zllrev�chunksr� r� r� r� r! r! r$ rq � s
z filefixupstate._buildlinelogc C sV g }t �t| j��D ]<}|d d }| j�|� d�t| j| jj ��}|�
|� q|S )z1() -> [str]. check out file contents from linelogr@ r� r4 ) r r� rA rn r rw �join�map�_getlinerx r; )r1 rn r� r� rY r! r! r$ r� � s z filefixupstate._checkoutlinelogc
s. | j �� }td�| jd �� }dd� t| j�D �}t|�D ]P\}\}}|td�d| dt|�| d t|�� �|� � �
d d�d
f 7 }q<|td �dt|� 7 }t d d
� ��|D ]8\}}| j � |d d � | j j
D ]� �� �|� q�q�|D ]0� |dd�� �fdd�|D ��| �� �f 7 }q�| jj|ddd�}|�sLt�td���dgt| j� }d} | t|� d }
t�|�D ]�� � �d��r��qz� |
d |
d � dk�r�t�td�� ��� |
d d� } tt�� | |
d � ��D ],\}} | dk�r�||| d
| 7 < �q�qz||k�r*ddg| _|S )z&() -> [str]. prompt all lines for editsZ HG: editing %s
HG: "y" means the line to the right exists in the changeset to the top
HG:
rH c S s" g | ]\}}t |t�s||f�qS r! )�
isinstancer/ )ri r� rj r! r! r$ rk � s
�z<filefixupstate._checkoutlinelogwithedits.<locals>.<listcomp>s HG: %s/%s %s %s
� |� -r@ �
r s HG: %s
c S s t � S r )r9 r! r! r! r$ �<lambda>� r4 z:filefixupstate._checkoutlinelogwithedits.<locals>.<lambda>r� s %s : %sr4 c s$ g | ] \}}|�� v r d nd�qS )� y� r! )ri r� Z_f�r� Zlinesetr! r$ rk � s �r )�actions empty editor text� s HG:s : s malformed line: %sNr� )r � getalllinesr rO rM � enumeraterA r r8 rb �split� defaultdictrw rx r: r� r� rl Zeditr
�
InputErrorr ro �
startswithr Zbytestrrr )
r1 ZalllinesZ
editortextZ visiblefctxsr� �jrj Z
editedtextrn Z
leftpadposZcolonposZ linecontentZchr! r� r$ r� � sh
� ���
�
���
�
z(filefixupstate._checkoutlinelogwitheditsc C s0 |\}}|d@ r"| j |d | S | j| S dS )z@((rev, linenum)) -> str. convert rev+line number to line contentr@ r� N)rp rs )r1 Zlineinfor� r� r! r! r$ r� s zfilefixupstate._getlineFc C sR ||kr dS | j }|�|�}|�|�t|� }|�||�}t|�|| t|� kS )a (a1, a2 : int) -> bool
check if these lines are continuous. i.e. no other insertions or
deletions (from other revisions) among these lines.
closedinterval decides whether a2 should be included or not. i.e. is
it [a1, a2), or [a1, a2] ?
T)r Z getoffset�intr� rA )r1 r� r� Zclosedintervalr� Zoffset1Zoffset2Zlinesinbetweenr! r! r$ r� & s
z filefixupstate._iscontinuousc
s� g �g d�g� � �fdd�}t |�D ]�\}}|\}}}}} � d d }
� d d } � d d } || kr�|| kr�||
kr�| �t|d d�|�r�|� d d< | � d d< q$|� t|�� d< q$|� �S )zx[(rev, a1, a2, b1, b2)] -> [(rev, a1, a2, b1, b2)].
merge adjacent fixups to make them less fragmented.
)rH rH rH rH rH c s& � d d dkr"�� t� d �� d S )Nr rH )r; �tupler! �Z
pcurrentchunkr= r! r$ � pushchunk> s z1filefixupstate._optimizefixups.<locals>.pushchunkr r� r� r@ )r� r� r� r� )
r1 rt r� r� r� r� r� r� r� r� ZlastrevZlasta2Zlastb2r! r� r$ r� 7 s,
���� z filefixupstate._optimizefixupsc sT dd� }|\}}} }
dg|| dg|
| } } |D ]f\}
}}}}t �||�D ] }t|
d�d d | || < qPt �||�D ] }t|
d�d d | || < q|q6� �� � jddd||| | |
| f d d
� � j�jdd � � �fd d
�}t �||�D ]$}|| || d||| �dd� q�t �| |
�D ]&}|| || d||| �dd� �q(d S )Nc S s | � d�r| d d� } | S )Nr� rH )�endswith)�liner! r! r$ �trimW s
z)filefixupstate._showchanges.<locals>.trimr r@ r� s hunks %s
s @@ -%d,%d +%d,%d @@s diff.hunk�Zlabel�rM �linetypec s| � � � d}| r>�j| }� j|d� |�� }�j�|�� � � jdd|dd� � jd| d|||d� � j�j |d � d S )
Nr4 )rR � node� %-7.7s r r� s diffchar s %s%s
r� )
� startitemrO r r rv r: Z changectxr� r6 rM )r� Zdiffcharr� r� Z linelabelr8 rF �r~ r1 r! r$ � writelineo s
�z.filefixupstate._showchanges.<locals>.writeliner� s deleteds diff.deleted� +s inserteds
diff.inserted)r r� r� r� r� r6 rM )r1 r~ r� r� r� rt r� r� r� r� r� ZaidxsZbidxsr� Zfa1Zfa2Zfb1Zfb2r� r� r! r� r$ r| V sB �
�
�zfilefixupstate._showchanges)NN)N)F)r( r) r* r+ r3 r� r� r� rz � staticmethodry rq r� r� r� r� r� r| r! r! r! r$ rg s
#3
D
rg c @ s� e Zd ZdZd#dd�Zd$dd�Zdd� Zed d
� �Zd d � Z d
d� Z
dd� Z dd� Z dd� Z
dd� Zdd� Zed%dd��Zd&dd �Zejd d � �Zd d � Zejd!d"� �ZdS )'�
fixupstatea^ state needed to run absorb
internally, it keeps paths and filefixupstates.
a typical use is like filefixupstates:
1. call diffwith, to calculate fixups
2. (optionally), present fixups to the user, or edit fixups
3. call apply, to apply changes to memory
4. call commit, to commit changes to hg database
Nc C s^ |pt � | _|pi | _|| _|d �� �� | _g | _d| _i | _i | _ i | _
d| _ t � | _
dS )z�([ctx], ui or None) -> None
stack: should be linear, and sorted by topo order - oldest first.
all commits in stack are considered mutable.
rH N)r rl rm rL r2 Z
unfiltered�paths�statusrP �fixupmap�
replacemap� finalnoder9 rv )r1 rL rl rm r! r! r$ r3 � s
zfixupstate.__init__c C sX | j d �||�| _g | _| j�d�}| jjs@|r@|r@|�� }n| jj}t� }t|�D ]�}| j �
d| � || }t | j ||�\} }
t dd� |g| D ��r�qV|�
� | d �
� kr�|s�qV|�| dd� � |
| j|< t| || j | jd�} |du�r"|�� |�d � |jd
d |d d
� |j
d
d� | �||� | | j|< | j�|� | j�| j� qVdS )z9diff and prepare fixups. update self.fixupmap, self.pathsrH r� s calculating fixups for %s
c s s. | ]&}t |t�s|�� p$t�|�� �V qd S r )r� r/ rX r Zbinaryr6 rh r! r! r$ � <genexpr>� s
�z&fixupstate.diffwith.<locals>.<genexpr>r@ N�rl rm s showing changes for s path� %s
r r� �r� )rL r� r� rm r� Zmodifiedr] r9 �sortedrl �debugrT �anyr6 �updaterP rg r� Zplainr� r� r� r; rv ) r1 � targetctx�matchr~ ZeditoptZinterestingpathsrN rM r} rO �ctx2fctxZfstater! r! r$ r� � s:
�
zfixupstate.diffwithc C s> t �| j�D ],\}}| jjr0| j�td�| � |�� q dS )z*apply fixups to individual filefixupstatess applying fixups to %s
N)r � iteritemsr� rl r, r� r r� )r1 rM �stater! r! r$ r� � s zfixupstate.applyc C s dd� t �| j�D �S )z>-> {path: chunkstats}. collect chunkstats from filefixupstatesc S s i | ]\}}||j �qS r! )rr )ri rM r� r! r! r$ �
<dictcomp>� s �z)fixupstate.chunkstats.<locals>.<dictcomp>)r r� r� r5 r! r! r$ rr � s
�zfixupstate.chunkstatsc C sh | j �d��F}| �� | �|� | j d �� | jv r<| �� | �� W d � n1 sX0 Y | jS )z6commit changes. update self.finalnode, self.replacemapr � .N) r2 Z transaction� _commitstack�_movebookmarksr8 r� �_moveworkingdirectoryparent�_cleanupoldcommitsr� )r1 �trr! r! r$ �commit� s
&zfixupstate.commitc s� | j }| j}|jrPt�|�D ]0\}}|d r |�td�||d |d f � q n:|js�|�� � � fdd�dD �\}}|�td�||f � dS ) z+print things like '1 of 2 chunk(s) applied'r s %s: %d of %d chunk(s) applied
r@ c 3 s$ | ] � t � fd d��D ��V qdS )c 3 s | ]}|� V qd S r r! �ri �s�r� r! r$ r� r4 z7fixupstate.printchunkstats.<locals>.<genexpr>.<genexpr>N)�sum)ri �Zstatsr� r$ r� r4 z-fixupstate.printchunkstats.<locals>.<genexpr>r� s %d of %d chunk(s) applied
N) rl rr r- r r� r� r r. �values)r1 rl rr rM �statZapplied�totalr! r� r$ �printchunkstats� s ��zfixupstate.printchunkstatsc C s d}d}| j D ]�}| �|�}|s*|s*|}q|�� o>| �|||�}| jrb|rbd| j|�� < td�}nt| j|||d�}| j | }|}|�� | j|�� < |r�|r�td�}ntd�}|t
|�| � |�f }ntd�| � |� }| j j
r|r| j �td�| � |�|f � q|�o|�� | _dS )z�make new commits. update self.finalnode, self.replacemap.
it is splitted from "commit" to avoid too much indentation.
Ns became empty and was dropped)rI s& %d file(s) changed, became empty as %ss %d file(s) changed, became %ss became %ss %s: %s
)rL �_getnewfilecontentsr] �_willbecomenoop�skip_empty_successorr� r8 r �
_commitsingler2 rA �_ctx2strrl r- r� r� )r1 Z
lastcommittedZnextp1rF rW Zwillbecomenoop�msgZnodestrr! r! r$ r�
s:
�
� zfixupstate._commitstackc C s8 | j jr d|�� |�� f S d|�� t|�� �f S d S )Ns %d:%s)rl r, r� r r r8 )r1 rF r! r! r$ r� 5 s zfixupstate._ctx2strc C s\ i }| j D ]L}| j| }||vr"q
|| }|�� }| j| �|�}||kr
|||�� < q
|S )z�(ctx) -> {path: str}
fetch file contents from filefixupstates.
return the working copy overrides - files different from ctx.
)r� rP r6 r� r� rM )r1 rF r= rM r� rR rY Z
newcontentr! r! r$ r� ; s
z fixupstate._getnewfilecontentsc s� � j }� fdd�t�|j�D �}g }|D ]j\}}|rh|�||f� � jjr�� j�td�|t |�f � q(|�|d f� � jjr(� j�td�| � q(|j�
|||� d S )Nc s( g | ] \}}|� j v r|� j | f�qS r! )r� )ri r& �hshr5 r! r$ rk O s
�z-fixupstate._movebookmarks.<locals>.<listcomp>s moving bookmark %s to %s
s deleting bookmark %s
) r2 r r� Z
_bookmarksr; rl r- r� r r Z applychanges)r1 r� r2 Z
needupdateZchangesr& r� r! r5 r$ r� M s
� �zfixupstate._movebookmarksc s� | j s4| j�d| j�� �}| j|�� }|�� | _ n | j| j }| jj�dd� }|}t� �d�r~�j
j � � �fdd�}|�j
_ zJ�� � �( ��
|�� |�� | j� W d � n1 s�0 Y W |� n|� 0 d S )Ns max(::. - %ln)c S s dS )Nr r! r! r! r! r$ r� n r4 z8fixupstate._moveworkingdirectoryparent.<locals>.<lambda>�_fsmonitorstatec s � �j _d S r )r� �
invalidater! �Zbak�dirstater! r$ �restores s z7fixupstate._moveworkingdirectoryparent.<locals>.restore)r� r2 �revsr� �keys�firstr8 r� r Z safehasattrr� r� Z parentchangeZrebuildZmanifestr� )r1 r� rF Znoopr� r! r� r$ r� b s
8z&fixupstate._moveworkingdirectoryparentc C s� |s$|� � }t|�dkr dS |d }|�� |�� kr8dS |�� �d�rJdS t|�� ��t| ��sddS t� | �D ]V\}}||vs�||vr� dS || }|| }|�
� |�
� kr� dS |� � |krn dS qndS )z�({path: content}, ctx, ctx) -> bool. test if a commit will be noop
if it will become an empty commit (does not change anything, after the
memworkingcopy overrides), return True. otherwise return False.
r@ Fr s closeT) rB rA r` ra r� r9 r] �issubsetr r� �flagsr6 )rW rF rQ rB rM rY rR Zpfctxr! r! r$ r� } s* zfixupstate._willbecomenoopc C sx |o|| j jf}|�� }| jr8| j�dd�r8|�� |d< t�|� � |� � dd� | j
� � D ��}t |||||d�}|�
� S )z�(ctx, {path: content}, node) -> node. make a single commit
the commit is a clone from ctx, with a (optionally) different p1, and
different file contents replaced by memworkingcopy.
r r s
absorb_sourcec S s i | ]\}}||g�qS r! r! )ri ZoldnodeZnewnoder! r! r$ r� � s �z,fixupstate._commitsingle.<locals>.<dictcomp>)ra rd )r2 r7 ra � _useobsoleterl Z
configboolr r Zupdate_hash_refsrb r� �itemsrf r� )r1 rW rF rI rB ra rd Zmctxr! r! r$ r� � s ��
�zfixupstate._commitsinglec C s t �| jt j�S )z
() -> bool)r
� isenabledr2 Zcreatemarkersoptr5 r! r! r$ r � s zfixupstate._useobsoletec C s2 dd� t �| j�D �}|r.tj| j|ddd� d S )Nc S s$ i | ] \}}||d ur |gng �qS r r! )ri �k�vr! r! r$ r� � s �z1fixupstate._cleanupoldcommits.<locals>.<dictcomp>r T)Z operationZfixphase)r r� r� r Z cleanupnodesr2 )r1 Z replacementsr! r! r$ r� � s
�
�z fixupstate._cleanupoldcommitsc C s t �| jd�S )Nr )r r� rl r5 r! r! r$ r� � s z fixupstate.skip_empty_successor)NN)NN)N)N)r( r) r* r+ r3 r� r� �propertyrr r� r� r� r� r� r� r� r� r� r� r Z
propertycacher r� r� r! r! r! r$ r� � s*
*
+
r� c C s� t | �tjtjfvrdS | j�� }| jt| j � d }g | _ | _
t � � }| �
|� t�|�� �}|| j }dd� |dd� D �}||||ffS )zA(crecord.uihunk or patch.recordhunk) -> (path, (a1, a2, [bline])))NNr@ c S s" g | ]}|� d �s|dd� �qS )r� r@ N)r� )ri r� r! r! r$ rk � r4 z _parsechunk.<locals>.<listcomp>N)�typer Zuihunkr Z
recordhunk�header�filenameZfromlinerA �beforeZafterr Zstringior� r ro �getvalueZremoved)ZhunkrM r� �bufZ
patchlinesr� r� r! r! r$ � _parsechunk� s
r c C s� i }t dd� �}tt|�D ] \}}|r|s,q|| �|� qt�|�D ]^\}}|| vsF|s\qF|jdd� t�| | � � �}|D ]\}} }
|
||| �< q~d�
|�||< qFt || �S )z�(ctx, [crecord.uihunk]) -> memctx
return a memctx with some [1] patches (chunks) applied to ctx.
[1]: modifications are handled. renames, mode changes, etc. are ignored.
c S s g S r r! r! r! r! r$ r� � r4 z$overlaydiffcontext.<locals>.<lambda>T)rC r4 ) r� r� r r; r r� �sortr ro r6 r� rf ) rF r� rW ZpatchmaprM �infoZpatches�linesr� r� r� r! r! r$ �overlaydiffcontext� s r c C sj |du rf| � dd�}|d }t|�� �dkr:t�td���t||�}|rft|�|krf| �td�| � |sxt�td���|du r�|d }|du r�d }|du r�i }t|| |d
�}t �
|||�} |� d ��rt �
||d �� |�� | �}
t �|
�} t�| | | �d
} t|d | �}d}
|� d��s*|� d��s6| �d|�}
|�|| |
� |
du�r�|
�� |
�ddt|j�� |
jdd� t|�D ]n}||jv�r��q~|
�� |
j|d� |
jdd� |
jdd|�� dd� |� � � � d
}|
jdd|d d� �q~|
� � |� d ��sf|� d��s4|j�r4| j d dd ��r4t� td ���|�!� |�"� �rP|�#� n| j$�sf| �td!�� |S )"z�pick fixup chunks from targetctx, apply them to stack.
if targetctx is None, the working copy context will be used.
if stack is None, the current draft stack will be used.
return fixupstate.
Nr r r� r@ s cannot absorb into a merges7 absorb: only the recent %d changesets will be analysed
s no mutable changeset to changer! r� � interactiverH r s
print_changess
apply_changess counts
%d changesets affected
s summaryr� )rF s changesetr� r� r r� s
descfirstliner� r � dry_runs# apply changes (y/N)? $$ &Yes $$ &Nor s absorb cancelled
s nothing applied
)%Z configintrA rB r
r� r rG �warnr� r r� r� r �diffr8 Z
parsepatchr Z recordfilterr � formatterr� r� r� rv r6 rJ r r rb �
splitlines�endZ promptchoiceZ
CanceledErrorr� r� r� r. )rl r2 rL r� �patsrm rE rD r� Zmatcherr Z
origchunksr� r~ rF Z
descfirstliner! r! r$ �absorb� s�
���
� �
����
r � as
apply-changess0 apply changes without prompting for confirmation� ps
print-changess; always print which changesets are modified by which changes� ir s* interactively select which chunks to apply� es
edit-linessG edit what lines belong to which changesets before commit (EXPERIMENTAL)s hg absorb [OPTION] [FILE]...)Z helpcategoryZ helpbasicc O s� t �|�}|�� �� |�� �j |d s0t�|� t| |||d�}tdd� |j� � D ��dkrxW d � W d � dS W d � n1 s�0 Y W d � n1 s�0 Y dS )a� incorporate corrections into the stack of draft changesets
absorb analyzes each change in your working directory and attempts to
amend the changed lines into the changesets in your stack that first
introduced those lines.
If absorb cannot find an unambiguous changeset to amend for a change,
that change will be left in the working directory, untouched. They can be
observed by :hg:`status` or :hg:`diff` afterwards. In other words,
absorb does not write to the working directory.
Changesets outside the revset `::. and not public() and not merge()` will
not be changed.
Changesets that become empty after applying the changes will be deleted.
By default, absorb will show what it plans to do and prompt for
confirmation. If you are confident that the changes will be absorbed
to the correct place, run :hg:`absorb -a` to apply the changes
immediately.
Returns 0 on success, 1 if all chunks were ignored and nothing amended.
r )r rm c s s | ]}|d V qdS )r Nr! r� r! r! r$ r� � r4 z absorbcmd.<locals>.<genexpr>r Nr@ )
r Z byteskwargsZwlock�lockr Zcheckunfinishedr r� rr r� )rl r2 r rm r� r! r! r$ � absorbcmdG s >
r )N)N)NNN)NNNN)5r+ Z
__future__r � collectionsZmercurial.i18nr Zmercurial.noder r Z mercurialr r r r r
r r r
r r r r r r r Zmercurial.utilsr Z
testedwithZcmdtableZcommandZ configtableZ
configitemZ
colortabler� �objectr r/ r? rG rT Z filestorerU rf rg r� r r r Z
dryrunoptsZ templateoptsZwalkoptsZCATEGORY_COMMITTINGr r! r! r! r$ �<module> s� D
�
R
| 6
O������ � � � �&