6h^ SrSSKJr SSKrSSKJr SSKJrJr SSK J r J r J r J r JrJrJrJrJrJrJrJrJrJrJr SSKJr Sr0r\R:"\5r0r\R>"\5r\"S S S S 9 \"S S SS 9 \"S SSS 9 SSSS.r \RBr!"SS5r""SS5r#Sr$S4Sjr%S4Sjr&"SS\RN5r(S5Sjr)"SS5r*"S S!5r+S"r,S#r-S5S$jr.\"S S%S&S\"S'54S(S)S\"S*54S+S,S\"S-54S.S/S\"S054/\ R^-\ R`-\ Rb-\"S15\RdS S29S35r3g)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 ) annotationsN)_)hexshort)cmdutilcommandscontextcrecorderrorlinelogmdiffobsoletepatchphasespycompat registrar rewriteutilscmutilutil) stringutilsships-with-hg-coreabsorb add-noiseTdefaults amend-flagmax-stack-size2syellows blue boldsbold)absorb.description absorb.node absorb.pathc*\rSrSrSrSrSrSrSrSr g)nulluiWzblank ui object doing nothingFTc SnU$)NcgN)argskwdss ./usr/lib/python3/dist-packages/hgext/absorb.pynullfunc$nullui.__getitem__..nullfunc_s r&)namer*s r) __getitem__nullui.__getitem__^s r,r&N) __name__ __module__ __qualname____firstlineno____doc__ debugflagverbosequietr.__static_attributes__r&r,r)r!r!Ws'IG Er,r!c*\rSrSrSrSrSrSrSrg)emptyfilecontextez.minimal filecontext representing an empty filecXlgr%_repo)selfrepos r)__init__emptyfilecontext.__init__hs r,cg)Nr,r&r?s r)dataemptyfilecontext.dataksr,c.URR$r%)r>nullidrDs r)nodeemptyfilecontext.nodenszz   r,r=N) r0r1r2r3r4rArErIr8r&r,r)r:r:es8!r,r:c[5n/nUH,nX1;dM URU5 URU5 M. U$)z@list -> list. remove duplicated items without changing the order)setaddappend)lstseenresultxs r)uniqrSrs; 5D F  = HHQK MM!  Mr,cTUn/nUR5[R:waqU(a[U5U:aOZUR 5n[U5S:waO:UR U5 USnUR5[R:waMqUR 5 U$)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)phaserpubliclenparentsrNreverse)headctxlimitctxrQrYs r) getdraftstackr^}s C F ))+ & S[E) ++- w<1   caj ))+ & NN Mr,cUc [5nU(deXS;a/04$/n0nUSR5n[U5H`nX;aUn OXXanURU5 Xr;aSn O:XtU'UR 5nU(dMGUnX;dMPUR5n O UbAX;aURXQ5 O(UR[ UR 555 UR5 [U5U4$)a([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) rLp1reversedrN copysourcer:r@rZrS) stackpath seenfctxsfctxsfctxmappctxr]fctxcopys r) getfilestackrlsJE L5 92v EG 8;;=D ?D y T  D    4D{vvx"  < LL $ LL)$))+6 7 MMO ; r,c$\rSrSrSrSrSrSrg) overlaystorezkread-only, hybrid store based on a dict and ctx. memworkingcopy: {path: content}, overrides file contents. cXlX lgr%basectxmemworkingcopy)r?rrrss r)rAoverlaystore.__init__s  ,r,cXR;agURUnXR;aURUnOUR5nUR5UR 54nUR 5nX4U4$)z-comply with mercurial.patch.filestore.getfileNNN)rrrsrEislinkisexecrc)r?rerjcontentmoderks r)getfileoverlaystore.getfilesq || ##||D! && &))$/GiikG t{{}- d""r,rqN)r0r1r2r3r4rAr{r8r&r,r)rnrns- #r,rnc Uc7UR5RRUR55nUcUR 5nUcUR 5nUR 5nUR5n[UR55RU5n[X5n[R"UR5UUUUUUSUS9 $)za({path: content}, ctx, (p1node, p2node)?, {}?) -> memctx memworkingcopy overrides file contents. N) r@rYtextfiles filectxfnuserdatebranchextra)r@ changelogrYrIr descriptionrrrLrunionrnr memctx) rsr]rYrdescrrrstores r)overlaycontextrs ((*&&..sxxz: }  |  88:D 88:D   " "> 2E  -E >> XXZ     r,c|\rSrSrSrSSjrSSjrSrSrSr \ S 5r S r S r S rS rSSjrSrSrSrg)filefixupstateiastate 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 XlX lU=(d [5UlX@lUVs/sHoUR 5PM snUl[R"[RUR 5Ul UR5Ul URR(a UR5UR :XdeSS/Ul/Ul/Ul/Ul[)5Ulgs snf)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)rgrer!uioptsrEcontentsrmaplistr splitnewlines contentlines _buildlinelogr r5_checkoutlinelog chunkstats targetlinesfixups finalcontentsrL ctxaffected)r?rgrerrfs r)rAfilefixupstate.__init__/s   . ,115a51 $,,U-@-@$--P))+ 77  ((*dmm; ;;a& 52sDcURSnURSnUR5n[R"U5nX`lUR RUR R5 UR Rn[U5[U5:XdeU(a$USSUSSS-4nURU5 URX5XF5Hxn URX5n URS==[U 5- ss'URS==S- ss'U=R U - slUcMeUR#X$XiU 5 Mz g)a{calculate fixups needed by examining the differences between self.fctxs[-1] and targetfctx, chunk by chunk. targetfctx is the target state we move towards. we may or may not be able to get there because not all modified chunks can be amended into a non-public fctx unambiguously. call this only once, before apply(). update self.fixups, self.chunkstats, and self.targetlines. r`rrUN)rrrEr rrr annotatemaxrevannotateresultrXrN_alldiffchunks_analysediffchunkrboolr _showchanges) r? targetfctxfmaalinesbblines annotated dummyendlinechunk newfixupss r)diffwithfilefixupstate.diffwithHs1 MM" ""2& OO $$Q'! dll112LL// 9~V,,, %bM!,imA.>.BCL   \ *((v>E..u@I OOA $y/ 1  OOA ! #  KK9 $K~!!"fYG ?r,c :[UR5Hupp4nURXEnURR(ai[ US- S5S-nURR [S5[URUR55X#[U54-5 URRXX4U5 M URRSS5(aUR!5UlgUR%5Ulg)z~apply self.fixups. update self.linelog, self.finalcontents. call this only once, before getfinalcontent(), after diffwith(). rUrs%s: chunk %d:%d -> %d lines edit_linesFN)rbrrrr5maxwriterrrgrIrXr replacelinesrget_checkoutlinelogwitheditsrr)r?reva1a2b1b2ridxs r)applyfilefixupstate.applyks$,DKK#8 CRR%%b,Fww  37A1, 67TZZ_1134bc&kJK LL % %crr :$9 99==u - -!%!?!?!AD !%!6!6!8D r,cVURRU5nURU$)z@(fctx) -> str. get modified file content for a given filecontext)rgindexr)r?rjrs r)getfinalcontentfilefixupstate.getfinalcontents'jjt$!!#&&r,crUup4pVX#UnU(d9U(a2U[SUS- 51nUV s/sHoU SS:wdMX)PM nn [UV V s1sHupU iM sn n 5n /n [U 5S:Xa?URX4S- S5(a%U SnUS:aUS-nU R XXEU45 OcXC- Xe- :XdXV:XaT[ X45HEn X)unnUS:dMXV:XaS=nnO XY-U- nUS-nUS-nU R XU S-UU45 MG UR U 5$s sn fs sn n f)aEanalyse 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. rrUT)rlistrX _iscontinuousrNrange_optimizefixups)r?rrrrrrinvolvednearbylinenumsirl involvedrevsrrfixuprevlinenumnb1nb2s r)r filefixupstate._analysediffchunksf&#I!#aa.1N&4&4! Q18L n 84841Q845  |  !d&8&8!VT&J&Jq/CQw7  (!;< W 282](| W7x$% c frk!Ag"QwH$$h1q5#s%CD###I../5sD.D.D3 c#d# [R"XX#S9nUHupVUS:waM Uv M g7f)z5like mdiff.allblocks, but only care about differences)lines1lines2!N)r allblocks)rrrrblocksrbtypes r)rfilefixupstate._alldiffchunkss2fD"LE}K#s.0c T[R"5nS/p2[[UR55HmnURUURUpeUS-S-nUR X%X65n[ [U55HuppURXyXU 5 M XVp2Mo U$)zncalculate the initial linelog based on self.content{,line}s. this is similar to running a partial "annotate". r,rrU) r rrXrrrrbrr) r?llogrrrrrllrevchunksrrrrs r)rfilefixupstate._buildlinelogs 6s4==)*A a($*;*;A*>vEAIE((v>F"*4<"8!!%RR8#9v + r,c./n[[UR55HpnUS-S-nURR U5 SR [ URURR55nURU5 Mr U$)z1() -> [str]. check out file contents from linelogrUrr,) rrXrr rjoinmap_getlinerrN)r?rrrrys r)rfilefixupstate._checkoutlinelogsts4==)*Aq5A+C LL ! !# &hhs4==$,,2M2MNOG OOG $ + r,c URR5n[S5URSR 5-n[ UR5VVs/sHup4[ U[5(aMX44PM! nnn[ U5HjunupdU[S5SU-S[U5U- S--[UR55UR5RSS5S4-- nMl U[S 5S[U5--- n[S 5nUHVup4URRUS-S -5 URRHnXxR!U5 M MX UHJnUS S R#UVV s/sHup9X7U;aSOSPM sn n5UR%U54-- nML UR&R)US SS9n U (d[*R,"[S55eS /[UR5-n Sn U [U5-S-n [.R0"U 5HnUR3S5(aMXS- U S -S:wa"[*R,"[S5U-5eXS -Sn[ [4R6"XU S- 55Hup?US:XdM XUS==U- ss'M! M X:wa SS/UlU $s snnfs sn nf)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: r`sHG: %s/%s %s %s |-rU rsHG: %s c[5$r%)rLr&r,r):filefixupstate._checkoutlinelogwithedits..scer,rs %s : %sr,y r)actionsempty editor textsHG:s : smalformed line: %sN)r getalllinesrrgre enumerate isinstancer:rXrrIrsplit defaultdictrrrMrrreditr InputErrorr r startswithrbytestrr)r?alllines editortextrr visiblefctxsjlinesetr_f editedtextr leftpadposcolonpos linecontentchs r)r(filefixupstate._checkoutlinelogwitheditss<<++- = jjn!!#  $ "$**- -a!12 QF-  #<0IAv !01qL)A-12affh %%eQ/2 5 J1 a ns'?!'CDDqLN+K"  1 !=>:!_Q/0K?0  1  # !fDOm 0sL;LL cfUup#US-(aURUS-U$URU$)z@((rev, linenum)) -> str. convert rev+line number to line contentrUr)rr)r?lineinforrs r)rfilefixupstate._getlines;  7$$SAX.w7 7##G, ,r,cX:agURnURU5nURU5[U5-nURXV5n[ U5X!- [U5-:H$)z(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 getoffsetintrrX)r?rrclosedintervalroffset1offset2linesinbetweens r)rfilefixupstate._iscontinuous&sg 8||..$..$s>'::))';>"bgN0C&CCCr,cL^ ^/m/SQ/m U U4Sjn[U5H}up4UupVpxn T SSn T SSn T SSn Xk:Xa@X:Xa;XZ:Xa6UR[US- S5U5(aUT SS'U T SS'MhU"5 [U5T S'M U"5 T$)zh[(rev, a1, a2, b1, b2)] -> [(rev, a1, a2, b1, b2)]. merge adjacent fixups to make them less fragmented. )r`r`r`r`r`cZ>TSSS:waTR[TS55 gg)Nrr`)rNtuple) pcurrentchunkrQsr) pushchunk1filefixupstate._optimizefixups..pushchunk>s0Q"b( eM!$456)r,rrrrU)rrrr)r?rrrrrrrrrlastrevlasta2lastb2rrQs @@r)rfilefixupstate._optimizefixups7s-.  7"&)HA"' CRR#A&q)G"1%a(F"1%a(F LN&&s261~r::') a #&( a # #'; a !*"   r,c L^^SnUupxpS/X- -S/X- -pUH]upnnn[X5Hn[U S5S- S-U UU- 'M [UU5Hn[U S5S- S-U UU - 'M M_ TR5 TRSSSXxU- XU - 4-SS 9 TR TR SS 9 UU4S jn[Xx5HnU"U UU- S U"UU5S S5 M [X5HnU"U UU - SU"UU5SS5 M g)Nc<URS5(aUSSnU$)Nrr`)endswith)lines r)trim)filefixupstate._showchanges..trimWs!}}U##CRyKr,rrUrshunks %s s@@ -%d,%d +%d,%d @@s diff.hunklabelrelinetypecj>TR5 SnU(aWTRUnTRUS9 UR5nTRR UR 55 TRSSUSS9 TRSU-SUUUS9 TRTRUS 9 g) Nr,)rjnode%-7.7s rr#s diffchar s%s%s r%) startitemrgr rrrM changectxrrEre) rdiffcharr r& linelabelrIr]rr?s r) writeline.filefixupstate._showchanges..writelineos LLNDjjo  $wwy  $$S]]_5 HHWj$nH E HHx'   GGXG 6r,rsdeleteds diff.deleted+sinserteds diff.inserted)rrr*rrEre)r?rrrrrr!rrrraidxsbidxsrfa1fa2fb1fb2rr.s`` r)rfilefixupstate._showchangesVsV sbgrwu'- #Cc33_!$S!qQ 6a"f %3_!$S!qQ 6a"f %(.     "br'2Bw%? ?  TYY1 7$rA a"f VAY  rA a"f VAY  r,) rrrrrgrrr rrerrr%)F)r0r1r2r3r4rArrrr staticmethodrrrrrrrrr8r&r,r)rrs]*!2!HF9*' 1/f BH-D">:r,rc\rSrSrSrSSjrSSjrSr\S5r Sr S r S r S r S rS rSr\SSj5rSSjr\R*S5rSr\R*S5rSrg) fixupstateiaBstate 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 U(deU=(d [5UlX0lXlUSR 5R 5Ul/UlSUl0Ul0Ul 0Ul SUl [5Ul g)z([ctx], ui or None) -> None stack: should be linear, and sorted by topo order - oldest first. all commits in stack are considered mutable. r`N)r!rrrdr@ unfilteredpathsstatusrhfixupmap replacemap finalnoderLr)r?rdrrs r)rAfixupstate.__init__ss  u.  "INN$//1     5r,cDURSRX5Ul/UlURR S5nURR (dU(aU(aUR 5nOURR n[5n[U5GHqnURRSU-5 Xn[URXv5up[SU/U -55(aM[UR5U SR5:Xa U(dMURU SS5 XRU'[!X4SUR0URD6n UbBUR#5 UR%S5 UR'S S US S 9 URS S 9 U R)X5 XR*U'URR-U5 UR.RU R.5 GMt g)z9diff and prepare fixups. update self.fixupmap, self.pathsr`rscalculating fixups for %s c3# UHWn[U[5(aMUR5=(d$ [R"UR 55v MY g7fr%)rr:rwrbinaryrE).0rs r) &fixupstate.diffwith..sC-A!!%56: 9j//99-s A!AA!rUNrsshowing changes for spath%s rr#r&)rdr>r=rrmodifiedrrLsortedrdebugrlanyrEupdaterhrr*plainrrr?rNr) r? targetctxmatchreditoptinterestingpathsrfrerrgctx2fctxfstates r)rfixupstate.diffwithsjjn++I=  ))-- -{{##E${{} #{{33 E +,D GGMM84? @"J*4::tGOE$-  E"INN$44W   U12Y '!)LL #EIDGGItyyIF~ 01'4~F) OOJ +"(MM$  JJ  d #    # #F$6$6 71-r,cURR5HWupURR(a'URR [ S5U-5 UR 5 MY g)z*apply fixups to individual filefixupstatessapplying fixups to %s N)r?itemsrr5rrrr?restates r)rfixupstate.applysL==..0KDww   a :;dBC KKM1r,cURR5VVs0sHupXR_M snn$s snnf)z>-> {path: chunkstats}. collect chunkstats from filefixupstates)r?rYrrZs r)rfixupstate.chunkstatss6;?--:M:M:OP:O;4&&&:OPPPs:crURRS5nUR5 URU5 URSR 5UR ;aUR 5 UR5 SSS5 UR$!,(df  UR$=f)z6commit changes. update self.finalnode, self.replacemapr.N) r@ transaction _commitstack_movebookmarksrIr@_moveworkingdirectoryparent_cleanupoldcommitsrA)r?trs r)commitfixupstate.commits YY " "9 -        #yy##%8002  # # % . ~~ . - ~~s A-B B6c^URnURnUR(aKUR5H6up4US(dMUR [ S5X4SUS4-5 M8 gUR (d=UR5mU4SjS5upVUR [ S5XV4-5 gg)z+print things like '1 of 2 chunk(s) applied'rs%s: %d of %d chunk(s) applied rUc3P>^# UHm[U4SjT55v M g7f)c3,># UH oTv M g7fr%r&)rFsrs r)rG7fixupstate.printchunkstats...s!61A$sN)sum)rFrstatss @r)rG-fixupstate.printchunkstats..sG1c!6!666s"&)rrUs%d of %d chunk(s) applied N)rrr6rYrrr7values)r?rrrestatappliedtotalros @r)printchunkstatsfixupstate.printchunkstatss WW__ ::(..0 77HH<=a$q'231 %%'EGGNG HHQ56'9II J r,cSnSnURGHnURU5nU(d U(dUnM'UR5=(a URXCU5nUR(a0U(a)SUR UR 5'[S5nOURXCUS9nURUnUnUR 5UR UR 5'U(a>U(a [S5nO [S5nU[U5URU54-nO[S5URU5-nURR(dGM]U(dGMgURR[S5URU5U4-5 GM U=(a UR 5Ulg)zvmake new commits. update self.finalnode, self.replacemap. it is splitted from "commit" to avoid too much indentation. Nsbecame empty and was dropped)ras&%d file(s) changed, became empty as %ss%d file(s) changed, became %ss became %ss%s: %s )rd_getnewfilecontentsr_willbecomenoopskip_empty_successorr@rIr _commitsingler@rX_ctx2strrr6rrA)r? lastcommittednextp1r]rswillbecomenoopmsgnodestrs r)rbfixupstate._commitstacksx  ::C!55c:N!- YY[T-A-AV.N((^.2 +78,,^V,L $ ' 2 &.;.@.@.B +!% IJ @AN+ m4!C L/DMM-,HHCww33 a n c0BC/HHI?@'?=+=+=+?r,cURR(a#SUR5UR54-$SUR5[ UR 554-$)Ns%d:%s)rr5rrrrI)r?r]s r)r|fixupstate._ctx2str2sL 77  swwy#'')44 4swwy% *;<< {path: str} fetch file contents from filefixupstates. return the working copy overrides - files different from ctx. )r=rhrEr?rre)r?r]rQrerUrjry newcontents r)rxfixupstate._getnewfilecontents8st JJD||D)H"=DiikGt,<.ksqr,_fsmonitorstatec(>TTRlgr%)r invalidate)bakdirstatesr)restore7fixupstate._moveworkingdirectoryparent..restoreps69((3r,)rAr@revsr@keysfirstrIrhasattrrrchanging_parentsrebuildmanifestr=)r?rr]nooprrrs @@r)rd&fixupstate._moveworkingdirectoryparent_s~~99>>"3T__5I5I5KLD))DJJL)C XXZDN))DNN+C99%% 8. / /**55C :37H $ $ / **4995  S\\^TZZH6 I65 Is$/E% :EE% E"E%% E.c(U(d%UR5n[U5S:wagUSnUR5UR5:wagUR5R S5(ag[ UR 55R[ U55(dgUR5HSupEXB;dXA;a gXnX$nUR5UR5:wa gUR5U:wdMS g g)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. rUFrscloseT) rYrXrrrrLrissubsetrYflagsrE)rsr]rirYreryrjpfctxs r)ryfixupstate._willbecomenoopzskkmG7|q 1:D ::<4;;= ( 99;??8 $ $399;((^)<==+113MD4?9DJE{{} ,zz|w&4r,c U=(a X0RR4nUR5nUR(a4URR SS5(aUR 5US'[R"UR5UR5URR5VVs0sHupgXg/_M snn5n[XXEUS9n U R5$s snnf)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)rr)r@rHr _useobsoleter configboolrrupdate_hash_refsrr@rYrrg) r?rsr]rarYroldnodenewnodermctxs r)r{fixupstate._commitsingles /"ii../    !3!3I|!L!L&)ggiE" #++ HHJ OO )-(=(=(? (?$G"(?   D {{} sC3c`[R"UR[R5$)z () -> bool)r isenabledr@createmarkersoptrDs r)rfixupstate._useobsoletes!!!$))X-F-FGGr,cURR5VVs0sH upXbU/O/_M nnnU(a"[R"URUSSS9 ggs snnf)NrT) operationfixphase)r@rYr cleanupnodesr@)r?kv replacementss r)refixupstate._cleanupoldcommitssh--/ / }" ,/      <9t    sAcD[R"URS5$)Nr)rrzrrDs r)rzfixupstate.skip_empty_successors//CCr,) rrhrAr?rr=r@r@rdr>rr%NN)r0r1r2r3r4rArrpropertyrrgrurbr|rxrcrdr8ryr{r propertycacherrerzr8r&r,r)r:r:s !*(8TQQK$)@V= $8*6:0 HH DDr,r:c[U5[R[R4;agUR R 5nUR[UR5-S- n/=Ul Ul [R"5nURU5 [R"UR!55nX R"-nUSSVs/sHofR%S5(aMUSSPM! nnXXW44$s snf)zA(crecord.uihunk or patch.recordhunk) -> (path, (a1, a2, [bline]))rrUNr)typer uihunkr recordhunkheaderfilenamefromlinerXbeforeafterrstringiorr rgetvalueremovedr)hunkrerbuf patchlinesrrrs r) _parsechunkrs Dz'..%*:*:;; ;;   !D T[[) )A -B!!DK$* --/CJJsO$$S\\^4J ll B'^ F^<<3Eeae^F F b! !!Gs D8 Dc0n[S5n[[U5H(upEU(aU(dMX4RU5 M* UR 5HjupFX@;dU(dMUR SS9 [ R"XR55nUH upn XX&M SRU5X$'Ml [X 5$)z(ctx, [crecord.uihunk]) -> memctx return a memctx with some [1] patches (chunks) applied to ctx. [1]: modifications are handled. renames, mode changes, etc. are ignored. c/$r%r&r&r,r)r$overlaydiffcontext..s2r,T)rZr,) rrrrNrYsortr rrErr) r]rrspatchmapreinfopatcheslinesrrrs r)overlaydiffcontextrsN:&H+v. 4 d#/")  ?'  T "##CINN$45%NBF!"L&"xx* . ..r,c UcURSS5nUSn[UR55S:a[R"[ S55e[ Xv5nU(a,[U5U:aUR[ S5U-5 U(d[R"[ S55eUcUSnUcS n[U4S U0UD6n[R"X4[R"U55n URS 5(av[R"XS R!5UR!5U 5n [R""U 5n [$R&"X U 5S n [)US U 5nURS5(aSUS'Sn URS5(dURS5(d&UR+S[R"U55n UR-X9U 5 U bU R/5 U R1SS[UR255 U R5SS9 [7U5HnXR2;aMU R/5 U R9US9 U R5SS9 U R1SSUR;5SS9 [<R>"URA55nU R1SSUSS9 M U RC5 URS5(dURS5(dEUR2(a4URES SS!9(a[RF"[ S"55eURI5 URK5(aURM5 U$URN(dUR1[ S#55 U$)$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`rUscannot absorb into a merges7absorb: only the recent %d changesets will be analysed sno mutable changeset to changer&r interactiver`rrT apply_changes print_changesscounts %d changesets affected ssummaryrJ)r]s changesetr(r)rr#s descfirstlinerIrdry_runs#apply changes (y/N)? $$ &Yes $$ &Norsabsorb cancelled snothing applied )( configintrXrYr rrr^warnr:rrRr byteskwargsrrdiffrI parsepatchr recordfilterr formatterrr*rrrErbr rr firstlinerend promptchoice CanceledErrorrrgrur7)rr@rdrQpatsrr\r[r[matcherr origchunksrrr] descfirstlines r)absorbrs2 } Y(9:t* w !A %""1%B#CD Dg- SZ5( GG%   q!BCDDJ  | u , ,t ,EmmIX-A-A$-GHG xx zz$b  0)..2BGL%%d+ %%bg>qA&uRy&9  xx !%_ B xx  (A(A \\)X%9%9$%? @ NN9r* ~   3S9J9J5K  $E?C+++ LLN JJ3J  GG\G * HHWj#'')>H J&001BCM HH +  #  88I  ))!!6 %%a(=&>? ? <<>>  ! ! # L HHQ+, - Lr,as apply-changess0apply changes without prompting for confirmationps print-changess;always print which changesets are modified by which changesis interactives*interactively select which chunks to applyes edit-linessGedit what lines belong to which changesets before commit (EXPERIMENTAL)shg absorb [OPTION] [FILE]...) helpcategory helpbasiccUR5 UR5 US(d[R"U5 [ X4SU0UD6n[ SUR R555S:XaSSS5 SSS5 gSSS5 SSS5 g!,(df  N=f!,(df  g=f)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. rrc3*# UH oSv M g7f)rNr&)rFrls r)rGabsorbcmd..s76t6srNrU)wlocklockrcheckunfinishedrrnrrq)rr@rrr[s r) absorbcmdrGs| tyy{I  # #D )r3d3d3 7U--4467 71 < # = #{{s)B4AB#B4B4# B1 -B44 Cr%rv)4r4 __future__r collectionsmercurial.i18nrmercurial.noderr mercurialrrr r r r r rrrrrrrrmercurial.utilsr testedwithcmdtablecommand configtable configitem colortablerr!r:rSr^rl filestorernrrr:rrr dryrunopts templateoptswalkoptsCATEGORY_COMMITTINGrr&r,r)r s4#"' #    H %  ! !+ . 9lD1 9mT2 9'4%  %%    ! !.O d#5??#.8wwt nDnDb ""/@Od      A B      L M      ; <      "   ':;<=>?@%&,,I%LM%Lr,