g dZddlZddlmZddlmZmZddlmZm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZddlmZdZiZej6eZiZej:eZedd d edd d edd d ddddZej>ZGddZ GddZ!dZ"d3dZ#d3dZ$GddejJZ&d4dZ'GddZ(Gdd Z)d!Z*d"Z+d5d#Z,edd$d%ded&fd'd(ded)fd*d+ded,fd-d.ded/fge jZze j\ze j^zed0ej`d 1d2Z1y)6a?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 N)_)hexshort)cmdutilcommandscontextcrecorderrorlinelogmdiffobsoletepatchphasespycompat registrar rewriteutilscmutilutil) stringutilsships-with-hg-coreabsorb add-noiseTdefaults amend-flagmax-stack-size2syellows blue boldsbold)absorb.description absorb.node absorb.pathc"eZdZdZdZdZdZdZy)nulluizblank ui object doing nothingFTc d}|S)NcyN)argskwdss 0usr/lib/python3.12/site-packages/hgext/absorb.pynullfuncz$nullui.__getitem__..nullfunc^s r$)namer(s r' __getitem__znullui.__getitem__]s r)N)__name__ __module__ __qualname____doc__ debugflagverbosequietr+r$r)r'r r Vs'IG Er)r c"eZdZdZdZdZdZy)emptyfilecontextz.minimal filecontext representing an empty filec||_yr#)_repo)selfrepos r'__init__zemptyfilecontext.__init__gs  r)cy)Nr)r$r7s r'datazemptyfilecontext.datajsr)c.|jjSr#)r6nullidr;s r'nodezemptyfilecontext.nodemszz   r)N)r,r-r.r/r9r<r?r$r)r'r4r4ds8!r)r4czt}g}|D])}||vs|j||j|+|S)z@list -> list. remove duplicated items without changing the order)setaddappend)lstseenresultxs r'uniqrHqs= 5D F  D= HHQK MM!  Mr)c@|}g}|jtjk7rh|rt||k\rnW|j }t|dk7rn8|j ||d}|jtjk7rh|j |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)phaserpubliclenparentsrCreverse)headctxlimitctxrFrNs r' getdraftstackrS|s C F ))+ & S[E) ++- w<1   caj ))+ & NN Mr)c| t}|sJ||dvrgifSg}i}|dj}t|D]X}||vr|}nP||}|j|||vrd}n2|||<|j }|sA|}||vsH|j}n|A||vr|j||n(|jt |j |jt||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. Nr) rAp1reversedrC copysourcer4r8rOrH) stackpath seenfctxsfctxsfctxmappctxrRfctxcopys r' getfilestackras JE L5 592v EG 8;;=D s?D 4y T 9 D    Ds{vvx"  4< LLd $ LL)$))+6 7 MMO ; r)ceZdZdZdZdZy) overlaystorezsread-only, hybrid store based on a dict and ctx. memworkingcopy: {path: content}, overrides file contents. c ||_||_yr#)basectxmemworkingcopy)r7rerfs r'r9zoverlaystore.__init__s ,r)c||jvry|j|}||jvr|j|}n|j}|j|j f}|j }|||fS)z-comply with mercurial.patch.filestore.getfileNNN)rerfr<islinkisexecrX)r7rZr_contentmoder`s r'getfilezoverlaystore.getfilesw t|| ##||D! 4&& &))$/GiikG t{{}- d""r)N)r,r-r.r/r9rmr$r)r'rcrcs- #r)rcc |7|jjj|j}||j }||j }|j }|j}t|jj|}t||}tj|j||||||d| S)zi({path: content}, ctx, (p1node, p2node)?, {}?) -> memctx memworkingcopy overrides file contents. N) r8rNtextfiles filectxfnuserdatebranchextra)r8 changelogrNr?ru descriptionrsrrrArpunionrcrmemctx) rfrRrNrudescrsrrrpstores r'overlaycontextr|s ((*&&..sxxz: }  |  88:D 88:D   " "> 2E n -E >> XXZ     r)cneZdZdZddZddZdZdZdZe dZ d Z d Z d Z d Zdd ZdZdZy)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||_||_|xs t|_|xsi|_|Dcgc]}|j c}|_tjtj|j |_ |j|_ |jjr|j|j k(sJddg|_g|_g|_g|_t)|_ycc}w)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. rN)r\rZr uioptsr<contentsrmaplistr splitnewlines contentlines _buildlinelogr r0_checkoutlinelog chunkstats targetlinesfixups finalcontentsrA ctxaffected)r7r\rZrrfs r'r9zfilefixupstate.__init__.s   .JB ,115a51 $,,U-@-@$--P))+ 77  ((*dmm; ;;a& 52sC;c|jd}|jd}|j}tj|}||_|j j|j j|j j}t|t|k(sJ|r$|dd|dddzf}|j||j||||D]x} |j| |} |jdxxt| z cc<|jdxxdz cc<|xj | z c_|d|j#|||| | zy)acalculate 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. rUrrJN)rrr<r rrr annotatemaxrevannotateresultrMrC_alldiffchunks_analysediffchunkrboolr _showchanges) r7 targetfctxfmaalinesbblines annotated dummyendlinechunk newfixupss r'diffwithzfilefixupstate.diffwithGs= MM" ""2& OO $$Q'! dll112LL// 9~V,,, %bM!,imA.>.BCL   \ *((Avv>E..ui@I OOA $y/ 1  OOA ! #  KK9 $K~!!"ffeYG ?r)c .t|jD]\}}}}}|j||}|jjrjt |dz ddz}|jj tdt|j|j||t|fz|jj||||||jjddr|j!|_y|j%|_y)zapply self.fixups. update self.linelog, self.finalcontents. call this only once, before getfinalcontent(), after diffwith(). rJrs%s: chunk %d:%d -> %d lines edit_linesFN)rWrrrr0maxwriterrr\r?rMr replacelinesrget_checkoutlinelogwitheditsrr)r7reva1a2b1b2ridxs r'applyzfilefixupstate.applyjs$,DKK#8 CRR%%b,Fww  37A1, 67TZZ_1134b"c&kJK LL % %c2r2r :$9 99== .!%!?!?!AD !%!6!6!8D r)cV|jj|}|j|S)z@(fctx) -> str. get modified file content for a given filecontext)r\indexr)r7r_rs r'getfinalcontentzfilefixupstate.getfinalcontents'jjt$!!#&&r)cT|\}}}}|||}|s1|r/|td|dz h}|D cgc]} || ddk7s|| }} t|D chc]\} } |  c} } } g} t| dk(r<|j||dz dr&| d}|dkDr|dz}| j |||||fnd||z ||z k(s||k(rTt ||D]E} || \}}|dkDs||k(rdx}}n || z|z }|dz}|dz}| j || | dz||fG|j | Scc} wcc} } w)aanalyse 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. rrJT)rlistrM _iscontinuousrCrange_optimizefixups)r7rrrrrrinvolvednearbylinenumsirl involvedrevsrrfixuprevlinenumnb1nb2s r'rz filefixupstate._analysediffchunks&BBR#I!#aa.1N&4&4 ! Q18L ! n 84841aQ845  |  !d&8&8R!VT&Jq/CQw7  (BB!;< "WR 282r](| W7Rx$% c 1frk!Ag"QwH$$h1q5#s%CD###I../5sDD D$ c#fKtj||||}|D]\}}|dk7r |yw)z5like mdiff.allblocks, but only care about differences)lines1lines2!N)r allblocks)rrrrblocksrbtypes r'rzfilefixupstate._alldiffchunkss9AfVD"LE5}K#s/1c ^tj}dg}}tt|jD]s}|j||j|}}|dzdz}|j ||||}t t|D]\} } } } |j|| | | | ||}}u|S)z~calculate the initial linelog based on self.content{,line}s. this is similar to running a partial "annotate". r)rrJ) r rrMrrrrWrr) r7llogrrrrrllrevchunksrrrrs r'rzfilefixupstate._buildlinelogs 6s4==)*A a($*;*;A*>vAEAIE((Avv>F"*4<"8BB!!%RR8#96vA + r)c*g}tt|jD]o}|dzdz}|jj |dj t |j|jj}|j|q|S)z1() -> [str]. check out file contents from linelogrJrr)) rrMrr rjoinmap_getlinerrC)r7rrrrks r'rzfilefixupstate._checkoutlinelogsts4==)*Aq5A+C LL ! !# &hhs4==$,,2M2MNOG OOG $ + r)c |jj}td|jdj z}t |jDcgc]\}}t |ts||f}}}t |D]j\}\}}|tdd|zdt||z dzzt|j|jjdddfzz }l|td dt|zzz }td }|D]U\}}|jj|dzd z|jjD]}||j!|W|D]F}|d d j#|D cgc]\}} |||vrdndc} }|j%|fzz }H|j&j)|d d} | st+j,tdd gt|jz} d} | t|zdz} t/j0| D]}|j3dr|| dz | d zdk7r!t+j,td|z|| d zd}t t5j6|| | dz D]\}}|dk(s | ||dxx|z cc< | |k7r ddg|_| Scc}}wcc} }w)z&() -> [str]. prompt all lines for editsZHG: editing %s HG: "y" means the line to the right exists in the changeset to the top HG: rUsHG: %s/%s %s %s |-rJ rsHG: %s ctSr#)rAr$r)r'z:filefixupstate._checkoutlinelogwithedits..scer)rs %s : %sr)y r)actionsempty editor textsHG:s : smalformed line: %sN)r getalllinesrr\rZ enumerate isinstancer4rMrr?rwsplit defaultdictrrrBrrreditr InputErrorr r startswithrbytestrr)r7alllines editortextrr visiblefctxsjlinesetr_f editedtextr leftpadposcolonpos linecontentchs r'rz(filefixupstate._checkoutlinelogwitheditss<<++- = jjn!!#  $ "$**- -1a!12F-  #<0IAv1 !01qL)A-12affh %%eQ/2 5 J1 a ns'?!'CDDHqLN+K"  :1 !=>2:\!_Q/0K?0  1  # !fDOm 0s K%K+c^|\}}|dzr|j|dz|S|j|S)z@((rev, linenum)) -> str. convert rev+line number to line contentrJr)rr)r7lineinforrs r'rzfilefixupstate._getlines= W 7$$SAX.w7 7##G, ,r)c||k\ry|j}|j|}|j|t|z}|j||}t |||z t|zk(S)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 getoffsetintrrM)r7rrclosedintervalroffset1offset2linesinbetweens r'rzfilefixupstate._iscontinuous%sm 8||..$..$s>'::))'7;>"b2gN0C&CCCr)c@ ggdg fd}t|D]y\}}|\}}}}} dd} dd} dd} || k(r:|| k(r5|| k(r0|jt|dz d|r| dd<| dd<e|t| d<{|S)zx[(rev, a1, a2, b1, b2)] -> [(rev, a1, a2, b1, b2)]. merge adjacent fixups to make them less fragmented. )rUrUrUrUrUcXdddk7rjtdyy)NrrU)rCtuple) pcurrentchunkrFsr' pushchunkz1filefixupstate._optimizefixups..pushchunk=s0Q"b( eM!$456)r)rrrrJ)rrrr)r7rrrrrrrrrlastrevlasta2lastb2rrFs @@r'rzfilefixupstate._optimizefixups6s-.  7"&)HAu"' CRR#A&q)G"1%a(F"1%a(Ff &L7N&&s261~r:') a #&( a # #'; a !*"   r)c Xd}|\}}} } dg||z zdg| | z z} } |D]Z\} }}}}t||D]}t| ddz dz| ||z <t||D]}t| ddz dz| || z <\jjddd|||z | | | z fzd j j d fd }t||D]}|| ||z d |||d dt| | D]}|| || z d|||ddy)Nc2|jdr|dd}|S)NrrU)endswith)lines r'trimz)filefixupstate._showchanges..trimVs}}U#CRyKr)rrJrshunks %s s@@ -%d,%d +%d,%d @@s diff.hunklabelrZlinetypecxjd}|rZj|}j||j}jj |j jdd|djd|zd|||jj| y) Nr))r_node%-7.7s rrs diffchar s%s%s r) startitemr\rrrrB changectxrr<rZ) rdiffcharrr linelabelr?rRrr7s r' writelinez.filefixupstate._showchanges..writelinens LLNDjjo  $wwy  $$S]]_5 HHWj$nH E HHx'   GGXG 6r)rsdeleteds diff.deleted+sinserteds diff.inserted)rrr rr<rZ)r7rrrrrrrrrraidxsbidxsrfa1fa2fb1fb2rrs`` r'rzfilefixupstate._showchangesUsl BBsb2grBwu'- #Cc33_!$S!qQ 6a"f %3_!$S!qQ 6a"f %(.     "b"r'2rBw%? ?  TYY1 7$r2A a"f VAY  r2A a"f VAY  r)NNr#)F)r,r-r.r/r9rrrr staticmethodrrrrrrrrr$r)r'r~r~s]*!2!HF9*' 1/f BH-D">:r)r~ceZdZdZddZddZdZedZdZ dZ d Z d Z d Z d Zd ZeddZddZej(dZdZej(dZy) 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|sJ|xs t|_|xsi|_||_|dj j |_g|_d|_i|_i|_ i|_ d|_ t|_ y)z([ctx], ui or None) -> None stack: should be linear, and sorted by topo order - oldest first. all commits in stack are considered mutable. rUN)r rrrYr8 unfilteredpathsstatusr]fixupmap replacemap finalnoderAr)r7rYrrs r'r9zfixupstate.__init__s{  u.JB  "INN$//1     5r)c"|jdj|||_g|_|jj d}|jj s|r|r|j }n|jj }t}t|D]o}|jjd|z||}t|j||\} } td|g| zDrX|j| djk(r|s|j| dd| |j|<t!| ||j|j} |H|j#|j%d|j'd d |d |jd | j)||| |j*|<|jj-||j.j| j.ry)z9diff and prepare fixups. update self.fixupmap, self.pathsrUrscalculating fixups for %s c3K|]I}t|ts7|jxs#tj|j Kywr#)rr4rirbinaryr<).0rs r' z&fixupstate.diffwith..sB-A!!%56 9j//99-sAArJNrrsshowing changes for spath%s rrr)rYrrrrmodifiedrprAsortedrdebugraanyr<updater]r~r plainrrr rCr) r7 targetctxmatchreditoptinterestingpathsr[rZrr\ctx2fctxfstates r'rzfixupstate.diffwithsjjn++Iu=  ))-- .{{##E${{} #{{33 E +,D GGMM84? @"4J*4::tYGOE8$-  E"INN$44W   U12Y '!)DLL #E4DGG$))LF~ 01'4~F) OOJ +"(DMM$  JJ  d #    # #F$6$6 71-r)c|jjD]R\}}|jjr'|jj t d|z|j Ty)z*apply fixups to individual filefixupstatessapplying fixups to %s N)r itemsrr0rrrr7rZstates r'rzfixupstate.applysN==..0KD%ww   a :;dBC KKM1r)c~|jjDcic]\}}||jc}}Scc}}w)z>-> {path: chunkstats}. collect chunkstats from filefixupstates)r r8rr9s r'rzfixupstate.chunkstatss:;?--:M:M:OP:O;4e&&&:OPPPs9cd|jjd5}|j|j||jdj |j vr|j |jddd|jS#1swY|jSxYw)z6commit changes. update self.finalnode, self.replacemapr.N) r8 transaction _commitstack_movebookmarksr?r!_moveworkingdirectoryparent_cleanupoldcommitsr")r7trs r'commitzfixupstate.commits YY " "9 -        #yy##%8002  # # % . ~~ . ~~s A+BB/cl|j}|j}|jrE|jD]1\}}|ds |j t d||d|dfz3y|j s>|jfddD\}}|j t d||fzyy)z+print things like '1 of 2 chunk(s) applied'rs%s: %d of %d chunk(s) applied rJc3HK|]tfdDyw)c3(K|] }| ywr#r$)r&srs r'r'z7fixupstate.printchunkstats...s!61!A$sN)sum)r&rstatss @r'r'z-fixupstate.printchunkstats..sG1c!6!66s")rrJs%d of %d chunk(s) applied N)rrr1r8rrr2values)r7rrrZstatappliedtotalrJs @r'printchunkstatszfixupstate.printchunkstatss WW__ ::(..0 d7HH<=a$q'231 %%'EGGNGU HHQ56'59II J r)cDd}d}|jD]s}|j|}|s|s|}|jxr|j|||}|jr+|r)d|j |j <td}n|j|||}|j|}|}|j |j |j <|r9|r td}n td}|t||j|fz}ntd|j|z}|jjs8|s<|jjtd|j||fzv|xr|j |_y)zmake new commits. update self.finalnode, self.replacemap. it is splitted from "commit" to avoid too much indentation. Nsbecame empty and was dropped)rVs&%d file(s) changed, became empty as %ss%d file(s) changed, became %ss became %ss%s: %s )rY_getnewfilecontentsrp_willbecomenoopskip_empty_successorr!r?r _commitsingler8rM_ctx2strrr1rr")r7 lastcommittednextp1rRrfwillbecomenoopmsgnodestrs r'r?zfixupstate._commitstacksx  ::C!55c:N!- YY[T-A-AV.N((^.2 +78,,^SV,L $ ' 2 &.;.@.@.B +!% IJ @AN+ m4!C L/DMM-,HHCww3 a n c0BC/HHI?@'?=+=+=+?r)c|jjr#d|j|jfzSd|jt |j fzS)Ns%d:%s)rr0rrrr?)r7rRs r'rUzfixupstate._ctx2str1sL 77  swwy#'')44 4swwy% *;<< {path: str} fetch file contents from filefixupstates. return the working copy overrides - files different from ctx. )rr]r<r rrZ)r7rRrFrZr5r_rk newcontents r'rQzfixupstate._getnewfilecontents7s| JJD||D)H("C=DiikGt,<.jsqr)_fsmonitorstatec(j_yr#)rf invalidate)bakdirstatesr'restorez7fixupstate._moveworkingdirectoryparent..restoreos69((3r))r"r8revsr!keysfirstr?rjr safehasattrrfrhchanging_parentsrebuildmanifestr)r7rlrRnooprkrirjs @@r'rAz&fixupstate._moveworkingdirectoryparent^s~~99>>"3T__5I5I5KLD))DJJL)C XXZDN))DNN+C99%%   H&7 8**55C :37H $ $ / **4995  S\\^TZZH6 I65 Is$.E :EEEE E(c|s$|j}t|dk7ry|d}|j|jk7ry|jj dryt |j jt |sy|jD]Q\}}||vs||vry||}||}|j|jk7ry|j|k7sQyy)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. rJFrscloseT) rNrMrtrurrArpissubsetr8flagsr<)rfrRr^rNrZrkr_pfctxs r'rRzfixupstate._willbecomenoopyskkmG7|q 1:D ::<4;;= ( 99;??8 $399;((^)<=+113MD'44s?t9DJE{{} ,zz|w&4r)c |xr||jjf}|j}|jr/|jj ddr|j |d<tj|j|j|jjDcic] \}}||g c}}}t|||||} | jScc}}w)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. rrs absorb_source)rurz)r8r>ru _useobsoleter configboolrrupdate_hash_refsrwr!r8r|rD) r7rfrRrVrNruoldnodenewnoderzmctxs r'rTzfixupstate._commitsingles /"dii../    !3!3I|!L&)ggiE" #++ HHJ OO )-(=(=(? (?$GW'"(?   CD {{} s2C(c^tj|jtjS)z () -> bool)r isenabledr8createmarkersoptr;s r'ryzfixupstate._useobsoletes!!!$))X-F-FGGr)c|jjDcic] \}}|||gng}}}|r$tj|j|ddyycc}}w)NrT) operationfixphase)r!r8r cleanupnodesr8)r7kv replacementss r'rBzfixupstate._cleanupoldcommitssl--/ /1 q}" ,/      <9t    sAcBtj|jdS)Nr)rrSrr;s r'rSzfixupstate.skip_empty_successors//CCr)rr#)r,r-r.r/r9rrpropertyrrDrOr?rUrQr@rArrRrTr propertycacheryrBrSr$r)r'rrs !*(8TQQK$)@V= $8*6:0 HH DDr)rct|tjtjfvry|j j }|jt|jzdz }gx|_ |_ tj}|j|tj|j!}||j"z}|ddDcgc]}|j%dr|dd}}||||ffScc}w)zA(crecord.uihunk or patch.recordhunk) -> (path, (a1, a2, [bline]))rrJNr)typer uihunkr recordhunkheaderfilenamefromlinerMbeforeafterrstringiorr rgetvalueremovedr)hunkrZrbuf patchlinesrrrs r' _parsechunkrs Dz'..%*:*:;; ;;   !D T[[) )A -B!!DK$* --/CJJsO$$S\\^4J dll B'^ F^1<<3Eae^F F "b&! !!Gs C?/C?ci}td}tt|D]\}}|r|s ||j| |j D]h\}}||vs|s |j dt j||j}|D] \}} } | |||  dj|||<jt||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. cgSr#r$r$r)r'rz$overlaydiffcontext..s2r)T)rOr)) rrrrCr8sortr rr<rr|) rRrrfpatchmaprZinfopatcheslinesrrrs r'overlaydiffcontextrsN:&H+v. d4 d#/") g s?'  T "##CINN$45%NBF!E"RL&"xxt* .# ..r)c||jdd}|d}t|jdkDrtjt dt ||}|r+t||k\r|jt d|z|stjt d||d}|d }|i}t||| }tj|||} |jd rutj||d j|j| } tj| } t!j"|| | d } t%|d | }|jdrd|d<d} |jds|jds|j'd|} |j)|| | | | j+| j-ddt|j.| j1dt3|D]}||j.vr| j+| j5|| j1d| j-dd|j7dt9j:|j=}| j-dd|d| j?|jds|jds=|j.r1|jAd d!rtjBt d"|jE|jGr|jI|S|jJs|j-t d#|S)$zpick 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. Nrrr=rJscannot absorb into a merges7absorb: only the recent %d changesets will be analysed sno mutable changeset to changer$r( interactiverUrrTs apply_changess print_changesscounts %d changesets affected ssummaryr*)rRs changesetr r rrs descfirstliner)rdry_runs#apply changes (y/N)? $$ &Yes $$ &Norsabsorb cancelled snothing applied )& configintrMrNr rrrSwarnrrr2rrdiffr? parsepatchr recordfilterr formatterrr rrr<rWrrr firstlinerwend promptchoice CanceledErrorrrDrOr2)rr8rYr1patsrrQrPr:matcherr origchunksrrrR descfirstlines r'absorbrs } Y(9:t* w !A %""1%B#CD Dgu- SZ5( GG%   q!BCDDJ  | | u$ /EmmItT2G xxzz$b  0)..2BGL%%d+ %%b*g>qA&uRy&9  xx "&  B xx !2B)C \\)T * NN9gr* ~   3S9J9J5K  $E?C%+++ LLN JJ3J  GG\G * HHWj#'')>H J&001BCM HH +  #  88J )*!!6 %%a(=&>? ? <<>  ! ! # L HHQ+, - Lr)as apply-changess0apply changes without prompting for confirmationps print-changess;always print which changesets are modified by which changesirs*interactively select which chunks to applyes edit-linessGedit what lines belong to which changesets before commit (EXPERIMENTAL)shg absorb [OPTION] [FILE]...) helpcategory helpbasicctj|}|j5|j5|dst j |t ||||}td|jjDdk(r ddddddy ddddddy#1swYxYw#1swYyxYw)aincorporate 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)rrc3&K|] }|d yw)rNr$)r&rHs r'r'zabsorbcmd..s76qt6srNrJ) r byteskwargswlocklockrcheckunfinishedrrIrrK)rr8rrr:s r' absorbcmdrGs|    %D tyy{J  # #D )r4d6 7U--4467 71 < # = #{{s)B>AB2B>!B>2B; 7B>>Cr#rh)NNNN)2r/ collectionsmercurial.i18nrmercurial.noderr mercurialrrrr r r r r rrrrrrrmercurial.utilsr testedwithcmdtablecommand configtable configitem colortablerr r4rHrSra filestorercr|r~rrrr dryrunopts templateoptswalkoptsCATEGORY_COMMITTINGrr$r)r'rs6"' #  )  H % !Y ! !+ . 9lD1 9mT2 9'4%  %%    ! !.O d#5??#.8wwt nDnDb ""/@Pf      A B      L M      ; <      "   ':;<=>?@%&,,I%L M%L r)