https://t.me/RX1948
Server : Apache
System : Linux iad1-shared-b8-43 6.6.49-grsec-jammy+ #10 SMP Thu Sep 12 23:23:08 UTC 2024 x86_64
User : dh_edsupp ( 6597262)
PHP Version : 8.2.26
Disable Function : NONE
Directory :  /lib/python3/dist-packages/mercurial/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Current File : //lib/python3/dist-packages/mercurial/__pycache__/context.cpython-310.pyc
o

�]Lb��@s�ddlmZddlZddlZddlZddlZddlmZddlm	Z	m
Z
mZddlm
Z
ddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"ddl#m$Z$m%Z%dd	l&m'Z'e"j(Z(Gd
d�de)�Z*Gdd
�d
e*�Z+Gdd�de)�Z,Gdd�de,�Z-Gdd�de*�Z.Gdd�de.�Z/Gdd�de,�Z0Gdd�de0�Z1Gdd�de.�Z2Gdd�de0�Z3Gdd�de/�Z4d d!�Z5d"d#�Z6d$d%�Z7Gd&d'�d'e.�Z8Gd(d)�d)e0�Z9Gd*d+�d+e.�Z:Gd,d-�d-e)�Z;dS).�)�absolute_importN�)�_)�hex�nullrev�short)�getattr)�dagop�encoding�error�fileset�match�
mergestate�metadata�obsolete�patch�pathutil�phases�pycompat�repoview�scmutil�sparse�subrepo�subrepoutil�util)�dateutil�
stringutil)�	timestampc@s�eZdZdZdd�Zdd�Ze�e�Zdd�Z	dd	�Z
d
d�Zdd
�Zdd�Z
dd�Zdd�Zdd�Zdd�Zedd��Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zdfd-d.�Zd/d0�Zd1d2�Zd3d4�Z d5d6�Z!d7d8�Z"d9d:�Z#d;d<�Z$d=d>�Z%d?d@�Z&dAdB�Z'dCdD�Z(dEdF�Z)dGdH�Z*edIdJ��Z+dKdL�Z,dMdN�Z-dgdPdQ�Z.dRdS�Z/dTdU�Z0	,	,	,	V	W	,	,dhdXdY�Z1	,	,	,	,	,	,	,	,	,didZd[�Z2d\d]�Z3d^d_�Z4	,	,	W	W	W	Wdjd`da�Z5dkdbdc�Z6ddde�Z7d,S)l�basectxaIA basectx object represents the common logic for its children:
    changectx: read-only context that is already present in the repo,
    workingctx: a context that represents the working directory and can
                be committed,
    memctx: a context that represents changes in-memory and can also
            be committed.cCs
||_dS�N��_repo��self�repo�r%�3/usr/lib/python3/dist-packages/mercurial/context.py�__init__?�
zbasectx.__init__cC�t|���Sr)r�node�r#r%r%r&�	__bytes__B�zbasectx.__bytes__cC�dt|�jt|�fS�Nz<%s %s>��type�__name__�strr+r%r%r&�__repr__G�zbasectx.__repr__cCs4zt|�t|�ko|j|jkWStyYdSw�NF)r1�_rev�AttributeError�r#�otherr%r%r&�__eq__Js
�zbasectx.__eq__cC�
||kSrr%r9r%r%r&�__ne__Pr(zbasectx.__ne__cC�
||jvSr��	_manifest�r#�keyr%r%r&�__contains__Sr(zbasectx.__contains__cC�
|�|�Sr)�filectxrAr%r%r&�__getitem__Vr(zbasectx.__getitem__cC�
t|j�Sr)�iterr@r+r%r%r&�__iter__Yr(zbasectx.__iter__cC�|��S)z�Builds a manifest that includes the given status results, if this is
        a working copy context. For non-working copy contexts, it just returns
        the normal manifest.)�manifest)r#�statusr%r%r&�_buildstatusmanifest\szbasectx._buildstatusmanifestcCs|S)zfThis internal method provides a way for child objects to override the
        match operator.
        r%)r#r:r
r%r%r&�_matchstatusbszbasectx._matchstatusc	s�d}|��dur|��|��kr|�|�}|�|��|dur#|�|�}gg}}	g}
g}|j|j|j}}
}t|���j|�|d�}t�|�D]Z\}}|�vrQqH|dur[|�	|�qH|\\}}\}}|durm|	�	|�qH|durw|
�	|�qH||kr�|�	|�qH||j
jjvr�|�	|�qH||�
||�r�|�	|�qH|�	|�qH|
r‡�fdd�|
D�}
��fdd�|D�}�fdd�|
D�}
t�||	|
||
||�S)z.build a status with respect to another contextN)r
�cleanc�$g|]}|�vr�r�|�r|�qSr%r%��.0�fn�r
�mf1r%r&�
<listcomp>��
�z(basectx._buildstatus.<locals>.<listcomp>crPr%r%rQrTr%r&rV�rWcsg|]}|�vr|�qSr%r%rQ)�
deletedsetr%r&rV��)�revrM�deleted�unknown�ignored�set�diffr�	iteritems�appendr!�
nodeconstants�wdirfilenodeids�cmprrL)r#r:�sr
�listignored�	listclean�listunknown�mf2�modified�added�removedrOr[r\r]�drS�value�node1�flag1�node2�flag2r%)rXr
rUr&�_buildstatushsR





���zbasectx._buildstatuscCst�||jj�Sr)r�stater!�uir+r%r%r&�substate��zbasectx.substatecCs|j|dS�Nr)rv�r#�subpathr%r%r&�subrev��zbasectx.subrevcC�|jSr)r7r+r%r%r&rZ��zbasectx.revcCr}r)�_noder+r%r%r&r*�r~zbasectx.nodecCr)r)rr*r+r%r%r&r�r-zbasectx.hexcCr}rr?r+r%r%r&rK�r~zbasectx.manifestcCr}r)�_manifestctxr+r%r%r&�manifestctx�r~zbasectx.manifestctxcCr}rr r+r%r%r&r$�r~zbasectx.repocCstj|��Sr)r�
phasenames�phaser+r%r%r&�phasestr�r|zbasectx.phasestrcCs|��tjkSr)r�r�publicr+r%r%r&�mutable�r|zbasectx.mutableNcCstj||||d�S)N)�badfn)rr
)r#�cwd�exprr�r%r%r&�matchfileset��zbasectx.matchfilesetcC�|��t�|jd�vS)z!True if the changeset is obsoletesobsolete�rZ�obsmod�getrevsr!r+r%r%r&r��zbasectx.obsoletecCr�)z True if the changeset is extinctsextinctr�r+r%r%r&�extinct�r�zbasectx.extinctcCr�)z:True if the changeset is not obsolete, but its ancestor is�orphanr�r+r%r%r&�orphan�r�zbasectx.orphancCr�)z�True if the changeset tries to be a successor of a public changeset

        Only non-public and non-obsolete changesets may be phase-divergent.
        sphasedivergentr�r+r%r%r&�phasedivergent��zbasectx.phasedivergentcCr�)z�Is a successor of a changeset with multiple possible successor sets

        Only non-public and non-obsolete changesets may be content-divergent.
        scontentdivergentr�r+r%r%r&�contentdivergent�r�zbasectx.contentdivergentcCs|��p|��p|��S)zTTrue if the changeset is either orphan, phase-divergent or
        content-divergent)r�r�r�r+r%r%r&�
isunstable�szbasectx.isunstablecCs>g}|��r|�d�|��r|�d�|��r|�d�|S)z�return the list of instabilities affecting this changeset.

        Instabilities are returned as strings. possible values are:
        - orphan,
        - phase-divergent,
        - content-divergent.
        r�sphase-divergentscontent-divergent)r�rar�r�)r#�
instabilitiesr%r%r&r��s


zbasectx.instabilitiescCr})z)return contexts for each parent changeset��_parentsr+r%r%r&�parents��zbasectx.parentscC�
|jdS�Nrr�r+r%r%r&�p1r(z
basectx.p1cCs$|j}t|�dkr
|dS|jtS)N�r)r��lenr!r)r#r�r%r%r&�p2s
z
basectx.p2c	Cs�d|jvr z|j�|�WStyt�|jpd|td���wd|jvs+||��vr;||j	vr;|j	||j	�
|�fS|jj}z||j
j�|�\}}W||fStybt�|jp\d|td���w)Nr@sNonesnot found in manifest�_manifestdelta)�__dict__r@�find�KeyErrorr�ManifestLookupErrorrr�filesr��flagsr!�manifestlog�
_changesetrK)r#�path�mflr*�flagr%r%r&�	_fileinfo	s,
��

����zbasectx._fileinfocCs|�|�dSr�)r��r#r�r%r%r&�filenode!r|zbasectx.filenodecCs(z|�|�dWStjyYdSw)Nr�)r�r�LookupErrorr�r%r%r&r�$s
�z
basectx.flagscCs
t�|�Sr)r�computechangesetcopiesr+r%r%r&�_copies*�
zbasectx._copiescCr�r��r�r+r%r%r&�p1copies.r(zbasectx.p1copiescCr�rxr�r+r%r%r&�p2copies1r(zbasectx.p2copiesTcCstj|||d�S)z>return a subrepo for the stored revision of path, never wdir())�allowcreate�r)r#r�r�r%r%r&�sub4rwzbasectx.subcCst�|||�Sr)r�nullsubrepo)r#r��pctxr%r%r&�nullsub8r|zbasectx.nullsubcCstj||dd�S)z]return a subrepo for the stored revision, or wdir if this is a wdir
        context.
        T)�	allowwdirr�r�r%r%r&�
workingsub;�zbasectx.workingsub�globFc	Cs4|j}|s	|��}tj|j||||||j|||d�
S)N)�auditor�ctx�listsubreposr�)r!�getcwd�matchmodr
�root�nofsauditor)	r#�pats�include�exclude�defaultr�r�r��rr%r%r&r
As
�z
basectx.matchc


CsD|dur|��}|dur|j|}tj|j||||||||||	d�S)z;Returns a diff generator for the given contexts and matcherN)r
�changes�opts�
losedatafn�pathfn�copy�copysourcematch�
hunksfilterfn)r�r!rr_)
r#�ctx2r
r�r�r�r�r�r�r�r%r%r&r_[s"

�zbasectx.diffcC�
|j��Sr)r@�dirsr+r%r%r&r�zr(zbasectx.dirscCs|j�|�Sr)r@�hasdir)r#�dirr%r%r&r�}r-zbasectx.hasdirc	s||}|j|}d}	t|t�st|t�rd}	||}}|j�|�}|�||�}t�ggggggg�}
|�||
||||�}
|	rLt�|
j|
j	|
j
ggg|
j�}
|r�t�||�D]D\�}z|�
��}Wntyjd}Ynwt��|�}
|j||
|||dd�}dD]}t|
|�t||�}}|��fdd�|D��q~qT|
j��|
j
��|
j	��|
j��|
j��|
j��|
j��|
S)a�return status of files between two nodes or node and working
        directory.

        If other is None, compare this node with working directory.

        ctx1.status(ctx2) returns the status of change from ctx1 to ctx2

        Returns a mercurial.scmutils.status object.

        Data can be accessed using either tuple notation:

            (modified, added, removed, deleted, unknown, ignored, clean)

        or direct attribute access:

            s.modified, s.added, ...
        FTN)r
r]rOr\r�)rjrkrlr[r\r]rOc3s�|]	}d�|fVqdS)s%s/%sNr%�rR�f�rzr%r&�	<genexpr>�s�z!basectx.status.<locals>.<genexpr>)r!�
isinstance�	changectx�narrowmatchrNrrLrsrjrlrkrO�itersubreposr{r�r��
subdirmatcherr�extend�sortr[r\r])r#r:r
rfrgrhr��ctx1r��reversedr�r��rev2�submatchre�k�rfiles�sfilesr%r�r&rL�sX

����	�






zbasectx.statuscCstd|j��)z)Get a mergestate object for this context.z"%s does not implement mergestate())�NotImplementedError�	__class__�r#rOr%r%r&r�s�zbasectx.mergestatecCs6t|���dkp|��|����kp|��p|��Srx)r�r��branchr��closesbranchr�r+r%r%r&�isempty�s���zbasectx.isemptyr�T�NNNr�FNN)	NNNNNNNNN)NNFFFF�F)8r2�
__module__�__qualname__�__doc__r'r,r
�	strmethod�__str__r4r;r=rCrFrIrMrNrs�
propertycachervr{rZr*rrKr�r$r�r�r�rr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r
r_r�r�rLrr�r%r%r%r&r7s�
B




�
�
�
ercsVeZdZdZdK�fdd�	Zdd�Zdd�ZeZed	d
��Z	edd��Z
ed
d��Zedd��Z
edd��Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Ze�fd#d$��Zd%d&�Zd'd(�Zd)d*�Zd+d,�Zd-d.�Zd/d0�Zd1d2�Zd3d4�Zd5d6�Z d7d8�Z!d9d:�Z"d;d<�Z#d=d>�Z$dLd@dA�Z%dMdCdD�Z&dEdF�Z'dGdH�Z(dIdJ�Z)�Z*S)Nr�z�A changecontext object makes access to data related to a particular
    changeset convenient. It represents a read-only context already present in
    the repo.Tcs&tt|��|�||_||_||_dSr)�superr�r'r7r�_maybe_filtered)r#r$rZr*�maybe_filtered�r�r%r&r'�s
zchangectx.__init__cCs(zt|j�WStyt|�YSwr)�hashr7r8�idr+r%r%r&�__hash__s
�zchangectx.__hash__cCs
|jtkSr)r7rr+r%r%r&�__nonzero__r(zchangectx.__nonzero__cCs(|jr|j}n|j��}|j�|���Sr)r�r!�
unfiltered�	changelog�changelogrevisionrZr"r%r%r&r�s
zchangectx._changesetcCr�r)r��readr+r%r%r&r@r�zchangectx._manifestcCs|jj|jjSr)r!r�r�rKr+r%r%r&r�rwzchangectx._manifestctxcCr�r)r��	readdeltar+r%r%r&r� r�zchangectx._manifestdeltacCsz|j}|jr
|j}n|��j}|�|j�\}}|tkr't|||�|�dd�gSt|||�|�dd�t|||�|�dd�gS)NF�r�)	r!r�rr�
parentrevsr7rr�r*)r#r$�clr�r�r%r%r&r�$s
�zchangectx._parentscCs"|j}|j|j|j|j|j|jfSr)r�rK�user�dater��description�extra�r#�cr%r%r&�	changeset4s�zchangectx.changesetcC�|jjSr)r�rKr+r%r%r&�manifestnode?�zchangectx.manifestnodecCrr)r�r
r+r%r%r&r
Brzchangectx.usercCrr)r�rr+r%r%r&rErzchangectx.datecCrr)r�r�r+r%r%r&r�Hrzchangectx.filescCs0t|���}|�|���|�|���t|�Sr)r^r��difference_update�
filesadded�filesremoved�sorted)r#rjr%r%r&�
filesmodifiedKszchangectx.filesmodifiedcC�j|jj}d}|jjdkrd}n|jj�dd�}|dkrd}n|dkr$d}|dur3|r1t�|�}|Sg}|S�NTschangeset-sidedataF�experimentalscopies.read-fromschangeset-onlys
compatibility)r�rr!�filecopiesmoderu�configr�computechangesetfilesadded)r#r�compute_on_none�sourcer%r%r&rQ�
�zchangectx.filesaddedcCrr)r�rr!rrur r�computechangesetfilesremoved)r#rr"r#r%r%r&rdr$zchangectx.filesremovedcs�|jj}|jj}d}|jjdkrd}n|jj�dd�}|dkr"d}n|dkr*d}}|dur?|r9tt|�j	\}}n|dur?i}|durEi}||fSr)
r�r�r�r!rrur r�r�r�)r#r�r�r"r#rr%r&r�ws$zchangectx._copiescCrr)r�rr+r%r%r&r�rzchangectx.descriptioncCst�|jj�d��S�N�branch)r
�tolocalr�r�getr+r%r%r&r���zchangectx.branchcCsd|jjvS�Nsclose�r�rr+r%r%r&r��r-zchangectx.closesbranchcCr)z#Return a dict of extra information.r,r+r%r%r&r��zchangectx.extracC�|j�|j�S)zReturn a list of byte tag names)r!�nodetagsrr+r%r%r&�tags��zchangectx.tagscCr.)z%Return a list of byte bookmark names.)r!�
nodebookmarksrr+r%r%r&�	bookmarks�r1zchangectx.bookmarkscCs*|j}|jr
|j}n|��j}|�|j�Sr)r!r�rr�	fast_rankr7)r#r$rr%r%r&r4�s

zchangectx.fast_rankcCs|jj�|j|j�Sr)r!�_phasecacher�r7r+r%r%r&r��r*zchangectx.phasecCs|jt�|jd�vS)Nsvisible)r7r�
filterrevsr!r+r%r%r&�hidden�r*zchangectx.hiddencC�dSr6r%r+r%r%r&�
isinmemory��zchangectx.isinmemorycs"�jj��j�}�fdd�|D�S)z�return list of changectx contexts for each child changeset.

        This returns only the immediate child changesets. Use descendants() to
        recursively walk children.
        c�g|]}�j|�qSr%r �rR�xr+r%r&rV��z&changectx.children.<locals>.<listcomp>)r!r�childrenrrr%r+r&r?�szchangectx.childrenccs*�|jj�|jg�D]}|j|Vq
dSr)r!r�	ancestorsr7)r#�ar%r%r&r@�s��zchangectx.ancestorsccs*�|jj�|jg�D]}|j|Vq
dS)zrRecursively yield all children of the changeset.

        For just the immediate children, use children()
        N)r!r�descendantsr7)r#rmr%r%r&rB�s��zchangectx.descendantsNcCs&|dur	|�|�}t|j||||d�S)z&get a file context from this changesetN)�fileidr��filelog)r�rEr!)r#r�rCrDr%r%r&rE�s

�zchangectx.filectxFc	s
|j}|dur
|jdj}|jj�|j|�}|s|jjj�nbt|�dkr)|d�nW|jj�	dd�D] }z	t
�|j|�}Wn
tj
yFYq1w|����|vrQn
q1|jj�|j|��|r�|jj�td�t��t|j�t|�fd��fdd	�t|�D���|j�S)
z�return the "best" ancestor context of self and c2

        If there are multiple candidates, it will show a message and check
        merge.preferancestor configuration before falling back to the
        revlog ancestor.Nrrsmergespreferancestors(note: using %s as ancestor of %s and %s
r�c3s(�|]}|�krtd�t|�VqdS)s:      alternatively, use --config merge.preferancestor=%s
N)rr�rR�n��ancr%r&r��s�����z%changectx.ancestor.<locals>.<genexpr>)rr�r!r�commonancestorsheadsrb�nullidr�ru�
configlistr�	revsymbolr�RepoLookupErrorr*�ancestorrLrr�joinr)r#�c2�warn�n2�cahsr�r�r%rGr&rN�s<
������
zchangectx.ancestorcCs|jj�|j|j�S)z.True if this changeset is an ancestor of other)r!r�
isancestorrevr7r9r%r%r&�isancestorof
szchangectx.isancestorofcs.��fdd�}t��j���|�}�j�|�S)�Generates matching file names.cs4t�fdd��jD��rdS���td���dS)Nc3s&�|]}�|kp��|d�VqdS)�/N)�
startswith)rRre�rSr%r&r�s�$z.changectx.walk.<locals>.bad.<locals>.<genexpr>sno such file in rev %s)�anyrv�badr)rS�msg�r
r#rYr&r[szchangectx.walk.<locals>.bad)r��badmatchr!r�r@�walk)r#r
r[�mr%r]r&r_szchangectx.walkcCrDr)r_�r#r
r%r%r&�matchesr(zchangectx.matchesr��NNr�)+r2r�r�r�r'rr�__bool__r�r�r@�propertyr�r�r�rrr
rr�rrrr�rr�r�rr0r3r4r�r7r9r?r@rBrErNrUr_rb�
__classcell__r%r%rr&r��sX




"	

-r�c@s�eZdZdZedd��Zedd��Zedd��Zedd	��Zed
d��Z	dd
�Z
e
Zdd�Ze
�e�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zedd��Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Zd(d)�Zd*d+�Zd,d-�Zd.d/�Zd0d1�Z d2d3�Z!d4d5�Z"d6d7�Z#d8d9�Z$d:d;�Z%d<d=�Z&d>d?�Z'd@dA�Z(dBdC�Z)dDdE�Z*dFdG�Z+dHdI�Z,dJdK�Z-dLdM�Z.dNdO�Z/dPdQ�Z0dRdS�Z1dTZ2dUdV�Z3dpdXdY�Z4dZd[�Z5d\d]�Z6dqd^d_�Z7d`da�Z8dbdc�Z9ddde�Z:dfdg�Z;dhdi�Z<drdjdk�Z=dsdldm�Z>dndo�Z?dWS)t�basefilectxaPA filecontext object represents the common logic for its children:
    filectx: read-only access to a filerevision that is already present
             in the repo,
    workingfilectx: a filecontext that represents files from the working
                    directory,
    memfilectx: a filecontext that represents files in-memory,
    cCr.r)r!�file�_pathr+r%r%r&�_filelog)r1zbasefilectx._filelogcCs8d|jvr
|j��Sd|jvr|�|j�S|j�|j�S)N�
_changectx�_descendantrev)r�rkrZ�_adjustlinkrevrlrj�linkrev�_filerevr+r%r%r&�	_changeid-s



zbasefilectx._changeidcCs&d|jvr|j�|j�S|j�|j�S)N�_fileid)r�rj�lookuprqrkr�rir+r%r%r&�	_filenode8s
zbasefilectx._filenodecCr.r)rjrZrsr+r%r%r&ro?r1zbasefilectx._filerevcCr}r�rir+r%r%r&�	_repopathCr�zbasefilectx._repopathcCs$z|jWdStjyYdSw�NTF)rsrr�r+r%r%r&rGs�zbasefilectx.__nonzero__cCs6z
d|��|jfWStjyd|��YSw)Ns%s@%ss%s@???)r�rkrr�r+r%r%r&r,Qs
�zbasefilectx.__bytes__cCr.r/r0r+r%r%r&r4Yr5zbasefilectx.__repr__cCs.z	t|j|jf�WStyt|�YSwr)rrirsr8rr+r%r%r&r\s
�zbasefilectx.__hash__cCs@zt|�t|�ko|j|jko|j|jkWStyYdSwr6)r1rirsr8r9r%r%r&r;bs
�
��zbasefilectx.__eq__cCr<rr%r9r%r%r&r=lr(zbasefilectx.__ne__cCr}r)ror+r%r%r&�filerevor~zbasefilectx.filerevcCr}r)rsr+r%r%r&r�rr~zbasefilectx.filenodecCr.r)rkr�rir+r%r%r&�_flagsur1zbasefilectx._flagscCr}r)rxr+r%r%r&r�yr~zbasefilectx.flagscCr}r)rjr+r%r%r&rD|r~zbasefilectx.filelogcCr}r)rpr+r%r%r&rZr~zbasefilectx.revcCr.r)rjrnror+r%r%r&rn�r|zbasefilectx.linkrevcCr�r)rkr*r+r%r%r&r*�r(zbasefilectx.nodecCr�r)rkrr+r%r%r&r�r(zbasefilectx.hexcCr�r)rkr
r+r%r%r&r
�r(zbasefilectx.usercCr�r)rkrr+r%r%r&r�r(zbasefilectx.datecCr�r)rkr�r+r%r%r&r��r(zbasefilectx.filescCr�r)rkrr+r%r%r&r�r(zbasefilectx.descriptioncCr�r)rkr�r+r%r%r&r��r(zbasefilectx.branchcCr�r)rkrr+r%r%r&r�r(zbasefilectx.extracCr�r)rkr�r+r%r%r&r��r(zbasefilectx.phasecCr�r)rkr�r+r%r%r&r��r(zbasefilectx.phasestrcCr�r)rkrr+r%r%r&r�r(zbasefilectx.obsoletecCr�r)rkr�r+r%r%r&r��r(zbasefilectx.instabilitiescCr�r)rkrKr+r%r%r&rK�r(zbasefilectx.manifestcCr}r)rkr+r%r%r&r��r~zbasefilectx.changectxcCr}r��_copiedr+r%r%r&�renamed�r~zbasefilectx.renamedcCs|jo|jdSr�ryr+r%r%r&�
copysource��zbasefilectx.copysourcecCr}rr r+r%r%r&r$�r~zbasefilectx.repocCr)r)r��datar+r%r%r&�size�r-zbasefilectx.sizecCr}rrtr+r%r%r&r��r~zbasefilectx.pathcCs&zt�|���WStyYdSwr6)r�binaryr~�IOErrorr+r%r%r&�isbinary�s
�zbasefilectx.isbinarycC�d|��vS)N�x�r�r+r%r%r&�isexec�r-zbasefilectx.isexeccCr��N�lr�r+r%r%r&�islink�r-zbasefilectx.islinkcCr8)z�whether this filectx represents a file not in self._changectx

        This is mainly for merge code to detect change/delete conflicts. This is
        expected to be True for all subclasses of basectx.Fr%r+r%r%r&�isabsent�szbasefilectx.isabsentFcCs�|jr|�|�S|jdurt�d��|jdur9|jjr%|j�|j|���S|�	�d|�	�kr9|j�|j|���S|�	�|�	�ksG|�
�dkrQ|j�|j|���SdS)�Vcompare with other file context

        returns True if different than fctx.
        Ns;filectx.cmp() must be reimplemented if not backed by revlog�r�T)�
_customcmprdrsr�ProgrammingErrorr!�_encodefilterpatsrjr~rr��r#�fctxr%r%r&rd�s

�
zbasefilectx.cmpNcCs
|j}|��j}|j}|��}||kr|St|dd�}d}	|dur0dd�|jd��D�}
d}n|g}
|durA|j|
||d�}}	||vr�|	durQ|j|
||d�}	|j}|j	}|	D])}
|durf|
|krfdS|�
|
�}||dvr�|||d���|�kr�|
SqY|S)	a|return the first ancestor of <srcrev> introducing <fnode>

        If the linkrev of the file revision does not point to an ancestor of
        srcrev, we'll walk down the ancestors until we find one introducing
        this file revision.

        :srcrev: the changeset revision we search ancestors from
        :inclusive: if true, the src revision will also be checked
        :stoprev: an optional revision to stop the walk at. If no introduction
                  of this file content could be found before this floor
                  revision, the function will returns "None" and stops its
                  iteration.
        �_ancestrycontextNcS�g|]}|���qSr%�rZ�rR�pr%r%r&rV�z.basefilectx._adjustlinkrev.<locals>.<listcomp>T��	inclusive�r)
r!rrr�rnrr�r@rsrir�readfastr))r#�srcrevr��stoprevr$rr��lkr�	memberanc�iteranc�revs�fnoder�rA�acr%r%r&rm�s8

�zbasefilectx._adjustlinkrevcCs0|��|krdS|j|d�}|durdS||kS)zBTrue if a filectx has been introduced after a given floor revisionT�r�NF)rn�	_introrev)r#�changelogrev�introrevr%r%r&�isintroducedafter'szbasefilectx.isintroducedaftercCrJ)areturn the rev of the changeset which introduced this file revision

        This method is different from linkrev because it take into account the
        changeset the filectx was created from. It ensures the returned
        revision is one of its ancestors. This prevents bugs from
        'linkrev-shadowing' when a file revision is used by multiple
        changesets.
        )r�r+r%r%r&r�0s	zbasefilectx.introrevcCsxd}t|�}d|vr|j}n	d|vr|j��}|dur#|j|d|d�Sd|vr8|j|j|d�}|dur6||_|S|��S)a?
        Same as `introrev` but, with an extra argument to limit changelog
        iteration range in some internal usecase.

        If `stoprev` is set, the `introrev` will not be searched past that
        `stoprev` revision and "None" might be returned. This is useful to
        limit the iteration range.
        NrprkT)r�r�rlr�)�varsrprkrZrmrlrn)r#r��toprev�attrsr�r%r%r&r�;s	
zbasefilectx._introrevcCs*|��}|��|kr|S|j|��|d�S)zzReturn filectx having identical contents, but pointing to the
        changeset revision where this filectx was introduced)�changeid)r�rZrEr�)r#r�r%r%r&�introfilectxXszbasefilectx.introfilectxcCslt|j|||d�}dt|�vsdt|�vr#|��|_t|dd�|_|Sdt|�vr4|j|_t|dd�|_|S)z@create parent filectx keeping ancestry info for _adjustlinkrev()�rCrDrprkr�Nrl)rEr!r�rZrlrr�)r#r�rCrDr�r%r%r&�_parentfilectx`s
�zbasefilectx._parentfilectxc	sx�j��j��j��j�}���fdd�|D�}���j�}|r3|�d|d|d�j�|d�f��fdd�|D�S)Ncs$g|]}|�jjjkr�|�f�qSr%�r!rbrJ)rRr*�ri�flr#r%r&rVts
�z'basefilectx.parents.<locals>.<listcomp>rrcs g|]\}}}��|||��qSr%)r�)rRr�r��lr+r%r&rV�� )rirjr�rsr{�insertr!rh)r#r��plr�r%r�r&r�ps�&	zbasefilectx.parentscCs|��dSr�)r�r+r%r%r&r��r-zbasefilectx.p1cCs2|��}t|�dkr|dSt|j|jd|jd�S)Nr�r���r�)r�r�rEr!rirj�r#r�r%r%r&r��szbasefilectx.p2cs�t��fdd�����fdd�}���}t|dd�durD�j��j}|��dur7|jdd�|�	�D�d	d
�}n
|j|��gd	d
�}||_
tj||||d�S)aDReturns a list of annotateline objects for each line in the file

        - line.fctx is the filectx of the node where that line was last changed
        - line.lineno is the line number at the first appearance in the managed
          file
        - line.text is the data on that line (including newline character)
        cs�j�|�Sr)r!rh)r=r+r%r&�<lambda>�sz&basefilectx.annotate.<locals>.<lambda>csJ�j���}�s�fdd�|D�}|D]}d|jvr"�|���|_q|S)Ncs g|]}|�����kr|�qSr%�r�r��r�r%r&rV�r�z9basefilectx.annotate.<locals>.parents.<locals>.<listcomp>rj)rpr�r�r�rj)r�r�r�)�follow�getlogr�r&r��s
�z%basefilectx.annotate.<locals>.parentsr�NcSr�r%r�r�r%r%r&rV�r�z(basefilectx.annotate.<locals>.<listcomp>Tr�)�skiprevs�diffopts)
r�lrucachefuncr�rr!rrrZr@r�r�r	�annotate)r#r�r�r�r��baserr�r%)r�r�r#r&r��s��zbasefilectx.annotateccsb�i}|}|r
d}nd}	|��d|�D]}|||��|��f<q|s&dS|�t|��}|Vq
rx)r�rnr��pop�max)r#�followfirst�visitr�cut�parentr%r%r&r@�s��zbasefilectx.ancestorscCs|j�|��|���S)z�Returns `data()` after running repository decoding filters.

        This is often equivalent to how the data would be expressed on disk.
        )r!�
wwritedatar�r~r+r%r%r&�decodeddata�r�zbasefilectx.decodeddata)FNr)FNNr�)@r2r�r�r�r�rjrprsrorurrdr,r
r�r�r4rr;r=rwr�rxr�rDrZrnr*rr
rr�rr�rr�r�rr�rKr�r{r|r$rr�r�r�r�r�r�rdrmr�r�r�r�r�r�r�r�r�r@r�r%r%r%r&rg s�









5	


2rgc@sleZdZdZ				ddd�Zedd��Zddd�Zd	d
�Zdd�Z	d
d�Z
dd�Zedd��Zdd�Z
dS)rEz^A filecontext object makes access to data related to a particular
    filerevision convenient.NcCsv||_||_|dus|dus|dusJd|||f��|dur"||_|dur)||_|dur0||_|dur9||_dSdS)z`changeid must be a revision number, if specified.
        fileid can be a file revision or node.Ns.bad args: changeid=%r, fileid=%r, changectx=%r)r!rirjrprkrq)r#r$r�r�rCrDr�r%r%r&r'�s$��
�zfilectx.__init__cCs4z|j|jWStjy|j��|jYSwr)r!rpr�FilteredRepoLookupErrorrr+r%r%r&rk�s
�zfilectx._changectxcCst|j|j||j|d�S)zMopens an arbitrary revision of the file without
        opening a new filelog)rCrDr��rEr!rirj)r#rCr�r%r%r&rEs�zfilectx.filectxcCr.r)rj�rawdatarsr+r%r%r&r�!r|zfilectx.rawdatacCr.)zlow-level revlog flags)rjr�ror+r%r%r&�rawflags$r1zfilectx.rawflagscCs\z|j�|j�WStjy-|jj�dd�dkrYdStjt	d�t
|j�t	d�d��w)Nscensorspolicysignorer�scensored node: %ss"set censor.policy to ignore errors)�hint)rjrrsr�CensoredNodeErrorr!rur �Abortrrr+r%r%r&r~(s��zfilectx.datacCr.r)rjrror+r%r%r&r3r|zfilectx.sizec	Csz|j�|j�}|sdS|��|��kr|S|��}|j}|j��D]}z
||�|�kr/WdSWq!t	j
y:Yq!w|S)a#check if file was actually renamed in this changeset revision

        If rename logged in file revision, we report copy for changeset only
        if file revisions linkrev points back to the changeset in question
        or both changeset parents contain different file revisions.
        N)rjr{rsrZrnr�rkr�r�rr�)r#r{�namer�r�r%r%r&rz6s 	��zfilectx._copiedcs �j��j�}�fdd�|D�S)Ncs"g|]
}t�j�j|�jd��qS�r�r�r<r+r%r&rVSs��z$filectx.children.<locals>.<listcomp>)rjr?rsrr%r+r&r?Ps
�zfilectx.children)NNNNr)r2r�r�r�r'r�rkrEr�r�r~rrzr?r%r%r%r&rE�s"
� 


rEcsFeZdZdZ						dD�fdd�	Zdd�Zdd	�Ze�e�Z	d
d�Z
e
Zedd
��Z
edd��Zedd��Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�ZeZeZeZd&d'�Zd(d)�Zd*d+�Zd,d-�Z d.d/�Z!d0d1�Z"d2d3�Z#d4d5�Z$d6d7�Z%d8d9�Z&d:d;�Z'd<d=�Z(d>d?�Z)dEdBdC�Z*�Z+S)F�committablectxz�A committablectx object provides common functionality for a context that
    wants the ability to commit, e.g. workingctx or memctx.r�Ncs�tt|��|�d|_d|_||_|rt�|�|_|r||_	|r#||_
i|_|r-|��|_|dur9t
�|�|jd<|j�d�sFd|jd<dSdS)Nr'sdefault)r�r�r'r7r�_textr�	parsedate�_date�_user�_status�_extrar�r
�	fromlocalr)�r#r$�textr
rrr�r�rr%r&r']s$

�zcommittablectx.__init__cCst|jd�dS)Nr�+)�bytesr�r+r%r%r&r,zr�zcommittablectx.__bytes__cCs|jjjdSr�r!rb�wdirhexr+r%r%r&r}r|zcommittablectx.hexcCr8�NTr%r+r%r%r&r�r:zcommittablectx.__nonzero__cCr�r)r!rLr+r%r%r&r��r�zcommittablectx._statuscCs|jj��Sr)r!ru�usernamer+r%r%r&r���zcommittablectx._usercCs(|jj}|�dd�}|durt��}|S)Nsdevelsdefault-date)r!ru�
configdater�makedate)r#rurr%r%r&r��s
zcommittablectx._datecC�dSrr%ryr%r%r&r{�r:zcommittablectx.subrevcCr�rr%r+r%r%r&r�r:zcommittablectx.manifestnodecCs|jp|jj��Sr)r�r!rur�r+r%r%r&r
�r�zcommittablectx.usercCr}r)r�r+r%r%r&r�r~zcommittablectx.datecCr}r)r�r+r%r%r&r�r~zcommittablectx.descriptioncCst|jj|jj|jj�Sr)rr�rjrkrlr+r%r%r&r��s�zcommittablectx.filescCrr)r�rjr+r%r%r&rj�rzcommittablectx.modifiedcCrr)r�rkr+r%r%r&rk�rzcommittablectx.addedcCrr)r�rlr+r%r%r&rl�rzcommittablectx.removedcCrr)r�r[r+r%r%r&r[�rzcommittablectx.deletedcCst�|jd�Sr&)r
r(r�r+r%r%r&r��r}zcommittablectx.branchcCs
d|jvSr+�r�r+r%r%r&r��r(zcommittablectx.closesbranchcCr}rr�r+r%r%r&r�r~zcommittablectx.extracCr8r6r%r+r%r%r&r9�r:zcommittablectx.isinmemorycC�gSrr%r+r%r%r&r0�r:zcommittablectx.tagscCs$g}|��D]	}|�|���q|Sr)r�r�r3)r#�br�r%r%r&r3�szcommittablectx.bookmarkscCs.t�|jj�}|��D]	}t||���}q|Sr)r�newcommitphaser!rur�r�r�)r#r�r�r%r%r&r��szcommittablectx.phasecCr8r6r%r+r%r%r&r7�r:zcommittablectx.hiddencCr�rr%r+r%r%r&r?�r:zcommittablectx.childrencCsPd|jvrz|j�|�WStyYdSwz|�|�WSty'YdSw)Nr@r�)r�r@r�r��	_flagfunc�OSErrorr�r%r%r&r��s
��zcommittablectx.flagscCs|jd�|�S)z1return the "best" ancestor context of self and c2r)r�rN)r#rPr%r%r&rN�rwzcommittablectx.ancestorccsD�|jD]}|Vq|jj�dd�|jD��D]}|j|VqdS)NcSr�r%r�r�r%r%r&rV�r�z,committablectx.ancestors.<locals>.<listcomp>)r�r!rr@)r#r�rAr%r%r&r@�s�
��zcommittablectx.ancestorscCr8)aQPerform post-commit cleanup necessary after committing this ctx

        Specifically, this updates backing stores this working context
        wraps to reflect the fact that the changes reflected by this
        workingctx have been committed.  For example, it marks
        modified and added files as normal in the dirstate.

        Nr%)r#r*r%r%r&�
markcommitted�szcommittablectx.markcommittedFTcCr8r6r%)r#�missing�merger�r%r%r&�dirty�r:zcommittablectx.dirty)r�NNNNN�FTT),r2r�r�r�r'r,rr
r�r�rrdr�r�r�r�r{rr
rrr�rjrkrlr[rrrr�r�rr9r0r3r�r7r?r�rNr@r�r�rfr%r%rr&r�Ys^�




r�cs:eZdZdZ	dA�fdd�	Zdd�Zdd	�Zd
d�Zedd
��Z	dBdd�Z
�fdd�Zdd�Zedd��Z
dd�ZdBdd�ZdCdd�ZdDdd�ZdDd d!�Zd"d#�Z				$			dEd%d&�Zd'd(�Zd)d*�Zd+d,�ZdFd-d.�Zed/d0��Zed1d2��Zd3d4�Z�fd5d6�Zd7d8�Zd9d:�Zd;d<�Zd=d>�Z dGd?d@�Z!�Z"S)H�
workingctxayA workingctx object makes access to data related to
    the current working directory convenient.
    date - any valid date string or (unixtime, offset), or None.
    user - username string, or None.
    extra - a dictionary of extra values, or None.
    changes - a list of file lists as returned by localrepo.status()
               or None to use the repository status.
    r�Nc	s^d}|rd|vrz|j��}Wntyt�td���wtt|�j|||||||d�dS)Nr'sbranch name not in UTF-8!�r�)	�dirstater��UnicodeDecodeErrorrr�rr�r�r'r�rr%r&r's�

�zworkingctx.__init__ccs*�|jj}|D]}|�|�jr|VqdSr�r!r��	get_entry�tracked)r#rmr�r%r%r&rIs���zworkingctx.__iter__cCs|jj�|�jSrr�rAr%r%r&rCr}zworkingctx.__contains__cCs
|jjjSrr�r+r%r%r&r"r(zworkingctx.hexcsH�jj��}|d�jjjkr|dd�}�j�����fdd�|D�S)Nrr�cs&g|]}t�j�j�|�|dd��qS)Fr
)r�r!rrZrE�r#�unfir%r&rV,s���z'workingctx._parents.<locals>.<listcomp>)r!r�r�rbrJrr�r%r�r&r�%s
�zworkingctx._parentscCs�|dur	|jjj}|jj}|���W|�||�}|j|}|r6|D]}||vr5|||vr5|�|||�q!||jjjkrXt|���	��D]\}}||vrW||vrW|�d|�qEWd�dSWd�dS1skwYdSr)
r!rbrJr��parentchange�
setparentsr�r�copies�items)r#�p1node�p2noder�r�r�r�rer%r%r&r�3s(


����"�zworkingctx.setparentscs|jtt|��|�Sr)r@r�r�r�r�rr%r&r�Fszworkingctx._fileinfocs�|jj��j�|��}t|�dkr |d�����fdd�}|S|\}}|�|�}|��|��|���������fdd�}|S)Nr�rcs�||�}��|�Srr�r�)�	copiesget�manr%r&�funcUs

z'workingctx._buildflagfunc.<locals>.funccsT�||�}��|���|���|�}}}||kr|S||kr"|S||kr(|SdS�Nr�r�)r��fl1�fl2�fla)r�m1�m2�mar%r&r`s
")r!r�r�r)r�r�rKrN)r#r�rr�r��par%)rr	r
rrr&�_buildflagfuncKs�
zworkingctx._buildflagfunccC�|jj�|j�Sr)r!r��flagfuncr
r+r%r%r&r�mrwzworkingctx._flagfunccCs"z|�|�WStyYdSwr)r�r�r�r%r%r&r�qs
�zworkingctx.flagscC�t|j|||d�S)z-get a file context from the working directory)r�rD)�workingfilectxr!�r#r�rDr%r%r&rEws
�zworkingctx.filectxFTcCspt|j�D]}|�|�j|d�rdSq|r|��p7|o%|��|����kp7|��p7|��p7|�	�p7|o7|�
�S)z-check whether a working directory is modified)r�T)rrvr�r�r�r�r�rjrkrlr[)r#r�r�r�rer%r%r&r�}s�����
�zworkingctx.dirtyc

s^|j����|jj|jj}���fdd�}g}|jjj}|D]|}t�|tj	�
�|��z||�}WntyK|�t
d�||��|�|�Yqw|�dd�}	|	dkrn|j|	krn|�t
d�|d|jd	||�f�t�|j�s�t�|j�s�|�t
d
�||��|�|�q��|�s�|�t
d�||��q|Wd�S1s�wYdS)Nc���t��|��Sr��pathtorrOr���ds�prefixr%r&r���z workingctx.add.<locals>.<lambda>�%s does not exist!
suislarge-file-limitrso%s: up to %d MB of RAM may be required to manage this file
(use 'hg revert %s' to cancel the pending addition)
r�i@Bs:%s not added: only files and symlinks supported currently
s%s already tracked!
)r!�wlockrur��wvfs�lstatr�
checkportable�osr�rOr�rQrra�configbytes�st_size�stat�S_ISREG�st_mode�S_ISLNK�set_tracked)
r#�listrru�uipath�rejectedrr��st�limitr%rr&�add�sJ

����	���
�$�zworkingctx.addcs�|j���3|jj���fdd�}g}|D]}��|�s.|jj�td�||��|�|�q|Wd�S1s;wYdS)Ncrrrr�rr%r&r��rz#workingctx.forget.<locals>.<lambda>s%s not tracked!
)r!rr��
set_untrackedrurQrra)r#r�rr(r)r�r%rr&�forget�s

�$�zworkingctx.forgetc
Cs�z	|jj�|�}Wn*ty3}z|jtjkr�|jj�td�|jj	�
|��WYd}~dSd}~wwt�|j
�sRt�|j
�sR|jj�td�|jj	�
|��dS|j���|jj	}|�|�|�||�Wd�dS1srwYdS)Nrs1copy failed: %s is not a file or a symbolic link
)r!rrr��errno�ENOENTrurQrr�rr"r#r$r%rr&r�)r#r#�destr*�errrr%r%r&r��s,�����
"�zworkingctx.copyr�c

CsD|j}|s	|��}t�|j�}	tj|j||||||j||||	d�S)N)r�r�r�r��icasefs)r!r�r�fscasesensitiver�r�r
r�)
r#r�r�r�r�r�r�r�r�r3r%r%r&r
�s"
�zworkingctx.matchcCs�|r|jjjr	|Sg}|D]1}|�|�dkr9||��}|dks/t|�dks/d|vs/t�|�r9|jj�	d|�q
|�
|�q
|S)Nr�r�i�
s*ignoring suspect symlink placeholder "%s"
)r!r��
_checklinkr�r~r�rr�ru�debugra)r#r��saner�rmr%r%r&�_filtersuspectsymlink�s"��z workingctx._filtersuspectsymlinkc
Cs|sggggfSg}g}g}g}|jd}t|�D]c}zQ||vs3|�|�|�|�ks3||�||�r9|�|�n2|durC|�|�n(||��}	|	j}
|	j}t�	|	|�}|durf|
||f}
|�||
f�n|�|�Wqt
tfy||�|�Yqw||||fSr�)r�rr�rdrarr$r!r�reliable_mtime_ofr�r�)r#r��mtime_boundaryrjr[rO�fixupr�r�re�moder�
file_mtime�
cache_infor%r%r&�_checklookups:
�

��	zworkingctx._checklookupc
s,|j��}|s|s|jjjr�zzd|jj��}|j�d��N|jj����|kr\|rO���r4�fdd�}n�j}|D]	\}}|||�q9|j��}|jj�	|�|r[|D]}	|	||�qSn|jj
�d�Wd�n1smwYWn
tj
y}Yn	wW|j��dSW|j��dS|j��wdS)z1update dirstate for files that are actually cleanFcs�j|ddd�S)NT��
p1_tracked�
wc_tracked)�update_file)r��pfd�r�r%r&r�Js�z-workingctx._poststatusfixup.<locals>.<lambda>s*skip updating dirstate: identity mismatch
N)r!�postdsstatusr��_dirty�identityr�pendingparentchange�	set_clean�currenttransaction�writerur7r�	LockError�clearpostdsstatus)
r#rLr<�
poststatus�oldid�normalr��pdf�tr�psr%rFr&�_poststatusfixup:sB

���������zworkingctx._poststatusfixupc
	Cs�g}d|vrt|j�}|jjj|||||d�\}}}g}	|rM|�||�\}
}}}	|j�|
�|j�|�|r>|r>|j	�|�|	rM|rM|j	�dd�|	D��|�
||	�|��ru|js`|j
s`|j	rrt�|j|j|j|jggg�|_|S||_|S)z7Gets the status from the dirstate -- internal use only.s.hgsub)r]rOr\css�|]\}}|VqdSrr%)rRr�rr%r%r&r�~s�z-workingctx._dirstatestatus.<locals>.<genexpr>)rrvr!r�rLr@rjr�r[rOrV�alwaysr\r]rrkrlr�)
r#r
r]rOr\�subreposrdrer;r<�	modified2�deleted2�	clean_setr%r%r&�_dirstatestatusis4

����zworkingctx._dirstatestatusc
Cs�i}i}|jj��}|j|d��}|j|d��}t|���t|���B}|j��}|jj���	�D]\}}	||vsA||�sBq5|	|vrK|	||<q5|	|vrS|	||<q5||fS)Nrr)
r!r�r�rKr^rkrjr�r�r�)
r#r�r�r��
p1manifest�
p2manifest�
changedsetr��dst�srcr%r%r&r��s 

�zworkingctx._copiescCs|�|j�S)aLgenerate a manifest corresponding to the values in self._status

        This reuse the file nodeid from parent, but we use special node
        identifiers for added and modified files. This is used by manifests
        merge to see that files are different and by update logic to avoid
        deleting newly added files.
        )rMr�r+r%r%r&r@�s	zworkingctx._manifestc
Cs�|��}|d����}|j}|jjj|jf|jjj|j	ffD] \}}|D]}|||<z
|�
|||��Wq%ty>Yq%wq|j|j
D]	}||vrO||=qF|S)z9Builds a manifest that includes the given status results.r)r�rKr�r�r!rb�addednodeidrk�modifiednodeidrj�setflagr�r[rl)r#rLr�r�ff�ir�r�r%r%r&rM�s&����zworkingctx._buildstatusmanifestcsR|�||||�}|�|j�|jdd�<||jdkr'tt|��||||||�}|S)aCbuild a status with respect to another context

        This includes logic for maintaining the fast path of status when
        comparing the working directory against its parent, which is to skip
        building a new manifest if self (working directory) is not comparing
        against its parent (repo['.']).
        N�.)r\r9rjr!r�r�rs)r#r:rer
rfrgrhrr%r&rs�s

�zworkingctx._buildstatuscs&��jdkr��fdd�}||_|S)a�override the match method with a filter for directory patterns

        We use inheritance to customize the match.bad method only in cases of
        workingctx since it belongs only to the working directory when
        comparing against the parent changeset.

        If we aren't comparing against the working directory's parent, then we
        just use the default match object sent to us.
        rgcs>|�vr��|�s�jj�d�jj�|�|f�dSdSdS)Ns%s: %s
)r�r!rurQr�r)r�r\�r:r#r%r&r[�s
��z$workingctx._matchstatus.<locals>.bad)r!r[)r#r:r
r[r%rhr&rN�s
zworkingctx._matchstatuscCs(t|jjj|j�|�t|j�ddd��S)rVTF)rXr\r])rr!r�r_r�rvrar%r%r&r_�s
��zworkingctx.walkcs0|j�|�}|jj�t�fdd���|�D��S)Nc3s �|]}��|�jr|VqdSr)r�r�r��rr%r&r��s�z%workingctx.matches.<locals>.<genexpr>)r!r�r�rrbrar%rir&rb�szworkingctx.matchescCs�|jj���A|��|��D]}|jjj|ddd�q|��D]}|jjj|ddd�q |jj�|�|j��t	�
|j|�Wd�n1sJwY|jj�|j���dS)NTrAF)
r!r�r�rjrkrDrlr��!_quick_access_changeid_invalidater�aftercommitrMrL)r#r*r�r%r%r&r��s��
�zworkingctx.markcommittedcCs |r	tj�|j�Stj�|j�Sr)�
mergestatemodrrOr!rr�r%r%r&rszworkingctx.mergestate)r�NNNNrr��r�r��FFFr�)#r2r�r�r�r'rIrCrr�r�r�r�r
r�r�rEr�r,r.r�r
r9r@rVr\r�r@rMrsrNr_rbr�rrfr%r%rr&r�sV
�



"




)
�,
/%


r�c@sFeZdZdZddd�Zdd�ZeZdd�Zd	d
�Zdd�Z	d
d�Z
dS)�committablefilectxz�A committablefilectx provides common functionality for a file context
    that wants the ability to commit, e.g. workingfilectx or memfilectx.NcCs>||_||_d|_d|_|_|dur||_|r||_dSdSr)r!rirprorsrjrk)r#r$r�rDr�r%r%r&r's
�zcommittablefilectx.__init__cCr8r�r%r+r%r%r&r(r:zcommittablefilectx.__nonzero__cCrJrr�r+r%r%r&rn-r-zcommittablefilectx.linkrevcCs0|��}|sdS||jjdj�||jjj�fSr�)r|rkr�r@r)r!rbrJr�r%r%r&r{1s
��zcommittablefilectx.renamedcs��fdd�}�j}�j}�jj}���}|r|dg}n|||d|�|fg}|dd�D]
}|�||||�|f�q-�fdd�|D�S)	z5return parent filectxs, following copies if necessarycs|j�|�jjj�Sr)r@r)r!rbrJ)r�r�r+r%r&r�?r*z,committablefilectx.parents.<locals>.filenoderrrNcs0g|]\}}}|�jjjkr�j|||d��qSr�)r!rbrJr�)rRr�rFr�r+r%r&rVOs
�z.committablefilectx.parents.<locals>.<listcomp>)rirjrkr�r{ra)r#r�r�r��pclr{r��pcr%r+r&r�<s
�zcommittablefilectx.parentscCr�rr%r+r%r%r&r?Ur:zcommittablefilectx.childrenrc)r2r�r�r�r'rrdrnr{r�r?r%r%r%r&ros
rocs�eZdZdZd$�fdd�	Zedd��Zdd�Zd	d
�Zdd�Z	d
d�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zd%dd�Zd%dd�Zdd�Zd d!�Zd"d#�Z�ZS)&rzrA workingfilectx object makes access to data related to a particular
    file in the working directory convenient.Ncstt|��||||�dSr)r�rr')r#r$r�rDr�rr%r&r']�zworkingfilectx.__init__cCrGr)r�r!r+r%r%r&rk`r�zworkingfilectx._changectxcCr.r)r!�wreadrir+r%r%r&r~dr|zworkingfilectx.datacCrr)r!r��copiedrir+r%r%r&r|gr}zworkingfilectx.copysourcecCs|jj�|j�jSr)r!rrrir!r+r%r%r&rjr�zworkingfilectx.sizecCrr)r!rrrir+r%r%r&rmr}zworkingfilectx.lstatc
Csf|j��\}}z|jj�|j�tj|fWSty2}z|j	t	j
kr$�||fWYd}~Sd}~wwr)rkrr!rrrir"�ST_MTIMEr�r/r0)r#�t�tzr2r%r%r&rps��zworkingfilectx.datecCrr)r!r�existsrir+r%r%r&rxyr}zworkingfilectx.existscCrr)r!r�lexistsrir+r%r%r&ry|r}zworkingfilectx.lexistscCrr)r!r�auditrir+r%r%r&rzr}zworkingfilectx.auditcCs
|�|�S)r�)rdr�r%r%r&rd�s
zworkingfilectx.cmpFcCs*|jj�dd�}|jjj|j||d�dS)�+wraps unlink for a repo's working directoryrsremoveemptydirs)�
ignoremissing�rmdirN)r!ru�
configboolr�
unlinkpathri)r#r|r}r%r%r&�remove�s
�zworkingfilectx.removecKs|jj|j||fd|i|��S)�wraps repo.wwrite�backgroundclose)r!�wwriteri�r#r~r�r��kwargsr%r%r&rM�s���zworkingfilectx.writecCs|jj�||j�dS)zmarks this file a copy of `src`N)r!r�r�ri)r#rar%r%r&�
markcopied�r�zworkingfilectx.markcopiedcCs�|jj}|j}|�|�|jj�dd�r@|�|�r%|�|�s%|j|dd�t	t
t�|���D]}|�
|�r=|�|�dSq.dS|�|�rQ|�|�sS|�|�dSdSdS)zsRemoves conflicting items in the working directory so that
        ``write()`` can be called successfully.
        rsmerge.checkpathconflictsT)�forciblyN)r!rrirzrur~�isdirr��rmtreer�r'r�finddirs�isfileorlink�unlink�
removedirs)r#rr�r�r%r%r&�clearunknown�s"
�

���zworkingfilectx.clearunknowncCs|jj�|j||�dSr)r!r�setflagsri)r#r�r=r%r%r&r��szworkingfilectx.setflagsrcr�)r2r�r�r�r'r�rkr~r|rrrrxryrzrdr�rMr�r�r�rfr%r%rr&rYs&
	
	
rcsJeZdZdZ�fdd�Zdd�ZdIdd�Zd	d
�Zedd��Z	ed
d��Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd%d&�Zd'd(�Zd)d*�ZdJd,d-�Zd.d/�Zd0d1�Zd2d3�Zd4d5�Zd6d7�Z						dKd8d9�Zd:d;�Z d<d=�Z!d>d?�Z"d@dA�Z#	dLdBdC�Z$dIdDdE�Z%dMdGdH�Z&�Z'S)N�overlayworkingctxa�Wraps another mutable context with a write-back cache that can be
    converted into a commit context.

    self._cache[path] maps to a dict with keys: {
        'exists': bool?
        'date': date?
        'data': str?
        'flags': str?
        'copied': str? (path or None)
    }
    If `exists` is True, `flags` must be non-None and 'date' is non-None. If it
    is `False`, the file was deleted.
    cstt|��|�|��dSr)r�r�r'rOr"rr%r&r'�szoverlayworkingctx.__init__cCs||_|g|_t�|d�dS)N�	_manifest)�_wrappedctxr�r�clearcachedproperty)r#�
wrappedctxr%r%r&�setbase�szoverlayworkingctx.setbaseNcCs>|dur	|jjj}||j��ksJ�|j|j��|g|_dSr)r!rbrJr�r*rr�)r#rrr%r%r&r��s
zoverlayworkingctx.setparentscCsb|�|�r*|j|dr#|j|ddur|j|dS|j|��St�d|��|j|��S�N�exists�data�No such file or directory: %s)�isdirty�_cacher�r~rr�r�r%r%r&r~�s
�zoverlayworkingctx.datacCs�|��}|d����}|j}|��D]}|jjj||<|�|||��q|�	�D]}|jjj
||<|�|||��q)|��D]}||=q?|Sr�)r�rKr�r�rkr!rbrbrdrjrcrl)r#r�rr�r�r%r%r&r@�szoverlayworkingctx._manifestc��fdd�}|S)Ncs�j|dS)N�flags�r�r�r+r%r&r��r|z&overlayworkingctx._flagfunc.<locals>.fr%)r#r�r%r+r&r��szoverlayworkingctx._flagfunccCst|��|��|���Sr)rrkrjrlr+r%r%r&r��szoverlayworkingctx.filesc��fdd��j��D�S)Ncs(g|]}�j|dr��|�r|�qS�r��r��_existsinparentr�r+r%r&rV	����z.overlayworkingctx.modified.<locals>.<listcomp>�r��keysr+r%r+r&rj	�
�zoverlayworkingctx.modifiedcr�)Ncs(g|]}�j|dr��|�s|�qSr�r�r�r+r%r&rV		r�z+overlayworkingctx.added.<locals>.<listcomp>r�r+r%r+r&rk	r�zoverlayworkingctx.addedcr�)Ncs(g|]}�j|ds��|�r|�qSr�r�r�r+r%r&rV	r�z-overlayworkingctx.removed.<locals>.<listcomp>r�r+r%r+r&rl	r�zoverlayworkingctx.removedcC�Ri}|j��}|j��D]}||�sq|�|d�|j|d}|r&|||<q|S�N�copied�r!r�r�r�r��r#r�r�r�r#r%r%r&r�	�
�zoverlayworkingctx.p1copiescCr�r�r�r�r%r%r&r�"	r�zoverlayworkingctx.p2copiescCr8r�r%r+r%r%r&r9.	r:zoverlayworkingctx.isinmemorycCs&|�|�r|j|dS|j|��S)N�date)r�r�r�rr�r%r%r&�filedate1	s
zoverlayworkingctx.filedatecCs$|j|d|�|�|�|�|d�dS)NT)rxrr�rt)�
_markdirtyr�r�)r#r��originr%r%r&r�7	s
�zoverlayworkingctx.markcopiedcCs|�|�r|j|dSdSr�)r�r�r�r%r%r&�copydata@	s
zoverlayworkingctx.copydatacCsB|�|�r|j|dr|j|dSt�d|��|j|��S)Nr�r�r�)r�r�rr�r�r�r�r%r%r&r�F	s
�zoverlayworkingctx.flagscCs$||jvr|j|dS||��vS)Nr�)r�r�rAr%r%r&rCQ	s
zoverlayworkingctx.__contains__cCs(z|j|WdStjyYdSwrv)r�rr�r�r%r%r&r�V	s
�z!overlayworkingctx._existsinparentc
s��fdd�}|�d�}t�t|��D]}d�|d|��}|�vr&|||�q�j|gdd�}t������	|��}t|�dkrnt|�dkrN|d|krNdS�fd	d
�|D�}|s[dSt
�d||���t|�d�|�f��dS)
a$Replicates conflict checks done by wvfs.write().

        Since we never write to the filesystem and never call `applyupdates` in
        IMM, we'll never check that a path is actually writable -- e.g., because
        it adds `a/foo`, but `a` is actually a file in the other commit.
        csLd���|��vrt�d||�����f��t�d||�����f��)Nr�s*error: %s conflicts with symlink %s in %d.s+error: '%s' conflicts with file '%s' in %d.)r�r�rr�rZ)r��	componentr+r%r&�failh	s����z/overlayworkingctx._auditconflicts.<locals>.failrWrspath)r�rNcsg|]}|�vr|�qSr%r%)rRr`r+r%r&rV�	rYz5overlayworkingctx._auditconflicts.<locals>.<listcomp>sberror: file '%s' cannot be written because  '%s/' is a directory in %s (containing %d entries: %s)s, )�splitr�xranger�rOr
r'r�rKr_rr�)r#r�r��
componentsrfr�r
�mfilesr%r+r&�_auditconflicts`	s*

����z!overlayworkingctx._auditconflictsr�cKs8|dur	t�d��|�|�|j|d|t��|d�dS)Nsdata must be non-NoneT)rxr~rr�)rr�r�r�rr�)r#r�r~r�r�r%r%r&rM�	s


�zoverlayworkingctx.writecCs0d}|rd}n|rd}|j|dt��|d�dS)Nr�r�r�T)rxrr�)r�rr�)r#r�r�r=r�r%r%r&r��	szoverlayworkingctx.setflagscCs|j|dd�dS)NF)rx)r�r�r%r%r&r��	r�zoverlayworkingctx.removecCsZ|�|�r(|j|dr!d|j|dvr!|�|j|d���S|j|dS|�|�S)zqexists behaves like `lexists`, but needs to follow symlinks and
        return False if they are broken.
        r�r�r�r�)r�r�rx�stripr�r�r%r%r&rx�	s
�
zoverlayworkingctx.existscCs"|�|�r|j|dS|�|�S)z'lexists returns True if the path existsr�)r�r�r�r�r%r%r&ry�	s

zoverlayworkingctx.lexistscCsF|�|�r|j|drt|j|d�St�d|��|j|��Sr�)r�r�r�rr�r�rr�r%r%r&r�	s
�zoverlayworkingctx.sizec
s�|dur���}t|�dkr|ddf}|ddur$�j|ddf}n�j|d�j|df}���}�fdd�}	|durE�j��}t�j||||	|||||d�
S)z�Converts this ``overlayworkingctx`` into a ``memctx`` ready to be
        committed.

        ``text`` is the commit message.
        ``parents`` (optional) are rev numbers.
        Nrrc	sV�j|dr)t|||�j|dd�j|dvd�j|dv�j|d�SdS)Nr�r�r�r�r�r�)r��
memfilectx�r$�memctxr�r+r%r&�getfile�	s�z+overlayworkingctx.tomemctx.<locals>.getfile)rrr
r��editor)r�r�r!r�r�r�r�)
r#r�r�rrr�r
r�r�r�r%r+r&�tomemctx�	s.
�zoverlayworkingctx.tomemctxcCs<|����}|��|d<|j|��|��||��|��d�S)Nsamend_source)r�r�rrr
)rr�rr�rr�rr
)r#�	precursorrr%r%r&�tomemctx_for_amend
s�z$overlayworkingctx.tomemctx_for_amendcCr>rr�r�r%r%r&r�
r(zoverlayworkingctx.isdirtycCsd|_i|_dSr)�_mergestater�r+r%r%r&rO
s
zoverlayworkingctx.cleanc	Cs�g}t�|��|����t�|��|j���fg�|j��D]-}|j|}z|j|}|�	�|dkrA|�
�|dkrA|�|�Wqtj
yLYqw|D]}|j|=qO|S)z�Removes keys from the cache that are actually clean, by comparing
        them with the underlying context.

        This can occur during the merge process, e.g. by passing --tool :local
        to resolve a conflict.
        r�r�)r�
prefetchfilesr$r�rZ�
matchfilesr�r�r�r~r�rarr�)r#r�r��cache�
underlyingr%r%r&�_compact
s,
���



��
zoverlayworkingctx._compactcCsb|r|dur|j�|�p
i}|�d�}|dur|j|��}|||||d�|j|<t�|d�dS)Nr�)r�r�r�r�r�r�)r�r)r�r~rr�)r#r�rxr~rr�rt�oldentryr%r%r&r�:
s
�zoverlayworkingctx._markdirtycCr)N)r�rD)�overlayworkingfilectxr!rr%r%r&rEO
s
�zoverlayworkingctx.filectxFcCs"|s|jdurt�|j�|_|jSr)r�rl�
memmergestater!r�r%r%r&rT
szoverlayworkingctx.mergestaterrm�NNNNNN)NNr�Nr�)(r2r�r�r�r'r�r�r~r�r@r�r�rjrkrlr�r�r9r�r�r�r�rCr�r�rMr�r�rxryrr�r�r�rOr�r�rErrfr%r%rr&r��sZ


	

0

�>&
�
r�cs�eZdZdZd$�fdd�	Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zd%dd�Zd%d d!�Zd"d#�Z�ZS)&r�z�Wrap a ``workingfilectx`` but intercepts all writes into an in-memory
    cache, which can be flushed through later by calling ``flush()``.Ncs,tt|��||||�||_||_||_dSr)r�r�r'r!�_parentri)r#r$r�rDr�rr%r&r'^
s
zoverlayworkingfilectx.__init__cC�|��|��kSr�r~r�r%r%r&rdd
r}zoverlayworkingfilectx.cmpcCr}r)r�r+r%r%r&r�g
r~zoverlayworkingfilectx.changectxcCr.r)r�r~rir+r%r%r&r~j
r|zoverlayworkingfilectx.datacCr.r)r�r�rir+r%r%r&rm
r|zoverlayworkingfilectx.datecCrJr)ryr+r%r%r&rxp
rzoverlayworkingfilectx.existscCr.r)r�rxrir+r%r%r&rys
r|zoverlayworkingfilectx.lexistscCr.r)r�r�rir+r%r%r&r|v
r|z overlayworkingfilectx.copysourcecCr.r)r�rrir+r%r%r&ry
r|zoverlayworkingfilectx.sizecCs|j�|j|�dSr)r�r�ri)r#r�r%r%r&r�|
r*z overlayworkingfilectx.markcopiedcCr�rr%r+r%r%r&rz
r:zoverlayworkingfilectx.auditcCr.r)r�r�rir+r%r%r&r��
r|zoverlayworkingfilectx.flagscCs|j�|j||�Sr)r�r�ri)r#r�r�r%r%r&r��
r�zoverlayworkingfilectx.setflagsFcKs|jj|j||fi|��Sr)r�rMrir�r%r%r&rM�
rrzoverlayworkingfilectx.writecCr.r)r�r�ri�r#r|r%r%r&r��
r|zoverlayworkingfilectx.removecCr�rr%r+r%r%r&r��
r:z"overlayworkingfilectx.clearunknownrcr�)r2r�r�r�r'rdr�r~rrxryr|rr�rzr�r�rMr�r�rfr%r%rr&r�Z
s$

r�cs:eZdZdZ	d�fdd�	Zddd�Zed	d
��Z�ZS)
�workingcommitctxz�A workingcommitctx object makes access to data related to
    the revision being committed convenient.

    This hides changes in the working directory, if they aren't
    committed in this context.
    r�Ncstt|��||||||�dSr)r�r�r')r#r$r�r�r
rrrr%r&r'�
s
�zworkingcommitctx.__init__Fc	sj|r
�fdd��jD�}ng}t��fdd��jjD��fdd��jjD��fdd��jjD�ggg|�S)z�Return matched files only in ``self._status``

        Uncommitted files appear "clean" via this context, even if
        they aren't actually so in the working directory.
        csg|]	}|�jvr|�qSr%)�_changedsetr�r+r%r&rV�
�z4workingcommitctx._dirstatestatus.<locals>.<listcomp>c�g|]}�|�r|�qSr%r%r��r
r%r&rV�
rYcr�r%r%r�r�r%r&rV�
rYcr�r%r%r�r�r%r&rV�
rY)r@rrLr�rjrkrl)r#r
r]rOr\r%r]r&r\�
s�z workingcommitctx._dirstatestatuscCs,t|jj�}|�|jj�|�|jj�|S)z/Return the set of files changed in this context)r^r�rj�updaterkrl)r#�changedr%r%r&r��
szworkingcommitctx._changedset)r�NNNrn)	r2r�r�r�r'r\r�r�rfr%r%rr&r��
s�
r�csi���fdd�}|S)z�Create a filectxfn that caches based on the path.

    We can't use util.cachefunc because it uses all arguments as the cache
    key and this creates a cycle since the arguments include the repo and
    memctx.
    cs |�vr�|||��|<�|Srr%r��r�rr%r&�
getfilectx�
sz(makecachingfilectxfn.<locals>.getfilectxr%)rr�r%r�r&�makecachingfilectxfn�
sr�cr�)z�Given a context return a memfilectx for ctx[path]

    This is a convenience method for building a memctx based on another
    context.
    c	s2�|}|��}t||||��|��|��|d�S�N)r�r�r|)r|r�r~r�r�)r$r�r�r�r|�r�r%r&r��
s�z"memfilefromctx.<locals>.getfilectxr%)r�r�r%r�r&�memfilefromctx�
s
r�cr�)z�Given a patch (e.g. patchstore object) return a memfilectx

    This is a convenience method for building a memctx based on a patchstore.
    c	s:��|�\}}}|durdS|\}}t|||||||d�Sr�)r�r�)r$r�r�r~r=r|r�r���
patchstorer%r&r��
s�z$memfilefrompatch.<locals>.getfilectxr%)r�r�r%r�r&�memfilefrompatch�
sr�csbeZdZdZdZ					d�fdd�	Zddd�Zdd	�Zed
d��Z	edd
��Z
dd�Z�ZS)r�aNUse memctx to perform in-memory commits via localrepo.commitctx().

    Revision information is supplied at initialization time while
    related files data and is made available through a callback
    mechanism.  'repo' is the current localrepo, 'parents' is a
    sequence of two parent revisions identifiers (pass None for every
    missing parent), 'text' is the commit message and 'files' lists
    names of files touched by the revision (normalized and relative to
    repository root).

    filectxfn(repo, memctx, path) is a callable receiving the
    repository, the current memctx object and the normalized path of
    requested file, relative to repository root. It is fired by the
    commit function for every file in 'files', but calls order is
    undefined. If the file is available in the revision being
    committed (updated or added), filectxfn returns a memfilectx
    object. If the file was removed, filectxfn return None for recent
    Mercurial. Moved files are represented by marking the source file
    removed and the new file added with copy information (see
    memfilectx).

    user receives the committer name and defaults to current
    repository username, date is the commit date in any format
    supported by dateutil.parsedate() and defaults to current date, extra
    is a dictionary of metadata or is left empty.
    TNc
s�tt��j||||||	d�d�_d�_�fdd�|D�}|\}}�fdd�||fD��_tt|��}|�_i�_	t
|tj�rDt
|�}nt|�sLt|�}t|��_|
rd|
�j�g��_�j��j�dSdS)Nr�csg|]	}|p
�jjj�qSr%r�r�r+r%r&rV1r�z#memctx.__init__.<locals>.<listcomp>cr;r%r r�r+r%r&rV3r>)r�r�r'r7rr�rr^�_filesrvr�r�	filestorer��callabler�r��
_filectxfnr!r��savecommitmessage)
r#r$r�r�r��	filectxfnr
rrr�r�r�r�rr+r&r's(

�

�zmemctx.__init__cCs|�|j||�S)zpget a file context from the working directory

        Returns None if file doesn't exist and should be removed.)r�r!rr%r%r&rEEr�zmemctx.filectxcC�|j�|�S�zcommit context to the repo�r!�	commitctxr+r%r%r&�commitKr�z
memctx.commitcCsn|jd}|����}|jjD]	}|jjj||<q|jjD]	}|jjj	||<q|jj
D]	}||vr4||=q+|S)z;generate a manifest based on the return values of filectxfnr)r�rKr�r�rjr!rbrcrkrbrl)r#r�rr�r%r%r&r@Os
�zmemctx._manifestc	s�|�����|jd}|��tkr|�����fdd�}n�fdd�}ggg}}}|jD]}||�s:|�|�q.||rD|�|�q.|�|�q.t�|||gggg�S)z?Calculate exact status from ``files`` specified at constructionrc�|�vp|�vSrr%r���man1�man2r%r&r�m�z memctx._status.<locals>.<lambda>c�|�vSrr%r��r�r%r&r�o��	r�rKr�rZrr�rarrL�r#r��managingrjrkrlr�r%r�r&r�cs

zmemctx._statuscCs$|jd��tkr|jdgS|jS)Nrr)r�rZrr+r%r%r&r�|szmemctx.parents)NNNNNr)
r2r�r�r��_returnnoneformissingfilesr'rEr�r�r@r�r�rfr%r%rr&r��
s 	�
&

r�csReZdZdZ			d�fdd�	Zdd�Zdd	�Zd
d�Zddd
�Zdd�Z	�Z
S)r�zpmemfilectx represents an in-memory file to commit.

    See memctx and committablefilectx for more details.
    FNcsDtt|��||d|�||_|rd|_n	|rd|_nd|_||_dS)aQ
        path is the normalized file path relative to repository root.
        data is the file content as a string.
        islink is True if the file is a symbolic link.
        isexec is True if the file is executable.
        copied is the source file path if current file was copied in the
        revision being committed, or None.Nr�r�r�)r�r�r'�_datarx�_copysource)r#r$r�r�r~r�r�r|rr%r&r'�s
zmemfilectx.__init__cCr}r)r�r+r%r%r&r|�r~zmemfilectx.copysourcecCr�rr�r�r%r%r&rd�r}zmemfilectx.cmpcCr}r�r�r+r%r%r&r~�r~zmemfilectx.datacCs|j|j=dS)r{N)rkrir�r%r%r&r��szmemfilectx.removecKs
||_dS)r�Nr��r#r~r�r�r%r%r&rM�r�zmemfilectx.write)FFNr�)r2r�r�r�r'r|rdr~r�rMrfr%r%rr&r��s�
r�csleZdZdZ						d�fdd�	Zdd�Zedd��Zdd	d
�Zdd�Z	ed
d��Z
edd��Z�Z
S)�metadataonlyctxa�Like memctx but it's reusing the manifest of different commit.
    Intended to be used by lightweight operations that are creating
    metadata-only changes.

    Revision information is supplied at initialization time.  'repo' is the
    current localrepo, 'ctx' is original revision which manifest we're reuisng
    'parents' is a sequence of two parent revisions identifiers (pass None for
    every missing parent), 'text' is the commit.

    user receives the committer name and defaults to current repository
    username, date is the commit date in any format supported by
    dateutil.parsedate() and defaults to current date, extra is a dictionary of
    metadata or is left empty.
    Nc	
s4|dur|��}tt|���||||�d|_d|_||_|��|_|dur+|�	�}n	�fdd�|D�}|dd�}t
|�dkrM|��t�t
|�dks@|\}	}
|_
|��j	\}}|	|jjjkrl|	��|krltd��|
|jjjkr}|
��|kr}td��|��|_i|_|r�||j|g�|_|j�|j�dSdS)Ncsg|]
}|dur�|�qSrr%r��r$r%r&rV�sz,metadataonlyctx.__init__.<locals>.<listcomp>r�z=can't reuse the manifest: its p1 doesn't match the new ctx p1z=can't reuse the manifest: its p2 doesn't match the new ctx p2)rr�r�r'r7r�_originalctxr�
_manifestnoder�r�rarr�r�r!rbrJ�RuntimeErrorr�r�rvr�r�)
r#r$�originalctxr�r�r
rrr�r�r��mp1�mp2rr�r&r'�s<

���
�zmetadataonlyctx.__init__cCr}r)r�r+r%r%r&r�r~zmetadataonlyctx.manifestnodecCs|jj|jSr)r!r�r�r+r%r%r&r��r1zmetadataonlyctx._manifestctxcCs|jj||d�S)N)rD)r�rErr%r%r&rE�r}zmetadataonlyctx.filectxcCr�r�r�r+r%r%r&r�r�zmetadataonlyctx.commitcCr�r)r�rKr+r%r%r&r@r�zmetadataonlyctx._manifestc	s�|�����|jd}|��tkr|�����fdd�}n�fdd�}ggg}}}|jD]}||�s:|�|�q.||vrD|�|�q.|�|�q.t�|||gggg�S)zjCalculate exact status from ``files`` specified in the ``origctx``
        and parents manifests.
        rcr�rr%r�r�r%r&r�r�z)metadataonlyctx._status.<locals>.<lambda>cr�rr%r�r�r%r&r�r�r�r�r%r�r&r�s

zmetadataonlyctx._statusr�r)r2r�r�r�r'rrer�rEr�r@r�r�rfr%r%rr&r��s$�0


r�c@sReZdZdZddd�Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�ZdS)�arbitraryfilectxz�Allows you to use filectx-like functions on a file in an arbitrary
    location on disk, possibly not in the working directory.
    NcCs||_||_dSr)r!ri)r#r�r$r%r%r&r')s
zarbitraryfilectx.__init__cCsZd|��vpd|��v}|s%t|t�r%|jr%t�|��|j�|����S|��|��kSr�)	r�r�rr!�filecmprdr��wjoinr~)r#r��symlinksr%r%r&rd.szarbitraryfilectx.cmpcCr}rrtr+r%r%r&r�9r~zarbitraryfilectx.pathcCr8rr%r+r%r%r&r�<r:zarbitraryfilectx.flagscC�t�|j�Sr�r�readfilerir+r%r%r&r~?r-zarbitraryfilectx.datacCrrrr+r%r%r&r�Br-zarbitraryfilectx.decodeddatacCst�|j�dSr)rr�rir+r%r%r&r�Er}zarbitraryfilectx.removecKs|rJ�t�|j|�dSr)r�	writefilerir�r%r%r&rMHszarbitraryfilectx.writer)r2r�r�r�r'rdr�r�r~r�r�rMr%r%r%r&r$s
r)<�
__future__rr/rrr"�i18nrr*rrrrr�r	r
rrr
r�rrlrrr�rrrrrrrrr�utilsrr�
dirstateutilsrr��objectrr�rgrEr�r�rorr�r�r�r�r�r�r�r�r�rr%r%r%r&�<module>s^P@.>~*@^&8,4n

https://t.me/RX1948 - 2025