6h;SSKJr SSKrSSKrSSKJr \R (aSSKrSSKJrJ r \ R"S5r Sr Sr \R"S5r\R"S 5r\ \R":Xde\ \R":XdeS rS rS rS r\R,"SS55rSrSrSrSrSrg)) annotationsN)attr)errorpolicyparsers,z >LLLLL4s20sz>LHHLHLLLLHllli cX[RU5unnnnnn n [XX$U5 g)a&parse a full v2-dirstate from a binary data into dictionaries: - map: a {path: entry} mapping that will be filled - copy_map: a {path: copy-source} mapping that will be filled - data: a binary blob contains v2 nodes data - tree_metadata:: a binary blob of the top level node (from the docket) N) TREE_METADATAunpack parse_nodes) mapcopy_mapdata tree_metadataroot_nodes_startroot_nodes_len_nodes_with_entry_count_nodes_with_copy_source_count_unreachable_bytes_unused_ignore_patterns_hashs nodes from starting at offset This is used by parse_dirstate to recursively fill `map` and `copy_map`. All directory specific information is ignored and do not need any processing (DIRECTORY, ALL_UNKNOWN_RECORDED, ALL_IGNORED_RECORDED) N) range NODE_SIZEslice_with_lenNODEr r r DirstateItem from_v2_data any_tracked)rrrstartleni node_start node_bytes path_startpath_len_basename_startcopy_source_startcopy_source_lenchildren_startchildren_count_descendants_with_entry_count_tracked_descendants_countflagssizemtime_smtime_nsitempaths rr r Zs3ZY]* #Di@  KK #        ) &     C4H##00gxP d9D  +HTN9rcXX-$N)rr$r%s rrrs  $$rc\rSrSr\R "5r\R "5r\R "SS9r\R "SS9r \R "SS9r \R "SS9r \R "SS9r Sr Srg)NodeN)defaultrcURnURU5nURnUn[U5nUR S5S-nUbU[U5-n [U5n OSn Sn UbUR 5uppO [ n Sn Sn Sn[RUUUU U URURURURU U U U5 $)N/r) r7getentryr%rfindv2_dataDIRSTATE_V2_DIRECTORYr packchildren_offsetr/descendants_with_entrytracked_descendants)selfr paths_offsetr7copyrCr)r*basename_startr,r-r2r3r4r5s rrG Node.packsyy||D! ! t9D)A-   ,s4y 8 !$iO ! O  -2]]_ *E(*EDGHyy           ' '  $ $      rr:)__name__ __module__ __qualname____firstlineno__ribr7rCparentr/rHrIrJrG__static_attributes__r:rrr<r<se 779D GGIE WWT "FWWQ'Ngga(O!WWQ/''!,$ rr<c [5nSnSnSnSnSnSnSn [U5S:Xa[RUUUUUUU 5n X*4$[ UR 5SS9n /n [ SS5n U RU 5 [U S5GHhununnUS- nX;aUS- n[U5n[UX5n U =RS- sl UR(aU =RS- sl U =RS- slU R[ UUU 55 S nSnU[U 5:aXSn[UU5(+nU(dM[!XX,5 U (dMU R"S:wdMU R$nUSL=(a" [U[U S R"55nUbU(aGM=[!UXU 5 Un U (dGMVU R"S:waMqGMk U R'5n U R"S:XdU R"5e[U 5S:Xd[U 55e[RU R(U RUUUUU 5n X*4$) aA Pack `map` and `copy_map` into the dirstate v2 binary format and return the tuple of (data, metadata) bytearrays. The on-disk format expects a tree-like structure where the leaves are written first (and sorted per-directory), going up levels until the root node and writing that one to the docket. See more details on the on-disk format in `mercurial/helptext/internals/dirstate-v2`. Since both `map` and `copy_map` are flat dicts we need to figure out the hierarchy. This algorithm does so without having to build the entire tree in-memory: it only keeps the minimum number of nodes around to satisfy the format. # Algorithm explanation This explanation does not talk about the different counters for tracked descendants and storing the copies, but that work is pretty simple once this algorithm is in place. ## Building a subtree First, sort `map`: this makes it so the leaves of the tree are contiguous per directory (i.e. a/b/c and a/b/d will be next to each other in the list), and enables us to use the ordering of folders to have a "cursor" of the current folder we're in without ever going twice in the same branch of the tree. The cursor is a node that remembers its parent and any information relevant to the format (see the `Node` class), building the relevant part of the tree lazily. Then, for each file in `map`, move the cursor into the tree to the corresponding folder of the file: for example, if the very first file is "a/b/c", we start from `Node[""]`, create `Node["a"]` which points to its parent `Node[""]`, then create `Node["a/b"]`, which points to its parent `Node["a"]`. These nodes are kept around in a stack. If the next file in `map` is in the same subtree ("a/b/d" or "a/b/e/f"), we add it to the stack and keep looping with the same logic of creating the tree nodes as needed. If however the next file in `map` is *not* in the same subtree ("a/other", if we're still in the "a/b" folder), then we know that the subtree we're in is complete. ## Writing the subtree We have the entire subtree in the stack, so we start writing it to disk folder by folder. The way we write a folder is to pop the stack into a list until the folder changes, revert this list of direct children (to satisfy the format requirement that children be sorted). This process repeats until we hit the "other" subtree. An example: a dir1/b dir1/c dir2/dir3/d dir2/dir3/e dir2/f Would have us: - add to the stack until "dir2/dir3/e" - realize that "dir2/f" is in a different subtree - pop "dir2/dir3/e", "dir2/dir3/d", reverse them so they're sorted and pack them since the next entry is "dir2/dir3" - go back up to "dir2" - add "dir2/f" to the stack - realize we're done with the map - pop "dir2/f", "dir2/dir3" from the stack, reverse and pack them - go up to the root node, do the same to write "a", "dir1" and "dir2" in that order ## Special case for the root node The root node is not serialized in the format, but its information is written to the docket. Again, see more details on the on-disk format in `mercurial/helptext/internals/dirstate-v2`. rssc*USRS5$)Nrr@)split)xs rpack_dirstate..s1Q4::d3Cr)keyrNrAT) bytearrayr%r rGsorteditemsr<append enumerate get_foldermove_to_correct_node_in_treer/trackedrJrI is_ancestorpack_directory_childrenr7rUpoprH)rrrrrnodes_with_entry_countnodes_with_copy_source_countunreachable_bytesunusedignore_patterns_hashr sorted_mapstack current_nodeindexr7rCcurrent_folder should_pack next_pathrUin_ancestor_of_next_paths r pack_dirstaterwsV ;DN#$  F' 3x1}%**   " (    "" )CDJ ET?L LL )*a 8}e!#   (A - (#D)3 L  ##q(# ==  , , 1 ,++q0+ T$|45  3z? "#)!,I))^DDK ; #LD H%L--4&,,+4D+@, :eBinn+EF)>%='F% %L--443!9N99;L    #6\%6%66 # u:?&CJ&?!&&$$##$M  rc<SU;aURSS5S$S$)zM Return the folder of the path that's given, an empty string for root paths. r@rArr)rsplit)r7s rrdrd[s%'+dl4;;tQ  ";;rcUS:XagX::agURS5nURS5n[S[X#555$)zReturns whether `maybe_ancestor` is an ancestor of `path`. >>> is_ancestor(b"a", b"") True >>> is_ancestor(b"a/b/c", b"a/b/c") False >>> is_ancestor(b"hgext3rd/__init__.py", b"hgext") False >>> is_ancestor(b"hgext3rd/__init__.py", b"hgext3rd") True rTFr@c3.# UH upX:Hv M g7fr9r:).0cos r is_ancestor..tsL"K$!qv"Ks)rYallzip)r7maybe_ancestorpath_componentsancestor_componentss rrgrgbsM jj&O(..t4 L#o"KL LLrcXR:wa[XR5(aU[UR5SRS5nUR SS5SnUR(aURS-U-nOUnUSnURU:XaUnO@U=R S- sl[ USU5nURU5 O URnXR:waMU$)z Move inside the dirstate node tree to the node corresponding to `target_folder`, creating the missing nodes along the way if needed. Nr@rArr^) r7rgr%lstriprYr/r<rbrU) target_folderrqrpprefixsubfolder_namesubfolder_path next_nodes rrerews ,, , }&7&7 8 8"3|'8'8#9#;<CCDIF#\\$215N  !-!2!2T!9N!J!/b I~~. ) ++q0+#ND,G  \*(..L) ,, ,* rcf/nUSRS:wa[USR5UR:XaZURUR55 USRS:wa([USR5UR:XaMZU(d#[R "SUR-5eUR 5 [5nUHnURU[U5S9nURU5 URUR5 URURURS55 U=RUR- sl U=RUR- sl M [U5UlURU5 g)zS Write the binary representation of the direct sorted children of `node` to `data` r^rsno direct children for %r)rrLN)r7rdrbrirProgrammingErrorreverser_rGr%extendrBrJrIrH)noderrrpdirect_childrenpacked_childrenchildpackeds rrhrhsC O )..C JuRy~~$>$))$Kuyy{+ )..C JuRy~~$>$))$K $$%ADII%MNNkO XCIFv& EJJ HLLS12   E$=$==  ##u'C'CC# !t9DKK r) __future__rstructtyping thirdpartyr TYPE_CHECKINGrr importmodrTREE_METADATA_SIZErStructr r r3rFrr rsr<rwrdrgrerhr:rrrs#     9 %    m, &}}%&]/////DII G(&R%- - - ``F<M*:!r