8yddlZddlZddlZddlmZddlmZmZmZddl m Z m Z m Z ddl mZmZmZmZmZmZmZddlmZmZddlmZmZej<d Zdd Z d Z!d Z"ej<ejFZ$ddZ%dZ&dZ'e'ejPZ)GddZ*e*Z(GddZ+dZ,GddZ-ej\e(d fdZ/ddZ0y)N)_)getattropensetattr)binhexshort)errorlineloglockmdiffpycompatscmutilutil)hashutil stringutil)r revmapc$|j|SN)file)repopaths >usr/lib/python3.12/site-packages/hgext/fastannotate/context.py_getflogr,s 99T?c,|j|j}|s1|Dcgc]&}|j|jk(s%|(}}|D]:}d|jvst |j |j|_<|Scc}w)N_filelog) _changeidparentsr__dict__r_repor)ffollowplps r_parentsr'2s~ KK B  4Aqvvx16683a 4QZZ'!!''16684AJ I5s &B Bc|j}|jd}|r|jds|dz }t|Dcgc]}||fc}|fScc}w)N r)datacountendswithrange)fctxtext linecountis r _decorater2IsZ 99;D 5!I DMM%(Q %i 0 1 01dAY 0 14 88 1s AcL|D]\\}}}}}|dk(s|d|||d|| |S)N=r)parentchildblocksa1a2b1b2ts r_pairr>TsD%RR! 9$Qi2.E!HRO & LrFch|rt|ts| t||}n||}|:|j||}|S|j ||j}|S||}|dk(r|j }n|j }||jk7r||_|||_|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. )changeidlinkrev) isinstanceint _revsinglerevfilectxlinkrevintrorevr _changectx)rrEr resolverev adjustctxctxr.rHs r resolvefctxrMbs*S#.3?s#3i 779 t9D K<<swwy<9D K4y  "||~H}}H swwy %DN"8nDO Krc|jddjddjddjddS) Ns.hg/s.hg.hg/s.l/s.l.hg/s.m/s.m.hg/s.lock/s .lock.hg/)replacers r encodedirrQs9 Wj)  #  # L ) rctjtfdtjj D}t tj|jddS)Nc3:K|]}|t|fywr)r).0kdiffoptss r zhashdiffopts..s J2IQ78Q'(2Is) rpprintsortedr rVdefaultsrrsha1digest)rV diffoptstrs` r hashdiffoptsr_sQ""J%..2I2IJJJ x}}Z(//1 22A 66rcFeZdZdZddddZdZejdZy) annotateoptszlike 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)sdiffoptss followrenames followmergec tj|}|jjD]"\}}t |||j ||$yr)r byteskwargsr[itemsrget)selfoptsrUvs r__init__zannotateopts.__init__sC##D)MM'')DAq D!TXXa^ ,*rcd}|js|dz }|js|dz }|jLt|jtjsJt |j}|t k7r|d|zz }|xsdS)z?represent opts in a short string, suitable for a directory namersr0sm0isdefault) followrename followmergerVrBr r__defaultdiffopthash)rfresult diffopthashs rshortstrzannotateopts.shortstrs  eOF eOF == $dmmU^^< <<&t}}5K11$,,##r) __name__ __module__ __qualname____doc__r[rir propertycacherqr5rrraras8H -   $ $rraceZdZdZdZedZedZdZeZ dZ edZ ddZ dd Z d Zdd Zd ZdZdZddZdZeddZddZdZej4dZej4dZddZy )_annotatecontextz{do not use this class directly as it does not use lock to protect writes. use "with annotatecontext(...)" instead. c||_|j|_||_||_||_||_d|_d|_i|_yr) ruirrg linelogpath revmappath_linelog_revmap _node2path)rfrrr{r|rgs rriz_annotatecontext.__init__sF ''  &$  rc|jtjj|jr^t |jd5} t jj|j|_ddd|jSt j|_|jS#t j$rt j|_YgwxYw#1swY|jSxYw)Nsrb) r}osrexistsr{r linelogmodr fromdataread LineLogErrorrfr#s rr z_annotatecontext.linelogs == ww~~d../$**E2a=(2(:(:(C(CAFFH(M 3}}!+ 2 2 4 }} &22=(2(:(:(< =3}}s* C+2B99,C(%C+'C((C++C?cz|j$tj|j|_|jSr)r~ revmapmodrr|rfs rrz_annotatecontext.revmaps, << $++DOO incrementrgrm _appendrevrcompleter_refineannotateresult)rfrErshowpath showlinesdirectlyrevfctx masterfctx initvisitvisitpcacheneededhistr#llrevror%r& newmainbranchprogressreadyr8 ismainbranchcurrr1bs bannotatedfrls rrz_annotatecontext.annotate'so$ c3 dii))..s34C!44S9' ww   - "))$*:*:7G*LM(((IF F  &!..tt/ ,!%J0I ~~'kk899:   Z (! 1 AF{a4iDKK ++AFFH5 %%e,44!1668,Q!!!$BF1I"JJq!,q0q F?LLO& AT[[(   a BqEAT[[(  !  % %a ( 77   !$(IIs=/A#BC 248II> dll112! 77'' S%7( b ADy EBD=!ELLO IIKF -LD= =QQq 1INI&DGq ""$! r7a!$"2"23Q"@AF6:6,-FFH)]` gq) )A*4B) 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)(cyrr5)xs rz6_annotatecontext.canannotatedirectly..strrA)rKrJ) rBrCbytesrrerrr _perfhackr)rfrEror#hshrKs rrz$_annotatecontext.canannotatedirectlys #s##&**3s8^DSICC#3t{{#B 9&*nn $I!!#t!LA$++%Fdnn%%cTd%Kqyrc|j|dd}||jvr$|g}d} |d}|j|}|sn:|d|jvr|dj}n|j |dSt j } | j|j | j| jtj} | j|jt|D]C}|j} t|j|| } |j| | || | }En|j } |j} | j} |j!}| j#|}| Dcgc]\}}||ks | j%||f }}}|r|j'|| }|r|j)|| | }||f}|Scc}}w)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. Trrrr)rrrr*rrr copyfromrrrreversedrr _doappendrev getalllinesrrr_addpathtoresult _resolvelines)rfrErrrchainar#r%r rbr8linesrrrrro linecontentss rannotatealllinesz!_annotatecontext.annotateallliness##CDD#I $++ %IEA"I%%a(a5DKK'1 A RU#!((*G   T\\ *   W^^ ,%%'F OODKK (e_FFHd..q!45!!'61f= %llG[[F##%llns#5:IUTQa5j6>>!$a(UI **66:F --ffgFLl+F Js  G+$G+c`|Dcgc]}|j|d}}dgt|z}tjt}t t|D]!}|||||dfj |#|rd} |jD]7\\} } } |j| tjzr,|| dd} n| i} |jD]\\} }} | | vr|| dd} |jjr*|jjdt| || fz|j!| |j#| }t%j&|j)}|| | <| D] }| | |||<t+d|DsJ|S|jjdt| z|j- |j!| |j#| }|j.}t%j&|j)}t|t|k7rt1j2dt5|D]!\}}||}||vs||D]}|||< ||=#|r|Scc}w#t$r|cYSwxYw)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. rNrs6fastannotate: reading %s line #%d to resolve lines %r c3$K|]}|du ywrr5)rTrs rrWz1_annotatecontext._resolvelines..cs9&Q1D=&ss+fastannotate: annotate %s to resolve lines sunexpected annotated lines)rr collections defaultdictrr-rrdrev2flagrsidebranchflag StopIterationrzrrr rrev2pathr splitnewlinesr*allrrfaerrorCorruptedFileErrorr)rfrrr rrevsrokey2idxsr1rrE_linenumidxsrevlineslinenumr.ridx annotatedlinerUs rrz_annotatecontext._resolvelines8s/==nqt$n=#n--**40s6{#A d1g~a034 5 < {,4NN,<(NS'D(*,T!W5a877,, GGMM!9#(:w"=!> $00fooc6JK % 3 3DIIK @(- #&.smG&<s  $-=9&9999  GGMM?%*L    S !$$S&//#*>?D..I'' 4E5zS^+001NOO$U+4aL='{&*s  +  ,Wb o>!   sJA J J-,J-cTt|tr|}n|j}|jj |}|s!t j dt|z|jj|tjzdk7r!t j dt|z|jj||jjDcgc]"\}}|jj||f$}}}|j||||Scc}}w)alike 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 revmaprs%s is not in revmap mainbranch)rBrrrrrrrrrrr rrrr) rfr#rrrrrrros rrz!_annotatecontext.annotatedirectlyys a C&&(C ##C(,,-Cc#h-NO O KK  ')*B*B Bq H,,1CH<  e$48LL4O4O 4ODAqT[[  #Q '4O  ))&!XyII s&'D$c|r|j|}|rt|trG|jj |}|j ||jj |}n|}tj|j}t|t|k7rtj||f}|S)znadd the missing path or line contents, they can be expensive. f could be either node or fctx. ) rrBrrrrrr rr*rrr)rfror#rrrr.rs rrz&_annotatecontext._refineannotateresults **62F !U# ++A.((DKK,@,@,GH'' 4E5zS[(0022e_F rcV|j|j|j|||yr)rr r)rfr.r8rs rrz_annotatecontext._appendrevs  $,, T6:NrcXtj|||jjSr)r allblocksrgrV)rfrrs rrz_annotatecontext._diffblockssq!TYY%7%788rc pfd}g}i}|@|D];\\}} } } } | dk7s||| | D cgc]\} }t| ts| c}} z }=t|}||vr|j||D] } || || <j |j |j }|||<t|D]j\\}} } } } | dk(r||j||| | | )|| | Dcgc]\}}t|tr|n|||f }}}|j||| |lycc}} wcc}}w)z'append a revision to linelog and revmapct|trtjd|j }j |}|"j |d|j}|S)z (fctx) -> intsf should not be an intT) sidebranchr)rBrCr ProgrammingErrorrrrr)r#rrErs rgetllrevz/_annotatecontext._doappendrev..getllrevs^!S!,,-FGG&&(C..%C{mmCDqvvxmHJrNr4rP) rBrCrremoverrrr replacelinesreplacelines_vec)r rr.r8rr siderevs siderevmapr9r:r;r<opr#rrrbliness ` rrz_annotatecontext._doappendrevsw   !(.$ RR":$.r"$5!$5DAq)!S1$5!H)/x= 8  OOD !A$QKJqM diik < 4$,V$4 RRbTz!$$UBB;!+2b 1 11&a-a:a=1E 1((B?%5!*s D, /#D2c v jfd}|Dcgc]\}}||||fc}}Scc}}w)z6(revmap, [(node, linenum)]) -> [(node, linenum, path)]cjj|}|/jj|}|j|<|Sr)rrerr)nodeidrrrfs r_getpathz3_annotatecontext._addpathtoresult.._getpathsF??&&v.D|v~~f'=>*.'Kr)r)rfrrrnrs` ` rrz!_annotatecontext._addpathtoresults? >[[F 1??1Ax{#???s5c|d}n?|jj|j}|stj|j j |k7rtjy)z:check if fctx is the master's head last time, raise if notNr)rrrrCannotReuseErrorr r)rfr.rs rrz%_annotatecontext._checklastmasterheads^ <EKK'' 4E..00 <<  % '**, , (rcn|jj|jjfd}|S)z-> (fctx) -> [fctx]c0t|}s|dd}|S)N)r$r)r')r#r%rmrls rr z-_annotatecontext._parentfunc..parentss"!L1BVIr)rgrlrm)rfr rmrls @@rrz_annotatecontext._parentfuncs/yy-- ii++   rc:|jjddS)N fastannotatesperfhack)rz configboolrs rrz_annotatecontext._perfhacksww!!/;??rc Nt|j||xs |jfi|Sr)rMrr)rfrErkwdss rrz_annotatecontext._resolvefctxs#499cD,=DIIG$GGrT)NFF)FFr)rrrsrtruripropertyr rr__del__rrrrrrrrrrr staticmethodrrrrrvrrrr5rrrxrxs    !G: ==!F@PD.6p?BJ.$O9/@/@b @ -    @@Hrrxc\|D]} tj|y#t$rY'wxYw)zsilent, best-effort unlinkN)runlinkOSError)pathsrs rrr s1  KK    s  ++cPeZdZdZefdZedZedZdZ edZ y) pathhelperz9helper for getting paths for lockfile, linelog and revmapctjjd|jt ||_||_y)Nr)rrjoinrqrQ_vfspathr")rfrrrgs rrizpathhelper.__init__s. T]]IdO   rctjj|jjj |j Sr)rrdirnamer"vfsr*r+rs rr-zpathhelper.dirnames,wwtzz~~224==ABBrcf|jjj|jdzS)Ns.lr"r.r*r+rs rr{zpathhelper.linelogpath $zz~~""4==5#899rcptj|jj|jdzS)Ns.lock)lockmodr r"r.r+rs rr zpathhelper.lock$s$||DJJNNDMMH,DEErcf|jjj|jdzS)Ns.mr0rs rr|zpathhelper.revmappath'r1rN) rrrsrtru defaultoptsrir r-r{r r|r5rrr(r(sQC(3CC::F::rr(c#Kt|||}tj|j|j}|j }d} |j 5t|||||}|r|j|ddd||jyy#1swYxYw#t$r2||j|jjd|zwxYw#||jwwxYww)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(rmakedirsr-r|r{r rxr Exceptionrzrr)rrrgrhelperr|r{actxs rannotatecontextr;,s dD )FMM&..!""J$$K D  [[]#D$ ZND J    JJL ]    LLN  ELM    JJL sBAC> B(&BB(C>B%!B((;C##C&&C;;C>c|j}|j}|jjdddrd}t ||}t ||||S)zdlike annotatecontext but get the context from a fctx. convenient when used in fctx.annotate rs forcefollowT)rVrl)r"_pathrzrrar;)r.r$rVrrraoptss rfctxannotatecontextr?QsN ::D ::D ww/>4@ ( @E 4ug 66rr)FN)TNF)1r contextlibrmercurial.i18nrmercurial.pycompatrrrmercurial.noderrr mercurialr r rr r3r rrrmercurial.utilsrrrrr lrucachefuncrr'r2r> revsinglerDrMrQr_r5rnrarxrr(contextmanagerr;r?r5rrrJs      .9T  w00 1 )Z7#5#4#45$$Dn HHD::4 %0%!!H 7r