|
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/hgext/fastannotate/__pycache__/ |
Upload File : |
o
�]Lb/{ � @ sT d dl mZ d dlZd dlZd dlZd dlmZ d dlmZm Z m
Z
d dl m Z m
Z
mZ d dlmZmZmZmZmZmZmZ d dlmZmZ dd l mZ m Z ej d
d � �Z!d&d
d�Z"dd� Z#dd� Z$e� ej%�Z&d'dd�Z'dd� Z(dd� Z)e)ej*�Z+G dd� de,�Z-e-� Z*G d d � d e,�Z.d d � Z/G d d!� d!e,�Z0ej1e*dfd"d#��Z2d(d$d%�Z3dS ))� )�absolute_importN)�_)�getattr�open�setattr)�bin�hex�short)�error�linelog�lock�mdiff�pycompat�scmutil�util)�hashutil�
stringutil� )r
�revmapc C s
| � |�S �N)�file)�repo�path� r �</usr/lib/python3/dist-packages/hgext/fastannotate/context.py�_getflog- s
r Tc sN � j � �� }|s� fdd�|D �}|D ]}d|jvr$t� j|�� �|_q|S )Nc s g | ] }|� � � � � kr|�qS r �r )�.0�p��fr r �
<listcomp>= s z _parents.<locals>.<listcomp>�_filelog)� _changeid�parents�__dict__r �_repor r" )r �follow�plr r r r �_parents3 s
�r) c sD � � � }|�d�}|r|�d�s|d7 }� fdd�t�|�D �|fS )N�
r c s g | ]}� |f�qS r r )r �i��fctxr r r! O s z _decorate.<locals>.<listcomp>)�data�count�endswithr �xrange)r- �text� linecountr r, r � _decorateJ s
r4 c C s> |D ]\\}}}}}|dkr | d ||� |d ||�< q|S )N� =r r )�parent�child�blocks�a1�a2�b1�b2�tr r r �_pairU s
�r> Fc C s� |rt |t�s|durt| |�}n| | }|du r0|�� du r%|| }|S | j||�� d�}|S || }|dkr=|�� }n|�� }||�� krO||_| | |_|S )a2 (repo, str, str) -> fctx
get the filectx object from repo, rev, path, in an efficient way.
if resolverev is True, "rev" is a revision specified by the revset
language, otherwise "rev" is a nodeid, or a revision number that can
be consumed by repo.__getitem__.
if adjustctx is not None, the returned fctx will point to a changeset
that introduces the change (last modified the file). if adjustctx
is 'linkrev', trust the linkrev and do not adjust it. this is noticeably
faster for big repos but is incorrect for some cases.
N)�changeid� linkrev) �
isinstance�int�
_revsingle�rev�filectx�linkrev�introrevr# �
_changectx)r rD r �
resolverev� adjustctx�ctxr- rG r r r � resolvefctxc s" �
�
rL c C s$ | � dd�� dd�� dd�� dd�S ) Ns .hg/s .hg.hg/s .l/s .l.hg/s .m/s .m.hg/s .lock/s .lock.hg/)�replacer r r r � encodedir� s
�rN c s: t �t� fdd�tjjD ���}tt�|�� � �d d� S )Nc 3 s � | ]
}|t � |�fV qd S r )r )r �k��diffoptsr r � <genexpr>� s � z hashdiffopts.<locals>.<genexpr>� )
r �pprint�sortedr
rQ �defaultsr r �sha1�digest)rQ �
diffoptstrr rP r � hashdiffopts� s �rZ c @ s2 e Zd ZdZdddd�Zdd� Zejdd� �ZdS ) � annotateoptsz�like mercurial.mdiff.diffopts, but is for annotate
followrename: follow renames, like "hg annotate -f"
followmerge: follow p2 of a merge changeset, otherwise p2 is ignored
NT)s diffoptss followrenames followmergec K s8 t �|�}t �| j�D ]\}}t| ||�||�� q d S r )r � byteskwargs� iteritemsrV r �get)�self�optsrO �vr r r �__init__� s
�zannotateopts.__init__c C sb d}| j s |d7 }| js|d7 }| jdur-t| jtj�s J �t| j�}|tkr-|d| 7 }|p0dS )z?represent opts in a short string, suitable for a directory name� s r0s m0N� is default)� followrename� followmergerQ rA r
rZ �_defaultdiffopthash)r_ �result� diffopthashr r r �shortstr� s
zannotateopts.shortstr) �__name__�
__module__� __qualname__�__doc__rV rb r �
propertycacherj r r r r r[ � s �r[ c @ s� e Zd ZdZdd� Zedd� �Zedd� �Zdd � ZeZ d
d � Z
ed d
� �Z d/dd�Z d0dd�Z
dd� Zd1dd�Zdd� Zdd � Zd d � Zd2d d �Zd!d"� Zed2d#d$��Zd2d%d&�Zd'd(� Zejd)d*� �Zejd+d,� �Z d2d-d.�Z dS )3�_annotatecontextz{do not use this class directly as it does not use lock to protect
writes. use "with annotatecontext(...)" instead.
c C s< || _ |j| _|| _|| _|| _|| _d | _d | _i | _d S r ) r �uir r` � linelogpath�
revmappath�_linelog�_revmap�
_node2path)r_ r r rr rs r` r r r rb � s
z_annotatecontext.__init__c C s� | j d u rPtj�| j�rKt| jd��.}z tj�|� � �| _ W n tj
y- t�� | _ Y n
w W d � | j S W d � | j S 1 sCw Y | j S t�� | _ | j S )Ns rb) rt �osr �existsrr r �
linelogmodr �fromdata�read� LineLogError�r_ r r r r r � s$
��
��
��
�z_annotatecontext.linelogc C s | j d u r t�| j�| _ | j S r )ru � revmapmodr rs �r_ r r r r � s
z_annotatecontext.revmapc C sn | j d ur
| j �� d | _ | jd ur5t| jd��}|�| j�� � W d � n1 s+w Y d | _d S d S )Ns wb)ru �flushrt r rr �write�encoder} r r r �close� s
�
�z_annotatecontext.closec C s& | � � | j�� t| j| jg� dS )z0delete linelog and revmap, useful for rebuildingN)r� rv �clear� _unlinkpathsrs rr r r r r �rebuild� s
z_annotatecontext.rebuildc C s& | j du r t�| j�S | j �| j j�S )z6return last node in revmap, or None if revmap is emptyN)ru r~ � getlastnoders �rev2hsh�maxrevr r r r �lastnode� s
z_annotatecontext.lastnodeTc C sh | j }z&| j|dd�}| jj�|�� �}|s%|r%||kr%| j�|�duW S ||kW S ty3 Y dS w )a return True if the revmap / linelog is up-to-date, or the file
does not exist in the master revision. False otherwise.
it tries to be fast and could return false negatives, because of the
use of linkrev instead of introrev.
useful for both server and client to decide whether to update
fastannotate cache or not.
if strict is True, even if fctx exists in the revmap, but is not the
last node, isuptodate will return False. it's good for performance - no
expensive check was done.
if strict is False, if fctx exists in the revmap, this function may
return True. this is useful for the client to skip downloading the
cache if the client's master is behind the server's.
T)rI N) r� � _resolvefctxr � changelog�noderF r �hsh2rev� LookupError)r_ �master�strictr� r �linknoder r r �
isuptodate s
�z_annotatecontext.isuptodateNFc
s6 t |t�rt� jj�|��}� �|�\}}|r4� jjr-� j� d� j
t � t
�|d��f � � �|||�S d}|rSz
� j|ddd�}W n tyK Y nw |� jv rSd}|g}|rn|�� du ritjtd�td�d��|�|� |dd� } i }
|d i} i } | r�| �� }
|
|
v s�|
| v r�q||
� jv r�� j�|
�� �}� j�|� � jj }||
� � f| |
< q|� � |
�}||
|
< |D ]}| � |d
�d | |< ||
vr�| �|� q�| s~t � }|}
|
r�|
� jvr�|�!|
� |
|
}|r�|d
}
nd}
n|
r�|
� jvs�|dur�� �"|
� � jj�r |�r� j� d � j
t#|�f � n | �s � j� d � j
� � j�� jj$� |dd� } � jj%d
t#|�d�}| �r| d }
|
| v �rI| �� �q7d}|
|
}|D ]}|| v�r_d}| �|� �qQ|�sf�q7| �� d}|
|v }|
| v�swJ �t&|
�}t'|�D ]<\}}t(� �)| | d |d ��}|d
k�r�|�r�|}t*| | ||�}| | d k�r�| |= | |= �q| | d 8 < �q|| |
< |
|
= |�r�|�+� d}t#|�dk�r܈ j,j-�r�|d
}|du �r�t(� �)d|d ��}� �.|
||� n |�r�|
�
� � j/|
�� < | �s:|�0� � fdd�| | d
D �}� �1||||�S )a� incrementally update the cache so it includes revisions in the main
branch till 'master'. and run annotate on 'rev', which may or may not be
included in the main branch.
if master is None, do not update linelog.
the first value returned is the annotate result, it is [(node, linenum)]
by default. [(node, linenum, path)] if showpath is True.
if showlines is True, a second value will be returned, it is a list of
corresponding line contents.
s6 fastannotate: %s: using fast path (resolved fctx: %s)
s nodeNT�rI rJ s cannot update linelog to wdir()s set fastannotate.mainbranch)�hintr r s7 fastannotate: %s: %d new changesets in the main branch
sB fastannotate: %s: linelog cannot help in annotating this revision
s building cache)�total���F� rc c s2 g | ]\}}t |t�r� j�|�n|�� |f�qS r )rA rB r r� r� )r �fr�lr r r r! � s ��z-_annotatecontext.annotate.<locals>.<listcomp>)2rA rB r r r� r� �canannotatedirectlyrq � debugflag�debugr r rT r � safehasattr�annotatedirectlyr� r� r rD r
�Abortr �append�popr� r �annotate�annotateresultr. � _parentfuncr^ �set�add�_checklastmasterhead�lenr� � makeprogressr4 � enumerate�list� _diffblocksr> � incrementr` rf �
_appendrevrv �complete�_refineannotateresult)r_ rD r� �showpath� showlines�directly�revfctx�
masterfctx� initvisit�visit�pcache�needed�histr �llrevrh r( r �
newmainbranch�progress�readyr8 � ismainbranch�currr+ �bs�
bannotatedr r r r� ( s
���
� �
�
��
�
���� �
�
�0
�z_annotatecontext.annotatec C s� d}d}t |t�s*|dur*ttd��t|�dd� �|�}|dur*|| jf| jv r*|}|du rO| jr3dnd}| j ||dd�}|| jv }|sO| jrO| j |ddd�}||fS )z�(str) -> bool, fctx or node.
return (True, f) if we can annotate without updating the linelog, pass
f to annotatedirectly.
return (False, f) if we need extra calculation. f is the fctx resolved
from rev.
TN)� �( c S s d S r r )�xr r r �<lambda>� s z6_annotatecontext.canannotatedirectly.<locals>.<lambda>r@ )rJ rI )
rA rB �bytesr r^ r� r r � _perfhackr� )r_ rD rh r �hshrJ r r r r� � s
z$_annotatecontext.canannotatedirectlyc sB | j |ddd�}|| jvrm|g}d} |d }| �|�}|s n|d | jv r-|d �� }n|�|d � qt�� } | �| j� | �| j � t
�� ���| j� t |�D ]}|�� }
t | �
||
��} | �| �|| � |
}qSn| j} | j�| �� } |�� }
��|
�� � �fdd�| D �}|r�| �|��}|r�| �|�| �}||f}|S )a
(rev : str) -> [(node : str, linenum : int, path : str)]
the result has the same format with annotate, but include all (including
deleted) lines up to rev. call this after calling annotate(rev, ...) for
better performance and accuracy.
Tr� rc r� r c s& g | ]\}}|� kr�� |�|f�qS r )r� �r �rr� �r� r r r r! / s & z5_annotatecontext.annotatealllines.<locals>.<listcomp>)r� r r� r. r� ry r �copyfromr� r� r~ �reversedr� r� � _doappendrev� getalllinesr� r� �_addpathtoresult�
_resolvelines)r_ rD r� r� r� �chain�ar r( r �br8 �linesr� rh � linecontentsr r� r �annotatealllines sJ
� �
z!_annotatecontext.annotatealllinesc s � fdd�|D �}dgt |� }t�t�}t�t |��D ]}||| || d f �|� q |�r d}z t�|�D ]\\} }
} � �| �t j
@ rHq9|| d d } W n t y] | Y S w |du r�i } t�|�D ]D\\} }
} | | vr�|| d d }| j j
r�| j �dt|�|
| f � | �|� �| ��}t�|�� �}|| | < | D ]
}| | |
||< q�qitdd� |D ��s�J �|S | j �d t|� � |�| � | �|� �| ��}|j}t�|�� �}t |�t |�kr�t�d
��t|�D ]\}}|| }||v �r || D ]}|||< q�||= q�|s1|S ) ah (annotateresult) -> [line]. designed for annotatealllines.
this is probably the most inefficient code in the whole fastannotate
directory. but we have made a decision that the linelog does not
store line contents. so getting them requires random accesses to
the revlog data, since they can be many, it can be very slow.
c s g | ] }� � |d ��qS )r )r� )r r� �r r r r! A s z2_annotatecontext._resolvelines.<locals>.<listcomp>Nr r s6 fastannotate: reading %s line #%d to resolve lines %r
c s s � | ]}|d uV qd S r r )r r� r r r rR d s � z1_annotatecontext._resolvelines.<locals>.<genexpr>s+ fastannotate: annotate %s to resolve lines
s unexpected annotated lines)r� � collections� defaultdictr� r r1 r� r] �rev2flagr~ �sidebranchflag�
StopIterationrq r� r� r r� �rev2pathr
�
splitnewlinesr. �allr� r� �faerror�CorruptedFileErrorr� )r_ r� r r �revsrh �key2idxsr+ r� rD �_linenum�idxs�revlines�linenumr- r� �idx� annotated�linerO r r� r r� 9 sl
� � ���
�
��1z _annotatecontext._resolvelinesc s� t |t�r|}n|�� }� j�|�}|s t�dt|� ��� j�|�t j
@ dkr1t�dt|� ��� j � |� � fdd�� j j
D �}� �||||�S )a like annotate, but when we know that f is in linelog.
f can be either a 20-char str (node) or a fctx. this is for perf - in
the best case, the user provides a node and we don't need to read the
filelog or construct any filecontext.
s %s is not in revmapr s %s is not in revmap mainbranchc s g | ] \}}� j �|�|f�qS r )r r� r� r r r r! � s �z5_annotatecontext.annotatedirectly.<locals>.<listcomp>)rA r� r� r r� r� r� r r� r~ r� r r� r� r� )r_ r r� r� r� r� rh r r r r� z s
�
�z!_annotatecontext.annotatedirectlyc C st |r| � |�}|r8t|t�r | j�|�}| �|| j�|��}n|}t�|� � �}t
|�t
|�kr4t � � �||f}|S )znadd the missing path or line contents, they can be expensive.
f could be either node or fctx.
)
r� rA r� r r� r� r� r
r� r. r� r� r� )r_ rh r r� r� r� r- r� r r r r� � s
z&_annotatecontext._refineannotateresultc C s | � | j| j|||� d S r )r� r r )r_ r- r8 r� r r r r� � s z_annotatecontext._appendrevc C s t �||| jj�S r )r
� allblocksr` rQ )r_ r� r� r r r r� � s z _annotatecontext._diffblocksc s � fdd�}g }i �|dur*|D ]\\}}} }
} | dkr)|dd� || |
� D �7 }qt |�}||v r7|�|� |D ]} || ��| < q9� j|�� |�� d�}
|
�|< t|�D ]0\\}}} }
} | dkrbqU|du rp| �|
||| |
� qU�fdd�|| |
� D �}| �|
|||� qUdS ) z'append a revision to linelog and revmapc sF t | t�r
t�d��| �� }� �|�}|du r!� j|d| �� d�}|S )z
(fctx) -> ints f should not be an intNT)�
sidebranchr )rA rB r
�ProgrammingErrorr� r� r� r )r r� rD r� r r �getllrev� s
z/_annotatecontext._doappendrev.<locals>.getllrevNr5 c S s g | ] \}}t |t�s|�qS r �rA rB )r r r� r r r r! � s ��z1_annotatecontext._doappendrev.<locals>.<listcomp>r c s* g | ]\}}t |t�r
|n� | |f�qS r r� r� )�
siderevmapr r r! � s ��)r� �remover� r� r r� � replacelines�replacelines_vec)r r r- r8 r� r� �siderevsr9 r: r; r< �opr r� �blinesr )r r� r r� � s6
��
��z _annotatecontext._doappendrevc s. �du r�j ���fdd�� � fdd�|D �S )z6(revmap, [(node, linenum)]) -> [(node, linenum, path)]Nc s2 �j �| �}|d u r� �� �| ��}|�j | < |S r )rv r^ r� r� )�nodeidr )r r_ r r �_getpath� s
z3_annotatecontext._addpathtoresult.<locals>._getpathc s g | ] \}}||� |�f�qS r r )r �nr� )r� r r r! � s z5_annotatecontext._addpathtoresult.<locals>.<listcomp>r� )r_ r� r r )r� r r_ r r� � s z!_annotatecontext._addpathtoresultc C sB |du rd}n| j �|�� �}|st�� �| jj|kr t�� �dS )z:check if fctx is the master's head last time, raise if notNr )r r� r� r� �CannotReuseErrorr r� )r_ r- r� r r r r� � s �z%_annotatecontext._checklastmasterheadc s" | j j�| j j� � �fdd�}|S )z-> (fctx) -> [fctx]c s t | �d�}� s|d d� }|S )N)r' r )r) )r r( �rf re r r r$ � s z-_annotatecontext._parentfunc.<locals>.parents)r` re rf )r_ r$ r r� r r� � s z _annotatecontext._parentfuncc C s | j �dd�S )N� fastannotates perfhack)rq �
configboolr r r r r� s z_annotatecontext._perfhackc K s t | j||p| jfi |��S r )rL r r )r_ rD r �kwdsr r r r� s z _annotatecontext._resolvefctx�T)NFF)FFr ) rk rl rm rn rb �propertyr r r� �__del__r� r� r� r� r� r� r� r� r� r� r� � staticmethodr� r� r� r ro r� r� r� r r r r rp � s>
# C
8A
1
rp c C s. | D ]}zt �|� W q ty Y qw dS )zsilent, best-effort unlinkN)r �unlink�OSError)�pathsr r r r r�
s ��r� c @ sH e Zd ZdZefdd�Zedd� �Zedd� �Zdd � Z ed
d � �Z
d S )
�
pathhelperz9helper for getting paths for lockfile, linelog and revmapc C s" t j�d|jt|��| _|| _d S )Nr� )rw r �joinrj rN �_vfspathr& )r_ r r r` r r r rb s �
zpathhelper.__init__c C s t j�| jj�| j��S r )rw r �dirnamer& �vfsr
r r r r r r s zpathhelper.dirnamec C � | j j�| jd �S )Ns .l�r& r
r
r r r r r rr ! � zpathhelper.linelogpathc C s t �| jj| jd �S )Ns .lock)�lockmodr r& r
r r r r r r % s zpathhelper.lockc C r )Ns .mr r r r r rs ( r zpathhelper.revmappathN) rk rl rm rn � defaultoptsrb r r rr r rs r r r r r s
r c c s� � t | ||�}t�|j� |j}|j}d}zMz'|�� � t| ||||�}|r*|�� |V W d � n1 s7w Y W n t yU |durL|�� | j
� d| � � w W |dura|� � dS dS |durl|� � w w )a context needed to perform (fast) annotate on a file
an annotatecontext of a single file consists of two structures: the
linelog and the revmap. this function takes care of locking. only 1
process is allowed to write that file's linelog and revmap at a time.
when something goes wrong, this function will assume the linelog and the
revmap are in a bad state, and remove them from disk.
use this function in the following way:
with annotatecontext(...) as actx:
actx. ....
Ns+ fastannotate: %s: cache broken and deleted
)
r r �makedirsr rs rr r rp r� � Exceptionrq r� r� )r r r` r� �helperrs rr �actxr r r �annotatecontext- s4 �
�� �� �
�r c C s: | j }| j}|j�ddd�rd}t||d�}t||||�S )zdlike annotatecontext but get the context from a fctx. convenient when
used in fctx.annotate
r� s forcefollowT)rQ re )r& �_pathrq r r[ r )r- r' rQ r� r r �aoptsr r r �fctxannotatecontextR s r r )FN)TNF)4�
__future__r r� �
contextlibrw �mercurial.i18nr �mercurial.pycompatr r r �mercurial.noder r r � mercurialr
r ry r r r
r r r �mercurial.utilsr r � r� r r~ � lrucachefuncr r) r4 r> � revsinglerC rL rN rZ r rg �objectr[ rp r� r �contextmanagerr r r r r r �<module> s@ $
-
" F $